1 /* 2 * linux/sound/oss/dmasound/dmasound_core.c 3 * 4 * 5 * OSS/Free compatible Atari TT/Falcon and Amiga DMA sound driver for 6 * Linux/m68k 7 * Extended to support Power Macintosh for Linux/ppc by Paul Mackerras 8 * 9 * (c) 1995 by Michael Schlueter & Michael Marte 10 * 11 * Michael Schlueter (michael@duck.syd.de) did the basic structure of the VFS 12 * interface and the u-law to signed byte conversion. 13 * 14 * Michael Marte (marte@informatik.uni-muenchen.de) did the sound queue, 15 * /dev/mixer, /dev/sndstat and complemented the VFS interface. He would like 16 * to thank: 17 * - Michael Schlueter for initial ideas and documentation on the MFP and 18 * the DMA sound hardware. 19 * - Therapy? for their CD 'Troublegum' which really made me rock. 20 * 21 * /dev/sndstat is based on code by Hannu Savolainen, the author of the 22 * VoxWare family of drivers. 23 * 24 * This file is subject to the terms and conditions of the GNU General Public 25 * License. See the file COPYING in the main directory of this archive 26 * for more details. 27 * 28 * History: 29 * 30 * 1995/8/25 First release 31 * 32 * 1995/9/02 Roman Hodek: 33 * - Fixed atari_stram_alloc() call, the timer 34 * programming and several race conditions 35 * 1995/9/14 Roman Hodek: 36 * - After some discussion with Michael Schlueter, 37 * revised the interrupt disabling 38 * - Slightly speeded up U8->S8 translation by using 39 * long operations where possible 40 * - Added 4:3 interpolation for /dev/audio 41 * 42 * 1995/9/20 Torsten Scherer: 43 * - Fixed a bug in sq_write and changed /dev/audio 44 * converting to play at 12517Hz instead of 6258Hz. 45 * 46 * 1995/9/23 Torsten Scherer: 47 * - Changed sq_interrupt() and sq_play() to pre-program 48 * the DMA for another frame while there's still one 49 * running. This allows the IRQ response to be 50 * arbitrarily delayed and playing will still continue. 51 * 52 * 1995/10/14 Guenther Kelleter, Torsten Scherer: 53 * - Better support for Falcon audio (the Falcon doesn't 54 * raise an IRQ at the end of a frame, but at the 55 * beginning instead!). uses 'if (codec_dma)' in lots 56 * of places to simply switch between Falcon and TT 57 * code. 58 * 59 * 1995/11/06 Torsten Scherer: 60 * - Started introducing a hardware abstraction scheme 61 * (may perhaps also serve for Amigas?) 62 * - Can now play samples at almost all frequencies by 63 * means of a more generalized expand routine 64 * - Takes a good deal of care to cut data only at 65 * sample sizes 66 * - Buffer size is now a kernel runtime option 67 * - Implemented fsync() & several minor improvements 68 * Guenther Kelleter: 69 * - Useful hints and bug fixes 70 * - Cross-checked it for Falcons 71 * 72 * 1996/3/9 Geert Uytterhoeven: 73 * - Support added for Amiga, A-law, 16-bit little 74 * endian. 75 * - Unification to drivers/sound/dmasound.c. 76 * 77 * 1996/4/6 Martin Mitchell: 78 * - Updated to 1.3 kernel. 79 * 80 * 1996/6/13 Topi Kanerva: 81 * - Fixed things that were broken (mainly the amiga 82 * 14-bit routines) 83 * - /dev/sndstat shows now the real hardware frequency 84 * - The lowpass filter is disabled by default now 85 * 86 * 1996/9/25 Geert Uytterhoeven: 87 * - Modularization 88 * 89 * 1998/6/10 Andreas Schwab: 90 * - Converted to use sound_core 91 * 92 * 1999/12/28 Richard Zidlicky: 93 * - Added support for Q40 94 * 95 * 2000/2/27 Geert Uytterhoeven: 96 * - Clean up and split the code into 4 parts: 97 * o dmasound_core: machine-independent code 98 * o dmasound_atari: Atari TT and Falcon support 99 * o dmasound_awacs: Apple PowerMac support 100 * o dmasound_paula: Amiga support 101 * 102 * 2000/3/25 Geert Uytterhoeven: 103 * - Integration of dmasound_q40 104 * - Small clean ups 105 * 106 * 2001/01/26 [1.0] Iain Sandoe 107 * - make /dev/sndstat show revision & edition info. 108 * - since dmasound.mach.sq_setup() can fail on pmac 109 * its type has been changed to int and the returns 110 * are checked. 111 * [1.1] - stop missing translations from being called. 112 * 2001/02/08 [1.2] - remove unused translation tables & move machine- 113 * specific tables to low-level. 114 * - return correct info. for SNDCTL_DSP_GETFMTS. 115 * [1.3] - implement SNDCTL_DSP_GETCAPS fully. 116 * [1.4] - make /dev/sndstat text length usage deterministic. 117 * - make /dev/sndstat call to low-level 118 * dmasound.mach.state_info() pass max space to ll driver. 119 * - tidy startup banners and output info. 120 * [1.5] - tidy up a little (removed some unused #defines in 121 * dmasound.h) 122 * - fix up HAS_RECORD conditionalisation. 123 * - add record code in places it is missing... 124 * - change buf-sizes to bytes to allow < 1kb for pmac 125 * if user param entry is < 256 the value is taken to 126 * be in kb > 256 is taken to be in bytes. 127 * - make default buff/frag params conditional on 128 * machine to allow smaller values for pmac. 129 * - made the ioctls, read & write comply with the OSS 130 * rules on setting params. 131 * - added parsing of _setup() params for record. 132 * 2001/04/04 [1.6] - fix bug where sample rates higher than maximum were 133 * being reported as OK. 134 * - fix open() to return -EBUSY as per OSS doc. when 135 * audio is in use - this is independent of O_NOBLOCK. 136 * - fix bug where SNDCTL_DSP_POST was blocking. 137 */ 138 139 /* Record capability notes 30/01/2001: 140 * At present these observations apply only to pmac LL driver (the only one 141 * that can do record, at present). However, if other LL drivers for machines 142 * with record are added they may apply. 143 * 144 * The fragment parameters for the record and play channels are separate. 145 * However, if the driver is opened O_RDWR there is no way (in the current OSS 146 * API) to specify their values independently for the record and playback 147 * channels. Since the only common factor between the input & output is the 148 * sample rate (on pmac) it should be possible to open /dev/dspX O_WRONLY and 149 * /dev/dspY O_RDONLY. The input & output channels could then have different 150 * characteristics (other than the first that sets sample rate claiming the 151 * right to set it for ever). As it stands, the format, channels, number of 152 * bits & sample rate are assumed to be common. In the future perhaps these 153 * should be the responsibility of the LL driver - and then if a card really 154 * does not share items between record & playback they can be specified 155 * separately. 156 */ 157 158 /* Thread-safeness of shared_resources notes: 31/01/2001 159 * If the user opens O_RDWR and then splits record & play between two threads 160 * both of which inherit the fd - and then starts changing things from both 161 * - we will have difficulty telling. 162 * 163 * It's bad application coding - but ... 164 * TODO: think about how to sort this out... without bogging everything down in 165 * semaphores. 166 * 167 * Similarly, the OSS spec says "all changes to parameters must be between 168 * open() and the first read() or write(). - and a bit later on (by 169 * implication) "between SNDCTL_DSP_RESET and the first read() or write() after 170 * it". If the app is multi-threaded and this rule is broken between threads 171 * we will have trouble spotting it - and the fault will be rather obscure :-( 172 * 173 * We will try and put out at least a kmsg if we see it happen... but I think 174 * it will be quite hard to trap it with an -EXXX return... because we can't 175 * see the fault until after the damage is done. 176 */ 177 178 #include <linux/module.h> 179 #include <linux/slab.h> 180 #include <linux/sound.h> 181 #include <linux/init.h> 182 #include <linux/soundcard.h> 183 #include <linux/poll.h> 184 #include <linux/smp_lock.h> 185 186 #include <asm/uaccess.h> 187 188 #include "dmasound.h" 189 190 #define DMASOUND_CORE_REVISION 1 191 #define DMASOUND_CORE_EDITION 6 192 193 /* 194 * Declarations 195 */ 196 197 int dmasound_catchRadius = 0; 198 module_param(dmasound_catchRadius, int, 0); 199 200 static unsigned int numWriteBufs = DEFAULT_N_BUFFERS; 201 module_param(numWriteBufs, int, 0); 202 static unsigned int writeBufSize = DEFAULT_BUFF_SIZE ; /* in bytes */ 203 module_param(writeBufSize, int, 0); 204 205 MODULE_LICENSE("GPL"); 206 207 #ifdef MODULE 208 static int sq_unit = -1; 209 static int mixer_unit = -1; 210 static int state_unit = -1; 211 static int irq_installed; 212 #endif /* MODULE */ 213 214 /* control over who can modify resources shared between play/record */ 215 static fmode_t shared_resource_owner; 216 static int shared_resources_initialised; 217 218 /* 219 * Mid level stuff 220 */ 221 222 struct sound_settings dmasound = { 223 .lock = __SPIN_LOCK_UNLOCKED(dmasound.lock) 224 }; 225 226 static inline void sound_silence(void) 227 { 228 dmasound.mach.silence(); /* _MUST_ stop DMA */ 229 } 230 231 static inline int sound_set_format(int format) 232 { 233 return dmasound.mach.setFormat(format); 234 } 235 236 237 static int sound_set_speed(int speed) 238 { 239 if (speed < 0) 240 return dmasound.soft.speed; 241 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. 246 */ 247 if (dmasound.mach.max_dsp_speed && 248 (speed > dmasound.mach.max_dsp_speed)) 249 speed = dmasound.mach.max_dsp_speed ; 250 251 dmasound.soft.speed = speed; 252 253 if (dmasound.minDev == SND_DEV_DSP) 254 dmasound.dsp.speed = dmasound.soft.speed; 255 256 return dmasound.soft.speed; 257 } 258 259 static int sound_set_stereo(int stereo) 260 { 261 if (stereo < 0) 262 return dmasound.soft.stereo; 263 264 stereo = !!stereo; /* should be 0 or 1 now */ 265 266 dmasound.soft.stereo = stereo; 267 if (dmasound.minDev == SND_DEV_DSP) 268 dmasound.dsp.stereo = stereo; 269 270 return stereo; 271 } 272 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) 276 { 277 ssize_t (*ct_func)(const u_char __user *, size_t, u_char *, ssize_t *, ssize_t); 278 279 switch (dmasound.soft.format) { 280 case AFMT_MU_LAW: 281 ct_func = trans->ct_ulaw; 282 break; 283 case AFMT_A_LAW: 284 ct_func = trans->ct_alaw; 285 break; 286 case AFMT_S8: 287 ct_func = trans->ct_s8; 288 break; 289 case AFMT_U8: 290 ct_func = trans->ct_u8; 291 break; 292 case AFMT_S16_BE: 293 ct_func = trans->ct_s16be; 294 break; 295 case AFMT_U16_BE: 296 ct_func = trans->ct_u16be; 297 break; 298 case AFMT_S16_LE: 299 ct_func = trans->ct_s16le; 300 break; 301 case AFMT_U16_LE: 302 ct_func = trans->ct_u16le; 303 break; 304 default: 305 return 0; 306 } 307 /* if the user has requested a non-existent translation don't try 308 to call it but just return 0 bytes moved 309 */ 310 if (ct_func) 311 return ct_func(userPtr, userCount, frame, frameUsed, frameLeft); 312 return 0; 313 } 314 315 /* 316 * /dev/mixer abstraction 317 */ 318 319 static struct { 320 int busy; 321 int modify_counter; 322 } mixer; 323 324 static int mixer_open(struct inode *inode, struct file *file) 325 { 326 lock_kernel(); 327 if (!try_module_get(dmasound.mach.owner)) { 328 unlock_kernel(); 329 return -ENODEV; 330 } 331 mixer.busy = 1; 332 unlock_kernel(); 333 return 0; 334 } 335 336 static int mixer_release(struct inode *inode, struct file *file) 337 { 338 lock_kernel(); 339 mixer.busy = 0; 340 module_put(dmasound.mach.owner); 341 unlock_kernel(); 342 return 0; 343 } 344 345 static int mixer_ioctl(struct file *file, u_int cmd, u_long arg) 346 { 347 if (_SIOC_DIR(cmd) & _SIOC_WRITE) 348 mixer.modify_counter++; 349 switch (cmd) { 350 case OSS_GETVERSION: 351 return IOCTL_OUT(arg, SOUND_VERSION); 352 case SOUND_MIXER_INFO: 353 { 354 mixer_info 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))) 360 return -EFAULT; 361 return 0; 362 } 363 } 364 if (dmasound.mach.mixer_ioctl) 365 return dmasound.mach.mixer_ioctl(cmd, arg); 366 return -EINVAL; 367 } 368 369 static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) 370 { 371 int ret; 372 373 lock_kernel(); 374 ret = mixer_ioctl(file, cmd, arg); 375 unlock_kernel(); 376 377 return ret; 378 } 379 380 static const struct file_operations mixer_fops = 381 { 382 .owner = THIS_MODULE, 383 .llseek = no_llseek, 384 .unlocked_ioctl = mixer_unlocked_ioctl, 385 .open = mixer_open, 386 .release = mixer_release, 387 }; 388 389 static void mixer_init(void) 390 { 391 #ifndef MODULE 392 int mixer_unit; 393 #endif 394 mixer_unit = register_sound_mixer(&mixer_fops, -1); 395 if (mixer_unit < 0) 396 return; 397 398 mixer.busy = 0; 399 dmasound.treble = 0; 400 dmasound.bass = 0; 401 if (dmasound.mach.mixer_init) 402 dmasound.mach.mixer_init(); 403 } 404 405 406 /* 407 * Sound queue stuff, the heart of the driver 408 */ 409 410 struct sound_queue dmasound_write_sq; 411 static void sq_reset_output(void) ; 412 413 static int sq_allocate_buffers(struct sound_queue *sq, int num, int size) 414 { 415 int i; 416 417 if (sq->buffers) 418 return 0; 419 sq->numBufs = num; 420 sq->bufSize = size; 421 sq->buffers = kmalloc (num * sizeof(char *), GFP_KERNEL); 422 if (!sq->buffers) 423 return -ENOMEM; 424 for (i = 0; i < num; i++) { 425 sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL); 426 if (!sq->buffers[i]) { 427 while (i--) 428 dmasound.mach.dma_free(sq->buffers[i], size); 429 kfree(sq->buffers); 430 sq->buffers = NULL; 431 return -ENOMEM; 432 } 433 } 434 return 0; 435 } 436 437 static void sq_release_buffers(struct sound_queue *sq) 438 { 439 int i; 440 441 if (sq->buffers) { 442 for (i = 0; i < sq->numBufs; i++) 443 dmasound.mach.dma_free(sq->buffers[i], sq->bufSize); 444 kfree(sq->buffers); 445 sq->buffers = NULL; 446 } 447 } 448 449 450 static int sq_setup(struct sound_queue *sq) 451 { 452 int (*setup_func)(void) = NULL; 453 int hard_frame ; 454 455 if (sq->locked) { /* are we already set? - and not changeable */ 456 #ifdef DEBUG_DMASOUND 457 printk("dmasound_core: tried to sq_setup a locked queue\n") ; 458 #endif 459 return -EINVAL ; 460 } 461 sq->locked = 1 ; /* don't think we have a race prob. here _check_ */ 462 463 /* make sure that the parameters are set up 464 This should have been done already... 465 */ 466 467 dmasound.mach.init(); 468 469 /* OK. If the user has set fragment parameters explicitly, then we 470 should leave them alone... as long as they are valid. 471 Invalid user fragment params can occur if we allow the whole buffer 472 to be used when the user requests the fragments sizes (with no soft 473 x-lation) and then the user subsequently sets a soft x-lation that 474 requires increased internal buffering. 475 476 Othwerwise (if the user did not set them) OSS says that we should 477 select frag params on the basis of 0.5 s output & 0.1 s input 478 latency. (TODO. For now we will copy in the defaults.) 479 */ 480 481 if (sq->user_frags <= 0) { 482 sq->max_count = sq->numBufs ; 483 sq->max_active = sq->numBufs ; 484 sq->block_size = sq->bufSize; 485 /* set up the user info */ 486 sq->user_frags = sq->numBufs ; 487 sq->user_frag_size = sq->bufSize ; 488 sq->user_frag_size *= 489 (dmasound.soft.size * (dmasound.soft.stereo+1) ) ; 490 sq->user_frag_size /= 491 (dmasound.hard.size * (dmasound.hard.stereo+1) ) ; 492 } else { 493 /* work out requested block size */ 494 sq->block_size = sq->user_frag_size ; 495 sq->block_size *= 496 (dmasound.hard.size * (dmasound.hard.stereo+1) ) ; 497 sq->block_size /= 498 (dmasound.soft.size * (dmasound.soft.stereo+1) ) ; 499 /* the user wants to write frag-size chunks */ 500 sq->block_size *= dmasound.hard.speed ; 501 sq->block_size /= dmasound.soft.speed ; 502 /* this only works for size values which are powers of 2 */ 503 hard_frame = 504 (dmasound.hard.size * (dmasound.hard.stereo+1))/8 ; 505 sq->block_size += (hard_frame - 1) ; 506 sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */ 507 /* let's just check for obvious mistakes */ 508 if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) { 509 #ifdef DEBUG_DMASOUND 510 printk("dmasound_core: invalid frag size (user set %d)\n", sq->user_frag_size) ; 511 #endif 512 sq->block_size = sq->bufSize ; 513 } 514 if ( sq->user_frags <= sq->numBufs ) { 515 sq->max_count = sq->user_frags ; 516 /* if user has set max_active - then use it */ 517 sq->max_active = (sq->max_active <= sq->max_count) ? 518 sq->max_active : sq->max_count ; 519 } else { 520 #ifdef DEBUG_DMASOUND 521 printk("dmasound_core: invalid frag count (user set %d)\n", sq->user_frags) ; 522 #endif 523 sq->max_count = 524 sq->max_active = sq->numBufs ; 525 } 526 } 527 sq->front = sq->count = sq->rear_size = 0; 528 sq->syncing = 0; 529 sq->active = 0; 530 531 if (sq == &write_sq) { 532 sq->rear = -1; 533 setup_func = dmasound.mach.write_sq_setup; 534 } 535 if (setup_func) 536 return setup_func(); 537 return 0 ; 538 } 539 540 static inline void sq_play(void) 541 { 542 dmasound.mach.play(); 543 } 544 545 static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft, 546 loff_t *ppos) 547 { 548 ssize_t uWritten = 0; 549 u_char *dest; 550 ssize_t uUsed = 0, bUsed, bLeft; 551 unsigned long flags ; 552 553 /* ++TeSche: Is something like this necessary? 554 * Hey, that's an honest question! Or does any other part of the 555 * filesystem already checks this situation? I really don't know. 556 */ 557 if (uLeft == 0) 558 return 0; 559 560 /* implement any changes we have made to the soft/hard params. 561 this is not satisfactory really, all we have done up to now is to 562 say what we would like - there hasn't been any real checking of capability 563 */ 564 565 if (shared_resources_initialised == 0) { 566 dmasound.mach.init() ; 567 shared_resources_initialised = 1 ; 568 } 569 570 /* set up the sq if it is not already done. This may seem a dumb place 571 to do it - but it is what OSS requires. It means that write() can 572 return memory allocation errors. To avoid this possibility use the 573 GETBLKSIZE or GETOSPACE ioctls (after you've fiddled with all the 574 params you want to change) - these ioctls also force the setup. 575 */ 576 577 if (write_sq.locked == 0) { 578 if ((uWritten = sq_setup(&write_sq)) < 0) return uWritten ; 579 uWritten = 0 ; 580 } 581 582 /* FIXME: I think that this may be the wrong behaviour when we get strapped 583 for time and the cpu is close to being (or actually) behind in sending data. 584 - because we've lost the time that the N samples, already in the buffer, 585 would have given us to get here with the next lot from the user. 586 */ 587 /* The interrupt doesn't start to play the last, incomplete frame. 588 * Thus we can append to it without disabling the interrupts! (Note 589 * also that write_sq.rear isn't affected by the interrupt.) 590 */ 591 592 /* as of 1.6 this behaviour changes if SNDCTL_DSP_POST has been issued: 593 this will mimic the behaviour of syncing and allow the sq_play() to 594 queue a partial fragment. Since sq_play() may/will be called from 595 the IRQ handler - at least on Pmac we have to deal with it. 596 The strategy - possibly not optimum - is to kill _POST status if we 597 get here. This seems, at least, reasonable - in the sense that POST 598 is supposed to indicate that we might not write before the queue 599 is drained - and if we get here in time then it does not apply. 600 */ 601 602 spin_lock_irqsave(&dmasound.lock, flags); 603 write_sq.syncing &= ~2 ; /* take out POST status */ 604 spin_unlock_irqrestore(&dmasound.lock, flags); 605 606 if (write_sq.count > 0 && 607 (bLeft = write_sq.block_size-write_sq.rear_size) > 0) { 608 dest = write_sq.buffers[write_sq.rear]; 609 bUsed = write_sq.rear_size; 610 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft, 611 dest, &bUsed, bLeft); 612 if (uUsed <= 0) 613 return uUsed; 614 src += uUsed; 615 uWritten += uUsed; 616 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */ 617 write_sq.rear_size = bUsed; 618 } 619 620 while (uLeft) { 621 while (write_sq.count >= write_sq.max_active) { 622 sq_play(); 623 if (write_sq.non_blocking) 624 return uWritten > 0 ? uWritten : -EAGAIN; 625 SLEEP(write_sq.action_queue); 626 if (signal_pending(current)) 627 return uWritten > 0 ? uWritten : -EINTR; 628 } 629 630 /* Here, we can avoid disabling the interrupt by first 631 * copying and translating the data, and then updating 632 * the write_sq variables. Until this is done, the interrupt 633 * won't see the new frame and we can work on it 634 * undisturbed. 635 */ 636 637 dest = write_sq.buffers[(write_sq.rear+1) % write_sq.max_count]; 638 bUsed = 0; 639 bLeft = write_sq.block_size; 640 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft, 641 dest, &bUsed, bLeft); 642 if (uUsed <= 0) 643 break; 644 src += uUsed; 645 uWritten += uUsed; 646 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */ 647 if (bUsed) { 648 write_sq.rear = (write_sq.rear+1) % write_sq.max_count; 649 write_sq.rear_size = bUsed; 650 write_sq.count++; 651 } 652 } /* uUsed may have been 0 */ 653 654 sq_play(); 655 656 return uUsed < 0? uUsed: uWritten; 657 } 658 659 static unsigned int sq_poll(struct file *file, struct poll_table_struct *wait) 660 { 661 unsigned int mask = 0; 662 int retVal; 663 664 if (write_sq.locked == 0) { 665 if ((retVal = sq_setup(&write_sq)) < 0) 666 return retVal; 667 return 0; 668 } 669 if (file->f_mode & FMODE_WRITE ) 670 poll_wait(file, &write_sq.action_queue, wait); 671 if (file->f_mode & FMODE_WRITE) 672 if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0) 673 mask |= POLLOUT | POLLWRNORM; 674 return mask; 675 676 } 677 678 static inline void sq_init_waitqueue(struct sound_queue *sq) 679 { 680 init_waitqueue_head(&sq->action_queue); 681 init_waitqueue_head(&sq->open_queue); 682 init_waitqueue_head(&sq->sync_queue); 683 sq->busy = 0; 684 } 685 686 #if 0 /* blocking open() */ 687 static inline void sq_wake_up(struct sound_queue *sq, struct file *file, 688 fmode_t mode) 689 { 690 if (file->f_mode & mode) { 691 sq->busy = 0; /* CHECK: IS THIS OK??? */ 692 WAKE_UP(sq->open_queue); 693 } 694 } 695 #endif 696 697 static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode, 698 int numbufs, int bufsize) 699 { 700 int rc = 0; 701 702 if (file->f_mode & mode) { 703 if (sq->busy) { 704 #if 0 /* blocking open() */ 705 rc = -EBUSY; 706 if (file->f_flags & O_NONBLOCK) 707 return rc; 708 rc = -EINTR; 709 while (sq->busy) { 710 SLEEP(sq->open_queue); 711 if (signal_pending(current)) 712 return rc; 713 } 714 rc = 0; 715 #else 716 /* OSS manual says we will return EBUSY regardless 717 of O_NOBLOCK. 718 */ 719 return -EBUSY ; 720 #endif 721 } 722 sq->busy = 1; /* Let's play spot-the-race-condition */ 723 724 /* allocate the default number & size of buffers. 725 (i.e. specified in _setup() or as module params) 726 can't be changed at the moment - but _could_ be perhaps 727 in the setfragments ioctl. 728 */ 729 if (( rc = sq_allocate_buffers(sq, numbufs, bufsize))) { 730 #if 0 /* blocking open() */ 731 sq_wake_up(sq, file, mode); 732 #else 733 sq->busy = 0 ; 734 #endif 735 return rc; 736 } 737 738 sq->non_blocking = file->f_flags & O_NONBLOCK; 739 } 740 return rc; 741 } 742 743 #define write_sq_init_waitqueue() sq_init_waitqueue(&write_sq) 744 #if 0 /* blocking open() */ 745 #define write_sq_wake_up(file) sq_wake_up(&write_sq, file, FMODE_WRITE) 746 #endif 747 #define write_sq_release_buffers() sq_release_buffers(&write_sq) 748 #define write_sq_open(file) \ 749 sq_open2(&write_sq, file, FMODE_WRITE, numWriteBufs, writeBufSize ) 750 751 static int sq_open(struct inode *inode, struct file *file) 752 { 753 int rc; 754 755 lock_kernel(); 756 if (!try_module_get(dmasound.mach.owner)) { 757 unlock_kernel(); 758 return -ENODEV; 759 } 760 761 rc = write_sq_open(file); /* checks the f_mode */ 762 if (rc) 763 goto out; 764 if (file->f_mode & FMODE_READ) { 765 /* TODO: if O_RDWR, release any resources grabbed by write part */ 766 rc = -ENXIO ; /* I think this is what is required by open(2) */ 767 goto out; 768 } 769 770 if (dmasound.mach.sq_open) 771 dmasound.mach.sq_open(file->f_mode); 772 773 /* CHECK whether this is sensible - in the case that dsp0 could be opened 774 O_RDONLY and dsp1 could be opened O_WRONLY 775 */ 776 777 dmasound.minDev = iminor(inode) & 0x0f; 778 779 /* OK. - we should make some attempt at consistency. At least the H'ware 780 options should be set with a valid mode. We will make it that the LL 781 driver must supply defaults for hard & soft params. 782 */ 783 784 if (shared_resource_owner == 0) { 785 /* you can make this AFMT_U8/mono/8K if you want to mimic old 786 OSS behaviour - while we still have soft translations ;-) */ 787 dmasound.soft = dmasound.mach.default_soft ; 788 dmasound.dsp = dmasound.mach.default_soft ; 789 dmasound.hard = dmasound.mach.default_hard ; 790 } 791 792 #ifndef DMASOUND_STRICT_OSS_COMPLIANCE 793 /* none of the current LL drivers can actually do this "native" at the moment 794 OSS does not really require us to supply /dev/audio if we can't do it. 795 */ 796 if (dmasound.minDev == SND_DEV_AUDIO) { 797 sound_set_speed(8000); 798 sound_set_stereo(0); 799 sound_set_format(AFMT_MU_LAW); 800 } 801 #endif 802 unlock_kernel(); 803 return 0; 804 out: 805 module_put(dmasound.mach.owner); 806 unlock_kernel(); 807 return rc; 808 } 809 810 static void sq_reset_output(void) 811 { 812 sound_silence(); /* this _must_ stop DMA, we might be about to lose the buffers */ 813 write_sq.active = 0; 814 write_sq.count = 0; 815 write_sq.rear_size = 0; 816 /* write_sq.front = (write_sq.rear+1) % write_sq.max_count;*/ 817 write_sq.front = 0 ; 818 write_sq.rear = -1 ; /* same as for set-up */ 819 820 /* OK - we can unlock the parameters and fragment settings */ 821 write_sq.locked = 0 ; 822 write_sq.user_frags = 0 ; 823 write_sq.user_frag_size = 0 ; 824 } 825 826 static void sq_reset(void) 827 { 828 sq_reset_output() ; 829 /* we could consider resetting the shared_resources_owner here... but I 830 think it is probably still rather non-obvious to application writer 831 */ 832 833 /* we release everything else though */ 834 shared_resources_initialised = 0 ; 835 } 836 837 static int sq_fsync(struct file *filp, struct dentry *dentry) 838 { 839 int rc = 0; 840 int timeout = 5; 841 842 write_sq.syncing |= 1; 843 sq_play(); /* there may be an incomplete frame waiting */ 844 845 while (write_sq.active) { 846 SLEEP(write_sq.sync_queue); 847 if (signal_pending(current)) { 848 /* While waiting for audio output to drain, an 849 * interrupt occurred. Stop audio output immediately 850 * and clear the queue. */ 851 sq_reset_output(); 852 rc = -EINTR; 853 break; 854 } 855 if (!--timeout) { 856 printk(KERN_WARNING "dmasound: Timeout draining output\n"); 857 sq_reset_output(); 858 rc = -EIO; 859 break; 860 } 861 } 862 863 /* flag no sync regardless of whether we had a DSP_POST or not */ 864 write_sq.syncing = 0 ; 865 return rc; 866 } 867 868 static int sq_release(struct inode *inode, struct file *file) 869 { 870 int rc = 0; 871 872 lock_kernel(); 873 874 if (file->f_mode & FMODE_WRITE) { 875 if (write_sq.busy) 876 rc = sq_fsync(file, file->f_path.dentry); 877 878 sq_reset_output() ; /* make sure dma is stopped and all is quiet */ 879 write_sq_release_buffers(); 880 write_sq.busy = 0; 881 } 882 883 if (file->f_mode & shared_resource_owner) { /* it's us that has them */ 884 shared_resource_owner = 0 ; 885 shared_resources_initialised = 0 ; 886 dmasound.hard = dmasound.mach.default_hard ; 887 } 888 889 module_put(dmasound.mach.owner); 890 891 #if 0 /* blocking open() */ 892 /* Wake up a process waiting for the queue being released. 893 * Note: There may be several processes waiting for a call 894 * to open() returning. */ 895 896 /* Iain: hmm I don't understand this next comment ... */ 897 /* There is probably a DOS atack here. They change the mode flag. */ 898 /* XXX add check here,*/ 899 read_sq_wake_up(file); /* checks f_mode */ 900 write_sq_wake_up(file); /* checks f_mode */ 901 #endif /* blocking open() */ 902 903 unlock_kernel(); 904 905 return rc; 906 } 907 908 /* here we see if we have a right to modify format, channels, size and so on 909 if no-one else has claimed it already then we do... 910 911 TODO: We might change this to mask O_RDWR such that only one or the other channel 912 is the owner - if we have problems. 913 */ 914 915 static int shared_resources_are_mine(fmode_t md) 916 { 917 if (shared_resource_owner) 918 return (shared_resource_owner & md) != 0; 919 else { 920 shared_resource_owner = md ; 921 return 1 ; 922 } 923 } 924 925 /* if either queue is locked we must deny the right to change shared params 926 */ 927 928 static int queues_are_quiescent(void) 929 { 930 if (write_sq.locked) 931 return 0 ; 932 return 1 ; 933 } 934 935 /* check and set a queue's fragments per user's wishes... 936 we will check against the pre-defined literals and the actual sizes. 937 This is a bit fraught - because soft translations can mess with our 938 buffer requirements *after* this call - OSS says "call setfrags first" 939 */ 940 941 /* It is possible to replace all the -EINVAL returns with an override that 942 just puts the allowable value in. This may be what many OSS apps require 943 */ 944 945 static int set_queue_frags(struct sound_queue *sq, int bufs, int size) 946 { 947 if (sq->locked) { 948 #ifdef DEBUG_DMASOUND 949 printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ; 950 #endif 951 return -EINVAL ; 952 } 953 954 if ((size < MIN_FRAG_SIZE) || (size > MAX_FRAG_SIZE)) 955 return -EINVAL ; 956 size = (1<<size) ; /* now in bytes */ 957 if (size > sq->bufSize) 958 return -EINVAL ; /* this might still not work */ 959 960 if (bufs <= 0) 961 return -EINVAL ; 962 if (bufs > sq->numBufs) /* the user is allowed say "don't care" with 0x7fff */ 963 bufs = sq->numBufs ; 964 965 /* there is, currently, no way to specify max_active separately 966 from max_count. This could be a LL driver issue - I guess 967 if there is a requirement for these values to be different then 968 we will have to pass that info. up to this level. 969 */ 970 sq->user_frags = 971 sq->max_active = bufs ; 972 sq->user_frag_size = size ; 973 974 return 0 ; 975 } 976 977 static int sq_ioctl(struct file *file, u_int cmd, u_long arg) 978 { 979 int val, result; 980 u_long fmt; 981 int data; 982 int size, nbufs; 983 audio_buf_info info; 984 985 switch (cmd) { 986 case SNDCTL_DSP_RESET: 987 sq_reset(); 988 return 0; 989 break ; 990 case SNDCTL_DSP_GETFMTS: 991 fmt = dmasound.mach.hardware_afmts ; /* this is what OSS says.. */ 992 return IOCTL_OUT(arg, fmt); 993 break ; 994 case SNDCTL_DSP_GETBLKSIZE: 995 /* this should tell the caller about bytes that the app can 996 read/write - the app doesn't care about our internal buffers. 997 We force sq_setup() here as per OSS 1.1 (which should 998 compute the values necessary). 999 Since there is no mechanism to specify read/write separately, for 1000 fds opened O_RDWR, the write_sq values will, arbitrarily, overwrite 1001 the read_sq ones. 1002 */ 1003 size = 0 ; 1004 if (file->f_mode & FMODE_WRITE) { 1005 if ( !write_sq.locked ) 1006 sq_setup(&write_sq) ; 1007 size = write_sq.user_frag_size ; 1008 } 1009 return IOCTL_OUT(arg, size); 1010 break ; 1011 case SNDCTL_DSP_POST: 1012 /* all we are going to do is to tell the LL that any 1013 partial frags can be queued for output. 1014 The LL will have to clear this flag when last output 1015 is queued. 1016 */ 1017 write_sq.syncing |= 0x2 ; 1018 sq_play() ; 1019 return 0 ; 1020 case SNDCTL_DSP_SYNC: 1021 /* This call, effectively, has the same behaviour as SNDCTL_DSP_RESET 1022 except that it waits for output to finish before resetting 1023 everything - read, however, is killed imediately. 1024 */ 1025 result = 0 ; 1026 if (file->f_mode & FMODE_WRITE) { 1027 result = sq_fsync(file, file->f_path.dentry); 1028 sq_reset_output() ; 1029 } 1030 /* if we are the shared resource owner then release them */ 1031 if (file->f_mode & shared_resource_owner) 1032 shared_resources_initialised = 0 ; 1033 return result ; 1034 break ; 1035 case SOUND_PCM_READ_RATE: 1036 return IOCTL_OUT(arg, dmasound.soft.speed); 1037 case SNDCTL_DSP_SPEED: 1038 /* changing this on the fly will have weird effects on the sound. 1039 Where there are rate conversions implemented in soft form - it 1040 will cause the _ctx_xxx() functions to be substituted. 1041 However, there doesn't appear to be any reason to dis-allow it from 1042 a driver pov. 1043 */ 1044 if (shared_resources_are_mine(file->f_mode)) { 1045 IOCTL_IN(arg, data); 1046 data = sound_set_speed(data) ; 1047 shared_resources_initialised = 0 ; 1048 return IOCTL_OUT(arg, data); 1049 } else 1050 return -EINVAL ; 1051 break ; 1052 /* OSS says these next 4 actions are undefined when the device is 1053 busy/active - we will just return -EINVAL. 1054 To be allowed to change one - (a) you have to own the right 1055 (b) the queue(s) must be quiescent 1056 */ 1057 case SNDCTL_DSP_STEREO: 1058 if (shared_resources_are_mine(file->f_mode) && 1059 queues_are_quiescent()) { 1060 IOCTL_IN(arg, data); 1061 shared_resources_initialised = 0 ; 1062 return IOCTL_OUT(arg, sound_set_stereo(data)); 1063 } else 1064 return -EINVAL ; 1065 break ; 1066 case SOUND_PCM_WRITE_CHANNELS: 1067 if (shared_resources_are_mine(file->f_mode) && 1068 queues_are_quiescent()) { 1069 IOCTL_IN(arg, data); 1070 /* the user might ask for 20 channels, we will return 1 or 2 */ 1071 shared_resources_initialised = 0 ; 1072 return IOCTL_OUT(arg, sound_set_stereo(data-1)+1); 1073 } else 1074 return -EINVAL ; 1075 break ; 1076 case SNDCTL_DSP_SETFMT: 1077 if (shared_resources_are_mine(file->f_mode) && 1078 queues_are_quiescent()) { 1079 int format; 1080 IOCTL_IN(arg, data); 1081 shared_resources_initialised = 0 ; 1082 format = sound_set_format(data); 1083 result = IOCTL_OUT(arg, format); 1084 if (result < 0) 1085 return result; 1086 if (format != data && data != AFMT_QUERY) 1087 return -EINVAL; 1088 return 0; 1089 } else 1090 return -EINVAL ; 1091 case SNDCTL_DSP_SUBDIVIDE: 1092 return -EINVAL ; 1093 case SNDCTL_DSP_SETFRAGMENT: 1094 /* we can do this independently for the two queues - with the 1095 proviso that for fds opened O_RDWR we cannot separate the 1096 actions and both queues will be set per the last call. 1097 NOTE: this does *NOT* actually set the queue up - merely 1098 registers our intentions. 1099 */ 1100 IOCTL_IN(arg, data); 1101 result = 0 ; 1102 nbufs = (data >> 16) & 0x7fff ; /* 0x7fff is 'use maximum' */ 1103 size = data & 0xffff; 1104 if (file->f_mode & FMODE_WRITE) { 1105 result = set_queue_frags(&write_sq, nbufs, size) ; 1106 if (result) 1107 return result ; 1108 } 1109 /* NOTE: this return value is irrelevant - OSS specifically says that 1110 the value is 'random' and that the user _must_ check the actual 1111 frags values using SNDCTL_DSP_GETBLKSIZE or similar */ 1112 return IOCTL_OUT(arg, data); 1113 break ; 1114 case SNDCTL_DSP_GETOSPACE: 1115 /* 1116 */ 1117 if (file->f_mode & FMODE_WRITE) { 1118 if ( !write_sq.locked ) 1119 sq_setup(&write_sq) ; 1120 info.fragments = write_sq.max_active - write_sq.count; 1121 info.fragstotal = write_sq.max_active; 1122 info.fragsize = write_sq.user_frag_size; 1123 info.bytes = info.fragments * info.fragsize; 1124 if (copy_to_user((void __user *)arg, &info, sizeof(info))) 1125 return -EFAULT; 1126 return 0; 1127 } else 1128 return -EINVAL ; 1129 break ; 1130 case SNDCTL_DSP_GETCAPS: 1131 val = dmasound.mach.capabilities & 0xffffff00; 1132 return IOCTL_OUT(arg,val); 1133 1134 default: 1135 return mixer_ioctl(file, cmd, arg); 1136 } 1137 return -EINVAL; 1138 } 1139 1140 static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) 1141 { 1142 int ret; 1143 1144 lock_kernel(); 1145 ret = sq_ioctl(file, cmd, arg); 1146 unlock_kernel(); 1147 1148 return ret; 1149 } 1150 1151 static const struct file_operations sq_fops = 1152 { 1153 .owner = THIS_MODULE, 1154 .llseek = no_llseek, 1155 .write = sq_write, 1156 .poll = sq_poll, 1157 .unlocked_ioctl = sq_unlocked_ioctl, 1158 .open = sq_open, 1159 .release = sq_release, 1160 }; 1161 1162 static int sq_init(void) 1163 { 1164 const struct file_operations *fops = &sq_fops; 1165 #ifndef MODULE 1166 int sq_unit; 1167 #endif 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) they 1179 * 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/sndstat 1194 */ 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-level 1198 driver. 1199 */ 1200 1201 #define STAT_BUFF_LEN 768 1202 1203 /* this is how much space we will allow the low-level driver to use 1204 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 162 1209 1210 static 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 1218 static char *get_afmt_string(int afmt) 1219 { 1220 switch(afmt) { 1221 case AFMT_MU_LAW: 1222 return "mu-law"; 1223 break; 1224 case AFMT_A_LAW: 1225 return "A-law"; 1226 break; 1227 case AFMT_U8: 1228 return "unsigned 8 bit"; 1229 break; 1230 case AFMT_S8: 1231 return "signed 8 bit"; 1232 break; 1233 case AFMT_S16_BE: 1234 return "signed 16 bit BE"; 1235 break; 1236 case AFMT_U16_BE: 1237 return "unsigned 16 bit BE"; 1238 break; 1239 case AFMT_S16_LE: 1240 return "signed 16 bit LE"; 1241 break; 1242 case AFMT_U16_LE: 1243 return "unsigned 16 bit LE"; 1244 break; 1245 case 0: 1246 return "format not set" ; 1247 break ; 1248 default: 1249 break ; 1250 } 1251 return "ERROR: Unsupported AFMT_XXXX code" ; 1252 } 1253 1254 static int state_open(struct inode *inode, struct file *file) 1255 { 1256 char *buffer = state.buf; 1257 int len = 0; 1258 int ret; 1259 1260 lock_kernel(); 1261 ret = -EBUSY; 1262 if (state.busy) 1263 goto out; 1264 1265 ret = -ENODEV; 1266 if (!try_module_get(dmasound.mach.owner)) 1267 goto out; 1268 1269 state.ptr = 0; 1270 state.busy = 1; 1271 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)) ; 1279 1280 /* call the low-level module to fill in any stat info. that it has 1281 if present. Maximum buffer usage is specified. 1282 */ 1283 1284 if (dmasound.mach.state_info) 1285 len += dmasound.mach.state_info(buffer+len, 1286 (size_t) LOW_LEVEL_STAT_ALLOC) ; 1287 1288 /* make usage of the state buffer as deterministic as poss. 1289 exceptional conditions could cause overrun - and this is flagged as 1290 a kernel error. 1291 */ 1292 1293 /* formats and settings */ 1294 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)); 1300 1301 len += sprintf(buffer+len,"Samp Rate:%14d s/sec%14d s/sec\n", 1302 dmasound.soft.speed, dmasound.hard.speed); 1303 1304 len += sprintf(buffer+len,"Channels :%20s%20s\n", 1305 dmasound.soft.stereo ? "stereo" : "mono", 1306 dmasound.hard.stereo ? "stereo" : "mono" ); 1307 1308 /* sound queue status */ 1309 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) ; 1324 #endif 1325 1326 if (len >= STAT_BUFF_LEN) 1327 printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n"); 1328 1329 state.len = len; 1330 ret = 0; 1331 out: 1332 unlock_kernel(); 1333 return ret; 1334 } 1335 1336 static int state_release(struct inode *inode, struct file *file) 1337 { 1338 lock_kernel(); 1339 state.busy = 0; 1340 module_put(dmasound.mach.owner); 1341 unlock_kernel(); 1342 return 0; 1343 } 1344 1345 static ssize_t state_read(struct file *file, char __user *buf, size_t count, 1346 loff_t *ppos) 1347 { 1348 int n = state.len - state.ptr; 1349 if (n > count) 1350 n = count; 1351 if (n <= 0) 1352 return 0; 1353 if (copy_to_user(buf, &state.buf[state.ptr], n)) 1354 return -EFAULT; 1355 state.ptr += n; 1356 return n; 1357 } 1358 1359 static const struct file_operations state_fops = { 1360 .owner = THIS_MODULE, 1361 .llseek = no_llseek, 1362 .read = state_read, 1363 .open = state_open, 1364 .release = state_release, 1365 }; 1366 1367 static int state_init(void) 1368 { 1369 #ifndef MODULE 1370 int state_unit; 1371 #endif 1372 state_unit = register_sound_special(&state_fops, SND_DEV_STATUS); 1373 if (state_unit < 0) 1374 return state_unit ; 1375 state.busy = 0; 1376 return 0 ; 1377 } 1378 1379 1380 /* 1381 * Config & Setup 1382 * 1383 * This function is called by _one_ chipset-specific driver 1384 */ 1385 1386 int dmasound_init(void) 1387 { 1388 int res ; 1389 #ifdef MODULE 1390 if (irq_installed) 1391 return -EBUSY; 1392 #endif 1393 1394 /* Set up sound queue, /dev/audio and /dev/dsp. */ 1395 1396 /* Set default settings. */ 1397 if ((res = sq_init()) < 0) 1398 return res ; 1399 1400 /* Set up /dev/sndstat. */ 1401 if ((res = state_init()) < 0) 1402 return res ; 1403 1404 /* Set up /dev/mixer. */ 1405 mixer_init(); 1406 1407 if (!dmasound.mach.irqinit()) { 1408 printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n"); 1409 return -ENODEV; 1410 } 1411 #ifdef MODULE 1412 irq_installed = 1; 1413 #endif 1414 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)); 1418 printk(KERN_INFO 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) ; 1424 return 0; 1425 } 1426 1427 #ifdef MODULE 1428 1429 void dmasound_deinit(void) 1430 { 1431 if (irq_installed) { 1432 sound_silence(); 1433 dmasound.mach.irqcleanup(); 1434 irq_installed = 0; 1435 } 1436 1437 write_sq_release_buffers(); 1438 1439 if (mixer_unit >= 0) 1440 unregister_sound_mixer(mixer_unit); 1441 if (state_unit >= 0) 1442 unregister_sound_special(state_unit); 1443 if (sq_unit >= 0) 1444 unregister_sound_dsp(sq_unit); 1445 } 1446 1447 #else /* !MODULE */ 1448 1449 static int dmasound_setup(char *str) 1450 { 1451 int ints[6], size; 1452 1453 str = get_options(str, ARRAY_SIZE(ints), ints); 1454 1455 /* check the bootstrap parameter for "dmasound=" */ 1456 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. 1459 */ 1460 1461 switch (ints[0]) { 1462 case 3: 1463 if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS)) 1464 printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius); 1465 else 1466 catchRadius = ints[3]; 1467 /* fall through */ 1468 case 2: 1469 if (ints[1] < MIN_BUFFERS) 1470 printk("dmasound_setup: invalid number of buffers, using default = %d\n", numWriteBufs); 1471 else 1472 numWriteBufs = ints[1]; 1473 /* fall through */ 1474 case 1: 1475 if ((size = ints[2]) < 256) /* check for small buffer specs */ 1476 size <<= 10 ; 1477 if (size < MIN_BUFSIZE || size > MAX_BUFSIZE) 1478 printk("dmasound_setup: invalid write buffer size, using default = %d\n", writeBufSize); 1479 else 1480 writeBufSize = size; 1481 case 0: 1482 break; 1483 default: 1484 printk("dmasound_setup: invalid number of arguments\n"); 1485 return 0; 1486 } 1487 return 1; 1488 } 1489 1490 __setup("dmasound=", dmasound_setup); 1491 1492 #endif /* !MODULE */ 1493 1494 /* 1495 * Conversion tables 1496 */ 1497 1498 #ifdef HAS_8BIT_TABLES 1499 /* 8 bit mu-law */ 1500 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 1534 }; 1535 1536 /* 8 bit A-law */ 1537 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 1571 }; 1572 #endif /* HAS_8BIT_TABLES */ 1573 1574 /* 1575 * Visible symbols for modules 1576 */ 1577 1578 EXPORT_SYMBOL(dmasound); 1579 EXPORT_SYMBOL(dmasound_init); 1580 #ifdef MODULE 1581 EXPORT_SYMBOL(dmasound_deinit); 1582 #endif 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); 1588 #endif 1589