~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/trident/trident_main.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp