kernel/sound/pci/trident/trident_main.c

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