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