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/smp_lock.h>
186 #include <asm/uaccess.h>
188 #include "dmasound.h"
190 #define DMASOUND_CORE_REVISION 1
191 #define DMASOUND_CORE_EDITION 6
197 int dmasound_catchRadius = 0;
198 module_param(dmasound_catchRadius, int, 0);
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);
205 MODULE_LICENSE("GPL");
208 static int sq_unit = -1;
209 static int mixer_unit = -1;
210 static int state_unit = -1;
211 static int irq_installed;
214 /* control over who can modify resources shared between play/record */
215 static fmode_t shared_resource_owner;
216 static int shared_resources_initialised;
222 struct sound_settings dmasound = {
223 .lock = __SPIN_LOCK_UNLOCKED(dmasound.lock)
226 static inline void sound_silence(void)
228 dmasound.mach.silence(); /* _MUST_ stop DMA */
231 static inline int sound_set_format(int format)
233 return dmasound.mach.setFormat(format);
237 static int sound_set_speed(int speed)
240 return dmasound.soft.speed;
242 /* trap out-of-range speed settings.
243 at present we allow (arbitrarily) low rates - using soft
244 up-conversion - but we can't allow > max because there is
245 no soft down-conversion.
247 if (dmasound.mach.max_dsp_speed &&
248 (speed > dmasound.mach.max_dsp_speed))
249 speed = dmasound.mach.max_dsp_speed ;
251 dmasound.soft.speed = speed;
253 if (dmasound.minDev == SND_DEV_DSP)
254 dmasound.dsp.speed = dmasound.soft.speed;
256 return dmasound.soft.speed;
259 static int sound_set_stereo(int stereo)
262 return dmasound.soft.stereo;
264 stereo = !!stereo; /* should be 0 or 1 now */
266 dmasound.soft.stereo = stereo;
267 if (dmasound.minDev == SND_DEV_DSP)
268 dmasound.dsp.stereo = stereo;
273 static ssize_t sound_copy_translate(TRANS *trans, const u_char __user *userPtr,
274 size_t userCount, u_char frame[],
275 ssize_t *frameUsed, ssize_t frameLeft)
277 ssize_t (*ct_func)(const u_char __user *, size_t, u_char *, ssize_t *, ssize_t);
279 switch (dmasound.soft.format) {
281 ct_func = trans->ct_ulaw;
284 ct_func = trans->ct_alaw;
287 ct_func = trans->ct_s8;
290 ct_func = trans->ct_u8;
293 ct_func = trans->ct_s16be;
296 ct_func = trans->ct_u16be;
299 ct_func = trans->ct_s16le;
302 ct_func = trans->ct_u16le;
307 /* if the user has requested a non-existent translation don't try
308 to call it but just return 0 bytes moved
311 return ct_func(userPtr, userCount, frame, frameUsed, frameLeft);
316 * /dev/mixer abstraction
324 static int mixer_open(struct inode *inode, struct file *file)
327 if (!try_module_get(dmasound.mach.owner)) {
336 static int mixer_release(struct inode *inode, struct file *file)
340 module_put(dmasound.mach.owner);
344 static int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
347 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
348 mixer.modify_counter++;
351 return IOCTL_OUT(arg, SOUND_VERSION);
352 case SOUND_MIXER_INFO:
355 memset(&info, 0, sizeof(info));
356 strlcpy(info.id, dmasound.mach.name2, sizeof(info.id));
357 strlcpy(info.name, dmasound.mach.name2, sizeof(info.name));
358 info.modify_counter = mixer.modify_counter;
359 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
364 if (dmasound.mach.mixer_ioctl)
365 return dmasound.mach.mixer_ioctl(cmd, arg);
369 static const struct file_operations mixer_fops =
371 .owner = THIS_MODULE,
373 .ioctl = mixer_ioctl,
375 .release = mixer_release,
378 static void mixer_init(void)
383 mixer_unit = register_sound_mixer(&mixer_fops, -1);
390 if (dmasound.mach.mixer_init)
391 dmasound.mach.mixer_init();
396 * Sound queue stuff, the heart of the driver
399 struct sound_queue dmasound_write_sq;
400 static void sq_reset_output(void) ;
402 static int sq_allocate_buffers(struct sound_queue *sq, int num, int size)
410 sq->buffers = kmalloc (num * sizeof(char *), GFP_KERNEL);
413 for (i = 0; i < num; i++) {
414 sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL);
415 if (!sq->buffers[i]) {
417 dmasound.mach.dma_free(sq->buffers[i], size);
426 static void sq_release_buffers(struct sound_queue *sq)
431 for (i = 0; i < sq->numBufs; i++)
432 dmasound.mach.dma_free(sq->buffers[i], sq->bufSize);
439 static int sq_setup(struct sound_queue *sq)
441 int (*setup_func)(void) = NULL;
444 if (sq->locked) { /* are we already set? - and not changeable */
445 #ifdef DEBUG_DMASOUND
446 printk("dmasound_core: tried to sq_setup a locked queue\n") ;
450 sq->locked = 1 ; /* don't think we have a race prob. here _check_ */
452 /* make sure that the parameters are set up
453 This should have been done already...
456 dmasound.mach.init();
458 /* OK. If the user has set fragment parameters explicitly, then we
459 should leave them alone... as long as they are valid.
460 Invalid user fragment params can occur if we allow the whole buffer
461 to be used when the user requests the fragments sizes (with no soft
462 x-lation) and then the user subsequently sets a soft x-lation that
463 requires increased internal buffering.
465 Othwerwise (if the user did not set them) OSS says that we should
466 select frag params on the basis of 0.5 s output & 0.1 s input
467 latency. (TODO. For now we will copy in the defaults.)
470 if (sq->user_frags <= 0) {
471 sq->max_count = sq->numBufs ;
472 sq->max_active = sq->numBufs ;
473 sq->block_size = sq->bufSize;
474 /* set up the user info */
475 sq->user_frags = sq->numBufs ;
476 sq->user_frag_size = sq->bufSize ;
477 sq->user_frag_size *=
478 (dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
479 sq->user_frag_size /=
480 (dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
482 /* work out requested block size */
483 sq->block_size = sq->user_frag_size ;
485 (dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
487 (dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
488 /* the user wants to write frag-size chunks */
489 sq->block_size *= dmasound.hard.speed ;
490 sq->block_size /= dmasound.soft.speed ;
491 /* this only works for size values which are powers of 2 */
493 (dmasound.hard.size * (dmasound.hard.stereo+1))/8 ;
494 sq->block_size += (hard_frame - 1) ;
495 sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */
496 /* let's just check for obvious mistakes */
497 if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) {
498 #ifdef DEBUG_DMASOUND
499 printk("dmasound_core: invalid frag size (user set %d)\n", sq->user_frag_size) ;
501 sq->block_size = sq->bufSize ;
503 if ( sq->user_frags <= sq->numBufs ) {
504 sq->max_count = sq->user_frags ;
505 /* if user has set max_active - then use it */
506 sq->max_active = (sq->max_active <= sq->max_count) ?
507 sq->max_active : sq->max_count ;
509 #ifdef DEBUG_DMASOUND
510 printk("dmasound_core: invalid frag count (user set %d)\n", sq->user_frags) ;
513 sq->max_active = sq->numBufs ;
516 sq->front = sq->count = sq->rear_size = 0;
520 if (sq == &write_sq) {
522 setup_func = dmasound.mach.write_sq_setup;
529 static inline void sq_play(void)
531 dmasound.mach.play();
534 static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft,
537 ssize_t uWritten = 0;
539 ssize_t uUsed = 0, bUsed, bLeft;
540 unsigned long flags ;
542 /* ++TeSche: Is something like this necessary?
543 * Hey, that's an honest question! Or does any other part of the
544 * filesystem already checks this situation? I really don't know.
549 /* implement any changes we have made to the soft/hard params.
550 this is not satisfactory really, all we have done up to now is to
551 say what we would like - there hasn't been any real checking of capability
554 if (shared_resources_initialised == 0) {
555 dmasound.mach.init() ;
556 shared_resources_initialised = 1 ;
559 /* set up the sq if it is not already done. This may seem a dumb place
560 to do it - but it is what OSS requires. It means that write() can
561 return memory allocation errors. To avoid this possibility use the
562 GETBLKSIZE or GETOSPACE ioctls (after you've fiddled with all the
563 params you want to change) - these ioctls also force the setup.
566 if (write_sq.locked == 0) {
567 if ((uWritten = sq_setup(&write_sq)) < 0) return uWritten ;
571 /* FIXME: I think that this may be the wrong behaviour when we get strapped
572 for time and the cpu is close to being (or actually) behind in sending data.
573 - because we've lost the time that the N samples, already in the buffer,
574 would have given us to get here with the next lot from the user.
576 /* The interrupt doesn't start to play the last, incomplete frame.
577 * Thus we can append to it without disabling the interrupts! (Note
578 * also that write_sq.rear isn't affected by the interrupt.)
581 /* as of 1.6 this behaviour changes if SNDCTL_DSP_POST has been issued:
582 this will mimic the behaviour of syncing and allow the sq_play() to
583 queue a partial fragment. Since sq_play() may/will be called from
584 the IRQ handler - at least on Pmac we have to deal with it.
585 The strategy - possibly not optimum - is to kill _POST status if we
586 get here. This seems, at least, reasonable - in the sense that POST
587 is supposed to indicate that we might not write before the queue
588 is drained - and if we get here in time then it does not apply.
591 spin_lock_irqsave(&dmasound.lock, flags);
592 write_sq.syncing &= ~2 ; /* take out POST status */
593 spin_unlock_irqrestore(&dmasound.lock, flags);
595 if (write_sq.count > 0 &&
596 (bLeft = write_sq.block_size-write_sq.rear_size) > 0) {
597 dest = write_sq.buffers[write_sq.rear];
598 bUsed = write_sq.rear_size;
599 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
600 dest, &bUsed, bLeft);
605 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
606 write_sq.rear_size = bUsed;
610 while (write_sq.count >= write_sq.max_active) {
612 if (write_sq.non_blocking)
613 return uWritten > 0 ? uWritten : -EAGAIN;
614 SLEEP(write_sq.action_queue);
615 if (signal_pending(current))
616 return uWritten > 0 ? uWritten : -EINTR;
619 /* Here, we can avoid disabling the interrupt by first
620 * copying and translating the data, and then updating
621 * the write_sq variables. Until this is done, the interrupt
622 * won't see the new frame and we can work on it
626 dest = write_sq.buffers[(write_sq.rear+1) % write_sq.max_count];
628 bLeft = write_sq.block_size;
629 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
630 dest, &bUsed, bLeft);
635 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
637 write_sq.rear = (write_sq.rear+1) % write_sq.max_count;
638 write_sq.rear_size = bUsed;
641 } /* uUsed may have been 0 */
645 return uUsed < 0? uUsed: uWritten;
648 static unsigned int sq_poll(struct file *file, struct poll_table_struct *wait)
650 unsigned int mask = 0;
653 if (write_sq.locked == 0) {
654 if ((retVal = sq_setup(&write_sq)) < 0)
658 if (file->f_mode & FMODE_WRITE )
659 poll_wait(file, &write_sq.action_queue, wait);
660 if (file->f_mode & FMODE_WRITE)
661 if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0)
662 mask |= POLLOUT | POLLWRNORM;
667 static inline void sq_init_waitqueue(struct sound_queue *sq)
669 init_waitqueue_head(&sq->action_queue);
670 init_waitqueue_head(&sq->open_queue);
671 init_waitqueue_head(&sq->sync_queue);
675 #if 0 /* blocking open() */
676 static inline void sq_wake_up(struct sound_queue *sq, struct file *file,
679 if (file->f_mode & mode) {
680 sq->busy = 0; /* CHECK: IS THIS OK??? */
681 WAKE_UP(sq->open_queue);
686 static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode,
687 int numbufs, int bufsize)
691 if (file->f_mode & mode) {
693 #if 0 /* blocking open() */
695 if (file->f_flags & O_NONBLOCK)
699 SLEEP(sq->open_queue);
700 if (signal_pending(current))
705 /* OSS manual says we will return EBUSY regardless
711 sq->busy = 1; /* Let's play spot-the-race-condition */
713 /* allocate the default number & size of buffers.
714 (i.e. specified in _setup() or as module params)
715 can't be changed at the moment - but _could_ be perhaps
716 in the setfragments ioctl.
718 if (( rc = sq_allocate_buffers(sq, numbufs, bufsize))) {
719 #if 0 /* blocking open() */
720 sq_wake_up(sq, file, mode);
727 sq->non_blocking = file->f_flags & O_NONBLOCK;
732 #define write_sq_init_waitqueue() sq_init_waitqueue(&write_sq)
733 #if 0 /* blocking open() */
734 #define write_sq_wake_up(file) sq_wake_up(&write_sq, file, FMODE_WRITE)
736 #define write_sq_release_buffers() sq_release_buffers(&write_sq)
737 #define write_sq_open(file) \
738 sq_open2(&write_sq, file, FMODE_WRITE, numWriteBufs, writeBufSize )
740 static int sq_open(struct inode *inode, struct file *file)
745 if (!try_module_get(dmasound.mach.owner)) {
750 rc = write_sq_open(file); /* checks the f_mode */
753 if (file->f_mode & FMODE_READ) {
754 /* TODO: if O_RDWR, release any resources grabbed by write part */
755 rc = -ENXIO ; /* I think this is what is required by open(2) */
759 if (dmasound.mach.sq_open)
760 dmasound.mach.sq_open(file->f_mode);
762 /* CHECK whether this is sensible - in the case that dsp0 could be opened
763 O_RDONLY and dsp1 could be opened O_WRONLY
766 dmasound.minDev = iminor(inode) & 0x0f;
768 /* OK. - we should make some attempt at consistency. At least the H'ware
769 options should be set with a valid mode. We will make it that the LL
770 driver must supply defaults for hard & soft params.
773 if (shared_resource_owner == 0) {
774 /* you can make this AFMT_U8/mono/8K if you want to mimic old
775 OSS behaviour - while we still have soft translations ;-) */
776 dmasound.soft = dmasound.mach.default_soft ;
777 dmasound.dsp = dmasound.mach.default_soft ;
778 dmasound.hard = dmasound.mach.default_hard ;
781 #ifndef DMASOUND_STRICT_OSS_COMPLIANCE
782 /* none of the current LL drivers can actually do this "native" at the moment
783 OSS does not really require us to supply /dev/audio if we can't do it.
785 if (dmasound.minDev == SND_DEV_AUDIO) {
786 sound_set_speed(8000);
788 sound_set_format(AFMT_MU_LAW);
794 module_put(dmasound.mach.owner);
799 static void sq_reset_output(void)
801 sound_silence(); /* this _must_ stop DMA, we might be about to lose the buffers */
804 write_sq.rear_size = 0;
805 /* write_sq.front = (write_sq.rear+1) % write_sq.max_count;*/
807 write_sq.rear = -1 ; /* same as for set-up */
809 /* OK - we can unlock the parameters and fragment settings */
810 write_sq.locked = 0 ;
811 write_sq.user_frags = 0 ;
812 write_sq.user_frag_size = 0 ;
815 static void sq_reset(void)
818 /* we could consider resetting the shared_resources_owner here... but I
819 think it is probably still rather non-obvious to application writer
822 /* we release everything else though */
823 shared_resources_initialised = 0 ;
826 static int sq_fsync(struct file *filp, struct dentry *dentry)
831 write_sq.syncing |= 1;
832 sq_play(); /* there may be an incomplete frame waiting */
834 while (write_sq.active) {
835 SLEEP(write_sq.sync_queue);
836 if (signal_pending(current)) {
837 /* While waiting for audio output to drain, an
838 * interrupt occurred. Stop audio output immediately
839 * and clear the queue. */
845 printk(KERN_WARNING "dmasound: Timeout draining output\n");
852 /* flag no sync regardless of whether we had a DSP_POST or not */
853 write_sq.syncing = 0 ;
857 static int sq_release(struct inode *inode, struct file *file)
863 if (file->f_mode & FMODE_WRITE) {
865 rc = sq_fsync(file, file->f_path.dentry);
867 sq_reset_output() ; /* make sure dma is stopped and all is quiet */
868 write_sq_release_buffers();
872 if (file->f_mode & shared_resource_owner) { /* it's us that has them */
873 shared_resource_owner = 0 ;
874 shared_resources_initialised = 0 ;
875 dmasound.hard = dmasound.mach.default_hard ;
878 module_put(dmasound.mach.owner);
880 #if 0 /* blocking open() */
881 /* Wake up a process waiting for the queue being released.
882 * Note: There may be several processes waiting for a call
883 * to open() returning. */
885 /* Iain: hmm I don't understand this next comment ... */
886 /* There is probably a DOS atack here. They change the mode flag. */
887 /* XXX add check here,*/
888 read_sq_wake_up(file); /* checks f_mode */
889 write_sq_wake_up(file); /* checks f_mode */
890 #endif /* blocking open() */
897 /* here we see if we have a right to modify format, channels, size and so on
898 if no-one else has claimed it already then we do...
900 TODO: We might change this to mask O_RDWR such that only one or the other channel
901 is the owner - if we have problems.
904 static int shared_resources_are_mine(fmode_t md)
906 if (shared_resource_owner)
907 return (shared_resource_owner & md) != 0;
909 shared_resource_owner = md ;
914 /* if either queue is locked we must deny the right to change shared params
917 static int queues_are_quiescent(void)
924 /* check and set a queue's fragments per user's wishes...
925 we will check against the pre-defined literals and the actual sizes.
926 This is a bit fraught - because soft translations can mess with our
927 buffer requirements *after* this call - OSS says "call setfrags first"
930 /* It is possible to replace all the -EINVAL returns with an override that
931 just puts the allowable value in. This may be what many OSS apps require
934 static int set_queue_frags(struct sound_queue *sq, int bufs, int size)
937 #ifdef DEBUG_DMASOUND
938 printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
943 if ((size < MIN_FRAG_SIZE) || (size > MAX_FRAG_SIZE))
945 size = (1<<size) ; /* now in bytes */
946 if (size > sq->bufSize)
947 return -EINVAL ; /* this might still not work */
951 if (bufs > sq->numBufs) /* the user is allowed say "don't care" with 0x7fff */
954 /* there is, currently, no way to specify max_active separately
955 from max_count. This could be a LL driver issue - I guess
956 if there is a requirement for these values to be different then
957 we will have to pass that info. up to this level.
960 sq->max_active = bufs ;
961 sq->user_frag_size = size ;
966 static int sq_ioctl(struct inode *inode, struct file *file, u_int cmd,
976 case SNDCTL_DSP_RESET:
980 case SNDCTL_DSP_GETFMTS:
981 fmt = dmasound.mach.hardware_afmts ; /* this is what OSS says.. */
982 return IOCTL_OUT(arg, fmt);
984 case SNDCTL_DSP_GETBLKSIZE:
985 /* this should tell the caller about bytes that the app can
986 read/write - the app doesn't care about our internal buffers.
987 We force sq_setup() here as per OSS 1.1 (which should
988 compute the values necessary).
989 Since there is no mechanism to specify read/write separately, for
990 fds opened O_RDWR, the write_sq values will, arbitrarily, overwrite
994 if (file->f_mode & FMODE_WRITE) {
995 if ( !write_sq.locked )
996 sq_setup(&write_sq) ;
997 size = write_sq.user_frag_size ;
999 return IOCTL_OUT(arg, size);
1001 case SNDCTL_DSP_POST:
1002 /* all we are going to do is to tell the LL that any
1003 partial frags can be queued for output.
1004 The LL will have to clear this flag when last output
1007 write_sq.syncing |= 0x2 ;
1010 case SNDCTL_DSP_SYNC:
1011 /* This call, effectively, has the same behaviour as SNDCTL_DSP_RESET
1012 except that it waits for output to finish before resetting
1013 everything - read, however, is killed imediately.
1016 if (file->f_mode & FMODE_WRITE) {
1017 result = sq_fsync(file, file->f_path.dentry);
1020 /* if we are the shared resource owner then release them */
1021 if (file->f_mode & shared_resource_owner)
1022 shared_resources_initialised = 0 ;
1025 case SOUND_PCM_READ_RATE:
1026 return IOCTL_OUT(arg, dmasound.soft.speed);
1027 case SNDCTL_DSP_SPEED:
1028 /* changing this on the fly will have weird effects on the sound.
1029 Where there are rate conversions implemented in soft form - it
1030 will cause the _ctx_xxx() functions to be substituted.
1031 However, there doesn't appear to be any reason to dis-allow it from
1034 if (shared_resources_are_mine(file->f_mode)) {
1035 IOCTL_IN(arg, data);
1036 data = sound_set_speed(data) ;
1037 shared_resources_initialised = 0 ;
1038 return IOCTL_OUT(arg, data);
1042 /* OSS says these next 4 actions are undefined when the device is
1043 busy/active - we will just return -EINVAL.
1044 To be allowed to change one - (a) you have to own the right
1045 (b) the queue(s) must be quiescent
1047 case SNDCTL_DSP_STEREO:
1048 if (shared_resources_are_mine(file->f_mode) &&
1049 queues_are_quiescent()) {
1050 IOCTL_IN(arg, data);
1051 shared_resources_initialised = 0 ;
1052 return IOCTL_OUT(arg, sound_set_stereo(data));
1056 case SOUND_PCM_WRITE_CHANNELS:
1057 if (shared_resources_are_mine(file->f_mode) &&
1058 queues_are_quiescent()) {
1059 IOCTL_IN(arg, data);
1060 /* the user might ask for 20 channels, we will return 1 or 2 */
1061 shared_resources_initialised = 0 ;
1062 return IOCTL_OUT(arg, sound_set_stereo(data-1)+1);
1066 case SNDCTL_DSP_SETFMT:
1067 if (shared_resources_are_mine(file->f_mode) &&
1068 queues_are_quiescent()) {
1070 IOCTL_IN(arg, data);
1071 shared_resources_initialised = 0 ;
1072 format = sound_set_format(data);
1073 result = IOCTL_OUT(arg, format);
1076 if (format != data && data != AFMT_QUERY)
1081 case SNDCTL_DSP_SUBDIVIDE:
1083 case SNDCTL_DSP_SETFRAGMENT:
1084 /* we can do this independently for the two queues - with the
1085 proviso that for fds opened O_RDWR we cannot separate the
1086 actions and both queues will be set per the last call.
1087 NOTE: this does *NOT* actually set the queue up - merely
1088 registers our intentions.
1090 IOCTL_IN(arg, data);
1092 nbufs = (data >> 16) & 0x7fff ; /* 0x7fff is 'use maximum' */
1093 size = data & 0xffff;
1094 if (file->f_mode & FMODE_WRITE) {
1095 result = set_queue_frags(&write_sq, nbufs, size) ;
1099 /* NOTE: this return value is irrelevant - OSS specifically says that
1100 the value is 'random' and that the user _must_ check the actual
1101 frags values using SNDCTL_DSP_GETBLKSIZE or similar */
1102 return IOCTL_OUT(arg, data);
1104 case SNDCTL_DSP_GETOSPACE:
1107 if (file->f_mode & FMODE_WRITE) {
1108 if ( !write_sq.locked )
1109 sq_setup(&write_sq) ;
1110 info.fragments = write_sq.max_active - write_sq.count;
1111 info.fragstotal = write_sq.max_active;
1112 info.fragsize = write_sq.user_frag_size;
1113 info.bytes = info.fragments * info.fragsize;
1114 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
1120 case SNDCTL_DSP_GETCAPS:
1121 val = dmasound.mach.capabilities & 0xffffff00;
1122 return IOCTL_OUT(arg,val);
1125 return mixer_ioctl(inode, file, cmd, arg);
1130 static const struct file_operations sq_fops =
1132 .owner = THIS_MODULE,
1133 .llseek = no_llseek,
1138 .release = sq_release,
1141 static int sq_init(void)
1143 const struct file_operations *fops = &sq_fops;
1148 sq_unit = register_sound_dsp(fops, -1);
1150 printk(KERN_ERR "dmasound_core: couldn't register fops\n") ;
1154 write_sq_init_waitqueue();
1156 /* These parameters will be restored for every clean open()
1157 * in the case of multiple open()s (e.g. dsp0 & dsp1) they
1158 * will be set so long as the shared resources have no owner.
1161 if (shared_resource_owner == 0) {
1162 dmasound.soft = dmasound.mach.default_soft ;
1163 dmasound.hard = dmasound.mach.default_hard ;
1164 dmasound.dsp = dmasound.mach.default_soft ;
1165 shared_resources_initialised = 0 ;
1175 /* we allow more space for record-enabled because there are extra output lines.
1176 the number here must include the amount we are prepared to give to the low-level
1180 #define STAT_BUFF_LEN 768
1182 /* this is how much space we will allow the low-level driver to use
1183 in the stat buffer. Currently, 2 * (80 character line + <NL>).
1184 We do not police this (it is up to the ll driver to be honest).
1187 #define LOW_LEVEL_STAT_ALLOC 162
1191 char buf[STAT_BUFF_LEN]; /* state.buf should not overflow! */
1195 /* publish this function for use by low-level code, if required */
1197 static char *get_afmt_string(int afmt)
1207 return "unsigned 8 bit";
1210 return "signed 8 bit";
1213 return "signed 16 bit BE";
1216 return "unsigned 16 bit BE";
1219 return "signed 16 bit LE";
1222 return "unsigned 16 bit LE";
1225 return "format not set" ;
1230 return "ERROR: Unsupported AFMT_XXXX code" ;
1233 static int state_open(struct inode *inode, struct file *file)
1235 char *buffer = state.buf;
1245 if (!try_module_get(dmasound.mach.owner))
1251 len += sprintf(buffer+len, "%sDMA sound driver rev %03d :\n",
1252 dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1253 ((dmasound.mach.version>>8) & 0x0f));
1254 len += sprintf(buffer+len,
1255 "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1256 DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1257 (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1259 /* call the low-level module to fill in any stat info. that it has
1260 if present. Maximum buffer usage is specified.
1263 if (dmasound.mach.state_info)
1264 len += dmasound.mach.state_info(buffer+len,
1265 (size_t) LOW_LEVEL_STAT_ALLOC) ;
1267 /* make usage of the state buffer as deterministic as poss.
1268 exceptional conditions could cause overrun - and this is flagged as
1272 /* formats and settings */
1274 len += sprintf(buffer+len,"\t\t === Formats & settings ===\n") ;
1275 len += sprintf(buffer+len,"Parameter %20s%20s\n","soft","hard") ;
1276 len += sprintf(buffer+len,"Format :%20s%20s\n",
1277 get_afmt_string(dmasound.soft.format),
1278 get_afmt_string(dmasound.hard.format));
1280 len += sprintf(buffer+len,"Samp Rate:%14d s/sec%14d s/sec\n",
1281 dmasound.soft.speed, dmasound.hard.speed);
1283 len += sprintf(buffer+len,"Channels :%20s%20s\n",
1284 dmasound.soft.stereo ? "stereo" : "mono",
1285 dmasound.hard.stereo ? "stereo" : "mono" );
1287 /* sound queue status */
1289 len += sprintf(buffer+len,"\t\t === Sound Queue status ===\n");
1290 len += sprintf(buffer+len,"Allocated:%8s%6s\n","Buffers","Size") ;
1291 len += sprintf(buffer+len,"%9s:%8d%6d\n",
1292 "write", write_sq.numBufs, write_sq.bufSize) ;
1293 len += sprintf(buffer+len,
1294 "Current : MaxFrg FragSiz MaxAct Frnt Rear "
1295 "Cnt RrSize A B S L xruns\n") ;
1296 len += sprintf(buffer+len,"%9s:%7d%8d%7d%5d%5d%4d%7d%2d%2d%2d%2d%7d\n",
1297 "write", write_sq.max_count, write_sq.block_size,
1298 write_sq.max_active, write_sq.front, write_sq.rear,
1299 write_sq.count, write_sq.rear_size, write_sq.active,
1300 write_sq.busy, write_sq.syncing, write_sq.locked, write_sq.xruns) ;
1301 #ifdef DEBUG_DMASOUND
1302 printk("dmasound: stat buffer used %d bytes\n", len) ;
1305 if (len >= STAT_BUFF_LEN)
1306 printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
1315 static int state_release(struct inode *inode, struct file *file)
1319 module_put(dmasound.mach.owner);
1324 static ssize_t state_read(struct file *file, char __user *buf, size_t count,
1327 int n = state.len - state.ptr;
1332 if (copy_to_user(buf, &state.buf[state.ptr], n))
1338 static const struct file_operations state_fops = {
1339 .owner = THIS_MODULE,
1340 .llseek = no_llseek,
1343 .release = state_release,
1346 static int state_init(void)
1351 state_unit = register_sound_special(&state_fops, SND_DEV_STATUS);
1362 * This function is called by _one_ chipset-specific driver
1365 int dmasound_init(void)
1373 /* Set up sound queue, /dev/audio and /dev/dsp. */
1375 /* Set default settings. */
1376 if ((res = sq_init()) < 0)
1379 /* Set up /dev/sndstat. */
1380 if ((res = state_init()) < 0)
1383 /* Set up /dev/mixer. */
1386 if (!dmasound.mach.irqinit()) {
1387 printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n");
1394 printk(KERN_INFO "%s DMA sound driver rev %03d installed\n",
1395 dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1396 ((dmasound.mach.version>>8) & 0x0f));
1398 "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1399 DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1400 (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1401 printk(KERN_INFO "Write will use %4d fragments of %7d bytes as default\n",
1402 numWriteBufs, writeBufSize) ;
1408 void dmasound_deinit(void)
1410 if (irq_installed) {
1412 dmasound.mach.irqcleanup();
1416 write_sq_release_buffers();
1418 if (mixer_unit >= 0)
1419 unregister_sound_mixer(mixer_unit);
1420 if (state_unit >= 0)
1421 unregister_sound_special(state_unit);
1423 unregister_sound_dsp(sq_unit);
1428 static int dmasound_setup(char *str)
1432 str = get_options(str, ARRAY_SIZE(ints), ints);
1434 /* check the bootstrap parameter for "dmasound=" */
1436 /* FIXME: other than in the most naive of cases there is no sense in these
1437 * buffers being other than powers of two. This is not checked yet.
1442 if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS))
1443 printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius);
1445 catchRadius = ints[3];
1448 if (ints[1] < MIN_BUFFERS)
1449 printk("dmasound_setup: invalid number of buffers, using default = %d\n", numWriteBufs);
1451 numWriteBufs = ints[1];
1454 if ((size = ints[2]) < 256) /* check for small buffer specs */
1456 if (size < MIN_BUFSIZE || size > MAX_BUFSIZE)
1457 printk("dmasound_setup: invalid write buffer size, using default = %d\n", writeBufSize);
1459 writeBufSize = size;
1463 printk("dmasound_setup: invalid number of arguments\n");
1469 __setup("dmasound=", dmasound_setup);
1471 #endif /* !MODULE */
1477 #ifdef HAS_8BIT_TABLES
1480 char dmasound_ulaw2dma8[] = {
1481 -126, -122, -118, -114, -110, -106, -102, -98,
1482 -94, -90, -86, -82, -78, -74, -70, -66,
1483 -63, -61, -59, -57, -55, -53, -51, -49,
1484 -47, -45, -43, -41, -39, -37, -35, -33,
1485 -31, -30, -29, -28, -27, -26, -25, -24,
1486 -23, -22, -21, -20, -19, -18, -17, -16,
1487 -16, -15, -15, -14, -14, -13, -13, -12,
1488 -12, -11, -11, -10, -10, -9, -9, -8,
1489 -8, -8, -7, -7, -7, -7, -6, -6,
1490 -6, -6, -5, -5, -5, -5, -4, -4,
1491 -4, -4, -4, -4, -3, -3, -3, -3,
1492 -3, -3, -3, -3, -2, -2, -2, -2,
1493 -2, -2, -2, -2, -2, -2, -2, -2,
1494 -1, -1, -1, -1, -1, -1, -1, -1,
1495 -1, -1, -1, -1, -1, -1, -1, -1,
1496 -1, -1, -1, -1, -1, -1, -1, 0,
1497 125, 121, 117, 113, 109, 105, 101, 97,
1498 93, 89, 85, 81, 77, 73, 69, 65,
1499 62, 60, 58, 56, 54, 52, 50, 48,
1500 46, 44, 42, 40, 38, 36, 34, 32,
1501 30, 29, 28, 27, 26, 25, 24, 23,
1502 22, 21, 20, 19, 18, 17, 16, 15,
1503 15, 14, 14, 13, 13, 12, 12, 11,
1504 11, 10, 10, 9, 9, 8, 8, 7,
1505 7, 7, 6, 6, 6, 6, 5, 5,
1506 5, 5, 4, 4, 4, 4, 3, 3,
1507 3, 3, 3, 3, 2, 2, 2, 2,
1508 2, 2, 2, 2, 1, 1, 1, 1,
1509 1, 1, 1, 1, 1, 1, 1, 1,
1510 0, 0, 0, 0, 0, 0, 0, 0,
1511 0, 0, 0, 0, 0, 0, 0, 0,
1512 0, 0, 0, 0, 0, 0, 0, 0
1517 char dmasound_alaw2dma8[] = {
1518 -22, -21, -24, -23, -18, -17, -20, -19,
1519 -30, -29, -32, -31, -26, -25, -28, -27,
1520 -11, -11, -12, -12, -9, -9, -10, -10,
1521 -15, -15, -16, -16, -13, -13, -14, -14,
1522 -86, -82, -94, -90, -70, -66, -78, -74,
1523 -118, -114, -126, -122, -102, -98, -110, -106,
1524 -43, -41, -47, -45, -35, -33, -39, -37,
1525 -59, -57, -63, -61, -51, -49, -55, -53,
1526 -2, -2, -2, -2, -2, -2, -2, -2,
1527 -2, -2, -2, -2, -2, -2, -2, -2,
1528 -1, -1, -1, -1, -1, -1, -1, -1,
1529 -1, -1, -1, -1, -1, -1, -1, -1,
1530 -6, -6, -6, -6, -5, -5, -5, -5,
1531 -8, -8, -8, -8, -7, -7, -7, -7,
1532 -3, -3, -3, -3, -3, -3, -3, -3,
1533 -4, -4, -4, -4, -4, -4, -4, -4,
1534 21, 20, 23, 22, 17, 16, 19, 18,
1535 29, 28, 31, 30, 25, 24, 27, 26,
1536 10, 10, 11, 11, 8, 8, 9, 9,
1537 14, 14, 15, 15, 12, 12, 13, 13,
1538 86, 82, 94, 90, 70, 66, 78, 74,
1539 118, 114, 126, 122, 102, 98, 110, 106,
1540 43, 41, 47, 45, 35, 33, 39, 37,
1541 59, 57, 63, 61, 51, 49, 55, 53,
1542 1, 1, 1, 1, 1, 1, 1, 1,
1543 1, 1, 1, 1, 1, 1, 1, 1,
1544 0, 0, 0, 0, 0, 0, 0, 0,
1545 0, 0, 0, 0, 0, 0, 0, 0,
1546 5, 5, 5, 5, 4, 4, 4, 4,
1547 7, 7, 7, 7, 6, 6, 6, 6,
1548 2, 2, 2, 2, 2, 2, 2, 2,
1549 3, 3, 3, 3, 3, 3, 3, 3
1551 #endif /* HAS_8BIT_TABLES */
1554 * Visible symbols for modules
1557 EXPORT_SYMBOL(dmasound);
1558 EXPORT_SYMBOL(dmasound_init);
1560 EXPORT_SYMBOL(dmasound_deinit);
1562 EXPORT_SYMBOL(dmasound_write_sq);
1563 EXPORT_SYMBOL(dmasound_catchRadius);
1564 #ifdef HAS_8BIT_TABLES
1565 EXPORT_SYMBOL(dmasound_ulaw2dma8);
1566 EXPORT_SYMBOL(dmasound_alaw2dma8);