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; 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 s = speed * devc->channels; 456 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff; 457 tmp = 256 - devc->tconst; 458 speed = ((1000000 + tmp / 2) / tmp) / devc->channels; 459 460 devc->speed = speed; 461 } 462 return devc->speed; 463} 464 465/* 466 * SB Pro specific routines 467 */ 468 469static int sbpro_audio_prepare_for_input(int dev, int bsize, int bcount) 470{ /* For SB Pro and Jazz16 */ 471 sb_devc *devc = audio_devs[dev]->devc; 472 unsigned long flags; 473 unsigned char bits = 0; 474 475 if (devc->dma16 >= 0 && devc->dma16 != devc->dma8) 476 audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = 477 devc->bits == 16 ? devc->dma16 : devc->dma8; 478 479 if (devc->model == MDL_JAZZ || devc->model == MDL_SMW) 480 if (devc->bits == AFMT_S16_LE) 481 bits = 0x04; /* 16 bit mode */ 482 483 spin_lock_irqsave(&devc->lock, flags); 484 if (sb_dsp_command(devc, 0x40)) 485 sb_dsp_command(devc, devc->tconst); 486 sb_dsp_command(devc, DSP_CMD_SPKOFF); 487 if (devc->channels == 1) 488 sb_dsp_command(devc, 0xa0 | bits); /* Mono input */ 489 else 490 sb_dsp_command(devc, 0xa8 | bits); /* Stereo input */ 491 spin_unlock_irqrestore(&devc->lock, flags); 492 493 devc->trigger_bits = 0; 494 return 0; 495} 496 497static int sbpro_audio_prepare_for_output(int dev, int bsize, int bcount) 498{ /* For SB Pro and Jazz16 */ 499 sb_devc *devc = audio_devs[dev]->devc; 500 unsigned long flags; 501 unsigned char tmp; 502 unsigned char bits = 0; 503 504 if (devc->dma16 >= 0 && devc->dma16 != devc->dma8) 505 audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = devc->bits == 16 ? devc->dma16 : devc->dma8; 506 if (devc->model == MDL_SBPRO) 507 sb_mixer_set_stereo(devc, devc->channels == 2); 508 509 spin_lock_irqsave(&devc->lock, flags); 510 if (sb_dsp_command(devc, 0x40)) 511 sb_dsp_command(devc, devc->tconst); 512 sb_dsp_command(devc, DSP_CMD_SPKON); 513 514 if (devc->model == MDL_JAZZ || devc->model == MDL_SMW) 515 { 516 if (devc->bits == AFMT_S16_LE) 517 bits = 0x04; /* 16 bit mode */ 518 519 if (devc->channels == 1) 520 sb_dsp_command(devc, 0xa0 | bits); /* Mono output */ 521 else 522 sb_dsp_command(devc, 0xa8 | bits); /* Stereo output */ 523 spin_unlock_irqrestore(&devc->lock, flags); 524 } 525 else 526 { 527 spin_unlock_irqrestore(&devc->lock, flags); 528 tmp = sb_getmixer(devc, 0x0e); 529 if (devc->channels == 1) 530 tmp &= ~0x02; 531 else 532 tmp |= 0x02; 533 sb_setmixer(devc, 0x0e, tmp); 534 } 535 devc->trigger_bits = 0; 536 return 0; 537} 538 539static int sbpro_audio_set_speed(int dev, int speed) 540{ 541 sb_devc *devc = audio_devs[dev]->devc; 542 543 if (speed > 0) 544 { 545 if (speed < 4000) 546 speed = 4000; 547 if (speed > 44100) 548 speed = 44100; 549 if (devc->channels > 1 && speed > 22050) 550 speed = 22050; 551 sb201_audio_set_speed(dev, speed); 552 } 553 return devc->speed; 554} 555 556static short sbpro_audio_set_channels(int dev, short channels) 557{ 558 sb_devc *devc = audio_devs[dev]->devc; 559 560 if (channels == 1 || channels == 2) 561 { 562 if (channels != devc->channels) 563 { 564 devc->channels = channels; 565 if (devc->model == MDL_SBPRO && devc->channels == 2) 566 sbpro_audio_set_speed(dev, devc->speed); 567 } 568 } 569 return devc->channels; 570} 571 572static int jazz16_audio_set_speed(int dev, int speed) 573{ 574 sb_devc *devc = audio_devs[dev]->devc; 575 576 if (speed > 0) 577 { 578 int tmp; 579 int s; 580 581 if (speed < 5000) 582 speed = 5000; 583 if (speed > 44100) 584 speed = 44100; 585 586 s = speed * devc->channels; 587 588 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff; 589 590 tmp = 256 - devc->tconst; 591 speed = ((1000000 + tmp / 2) / tmp) / devc->channels; 592 593 devc->speed = speed; 594 } 595 return devc->speed; 596} 597 598/* 599 * SB16 specific routines 600 */ 601 602static int sb16_audio_set_speed(int dev, int speed) 603{ 604 sb_devc *devc = audio_devs[dev]->devc; 605 int max_speed = devc->submodel == SUBMDL_ALS100 ? 48000 : 44100; 606 607 if (speed > 0) 608 { 609 if (speed < 5000) 610 speed = 5000; 611 612 if (speed > max_speed) 613 speed = max_speed; 614 615 devc->speed = speed; 616 } 617 return devc->speed; 618} 619 620static unsigned int sb16_audio_set_bits(int dev, unsigned int bits) 621{ 622 sb_devc *devc = audio_devs[dev]->devc; 623 624 if (bits != 0) 625 { 626 if (bits == AFMT_U8 || bits == AFMT_S16_LE) 627 devc->bits = bits; 628 else 629 devc->bits = AFMT_U8; 630 } 631 632 return devc->bits; 633} 634 635static int sb16_audio_prepare_for_input(int dev, int bsize, int bcount) 636{ 637 sb_devc *devc = audio_devs[dev]->devc; 638 639 if (!devc->fullduplex) 640 { 641 audio_devs[dev]->dmap_out->dma = 642 audio_devs[dev]->dmap_in->dma = 643 devc->bits == AFMT_S16_LE ? 644 devc->dma16 : devc->dma8; 645 } 646 else if (devc->bits == AFMT_S16_LE) 647 { 648 audio_devs[dev]->dmap_out->dma = devc->dma8; 649 audio_devs[dev]->dmap_in->dma = devc->dma16; 650 } 651 else 652 { 653 audio_devs[dev]->dmap_out->dma = devc->dma16; 654 audio_devs[dev]->dmap_in->dma = devc->dma8; 655 } 656 657 devc->trigger_bits = 0; 658 return 0; 659} 660 661static int sb16_audio_prepare_for_output(int dev, int bsize, int bcount) 662{ 663 sb_devc *devc = audio_devs[dev]->devc; 664 665 if (!devc->fullduplex) 666 { 667 audio_devs[dev]->dmap_out->dma = 668 audio_devs[dev]->dmap_in->dma = 669 devc->bits == AFMT_S16_LE ? 670 devc->dma16 : devc->dma8; 671 } 672 else if (devc->bits == AFMT_S16_LE) 673 { 674 audio_devs[dev]->dmap_out->dma = devc->dma8; 675 audio_devs[dev]->dmap_in->dma = devc->dma16; 676 } 677 else 678 { 679 audio_devs[dev]->dmap_out->dma = devc->dma16; 680 audio_devs[dev]->dmap_in->dma = devc->dma8; 681 } 682 683 devc->trigger_bits = 0; 684 return 0; 685} 686 687static void sb16_audio_output_block(int dev, unsigned long buf, int count, 688 int intrflag) 689{ 690 unsigned long flags, cnt; 691 sb_devc *devc = audio_devs[dev]->devc; 692 unsigned long bits; 693 694 if (!devc->fullduplex || devc->bits == AFMT_S16_LE) 695 { 696 devc->irq_mode = IMODE_OUTPUT; 697 devc->intr_active = 1; 698 } 699 else 700 { 701 devc->irq_mode_16 = IMODE_OUTPUT; 702 devc->intr_active_16 = 1; 703 } 704 705 /* save value */ 706 spin_lock_irqsave(&devc->lock, flags); 707 bits = devc->bits; 708 if (devc->fullduplex) 709 devc->bits = (devc->bits == AFMT_S16_LE) ? 710 AFMT_U8 : AFMT_S16_LE; 711 spin_unlock_irqrestore(&devc->lock, flags); 712 713 cnt = count; 714 if (devc->bits == AFMT_S16_LE) 715 cnt >>= 1; 716 cnt--; 717 718 spin_lock_irqsave(&devc->lock, flags); 719 720 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */ 721 722 sb_dsp_command(devc, 0x41); 723 sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff)); 724 sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff)); 725 726 sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xb6 : 0xc6)); 727 sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) + 728 (devc->bits == AFMT_S16_LE ? 0x10 : 0))); 729 sb_dsp_command(devc, (unsigned char) (cnt & 0xff)); 730 sb_dsp_command(devc, (unsigned char) (cnt >> 8)); 731 732 /* restore real value after all programming */ 733 devc->bits = bits; 734 spin_unlock_irqrestore(&devc->lock, flags); 735} 736 737 738/* 739 * This fails on the Cyrix MediaGX. If you don't have the DMA enabled 740 * before the first sample arrives it locks up. However even if you 741 * do enable the DMA in time you just get DMA timeouts and missing 742 * interrupts and stuff, so for now I've not bothered fixing this either. 743 */ 744 745static void sb16_audio_start_input(int dev, unsigned long buf, int count, int intrflag) 746{ 747 unsigned long flags, cnt; 748 sb_devc *devc = audio_devs[dev]->devc; 749 750 if (!devc->fullduplex || devc->bits != AFMT_S16_LE) 751 { 752 devc->irq_mode = IMODE_INPUT; 753 devc->intr_active = 1; 754 } 755 else 756 { 757 devc->irq_mode_16 = IMODE_INPUT; 758 devc->intr_active_16 = 1; 759 } 760 761 cnt = count; 762 if (devc->bits == AFMT_S16_LE) 763 cnt >>= 1; 764 cnt--; 765 766 spin_lock_irqsave(&devc->lock, flags); 767 768 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */ 769 770 sb_dsp_command(devc, 0x42); 771 sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff)); 772 sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff)); 773 774 sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xbe : 0xce)); 775 sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) + 776 (devc->bits == AFMT_S16_LE ? 0x10 : 0))); 777 sb_dsp_command(devc, (unsigned char) (cnt & 0xff)); 778 sb_dsp_command(devc, (unsigned char) (cnt >> 8)); 779 780 spin_unlock_irqrestore(&devc->lock, flags); 781} 782 783static void sb16_audio_trigger(int dev, int bits) 784{ 785 sb_devc *devc = audio_devs[dev]->devc; 786 787 int bits_16 = bits & devc->irq_mode_16; 788 bits &= devc->irq_mode; 789 790 if (!bits && !bits_16) 791 sb_dsp_command(devc, 0xd0); /* Halt DMA */ 792 else 793 { 794 if (bits) 795 { 796 switch (devc->irq_mode) 797 { 798 case IMODE_INPUT: 799 sb16_audio_start_input(dev, 800 devc->trg_buf, 801 devc->trg_bytes, 802 devc->trg_intrflag); 803 break; 804 805 case IMODE_OUTPUT: 806 sb16_audio_output_block(dev, 807 devc->trg_buf, 808 devc->trg_bytes, 809 devc->trg_intrflag); 810 break; 811 } 812 } 813 if (bits_16) 814 { 815 switch (devc->irq_mode_16) 816 { 817 case IMODE_INPUT: 818 sb16_audio_start_input(dev, 819 devc->trg_buf_16, 820 devc->trg_bytes_16, 821 devc->trg_intrflag_16); 822 break; 823 824 case IMODE_OUTPUT: 825 sb16_audio_output_block(dev, 826 devc->trg_buf_16, 827 devc->trg_bytes_16, 828 devc->trg_intrflag_16); 829 break; 830 } 831 } 832 } 833 834 devc->trigger_bits = bits | bits_16; 835} 836 837static unsigned char lbuf8[2048]; 838static signed short *lbuf16 = (signed short *)lbuf8; 839#define LBUFCOPYSIZE 1024 840static void 841sb16_copy_from_user(int dev, 842 char *localbuf, int localoffs, 843 const char __user *userbuf, int useroffs, 844 int max_in, int max_out, 845 int *used, int *returned, 846 int len) 847{ 848 sb_devc *devc = audio_devs[dev]->devc; 849 int i, c, p, locallen; 850 unsigned char *buf8; 851 signed short *buf16; 852 853 /* if not duplex no conversion */ 854 if (!devc->fullduplex) 855 { 856 if (copy_from_user(localbuf + localoffs, 857 userbuf + useroffs, len)) 858 return; 859 *used = len; 860 *returned = len; 861 } 862 else if (devc->bits == AFMT_S16_LE) 863 { 864 /* 16 -> 8 */ 865 /* max_in >> 1, max number of samples in ( 16 bits ) */ 866 /* max_out, max number of samples out ( 8 bits ) */ 867 /* len, number of samples that will be taken ( 16 bits )*/ 868 /* c, count of samples remaining in buffer ( 16 bits )*/ 869 /* p, count of samples already processed ( 16 bits )*/ 870 len = ( (max_in >> 1) > max_out) ? max_out : (max_in >> 1); 871 c = len; 872 p = 0; 873 buf8 = (unsigned char *)(localbuf + localoffs); 874 while (c) 875 { 876 locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c); 877 /* << 1 in order to get 16 bit samples */ 878 if (copy_from_user(lbuf16, 879 userbuf + useroffs + (p << 1), 880 locallen << 1)) 881 return; 882 for (i = 0; i < locallen; i++) 883 { 884 buf8[p+i] = ~((lbuf16[i] >> 8) & 0xff) ^ 0x80; 885 } 886 c -= locallen; p += locallen; 887 } 888 /* used = ( samples * 16 bits size ) */ 889 *used = max_in > ( max_out << 1) ? (max_out << 1) : max_in; 890 /* returned = ( samples * 8 bits size ) */ 891 *returned = len; 892 } 893 else 894 { 895 /* 8 -> 16 */ 896 /* max_in, max number of samples in ( 8 bits ) */ 897 /* max_out >> 1, max number of samples out ( 16 bits ) */ 898 /* len, number of samples that will be taken ( 8 bits )*/ 899 /* c, count of samples remaining in buffer ( 8 bits )*/ 900 /* p, count of samples already processed ( 8 bits )*/ 901 len = max_in > (max_out >> 1) ? (max_out >> 1) : max_in; 902 c = len; 903 p = 0; 904 buf16 = (signed short *)(localbuf + localoffs); 905 while (c) 906 { 907 locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c); 908 if (copy_from_user(lbuf8, 909 userbuf+useroffs + p, 910 locallen)) 911 return; 912 for (i = 0; i < locallen; i++) 913 { 914 buf16[p+i] = (~lbuf8[i] ^ 0x80) << 8; 915 } 916 c -= locallen; p += locallen; 917 } 918 /* used = ( samples * 8 bits size ) */ 919 *used = len; 920 /* returned = ( samples * 16 bits size ) */ 921 *returned = len << 1; 922 } 923} 924 925static void 926sb16_audio_mmap(int dev) 927{ 928 sb_devc *devc = audio_devs[dev]->devc; 929 devc->fullduplex = 0; 930} 931 932static struct audio_driver sb1_audio_driver = /* SB1.x */ 933{ 934 .owner = THIS_MODULE, 935 .open = sb_audio_open, 936 .close = sb_audio_close, 937 .output_block = sb_set_output_parms, 938 .start_input = sb_set_input_parms, 939 .prepare_for_input = sb1_audio_prepare_for_input, 940 .prepare_for_output = sb1_audio_prepare_for_output, 941 .halt_io = sb1_audio_halt_xfer, 942 .trigger = sb1_audio_trigger, 943 .set_speed = sb1_audio_set_speed, 944 .set_bits = sb1_audio_set_bits, 945 .set_channels = sb1_audio_set_channels 946}; 947 948static struct audio_driver sb20_audio_driver = /* SB2.0 */ 949{ 950 .owner = THIS_MODULE, 951 .open = sb_audio_open, 952 .close = sb_audio_close, 953 .output_block = sb_set_output_parms, 954 .start_input = sb_set_input_parms, 955 .prepare_for_input = sb1_audio_prepare_for_input, 956 .prepare_for_output = sb1_audio_prepare_for_output, 957 .halt_io = sb1_audio_halt_xfer, 958 .trigger = sb20_audio_trigger, 959 .set_speed = sb1_audio_set_speed, 960 .set_bits = sb1_audio_set_bits, 961 .set_channels = sb1_audio_set_channels 962}; 963 964static struct audio_driver sb201_audio_driver = /* SB2.01 */ 965{ 966 .owner = THIS_MODULE, 967 .open = sb_audio_open, 968 .close = sb_audio_close, 969 .output_block = sb_set_output_parms, 970 .start_input = sb_set_input_parms, 971 .prepare_for_input = sb1_audio_prepare_for_input, 972 .prepare_for_output = sb1_audio_prepare_for_output, 973 .halt_io = sb1_audio_halt_xfer, 974 .trigger = sb20_audio_trigger, 975 .set_speed = sb201_audio_set_speed, 976 .set_bits = sb1_audio_set_bits, 977 .set_channels = sb1_audio_set_channels 978}; 979 980static struct audio_driver sbpro_audio_driver = /* SB Pro */ 981{ 982 .owner = THIS_MODULE, 983 .open = sb_audio_open, 984 .close = sb_audio_close, 985 .output_block = sb_set_output_parms, 986 .start_input = sb_set_input_parms, 987 .prepare_for_input = sbpro_audio_prepare_for_input, 988 .prepare_for_output = sbpro_audio_prepare_for_output, 989 .halt_io = sb1_audio_halt_xfer, 990 .trigger = sb20_audio_trigger, 991 .set_speed = sbpro_audio_set_speed, 992 .set_bits = sb1_audio_set_bits, 993 .set_channels = sbpro_audio_set_channels 994}; 995 996static struct audio_driver jazz16_audio_driver = /* Jazz16 and SM Wave */ 997{ 998 .owner = THIS_MODULE, 999 .open = sb_audio_open, 1000 .close = sb_audio_close, 1001 .output_block = sb_set_output_parms, 1002 .start_input = sb_set_input_parms, 1003 .prepare_for_input = sbpro_audio_prepare_for_input, 1004 .prepare_for_output = sbpro_audio_prepare_for_output, 1005 .halt_io = sb1_audio_halt_xfer, 1006 .trigger = sb20_audio_trigger, 1007 .set_speed = jazz16_audio_set_speed, 1008 .set_bits = sb16_audio_set_bits, 1009 .set_channels = sbpro_audio_set_channels 1010}; 1011 1012static struct audio_driver sb16_audio_driver = /* SB16 */ 1013{ 1014 .owner = THIS_MODULE, 1015 .open = sb_audio_open, 1016 .close = sb_audio_close, 1017 .output_block = sb_set_output_parms, 1018 .start_input = sb_set_input_parms, 1019 .prepare_for_input = sb16_audio_prepare_for_input, 1020 .prepare_for_output = sb16_audio_prepare_for_output, 1021 .halt_io = sb1_audio_halt_xfer, 1022 .copy_user = sb16_copy_from_user, 1023 .trigger = sb16_audio_trigger, 1024 .set_speed = sb16_audio_set_speed, 1025 .set_bits = sb16_audio_set_bits, 1026 .set_channels = sbpro_audio_set_channels, 1027 .mmap = sb16_audio_mmap 1028}; 1029 1030void sb_audio_init(sb_devc * devc, char *name, struct module *owner) 1031{ 1032 int audio_flags = 0; 1033 int format_mask = AFMT_U8; 1034 1035 struct audio_driver *driver = &sb1_audio_driver; 1036 1037 switch (devc->model) 1038 { 1039 case MDL_SB1: /* SB1.0 or SB 1.5 */ 1040 DDB(printk("Will use standard SB1.x driver\n")); 1041 audio_flags = DMA_HARDSTOP; 1042 break; 1043 1044 case MDL_SB2: 1045 DDB(printk("Will use SB2.0 driver\n")); 1046 audio_flags = DMA_AUTOMODE; 1047 driver = &sb20_audio_driver; 1048 break; 1049 1050 case MDL_SB201: 1051 DDB(printk("Will use SB2.01 (high speed) driver\n")); 1052 audio_flags = DMA_AUTOMODE; 1053 driver = &sb201_audio_driver; 1054 break; 1055 1056 case MDL_JAZZ: 1057 case MDL_SMW: 1058 DDB(printk("Will use Jazz16 driver\n")); 1059 audio_flags = DMA_AUTOMODE; 1060 format_mask |= AFMT_S16_LE; 1061 driver = &jazz16_audio_driver; 1062 break; 1063 1064 case MDL_ESS: 1065 DDB(printk("Will use ESS ES688/1688 driver\n")); 1066 driver = ess_audio_init (devc, &audio_flags, &format_mask); 1067 break; 1068 1069 case MDL_SB16: 1070 DDB(printk("Will use SB16 driver\n")); 1071 audio_flags = DMA_AUTOMODE; 1072 format_mask |= AFMT_S16_LE; 1073 if (devc->dma8 != devc->dma16 && devc->dma16 != -1) 1074 { 1075 audio_flags |= DMA_DUPLEX; 1076 devc->duplex = 1; 1077 } 1078 driver = &sb16_audio_driver; 1079 break; 1080 1081 default: 1082 DDB(printk("Will use SB Pro driver\n")); 1083 audio_flags = DMA_AUTOMODE; 1084 driver = &sbpro_audio_driver; 1085 } 1086 1087 if (owner) 1088 driver->owner = owner; 1089 1090 if ((devc->dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, 1091 name,driver, sizeof(struct audio_driver), 1092 audio_flags, format_mask, devc, 1093 devc->dma8, 1094 devc->duplex ? devc->dma16 : devc->dma8)) < 0) 1095 { 1096 printk(KERN_ERR "Sound Blaster: unable to install audio.\n"); 1097 return; 1098 } 1099 audio_devs[devc->dev]->mixer_dev = devc->my_mixerdev; 1100 audio_devs[devc->dev]->min_fragment = 5; 1101} 1102