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