sound/pci/trident/trident_main.c

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