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