1/* 2 * sound/oss/sb_common.c 3 * 4 * Common 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 * 14 * Daniel J. Rodriksson: Modified sbintr to handle 8 and 16 bit interrupts 15 * for full duplex support ( only sb16 by now ) 16 * Rolf Fokkens: Added (BETA?) support for ES1887 chips. 17 * (fokkensr@vertis.nl) Which means: You can adjust the recording levels. 18 * 19 * 2000/01/18 - separated sb_card and sb_common - 20 * Jeff Garzik <jgarzik@pobox.com> 21 * 22 * 2000/09/18 - got rid of attach_uart401 23 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> 24 * 25 * 2001/01/26 - replaced CLI/STI with spinlocks 26 * Chris Rankin <rankinc@zipworld.com.au> 27 */ 28 29#include <linux/init.h> 30#include <linux/interrupt.h> 31#include <linux/module.h> 32#include <linux/delay.h> 33#include <linux/spinlock.h> 34#include <linux/slab.h> 35 36#include "sound_config.h" 37#include "sound_firmware.h" 38 39#include "mpu401.h" 40 41#include "sb_mixer.h" 42#include "sb.h" 43#include "sb_ess.h" 44 45/* 46 * global module flag 47 */ 48 49int sb_be_quiet; 50 51static sb_devc *detected_devc; /* For communication from probe to init */ 52static sb_devc *last_devc; /* For MPU401 initialization */ 53 54static unsigned char jazz_irq_bits[] = { 55 0, 0, 2, 3, 0, 1, 0, 4, 0, 2, 5, 0, 0, 0, 0, 6 56}; 57 58static unsigned char jazz_dma_bits[] = { 59 0, 1, 0, 2, 0, 3, 0, 4 60}; 61 62void *smw_free; 63 64/* 65 * Jazz16 chipset specific control variables 66 */ 67 68static int jazz16_base; /* Not detected */ 69static unsigned char jazz16_bits; /* I/O relocation bits */ 70static DEFINE_SPINLOCK(jazz16_lock); 71 72/* 73 * Logitech Soundman Wave specific initialization code 74 */ 75 76#ifdef SMW_MIDI0001_INCLUDED 77#include "smw-midi0001.h" 78#else 79static unsigned char *smw_ucode; 80static int smw_ucodeLen; 81 82#endif 83 84static sb_devc *last_sb; /* Last sb loaded */ 85 86int sb_dsp_command(sb_devc * devc, unsigned char val) 87{ 88 int i; 89 unsigned long limit; 90 91 limit = jiffies + HZ / 10; /* Timeout */ 92 93 /* 94 * Note! the i<500000 is an emergency exit. The sb_dsp_command() is sometimes 95 * called while interrupts are disabled. This means that the timer is 96 * disabled also. However the timeout situation is a abnormal condition. 97 * Normally the DSP should be ready to accept commands after just couple of 98 * loops. 99 */ 100 101 for (i = 0; i < 500000 && (limit-jiffies)>0; i++) 102 { 103 if ((inb(DSP_STATUS) & 0x80) == 0) 104 { 105 outb((val), DSP_COMMAND); 106 return 1; 107 } 108 } 109 printk(KERN_WARNING "Sound Blaster: DSP command(%x) timeout.\n", val); 110 return 0; 111} 112 113int sb_dsp_get_byte(sb_devc * devc) 114{ 115 int i; 116 117 for (i = 1000; i; i--) 118 { 119 if (inb(DSP_DATA_AVAIL) & 0x80) 120 return inb(DSP_READ); 121 } 122 return 0xffff; 123} 124 125static void sb_intr (sb_devc *devc) 126{ 127 int status; 128 unsigned char src = 0xff; 129 130 if (devc->model == MDL_SB16) 131 { 132 src = sb_getmixer(devc, IRQ_STAT); /* Interrupt source register */ 133 134 if (src & 4) /* MPU401 interrupt */ 135 if(devc->midi_irq_cookie) 136 uart401intr(devc->irq, devc->midi_irq_cookie); 137 138 if (!(src & 3)) 139 return; /* Not a DSP interrupt */ 140 } 141 if (devc->intr_active && (!devc->fullduplex || (src & 0x01))) 142 { 143 switch (devc->irq_mode) 144 { 145 case IMODE_OUTPUT: 146 DMAbuf_outputintr(devc->dev, 1); 147 break; 148 149 case IMODE_INPUT: 150 DMAbuf_inputintr(devc->dev); 151 break; 152 153 case IMODE_INIT: 154 break; 155 156 case IMODE_MIDI: 157 sb_midi_interrupt(devc); 158 break; 159 160 default: 161 /* printk(KERN_WARNING "Sound Blaster: Unexpected interrupt\n"); */ 162 ; 163 } 164 } 165 else if (devc->intr_active_16 && (src & 0x02)) 166 { 167 switch (devc->irq_mode_16) 168 { 169 case IMODE_OUTPUT: 170 DMAbuf_outputintr(devc->dev, 1); 171 break; 172 173 case IMODE_INPUT: 174 DMAbuf_inputintr(devc->dev); 175 break; 176 177 case IMODE_INIT: 178 break; 179 180 default: 181 /* printk(KERN_WARNING "Sound Blaster: Unexpected interrupt\n"); */ 182 ; 183 } 184 } 185 /* 186 * Acknowledge interrupts 187 */ 188 189 if (src & 0x01) 190 status = inb(DSP_DATA_AVAIL); 191 192 if (devc->model == MDL_SB16 && src & 0x02) 193 status = inb(DSP_DATA_AVL16); 194} 195 196static void pci_intr(sb_devc *devc) 197{ 198 int src = inb(devc->pcibase+0x1A); 199 src&=3; 200 if(src) 201 sb_intr(devc); 202} 203 204static irqreturn_t sbintr(int irq, void *dev_id) 205{ 206 sb_devc *devc = dev_id; 207 208 devc->irq_ok = 1; 209 210 switch (devc->model) { 211 case MDL_ESSPCI: 212 pci_intr (devc); 213 break; 214 215 case MDL_ESS: 216 ess_intr (devc); 217 break; 218 default: 219 sb_intr (devc); 220 break; 221 } 222 return IRQ_HANDLED; 223} 224 225int sb_dsp_reset(sb_devc * devc) 226{ 227 int loopc; 228 229 DEB(printk("Entered sb_dsp_reset()\n")); 230 231 if (devc->model == MDL_ESS) return ess_dsp_reset (devc); 232 233 /* This is only for non-ESS chips */ 234 235 outb(1, DSP_RESET); 236 237 udelay(10); 238 outb(0, DSP_RESET); 239 udelay(30); 240 241 for (loopc = 0; loopc < 1000 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++); 242 243 if (inb(DSP_READ) != 0xAA) 244 { 245 DDB(printk("sb: No response to RESET\n")); 246 return 0; /* Sorry */ 247 } 248 249 DEB(printk("sb_dsp_reset() OK\n")); 250 251 return 1; 252} 253 254static void dsp_get_vers(sb_devc * devc) 255{ 256 int i; 257 258 unsigned long flags; 259 260 DDB(printk("Entered dsp_get_vers()\n")); 261 spin_lock_irqsave(&devc->lock, flags); 262 devc->major = devc->minor = 0; 263 sb_dsp_command(devc, 0xe1); /* Get version */ 264 265 for (i = 100000; i; i--) 266 { 267 if (inb(DSP_DATA_AVAIL) & 0x80) 268 { 269 if (devc->major == 0) 270 devc->major = inb(DSP_READ); 271 else 272 { 273 devc->minor = inb(DSP_READ); 274 break; 275 } 276 } 277 } 278 spin_unlock_irqrestore(&devc->lock, flags); 279 DDB(printk("DSP version %d.%02d\n", devc->major, devc->minor)); 280} 281 282static int sb16_set_dma_hw(sb_devc * devc) 283{ 284 int bits; 285 286 if (devc->dma8 != 0 && devc->dma8 != 1 && devc->dma8 != 3) 287 { 288 printk(KERN_ERR "SB16: Invalid 8 bit DMA (%d)\n", devc->dma8); 289 return 0; 290 } 291 bits = (1 << devc->dma8); 292 293 if (devc->dma16 >= 5 && devc->dma16 <= 7) 294 bits |= (1 << devc->dma16); 295 296 sb_setmixer(devc, DMA_NR, bits); 297 return 1; 298} 299 300static void sb16_set_mpu_port(sb_devc * devc, struct address_info *hw_config) 301{ 302 /* 303 * This routine initializes new MIDI port setup register of SB Vibra (CT2502). 304 */ 305 unsigned char bits = sb_getmixer(devc, 0x84) & ~0x06; 306 307 switch (hw_config->io_base) 308 { 309 case 0x300: 310 sb_setmixer(devc, 0x84, bits | 0x04); 311 break; 312 313 case 0x330: 314 sb_setmixer(devc, 0x84, bits | 0x00); 315 break; 316 317 default: 318 sb_setmixer(devc, 0x84, bits | 0x02); /* Disable MPU */ 319 printk(KERN_ERR "SB16: Invalid MIDI I/O port %x\n", hw_config->io_base); 320 } 321} 322 323static int sb16_set_irq_hw(sb_devc * devc, int level) 324{ 325 int ival; 326 327 switch (level) 328 { 329 case 5: 330 ival = 2; 331 break; 332 case 7: 333 ival = 4; 334 break; 335 case 9: 336 ival = 1; 337 break; 338 case 10: 339 ival = 8; 340 break; 341 default: 342 printk(KERN_ERR "SB16: Invalid IRQ%d\n", level); 343 return 0; 344 } 345 sb_setmixer(devc, IRQ_NR, ival); 346 return 1; 347} 348 349static void relocate_Jazz16(sb_devc * devc, struct address_info *hw_config) 350{ 351 unsigned char bits = 0; 352 unsigned long flags; 353 354 if (jazz16_base != 0 && jazz16_base != hw_config->io_base) 355 return; 356 357 switch (hw_config->io_base) 358 { 359 case 0x220: 360 bits = 1; 361 break; 362 case 0x240: 363 bits = 2; 364 break; 365 case 0x260: 366 bits = 3; 367 break; 368 default: 369 return; 370 } 371 bits = jazz16_bits = bits << 5; 372 jazz16_base = hw_config->io_base; 373 374 /* 375 * Magic wake up sequence by writing to 0x201 (aka Joystick port) 376 */ 377 spin_lock_irqsave(&jazz16_lock, flags); 378 outb((0xAF), 0x201); 379 outb((0x50), 0x201); 380 outb((bits), 0x201); 381 spin_unlock_irqrestore(&jazz16_lock, flags); 382} 383 384static int init_Jazz16(sb_devc * devc, struct address_info *hw_config) 385{ 386 char name[100]; 387 /* 388 * First try to check that the card has Jazz16 chip. It identifies itself 389 * by returning 0x12 as response to DSP command 0xfa. 390 */ 391 392 if (!sb_dsp_command(devc, 0xfa)) 393 return 0; 394 395 if (sb_dsp_get_byte(devc) != 0x12) 396 return 0; 397 398 /* 399 * OK so far. Now configure the IRQ and DMA channel used by the card. 400 */ 401 if (hw_config->irq < 1 || hw_config->irq > 15 || jazz_irq_bits[hw_config->irq] == 0) 402 { 403 printk(KERN_ERR "Jazz16: Invalid interrupt (IRQ%d)\n", hw_config->irq); 404 return 0; 405 } 406 if (hw_config->dma < 0 || hw_config->dma > 3 || jazz_dma_bits[hw_config->dma] == 0) 407 { 408 printk(KERN_ERR "Jazz16: Invalid 8 bit DMA (DMA%d)\n", hw_config->dma); 409 return 0; 410 } 411 if (hw_config->dma2 < 0) 412 { 413 printk(KERN_ERR "Jazz16: No 16 bit DMA channel defined\n"); 414 return 0; 415 } 416 if (hw_config->dma2 < 5 || hw_config->dma2 > 7 || jazz_dma_bits[hw_config->dma2] == 0) 417 { 418 printk(KERN_ERR "Jazz16: Invalid 16 bit DMA (DMA%d)\n", hw_config->dma2); 419 return 0; 420 } 421 devc->dma16 = hw_config->dma2; 422 423 if (!sb_dsp_command(devc, 0xfb)) 424 return 0; 425 426 if (!sb_dsp_command(devc, jazz_dma_bits[hw_config->dma] | 427 (jazz_dma_bits[hw_config->dma2] << 4))) 428 return 0; 429 430 if (!sb_dsp_command(devc, jazz_irq_bits[hw_config->irq])) 431 return 0; 432 433 /* 434 * Now we have configured a standard Jazz16 device. 435 */ 436 devc->model = MDL_JAZZ; 437 strcpy(name, "Jazz16"); 438 439 hw_config->name = "Jazz16"; 440 devc->caps |= SB_NO_MIDI; 441 return 1; 442} 443 444static void relocate_ess1688(sb_devc * devc) 445{ 446 unsigned char bits; 447 448 switch (devc->base) 449 { 450 case 0x220: 451 bits = 0x04; 452 break; 453 case 0x230: 454 bits = 0x05; 455 break; 456 case 0x240: 457 bits = 0x06; 458 break; 459 case 0x250: 460 bits = 0x07; 461 break; 462 default: 463 return; /* Wrong port */ 464 } 465 466 DDB(printk("Doing ESS1688 address selection\n")); 467 468 /* 469 * ES1688 supports two alternative ways for software address config. 470 * First try the so called Read-Sequence-Key method. 471 */ 472 473 /* Reset the sequence logic */ 474 inb(0x229); 475 inb(0x229); 476 inb(0x229); 477 478 /* Perform the read sequence */ 479 inb(0x22b); 480 inb(0x229); 481 inb(0x22b); 482 inb(0x229); 483 inb(0x229); 484 inb(0x22b); 485 inb(0x229); 486 487 /* Select the base address by reading from it. Then probe using the port. */ 488 inb(devc->base); 489 if (sb_dsp_reset(devc)) /* Bingo */ 490 return; 491 492} 493 494int sb_dsp_detect(struct address_info *hw_config, int pci, int pciio, struct sb_module_options *sbmo) 495{ 496 sb_devc sb_info; 497 sb_devc *devc = &sb_info; 498 499 memset((char *) &sb_info, 0, sizeof(sb_info)); /* Zero everything */ 500 501 /* Copy module options in place */ 502 if(sbmo) memcpy(&devc->sbmo, sbmo, sizeof(struct sb_module_options)); 503 504 sb_info.my_mididev = -1; 505 sb_info.my_mixerdev = -1; 506 sb_info.dev = -1; 507 508 /* 509 * Initialize variables 510 */ 511 512 DDB(printk("sb_dsp_detect(%x) entered\n", hw_config->io_base)); 513 514 spin_lock_init(&devc->lock); 515 devc->type = hw_config->card_subtype; 516 517 devc->base = hw_config->io_base; 518 devc->irq = hw_config->irq; 519 devc->dma8 = hw_config->dma; 520 521 devc->dma16 = -1; 522 devc->pcibase = pciio; 523 524 if(pci == SB_PCI_ESSMAESTRO) 525 { 526 devc->model = MDL_ESSPCI; 527 devc->caps |= SB_PCI_IRQ; 528 hw_config->driver_use_1 |= SB_PCI_IRQ; 529 hw_config->card_subtype = MDL_ESSPCI; 530 } 531 532 if(pci == SB_PCI_YAMAHA) 533 { 534 devc->model = MDL_YMPCI; 535 devc->caps |= SB_PCI_IRQ; 536 hw_config->driver_use_1 |= SB_PCI_IRQ; 537 hw_config->card_subtype = MDL_YMPCI; 538 539 printk("Yamaha PCI mode.\n"); 540 } 541 542 if (devc->sbmo.acer) 543 { 544 unsigned long flags; 545 546 spin_lock_irqsave(&devc->lock, flags); 547 inb(devc->base + 0x09); 548 inb(devc->base + 0x09); 549 inb(devc->base + 0x09); 550 inb(devc->base + 0x0b); 551 inb(devc->base + 0x09); 552 inb(devc->base + 0x0b); 553 inb(devc->base + 0x09); 554 inb(devc->base + 0x09); 555 inb(devc->base + 0x0b); 556 inb(devc->base + 0x09); 557 inb(devc->base + 0x00); 558 spin_unlock_irqrestore(&devc->lock, flags); 559 } 560 /* 561 * Detect the device 562 */ 563 564 if (sb_dsp_reset(devc)) 565 dsp_get_vers(devc); 566 else 567 devc->major = 0; 568 569 if (devc->type == 0 || devc->type == MDL_JAZZ || devc->type == MDL_SMW) 570 if (devc->major == 0 || (devc->major == 3 && devc->minor == 1)) 571 relocate_Jazz16(devc, hw_config); 572 573 if (devc->major == 0 && (devc->type == MDL_ESS || devc->type == 0)) 574 relocate_ess1688(devc); 575 576 if (!sb_dsp_reset(devc)) 577 { 578 DDB(printk("SB reset failed\n")); 579#ifdef MODULE 580 printk(KERN_INFO "sb: dsp reset failed.\n"); 581#endif 582 return 0; 583 } 584 if (devc->major == 0) 585 dsp_get_vers(devc); 586 587 if (devc->major == 3 && devc->minor == 1) 588 { 589 if (devc->type == MDL_AZTECH) /* SG Washington? */ 590 { 591 if (sb_dsp_command(devc, 0x09)) 592 if (sb_dsp_command(devc, 0x00)) /* Enter WSS mode */ 593 { 594 int i; 595 596 /* Have some delay */ 597 for (i = 0; i < 10000; i++) 598 inb(DSP_DATA_AVAIL); 599 devc->caps = SB_NO_AUDIO | SB_NO_MIDI; /* Mixer only */ 600 devc->model = MDL_AZTECH; 601 } 602 } 603 } 604 605 if(devc->type == MDL_ESSPCI) 606 devc->model = MDL_ESSPCI; 607 608 if(devc->type == MDL_YMPCI) 609 { 610 printk("YMPCI selected\n"); 611 devc->model = MDL_YMPCI; 612 } 613 614 /* 615 * Save device information for sb_dsp_init() 616 */ 617 618 619 detected_devc = kmalloc(sizeof(sb_devc), GFP_KERNEL); 620 if (detected_devc == NULL) 621 { 622 printk(KERN_ERR "sb: Can't allocate memory for device information\n"); 623 return 0; 624 } 625 memcpy(detected_devc, devc, sizeof(sb_devc)); 626 MDB(printk(KERN_INFO "SB %d.%02d detected OK (%x)\n", devc->major, devc->minor, hw_config->io_base)); 627 return 1; 628} 629 630int sb_dsp_init(struct address_info *hw_config, struct module *owner) 631{ 632 sb_devc *devc; 633 char name[100]; 634 extern int sb_be_quiet; 635 int mixer22, mixer30; 636 637/* 638 * Check if we had detected a SB device earlier 639 */ 640 DDB(printk("sb_dsp_init(%x) entered\n", hw_config->io_base)); 641 name[0] = 0; 642 643 if (detected_devc == NULL) 644 { 645 MDB(printk("No detected device\n")); 646 return 0; 647 } 648 devc = detected_devc; 649 detected_devc = NULL; 650 651 if (devc->base != hw_config->io_base) 652 { 653 DDB(printk("I/O port mismatch\n")); 654 release_region(devc->base, 16); 655 return 0; 656 } 657 /* 658 * Now continue initialization of the device 659 */ 660 661 devc->caps = hw_config->driver_use_1; 662 663 if (!((devc->caps & SB_NO_AUDIO) && (devc->caps & SB_NO_MIDI)) && hw_config->irq > 0) 664 { /* IRQ setup */ 665 666 /* 667 * ESS PCI cards do shared PCI IRQ stuff. Since they 668 * will get shared PCI irq lines we must cope. 669 */ 670 671 int i=(devc->caps&SB_PCI_IRQ)?IRQF_SHARED:0; 672 673 if (request_irq(hw_config->irq, sbintr, i, "soundblaster", devc) < 0) 674 { 675 printk(KERN_ERR "SB: Can't allocate IRQ%d\n", hw_config->irq); 676 release_region(devc->base, 16); 677 return 0; 678 } 679 devc->irq_ok = 0; 680 681 if (devc->major == 4) 682 if (!sb16_set_irq_hw(devc, devc->irq)) /* Unsupported IRQ */ 683 { 684 free_irq(devc->irq, devc); 685 release_region(devc->base, 16); 686 return 0; 687 } 688 if ((devc->type == 0 || devc->type == MDL_ESS) && 689 devc->major == 3 && devc->minor == 1) 690 { /* Handle various chipsets which claim they are SB Pro compatible */ 691 if ((devc->type != 0 && devc->type != MDL_ESS) || 692 !ess_init(devc, hw_config)) 693 { 694 if ((devc->type != 0 && devc->type != MDL_JAZZ && 695 devc->type != MDL_SMW) || !init_Jazz16(devc, hw_config)) 696 { 697 DDB(printk("This is a genuine SB Pro\n")); 698 } 699 } 700 } 701 if (devc->major == 4 && devc->minor <= 11 ) /* Won't work */ 702 devc->irq_ok = 1; 703 else 704 { 705 int n; 706 707 for (n = 0; n < 3 && devc->irq_ok == 0; n++) 708 { 709 if (sb_dsp_command(devc, 0xf2)) /* Cause interrupt immediately */ 710 { 711 int i; 712 713 for (i = 0; !devc->irq_ok && i < 10000; i++); 714 } 715 } 716 if (!devc->irq_ok) 717 printk(KERN_WARNING "sb: Interrupt test on IRQ%d failed - Probable IRQ conflict\n", devc->irq); 718 else 719 { 720 DDB(printk("IRQ test OK (IRQ%d)\n", devc->irq)); 721 } 722 } 723 } /* IRQ setup */ 724 725 last_sb = devc; 726 727 switch (devc->major) 728 { 729 case 1: /* SB 1.0 or 1.5 */ 730 devc->model = hw_config->card_subtype = MDL_SB1; 731 break; 732 733 case 2: /* SB 2.x */ 734 if (devc->minor == 0) 735 devc->model = hw_config->card_subtype = MDL_SB2; 736 else 737 devc->model = hw_config->card_subtype = MDL_SB201; 738 break; 739 740 case 3: /* SB Pro and most clones */ 741 switch (devc->model) { 742 case 0: 743 devc->model = hw_config->card_subtype = MDL_SBPRO; 744 if (hw_config->name == NULL) 745 hw_config->name = "Sound Blaster Pro (8 BIT ONLY)"; 746 break; 747 case MDL_ESS: 748 ess_dsp_init(devc, hw_config); 749 break; 750 } 751 break; 752 753 case 4: 754 devc->model = hw_config->card_subtype = MDL_SB16; 755 /* 756 * ALS007 and ALS100 return DSP version 4.2 and have 2 post-reset !=0 757 * registers at 0x3c and 0x4c (output ctrl registers on ALS007) whereas 758 * a "standard" SB16 doesn't have a register at 0x4c. ALS100 actively 759 * updates register 0x22 whenever 0x30 changes, as per the SB16 spec. 760 * Since ALS007 doesn't, this can be used to differentiate the 2 cards. 761 */ 762 if ((devc->minor == 2) && sb_getmixer(devc,0x3c) && sb_getmixer(devc,0x4c)) 763 { 764 mixer30 = sb_getmixer(devc,0x30); 765 sb_setmixer(devc,0x22,(mixer22=sb_getmixer(devc,0x22)) & 0x0f); 766 sb_setmixer(devc,0x30,0xff); 767 /* ALS100 will force 0x30 to 0xf8 like SB16; ALS007 will allow 0xff. */ 768 /* Register 0x22 & 0xf0 on ALS100 == 0xf0; on ALS007 it == 0x10. */ 769 if ((sb_getmixer(devc,0x30) != 0xff) || ((sb_getmixer(devc,0x22) & 0xf0) != 0x10)) 770 { 771 devc->submodel = SUBMDL_ALS100; 772 if (hw_config->name == NULL) 773 hw_config->name = "Sound Blaster 16 (ALS-100)"; 774 } 775 else 776 { 777 sb_setmixer(devc,0x3c,0x1f); /* Enable all inputs */ 778 sb_setmixer(devc,0x4c,0x1f); 779 sb_setmixer(devc,0x22,mixer22); /* Restore 0x22 to original value */ 780 devc->submodel = SUBMDL_ALS007; 781 if (hw_config->name == NULL) 782 hw_config->name = "Sound Blaster 16 (ALS-007)"; 783 } 784 sb_setmixer(devc,0x30,mixer30); 785 } 786 else if (hw_config->name == NULL) 787 hw_config->name = "Sound Blaster 16"; 788 789 if (hw_config->dma2 == -1) 790 devc->dma16 = devc->dma8; 791 else if (hw_config->dma2 < 5 || hw_config->dma2 > 7) 792 { 793 printk(KERN_WARNING "SB16: Bad or missing 16 bit DMA channel\n"); 794 devc->dma16 = devc->dma8; 795 } 796 else 797 devc->dma16 = hw_config->dma2; 798 799 if(!sb16_set_dma_hw(devc)) { 800 free_irq(devc->irq, devc); 801 release_region(hw_config->io_base, 16); 802 return 0; 803 } 804 805 devc->caps |= SB_NO_MIDI; 806 } 807 808 if (!(devc->caps & SB_NO_MIXER)) 809 if (devc->major == 3 || devc->major == 4) 810 sb_mixer_init(devc, owner); 811 812 if (!(devc->caps & SB_NO_MIDI)) 813 sb_dsp_midi_init(devc, owner); 814 815 if (hw_config->name == NULL) 816 hw_config->name = "Sound Blaster (8 BIT/MONO ONLY)"; 817 818 sprintf(name, "%s (%d.%02d)", hw_config->name, devc->major, devc->minor); 819 conf_printf(name, hw_config); 820 821 /* 822 * Assuming that a sound card is Sound Blaster (compatible) is the most common 823 * configuration error and the mother of all problems. Usually sound cards 824 * emulate SB Pro but in addition they have a 16 bit native mode which should be 825 * used in Unix. See Readme.cards for more information about configuring OSS/Free 826 * properly. 827 */ 828 if (devc->model <= MDL_SBPRO) 829 { 830 if (devc->major == 3 && devc->minor != 1) /* "True" SB Pro should have v3.1 (rare ones may have 3.2). */ 831 { 832 printk(KERN_INFO "This sound card may not be fully Sound Blaster Pro compatible.\n"); 833 printk(KERN_INFO "In many cases there is another way to configure OSS so that\n"); 834 printk(KERN_INFO "it works properly with OSS (for example in 16 bit mode).\n"); 835 printk(KERN_INFO "Please ignore this message if you _really_ have a SB Pro.\n"); 836 } 837 else if (!sb_be_quiet && devc->model == MDL_SBPRO) 838 { 839 printk(KERN_INFO "SB DSP version is just %d.%02d which means that your card is\n", devc->major, devc->minor); 840 printk(KERN_INFO "several years old (8 bit only device) or alternatively the sound driver\n"); 841 printk(KERN_INFO "is incorrectly configured.\n"); 842 } 843 } 844 hw_config->card_subtype = devc->model; 845 hw_config->slots[0]=devc->dev; 846 last_devc = devc; /* For SB MPU detection */ 847 848 if (!(devc->caps & SB_NO_AUDIO) && devc->dma8 >= 0) 849 { 850 if (sound_alloc_dma(devc->dma8, "SoundBlaster8")) 851 { 852 printk(KERN_WARNING "Sound Blaster: Can't allocate 8 bit DMA channel %d\n", devc->dma8); 853 } 854 if (devc->dma16 >= 0 && devc->dma16 != devc->dma8) 855 { 856 if (sound_alloc_dma(devc->dma16, "SoundBlaster16")) 857 printk(KERN_WARNING "Sound Blaster: can't allocate 16 bit DMA channel %d.\n", devc->dma16); 858 } 859 sb_audio_init(devc, name, owner); 860 hw_config->slots[0]=devc->dev; 861 } 862 else 863 { 864 MDB(printk("Sound Blaster: no audio devices found.\n")); 865 } 866 return 1; 867} 868 869/* if (sbmpu) below we allow mpu401 to manage the midi devs 870 otherwise we have to unload them. (Andrzej Krzysztofowicz) */ 871 872void sb_dsp_unload(struct address_info *hw_config, int sbmpu) 873{ 874 sb_devc *devc; 875 876 devc = audio_devs[hw_config->slots[0]]->devc; 877 878 if (devc && devc->base == hw_config->io_base) 879 { 880 if ((devc->model & MDL_ESS) && devc->pcibase) 881 release_region(devc->pcibase, 8); 882 883 release_region(devc->base, 16); 884 885 if (!(devc->caps & SB_NO_AUDIO)) 886 { 887 sound_free_dma(devc->dma8); 888 if (devc->dma16 >= 0) 889 sound_free_dma(devc->dma16); 890 } 891 if (!(devc->caps & SB_NO_AUDIO && devc->caps & SB_NO_MIDI)) 892 { 893 if (devc->irq > 0) 894 free_irq(devc->irq, devc); 895 896 sb_mixer_unload(devc); 897 /* We don't have to do this bit any more the UART401 is its own 898 master -- Krzysztof Halasa */ 899 /* But we have to do it, if UART401 is not detected */ 900 if (!sbmpu) 901 sound_unload_mididev(devc->my_mididev); 902 sound_unload_audiodev(devc->dev); 903 } 904 kfree(devc); 905 } 906 else 907 release_region(hw_config->io_base, 16); 908 909 kfree(detected_devc); 910} 911 912/* 913 * Mixer access routines 914 * 915 * ES1887 modifications: some mixer registers reside in the 916 * range above 0xa0. These must be accessed in another way. 917 */ 918 919void sb_setmixer(sb_devc * devc, unsigned int port, unsigned int value) 920{ 921 unsigned long flags; 922 923 if (devc->model == MDL_ESS) { 924 ess_setmixer (devc, port, value); 925 return; 926 } 927 928 spin_lock_irqsave(&devc->lock, flags); 929 930 outb(((unsigned char) (port & 0xff)), MIXER_ADDR); 931 udelay(20); 932 outb(((unsigned char) (value & 0xff)), MIXER_DATA); 933 udelay(20); 934 935 spin_unlock_irqrestore(&devc->lock, flags); 936} 937 938unsigned int sb_getmixer(sb_devc * devc, unsigned int port) 939{ 940 unsigned int val; 941 unsigned long flags; 942 943 if (devc->model == MDL_ESS) return ess_getmixer (devc, port); 944 945 spin_lock_irqsave(&devc->lock, flags); 946 947 outb(((unsigned char) (port & 0xff)), MIXER_ADDR); 948 udelay(20); 949 val = inb(MIXER_DATA); 950 udelay(20); 951 952 spin_unlock_irqrestore(&devc->lock, flags); 953 954 return val; 955} 956 957void sb_chgmixer 958 (sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val) 959{ 960 int value; 961 962 value = sb_getmixer(devc, reg); 963 value = (value & ~mask) | (val & mask); 964 sb_setmixer(devc, reg, value); 965} 966 967/* 968 * MPU401 MIDI initialization. 969 */ 970 971static void smw_putmem(sb_devc * devc, int base, int addr, unsigned char val) 972{ 973 unsigned long flags; 974 975 spin_lock_irqsave(&jazz16_lock, flags); /* NOT the SB card? */ 976 977 outb((addr & 0xff), base + 1); /* Low address bits */ 978 outb((addr >> 8), base + 2); /* High address bits */ 979 outb((val), base); /* Data */ 980 981 spin_unlock_irqrestore(&jazz16_lock, flags); 982} 983 984static unsigned char smw_getmem(sb_devc * devc, int base, int addr) 985{ 986 unsigned long flags; 987 unsigned char val; 988 989 spin_lock_irqsave(&jazz16_lock, flags); /* NOT the SB card? */ 990 991 outb((addr & 0xff), base + 1); /* Low address bits */ 992 outb((addr >> 8), base + 2); /* High address bits */ 993 val = inb(base); /* Data */ 994 995 spin_unlock_irqrestore(&jazz16_lock, flags); 996 return val; 997} 998 999static int smw_midi_init(sb_devc * devc, struct address_info *hw_config) 1000{ 1001 int mpu_base = hw_config->io_base; 1002 int mp_base = mpu_base + 4; /* Microcontroller base */ 1003 int i; 1004 unsigned char control; 1005 1006 1007 /* 1008 * Reset the microcontroller so that the RAM can be accessed 1009 */ 1010 1011 control = inb(mpu_base + 7); 1012 outb((control | 3), mpu_base + 7); /* Set last two bits to 1 (?) */ 1013 outb(((control & 0xfe) | 2), mpu_base + 7); /* xxxxxxx0 resets the mc */ 1014 1015 mdelay(3); /* Wait at least 1ms */ 1016 1017 outb((control & 0xfc), mpu_base + 7); /* xxxxxx00 enables RAM */ 1018 1019 /* 1020 * Detect microcontroller by probing the 8k RAM area 1021 */ 1022 smw_putmem(devc, mp_base, 0, 0x00); 1023 smw_putmem(devc, mp_base, 1, 0xff); 1024 udelay(10); 1025 1026 if (smw_getmem(devc, mp_base, 0) != 0x00 || smw_getmem(devc, mp_base, 1) != 0xff) 1027 { 1028 DDB(printk("SM Wave: No microcontroller RAM detected (%02x, %02x)\n", smw_getmem(devc, mp_base, 0), smw_getmem(devc, mp_base, 1))); 1029 return 0; /* No RAM */ 1030 } 1031 /* 1032 * There is RAM so assume it's really a SM Wave 1033 */ 1034 1035 devc->model = MDL_SMW; 1036 smw_mixer_init(devc); 1037 1038#ifdef MODULE 1039 if (!smw_ucode) 1040 { 1041 smw_ucodeLen = mod_firmware_load("/etc/sound/midi0001.bin", (void *) &smw_ucode); 1042 smw_free = smw_ucode; 1043 } 1044#endif 1045 if (smw_ucodeLen > 0) 1046 { 1047 if (smw_ucodeLen != 8192) 1048 { 1049 printk(KERN_ERR "SM Wave: Invalid microcode (MIDI0001.BIN) length\n"); 1050 return 1; 1051 } 1052 /* 1053 * Download microcode 1054 */ 1055 1056 for (i = 0; i < 8192; i++) 1057 smw_putmem(devc, mp_base, i, smw_ucode[i]); 1058 1059 /* 1060 * Verify microcode 1061 */ 1062 1063 for (i = 0; i < 8192; i++) 1064 if (smw_getmem(devc, mp_base, i) != smw_ucode[i]) 1065 { 1066 printk(KERN_ERR "SM Wave: Microcode verification failed\n"); 1067 return 0; 1068 } 1069 } 1070 control = 0; 1071#ifdef SMW_SCSI_IRQ 1072 { 1073 static unsigned char scsi_irq_bits[] = { 1074 0, 0, 3, 1, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0 1075 }; 1076 control |= scsi_irq_bits[SMW_SCSI_IRQ] << 6; 1077 } 1078#endif 1079 1080#ifdef SMW_OPL4_ENABLE 1081 /* 1082 * Make the OPL4 chip visible on the PC bus at 0x380. 1083 * 1084 * There is no need to enable this feature since this driver 1085 * doesn't support OPL4 yet. Also there is no RAM in SM Wave so 1086 * enabling OPL4 is pretty useless. 1087 */ 1088 control |= 0x10; /* Uses IRQ12 if bit 0x20 == 0 */ 1089 /* control |= 0x20; Uncomment this if you want to use IRQ7 */ 1090#endif 1091 outb((control | 0x03), mpu_base + 7); /* xxxxxx11 restarts */ 1092 hw_config->name = "SoundMan Wave"; 1093 return 1; 1094} 1095 1096static int init_Jazz16_midi(sb_devc * devc, struct address_info *hw_config) 1097{ 1098 int mpu_base = hw_config->io_base; 1099 int sb_base = devc->base; 1100 int irq = hw_config->irq; 1101 1102 unsigned char bits = 0; 1103 unsigned long flags; 1104 1105 if (irq < 0) 1106 irq *= -1; 1107 1108 if (irq < 1 || irq > 15 || 1109 jazz_irq_bits[irq] == 0) 1110 { 1111 printk(KERN_ERR "Jazz16: Invalid MIDI interrupt (IRQ%d)\n", irq); 1112 return 0; 1113 } 1114 switch (sb_base) 1115 { 1116 case 0x220: 1117 bits = 1; 1118 break; 1119 case 0x240: 1120 bits = 2; 1121 break; 1122 case 0x260: 1123 bits = 3; 1124 break; 1125 default: 1126 return 0; 1127 } 1128 bits = jazz16_bits = bits << 5; 1129 switch (mpu_base) 1130 { 1131 case 0x310: 1132 bits |= 1; 1133 break; 1134 case 0x320: 1135 bits |= 2; 1136 break; 1137 case 0x330: 1138 bits |= 3; 1139 break; 1140 default: 1141 printk(KERN_ERR "Jazz16: Invalid MIDI I/O port %x\n", mpu_base); 1142 return 0; 1143 } 1144 /* 1145 * Magic wake up sequence by writing to 0x201 (aka Joystick port) 1146 */ 1147 spin_lock_irqsave(&jazz16_lock, flags); 1148 outb(0xAF, 0x201); 1149 outb(0x50, 0x201); 1150 outb(bits, 0x201); 1151 spin_unlock_irqrestore(&jazz16_lock, flags); 1152 1153 hw_config->name = "Jazz16"; 1154 smw_midi_init(devc, hw_config); 1155 1156 if (!sb_dsp_command(devc, 0xfb)) 1157 return 0; 1158 1159 if (!sb_dsp_command(devc, jazz_dma_bits[devc->dma8] | 1160 (jazz_dma_bits[devc->dma16] << 4))) 1161 return 0; 1162 1163 if (!sb_dsp_command(devc, jazz_irq_bits[devc->irq] | 1164 (jazz_irq_bits[irq] << 4))) 1165 return 0; 1166 1167 return 1; 1168} 1169 1170int probe_sbmpu(struct address_info *hw_config, struct module *owner) 1171{ 1172 sb_devc *devc = last_devc; 1173 int ret; 1174 1175 if (last_devc == NULL) 1176 return 0; 1177 1178 last_devc = NULL; 1179 1180 if (hw_config->io_base <= 0) 1181 { 1182 /* The real vibra16 is fine about this, but we have to go 1183 wipe up after Cyrix again */ 1184 1185 if(devc->model == MDL_SB16 && devc->minor >= 12) 1186 { 1187 unsigned char bits = sb_getmixer(devc, 0x84) & ~0x06; 1188 sb_setmixer(devc, 0x84, bits | 0x02); /* Disable MPU */ 1189 } 1190 return 0; 1191 } 1192 1193#if defined(CONFIG_SOUND_MPU401) 1194 if (devc->model == MDL_ESS) 1195 { 1196 struct resource *ports; 1197 ports = request_region(hw_config->io_base, 2, "mpu401"); 1198 if (!ports) { 1199 printk(KERN_ERR "sbmpu: I/O port conflict (%x)\n", hw_config->io_base); 1200 return 0; 1201 } 1202 if (!ess_midi_init(devc, hw_config)) { 1203 release_region(hw_config->io_base, 2); 1204 return 0; 1205 } 1206 hw_config->name = "ESS1xxx MPU"; 1207 devc->midi_irq_cookie = NULL; 1208 if (!probe_mpu401(hw_config, ports)) { 1209 release_region(hw_config->io_base, 2); 1210 return 0; 1211 } 1212 attach_mpu401(hw_config, owner); 1213 if (last_sb->irq == -hw_config->irq) 1214 last_sb->midi_irq_cookie = 1215 (void *)(long) hw_config->slots[1]; 1216 return 1; 1217 } 1218#endif 1219 1220 switch (devc->model) 1221 { 1222 case MDL_SB16: 1223 if (hw_config->io_base != 0x300 && hw_config->io_base != 0x330) 1224 { 1225 printk(KERN_ERR "SB16: Invalid MIDI port %x\n", hw_config->io_base); 1226 return 0; 1227 } 1228 hw_config->name = "Sound Blaster 16"; 1229 if (hw_config->irq < 3 || hw_config->irq == devc->irq) 1230 hw_config->irq = -devc->irq; 1231 if (devc->minor > 12) /* What is Vibra's version??? */ 1232 sb16_set_mpu_port(devc, hw_config); 1233 break; 1234 1235 case MDL_JAZZ: 1236 if (hw_config->irq < 3 || hw_config->irq == devc->irq) 1237 hw_config->irq = -devc->irq; 1238 if (!init_Jazz16_midi(devc, hw_config)) 1239 return 0; 1240 break; 1241 1242 case MDL_YMPCI: 1243 hw_config->name = "Yamaha PCI Legacy"; 1244 printk("Yamaha PCI legacy UART401 check.\n"); 1245 break; 1246 default: 1247 return 0; 1248 } 1249 1250 ret = probe_uart401(hw_config, owner); 1251 if (ret) 1252 last_sb->midi_irq_cookie=midi_devs[hw_config->slots[4]]->devc; 1253 return ret; 1254} 1255 1256void unload_sbmpu(struct address_info *hw_config) 1257{ 1258#if defined(CONFIG_SOUND_MPU401) 1259 if (!strcmp (hw_config->name, "ESS1xxx MPU")) { 1260 unload_mpu401(hw_config); 1261 return; 1262 } 1263#endif 1264 unload_uart401(hw_config); 1265} 1266 1267EXPORT_SYMBOL(sb_dsp_init); 1268EXPORT_SYMBOL(sb_dsp_detect); 1269EXPORT_SYMBOL(sb_dsp_unload); 1270EXPORT_SYMBOL(sb_be_quiet); 1271EXPORT_SYMBOL(probe_sbmpu); 1272EXPORT_SYMBOL(unload_sbmpu); 1273EXPORT_SYMBOL(smw_free); 1274MODULE_LICENSE("GPL"); 1275