1/* 2 * sound/oss/sb_audio.c 3 * 4 * Audio routines for Sound Blaster compatible cards. 5 * 6 * 7 * Copyright (C) by Hannu Savolainen 1993-1997 8 * 9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) 10 * Version 2 (June 1991). See the "COPYING" file distributed with this software 11 * for more info. 12 * 13 * Changes 14 * Alan Cox : Formatting and clean ups 15 * 16 * Status 17 * Mostly working. Weird uart bug causing irq storms 18 * 19 * Daniel J. Rodriksson: Changes to make sb16 work full duplex. 20 * Maybe other 16 bit cards in this code could behave 21 * the same. 22 * Chris Rankin: Use spinlocks instead of CLI/STI 23 */ 24 25#include <linux/spinlock.h> 26 27#include "sound_config.h" 28 29#include "sb_mixer.h" 30#include "sb.h" 31 32#include "sb_ess.h" 33 34int sb_audio_open(int dev, int mode) 35{ 36 sb_devc *devc = audio_devs[dev]->devc; 37 unsigned long flags; 38 39 if (devc == NULL) 40 { 41 printk(KERN_ERR "Sound Blaster: incomplete initialization.\n"); 42 return -ENXIO; 43 } 44 if (devc->caps & SB_NO_RECORDING && mode & OPEN_READ) 45 { 46 if (mode == OPEN_READ) 47 return -EPERM; 48 } 49 spin_lock_irqsave(&devc->lock, flags); 50 if (devc->opened) 51 { 52 spin_unlock_irqrestore(&devc->lock, flags); 53 return -EBUSY; 54 } 55 if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex) 56 { 57 if (sound_open_dma(devc->dma16, "Sound Blaster 16 bit")) 58 { 59 spin_unlock_irqrestore(&devc->lock, flags); 60 return -EBUSY; 61 } 62 } 63 devc->opened = mode; 64 spin_unlock_irqrestore(&devc->lock, flags); 65 66 devc->irq_mode = IMODE_NONE; 67 devc->irq_mode_16 = IMODE_NONE; 68 devc->fullduplex = devc->duplex && 69 ((mode & OPEN_READ) && (mode & OPEN_WRITE)); 70 sb_dsp_reset(devc); 71 72 /* At first glance this check isn't enough, some ESS chips might not 73 * have a RECLEV. However if they don't common_mixer_set will refuse 74 * cause devc->iomap has no register mapping for RECLEV 75 */ 76 if (devc->model == MDL_ESS) ess_mixer_reload (devc, SOUND_MIXER_RECLEV); 77 78 /* The ALS007 seems to require that the DSP be removed from the output */ 79 /* in order for recording to be activated properly. This is done by */ 80 /* setting the appropriate bits of the output control register 4ch to */ 81 /* zero. This code assumes that the output control registers are not */ 82 /* used anywhere else and therefore the DSP bits are *always* ON for */ 83 /* output and OFF for sampling. */ 84 85 if (devc->submodel == SUBMDL_ALS007) 86 { 87 if (mode & OPEN_READ) 88 sb_setmixer(devc,ALS007_OUTPUT_CTRL2, 89 sb_getmixer(devc,ALS007_OUTPUT_CTRL2) & 0xf9); 90 else 91 sb_setmixer(devc,ALS007_OUTPUT_CTRL2, 92 sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06); 93 } 94 return 0; 95} 96 97void sb_audio_close(int dev) 98{ 99 sb_devc *devc = audio_devs[dev]->devc; 100 101 /* fix things if mmap turned off fullduplex */ 102 if(devc->duplex 103 && !devc->fullduplex 104 && (devc->opened & OPEN_READ) && (devc->opened & OPEN_WRITE)) 105 { 106 struct dma_buffparms *dmap_temp; 107 dmap_temp = audio_devs[dev]->dmap_out; 108 audio_devs[dev]->dmap_out = audio_devs[dev]->dmap_in; 109 audio_devs[dev]->dmap_in = dmap_temp; 110 } 111 audio_devs[dev]->dmap_out->dma = devc->dma8; 112 audio_devs[dev]->dmap_in->dma = ( devc->duplex ) ? 113 devc->dma16 : devc->dma8; 114 115 if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex) 116 sound_close_dma(devc->dma16); 117 118 /* For ALS007, turn DSP output back on if closing the device for read */ 119 120 if ((devc->submodel == SUBMDL_ALS007) && (devc->opened & OPEN_READ)) 121 { 122 sb_setmixer(devc,ALS007_OUTPUT_CTRL2, 123 sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06); 124 } 125 devc->opened = 0; 126} 127 128static void sb_set_output_parms(int dev, unsigned long buf, int nr_bytes, 129 int intrflag) 130{ 131 sb_devc *devc = audio_devs[dev]->devc; 132 133 if (!devc->fullduplex || devc->bits == AFMT_S16_LE) 134 { 135 devc->trg_buf = buf; 136 devc->trg_bytes = nr_bytes; 137 devc->trg_intrflag = intrflag; 138 devc->irq_mode = IMODE_OUTPUT; 139 } 140 else 141 { 142 devc->trg_buf_16 = buf; 143 devc->trg_bytes_16 = nr_bytes; 144 devc->trg_intrflag_16 = intrflag; 145 devc->irq_mode_16 = IMODE_OUTPUT; 146 } 147} 148 149static void sb_set_input_parms(int dev, unsigned long buf, int count, int intrflag) 150{ 151 sb_devc *devc = audio_devs[dev]->devc; 152 153 if (!devc->fullduplex || devc->bits != AFMT_S16_LE) 154 { 155 devc->trg_buf = buf; 156 devc->trg_bytes = count; 157 devc->trg_intrflag = intrflag; 158 devc->irq_mode = IMODE_INPUT; 159 } 160 else 161 { 162 devc->trg_buf_16 = buf; 163 devc->trg_bytes_16 = count; 164 devc->trg_intrflag_16 = intrflag; 165 devc->irq_mode_16 = IMODE_INPUT; 166 } 167} 168 169/* 170 * SB1.x compatible routines 171 */ 172 173static void sb1_audio_output_block(int dev, unsigned long buf, int nr_bytes, int intrflag) 174{ 175 unsigned long flags; 176 int count = nr_bytes; 177 sb_devc *devc = audio_devs[dev]->devc; 178 179 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */ 180 181 if (audio_devs[dev]->dmap_out->dma > 3) 182 count >>= 1; 183 count--; 184 185 devc->irq_mode = IMODE_OUTPUT; 186 187 spin_lock_irqsave(&devc->lock, flags); 188 if (sb_dsp_command(devc, 0x14)) /* 8 bit DAC using DMA */ 189 { 190 sb_dsp_command(devc, (unsigned char) (count & 0xff)); 191 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff)); 192 } 193 else 194 printk(KERN_WARNING "Sound Blaster: unable to start DAC.\n"); 195 spin_unlock_irqrestore(&devc->lock, flags); 196 devc->intr_active = 1; 197} 198 199static void sb1_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag) 200{ 201 unsigned long flags; 202 int count = nr_bytes; 203 sb_devc *devc = audio_devs[dev]->devc; 204 205 /* 206 * Start a DMA input to the buffer pointed by dmaqtail 207 */ 208 209 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */ 210 211 if (audio_devs[dev]->dmap_out->dma > 3) 212 count >>= 1; 213 count--; 214 215 devc->irq_mode = IMODE_INPUT; 216 217 spin_lock_irqsave(&devc->lock, flags); 218 if (sb_dsp_command(devc, 0x24)) /* 8 bit ADC using DMA */ 219 { 220 sb_dsp_command(devc, (unsigned char) (count & 0xff)); 221 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff)); 222 } 223 else 224 printk(KERN_ERR "Sound Blaster: unable to start ADC.\n"); 225 spin_unlock_irqrestore(&devc->lock, flags); 226 227 devc->intr_active = 1; 228} 229 230static void sb1_audio_trigger(int dev, int bits) 231{ 232 sb_devc *devc = audio_devs[dev]->devc; 233 234 bits &= devc->irq_mode; 235 236 if (!bits) 237 sb_dsp_command(devc, 0xd0); /* Halt DMA */ 238 else 239 { 240 switch (devc->irq_mode) 241 { 242 case IMODE_INPUT: 243 sb1_audio_start_input(dev, devc->trg_buf, devc->trg_bytes, 244 devc->trg_intrflag); 245 break; 246 247 case IMODE_OUTPUT: 248 sb1_audio_output_block(dev, devc->trg_buf, devc->trg_bytes, 249 devc->trg_intrflag); 250 break; 251 } 252 } 253 devc->trigger_bits = bits; 254} 255 256static int sb1_audio_prepare_for_input(int dev, int bsize, int bcount) 257{ 258 sb_devc *devc = audio_devs[dev]->devc; 259 unsigned long flags; 260 261 spin_lock_irqsave(&devc->lock, flags); 262 if (sb_dsp_command(devc, 0x40)) 263 sb_dsp_command(devc, devc->tconst); 264 sb_dsp_command(devc, DSP_CMD_SPKOFF); 265 spin_unlock_irqrestore(&devc->lock, flags); 266 267 devc->trigger_bits = 0; 268 return 0; 269} 270 271static int sb1_audio_prepare_for_output(int dev, int bsize, int bcount) 272{ 273 sb_devc *devc = audio_devs[dev]->devc; 274 unsigned long flags; 275 276 spin_lock_irqsave(&devc->lock, flags); 277 if (sb_dsp_command(devc, 0x40)) 278 sb_dsp_command(devc, devc->tconst); 279 sb_dsp_command(devc, DSP_CMD_SPKON); 280 spin_unlock_irqrestore(&devc->lock, flags); 281 devc->trigger_bits = 0; 282 return 0; 283} 284 285static int sb1_audio_set_speed(int dev, int speed) 286{ 287 int max_speed = 23000; 288 sb_devc *devc = audio_devs[dev]->devc; 289 int tmp; 290 291 if (devc->opened & OPEN_READ) 292 max_speed = 13000; 293 294 if (speed > 0) 295 { 296 if (speed < 4000) 297 speed = 4000; 298 299 if (speed > max_speed) 300 speed = max_speed; 301 302 devc->tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff; 303 tmp = 256 - devc->tconst; 304 speed = (1000000 + tmp / 2) / tmp; 305 306 devc->speed = speed; 307 } 308 return devc->speed; 309} 310 311static short sb1_audio_set_channels(int dev, short channels) 312{ 313 sb_devc *devc = audio_devs[dev]->devc; 314 return devc->channels = 1; 315} 316 317static unsigned int sb1_audio_set_bits(int dev, unsigned int bits) 318{ 319 sb_devc *devc = audio_devs[dev]->devc; 320 return devc->bits = 8; 321} 322 323static void sb1_audio_halt_xfer(int dev) 324{ 325 unsigned long flags; 326 sb_devc *devc = audio_devs[dev]->devc; 327 328 spin_lock_irqsave(&devc->lock, flags); 329 sb_dsp_reset(devc); 330 spin_unlock_irqrestore(&devc->lock, flags); 331} 332 333/* 334 * SB 2.0 and SB 2.01 compatible routines 335 */ 336 337static void sb20_audio_output_block(int dev, unsigned long buf, int nr_bytes, 338 int intrflag) 339{ 340 unsigned long flags; 341 int count = nr_bytes; 342 sb_devc *devc = audio_devs[dev]->devc; 343 unsigned char cmd; 344 345 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */ 346 347 if (audio_devs[dev]->dmap_out->dma > 3) 348 count >>= 1; 349 count--; 350 351 devc->irq_mode = IMODE_OUTPUT; 352 353 spin_lock_irqsave(&devc->lock, flags); 354 if (sb_dsp_command(devc, 0x48)) /* DSP Block size */ 355 { 356 sb_dsp_command(devc, (unsigned char) (count & 0xff)); 357 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff)); 358 359 if (devc->speed * devc->channels <= 23000) 360 cmd = 0x1c; /* 8 bit PCM output */ 361 else 362 cmd = 0x90; /* 8 bit high speed PCM output (SB2.01/Pro) */ 363 364 if (!sb_dsp_command(devc, cmd)) 365 printk(KERN_ERR "Sound Blaster: unable to start DAC.\n"); 366 } 367 else 368 printk(KERN_ERR "Sound Blaster: unable to start DAC.\n"); 369 spin_unlock_irqrestore(&devc->lock, flags); 370 devc->intr_active = 1; 371} 372 373static void sb20_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag) 374{ 375 unsigned long flags; 376 int count = nr_bytes; 377 sb_devc *devc = audio_devs[dev]->devc; 378 unsigned char cmd; 379 380 /* 381 * Start a DMA input to the buffer pointed by dmaqtail 382 */ 383 384 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */ 385 386 if (audio_devs[dev]->dmap_out->dma > 3) 387 count >>= 1; 388 count--; 389 390 devc->irq_mode = IMODE_INPUT; 391 392 spin_lock_irqsave(&devc->lock, flags); 393 if (sb_dsp_command(devc, 0x48)) /* DSP Block size */ 394 { 395 sb_dsp_command(devc, (unsigned char) (count & 0xff)); 396 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff)); 397 398 if (devc->speed * devc->channels <= (devc->major == 3 ? 23000 : 13000)) 399 cmd = 0x2c; /* 8 bit PCM input */ 400 else 401 cmd = 0x98; /* 8 bit high speed PCM input (SB2.01/Pro) */ 402 403 if (!sb_dsp_command(devc, cmd)) 404 printk(KERN_ERR "Sound Blaster: unable to start ADC.\n"); 405 } 406 else 407 printk(KERN_ERR "Sound Blaster: unable to start ADC.\n"); 408 spin_unlock_irqrestore(&devc->lock, flags); 409 devc->intr_active = 1; 410} 411 412static void sb20_audio_trigger(int dev, int bits) 413{ 414 sb_devc *devc = audio_devs[dev]->devc; 415 bits &= devc->irq_mode; 416 417 if (!bits) 418 sb_dsp_command(devc, 0xd0); /* Halt DMA */ 419 else 420 { 421 switch (devc->irq_mode) 422 { 423 case IMODE_INPUT: 424 sb20_audio_start_input(dev, devc->trg_buf, devc->trg_bytes, 425 devc->trg_intrflag); 426 break; 427 428 case IMODE_OUTPUT: 429 sb20_audio_output_block(dev, devc->trg_buf, devc->trg_bytes, 430 devc->trg_intrflag); 431 break; 432 } 433 } 434 devc->trigger_bits = bits; 435} 436 437/* 438 * SB2.01 specific speed setup 439 */ 440 441static int sb201_audio_set_speed(int dev, int speed) 442{ 443 sb_devc *devc = audio_devs[dev]->devc; 444 int tmp; 445 int s = speed * devc->channels; 446 447 if (speed > 0) 448 { 449 if (speed < 4000) 450 speed = 4000; 451 if (speed > 44100) 452 speed = 44100; 453 if (devc->opened & OPEN_READ && speed > 15000) 454 speed = 15000; 455 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff; 456 tmp = 256 - devc->tconst; 457 speed = ((1000000 + tmp / 2) / tmp) / devc->channels; 458 459 devc->speed = speed; 460 } 461 return devc->speed; 462} 463 464/* 465 * SB Pro specific routines 466 */ 467 468static int sbpro_audio_prepare_for_input(int dev, int bsize, int bcount) 469{ /* For SB Pro and Jazz16 */ 470 sb_devc *devc = audio_devs[dev]->devc; 471 unsigned long flags; 472 unsigned char bits = 0; 473 474 if (devc->dma16 >= 0 && devc->dma16 != devc->dma8) 475 audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = 476 devc->bits == 16 ? devc->dma16 : devc->dma8; 477 478 if (devc->model == MDL_JAZZ || devc->model == MDL_SMW) 479 if (devc->bits == AFMT_S16_LE) 480 bits = 0x04; /* 16 bit mode */ 481 482 spin_lock_irqsave(&devc->lock, flags); 483 if (sb_dsp_command(devc, 0x40)) 484 sb_dsp_command(devc, devc->tconst); 485 sb_dsp_command(devc, DSP_CMD_SPKOFF); 486 if (devc->channels == 1) 487 sb_dsp_command(devc, 0xa0 | bits); /* Mono input */ 488 else 489 sb_dsp_command(devc, 0xa8 | bits); /* Stereo input */ 490 spin_unlock_irqrestore(&devc->lock, flags); 491 492 devc->trigger_bits = 0; 493 return 0; 494} 495 496static int sbpro_audio_prepare_for_output(int dev, int bsize, int bcount) 497{ /* For SB Pro and Jazz16 */ 498 sb_devc *devc = audio_devs[dev]->devc; 499 unsigned long flags; 500 unsigned char tmp; 501 unsigned char bits = 0; 502 503 if (devc->dma16 >= 0 && devc->dma16 != devc->dma8) 504 audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = devc->bits == 16 ? devc->dma16 : devc->dma8; 505 if (devc->model == MDL_SBPRO) 506 sb_mixer_set_stereo(devc, devc->channels == 2); 507 508 spin_lock_irqsave(&devc->lock, flags); 509 if (sb_dsp_command(devc, 0x40)) 510 sb_dsp_command(devc, devc->tconst); 511 sb_dsp_command(devc, DSP_CMD_SPKON); 512 513 if (devc->model == MDL_JAZZ || devc->model == MDL_SMW) 514 { 515 if (devc->bits == AFMT_S16_LE) 516 bits = 0x04; /* 16 bit mode */ 517 518 if (devc->channels == 1) 519 sb_dsp_command(devc, 0xa0 | bits); /* Mono output */ 520 else 521 sb_dsp_command(devc, 0xa8 | bits); /* Stereo output */ 522 spin_unlock_irqrestore(&devc->lock, flags); 523 } 524 else 525 { 526 spin_unlock_irqrestore(&devc->lock, flags); 527 tmp = sb_getmixer(devc, 0x0e); 528 if (devc->channels == 1) 529 tmp &= ~0x02; 530 else 531 tmp |= 0x02; 532 sb_setmixer(devc, 0x0e, tmp); 533 } 534 devc->trigger_bits = 0; 535 return 0; 536} 537 538static int sbpro_audio_set_speed(int dev, int speed) 539{ 540 sb_devc *devc = audio_devs[dev]->devc; 541 542 if (speed > 0) 543 { 544 if (speed < 4000) 545 speed = 4000; 546 if (speed > 44100) 547 speed = 44100; 548 if (devc->channels > 1 && speed > 22050) 549 speed = 22050; 550 sb201_audio_set_speed(dev, speed); 551 } 552 return devc->speed; 553} 554 555static short sbpro_audio_set_channels(int dev, short channels) 556{ 557 sb_devc *devc = audio_devs[dev]->devc; 558 559 if (channels == 1 || channels == 2) 560 { 561 if (channels != devc->channels) 562 { 563 devc->channels = channels; 564 if (devc->model == MDL_SBPRO && devc->channels == 2) 565 sbpro_audio_set_speed(dev, devc->speed); 566 } 567 } 568 return devc->channels; 569} 570 571static int jazz16_audio_set_speed(int dev, int speed) 572{ 573 sb_devc *devc = audio_devs[dev]->devc; 574 575 if (speed > 0) 576 { 577 int tmp; 578 int s = speed * devc->channels; 579 580 if (speed < 5000) 581 speed = 5000; 582 if (speed > 44100) 583 speed = 44100; 584 585 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff; 586 587 tmp = 256 - devc->tconst; 588 speed = ((1000000 + tmp / 2) / tmp) / devc->channels; 589 590 devc->speed = speed; 591 } 592 return devc->speed; 593} 594 595/* 596 * SB16 specific routines 597 */ 598 599static int sb16_audio_set_speed(int dev, int speed) 600{ 601 sb_devc *devc = audio_devs[dev]->devc; 602 int max_speed = devc->submodel == SUBMDL_ALS100 ? 48000 : 44100; 603 604 if (speed > 0) 605 { 606 if (speed < 5000) 607 speed = 5000; 608 609 if (speed > max_speed) 610 speed = max_speed; 611 612 devc->speed = speed; 613 } 614 return devc->speed; 615} 616 617static unsigned int sb16_audio_set_bits(int dev, unsigned int bits) 618{ 619 sb_devc *devc = audio_devs[dev]->devc; 620 621 if (bits != 0) 622 { 623 if (bits == AFMT_U8 || bits == AFMT_S16_LE) 624 devc->bits = bits; 625 else 626 devc->bits = AFMT_U8; 627 } 628 629 return devc->bits; 630} 631 632static int sb16_audio_prepare_for_input(int dev, int bsize, int bcount) 633{ 634 sb_devc *devc = audio_devs[dev]->devc; 635 636 if (!devc->fullduplex) 637 { 638 audio_devs[dev]->dmap_out->dma = 639 audio_devs[dev]->dmap_in->dma = 640 devc->bits == AFMT_S16_LE ? 641 devc->dma16 : devc->dma8; 642 } 643 else if (devc->bits == AFMT_S16_LE) 644 { 645 audio_devs[dev]->dmap_out->dma = devc->dma8; 646 audio_devs[dev]->dmap_in->dma = devc->dma16; 647 } 648 else 649 { 650 audio_devs[dev]->dmap_out->dma = devc->dma16; 651 audio_devs[dev]->dmap_in->dma = devc->dma8; 652 } 653 654 devc->trigger_bits = 0; 655 return 0; 656} 657 658static int sb16_audio_prepare_for_output(int dev, int bsize, int bcount) 659{ 660 sb_devc *devc = audio_devs[dev]->devc; 661 662 if (!devc->fullduplex) 663 { 664 audio_devs[dev]->dmap_out->dma = 665 audio_devs[dev]->dmap_in->dma = 666 devc->bits == AFMT_S16_LE ? 667 devc->dma16 : devc->dma8; 668 } 669 else if (devc->bits == AFMT_S16_LE) 670 { 671 audio_devs[dev]->dmap_out->dma = devc->dma8; 672 audio_devs[dev]->dmap_in->dma = devc->dma16; 673 } 674 else 675 { 676 audio_devs[dev]->dmap_out->dma = devc->dma16; 677 audio_devs[dev]->dmap_in->dma = devc->dma8; 678 } 679 680 devc->trigger_bits = 0; 681 return 0; 682} 683 684static void sb16_audio_output_block(int dev, unsigned long buf, int count, 685 int intrflag) 686{ 687 unsigned long flags, cnt; 688 sb_devc *devc = audio_devs[dev]->devc; 689 unsigned long bits; 690 691 if (!devc->fullduplex || devc->bits == AFMT_S16_LE) 692 { 693 devc->irq_mode = IMODE_OUTPUT; 694 devc->intr_active = 1; 695 } 696 else 697 { 698 devc->irq_mode_16 = IMODE_OUTPUT; 699 devc->intr_active_16 = 1; 700 } 701 702 /* save value */ 703 spin_lock_irqsave(&devc->lock, flags); 704 bits = devc->bits; 705 if (devc->fullduplex) 706 devc->bits = (devc->bits == AFMT_S16_LE) ? 707 AFMT_U8 : AFMT_S16_LE; 708 spin_unlock_irqrestore(&devc->lock, flags); 709 710 cnt = count; 711 if (devc->bits == AFMT_S16_LE) 712 cnt >>= 1; 713 cnt--; 714 715 spin_lock_irqsave(&devc->lock, flags); 716 717 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */ 718 719 sb_dsp_command(devc, 0x41); 720 sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff)); 721 sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff)); 722 723 sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xb6 : 0xc6)); 724 sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) + 725 (devc->bits == AFMT_S16_LE ? 0x10 : 0))); 726 sb_dsp_command(devc, (unsigned char) (cnt & 0xff)); 727 sb_dsp_command(devc, (unsigned char) (cnt >> 8)); 728 729 /* restore real value after all programming */ 730 devc->bits = bits; 731 spin_unlock_irqrestore(&devc->lock, flags); 732} 733 734 735/* 736 * This fails on the Cyrix MediaGX. If you don't have the DMA enabled 737 * before the first sample arrives it locks up. However even if you 738 * do enable the DMA in time you just get DMA timeouts and missing 739 * interrupts and stuff, so for now I've not bothered fixing this either. 740 */ 741 742static void sb16_audio_start_input(int dev, unsigned long buf, int count, int intrflag) 743{ 744 unsigned long flags, cnt; 745 sb_devc *devc = audio_devs[dev]->devc; 746 747 if (!devc->fullduplex || devc->bits != AFMT_S16_LE) 748 { 749 devc->irq_mode = IMODE_INPUT; 750 devc->intr_active = 1; 751 } 752 else 753 { 754 devc->irq_mode_16 = IMODE_INPUT; 755 devc->intr_active_16 = 1; 756 } 757 758 cnt = count; 759 if (devc->bits == AFMT_S16_LE) 760 cnt >>= 1; 761 cnt--; 762 763 spin_lock_irqsave(&devc->lock, flags); 764 765 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */ 766 767 sb_dsp_command(devc, 0x42); 768 sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff)); 769 sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff)); 770 771 sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xbe : 0xce)); 772 sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) + 773 (devc->bits == AFMT_S16_LE ? 0x10 : 0))); 774 sb_dsp_command(devc, (unsigned char) (cnt & 0xff)); 775 sb_dsp_command(devc, (unsigned char) (cnt >> 8)); 776 777 spin_unlock_irqrestore(&devc->lock, flags); 778} 779 780static void sb16_audio_trigger(int dev, int bits) 781{ 782 sb_devc *devc = audio_devs[dev]->devc; 783 784 int bits_16 = bits & devc->irq_mode_16; 785 bits &= devc->irq_mode; 786 787 if (!bits && !bits_16) 788 sb_dsp_command(devc, 0xd0); /* Halt DMA */ 789 else 790 { 791 if (bits) 792 { 793 switch (devc->irq_mode) 794 { 795 case IMODE_INPUT: 796 sb16_audio_start_input(dev, 797 devc->trg_buf, 798 devc->trg_bytes, 799 devc->trg_intrflag); 800 break; 801 802 case IMODE_OUTPUT: 803 sb16_audio_output_block(dev, 804 devc->trg_buf, 805 devc->trg_bytes, 806 devc->trg_intrflag); 807 break; 808 } 809 } 810 if (bits_16) 811 { 812 switch (devc->irq_mode_16) 813 { 814 case IMODE_INPUT: 815 sb16_audio_start_input(dev, 816 devc->trg_buf_16, 817 devc->trg_bytes_16, 818 devc->trg_intrflag_16); 819 break; 820 821 case IMODE_OUTPUT: 822 sb16_audio_output_block(dev, 823 devc->trg_buf_16, 824 devc->trg_bytes_16, 825 devc->trg_intrflag_16); 826 break; 827 } 828 } 829 } 830 831 devc->trigger_bits = bits | bits_16; 832} 833 834static unsigned char lbuf8[2048]; 835static signed short *lbuf16 = (signed short *)lbuf8; 836#define LBUFCOPYSIZE 1024 837static void 838sb16_copy_from_user(int dev, 839 char *localbuf, int localoffs, 840 const char __user *userbuf, int useroffs, 841 int max_in, int max_out, 842 int *used, int *returned, 843 int len) 844{ 845 sb_devc *devc = audio_devs[dev]->devc; 846 int i, c, p, locallen; 847 unsigned char *buf8; 848 signed short *buf16; 849 850 /* if not duplex no conversion */ 851 if (!devc->fullduplex) 852 { 853 if (copy_from_user(localbuf + localoffs, 854 userbuf + useroffs, len)) 855 return; 856 *used = len; 857 *returned = len; 858 } 859 else if (devc->bits == AFMT_S16_LE) 860 { 861 /* 16 -> 8 */ 862 /* max_in >> 1, max number of samples in ( 16 bits ) */ 863 /* max_out, max number of samples out ( 8 bits ) */ 864 /* len, number of samples that will be taken ( 16 bits )*/ 865 /* c, count of samples remaining in buffer ( 16 bits )*/ 866 /* p, count of samples already processed ( 16 bits )*/ 867 len = ( (max_in >> 1) > max_out) ? max_out : (max_in >> 1); 868 c = len; 869 p = 0; 870 buf8 = (unsigned char *)(localbuf + localoffs); 871 while (c) 872 { 873 locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c); 874 /* << 1 in order to get 16 bit samples */ 875 if (copy_from_user(lbuf16, 876 userbuf + useroffs + (p << 1), 877 locallen << 1)) 878 return; 879 for (i = 0; i < locallen; i++) 880 { 881 buf8[p+i] = ~((lbuf16[i] >> 8) & 0xff) ^ 0x80; 882 } 883 c -= locallen; p += locallen; 884 } 885 /* used = ( samples * 16 bits size ) */ 886 *used = max_in > ( max_out << 1) ? (max_out << 1) : max_in; 887 /* returned = ( samples * 8 bits size ) */ 888 *returned = len; 889 } 890 else 891 { 892 /* 8 -> 16 */ 893 /* max_in, max number of samples in ( 8 bits ) */ 894 /* max_out >> 1, max number of samples out ( 16 bits ) */ 895 /* len, number of samples that will be taken ( 8 bits )*/ 896 /* c, count of samples remaining in buffer ( 8 bits )*/ 897 /* p, count of samples already processed ( 8 bits )*/ 898 len = max_in > (max_out >> 1) ? (max_out >> 1) : max_in; 899 c = len; 900 p = 0; 901 buf16 = (signed short *)(localbuf + localoffs); 902 while (c) 903 { 904 locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c); 905 if (copy_from_user(lbuf8, 906 userbuf+useroffs + p, 907 locallen)) 908 return; 909 for (i = 0; i < locallen; i++) 910 { 911 buf16[p+i] = (~lbuf8[i] ^ 0x80) << 8; 912 } 913 c -= locallen; p += locallen; 914 } 915 /* used = ( samples * 8 bits size ) */ 916 *used = len; 917 /* returned = ( samples * 16 bits size ) */ 918 *returned = len << 1; 919 } 920} 921 922static void 923sb16_audio_mmap(int dev) 924{ 925 sb_devc *devc = audio_devs[dev]->devc; 926 devc->fullduplex = 0; 927} 928 929static struct audio_driver sb1_audio_driver = /* SB1.x */ 930{ 931 .owner = THIS_MODULE, 932 .open = sb_audio_open, 933 .close = sb_audio_close, 934 .output_block = sb_set_output_parms, 935 .start_input = sb_set_input_parms, 936 .prepare_for_input = sb1_audio_prepare_for_input, 937 .prepare_for_output = sb1_audio_prepare_for_output, 938 .halt_io = sb1_audio_halt_xfer, 939 .trigger = sb1_audio_trigger, 940 .set_speed = sb1_audio_set_speed, 941 .set_bits = sb1_audio_set_bits, 942 .set_channels = sb1_audio_set_channels 943}; 944 945static struct audio_driver sb20_audio_driver = /* SB2.0 */ 946{ 947 .owner = THIS_MODULE, 948 .open = sb_audio_open, 949 .close = sb_audio_close, 950 .output_block = sb_set_output_parms, 951 .start_input = sb_set_input_parms, 952 .prepare_for_input = sb1_audio_prepare_for_input, 953 .prepare_for_output = sb1_audio_prepare_for_output, 954 .halt_io = sb1_audio_halt_xfer, 955 .trigger = sb20_audio_trigger, 956 .set_speed = sb1_audio_set_speed, 957 .set_bits = sb1_audio_set_bits, 958 .set_channels = sb1_audio_set_channels 959}; 960 961static struct audio_driver sb201_audio_driver = /* SB2.01 */ 962{ 963 .owner = THIS_MODULE, 964 .open = sb_audio_open, 965 .close = sb_audio_close, 966 .output_block = sb_set_output_parms, 967 .start_input = sb_set_input_parms, 968 .prepare_for_input = sb1_audio_prepare_for_input, 969 .prepare_for_output = sb1_audio_prepare_for_output, 970 .halt_io = sb1_audio_halt_xfer, 971 .trigger = sb20_audio_trigger, 972 .set_speed = sb201_audio_set_speed, 973 .set_bits = sb1_audio_set_bits, 974 .set_channels = sb1_audio_set_channels 975}; 976 977static struct audio_driver sbpro_audio_driver = /* SB Pro */ 978{ 979 .owner = THIS_MODULE, 980 .open = sb_audio_open, 981 .close = sb_audio_close, 982 .output_block = sb_set_output_parms, 983 .start_input = sb_set_input_parms, 984 .prepare_for_input = sbpro_audio_prepare_for_input, 985 .prepare_for_output = sbpro_audio_prepare_for_output, 986 .halt_io = sb1_audio_halt_xfer, 987 .trigger = sb20_audio_trigger, 988 .set_speed = sbpro_audio_set_speed, 989 .set_bits = sb1_audio_set_bits, 990 .set_channels = sbpro_audio_set_channels 991}; 992 993static struct audio_driver jazz16_audio_driver = /* Jazz16 and SM Wave */ 994{ 995 .owner = THIS_MODULE, 996 .open = sb_audio_open, 997 .close = sb_audio_close, 998 .output_block = sb_set_output_parms, 999 .start_input = sb_set_input_parms, 1000 .prepare_for_input = sbpro_audio_prepare_for_input, 1001 .prepare_for_output = sbpro_audio_prepare_for_output, 1002 .halt_io = sb1_audio_halt_xfer, 1003 .trigger = sb20_audio_trigger, 1004 .set_speed = jazz16_audio_set_speed, 1005 .set_bits = sb16_audio_set_bits, 1006 .set_channels = sbpro_audio_set_channels 1007}; 1008 1009static struct audio_driver sb16_audio_driver = /* SB16 */ 1010{ 1011 .owner = THIS_MODULE, 1012 .open = sb_audio_open, 1013 .close = sb_audio_close, 1014 .output_block = sb_set_output_parms, 1015 .start_input = sb_set_input_parms, 1016 .prepare_for_input = sb16_audio_prepare_for_input, 1017 .prepare_for_output = sb16_audio_prepare_for_output, 1018 .halt_io = sb1_audio_halt_xfer, 1019 .copy_user = sb16_copy_from_user, 1020 .trigger = sb16_audio_trigger, 1021 .set_speed = sb16_audio_set_speed, 1022 .set_bits = sb16_audio_set_bits, 1023 .set_channels = sbpro_audio_set_channels, 1024 .mmap = sb16_audio_mmap 1025}; 1026 1027void sb_audio_init(sb_devc * devc, char *name, struct module *owner) 1028{ 1029 int audio_flags = 0; 1030 int format_mask = AFMT_U8; 1031 1032 struct audio_driver *driver = &sb1_audio_driver; 1033 1034 switch (devc->model) 1035 { 1036 case MDL_SB1: /* SB1.0 or SB 1.5 */ 1037 DDB(printk("Will use standard SB1.x driver\n")); 1038 audio_flags = DMA_HARDSTOP; 1039 break; 1040 1041 case MDL_SB2: 1042 DDB(printk("Will use SB2.0 driver\n")); 1043 audio_flags = DMA_AUTOMODE; 1044 driver = &sb20_audio_driver; 1045 break; 1046 1047 case MDL_SB201: 1048 DDB(printk("Will use SB2.01 (high speed) driver\n")); 1049 audio_flags = DMA_AUTOMODE; 1050 driver = &sb201_audio_driver; 1051 break; 1052 1053 case MDL_JAZZ: 1054 case MDL_SMW: 1055 DDB(printk("Will use Jazz16 driver\n")); 1056 audio_flags = DMA_AUTOMODE; 1057 format_mask |= AFMT_S16_LE; 1058 driver = &jazz16_audio_driver; 1059 break; 1060 1061 case MDL_ESS: 1062 DDB(printk("Will use ESS ES688/1688 driver\n")); 1063 driver = ess_audio_init (devc, &audio_flags, &format_mask); 1064 break; 1065 1066 case MDL_SB16: 1067 DDB(printk("Will use SB16 driver\n")); 1068 audio_flags = DMA_AUTOMODE; 1069 format_mask |= AFMT_S16_LE; 1070 if (devc->dma8 != devc->dma16 && devc->dma16 != -1) 1071 { 1072 audio_flags |= DMA_DUPLEX; 1073 devc->duplex = 1; 1074 } 1075 driver = &sb16_audio_driver; 1076 break; 1077 1078 default: 1079 DDB(printk("Will use SB Pro driver\n")); 1080 audio_flags = DMA_AUTOMODE; 1081 driver = &sbpro_audio_driver; 1082 } 1083 1084 if (owner) 1085 driver->owner = owner; 1086 1087 if ((devc->dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, 1088 name,driver, sizeof(struct audio_driver), 1089 audio_flags, format_mask, devc, 1090 devc->dma8, 1091 devc->duplex ? devc->dma16 : devc->dma8)) < 0) 1092 { 1093 printk(KERN_ERR "Sound Blaster: unable to install audio.\n"); 1094 return; 1095 } 1096 audio_devs[devc->dev]->mixer_dev = devc->my_mixerdev; 1097 audio_devs[devc->dev]->min_fragment = 5; 1098} 1099