2 * linux/sound/oss/dmasound/dmasound_core.c
5 * OSS/Free compatible Atari TT/Falcon and Amiga DMA sound driver for
7 * Extended to support Power Macintosh for Linux/ppc by Paul Mackerras
9 * (c) 1995 by Michael Schlueter & Michael Marte
11 * Michael Schlueter (michael@duck.syd.de) did the basic structure of the VFS
12 * interface and the u-law to signed byte conversion.
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
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.
21 * /dev/sndstat is based on code by Hannu Savolainen, the author of the
22 * VoxWare family of drivers.
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
30 * 1995/8/25 First release
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
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.
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.
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
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
66 * - Buffer size is now a kernel runtime option
67 * - Implemented fsync() & several minor improvements
69 * - Useful hints and bug fixes
70 * - Cross-checked it for Falcons
72 * 1996/3/9 Geert Uytterhoeven:
73 * - Support added for Amiga, A-law, 16-bit little
75 * - Unification to drivers/sound/dmasound.c.
77 * 1996/4/6 Martin Mitchell:
78 * - Updated to 1.3 kernel.
80 * 1996/6/13 Topi Kanerva:
81 * - Fixed things that were broken (mainly the amiga
83 * - /dev/sndstat shows now the real hardware frequency
84 * - The lowpass filter is disabled by default now
86 * 1996/9/25 Geert Uytterhoeven:
89 * 1998/6/10 Andreas Schwab:
90 * - Converted to use sound_core
92 * 1999/12/28 Richard Zidlicky:
93 * - Added support for Q40
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
102 * 2000/3/25 Geert Uytterhoeven:
103 * - Integration of dmasound_q40
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
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
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.
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.
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
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.
163 * It's bad application coding - but ...
164 * TODO: think about how to sort this out... without bogging everything down in
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 :-(
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.
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>
187 #include <linux/uaccess.h>
189 #include "dmasound.h"
191 #define DMASOUND_CORE_REVISION 1
192 #define DMASOUND_CORE_EDITION 6
198 static DEFINE_MUTEX(dmasound_core_mutex);
199 int dmasound_catchRadius = 0;
200 module_param(dmasound_catchRadius, int, 0);
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);
207 MODULE_LICENSE("GPL");
210 static int sq_unit = -1;
211 static int mixer_unit = -1;
212 static int state_unit = -1;
213 static int irq_installed;
216 /* control over who can modify resources shared between play/record */
217 static fmode_t shared_resource_owner;
218 static int shared_resources_initialised;
224 struct sound_settings dmasound = {
225 .lock = __SPIN_LOCK_UNLOCKED(dmasound.lock)
228 static inline void sound_silence(void)
230 dmasound.mach.silence(); /* _MUST_ stop DMA */
233 static inline int sound_set_format(int format)
235 return dmasound.mach.setFormat(format);
239 static int sound_set_speed(int speed)
242 return dmasound.soft.speed;
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.
249 if (dmasound.mach.max_dsp_speed &&
250 (speed > dmasound.mach.max_dsp_speed))
251 speed = dmasound.mach.max_dsp_speed ;
253 dmasound.soft.speed = speed;
255 if (dmasound.minDev == SND_DEV_DSP)
256 dmasound.dsp.speed = dmasound.soft.speed;
258 return dmasound.soft.speed;
261 static int sound_set_stereo(int stereo)
264 return dmasound.soft.stereo;
266 stereo = !!stereo; /* should be 0 or 1 now */
268 dmasound.soft.stereo = stereo;
269 if (dmasound.minDev == SND_DEV_DSP)
270 dmasound.dsp.stereo = stereo;
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)
279 ssize_t (*ct_func)(const u_char __user *, size_t, u_char *, ssize_t *, ssize_t);
281 switch (dmasound.soft.format) {
283 ct_func = trans->ct_ulaw;
286 ct_func = trans->ct_alaw;
289 ct_func = trans->ct_s8;
292 ct_func = trans->ct_u8;
295 ct_func = trans->ct_s16be;
298 ct_func = trans->ct_u16be;
301 ct_func = trans->ct_s16le;
304 ct_func = trans->ct_u16le;
309 /* if the user has requested a non-existent translation don't try
310 to call it but just return 0 bytes moved
313 return ct_func(userPtr, userCount, frame, frameUsed, frameLeft);
318 * /dev/mixer abstraction
326 static int mixer_open(struct inode *inode, struct file *file)
328 mutex_lock(&dmasound_core_mutex);
329 if (!try_module_get(dmasound.mach.owner)) {
330 mutex_unlock(&dmasound_core_mutex);
334 mutex_unlock(&dmasound_core_mutex);
338 static int mixer_release(struct inode *inode, struct file *file)
340 mutex_lock(&dmasound_core_mutex);
342 module_put(dmasound.mach.owner);
343 mutex_unlock(&dmasound_core_mutex);
347 static int mixer_ioctl(struct file *file, u_int cmd, u_long arg)
349 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
350 mixer.modify_counter++;
353 return IOCTL_OUT(arg, SOUND_VERSION);
354 case SOUND_MIXER_INFO:
357 memset(&info, 0, sizeof(info));
358 strscpy(info.id, dmasound.mach.name2, sizeof(info.id));
359 strscpy(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)))
366 if (dmasound.mach.mixer_ioctl)
367 return dmasound.mach.mixer_ioctl(cmd, arg);
371 static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
375 mutex_lock(&dmasound_core_mutex);
376 ret = mixer_ioctl(file, cmd, arg);
377 mutex_unlock(&dmasound_core_mutex);
382 static const struct file_operations mixer_fops =
384 .owner = THIS_MODULE,
386 .unlocked_ioctl = mixer_unlocked_ioctl,
387 .compat_ioctl = compat_ptr_ioctl,
389 .release = mixer_release,
392 static void mixer_init(void)
397 mixer_unit = register_sound_mixer(&mixer_fops, -1);
404 if (dmasound.mach.mixer_init)
405 dmasound.mach.mixer_init();
410 * Sound queue stuff, the heart of the driver
413 struct sound_queue dmasound_write_sq;
414 static void sq_reset_output(void) ;
416 static int sq_allocate_buffers(struct sound_queue *sq, int num, int size)
424 sq->buffers = kmalloc_array (num, sizeof(char *), GFP_KERNEL);
427 for (i = 0; i < num; i++) {
428 sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL);
429 if (!sq->buffers[i]) {
431 dmasound.mach.dma_free(sq->buffers[i], size);
440 static void sq_release_buffers(struct sound_queue *sq)
445 for (i = 0; i < sq->numBufs; i++)
446 dmasound.mach.dma_free(sq->buffers[i], sq->bufSize);
453 static int sq_setup(struct sound_queue *sq)
455 int (*setup_func)(void) = NULL;
458 if (sq->locked) { /* are we already set? - and not changeable */
459 #ifdef DEBUG_DMASOUND
460 printk("dmasound_core: tried to sq_setup a locked queue\n") ;
464 sq->locked = 1 ; /* don't think we have a race prob. here _check_ */
466 /* make sure that the parameters are set up
467 This should have been done already...
470 dmasound.mach.init();
472 /* OK. If the user has set fragment parameters explicitly, then we
473 should leave them alone... as long as they are valid.
474 Invalid user fragment params can occur if we allow the whole buffer
475 to be used when the user requests the fragments sizes (with no soft
476 x-lation) and then the user subsequently sets a soft x-lation that
477 requires increased internal buffering.
479 Othwerwise (if the user did not set them) OSS says that we should
480 select frag params on the basis of 0.5 s output & 0.1 s input
481 latency. (TODO. For now we will copy in the defaults.)
484 if (sq->user_frags <= 0) {
485 sq->max_count = sq->numBufs ;
486 sq->max_active = sq->numBufs ;
487 sq->block_size = sq->bufSize;
488 /* set up the user info */
489 sq->user_frags = sq->numBufs ;
490 sq->user_frag_size = sq->bufSize ;
491 sq->user_frag_size *=
492 (dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
493 sq->user_frag_size /=
494 (dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
496 /* work out requested block size */
497 sq->block_size = sq->user_frag_size ;
499 (dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
501 (dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
502 /* the user wants to write frag-size chunks */
503 sq->block_size *= dmasound.hard.speed ;
504 sq->block_size /= dmasound.soft.speed ;
505 /* this only works for size values which are powers of 2 */
507 (dmasound.hard.size * (dmasound.hard.stereo+1))/8 ;
508 sq->block_size += (hard_frame - 1) ;
509 sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */
510 /* let's just check for obvious mistakes */
511 if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) {
512 #ifdef DEBUG_DMASOUND
513 printk("dmasound_core: invalid frag size (user set %d)\n", sq->user_frag_size) ;
515 sq->block_size = sq->bufSize ;
517 if ( sq->user_frags <= sq->numBufs ) {
518 sq->max_count = sq->user_frags ;
519 /* if user has set max_active - then use it */
520 sq->max_active = (sq->max_active <= sq->max_count) ?
521 sq->max_active : sq->max_count ;
523 #ifdef DEBUG_DMASOUND
524 printk("dmasound_core: invalid frag count (user set %d)\n", sq->user_frags) ;
527 sq->max_active = sq->numBufs ;
530 sq->front = sq->count = sq->rear_size = 0;
534 if (sq == &write_sq) {
536 setup_func = dmasound.mach.write_sq_setup;
543 static inline void sq_play(void)
545 dmasound.mach.play();
548 static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft,
551 ssize_t uWritten = 0;
553 ssize_t uUsed = 0, bUsed, bLeft;
554 unsigned long flags ;
556 /* ++TeSche: Is something like this necessary?
557 * Hey, that's an honest question! Or does any other part of the
558 * filesystem already checks this situation? I really don't know.
563 /* implement any changes we have made to the soft/hard params.
564 this is not satisfactory really, all we have done up to now is to
565 say what we would like - there hasn't been any real checking of capability
568 if (shared_resources_initialised == 0) {
569 dmasound.mach.init() ;
570 shared_resources_initialised = 1 ;
573 /* set up the sq if it is not already done. This may seem a dumb place
574 to do it - but it is what OSS requires. It means that write() can
575 return memory allocation errors. To avoid this possibility use the
576 GETBLKSIZE or GETOSPACE ioctls (after you've fiddled with all the
577 params you want to change) - these ioctls also force the setup.
580 if (write_sq.locked == 0) {
581 if ((uWritten = sq_setup(&write_sq)) < 0) return uWritten ;
585 /* FIXME: I think that this may be the wrong behaviour when we get strapped
586 for time and the cpu is close to being (or actually) behind in sending data.
587 - because we've lost the time that the N samples, already in the buffer,
588 would have given us to get here with the next lot from the user.
590 /* The interrupt doesn't start to play the last, incomplete frame.
591 * Thus we can append to it without disabling the interrupts! (Note
592 * also that write_sq.rear isn't affected by the interrupt.)
595 /* as of 1.6 this behaviour changes if SNDCTL_DSP_POST has been issued:
596 this will mimic the behaviour of syncing and allow the sq_play() to
597 queue a partial fragment. Since sq_play() may/will be called from
598 the IRQ handler - at least on Pmac we have to deal with it.
599 The strategy - possibly not optimum - is to kill _POST status if we
600 get here. This seems, at least, reasonable - in the sense that POST
601 is supposed to indicate that we might not write before the queue
602 is drained - and if we get here in time then it does not apply.
605 spin_lock_irqsave(&dmasound.lock, flags);
606 write_sq.syncing &= ~2 ; /* take out POST status */
607 spin_unlock_irqrestore(&dmasound.lock, flags);
609 if (write_sq.count > 0 &&
610 (bLeft = write_sq.block_size-write_sq.rear_size) > 0) {
611 dest = write_sq.buffers[write_sq.rear];
612 bUsed = write_sq.rear_size;
613 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
614 dest, &bUsed, bLeft);
619 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
620 write_sq.rear_size = bUsed;
626 while (write_sq.count >= write_sq.max_active) {
627 prepare_to_wait(&write_sq.action_queue, &wait, TASK_INTERRUPTIBLE);
629 if (write_sq.non_blocking) {
630 finish_wait(&write_sq.action_queue, &wait);
631 return uWritten > 0 ? uWritten : -EAGAIN;
633 if (write_sq.count < write_sq.max_active)
636 schedule_timeout(HZ);
637 if (signal_pending(current)) {
638 finish_wait(&write_sq.action_queue, &wait);
639 return uWritten > 0 ? uWritten : -EINTR;
643 finish_wait(&write_sq.action_queue, &wait);
645 /* Here, we can avoid disabling the interrupt by first
646 * copying and translating the data, and then updating
647 * the write_sq variables. Until this is done, the interrupt
648 * won't see the new frame and we can work on it
652 dest = write_sq.buffers[(write_sq.rear+1) % write_sq.max_count];
654 bLeft = write_sq.block_size;
655 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
656 dest, &bUsed, bLeft);
661 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
663 write_sq.rear = (write_sq.rear+1) % write_sq.max_count;
664 write_sq.rear_size = bUsed;
667 } /* uUsed may have been 0 */
671 return uUsed < 0? uUsed: uWritten;
674 static __poll_t sq_poll(struct file *file, struct poll_table_struct *wait)
679 if (write_sq.locked == 0) {
680 if ((retVal = sq_setup(&write_sq)) < 0)
684 if (file->f_mode & FMODE_WRITE )
685 poll_wait(file, &write_sq.action_queue, wait);
686 if (file->f_mode & FMODE_WRITE)
687 if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0)
688 mask |= EPOLLOUT | EPOLLWRNORM;
693 static inline void sq_init_waitqueue(struct sound_queue *sq)
695 init_waitqueue_head(&sq->action_queue);
696 init_waitqueue_head(&sq->open_queue);
697 init_waitqueue_head(&sq->sync_queue);
701 #if 0 /* blocking open() */
702 static inline void sq_wake_up(struct sound_queue *sq, struct file *file,
705 if (file->f_mode & mode) {
706 sq->busy = 0; /* CHECK: IS THIS OK??? */
707 WAKE_UP(sq->open_queue);
712 static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode,
713 int numbufs, int bufsize)
717 if (file->f_mode & mode) {
719 #if 0 /* blocking open() */
721 if (file->f_flags & O_NONBLOCK)
724 if (wait_event_interruptible(sq->open_queue, !sq->busy))
728 /* OSS manual says we will return EBUSY regardless
734 sq->busy = 1; /* Let's play spot-the-race-condition */
736 /* allocate the default number & size of buffers.
737 (i.e. specified in _setup() or as module params)
738 can't be changed at the moment - but _could_ be perhaps
739 in the setfragments ioctl.
741 if (( rc = sq_allocate_buffers(sq, numbufs, bufsize))) {
742 #if 0 /* blocking open() */
743 sq_wake_up(sq, file, mode);
750 sq->non_blocking = file->f_flags & O_NONBLOCK;
755 #define write_sq_init_waitqueue() sq_init_waitqueue(&write_sq)
756 #if 0 /* blocking open() */
757 #define write_sq_wake_up(file) sq_wake_up(&write_sq, file, FMODE_WRITE)
759 #define write_sq_release_buffers() sq_release_buffers(&write_sq)
760 #define write_sq_open(file) \
761 sq_open2(&write_sq, file, FMODE_WRITE, numWriteBufs, writeBufSize )
763 static int sq_open(struct inode *inode, struct file *file)
767 mutex_lock(&dmasound_core_mutex);
768 if (!try_module_get(dmasound.mach.owner)) {
769 mutex_unlock(&dmasound_core_mutex);
773 rc = write_sq_open(file); /* checks the f_mode */
776 if (file->f_mode & FMODE_READ) {
777 /* TODO: if O_RDWR, release any resources grabbed by write part */
778 rc = -ENXIO ; /* I think this is what is required by open(2) */
782 if (dmasound.mach.sq_open)
783 dmasound.mach.sq_open(file->f_mode);
785 /* CHECK whether this is sensible - in the case that dsp0 could be opened
786 O_RDONLY and dsp1 could be opened O_WRONLY
789 dmasound.minDev = iminor(inode) & 0x0f;
791 /* OK. - we should make some attempt at consistency. At least the H'ware
792 options should be set with a valid mode. We will make it that the LL
793 driver must supply defaults for hard & soft params.
796 if (shared_resource_owner == 0) {
797 /* you can make this AFMT_U8/mono/8K if you want to mimic old
798 OSS behaviour - while we still have soft translations ;-) */
799 dmasound.soft = dmasound.mach.default_soft ;
800 dmasound.dsp = dmasound.mach.default_soft ;
801 dmasound.hard = dmasound.mach.default_hard ;
804 #ifndef DMASOUND_STRICT_OSS_COMPLIANCE
805 /* none of the current LL drivers can actually do this "native" at the moment
806 OSS does not really require us to supply /dev/audio if we can't do it.
808 if (dmasound.minDev == SND_DEV_AUDIO) {
809 sound_set_speed(8000);
811 sound_set_format(AFMT_MU_LAW);
814 mutex_unlock(&dmasound_core_mutex);
817 module_put(dmasound.mach.owner);
818 mutex_unlock(&dmasound_core_mutex);
822 static void sq_reset_output(void)
824 sound_silence(); /* this _must_ stop DMA, we might be about to lose the buffers */
827 write_sq.rear_size = 0;
828 /* write_sq.front = (write_sq.rear+1) % write_sq.max_count;*/
830 write_sq.rear = -1 ; /* same as for set-up */
832 /* OK - we can unlock the parameters and fragment settings */
833 write_sq.locked = 0 ;
834 write_sq.user_frags = 0 ;
835 write_sq.user_frag_size = 0 ;
838 static void sq_reset(void)
841 /* we could consider resetting the shared_resources_owner here... but I
842 think it is probably still rather non-obvious to application writer
845 /* we release everything else though */
846 shared_resources_initialised = 0 ;
849 static int sq_fsync(void)
854 write_sq.syncing |= 1;
855 sq_play(); /* there may be an incomplete frame waiting */
857 while (write_sq.active) {
858 wait_event_interruptible_timeout(write_sq.sync_queue,
859 !write_sq.active, HZ);
860 if (signal_pending(current)) {
861 /* While waiting for audio output to drain, an
862 * interrupt occurred. Stop audio output immediately
863 * and clear the queue. */
869 printk(KERN_WARNING "dmasound: Timeout draining output\n");
876 /* flag no sync regardless of whether we had a DSP_POST or not */
877 write_sq.syncing = 0 ;
881 static int sq_release(struct inode *inode, struct file *file)
885 mutex_lock(&dmasound_core_mutex);
887 if (file->f_mode & FMODE_WRITE) {
891 sq_reset_output() ; /* make sure dma is stopped and all is quiet */
892 write_sq_release_buffers();
896 if (file->f_mode & shared_resource_owner) { /* it's us that has them */
897 shared_resource_owner = 0 ;
898 shared_resources_initialised = 0 ;
899 dmasound.hard = dmasound.mach.default_hard ;
902 module_put(dmasound.mach.owner);
904 #if 0 /* blocking open() */
905 /* Wake up a process waiting for the queue being released.
906 * Note: There may be several processes waiting for a call
907 * to open() returning. */
909 /* Iain: hmm I don't understand this next comment ... */
910 /* There is probably a DOS atack here. They change the mode flag. */
911 /* XXX add check here,*/
912 read_sq_wake_up(file); /* checks f_mode */
913 write_sq_wake_up(file); /* checks f_mode */
914 #endif /* blocking open() */
916 mutex_unlock(&dmasound_core_mutex);
921 /* here we see if we have a right to modify format, channels, size and so on
922 if no-one else has claimed it already then we do...
924 TODO: We might change this to mask O_RDWR such that only one or the other channel
925 is the owner - if we have problems.
928 static int shared_resources_are_mine(fmode_t md)
930 if (shared_resource_owner)
931 return (shared_resource_owner & md) != 0;
933 shared_resource_owner = md ;
938 /* if either queue is locked we must deny the right to change shared params
941 static int queues_are_quiescent(void)
948 /* check and set a queue's fragments per user's wishes...
949 we will check against the pre-defined literals and the actual sizes.
950 This is a bit fraught - because soft translations can mess with our
951 buffer requirements *after* this call - OSS says "call setfrags first"
954 /* It is possible to replace all the -EINVAL returns with an override that
955 just puts the allowable value in. This may be what many OSS apps require
958 static int set_queue_frags(struct sound_queue *sq, int bufs, int size)
961 #ifdef DEBUG_DMASOUND
962 printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
967 if ((size < MIN_FRAG_SIZE) || (size > MAX_FRAG_SIZE))
969 size = (1<<size) ; /* now in bytes */
970 if (size > sq->bufSize)
971 return -EINVAL ; /* this might still not work */
975 if (bufs > sq->numBufs) /* the user is allowed say "don't care" with 0x7fff */
978 /* there is, currently, no way to specify max_active separately
979 from max_count. This could be a LL driver issue - I guess
980 if there is a requirement for these values to be different then
981 we will have to pass that info. up to this level.
984 sq->max_active = bufs ;
985 sq->user_frag_size = size ;
990 static int sq_ioctl(struct file *file, u_int cmd, u_long arg)
999 case SNDCTL_DSP_RESET:
1002 case SNDCTL_DSP_GETFMTS:
1003 fmt = dmasound.mach.hardware_afmts ; /* this is what OSS says.. */
1004 return IOCTL_OUT(arg, fmt);
1005 case SNDCTL_DSP_GETBLKSIZE:
1006 /* this should tell the caller about bytes that the app can
1007 read/write - the app doesn't care about our internal buffers.
1008 We force sq_setup() here as per OSS 1.1 (which should
1009 compute the values necessary).
1010 Since there is no mechanism to specify read/write separately, for
1011 fds opened O_RDWR, the write_sq values will, arbitrarily, overwrite
1015 if (file->f_mode & FMODE_WRITE) {
1016 if ( !write_sq.locked )
1017 sq_setup(&write_sq) ;
1018 size = write_sq.user_frag_size ;
1020 return IOCTL_OUT(arg, size);
1021 case SNDCTL_DSP_POST:
1022 /* all we are going to do is to tell the LL that any
1023 partial frags can be queued for output.
1024 The LL will have to clear this flag when last output
1027 write_sq.syncing |= 0x2 ;
1030 case SNDCTL_DSP_SYNC:
1031 /* This call, effectively, has the same behaviour as SNDCTL_DSP_RESET
1032 except that it waits for output to finish before resetting
1033 everything - read, however, is killed immediately.
1036 if (file->f_mode & FMODE_WRITE) {
1037 result = sq_fsync();
1040 /* if we are the shared resource owner then release them */
1041 if (file->f_mode & shared_resource_owner)
1042 shared_resources_initialised = 0 ;
1044 case SOUND_PCM_READ_RATE:
1045 return IOCTL_OUT(arg, dmasound.soft.speed);
1046 case SNDCTL_DSP_SPEED:
1047 /* changing this on the fly will have weird effects on the sound.
1048 Where there are rate conversions implemented in soft form - it
1049 will cause the _ctx_xxx() functions to be substituted.
1050 However, there doesn't appear to be any reason to dis-allow it from
1053 if (shared_resources_are_mine(file->f_mode)) {
1054 IOCTL_IN(arg, data);
1055 data = sound_set_speed(data) ;
1056 shared_resources_initialised = 0 ;
1057 return IOCTL_OUT(arg, data);
1061 /* OSS says these next 4 actions are undefined when the device is
1062 busy/active - we will just return -EINVAL.
1063 To be allowed to change one - (a) you have to own the right
1064 (b) the queue(s) must be quiescent
1066 case SNDCTL_DSP_STEREO:
1067 if (shared_resources_are_mine(file->f_mode) &&
1068 queues_are_quiescent()) {
1069 IOCTL_IN(arg, data);
1070 shared_resources_initialised = 0 ;
1071 return IOCTL_OUT(arg, sound_set_stereo(data));
1075 case SOUND_PCM_WRITE_CHANNELS:
1076 if (shared_resources_are_mine(file->f_mode) &&
1077 queues_are_quiescent()) {
1078 IOCTL_IN(arg, data);
1079 /* the user might ask for 20 channels, we will return 1 or 2 */
1080 shared_resources_initialised = 0 ;
1081 return IOCTL_OUT(arg, sound_set_stereo(data-1)+1);
1085 case SNDCTL_DSP_SETFMT:
1086 if (shared_resources_are_mine(file->f_mode) &&
1087 queues_are_quiescent()) {
1089 IOCTL_IN(arg, data);
1090 shared_resources_initialised = 0 ;
1091 format = sound_set_format(data);
1092 result = IOCTL_OUT(arg, format);
1095 if (format != data && data != AFMT_QUERY)
1100 case SNDCTL_DSP_SUBDIVIDE:
1102 case SNDCTL_DSP_SETFRAGMENT:
1103 /* we can do this independently for the two queues - with the
1104 proviso that for fds opened O_RDWR we cannot separate the
1105 actions and both queues will be set per the last call.
1106 NOTE: this does *NOT* actually set the queue up - merely
1107 registers our intentions.
1109 IOCTL_IN(arg, data);
1111 nbufs = (data >> 16) & 0x7fff ; /* 0x7fff is 'use maximum' */
1112 size = data & 0xffff;
1113 if (file->f_mode & FMODE_WRITE) {
1114 result = set_queue_frags(&write_sq, nbufs, size) ;
1118 /* NOTE: this return value is irrelevant - OSS specifically says that
1119 the value is 'random' and that the user _must_ check the actual
1120 frags values using SNDCTL_DSP_GETBLKSIZE or similar */
1121 return IOCTL_OUT(arg, data);
1122 case SNDCTL_DSP_GETOSPACE:
1125 if (file->f_mode & FMODE_WRITE) {
1126 if ( !write_sq.locked )
1127 sq_setup(&write_sq) ;
1128 info.fragments = write_sq.max_active - write_sq.count;
1129 info.fragstotal = write_sq.max_active;
1130 info.fragsize = write_sq.user_frag_size;
1131 info.bytes = info.fragments * info.fragsize;
1132 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
1138 case SNDCTL_DSP_GETCAPS:
1139 val = dmasound.mach.capabilities & 0xffffff00;
1140 return IOCTL_OUT(arg,val);
1143 return mixer_ioctl(file, cmd, arg);
1148 static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
1152 mutex_lock(&dmasound_core_mutex);
1153 ret = sq_ioctl(file, cmd, arg);
1154 mutex_unlock(&dmasound_core_mutex);
1159 static const struct file_operations sq_fops =
1161 .owner = THIS_MODULE,
1162 .llseek = no_llseek,
1165 .unlocked_ioctl = sq_unlocked_ioctl,
1166 .compat_ioctl = compat_ptr_ioctl,
1168 .release = sq_release,
1171 static int sq_init(void)
1173 const struct file_operations *fops = &sq_fops;
1178 sq_unit = register_sound_dsp(fops, -1);
1180 printk(KERN_ERR "dmasound_core: couldn't register fops\n") ;
1184 write_sq_init_waitqueue();
1186 /* These parameters will be restored for every clean open()
1187 * in the case of multiple open()s (e.g. dsp0 & dsp1) they
1188 * will be set so long as the shared resources have no owner.
1191 if (shared_resource_owner == 0) {
1192 dmasound.soft = dmasound.mach.default_soft ;
1193 dmasound.hard = dmasound.mach.default_hard ;
1194 dmasound.dsp = dmasound.mach.default_soft ;
1195 shared_resources_initialised = 0 ;
1205 /* we allow more space for record-enabled because there are extra output lines.
1206 the number here must include the amount we are prepared to give to the low-level
1210 #define STAT_BUFF_LEN 768
1212 /* this is how much space we will allow the low-level driver to use
1213 in the stat buffer. Currently, 2 * (80 character line + <NL>).
1214 We do not police this (it is up to the ll driver to be honest).
1217 #define LOW_LEVEL_STAT_ALLOC 162
1221 char buf[STAT_BUFF_LEN]; /* state.buf should not overflow! */
1225 /* publish this function for use by low-level code, if required */
1227 static char *get_afmt_string(int afmt)
1235 return "unsigned 8 bit";
1237 return "signed 8 bit";
1239 return "signed 16 bit BE";
1241 return "unsigned 16 bit BE";
1243 return "signed 16 bit LE";
1245 return "unsigned 16 bit LE";
1247 return "format not set" ;
1251 return "ERROR: Unsupported AFMT_XXXX code" ;
1254 static int state_open(struct inode *inode, struct file *file)
1256 char *buffer = state.buf;
1260 mutex_lock(&dmasound_core_mutex);
1266 if (!try_module_get(dmasound.mach.owner))
1272 len += sprintf(buffer+len, "%sDMA sound driver rev %03d :\n",
1273 dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1274 ((dmasound.mach.version>>8) & 0x0f));
1275 len += sprintf(buffer+len,
1276 "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1277 DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1278 (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1280 /* call the low-level module to fill in any stat info. that it has
1281 if present. Maximum buffer usage is specified.
1284 if (dmasound.mach.state_info)
1285 len += dmasound.mach.state_info(buffer+len,
1286 (size_t) LOW_LEVEL_STAT_ALLOC) ;
1288 /* make usage of the state buffer as deterministic as poss.
1289 exceptional conditions could cause overrun - and this is flagged as
1293 /* formats and settings */
1295 len += sprintf(buffer+len,"\t\t === Formats & settings ===\n") ;
1296 len += sprintf(buffer+len,"Parameter %20s%20s\n","soft","hard") ;
1297 len += sprintf(buffer+len,"Format :%20s%20s\n",
1298 get_afmt_string(dmasound.soft.format),
1299 get_afmt_string(dmasound.hard.format));
1301 len += sprintf(buffer+len,"Samp Rate:%14d s/sec%14d s/sec\n",
1302 dmasound.soft.speed, dmasound.hard.speed);
1304 len += sprintf(buffer+len,"Channels :%20s%20s\n",
1305 dmasound.soft.stereo ? "stereo" : "mono",
1306 dmasound.hard.stereo ? "stereo" : "mono" );
1308 /* sound queue status */
1310 len += sprintf(buffer+len,"\t\t === Sound Queue status ===\n");
1311 len += sprintf(buffer+len,"Allocated:%8s%6s\n","Buffers","Size") ;
1312 len += sprintf(buffer+len,"%9s:%8d%6d\n",
1313 "write", write_sq.numBufs, write_sq.bufSize) ;
1314 len += sprintf(buffer+len,
1315 "Current : MaxFrg FragSiz MaxAct Frnt Rear "
1316 "Cnt RrSize A B S L xruns\n") ;
1317 len += sprintf(buffer+len,"%9s:%7d%8d%7d%5d%5d%4d%7d%2d%2d%2d%2d%7d\n",
1318 "write", write_sq.max_count, write_sq.block_size,
1319 write_sq.max_active, write_sq.front, write_sq.rear,
1320 write_sq.count, write_sq.rear_size, write_sq.active,
1321 write_sq.busy, write_sq.syncing, write_sq.locked, write_sq.xruns) ;
1322 #ifdef DEBUG_DMASOUND
1323 printk("dmasound: stat buffer used %d bytes\n", len) ;
1326 if (len >= STAT_BUFF_LEN)
1327 printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
1332 mutex_unlock(&dmasound_core_mutex);
1336 static int state_release(struct inode *inode, struct file *file)
1338 mutex_lock(&dmasound_core_mutex);
1340 module_put(dmasound.mach.owner);
1341 mutex_unlock(&dmasound_core_mutex);
1345 static ssize_t state_read(struct file *file, char __user *buf, size_t count,
1348 int n = state.len - state.ptr;
1353 if (copy_to_user(buf, &state.buf[state.ptr], n))
1359 static const struct file_operations state_fops = {
1360 .owner = THIS_MODULE,
1361 .llseek = no_llseek,
1364 .release = state_release,
1367 static int state_init(void)
1372 state_unit = register_sound_special(&state_fops, SND_DEV_STATUS);
1383 * This function is called by _one_ chipset-specific driver
1386 int dmasound_init(void)
1394 /* Set up sound queue, /dev/audio and /dev/dsp. */
1396 /* Set default settings. */
1397 if ((res = sq_init()) < 0)
1400 /* Set up /dev/sndstat. */
1401 if ((res = state_init()) < 0)
1404 /* Set up /dev/mixer. */
1407 if (!dmasound.mach.irqinit()) {
1408 printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n");
1415 printk(KERN_INFO "%s DMA sound driver rev %03d installed\n",
1416 dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1417 ((dmasound.mach.version>>8) & 0x0f));
1419 "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1420 DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1421 (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1422 printk(KERN_INFO "Write will use %4d fragments of %7d bytes as default\n",
1423 numWriteBufs, writeBufSize) ;
1429 void dmasound_deinit(void)
1431 if (irq_installed) {
1433 dmasound.mach.irqcleanup();
1437 write_sq_release_buffers();
1439 if (mixer_unit >= 0)
1440 unregister_sound_mixer(mixer_unit);
1441 if (state_unit >= 0)
1442 unregister_sound_special(state_unit);
1444 unregister_sound_dsp(sq_unit);
1449 static int dmasound_setup(char *str)
1453 str = get_options(str, ARRAY_SIZE(ints), ints);
1455 /* check the bootstrap parameter for "dmasound=" */
1457 /* FIXME: other than in the most naive of cases there is no sense in these
1458 * buffers being other than powers of two. This is not checked yet.
1463 if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS))
1464 printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius);
1466 catchRadius = ints[3];
1469 if (ints[1] < MIN_BUFFERS)
1470 printk("dmasound_setup: invalid number of buffers, using default = %d\n", numWriteBufs);
1472 numWriteBufs = ints[1];
1475 if ((size = ints[2]) < 256) /* check for small buffer specs */
1477 if (size < MIN_BUFSIZE || size > MAX_BUFSIZE)
1478 printk("dmasound_setup: invalid write buffer size, using default = %d\n", writeBufSize);
1480 writeBufSize = size;
1484 printk("dmasound_setup: invalid number of arguments\n");
1490 __setup("dmasound=", dmasound_setup);
1492 #endif /* !MODULE */
1498 #ifdef HAS_8BIT_TABLES
1501 char dmasound_ulaw2dma8[] = {
1502 -126, -122, -118, -114, -110, -106, -102, -98,
1503 -94, -90, -86, -82, -78, -74, -70, -66,
1504 -63, -61, -59, -57, -55, -53, -51, -49,
1505 -47, -45, -43, -41, -39, -37, -35, -33,
1506 -31, -30, -29, -28, -27, -26, -25, -24,
1507 -23, -22, -21, -20, -19, -18, -17, -16,
1508 -16, -15, -15, -14, -14, -13, -13, -12,
1509 -12, -11, -11, -10, -10, -9, -9, -8,
1510 -8, -8, -7, -7, -7, -7, -6, -6,
1511 -6, -6, -5, -5, -5, -5, -4, -4,
1512 -4, -4, -4, -4, -3, -3, -3, -3,
1513 -3, -3, -3, -3, -2, -2, -2, -2,
1514 -2, -2, -2, -2, -2, -2, -2, -2,
1515 -1, -1, -1, -1, -1, -1, -1, -1,
1516 -1, -1, -1, -1, -1, -1, -1, -1,
1517 -1, -1, -1, -1, -1, -1, -1, 0,
1518 125, 121, 117, 113, 109, 105, 101, 97,
1519 93, 89, 85, 81, 77, 73, 69, 65,
1520 62, 60, 58, 56, 54, 52, 50, 48,
1521 46, 44, 42, 40, 38, 36, 34, 32,
1522 30, 29, 28, 27, 26, 25, 24, 23,
1523 22, 21, 20, 19, 18, 17, 16, 15,
1524 15, 14, 14, 13, 13, 12, 12, 11,
1525 11, 10, 10, 9, 9, 8, 8, 7,
1526 7, 7, 6, 6, 6, 6, 5, 5,
1527 5, 5, 4, 4, 4, 4, 3, 3,
1528 3, 3, 3, 3, 2, 2, 2, 2,
1529 2, 2, 2, 2, 1, 1, 1, 1,
1530 1, 1, 1, 1, 1, 1, 1, 1,
1531 0, 0, 0, 0, 0, 0, 0, 0,
1532 0, 0, 0, 0, 0, 0, 0, 0,
1533 0, 0, 0, 0, 0, 0, 0, 0
1538 char dmasound_alaw2dma8[] = {
1539 -22, -21, -24, -23, -18, -17, -20, -19,
1540 -30, -29, -32, -31, -26, -25, -28, -27,
1541 -11, -11, -12, -12, -9, -9, -10, -10,
1542 -15, -15, -16, -16, -13, -13, -14, -14,
1543 -86, -82, -94, -90, -70, -66, -78, -74,
1544 -118, -114, -126, -122, -102, -98, -110, -106,
1545 -43, -41, -47, -45, -35, -33, -39, -37,
1546 -59, -57, -63, -61, -51, -49, -55, -53,
1547 -2, -2, -2, -2, -2, -2, -2, -2,
1548 -2, -2, -2, -2, -2, -2, -2, -2,
1549 -1, -1, -1, -1, -1, -1, -1, -1,
1550 -1, -1, -1, -1, -1, -1, -1, -1,
1551 -6, -6, -6, -6, -5, -5, -5, -5,
1552 -8, -8, -8, -8, -7, -7, -7, -7,
1553 -3, -3, -3, -3, -3, -3, -3, -3,
1554 -4, -4, -4, -4, -4, -4, -4, -4,
1555 21, 20, 23, 22, 17, 16, 19, 18,
1556 29, 28, 31, 30, 25, 24, 27, 26,
1557 10, 10, 11, 11, 8, 8, 9, 9,
1558 14, 14, 15, 15, 12, 12, 13, 13,
1559 86, 82, 94, 90, 70, 66, 78, 74,
1560 118, 114, 126, 122, 102, 98, 110, 106,
1561 43, 41, 47, 45, 35, 33, 39, 37,
1562 59, 57, 63, 61, 51, 49, 55, 53,
1563 1, 1, 1, 1, 1, 1, 1, 1,
1564 1, 1, 1, 1, 1, 1, 1, 1,
1565 0, 0, 0, 0, 0, 0, 0, 0,
1566 0, 0, 0, 0, 0, 0, 0, 0,
1567 5, 5, 5, 5, 4, 4, 4, 4,
1568 7, 7, 7, 7, 6, 6, 6, 6,
1569 2, 2, 2, 2, 2, 2, 2, 2,
1570 3, 3, 3, 3, 3, 3, 3, 3
1572 #endif /* HAS_8BIT_TABLES */
1575 * Visible symbols for modules
1578 EXPORT_SYMBOL(dmasound);
1579 EXPORT_SYMBOL(dmasound_init);
1581 EXPORT_SYMBOL(dmasound_deinit);
1583 EXPORT_SYMBOL(dmasound_write_sq);
1584 EXPORT_SYMBOL(dmasound_catchRadius);
1585 #ifdef HAS_8BIT_TABLES
1586 EXPORT_SYMBOL(dmasound_ulaw2dma8);
1587 EXPORT_SYMBOL(dmasound_alaw2dma8);