sound/pci/trident/trident_main.c

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