sound/pci/trident/trident_main.c

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