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