1 /* 2 * Copyright (c) 2004 James Courtier-Dutton <James@superbug.demon.co.uk> 3 * Driver CA0106 chips. e.g. Sound Blaster Audigy LS and Live 24bit 4 * Version: 0.0.23 5 * 6 * FEATURES currently supported: 7 * Front, Rear and Center/LFE. 8 * Surround40 and Surround51. 9 * Capture from MIC an LINE IN input. 10 * SPDIF digital playback of PCM stereo and AC3/DTS works. 11 * (One can use a standard mono mini-jack to one RCA plugs cable. 12 * or one can use a standard stereo mini-jack to two RCA plugs cable. 13 * Plug one of the RCA plugs into the Coax input of the external decoder/receiver.) 14 * ( In theory one could output 3 different AC3 streams at once, to 3 different SPDIF outputs. ) 15 * Notes on how to capture sound: 16 * The AC97 is used in the PLAYBACK direction. 17 * The output from the AC97 chip, instead of reaching the speakers, is fed into the Philips 1361T ADC. 18 * So, to record from the MIC, set the MIC Playback volume to max, 19 * unmute the MIC and turn up the MASTER Playback volume. 20 * So, to prevent feedback when capturing, minimise the "Capture feedback into Playback" volume. 21 * 22 * The only playback controls that currently do anything are: - 23 * Analog Front 24 * Analog Rear 25 * Analog Center/LFE 26 * SPDIF Front 27 * SPDIF Rear 28 * SPDIF Center/LFE 29 * 30 * For capture from Mic in or Line in. 31 * Digital/Analog ( switch must be in Analog mode for CAPTURE. ) 32 * 33 * CAPTURE feedback into PLAYBACK 34 * 35 * Changelog: 36 * Support interrupts per period. 37 * Removed noise from Center/LFE channel when in Analog mode. 38 * Rename and remove mixer controls. 39 * 0.0.6 40 * Use separate card based DMA buffer for periods table list. 41 * 0.0.7 42 * Change remove and rename ctrls into lists. 43 * 0.0.8 44 * Try to fix capture sources. 45 * 0.0.9 46 * Fix AC3 output. 47 * Enable S32_LE format support. 48 * 0.0.10 49 * Enable playback 48000 and 96000 rates. (Rates other that these do not work, even with "plug:front".) 50 * 0.0.11 51 * Add Model name recognition. 52 * 0.0.12 53 * Correct interrupt timing. interrupt at end of period, instead of in the middle of a playback period. 54 * Remove redundent "voice" handling. 55 * 0.0.13 56 * Single trigger call for multi channels. 57 * 0.0.14 58 * Set limits based on what the sound card hardware can do. 59 * playback periods_min=2, periods_max=8 60 * capture hw constraints require period_size = n * 64 bytes. 61 * playback hw constraints require period_size = n * 64 bytes. 62 * 0.0.15 63 * Minor updates. 64 * 0.0.16 65 * Implement 192000 sample rate. 66 * 0.0.17 67 * Add support for SB0410 and SB0413. 68 * 0.0.18 69 * Modified Copyright message. 70 * 0.0.19 71 * Finally fix support for SB Live 24 bit. SB0410 and SB0413. 72 * The output codec needs resetting, otherwise all output is muted. 73 * 0.0.20 74 * Merge "pci_disable_device(pci);" fixes. 75 * 0.0.21 76 * Add 4 capture channels. (SPDIF only comes in on channel 0. ) 77 * Add SPDIF capture using optional digital I/O module for SB Live 24bit. (Analog capture does not yet work.) 78 * 0.0.22 79 * Add support for MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97. From kiksen, bug #901 80 * 0.0.23 81 * Implement support for Line-in capture on SB Live 24bit. 82 * 83 * BUGS: 84 * Some stability problems when unloading the snd-ca0106 kernel module. 85 * -- 86 * 87 * TODO: 88 * 4 Capture channels, only one implemented so far. 89 * Other capture rates apart from 48khz not implemented. 90 * MIDI 91 * -- 92 * GENERAL INFO: 93 * Model: SB0310 94 * P17 Chip: CA0106-DAT 95 * AC97 Codec: STAC 9721 96 * ADC: Philips 1361T (Stereo 24bit) 97 * DAC: WM8746EDS (6-channel, 24bit, 192Khz) 98 * 99 * GENERAL INFO: 100 * Model: SB0410 101 * P17 Chip: CA0106-DAT 102 * AC97 Codec: None 103 * ADC: WM8775EDS (4 Channel) 104 * DAC: CS4382 (114 dB, 24-Bit, 192 kHz, 8-Channel D/A Converter with DSD Support) 105 * SPDIF Out control switches between Mic in and SPDIF out. 106 * No sound out or mic input working yet. 107 * 108 * GENERAL INFO: 109 * Model: SB0413 110 * P17 Chip: CA0106-DAT 111 * AC97 Codec: None. 112 * ADC: Unknown 113 * DAC: Unknown 114 * Trying to handle it like the SB0410. 115 * 116 * This code was initally based on code from ALSA's emu10k1x.c which is: 117 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com> 118 * 119 * This program is free software; you can redistribute it and/or modify 120 * it under the terms of the GNU General Public License as published by 121 * the Free Software Foundation; either version 2 of the License, or 122 * (at your option) any later version. 123 * 124 * This program is distributed in the hope that it will be useful, 125 * but WITHOUT ANY WARRANTY; without even the implied warranty of 126 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 127 * GNU General Public License for more details. 128 * 129 * You should have received a copy of the GNU General Public License 130 * along with this program; if not, write to the Free Software 131 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 132 * 133 */ 134 #include <sound/driver.h> 135 #include <linux/delay.h> 136 #include <linux/init.h> 137 #include <linux/interrupt.h> 138 #include <linux/pci.h> 139 #include <linux/slab.h> 140 #include <linux/moduleparam.h> 141 #include <linux/dma-mapping.h> 142 #include <sound/core.h> 143 #include <sound/initval.h> 144 #include <sound/pcm.h> 145 #include <sound/ac97_codec.h> 146 #include <sound/info.h> 147 148 MODULE_AUTHOR("James Courtier-Dutton <James@superbug.demon.co.uk>"); 149 MODULE_DESCRIPTION("CA0106"); 150 MODULE_LICENSE("GPL"); 151 MODULE_SUPPORTED_DEVICE("{{Creative,SB CA0106 chip}}"); 152 153 // module parameters (see "Module Parameters") 154 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; 155 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; 156 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; 157 158 module_param_array(index, int, NULL, 0444); 159 MODULE_PARM_DESC(index, "Index value for the CA0106 soundcard."); 160 module_param_array(id, charp, NULL, 0444); 161 MODULE_PARM_DESC(id, "ID string for the CA0106 soundcard."); 162 module_param_array(enable, bool, NULL, 0444); 163 MODULE_PARM_DESC(enable, "Enable the CA0106 soundcard."); 164 165 #include "ca0106.h" 166 167 static struct snd_ca0106_details ca0106_chip_details[] = { 168 /* AudigyLS[SB0310] */ 169 { .serial = 0x10021102, 170 .name = "AudigyLS [SB0310]", 171 .ac97 = 1 } , 172 /* Unknown AudigyLS that also says SB0310 on it */ 173 { .serial = 0x10051102, 174 .name = "AudigyLS [SB0310b]", 175 .ac97 = 1 } , 176 /* New Sound Blaster Live! 7.1 24bit. This does not have an AC97. 53SB041000001 */ 177 { .serial = 0x10061102, 178 .name = "Live! 7.1 24bit [SB0410]", 179 .gpio_type = 1, 180 .i2c_adc = 1 } , 181 /* New Dell Sound Blaster Live! 7.1 24bit. This does not have an AC97. */ 182 { .serial = 0x10071102, 183 .name = "Live! 7.1 24bit [SB0413]", 184 .gpio_type = 1, 185 .i2c_adc = 1 } , 186 /* New Audigy SE. Has a different DAC. */ 187 /* SB0570: 188 * CTRL:CA0106-DAT 189 * ADC: WM8775EDS 190 * DAC: WM8768GEDS 191 */ 192 { .serial = 0x100a1102, 193 .name = "Audigy SE [SB0570]", 194 .gpio_type = 1, 195 .i2c_adc = 1, 196 .spi_dac = 1 } , 197 /* MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97 */ 198 /* SB0438 199 * CTRL:CA0106-DAT 200 * ADC: WM8775SEDS 201 * DAC: CS4382-KQZ 202 */ 203 { .serial = 0x10091462, 204 .name = "MSI K8N Diamond MB [SB0438]", 205 .gpio_type = 2, 206 .i2c_adc = 1 } , 207 /* Shuttle XPC SD31P which has an onboard Creative Labs 208 * Sound Blaster Live! 24-bit EAX 209 * high-definition 7.1 audio processor". 210 * Added using info from andrewvegan in alsa bug #1298 211 */ 212 { .serial = 0x30381297, 213 .name = "Shuttle XPC SD31P [SD31P]", 214 .gpio_type = 1, 215 .i2c_adc = 1 } , 216 /* Shuttle XPC SD11G5 which has an onboard Creative Labs 217 * Sound Blaster Live! 24-bit EAX 218 * high-definition 7.1 audio processor". 219 * Fixes ALSA bug#1600 220 */ 221 { .serial = 0x30411297, 222 .name = "Shuttle XPC SD11G5 [SD11G5]", 223 .gpio_type = 1, 224 .i2c_adc = 1 } , 225 { .serial = 0, 226 .name = "AudigyLS [Unknown]" } 227 }; 228 229 /* hardware definition */ 230 static struct snd_pcm_hardware snd_ca0106_playback_hw = { 231 .info = (SNDRV_PCM_INFO_MMAP | 232 SNDRV_PCM_INFO_INTERLEAVED | 233 SNDRV_PCM_INFO_BLOCK_TRANSFER | 234 SNDRV_PCM_INFO_MMAP_VALID), 235 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE, 236 .rates = (SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | 237 SNDRV_PCM_RATE_192000), 238 .rate_min = 48000, 239 .rate_max = 192000, 240 .channels_min = 2, //1, 241 .channels_max = 2, //6, 242 .buffer_bytes_max = ((65536 - 64) * 8), 243 .period_bytes_min = 64, 244 .period_bytes_max = (65536 - 64), 245 .periods_min = 2, 246 .periods_max = 8, 247 .fifo_size = 0, 248 }; 249 250 static struct snd_pcm_hardware snd_ca0106_capture_hw = { 251 .info = (SNDRV_PCM_INFO_MMAP | 252 SNDRV_PCM_INFO_INTERLEAVED | 253 SNDRV_PCM_INFO_BLOCK_TRANSFER | 254 SNDRV_PCM_INFO_MMAP_VALID), 255 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE, 256 .rates = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | 257 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000), 258 .rate_min = 44100, 259 .rate_max = 192000, 260 .channels_min = 2, 261 .channels_max = 2, 262 .buffer_bytes_max = ((65536 - 64) * 8), 263 .period_bytes_min = 64, 264 .period_bytes_max = (65536 - 64), 265 .periods_min = 2, 266 .periods_max = 2, 267 .fifo_size = 0, 268 }; 269 270 unsigned int snd_ca0106_ptr_read(struct snd_ca0106 * emu, 271 unsigned int reg, 272 unsigned int chn) 273 { 274 unsigned long flags; 275 unsigned int regptr, val; 276 277 regptr = (reg << 16) | chn; 278 279 spin_lock_irqsave(&emu->emu_lock, flags); 280 outl(regptr, emu->port + PTR); 281 val = inl(emu->port + DATA); 282 spin_unlock_irqrestore(&emu->emu_lock, flags); 283 return val; 284 } 285 286 void snd_ca0106_ptr_write(struct snd_ca0106 *emu, 287 unsigned int reg, 288 unsigned int chn, 289 unsigned int data) 290 { 291 unsigned int regptr; 292 unsigned long flags; 293 294 regptr = (reg << 16) | chn; 295 296 spin_lock_irqsave(&emu->emu_lock, flags); 297 outl(regptr, emu->port + PTR); 298 outl(data, emu->port + DATA); 299 spin_unlock_irqrestore(&emu->emu_lock, flags); 300 } 301 302 int snd_ca0106_spi_write(struct snd_ca0106 * emu, 303 unsigned int data) 304 { 305 unsigned int reset, set; 306 unsigned int reg, tmp; 307 int n, result; 308 reg = SPI; 309 if (data > 0xffff) /* Only 16bit values allowed */ 310 return 1; 311 tmp = snd_ca0106_ptr_read(emu, reg, 0); 312 reset = (tmp & ~0x3ffff) | 0x20000; /* Set xxx20000 */ 313 set = reset | 0x10000; /* Set xxx1xxxx */ 314 snd_ca0106_ptr_write(emu, reg, 0, reset | data); 315 tmp = snd_ca0106_ptr_read(emu, reg, 0); /* write post */ 316 snd_ca0106_ptr_write(emu, reg, 0, set | data); 317 result = 1; 318 /* Wait for status bit to return to 0 */ 319 for (n = 0; n < 100; n++) { 320 udelay(10); 321 tmp = snd_ca0106_ptr_read(emu, reg, 0); 322 if (!(tmp & 0x10000)) { 323 result = 0; 324 break; 325 } 326 } 327 if (result) /* Timed out */ 328 return 1; 329 snd_ca0106_ptr_write(emu, reg, 0, reset | data); 330 tmp = snd_ca0106_ptr_read(emu, reg, 0); /* Write post */ 331 return 0; 332 } 333 334 /* The ADC does not support i2c read, so only write is implemented */ 335 int snd_ca0106_i2c_write(struct snd_ca0106 *emu, 336 u32 reg, 337 u32 value) 338 { 339 u32 tmp; 340 int timeout = 0; 341 int status; 342 int retry; 343 if ((reg > 0x7f) || (value > 0x1ff)) { 344 snd_printk(KERN_ERR "i2c_write: invalid values.\n"); 345 return -EINVAL; 346 } 347 348 tmp = reg << 25 | value << 16; 349 // snd_printk("I2C-write:reg=0x%x, value=0x%x\n", reg, value); 350 /* Not sure what this I2C channel controls. */ 351 /* snd_ca0106_ptr_write(emu, I2C_D0, 0, tmp); */ 352 353 /* This controls the I2C connected to the WM8775 ADC Codec */ 354 snd_ca0106_ptr_write(emu, I2C_D1, 0, tmp); 355 356 for (retry = 0; retry < 10; retry++) { 357 /* Send the data to i2c */ 358 //tmp = snd_ca0106_ptr_read(emu, I2C_A, 0); 359 //tmp = tmp & ~(I2C_A_ADC_READ|I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD_MASK); 360 tmp = 0; 361 tmp = tmp | (I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD); 362 snd_ca0106_ptr_write(emu, I2C_A, 0, tmp); 363 364 /* Wait till the transaction ends */ 365 while (1) { 366 status = snd_ca0106_ptr_read(emu, I2C_A, 0); 367 //snd_printk("I2C:status=0x%x\n", status); 368 timeout++; 369 if ((status & I2C_A_ADC_START) == 0) 370 break; 371 372 if (timeout > 1000) 373 break; 374 } 375 //Read back and see if the transaction is successful 376 if ((status & I2C_A_ADC_ABORT) == 0) 377 break; 378 } 379 380 if (retry == 10) { 381 snd_printk(KERN_ERR "Writing to ADC failed!\n"); 382 return -EINVAL; 383 } 384 385 return 0; 386 } 387 388 389 static void snd_ca0106_intr_enable(struct snd_ca0106 *emu, unsigned int intrenb) 390 { 391 unsigned long flags; 392 unsigned int enable; 393 394 spin_lock_irqsave(&emu->emu_lock, flags); 395 enable = inl(emu->port + INTE) | intrenb; 396 outl(enable, emu->port + INTE); 397 spin_unlock_irqrestore(&emu->emu_lock, flags); 398 } 399 400 static void snd_ca0106_intr_disable(struct snd_ca0106 *emu, unsigned int intrenb) 401 { 402 unsigned long flags; 403 unsigned int enable; 404 405 spin_lock_irqsave(&emu->emu_lock, flags); 406 enable = inl(emu->port + INTE) & ~intrenb; 407 outl(enable, emu->port + INTE); 408 spin_unlock_irqrestore(&emu->emu_lock, flags); 409 } 410 411 412 static void snd_ca0106_pcm_free_substream(struct snd_pcm_runtime *runtime) 413 { 414 kfree(runtime->private_data); 415 } 416 417 /* open_playback callback */ 418 static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream, 419 int channel_id) 420 { 421 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream); 422 struct snd_ca0106_channel *channel = &(chip->playback_channels[channel_id]); 423 struct snd_ca0106_pcm *epcm; 424 struct snd_pcm_runtime *runtime = substream->runtime; 425 int err; 426 427 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); 428 429 if (epcm == NULL) 430 return -ENOMEM; 431 epcm->emu = chip; 432 epcm->substream = substream; 433 epcm->channel_id=channel_id; 434 435 runtime->private_data = epcm; 436 runtime->private_free = snd_ca0106_pcm_free_substream; 437 438 runtime->hw = snd_ca0106_playback_hw; 439 440 channel->emu = chip; 441 channel->number = channel_id; 442 443 channel->use = 1; 444 //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel); 445 //channel->interrupt = snd_ca0106_pcm_channel_interrupt; 446 channel->epcm = epcm; 447 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) 448 return err; 449 if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0) 450 return err; 451 return 0; 452 } 453 454 /* close callback */ 455 static int snd_ca0106_pcm_close_playback(struct snd_pcm_substream *substream) 456 { 457 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream); 458 struct snd_pcm_runtime *runtime = substream->runtime; 459 struct snd_ca0106_pcm *epcm = runtime->private_data; 460 chip->playback_channels[epcm->channel_id].use = 0; 461 /* FIXME: maybe zero others */ 462 return 0; 463 } 464 465 static int snd_ca0106_pcm_open_playback_front(struct snd_pcm_substream *substream) 466 { 467 return snd_ca0106_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL); 468 } 469 470 static int snd_ca0106_pcm_open_playback_center_lfe(struct snd_pcm_substream *substream) 471 { 472 return snd_ca0106_pcm_open_playback_channel(substream, PCM_CENTER_LFE_CHANNEL); 473 } 474 475 static int snd_ca0106_pcm_open_playback_unknown(struct snd_pcm_substream *substream) 476 { 477 return snd_ca0106_pcm_open_playback_channel(substream, PCM_UNKNOWN_CHANNEL); 478 } 479 480 static int snd_ca0106_pcm_open_playback_rear(struct snd_pcm_substream *substream) 481 { 482 return snd_ca0106_pcm_open_playback_channel(substream, PCM_REAR_CHANNEL); 483 } 484 485 /* open_capture callback */ 486 static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substream, 487 int channel_id) 488 { 489 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream); 490 struct snd_ca0106_channel *channel = &(chip->capture_channels[channel_id]); 491 struct snd_ca0106_pcm *epcm; 492 struct snd_pcm_runtime *runtime = substream->runtime; 493 int err; 494 495 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); 496 if (epcm == NULL) { 497 snd_printk(KERN_ERR "open_capture_channel: failed epcm alloc\n"); 498 return -ENOMEM; 499 } 500 epcm->emu = chip; 501 epcm->substream = substream; 502 epcm->channel_id=channel_id; 503 504 runtime->private_data = epcm; 505 runtime->private_free = snd_ca0106_pcm_free_substream; 506 507 runtime->hw = snd_ca0106_capture_hw; 508 509 channel->emu = chip; 510 channel->number = channel_id; 511 512 channel->use = 1; 513 //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel); 514 //channel->interrupt = snd_ca0106_pcm_channel_interrupt; 515 channel->epcm = epcm; 516 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) 517 return err; 518 //snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hw_constraints_capture_period_sizes); 519 if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0) 520 return err; 521 return 0; 522 } 523 524 /* close callback */ 525 static int snd_ca0106_pcm_close_capture(struct snd_pcm_substream *substream) 526 { 527 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream); 528 struct snd_pcm_runtime *runtime = substream->runtime; 529 struct snd_ca0106_pcm *epcm = runtime->private_data; 530 chip->capture_channels[epcm->channel_id].use = 0; 531 /* FIXME: maybe zero others */ 532 return 0; 533 } 534 535 static int snd_ca0106_pcm_open_0_capture(struct snd_pcm_substream *substream) 536 { 537 return snd_ca0106_pcm_open_capture_channel(substream, 0); 538 } 539 540 static int snd_ca0106_pcm_open_1_capture(struct snd_pcm_substream *substream) 541 { 542 return snd_ca0106_pcm_open_capture_channel(substream, 1); 543 } 544 545 static int snd_ca0106_pcm_open_2_capture(struct snd_pcm_substream *substream) 546 { 547 return snd_ca0106_pcm_open_capture_channel(substream, 2); 548 } 549 550 static int snd_ca0106_pcm_open_3_capture(struct snd_pcm_substream *substream) 551 { 552 return snd_ca0106_pcm_open_capture_channel(substream, 3); 553 } 554 555 /* hw_params callback */ 556 static int snd_ca0106_pcm_hw_params_playback(struct snd_pcm_substream *substream, 557 struct snd_pcm_hw_params *hw_params) 558 { 559 return snd_pcm_lib_malloc_pages(substream, 560 params_buffer_bytes(hw_params)); 561 } 562 563 /* hw_free callback */ 564 static int snd_ca0106_pcm_hw_free_playback(struct snd_pcm_substream *substream) 565 { 566 return snd_pcm_lib_free_pages(substream); 567 } 568 569 /* hw_params callback */ 570 static int snd_ca0106_pcm_hw_params_capture(struct snd_pcm_substream *substream, 571 struct snd_pcm_hw_params *hw_params) 572 { 573 return snd_pcm_lib_malloc_pages(substream, 574 params_buffer_bytes(hw_params)); 575 } 576 577 /* hw_free callback */ 578 static int snd_ca0106_pcm_hw_free_capture(struct snd_pcm_substream *substream) 579 { 580 return snd_pcm_lib_free_pages(substream); 581 } 582 583 /* prepare playback callback */ 584 static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream) 585 { 586 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); 587 struct snd_pcm_runtime *runtime = substream->runtime; 588 struct snd_ca0106_pcm *epcm = runtime->private_data; 589 int channel = epcm->channel_id; 590 u32 *table_base = (u32 *)(emu->buffer.area+(8*16*channel)); 591 u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size); 592 u32 hcfg_mask = HCFG_PLAYBACK_S32_LE; 593 u32 hcfg_set = 0x00000000; 594 u32 hcfg; 595 u32 reg40_mask = 0x30000 << (channel<<1); 596 u32 reg40_set = 0; 597 u32 reg40; 598 /* FIXME: Depending on mixer selection of SPDIF out or not, select the spdif rate or the DAC rate. */ 599 u32 reg71_mask = 0x03030000 ; /* Global. Set SPDIF rate. We only support 44100 to spdif, not to DAC. */ 600 u32 reg71_set = 0; 601 u32 reg71; 602 int i; 603 604 //snd_printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, periods=%u, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, runtime->periods, frames_to_bytes(runtime, 1)); 605 //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base); 606 //snd_printk("dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",emu->buffer.addr, emu->buffer.area, emu->buffer.bytes); 607 /* Rate can be set per channel. */ 608 /* reg40 control host to fifo */ 609 /* reg71 controls DAC rate. */ 610 switch (runtime->rate) { 611 case 44100: 612 reg40_set = 0x10000 << (channel<<1); 613 reg71_set = 0x01010000; 614 break; 615 case 48000: 616 reg40_set = 0; 617 reg71_set = 0; 618 break; 619 case 96000: 620 reg40_set = 0x20000 << (channel<<1); 621 reg71_set = 0x02020000; 622 break; 623 case 192000: 624 reg40_set = 0x30000 << (channel<<1); 625 reg71_set = 0x03030000; 626 break; 627 default: 628 reg40_set = 0; 629 reg71_set = 0; 630 break; 631 } 632 /* Format is a global setting */ 633 /* FIXME: Only let the first channel accessed set this. */ 634 switch (runtime->format) { 635 case SNDRV_PCM_FORMAT_S16_LE: 636 hcfg_set = 0; 637 break; 638 case SNDRV_PCM_FORMAT_S32_LE: 639 hcfg_set = HCFG_PLAYBACK_S32_LE; 640 break; 641 default: 642 hcfg_set = 0; 643 break; 644 } 645 hcfg = inl(emu->port + HCFG) ; 646 hcfg = (hcfg & ~hcfg_mask) | hcfg_set; 647 outl(hcfg, emu->port + HCFG); 648 reg40 = snd_ca0106_ptr_read(emu, 0x40, 0); 649 reg40 = (reg40 & ~reg40_mask) | reg40_set; 650 snd_ca0106_ptr_write(emu, 0x40, 0, reg40); 651 reg71 = snd_ca0106_ptr_read(emu, 0x71, 0); 652 reg71 = (reg71 & ~reg71_mask) | reg71_set; 653 snd_ca0106_ptr_write(emu, 0x71, 0, reg71); 654 655 /* FIXME: Check emu->buffer.size before actually writing to it. */ 656 for(i=0; i < runtime->periods; i++) { 657 table_base[i*2] = runtime->dma_addr + (i * period_size_bytes); 658 table_base[i*2+1] = period_size_bytes << 16; 659 } 660 661 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer.addr+(8*16*channel)); 662 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19); 663 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_PTR, channel, 0); 664 snd_ca0106_ptr_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr); 665 snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16); // buffer size in bytes 666 /* FIXME test what 0 bytes does. */ 667 snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, 0); // buffer size in bytes 668 snd_ca0106_ptr_write(emu, PLAYBACK_POINTER, channel, 0); 669 snd_ca0106_ptr_write(emu, 0x07, channel, 0x0); 670 snd_ca0106_ptr_write(emu, 0x08, channel, 0); 671 snd_ca0106_ptr_write(emu, PLAYBACK_MUTE, 0x0, 0x0); /* Unmute output */ 672 #if 0 673 snd_ca0106_ptr_write(emu, SPCS0, 0, 674 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | 675 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | 676 SPCS_GENERATIONSTATUS | 0x00001200 | 677 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT ); 678 } 679 #endif 680 681 return 0; 682 } 683 684 /* prepare capture callback */ 685 static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream) 686 { 687 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); 688 struct snd_pcm_runtime *runtime = substream->runtime; 689 struct snd_ca0106_pcm *epcm = runtime->private_data; 690 int channel = epcm->channel_id; 691 u32 hcfg_mask = HCFG_CAPTURE_S32_LE; 692 u32 hcfg_set = 0x00000000; 693 u32 hcfg; 694 u32 over_sampling=0x2; 695 u32 reg71_mask = 0x0000c000 ; /* Global. Set ADC rate. */ 696 u32 reg71_set = 0; 697 u32 reg71; 698 699 //snd_printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, periods=%u, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, runtime->periods, frames_to_bytes(runtime, 1)); 700 //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base); 701 //snd_printk("dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",emu->buffer.addr, emu->buffer.area, emu->buffer.bytes); 702 /* reg71 controls ADC rate. */ 703 switch (runtime->rate) { 704 case 44100: 705 reg71_set = 0x00004000; 706 break; 707 case 48000: 708 reg71_set = 0; 709 break; 710 case 96000: 711 reg71_set = 0x00008000; 712 over_sampling=0xa; 713 break; 714 case 192000: 715 reg71_set = 0x0000c000; 716 over_sampling=0xa; 717 break; 718 default: 719 reg71_set = 0; 720 break; 721 } 722 /* Format is a global setting */ 723 /* FIXME: Only let the first channel accessed set this. */ 724 switch (runtime->format) { 725 case SNDRV_PCM_FORMAT_S16_LE: 726 hcfg_set = 0; 727 break; 728 case SNDRV_PCM_FORMAT_S32_LE: 729 hcfg_set = HCFG_CAPTURE_S32_LE; 730 break; 731 default: 732 hcfg_set = 0; 733 break; 734 } 735 hcfg = inl(emu->port + HCFG) ; 736 hcfg = (hcfg & ~hcfg_mask) | hcfg_set; 737 outl(hcfg, emu->port + HCFG); 738 reg71 = snd_ca0106_ptr_read(emu, 0x71, 0); 739 reg71 = (reg71 & ~reg71_mask) | reg71_set; 740 snd_ca0106_ptr_write(emu, 0x71, 0, reg71); 741 if (emu->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */ 742 snd_ca0106_i2c_write(emu, ADC_MASTER, over_sampling); /* Adjust the over sampler to better suit the capture rate. */ 743 } 744 745 746 //printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, frames_to_bytes(runtime, 1)); 747 snd_ca0106_ptr_write(emu, 0x13, channel, 0); 748 snd_ca0106_ptr_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr); 749 snd_ca0106_ptr_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size)<<16); // buffer size in bytes 750 snd_ca0106_ptr_write(emu, CAPTURE_POINTER, channel, 0); 751 752 return 0; 753 } 754 755 /* trigger_playback callback */ 756 static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream, 757 int cmd) 758 { 759 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); 760 struct snd_pcm_runtime *runtime; 761 struct snd_ca0106_pcm *epcm; 762 int channel; 763 int result = 0; 764 struct list_head *pos; 765 struct snd_pcm_substream *s; 766 u32 basic = 0; 767 u32 extended = 0; 768 int running=0; 769 770 switch (cmd) { 771 case SNDRV_PCM_TRIGGER_START: 772 running=1; 773 break; 774 case SNDRV_PCM_TRIGGER_STOP: 775 default: 776 running=0; 777 break; 778 } 779 snd_pcm_group_for_each(pos, substream) { 780 s = snd_pcm_group_substream_entry(pos); 781 runtime = s->runtime; 782 epcm = runtime->private_data; 783 channel = epcm->channel_id; 784 //snd_printk("channel=%d\n",channel); 785 epcm->running = running; 786 basic |= (0x1<<channel); 787 extended |= (0x10<<channel); 788 snd_pcm_trigger_done(s, substream); 789 } 790 //snd_printk("basic=0x%x, extended=0x%x\n",basic, extended); 791 792 switch (cmd) { 793 case SNDRV_PCM_TRIGGER_START: 794 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (extended)); 795 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(basic)); 796 break; 797 case SNDRV_PCM_TRIGGER_STOP: 798 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(basic)); 799 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(extended)); 800 break; 801 default: 802 result = -EINVAL; 803 break; 804 } 805 return result; 806 } 807 808 /* trigger_capture callback */ 809 static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream, 810 int cmd) 811 { 812 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); 813 struct snd_pcm_runtime *runtime = substream->runtime; 814 struct snd_ca0106_pcm *epcm = runtime->private_data; 815 int channel = epcm->channel_id; 816 int result = 0; 817 818 switch (cmd) { 819 case SNDRV_PCM_TRIGGER_START: 820 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel)); 821 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel)); 822 epcm->running = 1; 823 break; 824 case SNDRV_PCM_TRIGGER_STOP: 825 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel)); 826 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel)); 827 epcm->running = 0; 828 break; 829 default: 830 result = -EINVAL; 831 break; 832 } 833 return result; 834 } 835 836 /* pointer_playback callback */ 837 static snd_pcm_uframes_t 838 snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream) 839 { 840 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); 841 struct snd_pcm_runtime *runtime = substream->runtime; 842 struct snd_ca0106_pcm *epcm = runtime->private_data; 843 snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0; 844 int channel = epcm->channel_id; 845 846 if (!epcm->running) 847 return 0; 848 849 ptr3 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel); 850 ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel); 851 ptr4 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel); 852 if (ptr3 != ptr4) ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel); 853 ptr2 = bytes_to_frames(runtime, ptr1); 854 ptr2+= (ptr4 >> 3) * runtime->period_size; 855 ptr=ptr2; 856 if (ptr >= runtime->buffer_size) 857 ptr -= runtime->buffer_size; 858 //printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate); 859 860 return ptr; 861 } 862 863 /* pointer_capture callback */ 864 static snd_pcm_uframes_t 865 snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream) 866 { 867 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); 868 struct snd_pcm_runtime *runtime = substream->runtime; 869 struct snd_ca0106_pcm *epcm = runtime->private_data; 870 snd_pcm_uframes_t ptr, ptr1, ptr2 = 0; 871 int channel = channel=epcm->channel_id; 872 873 if (!epcm->running) 874 return 0; 875 876 ptr1 = snd_ca0106_ptr_read(emu, CAPTURE_POINTER, channel); 877 ptr2 = bytes_to_frames(runtime, ptr1); 878 ptr=ptr2; 879 if (ptr >= runtime->buffer_size) 880 ptr -= runtime->buffer_size; 881 //printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate); 882 883 return ptr; 884 } 885 886 /* operators */ 887 static struct snd_pcm_ops snd_ca0106_playback_front_ops = { 888 .open = snd_ca0106_pcm_open_playback_front, 889 .close = snd_ca0106_pcm_close_playback, 890 .ioctl = snd_pcm_lib_ioctl, 891 .hw_params = snd_ca0106_pcm_hw_params_playback, 892 .hw_free = snd_ca0106_pcm_hw_free_playback, 893 .prepare = snd_ca0106_pcm_prepare_playback, 894 .trigger = snd_ca0106_pcm_trigger_playback, 895 .pointer = snd_ca0106_pcm_pointer_playback, 896 }; 897 898 static struct snd_pcm_ops snd_ca0106_capture_0_ops = { 899 .open = snd_ca0106_pcm_open_0_capture, 900 .close = snd_ca0106_pcm_close_capture, 901 .ioctl = snd_pcm_lib_ioctl, 902 .hw_params = snd_ca0106_pcm_hw_params_capture, 903 .hw_free = snd_ca0106_pcm_hw_free_capture, 904 .prepare = snd_ca0106_pcm_prepare_capture, 905 .trigger = snd_ca0106_pcm_trigger_capture, 906 .pointer = snd_ca0106_pcm_pointer_capture, 907 }; 908 909 static struct snd_pcm_ops snd_ca0106_capture_1_ops = { 910 .open = snd_ca0106_pcm_open_1_capture, 911 .close = snd_ca0106_pcm_close_capture, 912 .ioctl = snd_pcm_lib_ioctl, 913 .hw_params = snd_ca0106_pcm_hw_params_capture, 914 .hw_free = snd_ca0106_pcm_hw_free_capture, 915 .prepare = snd_ca0106_pcm_prepare_capture, 916 .trigger = snd_ca0106_pcm_trigger_capture, 917 .pointer = snd_ca0106_pcm_pointer_capture, 918 }; 919 920 static struct snd_pcm_ops snd_ca0106_capture_2_ops = { 921 .open = snd_ca0106_pcm_open_2_capture, 922 .close = snd_ca0106_pcm_close_capture, 923 .ioctl = snd_pcm_lib_ioctl, 924 .hw_params = snd_ca0106_pcm_hw_params_capture, 925 .hw_free = snd_ca0106_pcm_hw_free_capture, 926 .prepare = snd_ca0106_pcm_prepare_capture, 927 .trigger = snd_ca0106_pcm_trigger_capture, 928 .pointer = snd_ca0106_pcm_pointer_capture, 929 }; 930 931 static struct snd_pcm_ops snd_ca0106_capture_3_ops = { 932 .open = snd_ca0106_pcm_open_3_capture, 933 .close = snd_ca0106_pcm_close_capture, 934 .ioctl = snd_pcm_lib_ioctl, 935 .hw_params = snd_ca0106_pcm_hw_params_capture, 936 .hw_free = snd_ca0106_pcm_hw_free_capture, 937 .prepare = snd_ca0106_pcm_prepare_capture, 938 .trigger = snd_ca0106_pcm_trigger_capture, 939 .pointer = snd_ca0106_pcm_pointer_capture, 940 }; 941 942 static struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = { 943 .open = snd_ca0106_pcm_open_playback_center_lfe, 944 .close = snd_ca0106_pcm_close_playback, 945 .ioctl = snd_pcm_lib_ioctl, 946 .hw_params = snd_ca0106_pcm_hw_params_playback, 947 .hw_free = snd_ca0106_pcm_hw_free_playback, 948 .prepare = snd_ca0106_pcm_prepare_playback, 949 .trigger = snd_ca0106_pcm_trigger_playback, 950 .pointer = snd_ca0106_pcm_pointer_playback, 951 }; 952 953 static struct snd_pcm_ops snd_ca0106_playback_unknown_ops = { 954 .open = snd_ca0106_pcm_open_playback_unknown, 955 .close = snd_ca0106_pcm_close_playback, 956 .ioctl = snd_pcm_lib_ioctl, 957 .hw_params = snd_ca0106_pcm_hw_params_playback, 958 .hw_free = snd_ca0106_pcm_hw_free_playback, 959 .prepare = snd_ca0106_pcm_prepare_playback, 960 .trigger = snd_ca0106_pcm_trigger_playback, 961 .pointer = snd_ca0106_pcm_pointer_playback, 962 }; 963 964 static struct snd_pcm_ops snd_ca0106_playback_rear_ops = { 965 .open = snd_ca0106_pcm_open_playback_rear, 966 .close = snd_ca0106_pcm_close_playback, 967 .ioctl = snd_pcm_lib_ioctl, 968 .hw_params = snd_ca0106_pcm_hw_params_playback, 969 .hw_free = snd_ca0106_pcm_hw_free_playback, 970 .prepare = snd_ca0106_pcm_prepare_playback, 971 .trigger = snd_ca0106_pcm_trigger_playback, 972 .pointer = snd_ca0106_pcm_pointer_playback, 973 }; 974 975 976 static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97, 977 unsigned short reg) 978 { 979 struct snd_ca0106 *emu = ac97->private_data; 980 unsigned long flags; 981 unsigned short val; 982 983 spin_lock_irqsave(&emu->emu_lock, flags); 984 outb(reg, emu->port + AC97ADDRESS); 985 val = inw(emu->port + AC97DATA); 986 spin_unlock_irqrestore(&emu->emu_lock, flags); 987 return val; 988 } 989 990 static void snd_ca0106_ac97_write(struct snd_ac97 *ac97, 991 unsigned short reg, unsigned short val) 992 { 993 struct snd_ca0106 *emu = ac97->private_data; 994 unsigned long flags; 995 996 spin_lock_irqsave(&emu->emu_lock, flags); 997 outb(reg, emu->port + AC97ADDRESS); 998 outw(val, emu->port + AC97DATA); 999 spin_unlock_irqrestore(&emu->emu_lock, flags); 1000 } 1001 1002 static int snd_ca0106_ac97(struct snd_ca0106 *chip) 1003 { 1004 struct snd_ac97_bus *pbus; 1005 struct snd_ac97_template ac97; 1006 int err; 1007 static struct snd_ac97_bus_ops ops = { 1008 .write = snd_ca0106_ac97_write, 1009 .read = snd_ca0106_ac97_read, 1010 }; 1011 1012 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0) 1013 return err; 1014 pbus->no_vra = 1; /* we don't need VRA */ 1015 1016 memset(&ac97, 0, sizeof(ac97)); 1017 ac97.private_data = chip; 1018 ac97.scaps = AC97_SCAP_NO_SPDIF; 1019 return snd_ac97_mixer(pbus, &ac97, &chip->ac97); 1020 } 1021 1022 static int snd_ca0106_free(struct snd_ca0106 *chip) 1023 { 1024 if (chip->res_port != NULL) { /* avoid access to already used hardware */ 1025 // disable interrupts 1026 snd_ca0106_ptr_write(chip, BASIC_INTERRUPT, 0, 0); 1027 outl(0, chip->port + INTE); 1028 snd_ca0106_ptr_write(chip, EXTENDED_INT_MASK, 0, 0); 1029 udelay(1000); 1030 // disable audio 1031 //outl(HCFG_LOCKSOUNDCACHE, chip->port + HCFG); 1032 outl(0, chip->port + HCFG); 1033 /* FIXME: We need to stop and DMA transfers here. 1034 * But as I am not sure how yet, we cannot from the dma pages. 1035 * So we can fix: snd-malloc: Memory leak? pages not freed = 8 1036 */ 1037 } 1038 // release the data 1039 #if 1 1040 if (chip->buffer.area) 1041 snd_dma_free_pages(&chip->buffer); 1042 #endif 1043 1044 // release the i/o port 1045 release_and_free_resource(chip->res_port); 1046 1047 // release the irq 1048 if (chip->irq >= 0) 1049 free_irq(chip->irq, (void *)chip); 1050 pci_disable_device(chip->pci); 1051 kfree(chip); 1052 return 0; 1053 } 1054 1055 static int snd_ca0106_dev_free(struct snd_device *device) 1056 { 1057 struct snd_ca0106 *chip = device->device_data; 1058 return snd_ca0106_free(chip); 1059 } 1060 1061 static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id, 1062 struct pt_regs *regs) 1063 { 1064 unsigned int status; 1065 1066 struct snd_ca0106 *chip = dev_id; 1067 int i; 1068 int mask; 1069 unsigned int stat76; 1070 struct snd_ca0106_channel *pchannel; 1071 1072 status = inl(chip->port + IPR); 1073 if (! status) 1074 return IRQ_NONE; 1075 1076 stat76 = snd_ca0106_ptr_read(chip, EXTENDED_INT, 0); 1077 //snd_printk("interrupt status = 0x%08x, stat76=0x%08x\n", status, stat76); 1078 //snd_printk("ptr=0x%08x\n",snd_ca0106_ptr_read(chip, PLAYBACK_POINTER, 0)); 1079 mask = 0x11; /* 0x1 for one half, 0x10 for the other half period. */ 1080 for(i = 0; i < 4; i++) { 1081 pchannel = &(chip->playback_channels[i]); 1082 if (stat76 & mask) { 1083 /* FIXME: Select the correct substream for period elapsed */ 1084 if(pchannel->use) { 1085 snd_pcm_period_elapsed(pchannel->epcm->substream); 1086 //printk(KERN_INFO "interrupt [%d] used\n", i); 1087 } 1088 } 1089 //printk(KERN_INFO "channel=%p\n",pchannel); 1090 //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number); 1091 mask <<= 1; 1092 } 1093 mask = 0x110000; /* 0x1 for one half, 0x10 for the other half period. */ 1094 for(i = 0; i < 4; i++) { 1095 pchannel = &(chip->capture_channels[i]); 1096 if (stat76 & mask) { 1097 /* FIXME: Select the correct substream for period elapsed */ 1098 if(pchannel->use) { 1099 snd_pcm_period_elapsed(pchannel->epcm->substream); 1100 //printk(KERN_INFO "interrupt [%d] used\n", i); 1101 } 1102 } 1103 //printk(KERN_INFO "channel=%p\n",pchannel); 1104 //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number); 1105 mask <<= 1; 1106 } 1107 1108 snd_ca0106_ptr_write(chip, EXTENDED_INT, 0, stat76); 1109 1110 if (chip->midi.dev_id && 1111 (status & (chip->midi.ipr_tx|chip->midi.ipr_rx))) { 1112 if (chip->midi.interrupt) 1113 chip->midi.interrupt(&chip->midi, status); 1114 else 1115 chip->midi.interrupt_disable(&chip->midi, chip->midi.tx_enable | chip->midi.rx_enable); 1116 } 1117 1118 // acknowledge the interrupt if necessary 1119 outl(status, chip->port+IPR); 1120 1121 return IRQ_HANDLED; 1122 } 1123 1124 static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device, struct snd_pcm **rpcm) 1125 { 1126 struct snd_pcm *pcm; 1127 struct snd_pcm_substream *substream; 1128 int err; 1129 1130 if (rpcm) 1131 *rpcm = NULL; 1132 if ((err = snd_pcm_new(emu->card, "ca0106", device, 1, 1, &pcm)) < 0) 1133 return err; 1134 1135 pcm->private_data = emu; 1136 1137 switch (device) { 1138 case 0: 1139 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_front_ops); 1140 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_0_ops); 1141 break; 1142 case 1: 1143 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_rear_ops); 1144 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_1_ops); 1145 break; 1146 case 2: 1147 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_center_lfe_ops); 1148 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_2_ops); 1149 break; 1150 case 3: 1151 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_unknown_ops); 1152 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_3_ops); 1153 break; 1154 } 1155 1156 pcm->info_flags = 0; 1157 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX; 1158 strcpy(pcm->name, "CA0106"); 1159 emu->pcm = pcm; 1160 1161 for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; 1162 substream; 1163 substream = substream->next) { 1164 if ((err = snd_pcm_lib_preallocate_pages(substream, 1165 SNDRV_DMA_TYPE_DEV, 1166 snd_dma_pci_data(emu->pci), 1167 64*1024, 64*1024)) < 0) /* FIXME: 32*1024 for sound buffer, between 32and64 for Periods table. */ 1168 return err; 1169 } 1170 1171 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; 1172 substream; 1173 substream = substream->next) { 1174 if ((err = snd_pcm_lib_preallocate_pages(substream, 1175 SNDRV_DMA_TYPE_DEV, 1176 snd_dma_pci_data(emu->pci), 1177 64*1024, 64*1024)) < 0) 1178 return err; 1179 } 1180 1181 if (rpcm) 1182 *rpcm = pcm; 1183 1184 return 0; 1185 } 1186 1187 static unsigned int spi_dac_init[] = { 1188 0x00ff, 1189 0x02ff, 1190 0x0400, 1191 0x0520, 1192 0x0620, /* Set 24 bit. Was 0x0600 */ 1193 0x08ff, 1194 0x0aff, 1195 0x0cff, 1196 0x0eff, 1197 0x10ff, 1198 0x1200, 1199 0x1400, 1200 0x1480, 1201 0x1800, 1202 0x1aff, 1203 0x1cff, 1204 0x1e00, 1205 0x0530, 1206 0x0602, 1207 0x0622, 1208 0x1400, 1209 }; 1210 1211 static unsigned int i2c_adc_init[][2] = { 1212 { 0x17, 0x00 }, /* Reset */ 1213 { 0x07, 0x00 }, /* Timeout */ 1214 { 0x0b, 0x22 }, /* Interface control */ 1215 { 0x0c, 0x22 }, /* Master mode control */ 1216 { 0x0d, 0x08 }, /* Powerdown control */ 1217 { 0x0e, 0xcf }, /* Attenuation Left 0x01 = -103dB, 0xff = 24dB */ 1218 { 0x0f, 0xcf }, /* Attenuation Right 0.5dB steps */ 1219 { 0x10, 0x7b }, /* ALC Control 1 */ 1220 { 0x11, 0x00 }, /* ALC Control 2 */ 1221 { 0x12, 0x32 }, /* ALC Control 3 */ 1222 { 0x13, 0x00 }, /* Noise gate control */ 1223 { 0x14, 0xa6 }, /* Limiter control */ 1224 { 0x15, ADC_MUX_LINEIN }, /* ADC Mixer control */ 1225 }; 1226 1227 static int __devinit snd_ca0106_create(struct snd_card *card, 1228 struct pci_dev *pci, 1229 struct snd_ca0106 **rchip) 1230 { 1231 struct snd_ca0106 *chip; 1232 struct snd_ca0106_details *c; 1233 int err; 1234 int ch; 1235 static struct snd_device_ops ops = { 1236 .dev_free = snd_ca0106_dev_free, 1237 }; 1238 1239 *rchip = NULL; 1240 1241 if ((err = pci_enable_device(pci)) < 0) 1242 return err; 1243 if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 || 1244 pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) { 1245 printk(KERN_ERR "error to set 32bit mask DMA\n"); 1246 pci_disable_device(pci); 1247 return -ENXIO; 1248 } 1249 1250 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 1251 if (chip == NULL) { 1252 pci_disable_device(pci); 1253 return -ENOMEM; 1254 } 1255 1256 chip->card = card; 1257 chip->pci = pci; 1258 chip->irq = -1; 1259 1260 spin_lock_init(&chip->emu_lock); 1261 1262 chip->port = pci_resource_start(pci, 0); 1263 if ((chip->res_port = request_region(chip->port, 0x20, 1264 "snd_ca0106")) == NULL) { 1265 snd_ca0106_free(chip); 1266 printk(KERN_ERR "cannot allocate the port\n"); 1267 return -EBUSY; 1268 } 1269 1270 if (request_irq(pci->irq, snd_ca0106_interrupt, 1271 SA_INTERRUPT|SA_SHIRQ, "snd_ca0106", 1272 (void *)chip)) { 1273 snd_ca0106_free(chip); 1274 printk(KERN_ERR "cannot grab irq\n"); 1275 return -EBUSY; 1276 } 1277 chip->irq = pci->irq; 1278 1279 /* This stores the periods table. */ 1280 if(snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 1024, &chip->buffer) < 0) { 1281 snd_ca0106_free(chip); 1282 return -ENOMEM; 1283 } 1284 1285 pci_set_master(pci); 1286 /* read revision & serial */ 1287 pci_read_config_byte(pci, PCI_REVISION_ID, (char *)&chip->revision); 1288 pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial); 1289 pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model); 1290 #if 1 1291 printk(KERN_INFO "Model %04x Rev %08x Serial %08x\n", chip->model, 1292 chip->revision, chip->serial); 1293 #endif 1294 strcpy(card->driver, "CA0106"); 1295 strcpy(card->shortname, "CA0106"); 1296 1297 for (c = ca0106_chip_details; c->serial; c++) { 1298 if (c->serial == chip->serial) 1299 break; 1300 } 1301 chip->details = c; 1302 sprintf(card->longname, "%s at 0x%lx irq %i", 1303 c->name, chip->port, chip->irq); 1304 1305 outl(0, chip->port + INTE); 1306 1307 /* 1308 * Init to 0x02109204 : 1309 * Clock accuracy = 0 (1000ppm) 1310 * Sample Rate = 2 (48kHz) 1311 * Audio Channel = 1 (Left of 2) 1312 * Source Number = 0 (Unspecified) 1313 * Generation Status = 1 (Original for Cat Code 12) 1314 * Cat Code = 12 (Digital Signal Mixer) 1315 * Mode = 0 (Mode 0) 1316 * Emphasis = 0 (None) 1317 * CP = 1 (Copyright unasserted) 1318 * AN = 0 (Audio data) 1319 * P = 0 (Consumer) 1320 */ 1321 snd_ca0106_ptr_write(chip, SPCS0, 0, 1322 chip->spdif_bits[0] = 1323 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | 1324 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | 1325 SPCS_GENERATIONSTATUS | 0x00001200 | 1326 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT); 1327 /* Only SPCS1 has been tested */ 1328 snd_ca0106_ptr_write(chip, SPCS1, 0, 1329 chip->spdif_bits[1] = 1330 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | 1331 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | 1332 SPCS_GENERATIONSTATUS | 0x00001200 | 1333 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT); 1334 snd_ca0106_ptr_write(chip, SPCS2, 0, 1335 chip->spdif_bits[2] = 1336 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | 1337 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | 1338 SPCS_GENERATIONSTATUS | 0x00001200 | 1339 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT); 1340 snd_ca0106_ptr_write(chip, SPCS3, 0, 1341 chip->spdif_bits[3] = 1342 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | 1343 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | 1344 SPCS_GENERATIONSTATUS | 0x00001200 | 1345 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT); 1346 1347 snd_ca0106_ptr_write(chip, PLAYBACK_MUTE, 0, 0x00fc0000); 1348 snd_ca0106_ptr_write(chip, CAPTURE_MUTE, 0, 0x00fc0000); 1349 1350 /* Write 0x8000 to AC97_REC_GAIN to mute it. */ 1351 outb(AC97_REC_GAIN, chip->port + AC97ADDRESS); 1352 outw(0x8000, chip->port + AC97DATA); 1353 #if 0 1354 snd_ca0106_ptr_write(chip, SPCS0, 0, 0x2108006); 1355 snd_ca0106_ptr_write(chip, 0x42, 0, 0x2108006); 1356 snd_ca0106_ptr_write(chip, 0x43, 0, 0x2108006); 1357 snd_ca0106_ptr_write(chip, 0x44, 0, 0x2108006); 1358 #endif 1359 1360 //snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0xf0f003f); /* OSS drivers set this. */ 1361 /* Analog or Digital output */ 1362 snd_ca0106_ptr_write(chip, SPDIF_SELECT1, 0, 0xf); 1363 snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0x000f0000); /* 0x0b000000 for digital, 0x000b0000 for analog, from win2000 drivers. Use 0x000f0000 for surround71 */ 1364 chip->spdif_enable = 0; /* Set digital SPDIF output off */ 1365 chip->capture_source = 3; /* Set CAPTURE_SOURCE */ 1366 //snd_ca0106_ptr_write(chip, 0x45, 0, 0); /* Analogue out */ 1367 //snd_ca0106_ptr_write(chip, 0x45, 0, 0xf00); /* Digital out */ 1368 1369 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 0, 0x40c81000); /* goes to 0x40c80000 when doing SPDIF IN/OUT */ 1370 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 1, 0xffffffff); /* (Mute) CAPTURE feedback into PLAYBACK volume. Only lower 16 bits matter. */ 1371 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 2, 0x30300000); /* SPDIF IN Volume */ 1372 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 3, 0x00700000); /* SPDIF IN Volume, 0x70 = (vol & 0x3f) | 0x40 */ 1373 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING1, 0, 0x32765410); 1374 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING2, 0, 0x76767676); 1375 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING1, 0, 0x32765410); 1376 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING2, 0, 0x76767676); 1377 for(ch = 0; ch < 4; ch++) { 1378 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME1, ch, 0x30303030); /* Only high 16 bits matter */ 1379 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME2, ch, 0x30303030); 1380 //snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0x40404040); /* Mute */ 1381 //snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0x40404040); /* Mute */ 1382 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0xffffffff); /* Mute */ 1383 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0xffffffff); /* Mute */ 1384 } 1385 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4); /* Select MIC, Line in, TAD in, AUX in */ 1386 chip->capture_source = 3; /* Set CAPTURE_SOURCE */ 1387 1388 if (chip->details->gpio_type == 2) { /* The SB0438 use GPIO differently. */ 1389 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */ 1390 outl(0x0, chip->port+GPIO); 1391 //outl(0x00f0e000, chip->port+GPIO); /* Analog */ 1392 outl(0x005f5301, chip->port+GPIO); /* Analog */ 1393 } else if (chip->details->gpio_type == 1) { /* The SB0410 and SB0413 use GPIO differently. */ 1394 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */ 1395 outl(0x0, chip->port+GPIO); 1396 //outl(0x00f0e000, chip->port+GPIO); /* Analog */ 1397 outl(0x005f5301, chip->port+GPIO); /* Analog */ 1398 } else { 1399 outl(0x0, chip->port+GPIO); 1400 outl(0x005f03a3, chip->port+GPIO); /* Analog */ 1401 //outl(0x005f02a2, chip->port+GPIO); /* SPDIF */ 1402 } 1403 snd_ca0106_intr_enable(chip, 0x105); /* Win2000 uses 0x1e0 */ 1404 1405 //outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, chip->port+HCFG); 1406 //outl(0x00001409, chip->port+HCFG); /* 0x1000 causes AC3 to fails. Maybe it effects 24 bit output. */ 1407 //outl(0x00000009, chip->port+HCFG); 1408 outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG); /* AC97 2.0, Enable outputs. */ 1409 1410 if (chip->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */ 1411 int size, n; 1412 1413 size = ARRAY_SIZE(i2c_adc_init); 1414 //snd_printk("I2C:array size=0x%x\n", size); 1415 for (n=0; n < size; n++) { 1416 snd_ca0106_i2c_write(chip, i2c_adc_init[n][0], i2c_adc_init[n][1]); 1417 } 1418 for (n=0; n < 4; n++) { 1419 chip->i2c_capture_volume[n][0]= 0xcf; 1420 chip->i2c_capture_volume[n][1]= 0xcf; 1421 } 1422 chip->i2c_capture_source=2; /* Line in */ 1423 //snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); /* Enable Line-in capture. MIC in currently untested. */ 1424 } 1425 if (chip->details->spi_dac == 1) { /* The SB0570 use SPI to control DAC. */ 1426 int size, n; 1427 1428 size = ARRAY_SIZE(spi_dac_init); 1429 for (n=0; n < size; n++) 1430 snd_ca0106_spi_write(chip, spi_dac_init[n]); 1431 } 1432 1433 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, 1434 chip, &ops)) < 0) { 1435 snd_ca0106_free(chip); 1436 return err; 1437 } 1438 *rchip = chip; 1439 return 0; 1440 } 1441 1442 1443 static void ca0106_midi_interrupt_enable(struct snd_ca_midi *midi, int intr) 1444 { 1445 snd_ca0106_intr_enable((struct snd_ca0106 *)(midi->dev_id), intr); 1446 } 1447 1448 static void ca0106_midi_interrupt_disable(struct snd_ca_midi *midi, int intr) 1449 { 1450 snd_ca0106_intr_disable((struct snd_ca0106 *)(midi->dev_id), intr); 1451 } 1452 1453 static unsigned char ca0106_midi_read(struct snd_ca_midi *midi, int idx) 1454 { 1455 return (unsigned char)snd_ca0106_ptr_read((struct snd_ca0106 *)(midi->dev_id), 1456 midi->port + idx, 0); 1457 } 1458 1459 static void ca0106_midi_write(struct snd_ca_midi *midi, int data, int idx) 1460 { 1461 snd_ca0106_ptr_write((struct snd_ca0106 *)(midi->dev_id), midi->port + idx, 0, data); 1462 } 1463 1464 static struct snd_card *ca0106_dev_id_card(void *dev_id) 1465 { 1466 return ((struct snd_ca0106 *)dev_id)->card; 1467 } 1468 1469 static int ca0106_dev_id_port(void *dev_id) 1470 { 1471 return ((struct snd_ca0106 *)dev_id)->port; 1472 } 1473 1474 static int __devinit snd_ca0106_midi(struct snd_ca0106 *chip, unsigned int channel) 1475 { 1476 struct snd_ca_midi *midi; 1477 char *name; 1478 int err; 1479 1480 if (channel == CA0106_MIDI_CHAN_B) { 1481 name = "CA0106 MPU-401 (UART) B"; 1482 midi = &chip->midi2; 1483 midi->tx_enable = INTE_MIDI_TX_B; 1484 midi->rx_enable = INTE_MIDI_RX_B; 1485 midi->ipr_tx = IPR_MIDI_TX_B; 1486 midi->ipr_rx = IPR_MIDI_RX_B; 1487 midi->port = MIDI_UART_B_DATA; 1488 } else { 1489 name = "CA0106 MPU-401 (UART)"; 1490 midi = &chip->midi; 1491 midi->tx_enable = INTE_MIDI_TX_A; 1492 midi->rx_enable = INTE_MIDI_TX_B; 1493 midi->ipr_tx = IPR_MIDI_TX_A; 1494 midi->ipr_rx = IPR_MIDI_RX_A; 1495 midi->port = MIDI_UART_A_DATA; 1496 } 1497 1498 midi->reset = CA0106_MPU401_RESET; 1499 midi->enter_uart = CA0106_MPU401_ENTER_UART; 1500 midi->ack = CA0106_MPU401_ACK; 1501 1502 midi->input_avail = CA0106_MIDI_INPUT_AVAIL; 1503 midi->output_ready = CA0106_MIDI_OUTPUT_READY; 1504 1505 midi->channel = channel; 1506 1507 midi->interrupt_enable = ca0106_midi_interrupt_enable; 1508 midi->interrupt_disable = ca0106_midi_interrupt_disable; 1509 1510 midi->read = ca0106_midi_read; 1511 midi->write = ca0106_midi_write; 1512 1513 midi->get_dev_id_card = ca0106_dev_id_card; 1514 midi->get_dev_id_port = ca0106_dev_id_port; 1515 1516 midi->dev_id = chip; 1517 1518 if ((err = ca_midi_init(chip, midi, 0, name)) < 0) 1519 return err; 1520 1521 return 0; 1522 } 1523 1524 1525 static int __devinit snd_ca0106_probe(struct pci_dev *pci, 1526 const struct pci_device_id *pci_id) 1527 { 1528 static int dev; 1529 struct snd_card *card; 1530 struct snd_ca0106 *chip; 1531 int err; 1532 1533 if (dev >= SNDRV_CARDS) 1534 return -ENODEV; 1535 if (!enable[dev]) { 1536 dev++; 1537 return -ENOENT; 1538 } 1539 1540 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 1541 if (card == NULL) 1542 return -ENOMEM; 1543 1544 if ((err = snd_ca0106_create(card, pci, &chip)) < 0) { 1545 snd_card_free(card); 1546 return err; 1547 } 1548 1549 if ((err = snd_ca0106_pcm(chip, 0, NULL)) < 0) { 1550 snd_card_free(card); 1551 return err; 1552 } 1553 if ((err = snd_ca0106_pcm(chip, 1, NULL)) < 0) { 1554 snd_card_free(card); 1555 return err; 1556 } 1557 if ((err = snd_ca0106_pcm(chip, 2, NULL)) < 0) { 1558 snd_card_free(card); 1559 return err; 1560 } 1561 if ((err = snd_ca0106_pcm(chip, 3, NULL)) < 0) { 1562 snd_card_free(card); 1563 return err; 1564 } 1565 if (chip->details->ac97 == 1) { /* The SB0410 and SB0413 do not have an AC97 chip. */ 1566 if ((err = snd_ca0106_ac97(chip)) < 0) { 1567 snd_card_free(card); 1568 return err; 1569 } 1570 } 1571 if ((err = snd_ca0106_mixer(chip)) < 0) { 1572 snd_card_free(card); 1573 return err; 1574 } 1575 1576 snd_printdd("ca0106: probe for MIDI channel A ..."); 1577 if ((err = snd_ca0106_midi(chip,CA0106_MIDI_CHAN_A)) < 0) { 1578 snd_card_free(card); 1579 snd_printdd(" failed, err=0x%x\n",err); 1580 return err; 1581 } 1582 snd_printdd(" done.\n"); 1583 1584 #ifdef CONFIG_PROC_FS 1585 snd_ca0106_proc_init(chip); 1586 #endif 1587 1588 if ((err = snd_card_register(card)) < 0) { 1589 snd_card_free(card); 1590 return err; 1591 } 1592 1593 pci_set_drvdata(pci, card); 1594 dev++; 1595 return 0; 1596 } 1597 1598 static void __devexit snd_ca0106_remove(struct pci_dev *pci) 1599 { 1600 snd_card_free(pci_get_drvdata(pci)); 1601 pci_set_drvdata(pci, NULL); 1602 } 1603 1604 // PCI IDs 1605 static struct pci_device_id snd_ca0106_ids[] __devinitdata = { 1606 { 0x1102, 0x0007, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* Audigy LS or Live 24bit */ 1607 { 0, } 1608 }; 1609 MODULE_DEVICE_TABLE(pci, snd_ca0106_ids); 1610 1611 // pci_driver definition 1612 static struct pci_driver driver = { 1613 .name = "CA0106", 1614 .id_table = snd_ca0106_ids, 1615 .probe = snd_ca0106_probe, 1616 .remove = __devexit_p(snd_ca0106_remove), 1617 }; 1618 1619 // initialization of the module 1620 static int __init alsa_card_ca0106_init(void) 1621 { 1622 return pci_register_driver(&driver); 1623 } 1624 1625 // clean up the module 1626 static void __exit alsa_card_ca0106_exit(void) 1627 { 1628 pci_unregister_driver(&driver); 1629 } 1630 1631 module_init(alsa_card_ca0106_init) 1632 module_exit(alsa_card_ca0106_exit) 1633