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