1 /* 2 * Low-level ALSA driver for the ENSONIQ SoundScape PnP 3 * Copyright (c) by Chris Rankin 4 * 5 * This driver was written in part using information obtained from 6 * the OSS/Free SoundScape driver, written by Hannu Savolainen. 7 * 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 */ 23 24 #include <linux/init.h> 25 #include <linux/err.h> 26 #include <linux/isa.h> 27 #include <linux/delay.h> 28 #include <linux/pnp.h> 29 #include <linux/spinlock.h> 30 #include <linux/moduleparam.h> 31 #include <asm/dma.h> 32 #include <sound/core.h> 33 #include <sound/hwdep.h> 34 #include <sound/cs4231.h> 35 #include <sound/mpu401.h> 36 #include <sound/initval.h> 37 38 #include <sound/sscape_ioctl.h> 39 40 41 MODULE_AUTHOR("Chris Rankin"); 42 MODULE_DESCRIPTION("ENSONIQ SoundScape PnP driver"); 43 MODULE_LICENSE("GPL"); 44 45 static int index[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IDX; 46 static char* id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_STR; 47 static long port[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PORT; 48 static long wss_port[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PORT; 49 static int irq[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IRQ; 50 static int mpu_irq[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IRQ; 51 static int dma[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_DMA; 52 static int dma2[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_DMA; 53 54 module_param_array(index, int, NULL, 0444); 55 MODULE_PARM_DESC(index, "Index number for SoundScape soundcard"); 56 57 module_param_array(id, charp, NULL, 0444); 58 MODULE_PARM_DESC(id, "Description for SoundScape card"); 59 60 module_param_array(port, long, NULL, 0444); 61 MODULE_PARM_DESC(port, "Port # for SoundScape driver."); 62 63 module_param_array(wss_port, long, NULL, 0444); 64 MODULE_PARM_DESC(wss_port, "WSS Port # for SoundScape driver."); 65 66 module_param_array(irq, int, NULL, 0444); 67 MODULE_PARM_DESC(irq, "IRQ # for SoundScape driver."); 68 69 module_param_array(mpu_irq, int, NULL, 0444); 70 MODULE_PARM_DESC(mpu_irq, "MPU401 IRQ # for SoundScape driver."); 71 72 module_param_array(dma, int, NULL, 0444); 73 MODULE_PARM_DESC(dma, "DMA # for SoundScape driver."); 74 75 module_param_array(dma2, int, NULL, 0444); 76 MODULE_PARM_DESC(dma2, "DMA2 # for SoundScape driver."); 77 78 #ifdef CONFIG_PNP 79 static int isa_registered; 80 static int pnp_registered; 81 82 static struct pnp_card_device_id sscape_pnpids[] = { 83 { .id = "ENS3081", .devs = { { "ENS0000" } } }, /* Soundscape PnP */ 84 { .id = "ENS4081", .devs = { { "ENS1011" } } }, /* VIVO90 */ 85 { .id = "" } /* end */ 86 }; 87 88 MODULE_DEVICE_TABLE(pnp_card, sscape_pnpids); 89 #endif 90 91 92 #define MPU401_IO(i) ((i) + 0) 93 #define MIDI_DATA_IO(i) ((i) + 0) 94 #define MIDI_CTRL_IO(i) ((i) + 1) 95 #define HOST_CTRL_IO(i) ((i) + 2) 96 #define HOST_DATA_IO(i) ((i) + 3) 97 #define ODIE_ADDR_IO(i) ((i) + 4) 98 #define ODIE_DATA_IO(i) ((i) + 5) 99 #define CODEC_IO(i) ((i) + 8) 100 101 #define IC_ODIE 1 102 #define IC_OPUS 2 103 104 #define RX_READY 0x01 105 #define TX_READY 0x02 106 107 #define CMD_ACK 0x80 108 #define CMD_SET_MIDI_VOL 0x84 109 #define CMD_GET_MIDI_VOL 0x85 110 #define CMD_XXX_MIDI_VOL 0x86 111 #define CMD_SET_EXTMIDI 0x8a 112 #define CMD_GET_EXTMIDI 0x8b 113 #define CMD_SET_MT32 0x8c 114 #define CMD_GET_MT32 0x8d 115 116 enum GA_REG { 117 GA_INTSTAT_REG = 0, 118 GA_INTENA_REG, 119 GA_DMAA_REG, 120 GA_DMAB_REG, 121 GA_INTCFG_REG, 122 GA_DMACFG_REG, 123 GA_CDCFG_REG, 124 GA_SMCFGA_REG, 125 GA_SMCFGB_REG, 126 GA_HMCTL_REG 127 }; 128 129 #define DMA_8BIT 0x80 130 131 132 #define AD1845_FREQ_SEL_MSB 0x16 133 #define AD1845_FREQ_SEL_LSB 0x17 134 135 enum card_type { 136 SSCAPE, 137 SSCAPE_PNP, 138 SSCAPE_VIVO, 139 }; 140 141 struct soundscape { 142 spinlock_t lock; 143 unsigned io_base; 144 unsigned wss_base; 145 int codec_type; 146 int ic_type; 147 enum card_type type; 148 struct resource *io_res; 149 struct resource *wss_res; 150 struct snd_cs4231 *chip; 151 struct snd_mpu401 *mpu; 152 struct snd_hwdep *hw; 153 154 /* 155 * The MIDI device won't work until we've loaded 156 * its firmware via a hardware-dependent device IOCTL 157 */ 158 spinlock_t fwlock; 159 int hw_in_use; 160 unsigned long midi_usage; 161 unsigned char midi_vol; 162 }; 163 164 #define INVALID_IRQ ((unsigned)-1) 165 166 167 static inline struct soundscape *get_card_soundscape(struct snd_card *c) 168 { 169 return (struct soundscape *) (c->private_data); 170 } 171 172 static inline struct soundscape *get_mpu401_soundscape(struct snd_mpu401 * mpu) 173 { 174 return (struct soundscape *) (mpu->private_data); 175 } 176 177 static inline struct soundscape *get_hwdep_soundscape(struct snd_hwdep * hw) 178 { 179 return (struct soundscape *) (hw->private_data); 180 } 181 182 183 /* 184 * Allocates some kernel memory that we can use for DMA. 185 * I think this means that the memory has to map to 186 * contiguous pages of physical memory. 187 */ 188 static struct snd_dma_buffer *get_dmabuf(struct snd_dma_buffer *buf, unsigned long size) 189 { 190 if (buf) { 191 if (snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV, snd_dma_isa_data(), 192 size, buf) < 0) { 193 snd_printk(KERN_ERR "sscape: Failed to allocate %lu bytes for DMA\n", size); 194 return NULL; 195 } 196 } 197 198 return buf; 199 } 200 201 /* 202 * Release the DMA-able kernel memory ... 203 */ 204 static void free_dmabuf(struct snd_dma_buffer *buf) 205 { 206 if (buf && buf->area) 207 snd_dma_free_pages(buf); 208 } 209 210 211 /* 212 * This function writes to the SoundScape's control registers, 213 * but doesn't do any locking. It's up to the caller to do that. 214 * This is why this function is "unsafe" ... 215 */ 216 static inline void sscape_write_unsafe(unsigned io_base, enum GA_REG reg, unsigned char val) 217 { 218 outb(reg, ODIE_ADDR_IO(io_base)); 219 outb(val, ODIE_DATA_IO(io_base)); 220 } 221 222 /* 223 * Write to the SoundScape's control registers, and do the 224 * necessary locking ... 225 */ 226 static void sscape_write(struct soundscape *s, enum GA_REG reg, unsigned char val) 227 { 228 unsigned long flags; 229 230 spin_lock_irqsave(&s->lock, flags); 231 sscape_write_unsafe(s->io_base, reg, val); 232 spin_unlock_irqrestore(&s->lock, flags); 233 } 234 235 /* 236 * Read from the SoundScape's control registers, but leave any 237 * locking to the caller. This is why the function is "unsafe" ... 238 */ 239 static inline unsigned char sscape_read_unsafe(unsigned io_base, enum GA_REG reg) 240 { 241 outb(reg, ODIE_ADDR_IO(io_base)); 242 return inb(ODIE_DATA_IO(io_base)); 243 } 244 245 /* 246 * Puts the SoundScape into "host" mode, as compared to "MIDI" mode 247 */ 248 static inline void set_host_mode_unsafe(unsigned io_base) 249 { 250 outb(0x0, HOST_CTRL_IO(io_base)); 251 } 252 253 /* 254 * Puts the SoundScape into "MIDI" mode, as compared to "host" mode 255 */ 256 static inline void set_midi_mode_unsafe(unsigned io_base) 257 { 258 outb(0x3, HOST_CTRL_IO(io_base)); 259 } 260 261 /* 262 * Read the SoundScape's host-mode control register, but leave 263 * any locking issues to the caller ... 264 */ 265 static inline int host_read_unsafe(unsigned io_base) 266 { 267 int data = -1; 268 if ((inb(HOST_CTRL_IO(io_base)) & RX_READY) != 0) { 269 data = inb(HOST_DATA_IO(io_base)); 270 } 271 272 return data; 273 } 274 275 /* 276 * Read the SoundScape's host-mode control register, performing 277 * a limited amount of busy-waiting if the register isn't ready. 278 * Also leaves all locking-issues to the caller ... 279 */ 280 static int host_read_ctrl_unsafe(unsigned io_base, unsigned timeout) 281 { 282 int data; 283 284 while (((data = host_read_unsafe(io_base)) < 0) && (timeout != 0)) { 285 udelay(100); 286 --timeout; 287 } /* while */ 288 289 return data; 290 } 291 292 /* 293 * Write to the SoundScape's host-mode control registers, but 294 * leave any locking issues to the caller ... 295 */ 296 static inline int host_write_unsafe(unsigned io_base, unsigned char data) 297 { 298 if ((inb(HOST_CTRL_IO(io_base)) & TX_READY) != 0) { 299 outb(data, HOST_DATA_IO(io_base)); 300 return 1; 301 } 302 303 return 0; 304 } 305 306 /* 307 * Write to the SoundScape's host-mode control registers, performing 308 * a limited amount of busy-waiting if the register isn't ready. 309 * Also leaves all locking-issues to the caller ... 310 */ 311 static int host_write_ctrl_unsafe(unsigned io_base, unsigned char data, 312 unsigned timeout) 313 { 314 int err; 315 316 while (!(err = host_write_unsafe(io_base, data)) && (timeout != 0)) { 317 udelay(100); 318 --timeout; 319 } /* while */ 320 321 return err; 322 } 323 324 325 /* 326 * Check that the MIDI subsystem is operational. If it isn't, 327 * then we will hang the computer if we try to use it ... 328 * 329 * NOTE: This check is based upon observation, not documentation. 330 */ 331 static inline int verify_mpu401(const struct snd_mpu401 * mpu) 332 { 333 return ((inb(MIDI_CTRL_IO(mpu->port)) & 0xc0) == 0x80); 334 } 335 336 /* 337 * This is apparently the standard way to initailise an MPU-401 338 */ 339 static inline void initialise_mpu401(const struct snd_mpu401 * mpu) 340 { 341 outb(0, MIDI_DATA_IO(mpu->port)); 342 } 343 344 /* 345 * Tell the SoundScape to activate the AD1845 chip (I think). 346 * The AD1845 detection fails if we *don't* do this, so I 347 * think that this is a good idea ... 348 */ 349 static inline void activate_ad1845_unsafe(unsigned io_base) 350 { 351 sscape_write_unsafe(io_base, GA_HMCTL_REG, (sscape_read_unsafe(io_base, GA_HMCTL_REG) & 0xcf) | 0x10); 352 sscape_write_unsafe(io_base, GA_CDCFG_REG, 0x80); 353 } 354 355 /* 356 * Do the necessary ALSA-level cleanup to deallocate our driver ... 357 */ 358 static void soundscape_free(struct snd_card *c) 359 { 360 struct soundscape *sscape = get_card_soundscape(c); 361 release_and_free_resource(sscape->io_res); 362 release_and_free_resource(sscape->wss_res); 363 free_dma(sscape->chip->dma1); 364 } 365 366 /* 367 * Tell the SoundScape to begin a DMA tranfer using the given channel. 368 * All locking issues are left to the caller. 369 */ 370 static inline void sscape_start_dma_unsafe(unsigned io_base, enum GA_REG reg) 371 { 372 sscape_write_unsafe(io_base, reg, sscape_read_unsafe(io_base, reg) | 0x01); 373 sscape_write_unsafe(io_base, reg, sscape_read_unsafe(io_base, reg) & 0xfe); 374 } 375 376 /* 377 * Wait for a DMA transfer to complete. This is a "limited busy-wait", 378 * and all locking issues are left to the caller. 379 */ 380 static int sscape_wait_dma_unsafe(unsigned io_base, enum GA_REG reg, unsigned timeout) 381 { 382 while (!(sscape_read_unsafe(io_base, reg) & 0x01) && (timeout != 0)) { 383 udelay(100); 384 --timeout; 385 } /* while */ 386 387 return (sscape_read_unsafe(io_base, reg) & 0x01); 388 } 389 390 /* 391 * Wait for the On-Board Processor to return its start-up 392 * acknowledgement sequence. This wait is too long for 393 * us to perform "busy-waiting", and so we must sleep. 394 * This in turn means that we must not be holding any 395 * spinlocks when we call this function. 396 */ 397 static int obp_startup_ack(struct soundscape *s, unsigned timeout) 398 { 399 while (timeout != 0) { 400 unsigned long flags; 401 unsigned char x; 402 403 schedule_timeout_uninterruptible(1); 404 405 spin_lock_irqsave(&s->lock, flags); 406 x = inb(HOST_DATA_IO(s->io_base)); 407 spin_unlock_irqrestore(&s->lock, flags); 408 if ((x & 0xfe) == 0xfe) 409 return 1; 410 411 --timeout; 412 } /* while */ 413 414 return 0; 415 } 416 417 /* 418 * Wait for the host to return its start-up acknowledgement 419 * sequence. This wait is too long for us to perform 420 * "busy-waiting", and so we must sleep. This in turn means 421 * that we must not be holding any spinlocks when we call 422 * this function. 423 */ 424 static int host_startup_ack(struct soundscape *s, unsigned timeout) 425 { 426 while (timeout != 0) { 427 unsigned long flags; 428 unsigned char x; 429 430 schedule_timeout_uninterruptible(1); 431 432 spin_lock_irqsave(&s->lock, flags); 433 x = inb(HOST_DATA_IO(s->io_base)); 434 spin_unlock_irqrestore(&s->lock, flags); 435 if (x == 0xfe) 436 return 1; 437 438 --timeout; 439 } /* while */ 440 441 return 0; 442 } 443 444 /* 445 * Upload a byte-stream into the SoundScape using DMA channel A. 446 */ 447 static int upload_dma_data(struct soundscape *s, 448 const unsigned char __user *data, 449 size_t size) 450 { 451 unsigned long flags; 452 struct snd_dma_buffer dma; 453 int ret; 454 455 if (!get_dmabuf(&dma, PAGE_ALIGN(size))) 456 return -ENOMEM; 457 458 spin_lock_irqsave(&s->lock, flags); 459 460 /* 461 * Reset the board ... 462 */ 463 sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f); 464 465 /* 466 * Enable the DMA channels and configure them ... 467 */ 468 sscape_write_unsafe(s->io_base, GA_DMACFG_REG, 0x50); 469 sscape_write_unsafe(s->io_base, GA_DMAA_REG, (s->chip->dma1 << 4) | DMA_8BIT); 470 sscape_write_unsafe(s->io_base, GA_DMAB_REG, 0x20); 471 472 /* 473 * Take the board out of reset ... 474 */ 475 sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) | 0x80); 476 477 /* 478 * Upload the user's data (firmware?) to the SoundScape 479 * board through the DMA channel ... 480 */ 481 while (size != 0) { 482 unsigned long len; 483 484 /* 485 * Apparently, copying to/from userspace can sleep. 486 * We are therefore forbidden from holding any 487 * spinlocks while we copy ... 488 */ 489 spin_unlock_irqrestore(&s->lock, flags); 490 491 /* 492 * Remember that the data that we want to DMA 493 * comes from USERSPACE. We have already verified 494 * the userspace pointer ... 495 */ 496 len = min(size, dma.bytes); 497 len -= __copy_from_user(dma.area, data, len); 498 data += len; 499 size -= len; 500 501 /* 502 * Grab that spinlock again, now that we've 503 * finished copying! 504 */ 505 spin_lock_irqsave(&s->lock, flags); 506 507 snd_dma_program(s->chip->dma1, dma.addr, len, DMA_MODE_WRITE); 508 sscape_start_dma_unsafe(s->io_base, GA_DMAA_REG); 509 if (!sscape_wait_dma_unsafe(s->io_base, GA_DMAA_REG, 5000)) { 510 /* 511 * Don't forget to release this spinlock we're holding ... 512 */ 513 spin_unlock_irqrestore(&s->lock, flags); 514 515 snd_printk(KERN_ERR "sscape: DMA upload has timed out\n"); 516 ret = -EAGAIN; 517 goto _release_dma; 518 } 519 } /* while */ 520 521 set_host_mode_unsafe(s->io_base); 522 523 /* 524 * Boot the board ... (I think) 525 */ 526 sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) | 0x40); 527 spin_unlock_irqrestore(&s->lock, flags); 528 529 /* 530 * If all has gone well, then the board should acknowledge 531 * the new upload and tell us that it has rebooted OK. We 532 * give it 5 seconds (max) ... 533 */ 534 ret = 0; 535 if (!obp_startup_ack(s, 5)) { 536 snd_printk(KERN_ERR "sscape: No response from on-board processor after upload\n"); 537 ret = -EAGAIN; 538 } else if (!host_startup_ack(s, 5)) { 539 snd_printk(KERN_ERR "sscape: SoundScape failed to initialise\n"); 540 ret = -EAGAIN; 541 } 542 543 _release_dma: 544 /* 545 * NOTE!!! We are NOT holding any spinlocks at this point !!! 546 */ 547 sscape_write(s, GA_DMAA_REG, (s->ic_type == IC_ODIE ? 0x70 : 0x40)); 548 free_dmabuf(&dma); 549 550 return ret; 551 } 552 553 /* 554 * Upload the bootblock(?) into the SoundScape. The only 555 * purpose of this block of code seems to be to tell 556 * us which version of the microcode we should be using. 557 * 558 * NOTE: The boot-block data resides in USER-SPACE!!! 559 * However, we have already verified its memory 560 * addresses by the time we get here. 561 */ 562 static int sscape_upload_bootblock(struct soundscape *sscape, struct sscape_bootblock __user *bb) 563 { 564 unsigned long flags; 565 int data = 0; 566 int ret; 567 568 ret = upload_dma_data(sscape, bb->code, sizeof(bb->code)); 569 570 spin_lock_irqsave(&sscape->lock, flags); 571 if (ret == 0) { 572 data = host_read_ctrl_unsafe(sscape->io_base, 100); 573 } 574 set_midi_mode_unsafe(sscape->io_base); 575 spin_unlock_irqrestore(&sscape->lock, flags); 576 577 if (ret == 0) { 578 if (data < 0) { 579 snd_printk(KERN_ERR "sscape: timeout reading firmware version\n"); 580 ret = -EAGAIN; 581 } 582 else if (__copy_to_user(&bb->version, &data, sizeof(bb->version))) { 583 ret = -EFAULT; 584 } 585 } 586 587 return ret; 588 } 589 590 /* 591 * Upload the microcode into the SoundScape. The 592 * microcode is 64K of data, and if we try to copy 593 * it into a local variable then we will SMASH THE 594 * KERNEL'S STACK! We therefore leave it in USER 595 * SPACE, and save ourselves from copying it at all. 596 */ 597 static int sscape_upload_microcode(struct soundscape *sscape, 598 const struct sscape_microcode __user *mc) 599 { 600 unsigned long flags; 601 char __user *code; 602 int err; 603 604 /* 605 * We are going to have to copy this data into a special 606 * DMA-able buffer before we can upload it. We shall therefore 607 * just check that the data pointer is valid for now. 608 * 609 * NOTE: This buffer is 64K long! That's WAY too big to 610 * copy into a stack-temporary anyway. 611 */ 612 if ( get_user(code, &mc->code) || 613 !access_ok(VERIFY_READ, code, SSCAPE_MICROCODE_SIZE) ) 614 return -EFAULT; 615 616 if ((err = upload_dma_data(sscape, code, SSCAPE_MICROCODE_SIZE)) == 0) { 617 snd_printk(KERN_INFO "sscape: MIDI firmware loaded\n"); 618 } 619 620 spin_lock_irqsave(&sscape->lock, flags); 621 set_midi_mode_unsafe(sscape->io_base); 622 spin_unlock_irqrestore(&sscape->lock, flags); 623 624 initialise_mpu401(sscape->mpu); 625 626 return err; 627 } 628 629 /* 630 * Hardware-specific device functions, to implement special 631 * IOCTLs for the SoundScape card. This is how we upload 632 * the microcode into the card, for example, and so we 633 * must ensure that no two processes can open this device 634 * simultaneously, and that we can't open it at all if 635 * someone is using the MIDI device. 636 */ 637 static int sscape_hw_open(struct snd_hwdep * hw, struct file *file) 638 { 639 register struct soundscape *sscape = get_hwdep_soundscape(hw); 640 unsigned long flags; 641 int err; 642 643 spin_lock_irqsave(&sscape->fwlock, flags); 644 645 if ((sscape->midi_usage != 0) || sscape->hw_in_use) { 646 err = -EBUSY; 647 } else { 648 sscape->hw_in_use = 1; 649 err = 0; 650 } 651 652 spin_unlock_irqrestore(&sscape->fwlock, flags); 653 return err; 654 } 655 656 static int sscape_hw_release(struct snd_hwdep * hw, struct file *file) 657 { 658 register struct soundscape *sscape = get_hwdep_soundscape(hw); 659 unsigned long flags; 660 661 spin_lock_irqsave(&sscape->fwlock, flags); 662 sscape->hw_in_use = 0; 663 spin_unlock_irqrestore(&sscape->fwlock, flags); 664 return 0; 665 } 666 667 static int sscape_hw_ioctl(struct snd_hwdep * hw, struct file *file, 668 unsigned int cmd, unsigned long arg) 669 { 670 struct soundscape *sscape = get_hwdep_soundscape(hw); 671 int err = -EBUSY; 672 673 switch (cmd) { 674 case SND_SSCAPE_LOAD_BOOTB: 675 { 676 register struct sscape_bootblock __user *bb = (struct sscape_bootblock __user *) arg; 677 678 /* 679 * We are going to have to copy this data into a special 680 * DMA-able buffer before we can upload it. We shall therefore 681 * just check that the data pointer is valid for now ... 682 */ 683 if ( !access_ok(VERIFY_READ, bb->code, sizeof(bb->code)) ) 684 return -EFAULT; 685 686 /* 687 * Now check that we can write the firmware version number too... 688 */ 689 if ( !access_ok(VERIFY_WRITE, &bb->version, sizeof(bb->version)) ) 690 return -EFAULT; 691 692 err = sscape_upload_bootblock(sscape, bb); 693 } 694 break; 695 696 case SND_SSCAPE_LOAD_MCODE: 697 { 698 register const struct sscape_microcode __user *mc = (const struct sscape_microcode __user *) arg; 699 700 err = sscape_upload_microcode(sscape, mc); 701 } 702 break; 703 704 default: 705 err = -EINVAL; 706 break; 707 } /* switch */ 708 709 return err; 710 } 711 712 713 /* 714 * Mixer control for the SoundScape's MIDI device. 715 */ 716 static int sscape_midi_info(struct snd_kcontrol *ctl, 717 struct snd_ctl_elem_info *uinfo) 718 { 719 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 720 uinfo->count = 1; 721 uinfo->value.integer.min = 0; 722 uinfo->value.integer.max = 127; 723 return 0; 724 } 725 726 static int sscape_midi_get(struct snd_kcontrol *kctl, 727 struct snd_ctl_elem_value *uctl) 728 { 729 struct snd_cs4231 *chip = snd_kcontrol_chip(kctl); 730 struct snd_card *card = chip->card; 731 register struct soundscape *s = get_card_soundscape(card); 732 unsigned long flags; 733 734 spin_lock_irqsave(&s->lock, flags); 735 set_host_mode_unsafe(s->io_base); 736 737 if (host_write_ctrl_unsafe(s->io_base, CMD_GET_MIDI_VOL, 100)) { 738 uctl->value.integer.value[0] = host_read_ctrl_unsafe(s->io_base, 100); 739 } 740 741 set_midi_mode_unsafe(s->io_base); 742 spin_unlock_irqrestore(&s->lock, flags); 743 return 0; 744 } 745 746 static int sscape_midi_put(struct snd_kcontrol *kctl, 747 struct snd_ctl_elem_value *uctl) 748 { 749 struct snd_cs4231 *chip = snd_kcontrol_chip(kctl); 750 struct snd_card *card = chip->card; 751 register struct soundscape *s = get_card_soundscape(card); 752 unsigned long flags; 753 int change; 754 755 spin_lock_irqsave(&s->lock, flags); 756 757 /* 758 * We need to put the board into HOST mode before we 759 * can send any volume-changing HOST commands ... 760 */ 761 set_host_mode_unsafe(s->io_base); 762 763 /* 764 * To successfully change the MIDI volume setting, you seem to 765 * have to write a volume command, write the new volume value, 766 * and then perform another volume-related command. Perhaps the 767 * first command is an "open" and the second command is a "close"? 768 */ 769 if (s->midi_vol == ((unsigned char) uctl->value.integer. value[0] & 127)) { 770 change = 0; 771 goto __skip_change; 772 } 773 change = (host_write_ctrl_unsafe(s->io_base, CMD_SET_MIDI_VOL, 100) 774 && host_write_ctrl_unsafe(s->io_base, ((unsigned char) uctl->value.integer. value[0]) & 127, 100) 775 && host_write_ctrl_unsafe(s->io_base, CMD_XXX_MIDI_VOL, 100)); 776 __skip_change: 777 778 /* 779 * Take the board out of HOST mode and back into MIDI mode ... 780 */ 781 set_midi_mode_unsafe(s->io_base); 782 783 spin_unlock_irqrestore(&s->lock, flags); 784 return change; 785 } 786 787 static struct snd_kcontrol_new midi_mixer_ctl = { 788 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 789 .name = "MIDI", 790 .info = sscape_midi_info, 791 .get = sscape_midi_get, 792 .put = sscape_midi_put 793 }; 794 795 /* 796 * The SoundScape can use two IRQs from a possible set of four. 797 * These IRQs are encoded as bit patterns so that they can be 798 * written to the control registers. 799 */ 800 static unsigned __devinit get_irq_config(int irq) 801 { 802 static const int valid_irq[] = { 9, 5, 7, 10 }; 803 unsigned cfg; 804 805 for (cfg = 0; cfg < ARRAY_SIZE(valid_irq); ++cfg) { 806 if (irq == valid_irq[cfg]) 807 return cfg; 808 } /* for */ 809 810 return INVALID_IRQ; 811 } 812 813 814 /* 815 * Perform certain arcane port-checks to see whether there 816 * is a SoundScape board lurking behind the given ports. 817 */ 818 static int __devinit detect_sscape(struct soundscape *s) 819 { 820 unsigned long flags; 821 unsigned d; 822 int retval = 0; 823 int codec = s->wss_base; 824 825 spin_lock_irqsave(&s->lock, flags); 826 827 /* 828 * The following code is lifted from the original OSS driver, 829 * and as I don't have a datasheet I cannot really comment 830 * on what it is doing... 831 */ 832 if ((inb(HOST_CTRL_IO(s->io_base)) & 0x78) != 0) 833 goto _done; 834 835 d = inb(ODIE_ADDR_IO(s->io_base)) & 0xf0; 836 if ((d & 0x80) != 0) 837 goto _done; 838 839 if (d == 0) { 840 s->codec_type = 1; 841 s->ic_type = IC_ODIE; 842 } else if ((d & 0x60) != 0) { 843 s->codec_type = 2; 844 s->ic_type = IC_OPUS; 845 } else 846 goto _done; 847 848 outb(0xfa, ODIE_ADDR_IO(s->io_base)); 849 if ((inb(ODIE_ADDR_IO(s->io_base)) & 0x9f) != 0x0a) 850 goto _done; 851 852 outb(0xfe, ODIE_ADDR_IO(s->io_base)); 853 if ((inb(ODIE_ADDR_IO(s->io_base)) & 0x9f) != 0x0e) 854 goto _done; 855 856 outb(0xfe, ODIE_ADDR_IO(s->io_base)); 857 d = inb(ODIE_DATA_IO(s->io_base)); 858 if (s->type != SSCAPE_VIVO && (d & 0x9f) != 0x0e) 859 goto _done; 860 861 d = sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f; 862 sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0); 863 864 if (s->type == SSCAPE_VIVO) 865 codec += 4; 866 /* wait for WSS codec */ 867 for (d = 0; d < 500; d++) { 868 if ((inb(codec) & 0x80) == 0) 869 break; 870 spin_unlock_irqrestore(&s->lock, flags); 871 msleep(1); 872 spin_lock_irqsave(&s->lock, flags); 873 } 874 snd_printd(KERN_INFO "init delay = %d ms\n", d); 875 876 /* 877 * SoundScape successfully detected! 878 */ 879 retval = 1; 880 881 _done: 882 spin_unlock_irqrestore(&s->lock, flags); 883 return retval; 884 } 885 886 /* 887 * ALSA callback function, called when attempting to open the MIDI device. 888 * Check that the MIDI firmware has been loaded, because we don't want 889 * to crash the machine. Also check that someone isn't using the hardware 890 * IOCTL device. 891 */ 892 static int mpu401_open(struct snd_mpu401 * mpu) 893 { 894 int err; 895 896 if (!verify_mpu401(mpu)) { 897 snd_printk(KERN_ERR "sscape: MIDI disabled, please load firmware\n"); 898 err = -ENODEV; 899 } else { 900 register struct soundscape *sscape = get_mpu401_soundscape(mpu); 901 unsigned long flags; 902 903 spin_lock_irqsave(&sscape->fwlock, flags); 904 905 if (sscape->hw_in_use || (sscape->midi_usage == ULONG_MAX)) { 906 err = -EBUSY; 907 } else { 908 ++(sscape->midi_usage); 909 err = 0; 910 } 911 912 spin_unlock_irqrestore(&sscape->fwlock, flags); 913 } 914 915 return err; 916 } 917 918 static void mpu401_close(struct snd_mpu401 * mpu) 919 { 920 register struct soundscape *sscape = get_mpu401_soundscape(mpu); 921 unsigned long flags; 922 923 spin_lock_irqsave(&sscape->fwlock, flags); 924 --(sscape->midi_usage); 925 spin_unlock_irqrestore(&sscape->fwlock, flags); 926 } 927 928 /* 929 * Initialse an MPU-401 subdevice for MIDI support on the SoundScape. 930 */ 931 static int __devinit create_mpu401(struct snd_card *card, int devnum, unsigned long port, int irq) 932 { 933 struct soundscape *sscape = get_card_soundscape(card); 934 struct snd_rawmidi *rawmidi; 935 int err; 936 937 if ((err = snd_mpu401_uart_new(card, devnum, 938 MPU401_HW_MPU401, 939 port, MPU401_INFO_INTEGRATED, 940 irq, IRQF_DISABLED, 941 &rawmidi)) == 0) { 942 struct snd_mpu401 *mpu = (struct snd_mpu401 *) rawmidi->private_data; 943 mpu->open_input = mpu401_open; 944 mpu->open_output = mpu401_open; 945 mpu->close_input = mpu401_close; 946 mpu->close_output = mpu401_close; 947 mpu->private_data = sscape; 948 sscape->mpu = mpu; 949 950 initialise_mpu401(mpu); 951 } 952 953 return err; 954 } 955 956 957 /* 958 * Override for the CS4231 playback format function. 959 * The AD1845 has much simpler format and rate selection. 960 */ 961 static void ad1845_playback_format(struct snd_cs4231 * chip, struct snd_pcm_hw_params *params, unsigned char format) 962 { 963 unsigned long flags; 964 unsigned rate = params_rate(params); 965 966 /* 967 * The AD1845 can't handle sample frequencies 968 * outside of 4 kHZ to 50 kHZ 969 */ 970 if (rate > 50000) 971 rate = 50000; 972 else if (rate < 4000) 973 rate = 4000; 974 975 spin_lock_irqsave(&chip->reg_lock, flags); 976 977 /* 978 * Program the AD1845 correctly for the playback stream. 979 * Note that we do NOT need to toggle the MCE bit because 980 * the PLAYBACK_ENABLE bit of the Interface Configuration 981 * register is set. 982 * 983 * NOTE: We seem to need to write to the MSB before the LSB 984 * to get the correct sample frequency. 985 */ 986 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, (format & 0xf0)); 987 snd_cs4231_out(chip, AD1845_FREQ_SEL_MSB, (unsigned char) (rate >> 8)); 988 snd_cs4231_out(chip, AD1845_FREQ_SEL_LSB, (unsigned char) rate); 989 990 spin_unlock_irqrestore(&chip->reg_lock, flags); 991 } 992 993 /* 994 * Override for the CS4231 capture format function. 995 * The AD1845 has much simpler format and rate selection. 996 */ 997 static void ad1845_capture_format(struct snd_cs4231 * chip, struct snd_pcm_hw_params *params, unsigned char format) 998 { 999 unsigned long flags; 1000 unsigned rate = params_rate(params); 1001 1002 /* 1003 * The AD1845 can't handle sample frequencies 1004 * outside of 4 kHZ to 50 kHZ 1005 */ 1006 if (rate > 50000) 1007 rate = 50000; 1008 else if (rate < 4000) 1009 rate = 4000; 1010 1011 spin_lock_irqsave(&chip->reg_lock, flags); 1012 1013 /* 1014 * Program the AD1845 correctly for the playback stream. 1015 * Note that we do NOT need to toggle the MCE bit because 1016 * the CAPTURE_ENABLE bit of the Interface Configuration 1017 * register is set. 1018 * 1019 * NOTE: We seem to need to write to the MSB before the LSB 1020 * to get the correct sample frequency. 1021 */ 1022 snd_cs4231_out(chip, CS4231_REC_FORMAT, (format & 0xf0)); 1023 snd_cs4231_out(chip, AD1845_FREQ_SEL_MSB, (unsigned char) (rate >> 8)); 1024 snd_cs4231_out(chip, AD1845_FREQ_SEL_LSB, (unsigned char) rate); 1025 1026 spin_unlock_irqrestore(&chip->reg_lock, flags); 1027 } 1028 1029 /* 1030 * Create an AD1845 PCM subdevice on the SoundScape. The AD1845 1031 * is very much like a CS4231, with a few extra bits. We will 1032 * try to support at least some of the extra bits by overriding 1033 * some of the CS4231 callback. 1034 */ 1035 static int __devinit create_ad1845(struct snd_card *card, unsigned port, 1036 int irq, int dma1, int dma2) 1037 { 1038 register struct soundscape *sscape = get_card_soundscape(card); 1039 struct snd_cs4231 *chip; 1040 int err; 1041 1042 if (sscape->type == SSCAPE_VIVO) 1043 port += 4; 1044 1045 if (dma1 == dma2) 1046 dma2 = -1; 1047 1048 err = snd_cs4231_create(card, 1049 port, -1, irq, dma1, dma2, 1050 CS4231_HW_DETECT, CS4231_HWSHARE_DMA1, &chip); 1051 if (!err) { 1052 unsigned long flags; 1053 struct snd_pcm *pcm; 1054 1055 #define AD1845_FREQ_SEL_ENABLE 0x08 1056 1057 #define AD1845_PWR_DOWN_CTRL 0x1b 1058 #define AD1845_CRYS_CLOCK_SEL 0x1d 1059 1060 /* 1061 * It turns out that the PLAYBACK_ENABLE bit is set 1062 * by the lowlevel driver ... 1063 * 1064 #define AD1845_IFACE_CONFIG \ 1065 (CS4231_AUTOCALIB | CS4231_RECORD_ENABLE | CS4231_PLAYBACK_ENABLE) 1066 snd_cs4231_mce_up(chip); 1067 spin_lock_irqsave(&chip->reg_lock, flags); 1068 snd_cs4231_out(chip, CS4231_IFACE_CTRL, AD1845_IFACE_CONFIG); 1069 spin_unlock_irqrestore(&chip->reg_lock, flags); 1070 snd_cs4231_mce_down(chip); 1071 */ 1072 1073 if (sscape->type != SSCAPE_VIVO) { 1074 int val; 1075 /* 1076 * The input clock frequency on the SoundScape must 1077 * be 14.31818 MHz, because we must set this register 1078 * to get the playback to sound correct ... 1079 */ 1080 snd_cs4231_mce_up(chip); 1081 spin_lock_irqsave(&chip->reg_lock, flags); 1082 snd_cs4231_out(chip, AD1845_CRYS_CLOCK_SEL, 0x20); 1083 spin_unlock_irqrestore(&chip->reg_lock, flags); 1084 snd_cs4231_mce_down(chip); 1085 1086 /* 1087 * More custom configuration: 1088 * a) select "mode 2" and provide a current drive of 8mA 1089 * b) enable frequency selection (for capture/playback) 1090 */ 1091 spin_lock_irqsave(&chip->reg_lock, flags); 1092 snd_cs4231_out(chip, CS4231_MISC_INFO, 1093 CS4231_MODE2 | 0x10); 1094 val = snd_cs4231_in(chip, AD1845_PWR_DOWN_CTRL); 1095 snd_cs4231_out(chip, AD1845_PWR_DOWN_CTRL, 1096 val | AD1845_FREQ_SEL_ENABLE); 1097 spin_unlock_irqrestore(&chip->reg_lock, flags); 1098 } 1099 1100 err = snd_cs4231_pcm(chip, 0, &pcm); 1101 if (err < 0) { 1102 snd_printk(KERN_ERR "sscape: No PCM device " 1103 "for AD1845 chip\n"); 1104 goto _error; 1105 } 1106 1107 err = snd_cs4231_mixer(chip); 1108 if (err < 0) { 1109 snd_printk(KERN_ERR "sscape: No mixer device " 1110 "for AD1845 chip\n"); 1111 goto _error; 1112 } 1113 err = snd_cs4231_timer(chip, 0, NULL); 1114 if (err < 0) { 1115 snd_printk(KERN_ERR "sscape: No timer device " 1116 "for AD1845 chip\n"); 1117 goto _error; 1118 } 1119 1120 if (sscape->type != SSCAPE_VIVO) { 1121 err = snd_ctl_add(card, 1122 snd_ctl_new1(&midi_mixer_ctl, chip)); 1123 if (err < 0) { 1124 snd_printk(KERN_ERR "sscape: Could not create " 1125 "MIDI mixer control\n"); 1126 goto _error; 1127 } 1128 chip->set_playback_format = ad1845_playback_format; 1129 chip->set_capture_format = ad1845_capture_format; 1130 } 1131 1132 strcpy(card->driver, "SoundScape"); 1133 strcpy(card->shortname, pcm->name); 1134 snprintf(card->longname, sizeof(card->longname), 1135 "%s at 0x%lx, IRQ %d, DMA1 %d, DMA2 %d\n", 1136 pcm->name, chip->port, chip->irq, 1137 chip->dma1, chip->dma2); 1138 1139 sscape->chip = chip; 1140 } 1141 1142 _error: 1143 return err; 1144 } 1145 1146 1147 /* 1148 * Create an ALSA soundcard entry for the SoundScape, using 1149 * the given list of port, IRQ and DMA resources. 1150 */ 1151 static int __devinit create_sscape(int dev, struct snd_card *card) 1152 { 1153 struct soundscape *sscape = get_card_soundscape(card); 1154 unsigned dma_cfg; 1155 unsigned irq_cfg; 1156 unsigned mpu_irq_cfg; 1157 unsigned xport; 1158 struct resource *io_res; 1159 struct resource *wss_res; 1160 unsigned long flags; 1161 int err; 1162 1163 /* 1164 * Check that the user didn't pass us garbage data ... 1165 */ 1166 irq_cfg = get_irq_config(irq[dev]); 1167 if (irq_cfg == INVALID_IRQ) { 1168 snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", irq[dev]); 1169 return -ENXIO; 1170 } 1171 1172 mpu_irq_cfg = get_irq_config(mpu_irq[dev]); 1173 if (mpu_irq_cfg == INVALID_IRQ) { 1174 printk(KERN_ERR "sscape: Invalid IRQ %d\n", mpu_irq[dev]); 1175 return -ENXIO; 1176 } 1177 xport = port[dev]; 1178 1179 /* 1180 * Grab IO ports that we will need to probe so that we 1181 * can detect and control this hardware ... 1182 */ 1183 io_res = request_region(xport, 8, "SoundScape"); 1184 if (!io_res) { 1185 snd_printk(KERN_ERR "sscape: can't grab port 0x%x\n", xport); 1186 return -EBUSY; 1187 } 1188 wss_res = NULL; 1189 if (sscape->type == SSCAPE_VIVO) { 1190 wss_res = request_region(wss_port[dev], 4, "SoundScape"); 1191 if (!wss_res) { 1192 snd_printk(KERN_ERR "sscape: can't grab port 0x%lx\n", 1193 wss_port[dev]); 1194 err = -EBUSY; 1195 goto _release_region; 1196 } 1197 } 1198 1199 /* 1200 * Grab one DMA channel ... 1201 */ 1202 err = request_dma(dma[dev], "SoundScape"); 1203 if (err < 0) { 1204 snd_printk(KERN_ERR "sscape: can't grab DMA %d\n", dma[dev]); 1205 goto _release_region; 1206 } 1207 1208 spin_lock_init(&sscape->lock); 1209 spin_lock_init(&sscape->fwlock); 1210 sscape->io_res = io_res; 1211 sscape->wss_res = wss_res; 1212 sscape->io_base = xport; 1213 sscape->wss_base = wss_port[dev]; 1214 1215 if (!detect_sscape(sscape)) { 1216 printk(KERN_ERR "sscape: hardware not detected at 0x%x\n", sscape->io_base); 1217 err = -ENODEV; 1218 goto _release_dma; 1219 } 1220 1221 printk(KERN_INFO "sscape: hardware detected at 0x%x, using IRQ %d, DMA %d\n", 1222 sscape->io_base, irq[dev], dma[dev]); 1223 1224 if (sscape->type != SSCAPE_VIVO) { 1225 /* 1226 * Now create the hardware-specific device so that we can 1227 * load the microcode into the on-board processor. 1228 * We cannot use the MPU-401 MIDI system until this firmware 1229 * has been loaded into the card. 1230 */ 1231 err = snd_hwdep_new(card, "MC68EC000", 0, &(sscape->hw)); 1232 if (err < 0) { 1233 printk(KERN_ERR "sscape: Failed to create " 1234 "firmware device\n"); 1235 goto _release_dma; 1236 } 1237 strlcpy(sscape->hw->name, "SoundScape M68K", 1238 sizeof(sscape->hw->name)); 1239 sscape->hw->name[sizeof(sscape->hw->name) - 1] = '\0'; 1240 sscape->hw->iface = SNDRV_HWDEP_IFACE_SSCAPE; 1241 sscape->hw->ops.open = sscape_hw_open; 1242 sscape->hw->ops.release = sscape_hw_release; 1243 sscape->hw->ops.ioctl = sscape_hw_ioctl; 1244 sscape->hw->private_data = sscape; 1245 } 1246 1247 /* 1248 * Tell the on-board devices where their resources are (I think - 1249 * I can't be sure without a datasheet ... So many magic values!) 1250 */ 1251 spin_lock_irqsave(&sscape->lock, flags); 1252 1253 activate_ad1845_unsafe(sscape->io_base); 1254 1255 sscape_write_unsafe(sscape->io_base, GA_INTENA_REG, 0x00); /* disable */ 1256 sscape_write_unsafe(sscape->io_base, GA_SMCFGA_REG, 0x2e); 1257 sscape_write_unsafe(sscape->io_base, GA_SMCFGB_REG, 0x00); 1258 1259 /* 1260 * Enable and configure the DMA channels ... 1261 */ 1262 sscape_write_unsafe(sscape->io_base, GA_DMACFG_REG, 0x50); 1263 dma_cfg = (sscape->ic_type == IC_ODIE ? 0x70 : 0x40); 1264 sscape_write_unsafe(sscape->io_base, GA_DMAA_REG, dma_cfg); 1265 sscape_write_unsafe(sscape->io_base, GA_DMAB_REG, 0x20); 1266 1267 sscape_write_unsafe(sscape->io_base, 1268 GA_INTCFG_REG, 0xf0 | (mpu_irq_cfg << 2) | mpu_irq_cfg); 1269 sscape_write_unsafe(sscape->io_base, 1270 GA_CDCFG_REG, 0x09 | DMA_8BIT 1271 | (dma[dev] << 4) | (irq_cfg << 1)); 1272 1273 spin_unlock_irqrestore(&sscape->lock, flags); 1274 1275 /* 1276 * We have now enabled the codec chip, and so we should 1277 * detect the AD1845 device ... 1278 */ 1279 err = create_ad1845(card, wss_port[dev], irq[dev], 1280 dma[dev], dma2[dev]); 1281 if (err < 0) { 1282 printk(KERN_ERR "sscape: No AD1845 device at 0x%lx, IRQ %d\n", 1283 wss_port[dev], irq[dev]); 1284 goto _release_dma; 1285 } 1286 #define MIDI_DEVNUM 0 1287 if (sscape->type != SSCAPE_VIVO) { 1288 err = create_mpu401(card, MIDI_DEVNUM, 1289 MPU401_IO(xport), mpu_irq[dev]); 1290 if (err < 0) { 1291 printk(KERN_ERR "sscape: Failed to create " 1292 "MPU-401 device at 0x%x\n", 1293 MPU401_IO(xport)); 1294 goto _release_dma; 1295 } 1296 1297 /* 1298 * Enable the master IRQ ... 1299 */ 1300 sscape_write(sscape, GA_INTENA_REG, 0x80); 1301 1302 /* 1303 * Initialize mixer 1304 */ 1305 sscape->midi_vol = 0; 1306 host_write_ctrl_unsafe(sscape->io_base, CMD_SET_MIDI_VOL, 100); 1307 host_write_ctrl_unsafe(sscape->io_base, 0, 100); 1308 host_write_ctrl_unsafe(sscape->io_base, CMD_XXX_MIDI_VOL, 100); 1309 } 1310 1311 /* 1312 * Now that we have successfully created this sound card, 1313 * it is safe to store the pointer. 1314 * NOTE: we only register the sound card's "destructor" 1315 * function now that our "constructor" has completed. 1316 */ 1317 card->private_free = soundscape_free; 1318 1319 return 0; 1320 1321 _release_dma: 1322 free_dma(dma[dev]); 1323 1324 _release_region: 1325 release_and_free_resource(wss_res); 1326 release_and_free_resource(io_res); 1327 1328 return err; 1329 } 1330 1331 1332 static int __devinit snd_sscape_match(struct device *pdev, unsigned int i) 1333 { 1334 /* 1335 * Make sure we were given ALL of the other parameters. 1336 */ 1337 if (port[i] == SNDRV_AUTO_PORT) 1338 return 0; 1339 1340 if (irq[i] == SNDRV_AUTO_IRQ || 1341 mpu_irq[i] == SNDRV_AUTO_IRQ || 1342 dma[i] == SNDRV_AUTO_DMA) { 1343 printk(KERN_INFO 1344 "sscape: insufficient parameters, need IO, IRQ, MPU-IRQ and DMA\n"); 1345 return 0; 1346 } 1347 1348 return 1; 1349 } 1350 1351 static int __devinit snd_sscape_probe(struct device *pdev, unsigned int dev) 1352 { 1353 struct snd_card *card; 1354 struct soundscape *sscape; 1355 int ret; 1356 1357 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 1358 sizeof(struct soundscape)); 1359 if (!card) 1360 return -ENOMEM; 1361 1362 sscape = get_card_soundscape(card); 1363 sscape->type = SSCAPE; 1364 1365 dma[dev] &= 0x03; 1366 ret = create_sscape(dev, card); 1367 if (ret < 0) 1368 goto _release_card; 1369 1370 snd_card_set_dev(card, pdev); 1371 if ((ret = snd_card_register(card)) < 0) { 1372 printk(KERN_ERR "sscape: Failed to register sound card\n"); 1373 goto _release_card; 1374 } 1375 dev_set_drvdata(pdev, card); 1376 return 0; 1377 1378 _release_card: 1379 snd_card_free(card); 1380 return ret; 1381 } 1382 1383 static int __devexit snd_sscape_remove(struct device *devptr, unsigned int dev) 1384 { 1385 snd_card_free(dev_get_drvdata(devptr)); 1386 dev_set_drvdata(devptr, NULL); 1387 return 0; 1388 } 1389 1390 #define DEV_NAME "sscape" 1391 1392 static struct isa_driver snd_sscape_driver = { 1393 .match = snd_sscape_match, 1394 .probe = snd_sscape_probe, 1395 .remove = __devexit_p(snd_sscape_remove), 1396 /* FIXME: suspend/resume */ 1397 .driver = { 1398 .name = DEV_NAME 1399 }, 1400 }; 1401 1402 #ifdef CONFIG_PNP 1403 static inline int __devinit get_next_autoindex(int i) 1404 { 1405 while (i < SNDRV_CARDS && port[i] != SNDRV_AUTO_PORT) 1406 ++i; 1407 return i; 1408 } 1409 1410 1411 static int __devinit sscape_pnp_detect(struct pnp_card_link *pcard, 1412 const struct pnp_card_device_id *pid) 1413 { 1414 static int idx = 0; 1415 struct pnp_dev *dev; 1416 struct snd_card *card; 1417 struct soundscape *sscape; 1418 int ret; 1419 1420 /* 1421 * Allow this function to fail *quietly* if all the ISA PnP 1422 * devices were configured using module parameters instead. 1423 */ 1424 if ((idx = get_next_autoindex(idx)) >= SNDRV_CARDS) 1425 return -ENOSPC; 1426 1427 /* 1428 * We have found a candidate ISA PnP card. Now we 1429 * have to check that it has the devices that we 1430 * expect it to have. 1431 * 1432 * We will NOT try and autoconfigure all of the resources 1433 * needed and then activate the card as we are assuming that 1434 * has already been done at boot-time using /proc/isapnp. 1435 * We shall simply try to give each active card the resources 1436 * that it wants. This is a sensible strategy for a modular 1437 * system where unused modules are unloaded regularly. 1438 * 1439 * This strategy is utterly useless if we compile the driver 1440 * into the kernel, of course. 1441 */ 1442 // printk(KERN_INFO "sscape: %s\n", card->name); 1443 1444 /* 1445 * Check that we still have room for another sound card ... 1446 */ 1447 dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL); 1448 if (! dev) 1449 return -ENODEV; 1450 1451 if (!pnp_is_active(dev)) { 1452 if (pnp_activate_dev(dev) < 0) { 1453 printk(KERN_INFO "sscape: device is inactive\n"); 1454 return -EBUSY; 1455 } 1456 } 1457 1458 /* 1459 * Create a new ALSA sound card entry, in anticipation 1460 * of detecting our hardware ... 1461 */ 1462 card = snd_card_new(index[idx], id[idx], THIS_MODULE, 1463 sizeof(struct soundscape)); 1464 if (!card) 1465 return -ENOMEM; 1466 1467 sscape = get_card_soundscape(card); 1468 1469 /* 1470 * Identify card model ... 1471 */ 1472 if (!strncmp("ENS4081", pid->id, 7)) 1473 sscape->type = SSCAPE_VIVO; 1474 else 1475 sscape->type = SSCAPE_PNP; 1476 1477 /* 1478 * Read the correct parameters off the ISA PnP bus ... 1479 */ 1480 port[idx] = pnp_port_start(dev, 0); 1481 irq[idx] = pnp_irq(dev, 0); 1482 mpu_irq[idx] = pnp_irq(dev, 1); 1483 dma[idx] = pnp_dma(dev, 0) & 0x03; 1484 if (sscape->type == SSCAPE_PNP) { 1485 dma2[idx] = dma[idx]; 1486 wss_port[idx] = CODEC_IO(port[idx]); 1487 } else { 1488 wss_port[idx] = pnp_port_start(dev, 1); 1489 dma2[idx] = pnp_dma(dev, 1); 1490 } 1491 1492 ret = create_sscape(idx, card); 1493 if (ret < 0) 1494 goto _release_card; 1495 1496 snd_card_set_dev(card, &pcard->card->dev); 1497 if ((ret = snd_card_register(card)) < 0) { 1498 printk(KERN_ERR "sscape: Failed to register sound card\n"); 1499 goto _release_card; 1500 } 1501 1502 pnp_set_card_drvdata(pcard, card); 1503 ++idx; 1504 return 0; 1505 1506 _release_card: 1507 snd_card_free(card); 1508 return ret; 1509 } 1510 1511 static void __devexit sscape_pnp_remove(struct pnp_card_link * pcard) 1512 { 1513 snd_card_free(pnp_get_card_drvdata(pcard)); 1514 pnp_set_card_drvdata(pcard, NULL); 1515 } 1516 1517 static struct pnp_card_driver sscape_pnpc_driver = { 1518 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE, 1519 .name = "sscape", 1520 .id_table = sscape_pnpids, 1521 .probe = sscape_pnp_detect, 1522 .remove = __devexit_p(sscape_pnp_remove), 1523 }; 1524 1525 #endif /* CONFIG_PNP */ 1526 1527 static int __init sscape_init(void) 1528 { 1529 int err; 1530 1531 err = isa_register_driver(&snd_sscape_driver, SNDRV_CARDS); 1532 #ifdef CONFIG_PNP 1533 if (!err) 1534 isa_registered = 1; 1535 1536 err = pnp_register_card_driver(&sscape_pnpc_driver); 1537 if (!err) 1538 pnp_registered = 1; 1539 1540 if (isa_registered) 1541 err = 0; 1542 #endif 1543 return err; 1544 } 1545 1546 static void __exit sscape_exit(void) 1547 { 1548 #ifdef CONFIG_PNP 1549 if (pnp_registered) 1550 pnp_unregister_card_driver(&sscape_pnpc_driver); 1551 if (isa_registered) 1552 #endif 1553 isa_unregister_driver(&snd_sscape_driver); 1554 } 1555 1556 module_init(sscape_init); 1557 module_exit(sscape_exit); 1558