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