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