sound/pci/ca0106/ca0106_main.c

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