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