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
 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                         IRQF_DISABLED|IRQF_SHARED, "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[] = {
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)