xref: /linux/sound/oss/dmasound/dmasound_core.c (revision e9fb13bfec7e017130ddc5c1b5466340470f4900)
1 /*
2  *  linux/sound/oss/dmasound/dmasound_core.c
3  *
4  *
5  *  OSS/Free compatible Atari TT/Falcon and Amiga DMA sound driver for
6  *  Linux/m68k
7  *  Extended to support Power Macintosh for Linux/ppc by Paul Mackerras
8  *
9  *  (c) 1995 by Michael Schlueter & Michael Marte
10  *
11  *  Michael Schlueter (michael@duck.syd.de) did the basic structure of the VFS
12  *  interface and the u-law to signed byte conversion.
13  *
14  *  Michael Marte (marte@informatik.uni-muenchen.de) did the sound queue,
15  *  /dev/mixer, /dev/sndstat and complemented the VFS interface. He would like
16  *  to thank:
17  *    - Michael Schlueter for initial ideas and documentation on the MFP and
18  *	the DMA sound hardware.
19  *    - Therapy? for their CD 'Troublegum' which really made me rock.
20  *
21  *  /dev/sndstat is based on code by Hannu Savolainen, the author of the
22  *  VoxWare family of drivers.
23  *
24  *  This file is subject to the terms and conditions of the GNU General Public
25  *  License.  See the file COPYING in the main directory of this archive
26  *  for more details.
27  *
28  *  History:
29  *
30  *	1995/8/25	First release
31  *
32  *	1995/9/02	Roman Hodek:
33  *			  - Fixed atari_stram_alloc() call, the timer
34  *			    programming and several race conditions
35  *	1995/9/14	Roman Hodek:
36  *			  - After some discussion with Michael Schlueter,
37  *			    revised the interrupt disabling
38  *			  - Slightly speeded up U8->S8 translation by using
39  *			    long operations where possible
40  *			  - Added 4:3 interpolation for /dev/audio
41  *
42  *	1995/9/20	Torsten Scherer:
43  *			  - Fixed a bug in sq_write and changed /dev/audio
44  *			    converting to play at 12517Hz instead of 6258Hz.
45  *
46  *	1995/9/23	Torsten Scherer:
47  *			  - Changed sq_interrupt() and sq_play() to pre-program
48  *			    the DMA for another frame while there's still one
49  *			    running. This allows the IRQ response to be
50  *			    arbitrarily delayed and playing will still continue.
51  *
52  *	1995/10/14	Guenther Kelleter, Torsten Scherer:
53  *			  - Better support for Falcon audio (the Falcon doesn't
54  *			    raise an IRQ at the end of a frame, but at the
55  *			    beginning instead!). uses 'if (codec_dma)' in lots
56  *			    of places to simply switch between Falcon and TT
57  *			    code.
58  *
59  *	1995/11/06	Torsten Scherer:
60  *			  - Started introducing a hardware abstraction scheme
61  *			    (may perhaps also serve for Amigas?)
62  *			  - Can now play samples at almost all frequencies by
63  *			    means of a more generalized expand routine
64  *			  - Takes a good deal of care to cut data only at
65  *			    sample sizes
66  *			  - Buffer size is now a kernel runtime option
67  *			  - Implemented fsync() & several minor improvements
68  *			Guenther Kelleter:
69  *			  - Useful hints and bug fixes
70  *			  - Cross-checked it for Falcons
71  *
72  *	1996/3/9	Geert Uytterhoeven:
73  *			  - Support added for Amiga, A-law, 16-bit little
74  *			    endian.
75  *			  - Unification to drivers/sound/dmasound.c.
76  *
77  *	1996/4/6	Martin Mitchell:
78  *			  - Updated to 1.3 kernel.
79  *
80  *	1996/6/13       Topi Kanerva:
81  *			  - Fixed things that were broken (mainly the amiga
82  *			    14-bit routines)
83  *			  - /dev/sndstat shows now the real hardware frequency
84  *			  - The lowpass filter is disabled by default now
85  *
86  *	1996/9/25	Geert Uytterhoeven:
87  *			  - Modularization
88  *
89  *	1998/6/10	Andreas Schwab:
90  *			  - Converted to use sound_core
91  *
92  *	1999/12/28	Richard Zidlicky:
93  *			  - Added support for Q40
94  *
95  *	2000/2/27	Geert Uytterhoeven:
96  *			  - Clean up and split the code into 4 parts:
97  *			      o dmasound_core: machine-independent code
98  *			      o dmasound_atari: Atari TT and Falcon support
99  *			      o dmasound_awacs: Apple PowerMac support
100  *			      o dmasound_paula: Amiga support
101  *
102  *	2000/3/25	Geert Uytterhoeven:
103  *			  - Integration of dmasound_q40
104  *			  - Small clean ups
105  *
106  *	2001/01/26 [1.0] Iain Sandoe
107  *			  - make /dev/sndstat show revision & edition info.
108  *			  - since dmasound.mach.sq_setup() can fail on pmac
109  *			    its type has been changed to int and the returns
110  *			    are checked.
111  *		   [1.1]  - stop missing translations from being called.
112  *	2001/02/08 [1.2]  - remove unused translation tables & move machine-
113  *			    specific tables to low-level.
114  *			  - return correct info. for SNDCTL_DSP_GETFMTS.
115  *		   [1.3]  - implement SNDCTL_DSP_GETCAPS fully.
116  *		   [1.4]  - make /dev/sndstat text length usage deterministic.
117  *			  - make /dev/sndstat call to low-level
118  *			    dmasound.mach.state_info() pass max space to ll driver.
119  *			  - tidy startup banners and output info.
120  *		   [1.5]  - tidy up a little (removed some unused #defines in
121  *			    dmasound.h)
122  *			  - fix up HAS_RECORD conditionalisation.
123  *			  - add record code in places it is missing...
124  *			  - change buf-sizes to bytes to allow < 1kb for pmac
125  *			    if user param entry is < 256 the value is taken to
126  *			    be in kb > 256 is taken to be in bytes.
127  *			  - make default buff/frag params conditional on
128  *			    machine to allow smaller values for pmac.
129  *			  - made the ioctls, read & write comply with the OSS
130  *			    rules on setting params.
131  *			  - added parsing of _setup() params for record.
132  *	2001/04/04 [1.6]  - fix bug where sample rates higher than maximum were
133  *			    being reported as OK.
134  *			  - fix open() to return -EBUSY as per OSS doc. when
135  *			    audio is in use - this is independent of O_NOBLOCK.
136  *			  - fix bug where SNDCTL_DSP_POST was blocking.
137  */
138 
139  /* Record capability notes 30/01/2001:
140   * At present these observations apply only to pmac LL driver (the only one
141   * that can do record, at present).  However, if other LL drivers for machines
142   * with record are added they may apply.
143   *
144   * The fragment parameters for the record and play channels are separate.
145   * However, if the driver is opened O_RDWR there is no way (in the current OSS
146   * API) to specify their values independently for the record and playback
147   * channels.  Since the only common factor between the input & output is the
148   * sample rate (on pmac) it should be possible to open /dev/dspX O_WRONLY and
149   * /dev/dspY O_RDONLY.  The input & output channels could then have different
150   * characteristics (other than the first that sets sample rate claiming the
151   * right to set it for ever).  As it stands, the format, channels, number of
152   * bits & sample rate are assumed to be common.  In the future perhaps these
153   * should be the responsibility of the LL driver - and then if a card really
154   * does not share items between record & playback they can be specified
155   * separately.
156 */
157 
158 /* Thread-safeness of shared_resources notes: 31/01/2001
159  * If the user opens O_RDWR and then splits record & play between two threads
160  * both of which inherit the fd - and then starts changing things from both
161  * - we will have difficulty telling.
162  *
163  * It's bad application coding - but ...
164  * TODO: think about how to sort this out... without bogging everything down in
165  * semaphores.
166  *
167  * Similarly, the OSS spec says "all changes to parameters must be between
168  * open() and the first read() or write(). - and a bit later on (by
169  * implication) "between SNDCTL_DSP_RESET and the first read() or write() after
170  * it".  If the app is multi-threaded and this rule is broken between threads
171  * we will have trouble spotting it - and the fault will be rather obscure :-(
172  *
173  * We will try and put out at least a kmsg if we see it happen... but I think
174  * it will be quite hard to trap it with an -EXXX return... because we can't
175  * see the fault until after the damage is done.
176 */
177 
178 #include <linux/module.h>
179 #include <linux/slab.h>
180 #include <linux/sound.h>
181 #include <linux/init.h>
182 #include <linux/soundcard.h>
183 #include <linux/poll.h>
184 #include <linux/mutex.h>
185 
186 #include <asm/uaccess.h>
187 
188 #include "dmasound.h"
189 
190 #define DMASOUND_CORE_REVISION 1
191 #define DMASOUND_CORE_EDITION 6
192 
193     /*
194      *  Declarations
195      */
196 
197 static DEFINE_MUTEX(dmasound_core_mutex);
198 int dmasound_catchRadius = 0;
199 module_param(dmasound_catchRadius, int, 0);
200 
201 static unsigned int numWriteBufs = DEFAULT_N_BUFFERS;
202 module_param(numWriteBufs, int, 0);
203 static unsigned int writeBufSize = DEFAULT_BUFF_SIZE ;	/* in bytes */
204 module_param(writeBufSize, int, 0);
205 
206 MODULE_LICENSE("GPL");
207 
208 #ifdef MODULE
209 static int sq_unit = -1;
210 static int mixer_unit = -1;
211 static int state_unit = -1;
212 static int irq_installed;
213 #endif /* MODULE */
214 
215 /* control over who can modify resources shared between play/record */
216 static fmode_t shared_resource_owner;
217 static int shared_resources_initialised;
218 
219     /*
220      *  Mid level stuff
221      */
222 
223 struct sound_settings dmasound = {
224 	.lock = __SPIN_LOCK_UNLOCKED(dmasound.lock)
225 };
226 
227 static inline void sound_silence(void)
228 {
229 	dmasound.mach.silence(); /* _MUST_ stop DMA */
230 }
231 
232 static inline int sound_set_format(int format)
233 {
234 	return dmasound.mach.setFormat(format);
235 }
236 
237 
238 static int sound_set_speed(int speed)
239 {
240 	if (speed < 0)
241 		return dmasound.soft.speed;
242 
243 	/* trap out-of-range speed settings.
244 	   at present we allow (arbitrarily) low rates - using soft
245 	   up-conversion - but we can't allow > max because there is
246 	   no soft down-conversion.
247 	*/
248 	if (dmasound.mach.max_dsp_speed &&
249 	   (speed > dmasound.mach.max_dsp_speed))
250 		speed = dmasound.mach.max_dsp_speed ;
251 
252 	dmasound.soft.speed = speed;
253 
254 	if (dmasound.minDev == SND_DEV_DSP)
255 		dmasound.dsp.speed = dmasound.soft.speed;
256 
257 	return dmasound.soft.speed;
258 }
259 
260 static int sound_set_stereo(int stereo)
261 {
262 	if (stereo < 0)
263 		return dmasound.soft.stereo;
264 
265 	stereo = !!stereo;    /* should be 0 or 1 now */
266 
267 	dmasound.soft.stereo = stereo;
268 	if (dmasound.minDev == SND_DEV_DSP)
269 		dmasound.dsp.stereo = stereo;
270 
271 	return stereo;
272 }
273 
274 static ssize_t sound_copy_translate(TRANS *trans, const u_char __user *userPtr,
275 				    size_t userCount, u_char frame[],
276 				    ssize_t *frameUsed, ssize_t frameLeft)
277 {
278 	ssize_t (*ct_func)(const u_char __user *, size_t, u_char *, ssize_t *, ssize_t);
279 
280 	switch (dmasound.soft.format) {
281 	    case AFMT_MU_LAW:
282 		ct_func = trans->ct_ulaw;
283 		break;
284 	    case AFMT_A_LAW:
285 		ct_func = trans->ct_alaw;
286 		break;
287 	    case AFMT_S8:
288 		ct_func = trans->ct_s8;
289 		break;
290 	    case AFMT_U8:
291 		ct_func = trans->ct_u8;
292 		break;
293 	    case AFMT_S16_BE:
294 		ct_func = trans->ct_s16be;
295 		break;
296 	    case AFMT_U16_BE:
297 		ct_func = trans->ct_u16be;
298 		break;
299 	    case AFMT_S16_LE:
300 		ct_func = trans->ct_s16le;
301 		break;
302 	    case AFMT_U16_LE:
303 		ct_func = trans->ct_u16le;
304 		break;
305 	    default:
306 		return 0;
307 	}
308 	/* if the user has requested a non-existent translation don't try
309 	   to call it but just return 0 bytes moved
310 	*/
311 	if (ct_func)
312 		return ct_func(userPtr, userCount, frame, frameUsed, frameLeft);
313 	return 0;
314 }
315 
316     /*
317      *  /dev/mixer abstraction
318      */
319 
320 static struct {
321     int busy;
322     int modify_counter;
323 } mixer;
324 
325 static int mixer_open(struct inode *inode, struct file *file)
326 {
327 	mutex_lock(&dmasound_core_mutex);
328 	if (!try_module_get(dmasound.mach.owner)) {
329 		mutex_unlock(&dmasound_core_mutex);
330 		return -ENODEV;
331 	}
332 	mixer.busy = 1;
333 	mutex_unlock(&dmasound_core_mutex);
334 	return 0;
335 }
336 
337 static int mixer_release(struct inode *inode, struct file *file)
338 {
339 	mutex_lock(&dmasound_core_mutex);
340 	mixer.busy = 0;
341 	module_put(dmasound.mach.owner);
342 	mutex_unlock(&dmasound_core_mutex);
343 	return 0;
344 }
345 
346 static int mixer_ioctl(struct file *file, u_int cmd, u_long arg)
347 {
348 	if (_SIOC_DIR(cmd) & _SIOC_WRITE)
349 	    mixer.modify_counter++;
350 	switch (cmd) {
351 	    case OSS_GETVERSION:
352 		return IOCTL_OUT(arg, SOUND_VERSION);
353 	    case SOUND_MIXER_INFO:
354 		{
355 		    mixer_info info;
356 		    memset(&info, 0, sizeof(info));
357 		    strlcpy(info.id, dmasound.mach.name2, sizeof(info.id));
358 		    strlcpy(info.name, dmasound.mach.name2, sizeof(info.name));
359 		    info.modify_counter = mixer.modify_counter;
360 		    if (copy_to_user((void __user *)arg, &info, sizeof(info)))
361 			    return -EFAULT;
362 		    return 0;
363 		}
364 	}
365 	if (dmasound.mach.mixer_ioctl)
366 	    return dmasound.mach.mixer_ioctl(cmd, arg);
367 	return -EINVAL;
368 }
369 
370 static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
371 {
372 	int ret;
373 
374 	mutex_lock(&dmasound_core_mutex);
375 	ret = mixer_ioctl(file, cmd, arg);
376 	mutex_unlock(&dmasound_core_mutex);
377 
378 	return ret;
379 }
380 
381 static const struct file_operations mixer_fops =
382 {
383 	.owner		= THIS_MODULE,
384 	.llseek		= no_llseek,
385 	.unlocked_ioctl	= mixer_unlocked_ioctl,
386 	.open		= mixer_open,
387 	.release	= mixer_release,
388 };
389 
390 static void mixer_init(void)
391 {
392 #ifndef MODULE
393 	int mixer_unit;
394 #endif
395 	mixer_unit = register_sound_mixer(&mixer_fops, -1);
396 	if (mixer_unit < 0)
397 		return;
398 
399 	mixer.busy = 0;
400 	dmasound.treble = 0;
401 	dmasound.bass = 0;
402 	if (dmasound.mach.mixer_init)
403 	    dmasound.mach.mixer_init();
404 }
405 
406 
407     /*
408      *  Sound queue stuff, the heart of the driver
409      */
410 
411 struct sound_queue dmasound_write_sq;
412 static void sq_reset_output(void) ;
413 
414 static int sq_allocate_buffers(struct sound_queue *sq, int num, int size)
415 {
416 	int i;
417 
418 	if (sq->buffers)
419 		return 0;
420 	sq->numBufs = num;
421 	sq->bufSize = size;
422 	sq->buffers = kmalloc (num * sizeof(char *), GFP_KERNEL);
423 	if (!sq->buffers)
424 		return -ENOMEM;
425 	for (i = 0; i < num; i++) {
426 		sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL);
427 		if (!sq->buffers[i]) {
428 			while (i--)
429 				dmasound.mach.dma_free(sq->buffers[i], size);
430 			kfree(sq->buffers);
431 			sq->buffers = NULL;
432 			return -ENOMEM;
433 		}
434 	}
435 	return 0;
436 }
437 
438 static void sq_release_buffers(struct sound_queue *sq)
439 {
440 	int i;
441 
442 	if (sq->buffers) {
443 		for (i = 0; i < sq->numBufs; i++)
444 			dmasound.mach.dma_free(sq->buffers[i], sq->bufSize);
445 		kfree(sq->buffers);
446 		sq->buffers = NULL;
447 	}
448 }
449 
450 
451 static int sq_setup(struct sound_queue *sq)
452 {
453 	int (*setup_func)(void) = NULL;
454 	int hard_frame ;
455 
456 	if (sq->locked) { /* are we already set? - and not changeable */
457 #ifdef DEBUG_DMASOUND
458 printk("dmasound_core: tried to sq_setup a locked queue\n") ;
459 #endif
460 		return -EINVAL ;
461 	}
462 	sq->locked = 1 ; /* don't think we have a race prob. here _check_ */
463 
464 	/* make sure that the parameters are set up
465 	   This should have been done already...
466 	*/
467 
468 	dmasound.mach.init();
469 
470 	/* OK.  If the user has set fragment parameters explicitly, then we
471 	   should leave them alone... as long as they are valid.
472 	   Invalid user fragment params can occur if we allow the whole buffer
473 	   to be used when the user requests the fragments sizes (with no soft
474 	   x-lation) and then the user subsequently sets a soft x-lation that
475 	   requires increased internal buffering.
476 
477 	   Othwerwise (if the user did not set them) OSS says that we should
478 	   select frag params on the basis of 0.5 s output & 0.1 s input
479 	   latency. (TODO.  For now we will copy in the defaults.)
480 	*/
481 
482 	if (sq->user_frags <= 0) {
483 		sq->max_count = sq->numBufs ;
484 		sq->max_active = sq->numBufs ;
485 		sq->block_size = sq->bufSize;
486 		/* set up the user info */
487 		sq->user_frags = sq->numBufs ;
488 		sq->user_frag_size = sq->bufSize ;
489 		sq->user_frag_size *=
490 			(dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
491 		sq->user_frag_size /=
492 			(dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
493 	} else {
494 		/* work out requested block size */
495 		sq->block_size = sq->user_frag_size ;
496 		sq->block_size *=
497 			(dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
498 		sq->block_size /=
499 			(dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
500 		/* the user wants to write frag-size chunks */
501 		sq->block_size *= dmasound.hard.speed ;
502 		sq->block_size /= dmasound.soft.speed ;
503 		/* this only works for size values which are powers of 2 */
504 		hard_frame =
505 			(dmasound.hard.size * (dmasound.hard.stereo+1))/8 ;
506 		sq->block_size +=  (hard_frame - 1) ;
507 		sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */
508 		/* let's just check for obvious mistakes */
509 		if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) {
510 #ifdef DEBUG_DMASOUND
511 printk("dmasound_core: invalid frag size (user set %d)\n", sq->user_frag_size) ;
512 #endif
513 			sq->block_size = sq->bufSize ;
514 		}
515 		if ( sq->user_frags <= sq->numBufs ) {
516 			sq->max_count = sq->user_frags ;
517 			/* if user has set max_active - then use it */
518 			sq->max_active = (sq->max_active <= sq->max_count) ?
519 				sq->max_active : sq->max_count ;
520 		} else {
521 #ifdef DEBUG_DMASOUND
522 printk("dmasound_core: invalid frag count (user set %d)\n", sq->user_frags) ;
523 #endif
524 			sq->max_count =
525 			sq->max_active = sq->numBufs ;
526 		}
527 	}
528 	sq->front = sq->count = sq->rear_size = 0;
529 	sq->syncing = 0;
530 	sq->active = 0;
531 
532 	if (sq == &write_sq) {
533 	    sq->rear = -1;
534 	    setup_func = dmasound.mach.write_sq_setup;
535 	}
536 	if (setup_func)
537 	    return setup_func();
538 	return 0 ;
539 }
540 
541 static inline void sq_play(void)
542 {
543 	dmasound.mach.play();
544 }
545 
546 static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft,
547 			loff_t *ppos)
548 {
549 	ssize_t uWritten = 0;
550 	u_char *dest;
551 	ssize_t uUsed = 0, bUsed, bLeft;
552 	unsigned long flags ;
553 
554 	/* ++TeSche: Is something like this necessary?
555 	 * Hey, that's an honest question! Or does any other part of the
556 	 * filesystem already checks this situation? I really don't know.
557 	 */
558 	if (uLeft == 0)
559 		return 0;
560 
561 	/* implement any changes we have made to the soft/hard params.
562 	   this is not satisfactory really, all we have done up to now is to
563 	   say what we would like - there hasn't been any real checking of capability
564 	*/
565 
566 	if (shared_resources_initialised == 0) {
567 		dmasound.mach.init() ;
568 		shared_resources_initialised = 1 ;
569 	}
570 
571 	/* set up the sq if it is not already done. This may seem a dumb place
572 	   to do it - but it is what OSS requires.  It means that write() can
573 	   return memory allocation errors.  To avoid this possibility use the
574 	   GETBLKSIZE or GETOSPACE ioctls (after you've fiddled with all the
575 	   params you want to change) - these ioctls also force the setup.
576 	*/
577 
578 	if (write_sq.locked == 0) {
579 		if ((uWritten = sq_setup(&write_sq)) < 0) return uWritten ;
580 		uWritten = 0 ;
581 	}
582 
583 /* FIXME: I think that this may be the wrong behaviour when we get strapped
584 	for time and the cpu is close to being (or actually) behind in sending data.
585 	- because we've lost the time that the N samples, already in the buffer,
586 	would have given us to get here with the next lot from the user.
587 */
588 	/* The interrupt doesn't start to play the last, incomplete frame.
589 	 * Thus we can append to it without disabling the interrupts! (Note
590 	 * also that write_sq.rear isn't affected by the interrupt.)
591 	 */
592 
593 	/* as of 1.6 this behaviour changes if SNDCTL_DSP_POST has been issued:
594 	   this will mimic the behaviour of syncing and allow the sq_play() to
595 	   queue a partial fragment.  Since sq_play() may/will be called from
596 	   the IRQ handler - at least on Pmac we have to deal with it.
597 	   The strategy - possibly not optimum - is to kill _POST status if we
598 	   get here.  This seems, at least, reasonable - in the sense that POST
599 	   is supposed to indicate that we might not write before the queue
600 	   is drained - and if we get here in time then it does not apply.
601 	*/
602 
603 	spin_lock_irqsave(&dmasound.lock, flags);
604 	write_sq.syncing &= ~2 ; /* take out POST status */
605 	spin_unlock_irqrestore(&dmasound.lock, flags);
606 
607 	if (write_sq.count > 0 &&
608 	    (bLeft = write_sq.block_size-write_sq.rear_size) > 0) {
609 		dest = write_sq.buffers[write_sq.rear];
610 		bUsed = write_sq.rear_size;
611 		uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
612 					     dest, &bUsed, bLeft);
613 		if (uUsed <= 0)
614 			return uUsed;
615 		src += uUsed;
616 		uWritten += uUsed;
617 		uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
618 		write_sq.rear_size = bUsed;
619 	}
620 
621 	while (uLeft) {
622 		while (write_sq.count >= write_sq.max_active) {
623 			sq_play();
624 			if (write_sq.non_blocking)
625 				return uWritten > 0 ? uWritten : -EAGAIN;
626 			SLEEP(write_sq.action_queue);
627 			if (signal_pending(current))
628 				return uWritten > 0 ? uWritten : -EINTR;
629 		}
630 
631 		/* Here, we can avoid disabling the interrupt by first
632 		 * copying and translating the data, and then updating
633 		 * the write_sq variables. Until this is done, the interrupt
634 		 * won't see the new frame and we can work on it
635 		 * undisturbed.
636 		 */
637 
638 		dest = write_sq.buffers[(write_sq.rear+1) % write_sq.max_count];
639 		bUsed = 0;
640 		bLeft = write_sq.block_size;
641 		uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
642 					     dest, &bUsed, bLeft);
643 		if (uUsed <= 0)
644 			break;
645 		src += uUsed;
646 		uWritten += uUsed;
647 		uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
648 		if (bUsed) {
649 			write_sq.rear = (write_sq.rear+1) % write_sq.max_count;
650 			write_sq.rear_size = bUsed;
651 			write_sq.count++;
652 		}
653 	} /* uUsed may have been 0 */
654 
655 	sq_play();
656 
657 	return uUsed < 0? uUsed: uWritten;
658 }
659 
660 static unsigned int sq_poll(struct file *file, struct poll_table_struct *wait)
661 {
662 	unsigned int mask = 0;
663 	int retVal;
664 
665 	if (write_sq.locked == 0) {
666 		if ((retVal = sq_setup(&write_sq)) < 0)
667 			return retVal;
668 		return 0;
669 	}
670 	if (file->f_mode & FMODE_WRITE )
671 		poll_wait(file, &write_sq.action_queue, wait);
672 	if (file->f_mode & FMODE_WRITE)
673 		if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0)
674 			mask |= POLLOUT | POLLWRNORM;
675 	return mask;
676 
677 }
678 
679 static inline void sq_init_waitqueue(struct sound_queue *sq)
680 {
681 	init_waitqueue_head(&sq->action_queue);
682 	init_waitqueue_head(&sq->open_queue);
683 	init_waitqueue_head(&sq->sync_queue);
684 	sq->busy = 0;
685 }
686 
687 #if 0 /* blocking open() */
688 static inline void sq_wake_up(struct sound_queue *sq, struct file *file,
689 			      fmode_t mode)
690 {
691 	if (file->f_mode & mode) {
692 		sq->busy = 0; /* CHECK: IS THIS OK??? */
693 		WAKE_UP(sq->open_queue);
694 	}
695 }
696 #endif
697 
698 static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode,
699 		    int numbufs, int bufsize)
700 {
701 	int rc = 0;
702 
703 	if (file->f_mode & mode) {
704 		if (sq->busy) {
705 #if 0 /* blocking open() */
706 			rc = -EBUSY;
707 			if (file->f_flags & O_NONBLOCK)
708 				return rc;
709 			rc = -EINTR;
710 			while (sq->busy) {
711 				SLEEP(sq->open_queue);
712 				if (signal_pending(current))
713 					return rc;
714 			}
715 			rc = 0;
716 #else
717 			/* OSS manual says we will return EBUSY regardless
718 			   of O_NOBLOCK.
719 			*/
720 			return -EBUSY ;
721 #endif
722 		}
723 		sq->busy = 1; /* Let's play spot-the-race-condition */
724 
725 		/* allocate the default number & size of buffers.
726 		   (i.e. specified in _setup() or as module params)
727 		   can't be changed at the moment - but _could_ be perhaps
728 		   in the setfragments ioctl.
729 		*/
730 		if (( rc = sq_allocate_buffers(sq, numbufs, bufsize))) {
731 #if 0 /* blocking open() */
732 			sq_wake_up(sq, file, mode);
733 #else
734 			sq->busy = 0 ;
735 #endif
736 			return rc;
737 		}
738 
739 		sq->non_blocking = file->f_flags & O_NONBLOCK;
740 	}
741 	return rc;
742 }
743 
744 #define write_sq_init_waitqueue()	sq_init_waitqueue(&write_sq)
745 #if 0 /* blocking open() */
746 #define write_sq_wake_up(file)		sq_wake_up(&write_sq, file, FMODE_WRITE)
747 #endif
748 #define write_sq_release_buffers()	sq_release_buffers(&write_sq)
749 #define write_sq_open(file)	\
750 	sq_open2(&write_sq, file, FMODE_WRITE, numWriteBufs, writeBufSize )
751 
752 static int sq_open(struct inode *inode, struct file *file)
753 {
754 	int rc;
755 
756 	mutex_lock(&dmasound_core_mutex);
757 	if (!try_module_get(dmasound.mach.owner)) {
758 		mutex_unlock(&dmasound_core_mutex);
759 		return -ENODEV;
760 	}
761 
762 	rc = write_sq_open(file); /* checks the f_mode */
763 	if (rc)
764 		goto out;
765 	if (file->f_mode & FMODE_READ) {
766 		/* TODO: if O_RDWR, release any resources grabbed by write part */
767 		rc = -ENXIO ; /* I think this is what is required by open(2) */
768 		goto out;
769 	}
770 
771 	if (dmasound.mach.sq_open)
772 	    dmasound.mach.sq_open(file->f_mode);
773 
774 	/* CHECK whether this is sensible - in the case that dsp0 could be opened
775 	  O_RDONLY and dsp1 could be opened O_WRONLY
776 	*/
777 
778 	dmasound.minDev = iminor(inode) & 0x0f;
779 
780 	/* OK. - we should make some attempt at consistency. At least the H'ware
781 	   options should be set with a valid mode.  We will make it that the LL
782 	   driver must supply defaults for hard & soft params.
783 	*/
784 
785 	if (shared_resource_owner == 0) {
786 		/* you can make this AFMT_U8/mono/8K if you want to mimic old
787 		   OSS behaviour - while we still have soft translations ;-) */
788 		dmasound.soft = dmasound.mach.default_soft ;
789 		dmasound.dsp = dmasound.mach.default_soft ;
790 		dmasound.hard = dmasound.mach.default_hard ;
791 	}
792 
793 #ifndef DMASOUND_STRICT_OSS_COMPLIANCE
794 	/* none of the current LL drivers can actually do this "native" at the moment
795 	   OSS does not really require us to supply /dev/audio if we can't do it.
796 	*/
797 	if (dmasound.minDev == SND_DEV_AUDIO) {
798 		sound_set_speed(8000);
799 		sound_set_stereo(0);
800 		sound_set_format(AFMT_MU_LAW);
801 	}
802 #endif
803 	mutex_unlock(&dmasound_core_mutex);
804 	return 0;
805  out:
806 	module_put(dmasound.mach.owner);
807 	mutex_unlock(&dmasound_core_mutex);
808 	return rc;
809 }
810 
811 static void sq_reset_output(void)
812 {
813 	sound_silence(); /* this _must_ stop DMA, we might be about to lose the buffers */
814 	write_sq.active = 0;
815 	write_sq.count = 0;
816 	write_sq.rear_size = 0;
817 	/* write_sq.front = (write_sq.rear+1) % write_sq.max_count;*/
818 	write_sq.front = 0 ;
819 	write_sq.rear = -1 ; /* same as for set-up */
820 
821 	/* OK - we can unlock the parameters and fragment settings */
822 	write_sq.locked = 0 ;
823 	write_sq.user_frags = 0 ;
824 	write_sq.user_frag_size = 0 ;
825 }
826 
827 static void sq_reset(void)
828 {
829 	sq_reset_output() ;
830 	/* we could consider resetting the shared_resources_owner here... but I
831 	   think it is probably still rather non-obvious to application writer
832 	*/
833 
834 	/* we release everything else though */
835 	shared_resources_initialised = 0 ;
836 }
837 
838 static int sq_fsync(struct file *filp, struct dentry *dentry)
839 {
840 	int rc = 0;
841 	int timeout = 5;
842 
843 	write_sq.syncing |= 1;
844 	sq_play();	/* there may be an incomplete frame waiting */
845 
846 	while (write_sq.active) {
847 		SLEEP(write_sq.sync_queue);
848 		if (signal_pending(current)) {
849 			/* While waiting for audio output to drain, an
850 			 * interrupt occurred.  Stop audio output immediately
851 			 * and clear the queue. */
852 			sq_reset_output();
853 			rc = -EINTR;
854 			break;
855 		}
856 		if (!--timeout) {
857 			printk(KERN_WARNING "dmasound: Timeout draining output\n");
858 			sq_reset_output();
859 			rc = -EIO;
860 			break;
861 		}
862 	}
863 
864 	/* flag no sync regardless of whether we had a DSP_POST or not */
865 	write_sq.syncing = 0 ;
866 	return rc;
867 }
868 
869 static int sq_release(struct inode *inode, struct file *file)
870 {
871 	int rc = 0;
872 
873 	mutex_lock(&dmasound_core_mutex);
874 
875 	if (file->f_mode & FMODE_WRITE) {
876 		if (write_sq.busy)
877 			rc = sq_fsync(file, file->f_path.dentry);
878 
879 		sq_reset_output() ; /* make sure dma is stopped and all is quiet */
880 		write_sq_release_buffers();
881 		write_sq.busy = 0;
882 	}
883 
884 	if (file->f_mode & shared_resource_owner) { /* it's us that has them */
885 		shared_resource_owner = 0 ;
886 		shared_resources_initialised = 0 ;
887 		dmasound.hard = dmasound.mach.default_hard ;
888 	}
889 
890 	module_put(dmasound.mach.owner);
891 
892 #if 0 /* blocking open() */
893 	/* Wake up a process waiting for the queue being released.
894 	 * Note: There may be several processes waiting for a call
895 	 * to open() returning. */
896 
897 	/* Iain: hmm I don't understand this next comment ... */
898 	/* There is probably a DOS atack here. They change the mode flag. */
899 	/* XXX add check here,*/
900 	read_sq_wake_up(file); /* checks f_mode */
901 	write_sq_wake_up(file); /* checks f_mode */
902 #endif /* blocking open() */
903 
904 	mutex_unlock(&dmasound_core_mutex);
905 
906 	return rc;
907 }
908 
909 /* here we see if we have a right to modify format, channels, size and so on
910    if no-one else has claimed it already then we do...
911 
912    TODO: We might change this to mask O_RDWR such that only one or the other channel
913    is the owner - if we have problems.
914 */
915 
916 static int shared_resources_are_mine(fmode_t md)
917 {
918 	if (shared_resource_owner)
919 		return (shared_resource_owner & md) != 0;
920 	else {
921 		shared_resource_owner = md ;
922 		return 1 ;
923 	}
924 }
925 
926 /* if either queue is locked we must deny the right to change shared params
927 */
928 
929 static int queues_are_quiescent(void)
930 {
931 	if (write_sq.locked)
932 		return 0 ;
933 	return 1 ;
934 }
935 
936 /* check and set a queue's fragments per user's wishes...
937    we will check against the pre-defined literals and the actual sizes.
938    This is a bit fraught - because soft translations can mess with our
939    buffer requirements *after* this call - OSS says "call setfrags first"
940 */
941 
942 /* It is possible to replace all the -EINVAL returns with an override that
943    just puts the allowable value in.  This may be what many OSS apps require
944 */
945 
946 static int set_queue_frags(struct sound_queue *sq, int bufs, int size)
947 {
948 	if (sq->locked) {
949 #ifdef DEBUG_DMASOUND
950 printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
951 #endif
952 		return -EINVAL ;
953 	}
954 
955 	if ((size < MIN_FRAG_SIZE) || (size > MAX_FRAG_SIZE))
956 		return -EINVAL ;
957 	size = (1<<size) ; /* now in bytes */
958 	if (size > sq->bufSize)
959 		return -EINVAL ; /* this might still not work */
960 
961 	if (bufs <= 0)
962 		return -EINVAL ;
963 	if (bufs > sq->numBufs) /* the user is allowed say "don't care" with 0x7fff */
964 		bufs = sq->numBufs ;
965 
966 	/* there is, currently, no way to specify max_active separately
967 	   from max_count.  This could be a LL driver issue - I guess
968 	   if there is a requirement for these values to be different then
969 	  we will have to pass that info. up to this level.
970 	*/
971 	sq->user_frags =
972 	sq->max_active = bufs ;
973 	sq->user_frag_size = size ;
974 
975 	return 0 ;
976 }
977 
978 static int sq_ioctl(struct file *file, u_int cmd, u_long arg)
979 {
980 	int val, result;
981 	u_long fmt;
982 	int data;
983 	int size, nbufs;
984 	audio_buf_info info;
985 
986 	switch (cmd) {
987 	case SNDCTL_DSP_RESET:
988 		sq_reset();
989 		return 0;
990 		break ;
991 	case SNDCTL_DSP_GETFMTS:
992 		fmt = dmasound.mach.hardware_afmts ; /* this is what OSS says.. */
993 		return IOCTL_OUT(arg, fmt);
994 		break ;
995 	case SNDCTL_DSP_GETBLKSIZE:
996 		/* this should tell the caller about bytes that the app can
997 		   read/write - the app doesn't care about our internal buffers.
998 		   We force sq_setup() here as per OSS 1.1 (which should
999 		   compute the values necessary).
1000 		   Since there is no mechanism to specify read/write separately, for
1001 		   fds opened O_RDWR, the write_sq values will, arbitrarily, overwrite
1002 		   the read_sq ones.
1003 		*/
1004 		size = 0 ;
1005 		if (file->f_mode & FMODE_WRITE) {
1006 			if ( !write_sq.locked )
1007 				sq_setup(&write_sq) ;
1008 			size = write_sq.user_frag_size ;
1009 		}
1010 		return IOCTL_OUT(arg, size);
1011 		break ;
1012 	case SNDCTL_DSP_POST:
1013 		/* all we are going to do is to tell the LL that any
1014 		   partial frags can be queued for output.
1015 		   The LL will have to clear this flag when last output
1016 		   is queued.
1017 		*/
1018 		write_sq.syncing |= 0x2 ;
1019 		sq_play() ;
1020 		return 0 ;
1021 	case SNDCTL_DSP_SYNC:
1022 		/* This call, effectively, has the same behaviour as SNDCTL_DSP_RESET
1023 		   except that it waits for output to finish before resetting
1024 		   everything - read, however, is killed immediately.
1025 		*/
1026 		result = 0 ;
1027 		if (file->f_mode & FMODE_WRITE) {
1028 			result = sq_fsync(file, file->f_path.dentry);
1029 			sq_reset_output() ;
1030 		}
1031 		/* if we are the shared resource owner then release them */
1032 		if (file->f_mode & shared_resource_owner)
1033 			shared_resources_initialised = 0 ;
1034 		return result ;
1035 		break ;
1036 	case SOUND_PCM_READ_RATE:
1037 		return IOCTL_OUT(arg, dmasound.soft.speed);
1038 	case SNDCTL_DSP_SPEED:
1039 		/* changing this on the fly will have weird effects on the sound.
1040 		   Where there are rate conversions implemented in soft form - it
1041 		   will cause the _ctx_xxx() functions to be substituted.
1042 		   However, there doesn't appear to be any reason to dis-allow it from
1043 		   a driver pov.
1044 		*/
1045 		if (shared_resources_are_mine(file->f_mode)) {
1046 			IOCTL_IN(arg, data);
1047 			data = sound_set_speed(data) ;
1048 			shared_resources_initialised = 0 ;
1049 			return IOCTL_OUT(arg, data);
1050 		} else
1051 			return -EINVAL ;
1052 		break ;
1053 	/* OSS says these next 4 actions are undefined when the device is
1054 	   busy/active - we will just return -EINVAL.
1055 	   To be allowed to change one - (a) you have to own the right
1056 	    (b) the queue(s) must be quiescent
1057 	*/
1058 	case SNDCTL_DSP_STEREO:
1059 		if (shared_resources_are_mine(file->f_mode) &&
1060 		    queues_are_quiescent()) {
1061 			IOCTL_IN(arg, data);
1062 			shared_resources_initialised = 0 ;
1063 			return IOCTL_OUT(arg, sound_set_stereo(data));
1064 		} else
1065 			return -EINVAL ;
1066 		break ;
1067 	case SOUND_PCM_WRITE_CHANNELS:
1068 		if (shared_resources_are_mine(file->f_mode) &&
1069 		    queues_are_quiescent()) {
1070 			IOCTL_IN(arg, data);
1071 			/* the user might ask for 20 channels, we will return 1 or 2 */
1072 			shared_resources_initialised = 0 ;
1073 			return IOCTL_OUT(arg, sound_set_stereo(data-1)+1);
1074 		} else
1075 			return -EINVAL ;
1076 		break ;
1077 	case SNDCTL_DSP_SETFMT:
1078 		if (shared_resources_are_mine(file->f_mode) &&
1079 		    queues_are_quiescent()) {
1080 		    	int format;
1081 			IOCTL_IN(arg, data);
1082 			shared_resources_initialised = 0 ;
1083 			format = sound_set_format(data);
1084 			result = IOCTL_OUT(arg, format);
1085 			if (result < 0)
1086 				return result;
1087 			if (format != data && data != AFMT_QUERY)
1088 				return -EINVAL;
1089 			return 0;
1090 		} else
1091 			return -EINVAL ;
1092 	case SNDCTL_DSP_SUBDIVIDE:
1093 		return -EINVAL ;
1094 	case SNDCTL_DSP_SETFRAGMENT:
1095 		/* we can do this independently for the two queues - with the
1096 		   proviso that for fds opened O_RDWR we cannot separate the
1097 		   actions and both queues will be set per the last call.
1098 		   NOTE: this does *NOT* actually set the queue up - merely
1099 		   registers our intentions.
1100 		*/
1101 		IOCTL_IN(arg, data);
1102 		result = 0 ;
1103 		nbufs = (data >> 16) & 0x7fff ; /* 0x7fff is 'use maximum' */
1104 		size = data & 0xffff;
1105 		if (file->f_mode & FMODE_WRITE) {
1106 			result = set_queue_frags(&write_sq, nbufs, size) ;
1107 			if (result)
1108 				return result ;
1109 		}
1110 		/* NOTE: this return value is irrelevant - OSS specifically says that
1111 		   the value is 'random' and that the user _must_ check the actual
1112 		   frags values using SNDCTL_DSP_GETBLKSIZE or similar */
1113 		return IOCTL_OUT(arg, data);
1114 		break ;
1115 	case SNDCTL_DSP_GETOSPACE:
1116 		/*
1117 		*/
1118 		if (file->f_mode & FMODE_WRITE) {
1119 			if ( !write_sq.locked )
1120 				sq_setup(&write_sq) ;
1121 			info.fragments = write_sq.max_active - write_sq.count;
1122 			info.fragstotal = write_sq.max_active;
1123 			info.fragsize = write_sq.user_frag_size;
1124 			info.bytes = info.fragments * info.fragsize;
1125 			if (copy_to_user((void __user *)arg, &info, sizeof(info)))
1126 				return -EFAULT;
1127 			return 0;
1128 		} else
1129 			return -EINVAL ;
1130 		break ;
1131 	case SNDCTL_DSP_GETCAPS:
1132 		val = dmasound.mach.capabilities & 0xffffff00;
1133 		return IOCTL_OUT(arg,val);
1134 
1135 	default:
1136 		return mixer_ioctl(file, cmd, arg);
1137 	}
1138 	return -EINVAL;
1139 }
1140 
1141 static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
1142 {
1143 	int ret;
1144 
1145 	mutex_lock(&dmasound_core_mutex);
1146 	ret = sq_ioctl(file, cmd, arg);
1147 	mutex_unlock(&dmasound_core_mutex);
1148 
1149 	return ret;
1150 }
1151 
1152 static const struct file_operations sq_fops =
1153 {
1154 	.owner		= THIS_MODULE,
1155 	.llseek		= no_llseek,
1156 	.write		= sq_write,
1157 	.poll		= sq_poll,
1158 	.unlocked_ioctl	= sq_unlocked_ioctl,
1159 	.open		= sq_open,
1160 	.release	= sq_release,
1161 };
1162 
1163 static int sq_init(void)
1164 {
1165 	const struct file_operations *fops = &sq_fops;
1166 #ifndef MODULE
1167 	int sq_unit;
1168 #endif
1169 
1170 	sq_unit = register_sound_dsp(fops, -1);
1171 	if (sq_unit < 0) {
1172 		printk(KERN_ERR "dmasound_core: couldn't register fops\n") ;
1173 		return sq_unit ;
1174 	}
1175 
1176 	write_sq_init_waitqueue();
1177 
1178 	/* These parameters will be restored for every clean open()
1179 	 * in the case of multiple open()s (e.g. dsp0 & dsp1) they
1180 	 * will be set so long as the shared resources have no owner.
1181 	 */
1182 
1183 	if (shared_resource_owner == 0) {
1184 		dmasound.soft = dmasound.mach.default_soft ;
1185 		dmasound.hard = dmasound.mach.default_hard ;
1186 		dmasound.dsp = dmasound.mach.default_soft ;
1187 		shared_resources_initialised = 0 ;
1188 	}
1189 	return 0 ;
1190 }
1191 
1192 
1193     /*
1194      *  /dev/sndstat
1195      */
1196 
1197 /* we allow more space for record-enabled because there are extra output lines.
1198    the number here must include the amount we are prepared to give to the low-level
1199    driver.
1200 */
1201 
1202 #define STAT_BUFF_LEN 768
1203 
1204 /* this is how much space we will allow the low-level driver to use
1205    in the stat buffer.  Currently, 2 * (80 character line + <NL>).
1206    We do not police this (it is up to the ll driver to be honest).
1207 */
1208 
1209 #define LOW_LEVEL_STAT_ALLOC 162
1210 
1211 static struct {
1212     int busy;
1213     char buf[STAT_BUFF_LEN];	/* state.buf should not overflow! */
1214     int len, ptr;
1215 } state;
1216 
1217 /* publish this function for use by low-level code, if required */
1218 
1219 static char *get_afmt_string(int afmt)
1220 {
1221         switch(afmt) {
1222             case AFMT_MU_LAW:
1223                 return "mu-law";
1224                 break;
1225             case AFMT_A_LAW:
1226                 return "A-law";
1227                 break;
1228             case AFMT_U8:
1229                 return "unsigned 8 bit";
1230                 break;
1231             case AFMT_S8:
1232                 return "signed 8 bit";
1233                 break;
1234             case AFMT_S16_BE:
1235                 return "signed 16 bit BE";
1236                 break;
1237             case AFMT_U16_BE:
1238                 return "unsigned 16 bit BE";
1239                 break;
1240             case AFMT_S16_LE:
1241                 return "signed 16 bit LE";
1242                 break;
1243             case AFMT_U16_LE:
1244                 return "unsigned 16 bit LE";
1245                 break;
1246 	    case 0:
1247 		return "format not set" ;
1248 		break ;
1249             default:
1250                 break ;
1251         }
1252         return "ERROR: Unsupported AFMT_XXXX code" ;
1253 }
1254 
1255 static int state_open(struct inode *inode, struct file *file)
1256 {
1257 	char *buffer = state.buf;
1258 	int len = 0;
1259 	int ret;
1260 
1261 	mutex_lock(&dmasound_core_mutex);
1262 	ret = -EBUSY;
1263 	if (state.busy)
1264 		goto out;
1265 
1266 	ret = -ENODEV;
1267 	if (!try_module_get(dmasound.mach.owner))
1268 		goto out;
1269 
1270 	state.ptr = 0;
1271 	state.busy = 1;
1272 
1273 	len += sprintf(buffer+len, "%sDMA sound driver rev %03d :\n",
1274 		dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1275 		((dmasound.mach.version>>8) & 0x0f));
1276 	len += sprintf(buffer+len,
1277 		"Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1278 		DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1279 		(dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1280 
1281 	/* call the low-level module to fill in any stat info. that it has
1282 	   if present.  Maximum buffer usage is specified.
1283 	*/
1284 
1285 	if (dmasound.mach.state_info)
1286 		len += dmasound.mach.state_info(buffer+len,
1287 			(size_t) LOW_LEVEL_STAT_ALLOC) ;
1288 
1289 	/* make usage of the state buffer as deterministic as poss.
1290 	   exceptional conditions could cause overrun - and this is flagged as
1291 	   a kernel error.
1292 	*/
1293 
1294 	/* formats and settings */
1295 
1296 	len += sprintf(buffer+len,"\t\t === Formats & settings ===\n") ;
1297 	len += sprintf(buffer+len,"Parameter %20s%20s\n","soft","hard") ;
1298 	len += sprintf(buffer+len,"Format   :%20s%20s\n",
1299 		get_afmt_string(dmasound.soft.format),
1300 		get_afmt_string(dmasound.hard.format));
1301 
1302 	len += sprintf(buffer+len,"Samp Rate:%14d s/sec%14d s/sec\n",
1303 		       dmasound.soft.speed, dmasound.hard.speed);
1304 
1305 	len += sprintf(buffer+len,"Channels :%20s%20s\n",
1306 		       dmasound.soft.stereo ? "stereo" : "mono",
1307 		       dmasound.hard.stereo ? "stereo" : "mono" );
1308 
1309 	/* sound queue status */
1310 
1311 	len += sprintf(buffer+len,"\t\t === Sound Queue status ===\n");
1312 	len += sprintf(buffer+len,"Allocated:%8s%6s\n","Buffers","Size") ;
1313 	len += sprintf(buffer+len,"%9s:%8d%6d\n",
1314 		"write", write_sq.numBufs, write_sq.bufSize) ;
1315 	len += sprintf(buffer+len,
1316 		"Current  : MaxFrg FragSiz MaxAct Frnt Rear "
1317 		"Cnt RrSize A B S L  xruns\n") ;
1318 	len += sprintf(buffer+len,"%9s:%7d%8d%7d%5d%5d%4d%7d%2d%2d%2d%2d%7d\n",
1319 		"write", write_sq.max_count, write_sq.block_size,
1320 		write_sq.max_active, write_sq.front, write_sq.rear,
1321 		write_sq.count, write_sq.rear_size, write_sq.active,
1322 		write_sq.busy, write_sq.syncing, write_sq.locked, write_sq.xruns) ;
1323 #ifdef DEBUG_DMASOUND
1324 printk("dmasound: stat buffer used %d bytes\n", len) ;
1325 #endif
1326 
1327 	if (len >= STAT_BUFF_LEN)
1328 		printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
1329 
1330 	state.len = len;
1331 	ret = 0;
1332 out:
1333 	mutex_unlock(&dmasound_core_mutex);
1334 	return ret;
1335 }
1336 
1337 static int state_release(struct inode *inode, struct file *file)
1338 {
1339 	mutex_lock(&dmasound_core_mutex);
1340 	state.busy = 0;
1341 	module_put(dmasound.mach.owner);
1342 	mutex_unlock(&dmasound_core_mutex);
1343 	return 0;
1344 }
1345 
1346 static ssize_t state_read(struct file *file, char __user *buf, size_t count,
1347 			  loff_t *ppos)
1348 {
1349 	int n = state.len - state.ptr;
1350 	if (n > count)
1351 		n = count;
1352 	if (n <= 0)
1353 		return 0;
1354 	if (copy_to_user(buf, &state.buf[state.ptr], n))
1355 		return -EFAULT;
1356 	state.ptr += n;
1357 	return n;
1358 }
1359 
1360 static const struct file_operations state_fops = {
1361 	.owner		= THIS_MODULE,
1362 	.llseek		= no_llseek,
1363 	.read		= state_read,
1364 	.open		= state_open,
1365 	.release	= state_release,
1366 };
1367 
1368 static int state_init(void)
1369 {
1370 #ifndef MODULE
1371 	int state_unit;
1372 #endif
1373 	state_unit = register_sound_special(&state_fops, SND_DEV_STATUS);
1374 	if (state_unit < 0)
1375 		return state_unit ;
1376 	state.busy = 0;
1377 	return 0 ;
1378 }
1379 
1380 
1381     /*
1382      *  Config & Setup
1383      *
1384      *  This function is called by _one_ chipset-specific driver
1385      */
1386 
1387 int dmasound_init(void)
1388 {
1389 	int res ;
1390 #ifdef MODULE
1391 	if (irq_installed)
1392 		return -EBUSY;
1393 #endif
1394 
1395 	/* Set up sound queue, /dev/audio and /dev/dsp. */
1396 
1397 	/* Set default settings. */
1398 	if ((res = sq_init()) < 0)
1399 		return res ;
1400 
1401 	/* Set up /dev/sndstat. */
1402 	if ((res = state_init()) < 0)
1403 		return res ;
1404 
1405 	/* Set up /dev/mixer. */
1406 	mixer_init();
1407 
1408 	if (!dmasound.mach.irqinit()) {
1409 		printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n");
1410 		return -ENODEV;
1411 	}
1412 #ifdef MODULE
1413 	irq_installed = 1;
1414 #endif
1415 
1416 	printk(KERN_INFO "%s DMA sound driver rev %03d installed\n",
1417 		dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1418 		((dmasound.mach.version>>8) & 0x0f));
1419 	printk(KERN_INFO
1420 		"Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1421 		DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1422 		(dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1423 	printk(KERN_INFO "Write will use %4d fragments of %7d bytes as default\n",
1424 		numWriteBufs, writeBufSize) ;
1425 	return 0;
1426 }
1427 
1428 #ifdef MODULE
1429 
1430 void dmasound_deinit(void)
1431 {
1432 	if (irq_installed) {
1433 		sound_silence();
1434 		dmasound.mach.irqcleanup();
1435 		irq_installed = 0;
1436 	}
1437 
1438 	write_sq_release_buffers();
1439 
1440 	if (mixer_unit >= 0)
1441 		unregister_sound_mixer(mixer_unit);
1442 	if (state_unit >= 0)
1443 		unregister_sound_special(state_unit);
1444 	if (sq_unit >= 0)
1445 		unregister_sound_dsp(sq_unit);
1446 }
1447 
1448 #else /* !MODULE */
1449 
1450 static int dmasound_setup(char *str)
1451 {
1452 	int ints[6], size;
1453 
1454 	str = get_options(str, ARRAY_SIZE(ints), ints);
1455 
1456 	/* check the bootstrap parameter for "dmasound=" */
1457 
1458 	/* FIXME: other than in the most naive of cases there is no sense in these
1459 	 *	  buffers being other than powers of two.  This is not checked yet.
1460 	 */
1461 
1462 	switch (ints[0]) {
1463 	case 3:
1464 		if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS))
1465 			printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius);
1466 		else
1467 			catchRadius = ints[3];
1468 		/* fall through */
1469 	case 2:
1470 		if (ints[1] < MIN_BUFFERS)
1471 			printk("dmasound_setup: invalid number of buffers, using default = %d\n", numWriteBufs);
1472 		else
1473 			numWriteBufs = ints[1];
1474 		/* fall through */
1475 	case 1:
1476 		if ((size = ints[2]) < 256) /* check for small buffer specs */
1477 			size <<= 10 ;
1478                 if (size < MIN_BUFSIZE || size > MAX_BUFSIZE)
1479                         printk("dmasound_setup: invalid write buffer size, using default = %d\n", writeBufSize);
1480                 else
1481                         writeBufSize = size;
1482 	case 0:
1483 		break;
1484 	default:
1485 		printk("dmasound_setup: invalid number of arguments\n");
1486 		return 0;
1487 	}
1488 	return 1;
1489 }
1490 
1491 __setup("dmasound=", dmasound_setup);
1492 
1493 #endif /* !MODULE */
1494 
1495     /*
1496      *  Conversion tables
1497      */
1498 
1499 #ifdef HAS_8BIT_TABLES
1500 /* 8 bit mu-law */
1501 
1502 char dmasound_ulaw2dma8[] = {
1503 	-126,	-122,	-118,	-114,	-110,	-106,	-102,	-98,
1504 	-94,	-90,	-86,	-82,	-78,	-74,	-70,	-66,
1505 	-63,	-61,	-59,	-57,	-55,	-53,	-51,	-49,
1506 	-47,	-45,	-43,	-41,	-39,	-37,	-35,	-33,
1507 	-31,	-30,	-29,	-28,	-27,	-26,	-25,	-24,
1508 	-23,	-22,	-21,	-20,	-19,	-18,	-17,	-16,
1509 	-16,	-15,	-15,	-14,	-14,	-13,	-13,	-12,
1510 	-12,	-11,	-11,	-10,	-10,	-9,	-9,	-8,
1511 	-8,	-8,	-7,	-7,	-7,	-7,	-6,	-6,
1512 	-6,	-6,	-5,	-5,	-5,	-5,	-4,	-4,
1513 	-4,	-4,	-4,	-4,	-3,	-3,	-3,	-3,
1514 	-3,	-3,	-3,	-3,	-2,	-2,	-2,	-2,
1515 	-2,	-2,	-2,	-2,	-2,	-2,	-2,	-2,
1516 	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
1517 	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
1518 	-1,	-1,	-1,	-1,	-1,	-1,	-1,	0,
1519 	125,	121,	117,	113,	109,	105,	101,	97,
1520 	93,	89,	85,	81,	77,	73,	69,	65,
1521 	62,	60,	58,	56,	54,	52,	50,	48,
1522 	46,	44,	42,	40,	38,	36,	34,	32,
1523 	30,	29,	28,	27,	26,	25,	24,	23,
1524 	22,	21,	20,	19,	18,	17,	16,	15,
1525 	15,	14,	14,	13,	13,	12,	12,	11,
1526 	11,	10,	10,	9,	9,	8,	8,	7,
1527 	7,	7,	6,	6,	6,	6,	5,	5,
1528 	5,	5,	4,	4,	4,	4,	3,	3,
1529 	3,	3,	3,	3,	2,	2,	2,	2,
1530 	2,	2,	2,	2,	1,	1,	1,	1,
1531 	1,	1,	1,	1,	1,	1,	1,	1,
1532 	0,	0,	0,	0,	0,	0,	0,	0,
1533 	0,	0,	0,	0,	0,	0,	0,	0,
1534 	0,	0,	0,	0,	0,	0,	0,	0
1535 };
1536 
1537 /* 8 bit A-law */
1538 
1539 char dmasound_alaw2dma8[] = {
1540 	-22,	-21,	-24,	-23,	-18,	-17,	-20,	-19,
1541 	-30,	-29,	-32,	-31,	-26,	-25,	-28,	-27,
1542 	-11,	-11,	-12,	-12,	-9,	-9,	-10,	-10,
1543 	-15,	-15,	-16,	-16,	-13,	-13,	-14,	-14,
1544 	-86,	-82,	-94,	-90,	-70,	-66,	-78,	-74,
1545 	-118,	-114,	-126,	-122,	-102,	-98,	-110,	-106,
1546 	-43,	-41,	-47,	-45,	-35,	-33,	-39,	-37,
1547 	-59,	-57,	-63,	-61,	-51,	-49,	-55,	-53,
1548 	-2,	-2,	-2,	-2,	-2,	-2,	-2,	-2,
1549 	-2,	-2,	-2,	-2,	-2,	-2,	-2,	-2,
1550 	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
1551 	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
1552 	-6,	-6,	-6,	-6,	-5,	-5,	-5,	-5,
1553 	-8,	-8,	-8,	-8,	-7,	-7,	-7,	-7,
1554 	-3,	-3,	-3,	-3,	-3,	-3,	-3,	-3,
1555 	-4,	-4,	-4,	-4,	-4,	-4,	-4,	-4,
1556 	21,	20,	23,	22,	17,	16,	19,	18,
1557 	29,	28,	31,	30,	25,	24,	27,	26,
1558 	10,	10,	11,	11,	8,	8,	9,	9,
1559 	14,	14,	15,	15,	12,	12,	13,	13,
1560 	86,	82,	94,	90,	70,	66,	78,	74,
1561 	118,	114,	126,	122,	102,	98,	110,	106,
1562 	43,	41,	47,	45,	35,	33,	39,	37,
1563 	59,	57,	63,	61,	51,	49,	55,	53,
1564 	1,	1,	1,	1,	1,	1,	1,	1,
1565 	1,	1,	1,	1,	1,	1,	1,	1,
1566 	0,	0,	0,	0,	0,	0,	0,	0,
1567 	0,	0,	0,	0,	0,	0,	0,	0,
1568 	5,	5,	5,	5,	4,	4,	4,	4,
1569 	7,	7,	7,	7,	6,	6,	6,	6,
1570 	2,	2,	2,	2,	2,	2,	2,	2,
1571 	3,	3,	3,	3,	3,	3,	3,	3
1572 };
1573 #endif /* HAS_8BIT_TABLES */
1574 
1575     /*
1576      *  Visible symbols for modules
1577      */
1578 
1579 EXPORT_SYMBOL(dmasound);
1580 EXPORT_SYMBOL(dmasound_init);
1581 #ifdef MODULE
1582 EXPORT_SYMBOL(dmasound_deinit);
1583 #endif
1584 EXPORT_SYMBOL(dmasound_write_sq);
1585 EXPORT_SYMBOL(dmasound_catchRadius);
1586 #ifdef HAS_8BIT_TABLES
1587 EXPORT_SYMBOL(dmasound_ulaw2dma8);
1588 EXPORT_SYMBOL(dmasound_alaw2dma8);
1589 #endif
1590