sound/pci/trident/trident_main.c

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