git.oblomov.eu Git - linux-2.6/blob - sound/pci/trident/trident_main.c

   1 /*
   2  *  Maintained by Jaroslav Kysela <perex@perex.cz>
   3  *  Originated by audio@tridentmicro.com
   4  *  Fri Feb 19 15:55:28 MST 1999
   5  *  Routines for control of Trident 4DWave (DX and NX) chip
   6  *
   7  *  BUGS:
   8  *
   9  *  TODO:
  10  *    ---
  11  *
  12  *   This program is free software; you can redistribute it and/or modify
  13  *   it under the terms of the GNU General Public License as published by
  14  *   the Free Software Foundation; either version 2 of the License, or
  15  *   (at your option) any later version.
  16  *
  17  *   This program is distributed in the hope that it will be useful,
  18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *   GNU General Public License for more details.
  21  *
  22  *   You should have received a copy of the GNU General Public License
  23  *   along with this program; if not, write to the Free Software
  24  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  25  *
  26  *
  27  *  SiS7018 S/PDIF support by Thomas Winischhofer <thomas@winischhofer.net>
  28  */
  29
  30 #include <linux/delay.h>
  31 #include <linux/init.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/pci.h>
  34 #include <linux/slab.h>
  35 #include <linux/vmalloc.h>
  36 #include <linux/gameport.h>
  37 #include <linux/dma-mapping.h>
  38
  39 #include <sound/core.h>
  40 #include <sound/info.h>
  41 #include <sound/control.h>
  42 #include <sound/tlv.h>
  43 #include <sound/trident.h>
  44 #include <sound/asoundef.h>
  45
  46 #include <asm/io.h>
  47
  48 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
  49                                        struct snd_trident_voice * voice,
  50                                        struct snd_pcm_substream *substream);
  51 static int snd_trident_pcm_mixer_free(struct snd_trident *trident,
  52                                       struct snd_trident_voice * voice,
  53                                       struct snd_pcm_substream *substream);
  54 static irqreturn_t snd_trident_interrupt(int irq, void *dev_id);
  55 static int snd_trident_sis_reset(struct snd_trident *trident);
  56
  57 static void snd_trident_clear_voices(struct snd_trident * trident,
  58                                      unsigned short v_min, unsigned short v_max);
  59 static int snd_trident_free(struct snd_trident *trident);
  60
  61 /*
  62  *  common I/O routines
  63  */
  64
  65
  66 #if 0
  67 static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)
  68 {
  69         unsigned int val, tmp;
  70
  71         printk(KERN_DEBUG "Trident voice %i:\n", voice);
  72         outb(voice, TRID_REG(trident, T4D_LFO_GC_CIR));
  73         val = inl(TRID_REG(trident, CH_LBA));
  74         printk(KERN_DEBUG "LBA: 0x%x\n", val);
  75         val = inl(TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
  76         printk(KERN_DEBUG "GVSel: %i\n", val >> 31);
  77         printk(KERN_DEBUG "Pan: 0x%x\n", (val >> 24) & 0x7f);
  78         printk(KERN_DEBUG "Vol: 0x%x\n", (val >> 16) & 0xff);
  79         printk(KERN_DEBUG "CTRL: 0x%x\n", (val >> 12) & 0x0f);
  80         printk(KERN_DEBUG "EC: 0x%x\n", val & 0x0fff);
  81         if (trident->device != TRIDENT_DEVICE_ID_NX) {
  82                 val = inl(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS));
  83                 printk(KERN_DEBUG "CSO: 0x%x\n", val >> 16);
  84                 printk("Alpha: 0x%x\n", (val >> 4) & 0x0fff);
  85                 printk(KERN_DEBUG "FMS: 0x%x\n", val & 0x0f);
  86                 val = inl(TRID_REG(trident, CH_DX_ESO_DELTA));
  87                 printk(KERN_DEBUG "ESO: 0x%x\n", val >> 16);
  88                 printk(KERN_DEBUG "Delta: 0x%x\n", val & 0xffff);
  89                 val = inl(TRID_REG(trident, CH_DX_FMC_RVOL_CVOL));
  90         } else {                // TRIDENT_DEVICE_ID_NX
  91                 val = inl(TRID_REG(trident, CH_NX_DELTA_CSO));
  92                 tmp = (val >> 24) & 0xff;
  93                 printk(KERN_DEBUG "CSO: 0x%x\n", val & 0x00ffffff);
  94                 val = inl(TRID_REG(trident, CH_NX_DELTA_ESO));
  95                 tmp |= (val >> 16) & 0xff00;
  96                 printk(KERN_DEBUG "Delta: 0x%x\n", tmp);
  97                 printk(KERN_DEBUG "ESO: 0x%x\n", val & 0x00ffffff);
  98                 val = inl(TRID_REG(trident, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL));
  99                 printk(KERN_DEBUG "Alpha: 0x%x\n", val >> 20);
 100                 printk(KERN_DEBUG "FMS: 0x%x\n", (val >> 16) & 0x0f);
 101         }
 102         printk(KERN_DEBUG "FMC: 0x%x\n", (val >> 14) & 3);
 103         printk(KERN_DEBUG "RVol: 0x%x\n", (val >> 7) & 0x7f);
 104         printk(KERN_DEBUG "CVol: 0x%x\n", val & 0x7f);
 105 }
 106 #endif
 107
 108 /*---------------------------------------------------------------------------
 109    unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
 110
 111    Description: This routine will do all of the reading from the external
 112                 CODEC (AC97).
 113
 114    Parameters:  ac97 - ac97 codec structure
 115                 reg - CODEC register index, from AC97 Hal.
 116
 117    returns:     16 bit value read from the AC97.
 118
 119   ---------------------------------------------------------------------------*/
 120 static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
 121 {
 122         unsigned int data = 0, treg;
 123         unsigned short count = 0xffff;
 124         unsigned long flags;
 125         struct snd_trident *trident = ac97->private_data;
 126
 127         spin_lock_irqsave(&trident->reg_lock, flags);
 128         if (trident->device == TRIDENT_DEVICE_ID_DX) {
 129                 data = (DX_AC97_BUSY_READ | (reg & 0x000000ff));
 130                 outl(data, TRID_REG(trident, DX_ACR1_AC97_R));
 131                 do {
 132                         data = inl(TRID_REG(trident, DX_ACR1_AC97_R));
 133                         if ((data & DX_AC97_BUSY_READ) == 0)
 134                                 break;
 135                 } while (--count);
 136         } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
 137                 data = (NX_AC97_BUSY_READ | (reg & 0x000000ff));
 138                 treg = ac97->num == 0 ? NX_ACR2_AC97_R_PRIMARY : NX_ACR3_AC97_R_SECONDARY;
 139                 outl(data, TRID_REG(trident, treg));
 140                 do {
 141                         data = inl(TRID_REG(trident, treg));
 142                         if ((data & 0x00000C00) == 0)
 143                                 break;
 144                 } while (--count);
 145         } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
 146                 data = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
 147                 if (ac97->num == 1)
 148                         data |= SI_AC97_SECONDARY;
 149                 outl(data, TRID_REG(trident, SI_AC97_READ));
 150                 do {
 151                         data = inl(TRID_REG(trident, SI_AC97_READ));
 152                         if ((data & (SI_AC97_BUSY_READ)) == 0)
 153                                 break;
 154                 } while (--count);
 155         }
 156
 157         if (count == 0 && !trident->ac97_detect) {
 158                 snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
 159                            reg, data);
 160                 data = 0;
 161         }
 162
 163         spin_unlock_irqrestore(&trident->reg_lock, flags);
 164         return ((unsigned short) (data >> 16));
 165 }
 166
 167 /*---------------------------------------------------------------------------
 168    void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
 169    unsigned short wdata)
 170
 171    Description: This routine will do all of the writing to the external
 172                 CODEC (AC97).
 173
 174    Parameters:  ac97 - ac97 codec structure
 175                 reg - CODEC register index, from AC97 Hal.
 176                 data  - Lower 16 bits are the data to write to CODEC.
 177
 178    returns:     TRUE if everything went ok, else FALSE.
 179
 180   ---------------------------------------------------------------------------*/
 181 static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
 182                                     unsigned short wdata)
 183 {
 184         unsigned int address, data;
 185         unsigned short count = 0xffff;
 186         unsigned long flags;
 187         struct snd_trident *trident = ac97->private_data;
 188
 189         data = ((unsigned long) wdata) << 16;
 190
 191         spin_lock_irqsave(&trident->reg_lock, flags);
 192         if (trident->device == TRIDENT_DEVICE_ID_DX) {
 193                 address = DX_ACR0_AC97_W;
 194
 195                 /* read AC-97 write register status */
 196                 do {
 197                         if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0)
 198                                 break;
 199                 } while (--count);
 200
 201                 data |= (DX_AC97_BUSY_WRITE | (reg & 0x000000ff));
 202         } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
 203                 address = NX_ACR1_AC97_W;
 204
 205                 /* read AC-97 write register status */
 206                 do {
 207                         if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0)
 208                                 break;
 209                 } while (--count);
 210
 211                 data |= (NX_AC97_BUSY_WRITE | (ac97->num << 8) | (reg & 0x000000ff));
 212         } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
 213                 address = SI_AC97_WRITE;
 214
 215                 /* read AC-97 write register status */
 216                 do {
 217                         if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0)
 218                                 break;
 219                 } while (--count);
 220
 221                 data |= SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
 222                 if (ac97->num == 1)
 223                         data |= SI_AC97_SECONDARY;
 224         } else {
 225                 address = 0;    /* keep GCC happy */
 226                 count = 0;      /* return */
 227         }
 228
 229         if (count == 0) {
 230                 spin_unlock_irqrestore(&trident->reg_lock, flags);
 231                 return;
 232         }
 233         outl(data, TRID_REG(trident, address));
 234         spin_unlock_irqrestore(&trident->reg_lock, flags);
 235 }
 236
 237 /*---------------------------------------------------------------------------
 238    void snd_trident_enable_eso(struct snd_trident *trident)
 239
 240    Description: This routine will enable end of loop interrupts.
 241                 End of loop interrupts will occur when a running
 242                 channel reaches ESO.
 243                 Also enables middle of loop interrupts.
 244
 245    Parameters:  trident - pointer to target device class for 4DWave.
 246
 247   ---------------------------------------------------------------------------*/
 248
 249 static void snd_trident_enable_eso(struct snd_trident * trident)
 250 {
 251         unsigned int val;
 252
 253         val = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
 254         val |= ENDLP_IE;
 255         val |= MIDLP_IE;
 256         if (trident->device == TRIDENT_DEVICE_ID_SI7018)
 257                 val |= BANK_B_EN;
 258         outl(val, TRID_REG(trident, T4D_LFO_GC_CIR));
 259 }
 260
 261 /*---------------------------------------------------------------------------
 262    void snd_trident_disable_eso(struct snd_trident *trident)
 263
 264    Description: This routine will disable end of loop interrupts.
 265                 End of loop interrupts will occur when a running
 266                 channel reaches ESO.
 267                 Also disables middle of loop interrupts.
 268
 269    Parameters:
 270                 trident - pointer to target device class for 4DWave.
 271
 272    returns:     TRUE if everything went ok, else FALSE.
 273
 274   ---------------------------------------------------------------------------*/
 275
 276 static void snd_trident_disable_eso(struct snd_trident * trident)
 277 {
 278         unsigned int tmp;
 279
 280         tmp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
 281         tmp &= ~ENDLP_IE;
 282         tmp &= ~MIDLP_IE;
 283         outl(tmp, TRID_REG(trident, T4D_LFO_GC_CIR));
 284 }
 285
 286 /*---------------------------------------------------------------------------
 287    void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
 288
 289     Description: Start a voice, any channel 0 thru 63.
 290                  This routine automatically handles the fact that there are
 291                  more than 32 channels available.
 292
 293     Parameters : voice - Voice number 0 thru n.
 294                  trident - pointer to target device class for 4DWave.
 295
 296     Return Value: None.
 297
 298   ---------------------------------------------------------------------------*/
 299
 300 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
 301 {
 302         unsigned int mask = 1 << (voice & 0x1f);
 303         unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A;
 304
 305         outl(mask, TRID_REG(trident, reg));
 306 }
 307
 308 EXPORT_SYMBOL(snd_trident_start_voice);
 309
 310 /*---------------------------------------------------------------------------
 311    void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
 312
 313     Description: Stop a voice, any channel 0 thru 63.
 314                  This routine automatically handles the fact that there are
 315                  more than 32 channels available.
 316
 317     Parameters : voice - Voice number 0 thru n.
 318                  trident - pointer to target device class for 4DWave.
 319
 320     Return Value: None.
 321
 322   ---------------------------------------------------------------------------*/
 323
 324 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
 325 {
 326         unsigned int mask = 1 << (voice & 0x1f);
 327         unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A;
 328
 329         outl(mask, TRID_REG(trident, reg));
 330 }
 331
 332 EXPORT_SYMBOL(snd_trident_stop_voice);
 333
 334 /*---------------------------------------------------------------------------
 335     int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
 336
 337     Description: Allocate hardware channel in Bank B (32-63).
 338
 339     Parameters :  trident - pointer to target device class for 4DWave.
 340
 341     Return Value: hardware channel - 32-63 or -1 when no channel is available
 342
 343   ---------------------------------------------------------------------------*/
 344
 345 static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
 346 {
 347         int idx;
 348
 349         if (trident->ChanPCMcnt >= trident->ChanPCM)
 350                 return -1;
 351         for (idx = 31; idx >= 0; idx--) {
 352                 if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) {
 353                         trident->ChanMap[T4D_BANK_B] |= 1 << idx;
 354                         trident->ChanPCMcnt++;
 355                         return idx + 32;
 356                 }
 357         }
 358         return -1;
 359 }
 360
 361 /*---------------------------------------------------------------------------
 362     void snd_trident_free_pcm_channel(int channel)
 363
 364     Description: Free hardware channel in Bank B (32-63)
 365
 366     Parameters :  trident - pointer to target device class for 4DWave.
 367                   channel - hardware channel number 0-63
 368
 369     Return Value: none
 370
 371   ---------------------------------------------------------------------------*/
 372
 373 static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
 374 {
 375         if (channel < 32 || channel > 63)
 376                 return;
 377         channel &= 0x1f;
 378         if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) {
 379                 trident->ChanMap[T4D_BANK_B] &= ~(1 << channel);
 380                 trident->ChanPCMcnt--;
 381         }
 382 }
 383
 384 /*---------------------------------------------------------------------------
 385     unsigned int snd_trident_allocate_synth_channel(void)
 386
 387     Description: Allocate hardware channel in Bank A (0-31).
 388
 389     Parameters :  trident - pointer to target device class for 4DWave.
 390
 391     Return Value: hardware channel - 0-31 or -1 when no channel is available
 392
 393   ---------------------------------------------------------------------------*/
 394
 395 static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
 396 {
 397         int idx;
 398
 399         for (idx = 31; idx >= 0; idx--) {
 400                 if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) {
 401                         trident->ChanMap[T4D_BANK_A] |= 1 << idx;
 402                         trident->synth.ChanSynthCount++;
 403                         return idx;
 404                 }
 405         }
 406         return -1;
 407 }
 408
 409 /*---------------------------------------------------------------------------
 410     void snd_trident_free_synth_channel( int channel )
 411
 412     Description: Free hardware channel in Bank B (0-31).
 413
 414     Parameters :  trident - pointer to target device class for 4DWave.
 415                   channel - hardware channel number 0-63
 416
 417     Return Value: none
 418
 419   ---------------------------------------------------------------------------*/
 420
 421 static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
 422 {
 423         if (channel < 0 || channel > 31)
 424                 return;
 425         channel &= 0x1f;
 426         if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) {
 427                 trident->ChanMap[T4D_BANK_A] &= ~(1 << channel);
 428                 trident->synth.ChanSynthCount--;
 429         }
 430 }
 431
 432 /*---------------------------------------------------------------------------
 433    snd_trident_write_voice_regs
 434
 435    Description: This routine will complete and write the 5 hardware channel
 436                 registers to hardware.
 437
 438    Parameters:  trident - pointer to target device class for 4DWave.
 439                 voice - synthesizer voice structure
 440                 Each register field.
 441
 442   ---------------------------------------------------------------------------*/
 443
 444 void snd_trident_write_voice_regs(struct snd_trident * trident,
 445                                   struct snd_trident_voice * voice)
 446 {
 447         unsigned int FmcRvolCvol;
 448         unsigned int regs[5];
 449
 450         regs[1] = voice->LBA;
 451         regs[4] = (voice->GVSel << 31) |
 452                   ((voice->Pan & 0x0000007f) << 24) |
 453                   ((voice->CTRL & 0x0000000f) << 12);
 454         FmcRvolCvol = ((voice->FMC & 3) << 14) |
 455                       ((voice->RVol & 0x7f) << 7) |
 456                       (voice->CVol & 0x7f);
 457
 458         switch (trident->device) {
 459         case TRIDENT_DEVICE_ID_SI7018:
 460                 regs[4] |= voice->number > 31 ?
 461                                 (voice->Vol & 0x000003ff) :
 462                                 ((voice->Vol & 0x00003fc) << (16-2)) |
 463                                 (voice->EC & 0x00000fff);
 464                 regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
 465                         (voice->FMS & 0x0000000f);
 466                 regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
 467                 regs[3] = (voice->Attribute << 16) | FmcRvolCvol;
 468                 break;
 469         case TRIDENT_DEVICE_ID_DX:
 470                 regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
 471                            (voice->EC & 0x00000fff);
 472                 regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
 473                         (voice->FMS & 0x0000000f);
 474                 regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
 475                 regs[3] = FmcRvolCvol;
 476                 break;
 477         case TRIDENT_DEVICE_ID_NX:
 478                 regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
 479                            (voice->EC & 0x00000fff);
 480                 regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff);
 481                 regs[2] = ((voice->Delta << 16) & 0xff000000) |
 482                         (voice->ESO & 0x00ffffff);
 483                 regs[3] = (voice->Alpha << 20) |
 484                         ((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol;
 485                 break;
 486         default:
 487                 snd_BUG();
 488                 return;
 489         }
 490
 491         outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
 492         outl(regs[0], TRID_REG(trident, CH_START + 0));
 493         outl(regs[1], TRID_REG(trident, CH_START + 4));
 494         outl(regs[2], TRID_REG(trident, CH_START + 8));
 495         outl(regs[3], TRID_REG(trident, CH_START + 12));
 496         outl(regs[4], TRID_REG(trident, CH_START + 16));
 497
 498 #if 0
 499         printk(KERN_DEBUG "written %i channel:\n", voice->number);
 500         printk(KERN_DEBUG "  regs[0] = 0x%x/0x%x\n",
 501                regs[0], inl(TRID_REG(trident, CH_START + 0)));
 502         printk(KERN_DEBUG "  regs[1] = 0x%x/0x%x\n",
 503                regs[1], inl(TRID_REG(trident, CH_START + 4)));
 504         printk(KERN_DEBUG "  regs[2] = 0x%x/0x%x\n",
 505                regs[2], inl(TRID_REG(trident, CH_START + 8)));
 506         printk(KERN_DEBUG "  regs[3] = 0x%x/0x%x\n",
 507                regs[3], inl(TRID_REG(trident, CH_START + 12)));
 508         printk(KERN_DEBUG "  regs[4] = 0x%x/0x%x\n",
 509                regs[4], inl(TRID_REG(trident, CH_START + 16)));
 510 #endif
 511 }
 512
 513 EXPORT_SYMBOL(snd_trident_write_voice_regs);
 514
 515 /*---------------------------------------------------------------------------
 516    snd_trident_write_cso_reg
 517
 518    Description: This routine will write the new CSO offset
 519                 register to hardware.
 520
 521    Parameters:  trident - pointer to target device class for 4DWave.
 522                 voice - synthesizer voice structure
 523                 CSO - new CSO value
 524
 525   ---------------------------------------------------------------------------*/
 526
 527 static void snd_trident_write_cso_reg(struct snd_trident * trident,
 528                                       struct snd_trident_voice * voice,
 529                                       unsigned int CSO)
 530 {
 531         voice->CSO = CSO;
 532         outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
 533         if (trident->device != TRIDENT_DEVICE_ID_NX) {
 534                 outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2);
 535         } else {
 536                 outl((voice->Delta << 24) |
 537                      (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
 538         }
 539 }
 540
 541 /*---------------------------------------------------------------------------
 542    snd_trident_write_eso_reg
 543
 544    Description: This routine will write the new ESO offset
 545                 register to hardware.
 546
 547    Parameters:  trident - pointer to target device class for 4DWave.
 548                 voice - synthesizer voice structure
 549                 ESO - new ESO value
 550
 551   ---------------------------------------------------------------------------*/
 552
 553 static void snd_trident_write_eso_reg(struct snd_trident * trident,
 554                                       struct snd_trident_voice * voice,
 555                                       unsigned int ESO)
 556 {
 557         voice->ESO = ESO;
 558         outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
 559         if (trident->device != TRIDENT_DEVICE_ID_NX) {
 560                 outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2);
 561         } else {
 562                 outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff),
 563                      TRID_REG(trident, CH_NX_DELTA_ESO));
 564         }
 565 }
 566
 567 /*---------------------------------------------------------------------------
 568    snd_trident_write_vol_reg
 569
 570    Description: This routine will write the new voice volume
 571                 register to hardware.
 572
 573    Parameters:  trident - pointer to target device class for 4DWave.
 574                 voice - synthesizer voice structure
 575                 Vol - new voice volume
 576
 577   ---------------------------------------------------------------------------*/
 578
 579 static void snd_trident_write_vol_reg(struct snd_trident * trident,
 580                                       struct snd_trident_voice * voice,
 581                                       unsigned int Vol)
 582 {
 583         voice->Vol = Vol;
 584         outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
 585         switch (trident->device) {
 586         case TRIDENT_DEVICE_ID_DX:
 587         case TRIDENT_DEVICE_ID_NX:
 588                 outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
 589                 break;
 590         case TRIDENT_DEVICE_ID_SI7018:
 591                 /* printk(KERN_DEBUG "voice->Vol = 0x%x\n", voice->Vol); */
 592                 outw((voice->CTRL << 12) | voice->Vol,
 593                      TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
 594                 break;
 595         }
 596 }
 597
 598 /*---------------------------------------------------------------------------
 599    snd_trident_write_pan_reg
 600
 601    Description: This routine will write the new voice pan
 602                 register to hardware.
 603
 604    Parameters:  trident - pointer to target device class for 4DWave.
 605                 voice - synthesizer voice structure
 606                 Pan - new pan value
 607
 608   ---------------------------------------------------------------------------*/
 609
 610 static void snd_trident_write_pan_reg(struct snd_trident * trident,
 611                                       struct snd_trident_voice * voice,
 612                                       unsigned int Pan)
 613 {
 614         voice->Pan = Pan;
 615         outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
 616         outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f),
 617              TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
 618 }
 619
 620 /*---------------------------------------------------------------------------
 621    snd_trident_write_rvol_reg
 622
 623    Description: This routine will write the new reverb volume
 624                 register to hardware.
 625
 626    Parameters:  trident - pointer to target device class for 4DWave.
 627                 voice - synthesizer voice structure
 628                 RVol - new reverb volume
 629
 630   ---------------------------------------------------------------------------*/
 631
 632 static void snd_trident_write_rvol_reg(struct snd_trident * trident,
 633                                        struct snd_trident_voice * voice,
 634                                        unsigned int RVol)
 635 {
 636         voice->RVol = RVol;
 637         outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
 638         outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
 639              (voice->CVol & 0x007f),
 640              TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
 641                       CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
 642 }
 643
 644 /*---------------------------------------------------------------------------
 645    snd_trident_write_cvol_reg
 646
 647    Description: This routine will write the new chorus volume
 648                 register to hardware.
 649
 650    Parameters:  trident - pointer to target device class for 4DWave.
 651                 voice - synthesizer voice structure
 652                 CVol - new chorus volume
 653
 654   ---------------------------------------------------------------------------*/
 655
 656 static void snd_trident_write_cvol_reg(struct snd_trident * trident,
 657                                        struct snd_trident_voice * voice,
 658                                        unsigned int CVol)
 659 {
 660         voice->CVol = CVol;
 661         outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
 662         outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
 663              (voice->CVol & 0x007f),
 664              TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
 665                       CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
 666 }
 667
 668 /*---------------------------------------------------------------------------
 669    snd_trident_convert_rate
 670
 671    Description: This routine converts rate in HZ to hardware delta value.
 672
 673    Parameters:  trident - pointer to target device class for 4DWave.
 674                 rate - Real or Virtual channel number.
 675
 676    Returns:     Delta value.
 677
 678   ---------------------------------------------------------------------------*/
 679 static unsigned int snd_trident_convert_rate(unsigned int rate)
 680 {
 681         unsigned int delta;
 682
 683         // We special case 44100 and 8000 since rounding with the equation
 684         // does not give us an accurate enough value. For 11025 and 22050
 685         // the equation gives us the best answer. All other frequencies will
 686         // also use the equation. JDW
 687         if (rate == 44100)
 688                 delta = 0xeb3;
 689         else if (rate == 8000)
 690                 delta = 0x2ab;
 691         else if (rate == 48000)
 692                 delta = 0x1000;
 693         else
 694                 delta = (((rate << 12) + 24000) / 48000) & 0x0000ffff;
 695         return delta;
 696 }
 697
 698 /*---------------------------------------------------------------------------
 699    snd_trident_convert_adc_rate
 700
 701    Description: This routine converts rate in HZ to hardware delta value.
 702
 703    Parameters:  trident - pointer to target device class for 4DWave.
 704                 rate - Real or Virtual channel number.
 705
 706    Returns:     Delta value.
 707
 708   ---------------------------------------------------------------------------*/
 709 static unsigned int snd_trident_convert_adc_rate(unsigned int rate)
 710 {
 711         unsigned int delta;
 712
 713         // We special case 44100 and 8000 since rounding with the equation
 714         // does not give us an accurate enough value. For 11025 and 22050
 715         // the equation gives us the best answer. All other frequencies will
 716         // also use the equation. JDW
 717         if (rate == 44100)
 718                 delta = 0x116a;
 719         else if (rate == 8000)
 720                 delta = 0x6000;
 721         else if (rate == 48000)
 722                 delta = 0x1000;
 723         else
 724                 delta = ((48000 << 12) / rate) & 0x0000ffff;
 725         return delta;
 726 }
 727
 728 /*---------------------------------------------------------------------------
 729    snd_trident_spurious_threshold
 730
 731    Description: This routine converts rate in HZ to spurious threshold.
 732
 733    Parameters:  trident - pointer to target device class for 4DWave.
 734                 rate - Real or Virtual channel number.
 735
 736    Returns:     Delta value.
 737
 738   ---------------------------------------------------------------------------*/
 739 static unsigned int snd_trident_spurious_threshold(unsigned int rate,
 740                                                    unsigned int period_size)
 741 {
 742         unsigned int res = (rate * period_size) / 48000;
 743         if (res < 64)
 744                 res = res / 2;
 745         else
 746                 res -= 32;
 747         return res;
 748 }
 749
 750 /*---------------------------------------------------------------------------
 751    snd_trident_control_mode
 752
 753    Description: This routine returns a control mode for a PCM channel.
 754
 755    Parameters:  trident - pointer to target device class for 4DWave.
 756                 substream  - PCM substream
 757
 758    Returns:     Control value.
 759
 760   ---------------------------------------------------------------------------*/
 761 static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream)
 762 {
 763         unsigned int CTRL;
 764         struct snd_pcm_runtime *runtime = substream->runtime;
 765
 766         /* set ctrl mode
 767            CTRL default: 8-bit (unsigned) mono, loop mode enabled
 768          */
 769         CTRL = 0x00000001;
 770         if (snd_pcm_format_width(runtime->format) == 16)
 771                 CTRL |= 0x00000008;     // 16-bit data
 772         if (snd_pcm_format_signed(runtime->format))
 773                 CTRL |= 0x00000002;     // signed data
 774         if (runtime->channels > 1)
 775                 CTRL |= 0x00000004;     // stereo data
 776         return CTRL;
 777 }
 778
 779 /*
 780  *  PCM part
 781  */
 782
 783 /*---------------------------------------------------------------------------
 784    snd_trident_ioctl
 785
 786    Description: Device I/O control handler for playback/capture parameters.
 787
 788    Parameters:   substream  - PCM substream class
 789                 cmd     - what ioctl message to process
 790                 arg     - additional message infoarg
 791
 792    Returns:     Error status
 793
 794   ---------------------------------------------------------------------------*/
 795
 796 static int snd_trident_ioctl(struct snd_pcm_substream *substream,
 797                              unsigned int cmd,
 798                              void *arg)
 799 {
 800         /* FIXME: it seems that with small periods the behaviour of
 801                   trident hardware is unpredictable and interrupt generator
 802                   is broken */
 803         return snd_pcm_lib_ioctl(substream, cmd, arg);
 804 }
 805
 806 /*---------------------------------------------------------------------------
 807    snd_trident_allocate_pcm_mem
 808
 809    Description: Allocate PCM ring buffer for given substream
 810
 811    Parameters:  substream  - PCM substream class
 812                 hw_params  - hardware parameters
 813
 814    Returns:     Error status
 815
 816   ---------------------------------------------------------------------------*/
 817
 818 static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream,
 819                                         struct snd_pcm_hw_params *hw_params)
 820 {
 821         struct snd_trident *trident = snd_pcm_substream_chip(substream);
 822         struct snd_pcm_runtime *runtime = substream->runtime;
 823         struct snd_trident_voice *voice = runtime->private_data;
 824         int err;
 825
 826         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
 827                 return err;
 828         if (trident->tlb.entries) {
 829                 if (err > 0) { /* change */
 830                         if (voice->memblk)
 831                                 snd_trident_free_pages(trident, voice->memblk);
 832                         voice->memblk = snd_trident_alloc_pages(trident, substream);
 833                         if (voice->memblk == NULL)
 834                                 return -ENOMEM;
 835                 }
 836         }
 837         return 0;
 838 }
 839
 840 /*---------------------------------------------------------------------------
 841    snd_trident_allocate_evoice
 842
 843    Description: Allocate extra voice as interrupt generator
 844
 845    Parameters:  substream  - PCM substream class
 846                 hw_params  - hardware parameters
 847
 848    Returns:     Error status
 849
 850   ---------------------------------------------------------------------------*/
 851
 852 static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream,
 853                                        struct snd_pcm_hw_params *hw_params)
 854 {
 855         struct snd_trident *trident = snd_pcm_substream_chip(substream);
 856         struct snd_pcm_runtime *runtime = substream->runtime;
 857         struct snd_trident_voice *voice = runtime->private_data;
 858         struct snd_trident_voice *evoice = voice->extra;
 859
 860         /* voice management */
 861
 862         if (params_buffer_size(hw_params) / 2 != params_period_size(hw_params)) {
 863                 if (evoice == NULL) {
 864                         evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
 865                         if (evoice == NULL)
 866                                 return -ENOMEM;
 867                         voice->extra = evoice;
 868                         evoice->substream = substream;
 869                 }
 870         } else {
 871                 if (evoice != NULL) {
 872                         snd_trident_free_voice(trident, evoice);
 873                         voice->extra = evoice = NULL;
 874                 }
 875         }
 876
 877         return 0;
 878 }
 879
 880 /*---------------------------------------------------------------------------
 881    snd_trident_hw_params
 882
 883    Description: Set the hardware parameters for the playback device.
 884
 885    Parameters:  substream  - PCM substream class
 886                 hw_params  - hardware parameters
 887
 888    Returns:     Error status
 889
 890   ---------------------------------------------------------------------------*/
 891
 892 static int snd_trident_hw_params(struct snd_pcm_substream *substream,
 893                                  struct snd_pcm_hw_params *hw_params)
 894 {
 895         int err;
 896
 897         err = snd_trident_allocate_pcm_mem(substream, hw_params);
 898         if (err >= 0)
 899                 err = snd_trident_allocate_evoice(substream, hw_params);
 900         return err;
 901 }
 902
 903 /*---------------------------------------------------------------------------
 904    snd_trident_playback_hw_free
 905
 906    Description: Release the hardware resources for the playback device.
 907
 908    Parameters:  substream  - PCM substream class
 909
 910    Returns:     Error status
 911
 912   ---------------------------------------------------------------------------*/
 913
 914 static int snd_trident_hw_free(struct snd_pcm_substream *substream)
 915 {
 916         struct snd_trident *trident = snd_pcm_substream_chip(substream);
 917         struct snd_pcm_runtime *runtime = substream->runtime;
 918         struct snd_trident_voice *voice = runtime->private_data;
 919         struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
 920
 921         if (trident->tlb.entries) {
 922                 if (voice && voice->memblk) {
 923                         snd_trident_free_pages(trident, voice->memblk);
 924                         voice->memblk = NULL;
 925                 }
 926         }
 927         snd_pcm_lib_free_pages(substream);
 928         if (evoice != NULL) {
 929                 snd_trident_free_voice(trident, evoice);
 930                 voice->extra = NULL;
 931         }
 932         return 0;
 933 }
 934
 935 /*---------------------------------------------------------------------------
 936    snd_trident_playback_prepare
 937
 938    Description: Prepare playback device for playback.
 939
 940    Parameters:  substream  - PCM substream class
 941
 942    Returns:     Error status
 943
 944   ---------------------------------------------------------------------------*/
 945
 946 static int snd_trident_playback_prepare(struct snd_pcm_substream *substream)
 947 {
 948         struct snd_trident *trident = snd_pcm_substream_chip(substream);
 949         struct snd_pcm_runtime *runtime = substream->runtime;
 950         struct snd_trident_voice *voice = runtime->private_data;
 951         struct snd_trident_voice *evoice = voice->extra;
 952         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
 953
 954         spin_lock_irq(&trident->reg_lock);
 955
 956         /* set delta (rate) value */
 957         voice->Delta = snd_trident_convert_rate(runtime->rate);
 958         voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
 959
 960         /* set Loop Begin Address */
 961         if (voice->memblk)
 962                 voice->LBA = voice->memblk->offset;
 963         else
 964                 voice->LBA = runtime->dma_addr;
 965
 966         voice->CSO = 0;
 967         voice->ESO = runtime->buffer_size - 1;  /* in samples */
 968         voice->CTRL = snd_trident_control_mode(substream);
 969         voice->FMC = 3;
 970         voice->GVSel = 1;
 971         voice->EC = 0;
 972         voice->Alpha = 0;
 973         voice->FMS = 0;
 974         voice->Vol = mix->vol;
 975         voice->RVol = mix->rvol;
 976         voice->CVol = mix->cvol;
 977         voice->Pan = mix->pan;
 978         voice->Attribute = 0;
 979 #if 0
 980         voice->Attribute = (1<<(30-16))|(2<<(26-16))|
 981                            (0<<(24-16))|(0x1f<<(19-16));
 982 #else
 983         voice->Attribute = 0;
 984 #endif
 985
 986         snd_trident_write_voice_regs(trident, voice);
 987
 988         if (evoice != NULL) {
 989                 evoice->Delta = voice->Delta;
 990                 evoice->spurious_threshold = voice->spurious_threshold;
 991                 evoice->LBA = voice->LBA;
 992                 evoice->CSO = 0;
 993                 evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
 994                 evoice->CTRL = voice->CTRL;
 995                 evoice->FMC = 3;
 996                 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
 997                 evoice->EC = 0;
 998                 evoice->Alpha = 0;
 999                 evoice->FMS = 0;
1000                 evoice->Vol = 0x3ff;                    /* mute */
1001                 evoice->RVol = evoice->CVol = 0x7f;     /* mute */
1002                 evoice->Pan = 0x7f;                     /* mute */
1003 #if 0
1004                 evoice->Attribute = (1<<(30-16))|(2<<(26-16))|
1005                                     (0<<(24-16))|(0x1f<<(19-16));
1006 #else
1007                 evoice->Attribute = 0;
1008 #endif
1009                 snd_trident_write_voice_regs(trident, evoice);
1010                 evoice->isync2 = 1;
1011                 evoice->isync_mark = runtime->period_size;
1012                 evoice->ESO = (runtime->period_size * 2) - 1;
1013         }
1014
1015         spin_unlock_irq(&trident->reg_lock);
1016
1017         return 0;
1018 }
1019
1020 /*---------------------------------------------------------------------------
1021    snd_trident_capture_hw_params
1022
1023    Description: Set the hardware parameters for the capture device.
1024
1025    Parameters:  substream  - PCM substream class
1026                 hw_params  - hardware parameters
1027
1028    Returns:     Error status
1029
1030   ---------------------------------------------------------------------------*/
1031
1032 static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream,
1033                                          struct snd_pcm_hw_params *hw_params)
1034 {
1035         return snd_trident_allocate_pcm_mem(substream, hw_params);
1036 }
1037
1038 /*---------------------------------------------------------------------------
1039    snd_trident_capture_prepare
1040
1041    Description: Prepare capture device for playback.
1042
1043    Parameters:  substream  - PCM substream class
1044
1045    Returns:     Error status
1046
1047   ---------------------------------------------------------------------------*/
1048
1049 static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)
1050 {
1051         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1052         struct snd_pcm_runtime *runtime = substream->runtime;
1053         struct snd_trident_voice *voice = runtime->private_data;
1054         unsigned int val, ESO_bytes;
1055
1056         spin_lock_irq(&trident->reg_lock);
1057
1058         // Initilize the channel and set channel Mode
1059         outb(0, TRID_REG(trident, LEGACY_DMAR15));
1060
1061         // Set DMA channel operation mode register
1062         outb(0x54, TRID_REG(trident, LEGACY_DMAR11));
1063
1064         // Set channel buffer Address, DMAR0 expects contiguous PCI memory area
1065         voice->LBA = runtime->dma_addr;
1066         outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
1067         if (voice->memblk)
1068                 voice->LBA = voice->memblk->offset;
1069
1070         // set ESO
1071         ESO_bytes = snd_pcm_lib_buffer_bytes(substream) - 1;
1072         outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6));
1073         outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4));
1074         ESO_bytes++;
1075
1076         // Set channel sample rate, 4.12 format
1077         val = (((unsigned int) 48000L << 12) + (runtime->rate/2)) / runtime->rate;
1078         outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R));
1079
1080         // Set channel interrupt blk length
1081         if (snd_pcm_format_width(runtime->format) == 16) {
1082                 val = (unsigned short) ((ESO_bytes >> 1) - 1);
1083         } else {
1084                 val = (unsigned short) (ESO_bytes - 1);
1085         }
1086
1087         outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL));
1088
1089         // Right now, set format and start to run captureing,
1090         // continuous run loop enable.
1091         trident->bDMAStart = 0x19;      // 0001 1001b
1092
1093         if (snd_pcm_format_width(runtime->format) == 16)
1094                 trident->bDMAStart |= 0x80;
1095         if (snd_pcm_format_signed(runtime->format))
1096                 trident->bDMAStart |= 0x20;
1097         if (runtime->channels > 1)
1098                 trident->bDMAStart |= 0x40;
1099
1100         // Prepare capture intr channel
1101
1102         voice->Delta = snd_trident_convert_rate(runtime->rate);
1103         voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1104         voice->isync = 1;
1105         voice->isync_mark = runtime->period_size;
1106         voice->isync_max = runtime->buffer_size;
1107
1108         // Set voice parameters
1109         voice->CSO = 0;
1110         voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
1111         voice->CTRL = snd_trident_control_mode(substream);
1112         voice->FMC = 3;
1113         voice->RVol = 0x7f;
1114         voice->CVol = 0x7f;
1115         voice->GVSel = 1;
1116         voice->Pan = 0x7f;              /* mute */
1117         voice->Vol = 0x3ff;             /* mute */
1118         voice->EC = 0;
1119         voice->Alpha = 0;
1120         voice->FMS = 0;
1121         voice->Attribute = 0;
1122
1123         snd_trident_write_voice_regs(trident, voice);
1124
1125         spin_unlock_irq(&trident->reg_lock);
1126         return 0;
1127 }
1128
1129 /*---------------------------------------------------------------------------
1130    snd_trident_si7018_capture_hw_params
1131
1132    Description: Set the hardware parameters for the capture device.
1133
1134    Parameters:  substream  - PCM substream class
1135                 hw_params  - hardware parameters
1136
1137    Returns:     Error status
1138
1139   ---------------------------------------------------------------------------*/
1140
1141 static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream,
1142                                                 struct snd_pcm_hw_params *hw_params)
1143 {
1144         int err;
1145
1146         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
1147                 return err;
1148
1149         return snd_trident_allocate_evoice(substream, hw_params);
1150 }
1151
1152 /*---------------------------------------------------------------------------
1153    snd_trident_si7018_capture_hw_free
1154
1155    Description: Release the hardware resources for the capture device.
1156
1157    Parameters:  substream  - PCM substream class
1158
1159    Returns:     Error status
1160
1161   ---------------------------------------------------------------------------*/
1162
1163 static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream)
1164 {
1165         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1166         struct snd_pcm_runtime *runtime = substream->runtime;
1167         struct snd_trident_voice *voice = runtime->private_data;
1168         struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
1169
1170         snd_pcm_lib_free_pages(substream);
1171         if (evoice != NULL) {
1172                 snd_trident_free_voice(trident, evoice);
1173                 voice->extra = NULL;
1174         }
1175         return 0;
1176 }
1177
1178 /*---------------------------------------------------------------------------
1179    snd_trident_si7018_capture_prepare
1180
1181    Description: Prepare capture device for playback.
1182
1183    Parameters:  substream  - PCM substream class
1184
1185    Returns:     Error status
1186
1187   ---------------------------------------------------------------------------*/
1188
1189 static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream)
1190 {
1191         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1192         struct snd_pcm_runtime *runtime = substream->runtime;
1193         struct snd_trident_voice *voice = runtime->private_data;
1194         struct snd_trident_voice *evoice = voice->extra;
1195
1196         spin_lock_irq(&trident->reg_lock);
1197
1198         voice->LBA = runtime->dma_addr;
1199         voice->Delta = snd_trident_convert_adc_rate(runtime->rate);
1200         voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1201
1202         // Set voice parameters
1203         voice->CSO = 0;
1204         voice->ESO = runtime->buffer_size - 1;          /* in samples */
1205         voice->CTRL = snd_trident_control_mode(substream);
1206         voice->FMC = 0;
1207         voice->RVol = 0;
1208         voice->CVol = 0;
1209         voice->GVSel = 1;
1210         voice->Pan = T4D_DEFAULT_PCM_PAN;
1211         voice->Vol = 0;
1212         voice->EC = 0;
1213         voice->Alpha = 0;
1214         voice->FMS = 0;
1215
1216         voice->Attribute = (2 << (30-16)) |
1217                            (2 << (26-16)) |
1218                            (2 << (24-16)) |
1219                            (1 << (23-16));
1220
1221         snd_trident_write_voice_regs(trident, voice);
1222
1223         if (evoice != NULL) {
1224                 evoice->Delta = snd_trident_convert_rate(runtime->rate);
1225                 evoice->spurious_threshold = voice->spurious_threshold;
1226                 evoice->LBA = voice->LBA;
1227                 evoice->CSO = 0;
1228                 evoice->ESO = (runtime->period_size * 2) + 20 - 1; /* in samples, 20 means correction */
1229                 evoice->CTRL = voice->CTRL;
1230                 evoice->FMC = 3;
1231                 evoice->GVSel = 0;
1232                 evoice->EC = 0;
1233                 evoice->Alpha = 0;
1234                 evoice->FMS = 0;
1235                 evoice->Vol = 0x3ff;                    /* mute */
1236                 evoice->RVol = evoice->CVol = 0x7f;     /* mute */
1237                 evoice->Pan = 0x7f;                     /* mute */
1238                 evoice->Attribute = 0;
1239                 snd_trident_write_voice_regs(trident, evoice);
1240                 evoice->isync2 = 1;
1241                 evoice->isync_mark = runtime->period_size;
1242                 evoice->ESO = (runtime->period_size * 2) - 1;
1243         }
1244
1245         spin_unlock_irq(&trident->reg_lock);
1246         return 0;
1247 }
1248
1249 /*---------------------------------------------------------------------------
1250    snd_trident_foldback_prepare
1251
1252    Description: Prepare foldback capture device for playback.
1253
1254    Parameters:  substream  - PCM substream class
1255
1256    Returns:     Error status
1257
1258   ---------------------------------------------------------------------------*/
1259
1260 static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream)
1261 {
1262         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1263         struct snd_pcm_runtime *runtime = substream->runtime;
1264         struct snd_trident_voice *voice = runtime->private_data;
1265         struct snd_trident_voice *evoice = voice->extra;
1266
1267         spin_lock_irq(&trident->reg_lock);
1268
1269         /* Set channel buffer Address */
1270         if (voice->memblk)
1271                 voice->LBA = voice->memblk->offset;
1272         else
1273                 voice->LBA = runtime->dma_addr;
1274
1275         /* set target ESO for channel */
1276         voice->ESO = runtime->buffer_size - 1;  /* in samples */
1277
1278         /* set sample rate */
1279         voice->Delta = 0x1000;
1280         voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
1281
1282         voice->CSO = 0;
1283         voice->CTRL = snd_trident_control_mode(substream);
1284         voice->FMC = 3;
1285         voice->RVol = 0x7f;
1286         voice->CVol = 0x7f;
1287         voice->GVSel = 1;
1288         voice->Pan = 0x7f;      /* mute */
1289         voice->Vol = 0x3ff;     /* mute */
1290         voice->EC = 0;
1291         voice->Alpha = 0;
1292         voice->FMS = 0;
1293         voice->Attribute = 0;
1294
1295         /* set up capture channel */
1296         outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan));
1297
1298         snd_trident_write_voice_regs(trident, voice);
1299
1300         if (evoice != NULL) {
1301                 evoice->Delta = voice->Delta;
1302                 evoice->spurious_threshold = voice->spurious_threshold;
1303                 evoice->LBA = voice->LBA;
1304                 evoice->CSO = 0;
1305                 evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
1306                 evoice->CTRL = voice->CTRL;
1307                 evoice->FMC = 3;
1308                 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1309                 evoice->EC = 0;
1310                 evoice->Alpha = 0;
1311                 evoice->FMS = 0;
1312                 evoice->Vol = 0x3ff;                    /* mute */
1313                 evoice->RVol = evoice->CVol = 0x7f;     /* mute */
1314                 evoice->Pan = 0x7f;                     /* mute */
1315                 evoice->Attribute = 0;
1316                 snd_trident_write_voice_regs(trident, evoice);
1317                 evoice->isync2 = 1;
1318                 evoice->isync_mark = runtime->period_size;
1319                 evoice->ESO = (runtime->period_size * 2) - 1;
1320         }
1321
1322         spin_unlock_irq(&trident->reg_lock);
1323         return 0;
1324 }
1325
1326 /*---------------------------------------------------------------------------
1327    snd_trident_spdif_hw_params
1328
1329    Description: Set the hardware parameters for the spdif device.
1330
1331    Parameters:  substream  - PCM substream class
1332                 hw_params  - hardware parameters
1333
1334    Returns:     Error status
1335
1336   ---------------------------------------------------------------------------*/
1337
1338 static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream,
1339                                        struct snd_pcm_hw_params *hw_params)
1340 {
1341         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1342         unsigned int old_bits = 0, change = 0;
1343         int err;
1344
1345         err = snd_trident_allocate_pcm_mem(substream, hw_params);
1346         if (err < 0)
1347                 return err;
1348
1349         if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1350                 err = snd_trident_allocate_evoice(substream, hw_params);
1351                 if (err < 0)
1352                         return err;
1353         }
1354
1355         /* prepare SPDIF channel */
1356         spin_lock_irq(&trident->reg_lock);
1357         old_bits = trident->spdif_pcm_bits;
1358         if (old_bits & IEC958_AES0_PROFESSIONAL)
1359                 trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS;
1360         else
1361                 trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24);
1362         if (params_rate(hw_params) >= 48000) {
1363                 trident->spdif_pcm_ctrl = 0x3c; // 48000 Hz
1364                 trident->spdif_pcm_bits |=
1365                         trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1366                                 IEC958_AES0_PRO_FS_48000 :
1367                                 (IEC958_AES3_CON_FS_48000 << 24);
1368         }
1369         else if (params_rate(hw_params) >= 44100) {
1370                 trident->spdif_pcm_ctrl = 0x3e; // 44100 Hz
1371                 trident->spdif_pcm_bits |=
1372                         trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1373                                 IEC958_AES0_PRO_FS_44100 :
1374                                 (IEC958_AES3_CON_FS_44100 << 24);
1375         }
1376         else {
1377                 trident->spdif_pcm_ctrl = 0x3d; // 32000 Hz
1378                 trident->spdif_pcm_bits |=
1379                         trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1380                                 IEC958_AES0_PRO_FS_32000 :
1381                                 (IEC958_AES3_CON_FS_32000 << 24);
1382         }
1383         change = old_bits != trident->spdif_pcm_bits;
1384         spin_unlock_irq(&trident->reg_lock);
1385
1386         if (change)
1387                 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id);
1388
1389         return 0;
1390 }
1391
1392 /*---------------------------------------------------------------------------
1393    snd_trident_spdif_prepare
1394
1395    Description: Prepare SPDIF device for playback.
1396
1397    Parameters:  substream  - PCM substream class
1398
1399    Returns:     Error status
1400
1401   ---------------------------------------------------------------------------*/
1402
1403 static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream)
1404 {
1405         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1406         struct snd_pcm_runtime *runtime = substream->runtime;
1407         struct snd_trident_voice *voice = runtime->private_data;
1408         struct snd_trident_voice *evoice = voice->extra;
1409         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
1410         unsigned int RESO, LBAO;
1411         unsigned int temp;
1412
1413         spin_lock_irq(&trident->reg_lock);
1414
1415         if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1416
1417                 /* set delta (rate) value */
1418                 voice->Delta = snd_trident_convert_rate(runtime->rate);
1419                 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1420
1421                 /* set Loop Back Address */
1422                 LBAO = runtime->dma_addr;
1423                 if (voice->memblk)
1424                         voice->LBA = voice->memblk->offset;
1425                 else
1426                         voice->LBA = LBAO;
1427
1428                 voice->isync = 1;
1429                 voice->isync3 = 1;
1430                 voice->isync_mark = runtime->period_size;
1431                 voice->isync_max = runtime->buffer_size;
1432
1433                 /* set target ESO for channel */
1434                 RESO = runtime->buffer_size - 1;
1435                 voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
1436
1437                 /* set ctrl mode */
1438                 voice->CTRL = snd_trident_control_mode(substream);
1439
1440                 voice->FMC = 3;
1441                 voice->RVol = 0x7f;
1442                 voice->CVol = 0x7f;
1443                 voice->GVSel = 1;
1444                 voice->Pan = 0x7f;
1445                 voice->Vol = 0x3ff;
1446                 voice->EC = 0;
1447                 voice->CSO = 0;
1448                 voice->Alpha = 0;
1449                 voice->FMS = 0;
1450                 voice->Attribute = 0;
1451
1452                 /* prepare surrogate IRQ channel */
1453                 snd_trident_write_voice_regs(trident, voice);
1454
1455                 outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO));
1456                 outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2));
1457                 outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA));
1458                 outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO));
1459                 outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2));
1460
1461                 /* set SPDIF setting */
1462                 outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1463                 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1464
1465         } else {        /* SiS */
1466
1467                 /* set delta (rate) value */
1468                 voice->Delta = 0x800;
1469                 voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
1470
1471                 /* set Loop Begin Address */
1472                 if (voice->memblk)
1473                         voice->LBA = voice->memblk->offset;
1474                 else
1475                         voice->LBA = runtime->dma_addr;
1476
1477                 voice->CSO = 0;
1478                 voice->ESO = runtime->buffer_size - 1;  /* in samples */
1479                 voice->CTRL = snd_trident_control_mode(substream);
1480                 voice->FMC = 3;
1481                 voice->GVSel = 1;
1482                 voice->EC = 0;
1483                 voice->Alpha = 0;
1484                 voice->FMS = 0;
1485                 voice->Vol = mix->vol;
1486                 voice->RVol = mix->rvol;
1487                 voice->CVol = mix->cvol;
1488                 voice->Pan = mix->pan;
1489                 voice->Attribute = (1<<(30-16))|(7<<(26-16))|
1490                                    (0<<(24-16))|(0<<(19-16));
1491
1492                 snd_trident_write_voice_regs(trident, voice);
1493
1494                 if (evoice != NULL) {
1495                         evoice->Delta = voice->Delta;
1496                         evoice->spurious_threshold = voice->spurious_threshold;
1497                         evoice->LBA = voice->LBA;
1498                         evoice->CSO = 0;
1499                         evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
1500                         evoice->CTRL = voice->CTRL;
1501                         evoice->FMC = 3;
1502                         evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1503                         evoice->EC = 0;
1504                         evoice->Alpha = 0;
1505                         evoice->FMS = 0;
1506                         evoice->Vol = 0x3ff;                    /* mute */
1507                         evoice->RVol = evoice->CVol = 0x7f;     /* mute */
1508                         evoice->Pan = 0x7f;                     /* mute */
1509                         evoice->Attribute = 0;
1510                         snd_trident_write_voice_regs(trident, evoice);
1511                         evoice->isync2 = 1;
1512                         evoice->isync_mark = runtime->period_size;
1513                         evoice->ESO = (runtime->period_size * 2) - 1;
1514                 }
1515
1516                 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1517                 temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
1518                 temp &= ~(1<<19);
1519                 outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR));
1520                 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1521                 temp |= SPDIF_EN;
1522                 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1523         }
1524
1525         spin_unlock_irq(&trident->reg_lock);
1526
1527         return 0;
1528 }
1529
1530 /*---------------------------------------------------------------------------
1531    snd_trident_trigger
1532
1533    Description: Start/stop devices
1534
1535    Parameters:  substream  - PCM substream class
1536                 cmd     - trigger command (STOP, GO)
1537
1538    Returns:     Error status
1539
1540   ---------------------------------------------------------------------------*/
1541
1542 static int snd_trident_trigger(struct snd_pcm_substream *substream,
1543                                int cmd)
1544
1545 {
1546         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1547         struct snd_pcm_substream *s;
1548         unsigned int what, whati, capture_flag, spdif_flag;
1549         struct snd_trident_voice *voice, *evoice;
1550         unsigned int val, go;
1551
1552         switch (cmd) {
1553         case SNDRV_PCM_TRIGGER_START:
1554         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1555         case SNDRV_PCM_TRIGGER_RESUME:
1556                 go = 1;
1557                 break;
1558         case SNDRV_PCM_TRIGGER_STOP:
1559         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1560         case SNDRV_PCM_TRIGGER_SUSPEND:
1561                 go = 0;
1562                 break;
1563         default:
1564                 return -EINVAL;
1565         }
1566         what = whati = capture_flag = spdif_flag = 0;
1567         spin_lock(&trident->reg_lock);
1568         val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
1569         snd_pcm_group_for_each_entry(s, substream) {
1570                 if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
1571                         voice = s->runtime->private_data;
1572                         evoice = voice->extra;
1573                         what |= 1 << (voice->number & 0x1f);
1574                         if (evoice == NULL) {
1575                                 whati |= 1 << (voice->number & 0x1f);
1576                         } else {
1577                                 what |= 1 << (evoice->number & 0x1f);
1578                                 whati |= 1 << (evoice->number & 0x1f);
1579                                 if (go)
1580                                         evoice->stimer = val;
1581                         }
1582                         if (go) {
1583                                 voice->running = 1;
1584                                 voice->stimer = val;
1585                         } else {
1586                                 voice->running = 0;
1587                         }
1588                         snd_pcm_trigger_done(s, substream);
1589                         if (voice->capture)
1590                                 capture_flag = 1;
1591                         if (voice->spdif)
1592                                 spdif_flag = 1;
1593                 }
1594         }
1595         if (spdif_flag) {
1596                 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1597                         outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1598                         val = trident->spdif_pcm_ctrl;
1599                         if (!go)
1600                                 val &= ~(0x28);
1601                         outb(val, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1602                 } else {
1603                         outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1604                         val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN;
1605                         outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1606                 }
1607         }
1608         if (!go)
1609                 outl(what, TRID_REG(trident, T4D_STOP_B));
1610         val = inl(TRID_REG(trident, T4D_AINTEN_B));
1611         if (go) {
1612                 val |= whati;
1613         } else {
1614                 val &= ~whati;
1615         }
1616         outl(val, TRID_REG(trident, T4D_AINTEN_B));
1617         if (go) {
1618                 outl(what, TRID_REG(trident, T4D_START_B));
1619
1620                 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1621                         outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1622         } else {
1623                 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1624                         outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1625         }
1626         spin_unlock(&trident->reg_lock);
1627         return 0;
1628 }
1629
1630 /*---------------------------------------------------------------------------
1631    snd_trident_playback_pointer
1632
1633    Description: This routine return the playback position
1634
1635    Parameters:  substream  - PCM substream class
1636
1637    Returns:     position of buffer
1638
1639   ---------------------------------------------------------------------------*/
1640
1641 static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream)
1642 {
1643         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1644         struct snd_pcm_runtime *runtime = substream->runtime;
1645         struct snd_trident_voice *voice = runtime->private_data;
1646         unsigned int cso;
1647
1648         if (!voice->running)
1649                 return 0;
1650
1651         spin_lock(&trident->reg_lock);
1652
1653         outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
1654
1655         if (trident->device != TRIDENT_DEVICE_ID_NX) {
1656                 cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2));
1657         } else {                // ID_4DWAVE_NX
1658                 cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff;
1659         }
1660
1661         spin_unlock(&trident->reg_lock);
1662
1663         if (cso >= runtime->buffer_size)
1664                 cso = 0;
1665
1666         return cso;
1667 }
1668
1669 /*---------------------------------------------------------------------------
1670    snd_trident_capture_pointer
1671
1672    Description: This routine return the capture position
1673
1674    Parameters:   pcm1    - PCM device class
1675
1676    Returns:     position of buffer
1677
1678   ---------------------------------------------------------------------------*/
1679
1680 static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream)
1681 {
1682         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1683         struct snd_pcm_runtime *runtime = substream->runtime;
1684         struct snd_trident_voice *voice = runtime->private_data;
1685         unsigned int result;
1686
1687         if (!voice->running)
1688                 return 0;
1689
1690         result = inw(TRID_REG(trident, T4D_SBBL_SBCL));
1691         if (runtime->channels > 1)
1692                 result >>= 1;
1693         if (result > 0)
1694                 result = runtime->buffer_size - result;
1695
1696         return result;
1697 }
1698
1699 /*---------------------------------------------------------------------------
1700    snd_trident_spdif_pointer
1701
1702    Description: This routine return the SPDIF playback position
1703
1704    Parameters:  substream  - PCM substream class
1705
1706    Returns:     position of buffer
1707
1708   ---------------------------------------------------------------------------*/
1709
1710 static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream)
1711 {
1712         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1713         struct snd_pcm_runtime *runtime = substream->runtime;
1714         struct snd_trident_voice *voice = runtime->private_data;
1715         unsigned int result;
1716
1717         if (!voice->running)
1718                 return 0;
1719
1720         result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
1721
1722         return result;
1723 }
1724
1725 /*
1726  *  Playback support device description
1727  */
1728
1729 static struct snd_pcm_hardware snd_trident_playback =
1730 {
1731         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1732                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1733                                  SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1734                                  SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1735         .formats =              (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1736                                  SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1737         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1738         .rate_min =             4000,
1739         .rate_max =             48000,
1740         .channels_min =         1,
1741         .channels_max =         2,
1742         .buffer_bytes_max =     (256*1024),
1743         .period_bytes_min =     64,
1744         .period_bytes_max =     (256*1024),
1745         .periods_min =          1,
1746         .periods_max =          1024,
1747         .fifo_size =            0,
1748 };
1749
1750 /*
1751  *  Capture support device description
1752  */
1753
1754 static struct snd_pcm_hardware snd_trident_capture =
1755 {
1756         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1757                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1758                                  SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1759                                  SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1760         .formats =              (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1761                                  SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1762         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1763         .rate_min =             4000,
1764         .rate_max =             48000,
1765         .channels_min =         1,
1766         .channels_max =         2,
1767         .buffer_bytes_max =     (128*1024),
1768         .period_bytes_min =     64,
1769         .period_bytes_max =     (128*1024),
1770         .periods_min =          1,
1771         .periods_max =          1024,
1772         .fifo_size =            0,
1773 };
1774
1775 /*
1776  *  Foldback capture support device description
1777  */
1778
1779 static struct snd_pcm_hardware snd_trident_foldback =
1780 {
1781         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1782                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1783                                  SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1784                                  SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1785         .formats =              SNDRV_PCM_FMTBIT_S16_LE,
1786         .rates =                SNDRV_PCM_RATE_48000,
1787         .rate_min =             48000,
1788         .rate_max =             48000,
1789         .channels_min =         2,
1790         .channels_max =         2,
1791         .buffer_bytes_max =     (128*1024),
1792         .period_bytes_min =     64,
1793         .period_bytes_max =     (128*1024),
1794         .periods_min =          1,
1795         .periods_max =          1024,
1796         .fifo_size =            0,
1797 };
1798
1799 /*
1800  *  SPDIF playback support device description
1801  */
1802
1803 static struct snd_pcm_hardware snd_trident_spdif =
1804 {
1805         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1806                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1807                                  SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1808                                  SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1809         .formats =              SNDRV_PCM_FMTBIT_S16_LE,
1810         .rates =                (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
1811                                  SNDRV_PCM_RATE_48000),
1812         .rate_min =             32000,
1813         .rate_max =             48000,
1814         .channels_min =         2,
1815         .channels_max =         2,
1816         .buffer_bytes_max =     (128*1024),
1817         .period_bytes_min =     64,
1818         .period_bytes_max =     (128*1024),
1819         .periods_min =          1,
1820         .periods_max =          1024,
1821         .fifo_size =            0,
1822 };
1823
1824 static struct snd_pcm_hardware snd_trident_spdif_7018 =
1825 {
1826         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1827                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1828                                  SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1829                                  SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1830         .formats =              SNDRV_PCM_FMTBIT_S16_LE,
1831         .rates =                SNDRV_PCM_RATE_48000,
1832         .rate_min =             48000,
1833         .rate_max =             48000,
1834         .channels_min =         2,
1835         .channels_max =         2,
1836         .buffer_bytes_max =     (128*1024),
1837         .period_bytes_min =     64,
1838         .period_bytes_max =     (128*1024),
1839         .periods_min =          1,
1840         .periods_max =          1024,
1841         .fifo_size =            0,
1842 };
1843
1844 static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime)
1845 {
1846         struct snd_trident_voice *voice = runtime->private_data;
1847         struct snd_trident *trident;
1848
1849         if (voice) {
1850                 trident = voice->trident;
1851                 snd_trident_free_voice(trident, voice);
1852         }
1853 }
1854
1855 static int snd_trident_playback_open(struct snd_pcm_substream *substream)
1856 {
1857         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1858         struct snd_pcm_runtime *runtime = substream->runtime;
1859         struct snd_trident_voice *voice;
1860
1861         voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1862         if (voice == NULL)
1863                 return -EAGAIN;
1864         snd_trident_pcm_mixer_build(trident, voice, substream);
1865         voice->substream = substream;
1866         runtime->private_data = voice;
1867         runtime->private_free = snd_trident_pcm_free_substream;
1868         runtime->hw = snd_trident_playback;
1869         snd_pcm_set_sync(substream);
1870         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1871         return 0;
1872 }
1873
1874 /*---------------------------------------------------------------------------
1875    snd_trident_playback_close
1876
1877    Description: This routine will close the 4DWave playback device. For now
1878                 we will simply free the dma transfer buffer.
1879
1880    Parameters:  substream  - PCM substream class
1881
1882   ---------------------------------------------------------------------------*/
1883 static int snd_trident_playback_close(struct snd_pcm_substream *substream)
1884 {
1885         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1886         struct snd_pcm_runtime *runtime = substream->runtime;
1887         struct snd_trident_voice *voice = runtime->private_data;
1888
1889         snd_trident_pcm_mixer_free(trident, voice, substream);
1890         return 0;
1891 }
1892
1893 /*---------------------------------------------------------------------------
1894    snd_trident_spdif_open
1895
1896    Description: This routine will open the 4DWave SPDIF device.
1897
1898    Parameters:  substream  - PCM substream class
1899
1900    Returns:     status  - success or failure flag
1901
1902   ---------------------------------------------------------------------------*/
1903
1904 static int snd_trident_spdif_open(struct snd_pcm_substream *substream)
1905 {
1906         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1907         struct snd_trident_voice *voice;
1908         struct snd_pcm_runtime *runtime = substream->runtime;
1909
1910         voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1911         if (voice == NULL)
1912                 return -EAGAIN;
1913         voice->spdif = 1;
1914         voice->substream = substream;
1915         spin_lock_irq(&trident->reg_lock);
1916         trident->spdif_pcm_bits = trident->spdif_bits;
1917         spin_unlock_irq(&trident->reg_lock);
1918
1919         runtime->private_data = voice;
1920         runtime->private_free = snd_trident_pcm_free_substream;
1921         if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1922                 runtime->hw = snd_trident_spdif;
1923         } else {
1924                 runtime->hw = snd_trident_spdif_7018;
1925         }
1926
1927         trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1928         snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1929                        SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1930
1931         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1932         return 0;
1933 }
1934
1935
1936 /*---------------------------------------------------------------------------
1937    snd_trident_spdif_close
1938
1939    Description: This routine will close the 4DWave SPDIF device.
1940
1941    Parameters:  substream  - PCM substream class
1942
1943   ---------------------------------------------------------------------------*/
1944
1945 static int snd_trident_spdif_close(struct snd_pcm_substream *substream)
1946 {
1947         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1948         unsigned int temp;
1949
1950         spin_lock_irq(&trident->reg_lock);
1951         // restore default SPDIF setting
1952         if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1953                 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1954                 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
1955         } else {
1956                 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
1957                 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1958                 if (trident->spdif_ctrl) {
1959                         temp |= SPDIF_EN;
1960                 } else {
1961                         temp &= ~SPDIF_EN;
1962                 }
1963                 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1964         }
1965         spin_unlock_irq(&trident->reg_lock);
1966         trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1967         snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1968                        SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1969         return 0;
1970 }
1971
1972 /*---------------------------------------------------------------------------
1973    snd_trident_capture_open
1974
1975    Description: This routine will open the 4DWave capture device.
1976
1977    Parameters:  substream  - PCM substream class
1978
1979    Returns:     status  - success or failure flag
1980
1981   ---------------------------------------------------------------------------*/
1982
1983 static int snd_trident_capture_open(struct snd_pcm_substream *substream)
1984 {
1985         struct snd_trident *trident = snd_pcm_substream_chip(substream);
1986         struct snd_trident_voice *voice;
1987         struct snd_pcm_runtime *runtime = substream->runtime;
1988
1989         voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1990         if (voice == NULL)
1991                 return -EAGAIN;
1992         voice->capture = 1;
1993         voice->substream = substream;
1994         runtime->private_data = voice;
1995         runtime->private_free = snd_trident_pcm_free_substream;
1996         runtime->hw = snd_trident_capture;
1997         snd_pcm_set_sync(substream);
1998         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1999         return 0;
2000 }
2001
2002 /*---------------------------------------------------------------------------
2003    snd_trident_capture_close
2004
2005    Description: This routine will close the 4DWave capture device. For now
2006                 we will simply free the dma transfer buffer.
2007
2008    Parameters:  substream  - PCM substream class
2009
2010   ---------------------------------------------------------------------------*/
2011 static int snd_trident_capture_close(struct snd_pcm_substream *substream)
2012 {
2013         return 0;
2014 }
2015
2016 /*---------------------------------------------------------------------------
2017    snd_trident_foldback_open
2018
2019    Description: This routine will open the 4DWave foldback capture device.
2020
2021    Parameters:  substream  - PCM substream class
2022
2023    Returns:     status  - success or failure flag
2024
2025   ---------------------------------------------------------------------------*/
2026
2027 static int snd_trident_foldback_open(struct snd_pcm_substream *substream)
2028 {
2029         struct snd_trident *trident = snd_pcm_substream_chip(substream);
2030         struct snd_trident_voice *voice;
2031         struct snd_pcm_runtime *runtime = substream->runtime;
2032
2033         voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
2034         if (voice == NULL)
2035                 return -EAGAIN;
2036         voice->foldback_chan = substream->number;
2037         voice->substream = substream;
2038         runtime->private_data = voice;
2039         runtime->private_free = snd_trident_pcm_free_substream;
2040         runtime->hw = snd_trident_foldback;
2041         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
2042         return 0;
2043 }
2044
2045 /*---------------------------------------------------------------------------
2046    snd_trident_foldback_close
2047
2048    Description: This routine will close the 4DWave foldback capture device.
2049                 For now we will simply free the dma transfer buffer.
2050
2051    Parameters:  substream  - PCM substream class
2052
2053   ---------------------------------------------------------------------------*/
2054 static int snd_trident_foldback_close(struct snd_pcm_substream *substream)
2055 {
2056         struct snd_trident *trident = snd_pcm_substream_chip(substream);
2057         struct snd_trident_voice *voice;
2058         struct snd_pcm_runtime *runtime = substream->runtime;
2059         voice = runtime->private_data;
2060
2061         /* stop capture channel */
2062         spin_lock_irq(&trident->reg_lock);
2063         outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan));
2064         spin_unlock_irq(&trident->reg_lock);
2065         return 0;
2066 }
2067
2068 /*---------------------------------------------------------------------------
2069    PCM operations
2070   ---------------------------------------------------------------------------*/
2071
2072 static struct snd_pcm_ops snd_trident_playback_ops = {
2073         .open =         snd_trident_playback_open,
2074         .close =        snd_trident_playback_close,
2075         .ioctl =        snd_trident_ioctl,
2076         .hw_params =    snd_trident_hw_params,
2077         .hw_free =      snd_trident_hw_free,
2078         .prepare =      snd_trident_playback_prepare,
2079         .trigger =      snd_trident_trigger,
2080         .pointer =      snd_trident_playback_pointer,
2081 };
2082
2083 static struct snd_pcm_ops snd_trident_nx_playback_ops = {
2084         .open =         snd_trident_playback_open,
2085         .close =        snd_trident_playback_close,
2086         .ioctl =        snd_trident_ioctl,
2087         .hw_params =    snd_trident_hw_params,
2088         .hw_free =      snd_trident_hw_free,
2089         .prepare =      snd_trident_playback_prepare,
2090         .trigger =      snd_trident_trigger,
2091         .pointer =      snd_trident_playback_pointer,
2092         .page =         snd_pcm_sgbuf_ops_page,
2093 };
2094
2095 static struct snd_pcm_ops snd_trident_capture_ops = {
2096         .open =         snd_trident_capture_open,
2097         .close =        snd_trident_capture_close,
2098         .ioctl =        snd_trident_ioctl,
2099         .hw_params =    snd_trident_capture_hw_params,
2100         .hw_free =      snd_trident_hw_free,
2101         .prepare =      snd_trident_capture_prepare,
2102         .trigger =      snd_trident_trigger,
2103         .pointer =      snd_trident_capture_pointer,
2104 };
2105
2106 static struct snd_pcm_ops snd_trident_si7018_capture_ops = {
2107         .open =         snd_trident_capture_open,
2108         .close =        snd_trident_capture_close,
2109         .ioctl =        snd_trident_ioctl,
2110         .hw_params =    snd_trident_si7018_capture_hw_params,
2111         .hw_free =      snd_trident_si7018_capture_hw_free,
2112         .prepare =      snd_trident_si7018_capture_prepare,
2113         .trigger =      snd_trident_trigger,
2114         .pointer =      snd_trident_playback_pointer,
2115 };
2116
2117 static struct snd_pcm_ops snd_trident_foldback_ops = {
2118         .open =         snd_trident_foldback_open,
2119         .close =        snd_trident_foldback_close,
2120         .ioctl =        snd_trident_ioctl,
2121         .hw_params =    snd_trident_hw_params,
2122         .hw_free =      snd_trident_hw_free,
2123         .prepare =      snd_trident_foldback_prepare,
2124         .trigger =      snd_trident_trigger,
2125         .pointer =      snd_trident_playback_pointer,
2126 };
2127
2128 static struct snd_pcm_ops snd_trident_nx_foldback_ops = {
2129         .open =         snd_trident_foldback_open,
2130         .close =        snd_trident_foldback_close,
2131         .ioctl =        snd_trident_ioctl,
2132         .hw_params =    snd_trident_hw_params,
2133         .hw_free =      snd_trident_hw_free,
2134         .prepare =      snd_trident_foldback_prepare,
2135         .trigger =      snd_trident_trigger,
2136         .pointer =      snd_trident_playback_pointer,
2137         .page =         snd_pcm_sgbuf_ops_page,
2138 };
2139
2140 static struct snd_pcm_ops snd_trident_spdif_ops = {
2141         .open =         snd_trident_spdif_open,
2142         .close =        snd_trident_spdif_close,
2143         .ioctl =        snd_trident_ioctl,
2144         .hw_params =    snd_trident_spdif_hw_params,
2145         .hw_free =      snd_trident_hw_free,
2146         .prepare =      snd_trident_spdif_prepare,
2147         .trigger =      snd_trident_trigger,
2148         .pointer =      snd_trident_spdif_pointer,
2149 };
2150
2151 static struct snd_pcm_ops snd_trident_spdif_7018_ops = {
2152         .open =         snd_trident_spdif_open,
2153         .close =        snd_trident_spdif_close,
2154         .ioctl =        snd_trident_ioctl,
2155         .hw_params =    snd_trident_spdif_hw_params,
2156         .hw_free =      snd_trident_hw_free,
2157         .prepare =      snd_trident_spdif_prepare,
2158         .trigger =      snd_trident_trigger,
2159         .pointer =      snd_trident_playback_pointer,
2160 };
2161
2162 /*---------------------------------------------------------------------------
2163    snd_trident_pcm
2164
2165    Description: This routine registers the 4DWave device for PCM support.
2166
2167    Parameters:  trident - pointer to target device class for 4DWave.
2168
2169    Returns:     None
2170
2171   ---------------------------------------------------------------------------*/
2172
2173 int __devinit snd_trident_pcm(struct snd_trident * trident,
2174                               int device, struct snd_pcm ** rpcm)
2175 {
2176         struct snd_pcm *pcm;
2177         int err;
2178
2179         if (rpcm)
2180                 *rpcm = NULL;
2181         if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0)
2182                 return err;
2183
2184         pcm->private_data = trident;
2185
2186         if (trident->tlb.entries) {
2187                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops);
2188         } else {
2189                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_playback_ops);
2190         }
2191         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
2192                         trident->device != TRIDENT_DEVICE_ID_SI7018 ?
2193                         &snd_trident_capture_ops :
2194                         &snd_trident_si7018_capture_ops);
2195
2196         pcm->info_flags = 0;
2197         pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
2198         strcpy(pcm->name, "Trident 4DWave");
2199         trident->pcm = pcm;
2200
2201         if (trident->tlb.entries) {
2202                 struct snd_pcm_substream *substream;
2203                 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
2204                         snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
2205                                                       snd_dma_pci_data(trident->pci),
2206                                                       64*1024, 128*1024);
2207                 snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
2208                                               SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
2209                                               64*1024, 128*1024);
2210         } else {
2211                 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
2212                                                       snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2213         }
2214
2215         if (rpcm)
2216                 *rpcm = pcm;
2217         return 0;
2218 }
2219
2220 /*---------------------------------------------------------------------------
2221    snd_trident_foldback_pcm
2222
2223    Description: This routine registers the 4DWave device for foldback PCM support.
2224
2225    Parameters:  trident - pointer to target device class for 4DWave.
2226
2227    Returns:     None
2228
2229   ---------------------------------------------------------------------------*/
2230
2231 int __devinit snd_trident_foldback_pcm(struct snd_trident * trident,
2232                                        int device, struct snd_pcm ** rpcm)
2233 {
2234         struct snd_pcm *foldback;
2235         int err;
2236         int num_chan = 3;
2237         struct snd_pcm_substream *substream;
2238
2239         if (rpcm)
2240                 *rpcm = NULL;
2241         if (trident->device == TRIDENT_DEVICE_ID_NX)
2242                 num_chan = 4;
2243         if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0)
2244                 return err;
2245
2246         foldback->private_data = trident;
2247         if (trident->tlb.entries)
2248                 snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops);
2249         else
2250                 snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_foldback_ops);
2251         foldback->info_flags = 0;
2252         strcpy(foldback->name, "Trident 4DWave");
2253         substream = foldback->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
2254         strcpy(substream->name, "Front Mixer");
2255         substream = substream->next;
2256         strcpy(substream->name, "Reverb Mixer");
2257         substream = substream->next;
2258         strcpy(substream->name, "Chorus Mixer");
2259         if (num_chan == 4) {
2260                 substream = substream->next;
2261                 strcpy(substream->name, "Second AC'97 ADC");
2262         }
2263         trident->foldback = foldback;
2264
2265         if (trident->tlb.entries)
2266                 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV_SG,
2267                                                       snd_dma_pci_data(trident->pci), 0, 128*1024);
2268         else
2269                 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV,
2270                                                       snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2271
2272         if (rpcm)
2273                 *rpcm = foldback;
2274         return 0;
2275 }
2276
2277 /*---------------------------------------------------------------------------
2278    snd_trident_spdif
2279
2280    Description: This routine registers the 4DWave-NX device for SPDIF support.
2281
2282    Parameters:  trident - pointer to target device class for 4DWave-NX.
2283
2284    Returns:     None
2285
2286   ---------------------------------------------------------------------------*/
2287
2288 int __devinit snd_trident_spdif_pcm(struct snd_trident * trident,
2289                                     int device, struct snd_pcm ** rpcm)
2290 {
2291         struct snd_pcm *spdif;
2292         int err;
2293
2294         if (rpcm)
2295                 *rpcm = NULL;
2296         if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0)
2297                 return err;
2298
2299         spdif->private_data = trident;
2300         if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2301                 snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops);
2302         } else {
2303                 snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_7018_ops);
2304         }
2305         spdif->info_flags = 0;
2306         strcpy(spdif->name, "Trident 4DWave IEC958");
2307         trident->spdif = spdif;
2308
2309         snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2310
2311         if (rpcm)
2312                 *rpcm = spdif;
2313         return 0;
2314 }
2315
2316 /*
2317  *  Mixer part
2318  */
2319
2320
2321 /*---------------------------------------------------------------------------
2322     snd_trident_spdif_control
2323
2324     Description: enable/disable S/PDIF out from ac97 mixer
2325   ---------------------------------------------------------------------------*/
2326
2327 #define snd_trident_spdif_control_info  snd_ctl_boolean_mono_info
2328
2329 static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol,
2330                                          struct snd_ctl_elem_value *ucontrol)
2331 {
2332         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2333         unsigned char val;
2334
2335         spin_lock_irq(&trident->reg_lock);
2336         val = trident->spdif_ctrl;
2337         ucontrol->value.integer.value[0] = val == kcontrol->private_value;
2338         spin_unlock_irq(&trident->reg_lock);
2339         return 0;
2340 }
2341
2342 static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol,
2343                                          struct snd_ctl_elem_value *ucontrol)
2344 {
2345         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2346         unsigned char val;
2347         int change;
2348
2349         val = ucontrol->value.integer.value[0] ? (unsigned char) kcontrol->private_value : 0x00;
2350         spin_lock_irq(&trident->reg_lock);
2351         /* S/PDIF C Channel bits 0-31 : 48khz, SCMS disabled */
2352         change = trident->spdif_ctrl != val;
2353         trident->spdif_ctrl = val;
2354         if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2355                 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) {
2356                         outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2357                         outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
2358                 }
2359         } else {
2360                 if (trident->spdif == NULL) {
2361                         unsigned int temp;
2362                         outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2363                         temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN;
2364                         if (val)
2365                                 temp |= SPDIF_EN;
2366                         outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
2367                 }
2368         }
2369         spin_unlock_irq(&trident->reg_lock);
2370         return change;
2371 }
2372
2373 static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata =
2374 {
2375         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
2376         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2377         .info =         snd_trident_spdif_control_info,
2378         .get =          snd_trident_spdif_control_get,
2379         .put =          snd_trident_spdif_control_put,
2380         .private_value = 0x28,
2381 };
2382
2383 /*---------------------------------------------------------------------------
2384     snd_trident_spdif_default
2385
2386     Description: put/get the S/PDIF default settings
2387   ---------------------------------------------------------------------------*/
2388
2389 static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol,
2390                                           struct snd_ctl_elem_info *uinfo)
2391 {
2392         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2393         uinfo->count = 1;
2394         return 0;
2395 }
2396
2397 static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol,
2398                                          struct snd_ctl_elem_value *ucontrol)
2399 {
2400         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2401
2402         spin_lock_irq(&trident->reg_lock);
2403         ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
2404         ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
2405         ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
2406         ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
2407         spin_unlock_irq(&trident->reg_lock);
2408         return 0;
2409 }
2410
2411 static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol,
2412                                          struct snd_ctl_elem_value *ucontrol)
2413 {
2414         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2415         unsigned int val;
2416         int change;
2417
2418         val = (ucontrol->value.iec958.status[0] << 0) |
2419               (ucontrol->value.iec958.status[1] << 8) |
2420               (ucontrol->value.iec958.status[2] << 16) |
2421               (ucontrol->value.iec958.status[3] << 24);
2422         spin_lock_irq(&trident->reg_lock);
2423         change = trident->spdif_bits != val;
2424         trident->spdif_bits = val;
2425         if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2426                 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0)
2427                         outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2428         } else {
2429                 if (trident->spdif == NULL)
2430                         outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2431         }
2432         spin_unlock_irq(&trident->reg_lock);
2433         return change;
2434 }
2435
2436 static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata =
2437 {
2438         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
2439         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2440         .info =         snd_trident_spdif_default_info,
2441         .get =          snd_trident_spdif_default_get,
2442         .put =          snd_trident_spdif_default_put
2443 };
2444
2445 /*---------------------------------------------------------------------------
2446     snd_trident_spdif_mask
2447
2448     Description: put/get the S/PDIF mask
2449   ---------------------------------------------------------------------------*/
2450
2451 static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol,
2452                                        struct snd_ctl_elem_info *uinfo)
2453 {
2454         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2455         uinfo->count = 1;
2456         return 0;
2457 }
2458
2459 static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol,
2460                                       struct snd_ctl_elem_value *ucontrol)
2461 {
2462         ucontrol->value.iec958.status[0] = 0xff;
2463         ucontrol->value.iec958.status[1] = 0xff;
2464         ucontrol->value.iec958.status[2] = 0xff;
2465         ucontrol->value.iec958.status[3] = 0xff;
2466         return 0;
2467 }
2468
2469 static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata =
2470 {
2471         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
2472         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
2473         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
2474         .info =         snd_trident_spdif_mask_info,
2475         .get =          snd_trident_spdif_mask_get,
2476 };
2477
2478 /*---------------------------------------------------------------------------
2479     snd_trident_spdif_stream
2480
2481     Description: put/get the S/PDIF stream settings
2482   ---------------------------------------------------------------------------*/
2483
2484 static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol,
2485                                          struct snd_ctl_elem_info *uinfo)
2486 {
2487         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2488         uinfo->count = 1;
2489         return 0;
2490 }
2491
2492 static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol,
2493                                         struct snd_ctl_elem_value *ucontrol)
2494 {
2495         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2496
2497         spin_lock_irq(&trident->reg_lock);
2498         ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
2499         ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
2500         ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
2501         ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
2502         spin_unlock_irq(&trident->reg_lock);
2503         return 0;
2504 }
2505
2506 static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol,
2507                                         struct snd_ctl_elem_value *ucontrol)
2508 {
2509         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2510         unsigned int val;
2511         int change;
2512
2513         val = (ucontrol->value.iec958.status[0] << 0) |
2514               (ucontrol->value.iec958.status[1] << 8) |
2515               (ucontrol->value.iec958.status[2] << 16) |
2516               (ucontrol->value.iec958.status[3] << 24);
2517         spin_lock_irq(&trident->reg_lock);
2518         change = trident->spdif_pcm_bits != val;
2519         trident->spdif_pcm_bits = val;
2520         if (trident->spdif != NULL) {
2521                 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2522                         outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
2523                 } else {
2524                         outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2525                 }
2526         }
2527         spin_unlock_irq(&trident->reg_lock);
2528         return change;
2529 }
2530
2531 static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata =
2532 {
2533         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2534         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
2535         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
2536         .info =         snd_trident_spdif_stream_info,
2537         .get =          snd_trident_spdif_stream_get,
2538         .put =          snd_trident_spdif_stream_put
2539 };
2540
2541 /*---------------------------------------------------------------------------
2542     snd_trident_ac97_control
2543
2544     Description: enable/disable rear path for ac97
2545   ---------------------------------------------------------------------------*/
2546
2547 #define snd_trident_ac97_control_info   snd_ctl_boolean_mono_info
2548
2549 static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol,
2550                                         struct snd_ctl_elem_value *ucontrol)
2551 {
2552         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2553         unsigned char val;
2554
2555         spin_lock_irq(&trident->reg_lock);
2556         val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2557         ucontrol->value.integer.value[0] = (val & (1 << kcontrol->private_value)) ? 1 : 0;
2558         spin_unlock_irq(&trident->reg_lock);
2559         return 0;
2560 }
2561
2562 static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol,
2563                                         struct snd_ctl_elem_value *ucontrol)
2564 {
2565         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2566         unsigned char val;
2567         int change = 0;
2568
2569         spin_lock_irq(&trident->reg_lock);
2570         val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2571         val &= ~(1 << kcontrol->private_value);
2572         if (ucontrol->value.integer.value[0])
2573                 val |= 1 << kcontrol->private_value;
2574         change = val != trident->ac97_ctrl;
2575         trident->ac97_ctrl = val;
2576         outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2577         spin_unlock_irq(&trident->reg_lock);
2578         return change;
2579 }
2580
2581 static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata =
2582 {
2583         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
2584         .name =         "Rear Path",
2585         .info =         snd_trident_ac97_control_info,
2586         .get =          snd_trident_ac97_control_get,
2587         .put =          snd_trident_ac97_control_put,
2588         .private_value = 4,
2589 };
2590
2591 /*---------------------------------------------------------------------------
2592     snd_trident_vol_control
2593
2594     Description: wave & music volume control
2595   ---------------------------------------------------------------------------*/
2596
2597 static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol,
2598                                         struct snd_ctl_elem_info *uinfo)
2599 {
2600         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2601         uinfo->count = 2;
2602         uinfo->value.integer.min = 0;
2603         uinfo->value.integer.max = 255;
2604         return 0;
2605 }
2606
2607 static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol,
2608                                        struct snd_ctl_elem_value *ucontrol)
2609 {
2610         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2611         unsigned int val;
2612
2613         val = trident->musicvol_wavevol;
2614         ucontrol->value.integer.value[0] = 255 - ((val >> kcontrol->private_value) & 0xff);
2615         ucontrol->value.integer.value[1] = 255 - ((val >> (kcontrol->private_value + 8)) & 0xff);
2616         return 0;
2617 }
2618
2619 static const DECLARE_TLV_DB_SCALE(db_scale_gvol, -6375, 25, 0);
2620
2621 static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol,
2622                                        struct snd_ctl_elem_value *ucontrol)
2623 {
2624         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2625         unsigned int val;
2626         int change = 0;
2627
2628         spin_lock_irq(&trident->reg_lock);
2629         val = trident->musicvol_wavevol;
2630         val &= ~(0xffff << kcontrol->private_value);
2631         val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) |
2632                 ((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value;
2633         change = val != trident->musicvol_wavevol;
2634         outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2635         spin_unlock_irq(&trident->reg_lock);
2636         return change;
2637 }
2638
2639 static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata =
2640 {
2641         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
2642         .name =         "Music Playback Volume",
2643         .info =         snd_trident_vol_control_info,
2644         .get =          snd_trident_vol_control_get,
2645         .put =          snd_trident_vol_control_put,
2646         .private_value = 16,
2647         .tlv = { .p = db_scale_gvol },
2648 };
2649
2650 static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata =
2651 {
2652         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
2653         .name =         "Wave Playback Volume",
2654         .info =         snd_trident_vol_control_info,
2655         .get =          snd_trident_vol_control_get,
2656         .put =          snd_trident_vol_control_put,
2657         .private_value = 0,
2658         .tlv = { .p = db_scale_gvol },
2659 };
2660
2661 /*---------------------------------------------------------------------------
2662     snd_trident_pcm_vol_control
2663
2664     Description: PCM front volume control
2665   ---------------------------------------------------------------------------*/
2666
2667 static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol,
2668                                             struct snd_ctl_elem_info *uinfo)
2669 {
2670         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2671
2672         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2673         uinfo->count = 1;
2674         uinfo->value.integer.min = 0;
2675         uinfo->value.integer.max = 255;
2676         if (trident->device == TRIDENT_DEVICE_ID_SI7018)
2677                 uinfo->value.integer.max = 1023;
2678         return 0;
2679 }
2680
2681 static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol,
2682                                            struct snd_ctl_elem_value *ucontrol)
2683 {
2684         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2685         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2686
2687         if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2688                 ucontrol->value.integer.value[0] = 1023 - mix->vol;
2689         } else {
2690                 ucontrol->value.integer.value[0] = 255 - (mix->vol>>2);
2691         }
2692         return 0;
2693 }
2694
2695 static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol,
2696                                            struct snd_ctl_elem_value *ucontrol)
2697 {
2698         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2699         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2700         unsigned int val;
2701         int change = 0;
2702
2703         if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2704                 val = 1023 - (ucontrol->value.integer.value[0] & 1023);
2705         } else {
2706                 val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2;
2707         }
2708         spin_lock_irq(&trident->reg_lock);
2709         change = val != mix->vol;
2710         mix->vol = val;
2711         if (mix->voice != NULL)
2712                 snd_trident_write_vol_reg(trident, mix->voice, val);
2713         spin_unlock_irq(&trident->reg_lock);
2714         return change;
2715 }
2716
2717 static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata =
2718 {
2719         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
2720         .name =         "PCM Front Playback Volume",
2721         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2722         .count =        32,
2723         .info =         snd_trident_pcm_vol_control_info,
2724         .get =          snd_trident_pcm_vol_control_get,
2725         .put =          snd_trident_pcm_vol_control_put,
2726         /* FIXME: no tlv yet */
2727 };
2728
2729 /*---------------------------------------------------------------------------
2730     snd_trident_pcm_pan_control
2731
2732     Description: PCM front pan control
2733   ---------------------------------------------------------------------------*/
2734
2735 static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol,
2736                                             struct snd_ctl_elem_info *uinfo)
2737 {
2738         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2739         uinfo->count = 1;
2740         uinfo->value.integer.min = 0;
2741         uinfo->value.integer.max = 127;
2742         return 0;
2743 }
2744
2745 static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol,
2746                                            struct snd_ctl_elem_value *ucontrol)
2747 {
2748         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2749         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2750
2751         ucontrol->value.integer.value[0] = mix->pan;
2752         if (ucontrol->value.integer.value[0] & 0x40) {
2753                 ucontrol->value.integer.value[0] = (0x3f - (ucontrol->value.integer.value[0] & 0x3f));
2754         } else {
2755                 ucontrol->value.integer.value[0] |= 0x40;
2756         }
2757         return 0;
2758 }
2759
2760 static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol,
2761                                            struct snd_ctl_elem_value *ucontrol)
2762 {
2763         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2764         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2765         unsigned char val;
2766         int change = 0;
2767
2768         if (ucontrol->value.integer.value[0] & 0x40)
2769                 val = ucontrol->value.integer.value[0] & 0x3f;
2770         else
2771                 val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40;
2772         spin_lock_irq(&trident->reg_lock);
2773         change = val != mix->pan;
2774         mix->pan = val;
2775         if (mix->voice != NULL)
2776                 snd_trident_write_pan_reg(trident, mix->voice, val);
2777         spin_unlock_irq(&trident->reg_lock);
2778         return change;
2779 }
2780
2781 static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata =
2782 {
2783         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
2784         .name =         "PCM Pan Playback Control",
2785         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2786         .count =        32,
2787         .info =         snd_trident_pcm_pan_control_info,
2788         .get =          snd_trident_pcm_pan_control_get,
2789         .put =          snd_trident_pcm_pan_control_put,
2790 };
2791
2792 /*---------------------------------------------------------------------------
2793     snd_trident_pcm_rvol_control
2794
2795     Description: PCM reverb volume control
2796   ---------------------------------------------------------------------------*/
2797
2798 static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol,
2799                                              struct snd_ctl_elem_info *uinfo)
2800 {
2801         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2802         uinfo->count = 1;
2803         uinfo->value.integer.min = 0;
2804         uinfo->value.integer.max = 127;
2805         return 0;
2806 }
2807
2808 static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol,
2809                                             struct snd_ctl_elem_value *ucontrol)
2810 {
2811         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2812         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2813
2814         ucontrol->value.integer.value[0] = 127 - mix->rvol;
2815         return 0;
2816 }
2817
2818 static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol,
2819                                             struct snd_ctl_elem_value *ucontrol)
2820 {
2821         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2822         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2823         unsigned short val;
2824         int change = 0;
2825
2826         val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
2827         spin_lock_irq(&trident->reg_lock);
2828         change = val != mix->rvol;
2829         mix->rvol = val;
2830         if (mix->voice != NULL)
2831                 snd_trident_write_rvol_reg(trident, mix->voice, val);
2832         spin_unlock_irq(&trident->reg_lock);
2833         return change;
2834 }
2835
2836 static const DECLARE_TLV_DB_SCALE(db_scale_crvol, -3175, 25, 1);
2837
2838 static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata =
2839 {
2840         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
2841         .name =         "PCM Reverb Playback Volume",
2842         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2843         .count =        32,
2844         .info =         snd_trident_pcm_rvol_control_info,
2845         .get =          snd_trident_pcm_rvol_control_get,
2846         .put =          snd_trident_pcm_rvol_control_put,
2847         .tlv = { .p = db_scale_crvol },
2848 };
2849
2850 /*---------------------------------------------------------------------------
2851     snd_trident_pcm_cvol_control
2852
2853     Description: PCM chorus volume control
2854   ---------------------------------------------------------------------------*/
2855
2856 static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol,
2857                                              struct snd_ctl_elem_info *uinfo)
2858 {
2859         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2860         uinfo->count = 1;
2861         uinfo->value.integer.min = 0;
2862         uinfo->value.integer.max = 127;
2863         return 0;
2864 }
2865
2866 static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol,
2867                                             struct snd_ctl_elem_value *ucontrol)
2868 {
2869         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2870         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2871
2872         ucontrol->value.integer.value[0] = 127 - mix->cvol;
2873         return 0;
2874 }
2875
2876 static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol,
2877                                             struct snd_ctl_elem_value *ucontrol)
2878 {
2879         struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2880         struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2881         unsigned short val;
2882         int change = 0;
2883
2884         val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
2885         spin_lock_irq(&trident->reg_lock);
2886         change = val != mix->cvol;
2887         mix->cvol = val;
2888         if (mix->voice != NULL)
2889                 snd_trident_write_cvol_reg(trident, mix->voice, val);
2890         spin_unlock_irq(&trident->reg_lock);
2891         return change;
2892 }
2893
2894 static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata =
2895 {
2896         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
2897         .name =         "PCM Chorus Playback Volume",
2898         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2899         .count =        32,
2900         .info =         snd_trident_pcm_cvol_control_info,
2901         .get =          snd_trident_pcm_cvol_control_get,
2902         .put =          snd_trident_pcm_cvol_control_put,
2903         .tlv = { .p = db_scale_crvol },
2904 };
2905
2906 static void snd_trident_notify_pcm_change1(struct snd_card *card,
2907                                            struct snd_kcontrol *kctl,
2908                                            int num, int activate)
2909 {
2910         struct snd_ctl_elem_id id;
2911
2912         if (! kctl)
2913                 return;
2914         if (activate)
2915                 kctl->vd[num].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2916         else
2917                 kctl->vd[num].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2918         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE |
2919                        SNDRV_CTL_EVENT_MASK_INFO,
2920                        snd_ctl_build_ioff(&id, kctl, num));
2921 }
2922
2923 static void snd_trident_notify_pcm_change(struct snd_trident *trident,
2924                                           struct snd_trident_pcm_mixer *tmix,
2925                                           int num, int activate)
2926 {
2927         snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
2928         snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
2929         snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate);
2930         snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
2931 }
2932
2933 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
2934                                        struct snd_trident_voice *voice,
2935                                        struct snd_pcm_substream *substream)
2936 {
2937         struct snd_trident_pcm_mixer *tmix;
2938
2939         if (snd_BUG_ON(!trident || !voice || !substream))
2940                 return -EINVAL;
2941         tmix = &trident->pcm_mixer[substream->number];
2942         tmix->voice = voice;
2943         tmix->vol = T4D_DEFAULT_PCM_VOL;
2944         tmix->pan = T4D_DEFAULT_PCM_PAN;
2945         tmix->rvol = T4D_DEFAULT_PCM_RVOL;
2946         tmix->cvol = T4D_DEFAULT_PCM_CVOL;
2947         snd_trident_notify_pcm_change(trident, tmix, substream->number, 1);
2948         return 0;
2949 }
2950
2951 static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
2952 {
2953         struct snd_trident_pcm_mixer *tmix;
2954
2955         if (snd_BUG_ON(!trident || !substream))
2956                 return -EINVAL;
2957         tmix = &trident->pcm_mixer[substream->number];
2958         tmix->voice = NULL;
2959         snd_trident_notify_pcm_change(trident, tmix, substream->number, 0);
2960         return 0;
2961 }
2962
2963 /*---------------------------------------------------------------------------
2964    snd_trident_mixer
2965
2966    Description: This routine registers the 4DWave device for mixer support.
2967
2968    Parameters:  trident - pointer to target device class for 4DWave.
2969
2970    Returns:     None
2971
2972   ---------------------------------------------------------------------------*/
2973
2974 static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device)
2975 {
2976         struct snd_ac97_template _ac97;
2977         struct snd_card *card = trident->card;
2978         struct snd_kcontrol *kctl;
2979         struct snd_ctl_elem_value *uctl;
2980         int idx, err, retries = 2;
2981         static struct snd_ac97_bus_ops ops = {
2982                 .write = snd_trident_codec_write,
2983                 .read = snd_trident_codec_read,
2984         };
2985
2986         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
2987         if (!uctl)
2988                 return -ENOMEM;
2989
2990         if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0)
2991                 goto __out;
2992
2993         memset(&_ac97, 0, sizeof(_ac97));
2994         _ac97.private_data = trident;
2995         trident->ac97_detect = 1;
2996
2997       __again:
2998         if ((err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97)) < 0) {
2999                 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
3000                         if ((err = snd_trident_sis_reset(trident)) < 0)
3001                                 goto __out;
3002                         if (retries-- > 0)
3003                                 goto __again;
3004                         err = -EIO;
3005                 }
3006                 goto __out;
3007         }
3008
3009         /* secondary codec? */
3010         if (trident->device == TRIDENT_DEVICE_ID_SI7018 &&
3011             (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) {
3012                 _ac97.num = 1;
3013                 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
3014                 if (err < 0)
3015                         snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n");
3016 #if 0   // only for my testing purpose --jk
3017                 {
3018                         struct snd_ac97 *mc97;
3019                         err = snd_ac97_modem(trident->card, &_ac97, &mc97);
3020                         if (err < 0)
3021                                 snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err);
3022                 }
3023 #endif
3024         }
3025
3026         trident->ac97_detect = 0;
3027
3028         if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
3029                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident))) < 0)
3030                         goto __out;
3031                 kctl->put(kctl, uctl);
3032                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident))) < 0)
3033                         goto __out;
3034                 kctl->put(kctl, uctl);
3035                 outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3036         } else {
3037                 outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3038         }
3039
3040         for (idx = 0; idx < 32; idx++) {
3041                 struct snd_trident_pcm_mixer *tmix;
3042
3043                 tmix = &trident->pcm_mixer[idx];
3044                 tmix->voice = NULL;
3045         }
3046         if ((trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident)) == NULL)
3047                 goto __nomem;
3048         if ((err = snd_ctl_add(card, trident->ctl_vol)))
3049                 goto __out;
3050
3051         if ((trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident)) == NULL)
3052                 goto __nomem;
3053         if ((err = snd_ctl_add(card, trident->ctl_pan)))
3054                 goto __out;
3055
3056         if ((trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident)) == NULL)
3057                 goto __nomem;
3058         if ((err = snd_ctl_add(card, trident->ctl_rvol)))
3059                 goto __out;
3060
3061         if ((trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident)) == NULL)
3062                 goto __nomem;
3063         if ((err = snd_ctl_add(card, trident->ctl_cvol)))
3064                 goto __out;
3065
3066         if (trident->device == TRIDENT_DEVICE_ID_NX) {
3067                 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident))) < 0)
3068                         goto __out;
3069                 kctl->put(kctl, uctl);
3070         }
3071         if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
3072
3073                 kctl = snd_ctl_new1(&snd_trident_spdif_control, trident);
3074                 if (kctl == NULL) {
3075                         err = -ENOMEM;
3076                         goto __out;
3077                 }
3078                 if (trident->ac97->ext_id & AC97_EI_SPDIF)
3079                         kctl->id.index++;
3080                 if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF))
3081                         kctl->id.index++;
3082                 idx = kctl->id.index;
3083                 if ((err = snd_ctl_add(card, kctl)) < 0)
3084                         goto __out;
3085                 kctl->put(kctl, uctl);
3086
3087                 kctl = snd_ctl_new1(&snd_trident_spdif_default, trident);
3088                 if (kctl == NULL) {
3089                         err = -ENOMEM;
3090                         goto __out;
3091                 }
3092                 kctl->id.index = idx;
3093                 kctl->id.device = pcm_spdif_device;
3094                 if ((err = snd_ctl_add(card, kctl)) < 0)
3095                         goto __out;
3096
3097                 kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident);
3098                 if (kctl == NULL) {
3099                         err = -ENOMEM;
3100                         goto __out;
3101                 }
3102                 kctl->id.index = idx;
3103                 kctl->id.device = pcm_spdif_device;
3104                 if ((err = snd_ctl_add(card, kctl)) < 0)
3105                         goto __out;
3106
3107                 kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident);
3108                 if (kctl == NULL) {
3109                         err = -ENOMEM;
3110                         goto __out;
3111                 }
3112                 kctl->id.index = idx;
3113                 kctl->id.device = pcm_spdif_device;
3114                 if ((err = snd_ctl_add(card, kctl)) < 0)
3115                         goto __out;
3116                 trident->spdif_pcm_ctl = kctl;
3117         }
3118
3119         err = 0;
3120         goto __out;
3121
3122  __nomem:
3123         err = -ENOMEM;
3124
3125  __out:
3126         kfree(uctl);
3127
3128         return err;
3129 }
3130
3131 /*
3132  * gameport interface
3133  */
3134
3135 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
3136
3137 static unsigned char snd_trident_gameport_read(struct gameport *gameport)
3138 {
3139         struct snd_trident *chip = gameport_get_port_data(gameport);
3140
3141         if (snd_BUG_ON(!chip))
3142                 return 0;
3143         return inb(TRID_REG(chip, GAMEPORT_LEGACY));
3144 }
3145
3146 static void snd_trident_gameport_trigger(struct gameport *gameport)
3147 {
3148         struct snd_trident *chip = gameport_get_port_data(gameport);
3149
3150         if (snd_BUG_ON(!chip))
3151                 return;
3152         outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY));
3153 }
3154
3155 static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
3156 {
3157         struct snd_trident *chip = gameport_get_port_data(gameport);
3158         int i;
3159
3160         if (snd_BUG_ON(!chip))
3161                 return 0;
3162
3163         *buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf;
3164
3165         for (i = 0; i < 4; i++) {
3166                 axes[i] = inw(TRID_REG(chip, GAMEPORT_AXES + i * 2));
3167                 if (axes[i] == 0xffff) axes[i] = -1;
3168         }
3169
3170         return 0;
3171 }
3172
3173 static int snd_trident_gameport_open(struct gameport *gameport, int mode)
3174 {
3175         struct snd_trident *chip = gameport_get_port_data(gameport);
3176
3177         if (snd_BUG_ON(!chip))
3178                 return 0;
3179
3180         switch (mode) {
3181                 case GAMEPORT_MODE_COOKED:
3182                         outb(GAMEPORT_MODE_ADC, TRID_REG(chip, GAMEPORT_GCR));
3183                         msleep(20);
3184                         return 0;
3185                 case GAMEPORT_MODE_RAW:
3186                         outb(0, TRID_REG(chip, GAMEPORT_GCR));
3187                         return 0;
3188                 default:
3189                         return -1;
3190         }
3191 }
3192
3193 int __devinit snd_trident_create_gameport(struct snd_trident *chip)
3194 {
3195         struct gameport *gp;
3196
3197         chip->gameport = gp = gameport_allocate_port();
3198         if (!gp) {
3199                 printk(KERN_ERR "trident: cannot allocate memory for gameport\n");
3200                 return -ENOMEM;
3201         }
3202
3203         gameport_set_name(gp, "Trident 4DWave");
3204         gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
3205         gameport_set_dev_parent(gp, &chip->pci->dev);
3206
3207         gameport_set_port_data(gp, chip);
3208         gp->fuzz = 64;
3209         gp->read = snd_trident_gameport_read;
3210         gp->trigger = snd_trident_gameport_trigger;
3211         gp->cooked_read = snd_trident_gameport_cooked_read;
3212         gp->open = snd_trident_gameport_open;
3213
3214         gameport_register_port(gp);
3215
3216         return 0;
3217 }
3218
3219 static inline void snd_trident_free_gameport(struct snd_trident *chip)
3220 {
3221         if (chip->gameport) {
3222                 gameport_unregister_port(chip->gameport);
3223                 chip->gameport = NULL;
3224         }
3225 }
3226 #else
3227 int __devinit snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; }
3228 static inline void snd_trident_free_gameport(struct snd_trident *chip) { }
3229 #endif /* CONFIG_GAMEPORT */
3230
3231 /*
3232  * delay for 1 tick
3233  */
3234 static inline void do_delay(struct snd_trident *chip)
3235 {
3236         schedule_timeout_uninterruptible(1);
3237 }
3238
3239 /*
3240  *  SiS reset routine
3241  */
3242
3243 static int snd_trident_sis_reset(struct snd_trident *trident)
3244 {
3245         unsigned long end_time;
3246         unsigned int i;
3247         int r;
3248
3249         r = trident->in_suspend ? 0 : 2;        /* count of retries */
3250       __si7018_retry:
3251         pci_write_config_byte(trident->pci, 0x46, 0x04);        /* SOFTWARE RESET */
3252         udelay(100);
3253         pci_write_config_byte(trident->pci, 0x46, 0x00);
3254         udelay(100);
3255         /* disable AC97 GPIO interrupt */
3256         outb(0x00, TRID_REG(trident, SI_AC97_GPIO));
3257         /* initialize serial interface, force cold reset */
3258         i = PCMOUT|SURROUT|CENTEROUT|LFEOUT|SECONDARY_ID|COLD_RESET;
3259         outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3260         udelay(1000);
3261         /* remove cold reset */
3262         i &= ~COLD_RESET;
3263         outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3264         udelay(2000);
3265         /* wait, until the codec is ready */
3266         end_time = (jiffies + (HZ * 3) / 4) + 1;
3267         do {
3268                 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0)
3269                         goto __si7018_ok;
3270                 do_delay(trident);
3271         } while (time_after_eq(end_time, jiffies));
3272         snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
3273         if (r-- > 0) {
3274                 end_time = jiffies + HZ;
3275                 do {
3276                         do_delay(trident);
3277                 } while (time_after_eq(end_time, jiffies));
3278                 goto __si7018_retry;
3279         }
3280       __si7018_ok:
3281         /* wait for the second codec */
3282         do {
3283                 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0)
3284                         break;
3285                 do_delay(trident);
3286         } while (time_after_eq(end_time, jiffies));
3287         /* enable 64 channel mode */
3288         outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR));
3289         return 0;
3290 }
3291
3292 /*
3293  *  /proc interface
3294  */
3295
3296 static void snd_trident_proc_read(struct snd_info_entry *entry,
3297                                   struct snd_info_buffer *buffer)
3298 {
3299         struct snd_trident *trident = entry->private_data;
3300         char *s;
3301
3302         switch (trident->device) {
3303         case TRIDENT_DEVICE_ID_SI7018:
3304                 s = "SiS 7018 Audio";
3305                 break;
3306         case TRIDENT_DEVICE_ID_DX:
3307                 s = "Trident 4DWave PCI DX";
3308                 break;
3309         case TRIDENT_DEVICE_ID_NX:
3310                 s = "Trident 4DWave PCI NX";
3311                 break;
3312         default:
3313                 s = "???";
3314         }
3315         snd_iprintf(buffer, "%s\n\n", s);
3316         snd_iprintf(buffer, "Spurious IRQs    : %d\n", trident->spurious_irq_count);
3317         snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta);
3318         if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018)
3319                 snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", trident->spdif_ctrl == 0x28 ? "on" : "off");
3320         if (trident->device == TRIDENT_DEVICE_ID_NX) {
3321                 snd_iprintf(buffer, "Rear Speakers    : %s\n", trident->ac97_ctrl & 0x00000010 ? "on" : "off");
3322                 if (trident->tlb.entries) {
3323                         snd_iprintf(buffer,"\nVirtual Memory\n");
3324                         snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size);
3325                         snd_iprintf(buffer, "Memory Used    : %d\n", trident->tlb.memhdr->used);
3326                         snd_iprintf(buffer, "Memory Free    : %d\n", snd_util_mem_avail(trident->tlb.memhdr));
3327                 }
3328         }
3329 }
3330
3331 static void __devinit snd_trident_proc_init(struct snd_trident * trident)
3332 {
3333         struct snd_info_entry *entry;
3334         const char *s = "trident";
3335
3336         if (trident->device == TRIDENT_DEVICE_ID_SI7018)
3337                 s = "sis7018";
3338         if (! snd_card_proc_new(trident->card, s, &entry))
3339                 snd_info_set_text_ops(entry, trident, snd_trident_proc_read);
3340 }
3341
3342 static int snd_trident_dev_free(struct snd_device *device)
3343 {
3344         struct snd_trident *trident = device->device_data;
3345         return snd_trident_free(trident);
3346 }
3347
3348 /*---------------------------------------------------------------------------
3349    snd_trident_tlb_alloc
3350
3351    Description: Allocate and set up the TLB page table on 4D NX.
3352                 Each entry has 4 bytes (physical PCI address).
3353
3354    Parameters:  trident - pointer to target device class for 4DWave.
3355
3356    Returns:     0 or negative error code
3357
3358   ---------------------------------------------------------------------------*/
3359
3360 static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident)
3361 {
3362         int i;
3363
3364         /* TLB array must be aligned to 16kB !!! so we allocate
3365            32kB region and correct offset when necessary */
3366
3367         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
3368                                 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
3369                 snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n");
3370                 return -ENOMEM;
3371         }
3372         trident->tlb.entries = (unsigned int*)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
3373         trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4);
3374         /* allocate shadow TLB page table (virtual addresses) */
3375         trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long));
3376         if (trident->tlb.shadow_entries == NULL) {
3377                 snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n");
3378                 return -ENOMEM;
3379         }
3380         /* allocate and setup silent page and initialise TLB entries */
3381         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
3382                                 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
3383                 snd_printk(KERN_ERR "trident: unable to allocate silent page\n");
3384                 return -ENOMEM;
3385         }
3386         memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE);
3387         for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++) {
3388                 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
3389                 trident->tlb.shadow_entries[i] = (unsigned long)trident->tlb.silent_page.area;
3390         }
3391
3392         /* use emu memory block manager code to manage tlb page allocation */
3393         trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES);
3394         if (trident->tlb.memhdr == NULL)
3395                 return -ENOMEM;
3396
3397         trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
3398         return 0;
3399 }
3400
3401 /*
3402  * initialize 4D DX chip
3403  */
3404
3405 static void snd_trident_stop_all_voices(struct snd_trident *trident)
3406 {
3407         outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
3408         outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
3409         outl(0, TRID_REG(trident, T4D_AINTEN_A));
3410         outl(0, TRID_REG(trident, T4D_AINTEN_B));
3411 }
3412
3413 static int snd_trident_4d_dx_init(struct snd_trident *trident)
3414 {
3415         struct pci_dev *pci = trident->pci;
3416         unsigned long end_time;
3417
3418         /* reset the legacy configuration and whole audio/wavetable block */
3419         pci_write_config_dword(pci, 0x40, 0);   /* DDMA */
3420         pci_write_config_byte(pci, 0x44, 0);    /* ports */
3421         pci_write_config_byte(pci, 0x45, 0);    /* Legacy DMA */
3422         pci_write_config_byte(pci, 0x46, 4); /* reset */
3423         udelay(100);
3424         pci_write_config_byte(pci, 0x46, 0); /* release reset */
3425         udelay(100);
3426
3427         /* warm reset of the AC'97 codec */
3428         outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3429         udelay(100);
3430         outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3431         /* DAC on, disable SB IRQ and try to force ADC valid signal */
3432         trident->ac97_ctrl = 0x0000004a;
3433         outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3434         /* wait, until the codec is ready */
3435         end_time = (jiffies + (HZ * 3) / 4) + 1;
3436         do {
3437                 if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0)
3438                         goto __dx_ok;
3439                 do_delay(trident);
3440         } while (time_after_eq(end_time, jiffies));
3441         snd_printk(KERN_ERR "AC'97 codec ready error\n");
3442         return -EIO;
3443
3444  __dx_ok:
3445         snd_trident_stop_all_voices(trident);
3446
3447         return 0;
3448 }
3449
3450 /*
3451  * initialize 4D NX chip
3452  */
3453 static int snd_trident_4d_nx_init(struct snd_trident *trident)
3454 {
3455         struct pci_dev *pci = trident->pci;
3456         unsigned long end_time;
3457
3458         /* reset the legacy configuration and whole audio/wavetable block */
3459         pci_write_config_dword(pci, 0x40, 0);   /* DDMA */
3460         pci_write_config_byte(pci, 0x44, 0);    /* ports */
3461         pci_write_config_byte(pci, 0x45, 0);    /* Legacy DMA */
3462
3463         pci_write_config_byte(pci, 0x46, 1); /* reset */
3464         udelay(100);
3465         pci_write_config_byte(pci, 0x46, 0); /* release reset */
3466         udelay(100);
3467
3468         /* warm reset of the AC'97 codec */
3469         outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3470         udelay(100);
3471         outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3472         /* wait, until the codec is ready */
3473         end_time = (jiffies + (HZ * 3) / 4) + 1;
3474         do {
3475                 if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0)
3476                         goto __nx_ok;
3477                 do_delay(trident);
3478         } while (time_after_eq(end_time, jiffies));
3479         snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
3480         return -EIO;
3481
3482  __nx_ok:
3483         /* DAC on */
3484         trident->ac97_ctrl = 0x00000002;
3485         outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3486         /* disable SB IRQ */
3487         outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT));
3488
3489         snd_trident_stop_all_voices(trident);
3490
3491         if (trident->tlb.entries != NULL) {
3492                 unsigned int i;
3493                 /* enable virtual addressing via TLB */
3494                 i = trident->tlb.entries_dmaaddr;
3495                 i |= 0x00000001;
3496                 outl(i, TRID_REG(trident, NX_TLBC));
3497         } else {
3498                 outl(0, TRID_REG(trident, NX_TLBC));
3499         }
3500         /* initialize S/PDIF */
3501         outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
3502         outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3503
3504         return 0;
3505 }
3506
3507 /*
3508  * initialize sis7018 chip
3509  */
3510 static int snd_trident_sis_init(struct snd_trident *trident)
3511 {
3512         int err;
3513
3514         if ((err = snd_trident_sis_reset(trident)) < 0)
3515                 return err;
3516
3517         snd_trident_stop_all_voices(trident);
3518
3519         /* initialize S/PDIF */
3520         outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
3521
3522         return 0;
3523 }
3524
3525 /*---------------------------------------------------------------------------
3526    snd_trident_create
3527
3528    Description: This routine will create the device specific class for
3529                 the 4DWave card. It will also perform basic initialization.
3530
3531    Parameters:  card  - which card to create
3532                 pci   - interface to PCI bus resource info
3533                 dma1ptr - playback dma buffer
3534                 dma2ptr - capture dma buffer
3535                 irqptr  -  interrupt resource info
3536
3537    Returns:     4DWave device class private data
3538
3539   ---------------------------------------------------------------------------*/
3540
3541 int __devinit snd_trident_create(struct snd_card *card,
3542                        struct pci_dev *pci,
3543                        int pcm_streams,
3544                        int pcm_spdif_device,
3545                        int max_wavetable_size,
3546                        struct snd_trident ** rtrident)
3547 {
3548         struct snd_trident *trident;
3549         int i, err;
3550         struct snd_trident_voice *voice;
3551         struct snd_trident_pcm_mixer *tmix;
3552         static struct snd_device_ops ops = {
3553                 .dev_free =     snd_trident_dev_free,
3554         };
3555
3556         *rtrident = NULL;
3557
3558         /* enable PCI device */
3559         if ((err = pci_enable_device(pci)) < 0)
3560                 return err;
3561         /* check, if we can restrict PCI DMA transfers to 30 bits */
3562         if (pci_set_dma_mask(pci, DMA_BIT_MASK(30)) < 0 ||
3563             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(30)) < 0) {
3564                 snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n");
3565                 pci_disable_device(pci);
3566                 return -ENXIO;
3567         }
3568
3569         trident = kzalloc(sizeof(*trident), GFP_KERNEL);
3570         if (trident == NULL) {
3571                 pci_disable_device(pci);
3572                 return -ENOMEM;
3573         }
3574         trident->device = (pci->vendor << 16) | pci->device;
3575         trident->card = card;
3576         trident->pci = pci;
3577         spin_lock_init(&trident->reg_lock);
3578         spin_lock_init(&trident->event_lock);
3579         spin_lock_init(&trident->voice_alloc);
3580         if (pcm_streams < 1)
3581                 pcm_streams = 1;
3582         if (pcm_streams > 32)
3583                 pcm_streams = 32;
3584         trident->ChanPCM = pcm_streams;
3585         if (max_wavetable_size < 0 )
3586                 max_wavetable_size = 0;
3587         trident->synth.max_size = max_wavetable_size * 1024;
3588         trident->irq = -1;
3589
3590         trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
3591         pci_set_master(pci);
3592
3593         if ((err = pci_request_regions(pci, "Trident Audio")) < 0) {
3594                 kfree(trident);
3595                 pci_disable_device(pci);
3596                 return err;
3597         }
3598         trident->port = pci_resource_start(pci, 0);
3599
3600         if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
3601                         "Trident Audio", trident)) {
3602                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
3603                 snd_trident_free(trident);
3604                 return -EBUSY;
3605         }
3606         trident->irq = pci->irq;
3607
3608         /* allocate 16k-aligned TLB for NX cards */
3609         trident->tlb.entries = NULL;
3610         trident->tlb.buffer.area = NULL;
3611         if (trident->device == TRIDENT_DEVICE_ID_NX) {
3612                 if ((err = snd_trident_tlb_alloc(trident)) < 0) {
3613                         snd_trident_free(trident);
3614                         return err;
3615                 }
3616         }
3617
3618         trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF;
3619
3620         /* initialize chip */
3621         switch (trident->device) {
3622         case TRIDENT_DEVICE_ID_DX:
3623                 err = snd_trident_4d_dx_init(trident);
3624                 break;
3625         case TRIDENT_DEVICE_ID_NX:
3626                 err = snd_trident_4d_nx_init(trident);
3627                 break;
3628         case TRIDENT_DEVICE_ID_SI7018:
3629                 err = snd_trident_sis_init(trident);
3630                 break;
3631         default:
3632                 snd_BUG();
3633                 break;
3634         }
3635         if (err < 0) {
3636                 snd_trident_free(trident);
3637                 return err;
3638         }
3639
3640         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) {
3641                 snd_trident_free(trident);
3642                 return err;
3643         }
3644
3645         if ((err = snd_trident_mixer(trident, pcm_spdif_device)) < 0)
3646                 return err;
3647
3648         /* initialise synth voices */
3649         for (i = 0; i < 64; i++) {
3650                 voice = &trident->synth.voices[i];
3651                 voice->number = i;
3652                 voice->trident = trident;
3653         }
3654         /* initialize pcm mixer entries */
3655         for (i = 0; i < 32; i++) {
3656                 tmix = &trident->pcm_mixer[i];
3657                 tmix->vol = T4D_DEFAULT_PCM_VOL;
3658                 tmix->pan = T4D_DEFAULT_PCM_PAN;
3659                 tmix->rvol = T4D_DEFAULT_PCM_RVOL;
3660                 tmix->cvol = T4D_DEFAULT_PCM_CVOL;
3661         }
3662
3663         snd_trident_enable_eso(trident);
3664
3665         snd_trident_proc_init(trident);
3666         snd_card_set_dev(card, &pci->dev);
3667         *rtrident = trident;
3668         return 0;
3669 }
3670
3671 /*---------------------------------------------------------------------------
3672    snd_trident_free
3673
3674    Description: This routine will free the device specific class for
3675                 the 4DWave card.
3676
3677    Parameters:  trident  - device specific private data for 4DWave card
3678
3679    Returns:     None.
3680
3681   ---------------------------------------------------------------------------*/
3682
3683 static int snd_trident_free(struct snd_trident *trident)
3684 {
3685         snd_trident_free_gameport(trident);
3686         snd_trident_disable_eso(trident);
3687         // Disable S/PDIF out
3688         if (trident->device == TRIDENT_DEVICE_ID_NX)
3689                 outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3690         else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
3691                 outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3692         }
3693         if (trident->irq >= 0)
3694                 free_irq(trident->irq, trident);
3695         if (trident->tlb.buffer.area) {
3696                 outl(0, TRID_REG(trident, NX_TLBC));
3697                 if (trident->tlb.memhdr)
3698                         snd_util_memhdr_free(trident->tlb.memhdr);
3699                 if (trident->tlb.silent_page.area)
3700                         snd_dma_free_pages(&trident->tlb.silent_page);
3701                 vfree(trident->tlb.shadow_entries);
3702                 snd_dma_free_pages(&trident->tlb.buffer);
3703         }
3704         pci_release_regions(trident->pci);
3705         pci_disable_device(trident->pci);
3706         kfree(trident);
3707         return 0;
3708 }
3709
3710 /*---------------------------------------------------------------------------
3711    snd_trident_interrupt
3712
3713    Description: ISR for Trident 4DWave device
3714
3715    Parameters:  trident  - device specific private data for 4DWave card
3716
3717    Problems:    It seems that Trident chips generates interrupts more than
3718                 one time in special cases. The spurious interrupts are
3719                 detected via sample timer (T4D_STIMER) and computing
3720                 corresponding delta value. The limits are detected with
3721                 the method try & fail so it is possible that it won't
3722                 work on all computers. [jaroslav]
3723
3724    Returns:     None.
3725
3726   ---------------------------------------------------------------------------*/
3727
3728 static irqreturn_t snd_trident_interrupt(int irq, void *dev_id)
3729 {
3730         struct snd_trident *trident = dev_id;
3731         unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
3732         int delta;
3733         struct snd_trident_voice *voice;
3734
3735         audio_int = inl(TRID_REG(trident, T4D_MISCINT));
3736         if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
3737                 return IRQ_NONE;
3738         if (audio_int & ADDRESS_IRQ) {
3739                 // get interrupt status for all channels
3740                 spin_lock(&trident->reg_lock);
3741                 stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
3742                 chn_int = inl(TRID_REG(trident, T4D_AINT_A));
3743                 if (chn_int == 0)
3744                         goto __skip1;
3745                 outl(chn_int, TRID_REG(trident, T4D_AINT_A));   /* ack */
3746               __skip1:
3747                 chn_int = inl(TRID_REG(trident, T4D_AINT_B));
3748                 if (chn_int == 0)
3749                         goto __skip2;
3750                 for (channel = 63; channel >= 32; channel--) {
3751                         mask = 1 << (channel&0x1f);
3752                         if ((chn_int & mask) == 0)
3753                                 continue;
3754                         voice = &trident->synth.voices[channel];
3755                         if (!voice->pcm || voice->substream == NULL) {
3756                                 outl(mask, TRID_REG(trident, T4D_STOP_B));
3757                                 continue;
3758                         }
3759                         delta = (int)stimer - (int)voice->stimer;
3760                         if (delta < 0)
3761                                 delta = -delta;
3762                         if ((unsigned int)delta < voice->spurious_threshold) {
3763                                 /* do some statistics here */
3764                                 trident->spurious_irq_count++;
3765                                 if (trident->spurious_irq_max_delta < (unsigned int)delta)
3766                                         trident->spurious_irq_max_delta = delta;
3767                                 continue;
3768                         }
3769                         voice->stimer = stimer;
3770                         if (voice->isync) {
3771                                 if (!voice->isync3) {
3772                                         tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL));
3773                                         if (trident->bDMAStart & 0x40)
3774                                                 tmp >>= 1;
3775                                         if (tmp > 0)
3776                                                 tmp = voice->isync_max - tmp;
3777                                 } else {
3778                                         tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
3779                                 }
3780                                 if (tmp < voice->isync_mark) {
3781                                         if (tmp > 0x10)
3782                                                 tmp = voice->isync_ESO - 7;
3783                                         else
3784                                                 tmp = voice->isync_ESO + 2;
3785                                         /* update ESO for IRQ voice to preserve sync */
3786                                         snd_trident_stop_voice(trident, voice->number);
3787                                         snd_trident_write_eso_reg(trident, voice, tmp);
3788                                         snd_trident_start_voice(trident, voice->number);
3789                                 }
3790                         } else if (voice->isync2) {
3791                                 voice->isync2 = 0;
3792                                 /* write original ESO and update CSO for IRQ voice to preserve sync */
3793                                 snd_trident_stop_voice(trident, voice->number);
3794                                 snd_trident_write_cso_reg(trident, voice, voice->isync_mark);
3795                                 snd_trident_write_eso_reg(trident, voice, voice->ESO);
3796                                 snd_trident_start_voice(trident, voice->number);
3797                         }
3798 #if 0
3799                         if (voice->extra) {
3800                                 /* update CSO for extra voice to preserve sync */
3801                                 snd_trident_stop_voice(trident, voice->extra->number);
3802                                 snd_trident_write_cso_reg(trident, voice->extra, 0);
3803                                 snd_trident_start_voice(trident, voice->extra->number);
3804                         }
3805 #endif
3806                         spin_unlock(&trident->reg_lock);
3807                         snd_pcm_period_elapsed(voice->substream);
3808                         spin_lock(&trident->reg_lock);
3809                 }
3810                 outl(chn_int, TRID_REG(trident, T4D_AINT_B));   /* ack */
3811               __skip2:
3812                 spin_unlock(&trident->reg_lock);
3813         }
3814         if (audio_int & MPU401_IRQ) {
3815                 if (trident->rmidi) {
3816                         snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);
3817                 } else {
3818                         inb(TRID_REG(trident, T4D_MPUR0));
3819                 }
3820         }
3821         // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
3822         return IRQ_HANDLED;
3823 }
3824
3825 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
3826 {
3827         struct snd_trident_voice *pvoice;
3828         unsigned long flags;
3829         int idx;
3830
3831         spin_lock_irqsave(&trident->voice_alloc, flags);
3832         if (type == SNDRV_TRIDENT_VOICE_TYPE_PCM) {
3833                 idx = snd_trident_allocate_pcm_channel(trident);
3834                 if(idx < 0) {
3835                         spin_unlock_irqrestore(&trident->voice_alloc, flags);
3836                         return NULL;
3837                 }
3838                 pvoice = &trident->synth.voices[idx];
3839                 pvoice->use = 1;
3840                 pvoice->pcm = 1;
3841                 pvoice->capture = 0;
3842                 pvoice->spdif = 0;
3843                 pvoice->memblk = NULL;
3844                 pvoice->substream = NULL;
3845                 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3846                 return pvoice;
3847         }
3848         if (type == SNDRV_TRIDENT_VOICE_TYPE_SYNTH) {
3849                 idx = snd_trident_allocate_synth_channel(trident);
3850                 if(idx < 0) {
3851                         spin_unlock_irqrestore(&trident->voice_alloc, flags);
3852                         return NULL;
3853                 }
3854                 pvoice = &trident->synth.voices[idx];
3855                 pvoice->use = 1;
3856                 pvoice->synth = 1;
3857                 pvoice->client = client;
3858                 pvoice->port = port;
3859                 pvoice->memblk = NULL;
3860                 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3861                 return pvoice;
3862         }
3863         if (type == SNDRV_TRIDENT_VOICE_TYPE_MIDI) {
3864         }
3865         spin_unlock_irqrestore(&trident->voice_alloc, flags);
3866         return NULL;
3867 }
3868
3869 EXPORT_SYMBOL(snd_trident_alloc_voice);
3870
3871 void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
3872 {
3873         unsigned long flags;
3874         void (*private_free)(struct snd_trident_voice *);
3875         void *private_data;
3876
3877         if (voice == NULL || !voice->use)
3878                 return;
3879         snd_trident_clear_voices(trident, voice->number, voice->number);
3880         spin_lock_irqsave(&trident->voice_alloc, flags);
3881         private_free = voice->private_free;
3882         private_data = voice->private_data;
3883         voice->private_free = NULL;
3884         voice->private_data = NULL;
3885         if (voice->pcm)
3886                 snd_trident_free_pcm_channel(trident, voice->number);
3887         if (voice->synth)
3888                 snd_trident_free_synth_channel(trident, voice->number);
3889         voice->use = voice->pcm = voice->synth = voice->midi = 0;
3890         voice->capture = voice->spdif = 0;
3891         voice->sample_ops = NULL;
3892         voice->substream = NULL;
3893         voice->extra = NULL;
3894         spin_unlock_irqrestore(&trident->voice_alloc, flags);
3895         if (private_free)
3896                 private_free(voice);
3897 }
3898
3899 EXPORT_SYMBOL(snd_trident_free_voice);
3900
3901 static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
3902 {
3903         unsigned int i, val, mask[2] = { 0, 0 };
3904
3905         if (snd_BUG_ON(v_min > 63 || v_max > 63))
3906                 return;
3907         for (i = v_min; i <= v_max; i++)
3908                 mask[i >> 5] |= 1 << (i & 0x1f);
3909         if (mask[0]) {
3910                 outl(mask[0], TRID_REG(trident, T4D_STOP_A));
3911                 val = inl(TRID_REG(trident, T4D_AINTEN_A));
3912                 outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A));
3913         }
3914         if (mask[1]) {
3915                 outl(mask[1], TRID_REG(trident, T4D_STOP_B));
3916                 val = inl(TRID_REG(trident, T4D_AINTEN_B));
3917                 outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B));
3918         }
3919 }
3920
3921 #ifdef CONFIG_PM
3922 int snd_trident_suspend(struct pci_dev *pci, pm_message_t state)
3923 {
3924         struct snd_card *card = pci_get_drvdata(pci);
3925         struct snd_trident *trident = card->private_data;
3926
3927         trident->in_suspend = 1;
3928         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
3929         snd_pcm_suspend_all(trident->pcm);
3930         snd_pcm_suspend_all(trident->foldback);
3931         snd_pcm_suspend_all(trident->spdif);
3932
3933         snd_ac97_suspend(trident->ac97);
3934         snd_ac97_suspend(trident->ac97_sec);
3935
3936         pci_disable_device(pci);
3937         pci_save_state(pci);
3938         pci_set_power_state(pci, pci_choose_state(pci, state));
3939         return 0;
3940 }
3941
3942 int snd_trident_resume(struct pci_dev *pci)
3943 {
3944         struct snd_card *card = pci_get_drvdata(pci);
3945         struct snd_trident *trident = card->private_data;
3946
3947         pci_set_power_state(pci, PCI_D0);
3948         pci_restore_state(pci);
3949         if (pci_enable_device(pci) < 0) {
3950                 printk(KERN_ERR "trident: pci_enable_device failed, "
3951                        "disabling device\n");
3952                 snd_card_disconnect(card);
3953                 return -EIO;
3954         }
3955         pci_set_master(pci);
3956
3957         switch (trident->device) {
3958         case TRIDENT_DEVICE_ID_DX:
3959                 snd_trident_4d_dx_init(trident);
3960                 break;
3961         case TRIDENT_DEVICE_ID_NX:
3962                 snd_trident_4d_nx_init(trident);
3963                 break;
3964         case TRIDENT_DEVICE_ID_SI7018:
3965                 snd_trident_sis_init(trident);
3966                 break;
3967         }
3968
3969         snd_ac97_resume(trident->ac97);
3970         snd_ac97_resume(trident->ac97_sec);
3971
3972         /* restore some registers */
3973         outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3974
3975         snd_trident_enable_eso(trident);
3976
3977         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
3978         trident->in_suspend = 0;
3979         return 0;
3980 }
3981 #endif /* CONFIG_PM */