2 * Maintained by Jaroslav Kysela <perex@suse.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
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.
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.
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
27 * SiS7018 S/PDIF support by Thomas Winischhofer <thomas@winischhofer.net>
30 #include <sound/driver.h>
31 #include <linux/delay.h>
32 #include <linux/init.h>
33 #include <linux/interrupt.h>
34 #include <linux/pci.h>
35 #include <linux/slab.h>
36 #include <linux/vmalloc.h>
37 #include <linux/gameport.h>
38 #include <linux/dma-mapping.h>
40 #include <sound/core.h>
41 #include <sound/info.h>
42 #include <sound/control.h>
43 #include <sound/trident.h>
44 #include <sound/asoundef.h>
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 struct pt_regs
*regs
);
56 static int snd_trident_sis_reset(struct snd_trident
*trident
);
58 static void snd_trident_clear_voices(struct snd_trident
* trident
,
59 unsigned short v_min
, unsigned short v_max
);
60 static int snd_trident_free(struct snd_trident
*trident
);
68 static void snd_trident_print_voice_regs(struct snd_trident
*trident
, int voice
)
70 unsigned int val
, tmp
;
72 printk("Trident voice %i:\n", voice
);
73 outb(voice
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
74 val
= inl(TRID_REG(trident
, CH_LBA
));
75 printk("LBA: 0x%x\n", val
);
76 val
= inl(TRID_REG(trident
, CH_GVSEL_PAN_VOL_CTRL_EC
));
77 printk("GVSel: %i\n", val
>> 31);
78 printk("Pan: 0x%x\n", (val
>> 24) & 0x7f);
79 printk("Vol: 0x%x\n", (val
>> 16) & 0xff);
80 printk("CTRL: 0x%x\n", (val
>> 12) & 0x0f);
81 printk("EC: 0x%x\n", val
& 0x0fff);
82 if (trident
->device
!= TRIDENT_DEVICE_ID_NX
) {
83 val
= inl(TRID_REG(trident
, CH_DX_CSO_ALPHA_FMS
));
84 printk("CSO: 0x%x\n", val
>> 16);
85 printk("Alpha: 0x%x\n", (val
>> 4) & 0x0fff);
86 printk("FMS: 0x%x\n", val
& 0x0f);
87 val
= inl(TRID_REG(trident
, CH_DX_ESO_DELTA
));
88 printk("ESO: 0x%x\n", val
>> 16);
89 printk("Delta: 0x%x\n", val
& 0xffff);
90 val
= inl(TRID_REG(trident
, CH_DX_FMC_RVOL_CVOL
));
91 } else { // TRIDENT_DEVICE_ID_NX
92 val
= inl(TRID_REG(trident
, CH_NX_DELTA_CSO
));
93 tmp
= (val
>> 24) & 0xff;
94 printk("CSO: 0x%x\n", val
& 0x00ffffff);
95 val
= inl(TRID_REG(trident
, CH_NX_DELTA_ESO
));
96 tmp
|= (val
>> 16) & 0xff00;
97 printk("Delta: 0x%x\n", tmp
);
98 printk("ESO: 0x%x\n", val
& 0x00ffffff);
99 val
= inl(TRID_REG(trident
, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL
));
100 printk("Alpha: 0x%x\n", val
>> 20);
101 printk("FMS: 0x%x\n", (val
>> 16) & 0x0f);
103 printk("FMC: 0x%x\n", (val
>> 14) & 3);
104 printk("RVol: 0x%x\n", (val
>> 7) & 0x7f);
105 printk("CVol: 0x%x\n", val
& 0x7f);
109 /*---------------------------------------------------------------------------
110 unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
112 Description: This routine will do all of the reading from the external
115 Parameters: ac97 - ac97 codec structure
116 reg - CODEC register index, from AC97 Hal.
118 returns: 16 bit value read from the AC97.
120 ---------------------------------------------------------------------------*/
121 static unsigned short snd_trident_codec_read(struct snd_ac97
*ac97
, unsigned short reg
)
123 unsigned int data
= 0, treg
;
124 unsigned short count
= 0xffff;
126 struct snd_trident
*trident
= ac97
->private_data
;
128 spin_lock_irqsave(&trident
->reg_lock
, flags
);
129 if (trident
->device
== TRIDENT_DEVICE_ID_DX
) {
130 data
= (DX_AC97_BUSY_READ
| (reg
& 0x000000ff));
131 outl(data
, TRID_REG(trident
, DX_ACR1_AC97_R
));
133 data
= inl(TRID_REG(trident
, DX_ACR1_AC97_R
));
134 if ((data
& DX_AC97_BUSY_READ
) == 0)
137 } else if (trident
->device
== TRIDENT_DEVICE_ID_NX
) {
138 data
= (NX_AC97_BUSY_READ
| (reg
& 0x000000ff));
139 treg
= ac97
->num
== 0 ? NX_ACR2_AC97_R_PRIMARY
: NX_ACR3_AC97_R_SECONDARY
;
140 outl(data
, TRID_REG(trident
, treg
));
142 data
= inl(TRID_REG(trident
, treg
));
143 if ((data
& 0x00000C00) == 0)
146 } else if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
) {
147 data
= SI_AC97_BUSY_READ
| SI_AC97_AUDIO_BUSY
| (reg
& 0x000000ff);
149 data
|= SI_AC97_SECONDARY
;
150 outl(data
, TRID_REG(trident
, SI_AC97_READ
));
152 data
= inl(TRID_REG(trident
, SI_AC97_READ
));
153 if ((data
& (SI_AC97_BUSY_READ
)) == 0)
158 if (count
== 0 && !trident
->ac97_detect
) {
159 snd_printk(KERN_ERR
"ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
164 spin_unlock_irqrestore(&trident
->reg_lock
, flags
);
165 return ((unsigned short) (data
>> 16));
168 /*---------------------------------------------------------------------------
169 void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
170 unsigned short wdata)
172 Description: This routine will do all of the writing to the external
175 Parameters: ac97 - ac97 codec structure
176 reg - CODEC register index, from AC97 Hal.
177 data - Lower 16 bits are the data to write to CODEC.
179 returns: TRUE if everything went ok, else FALSE.
181 ---------------------------------------------------------------------------*/
182 static void snd_trident_codec_write(struct snd_ac97
*ac97
, unsigned short reg
,
183 unsigned short wdata
)
185 unsigned int address
, data
;
186 unsigned short count
= 0xffff;
188 struct snd_trident
*trident
= ac97
->private_data
;
190 data
= ((unsigned long) wdata
) << 16;
192 spin_lock_irqsave(&trident
->reg_lock
, flags
);
193 if (trident
->device
== TRIDENT_DEVICE_ID_DX
) {
194 address
= DX_ACR0_AC97_W
;
196 /* read AC-97 write register status */
198 if ((inw(TRID_REG(trident
, address
)) & DX_AC97_BUSY_WRITE
) == 0)
202 data
|= (DX_AC97_BUSY_WRITE
| (reg
& 0x000000ff));
203 } else if (trident
->device
== TRIDENT_DEVICE_ID_NX
) {
204 address
= NX_ACR1_AC97_W
;
206 /* read AC-97 write register status */
208 if ((inw(TRID_REG(trident
, address
)) & NX_AC97_BUSY_WRITE
) == 0)
212 data
|= (NX_AC97_BUSY_WRITE
| (ac97
->num
<< 8) | (reg
& 0x000000ff));
213 } else if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
) {
214 address
= SI_AC97_WRITE
;
216 /* read AC-97 write register status */
218 if ((inw(TRID_REG(trident
, address
)) & (SI_AC97_BUSY_WRITE
)) == 0)
222 data
|= SI_AC97_BUSY_WRITE
| SI_AC97_AUDIO_BUSY
| (reg
& 0x000000ff);
224 data
|= SI_AC97_SECONDARY
;
226 address
= 0; /* keep GCC happy */
227 count
= 0; /* return */
231 spin_unlock_irqrestore(&trident
->reg_lock
, flags
);
234 outl(data
, TRID_REG(trident
, address
));
235 spin_unlock_irqrestore(&trident
->reg_lock
, flags
);
238 /*---------------------------------------------------------------------------
239 void snd_trident_enable_eso(struct snd_trident *trident)
241 Description: This routine will enable end of loop interrupts.
242 End of loop interrupts will occur when a running
244 Also enables middle of loop interrupts.
246 Parameters: trident - pointer to target device class for 4DWave.
248 ---------------------------------------------------------------------------*/
250 static void snd_trident_enable_eso(struct snd_trident
* trident
)
254 val
= inl(TRID_REG(trident
, T4D_LFO_GC_CIR
));
257 if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
)
259 outl(val
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
262 /*---------------------------------------------------------------------------
263 void snd_trident_disable_eso(struct snd_trident *trident)
265 Description: This routine will disable end of loop interrupts.
266 End of loop interrupts will occur when a running
268 Also disables middle of loop interrupts.
271 trident - pointer to target device class for 4DWave.
273 returns: TRUE if everything went ok, else FALSE.
275 ---------------------------------------------------------------------------*/
277 static void snd_trident_disable_eso(struct snd_trident
* trident
)
281 tmp
= inl(TRID_REG(trident
, T4D_LFO_GC_CIR
));
284 outl(tmp
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
287 /*---------------------------------------------------------------------------
288 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
290 Description: Start a voice, any channel 0 thru 63.
291 This routine automatically handles the fact that there are
292 more than 32 channels available.
294 Parameters : voice - Voice number 0 thru n.
295 trident - pointer to target device class for 4DWave.
299 ---------------------------------------------------------------------------*/
301 void snd_trident_start_voice(struct snd_trident
* trident
, unsigned int voice
)
303 unsigned int mask
= 1 << (voice
& 0x1f);
304 unsigned int reg
= (voice
& 0x20) ? T4D_START_B
: T4D_START_A
;
306 outl(mask
, TRID_REG(trident
, reg
));
309 EXPORT_SYMBOL(snd_trident_start_voice
);
311 /*---------------------------------------------------------------------------
312 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
314 Description: Stop a voice, any channel 0 thru 63.
315 This routine automatically handles the fact that there are
316 more than 32 channels available.
318 Parameters : voice - Voice number 0 thru n.
319 trident - pointer to target device class for 4DWave.
323 ---------------------------------------------------------------------------*/
325 void snd_trident_stop_voice(struct snd_trident
* trident
, unsigned int voice
)
327 unsigned int mask
= 1 << (voice
& 0x1f);
328 unsigned int reg
= (voice
& 0x20) ? T4D_STOP_B
: T4D_STOP_A
;
330 outl(mask
, TRID_REG(trident
, reg
));
333 EXPORT_SYMBOL(snd_trident_stop_voice
);
335 /*---------------------------------------------------------------------------
336 int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
338 Description: Allocate hardware channel in Bank B (32-63).
340 Parameters : trident - pointer to target device class for 4DWave.
342 Return Value: hardware channel - 32-63 or -1 when no channel is available
344 ---------------------------------------------------------------------------*/
346 static int snd_trident_allocate_pcm_channel(struct snd_trident
* trident
)
350 if (trident
->ChanPCMcnt
>= trident
->ChanPCM
)
352 for (idx
= 31; idx
>= 0; idx
--) {
353 if (!(trident
->ChanMap
[T4D_BANK_B
] & (1 << idx
))) {
354 trident
->ChanMap
[T4D_BANK_B
] |= 1 << idx
;
355 trident
->ChanPCMcnt
++;
362 /*---------------------------------------------------------------------------
363 void snd_trident_free_pcm_channel(int channel)
365 Description: Free hardware channel in Bank B (32-63)
367 Parameters : trident - pointer to target device class for 4DWave.
368 channel - hardware channel number 0-63
372 ---------------------------------------------------------------------------*/
374 static void snd_trident_free_pcm_channel(struct snd_trident
*trident
, int channel
)
376 if (channel
< 32 || channel
> 63)
379 if (trident
->ChanMap
[T4D_BANK_B
] & (1 << channel
)) {
380 trident
->ChanMap
[T4D_BANK_B
] &= ~(1 << channel
);
381 trident
->ChanPCMcnt
--;
385 /*---------------------------------------------------------------------------
386 unsigned int snd_trident_allocate_synth_channel(void)
388 Description: Allocate hardware channel in Bank A (0-31).
390 Parameters : trident - pointer to target device class for 4DWave.
392 Return Value: hardware channel - 0-31 or -1 when no channel is available
394 ---------------------------------------------------------------------------*/
396 static int snd_trident_allocate_synth_channel(struct snd_trident
* trident
)
400 for (idx
= 31; idx
>= 0; idx
--) {
401 if (!(trident
->ChanMap
[T4D_BANK_A
] & (1 << idx
))) {
402 trident
->ChanMap
[T4D_BANK_A
] |= 1 << idx
;
403 trident
->synth
.ChanSynthCount
++;
410 /*---------------------------------------------------------------------------
411 void snd_trident_free_synth_channel( int channel )
413 Description: Free hardware channel in Bank B (0-31).
415 Parameters : trident - pointer to target device class for 4DWave.
416 channel - hardware channel number 0-63
420 ---------------------------------------------------------------------------*/
422 static void snd_trident_free_synth_channel(struct snd_trident
*trident
, int channel
)
424 if (channel
< 0 || channel
> 31)
427 if (trident
->ChanMap
[T4D_BANK_A
] & (1 << channel
)) {
428 trident
->ChanMap
[T4D_BANK_A
] &= ~(1 << channel
);
429 trident
->synth
.ChanSynthCount
--;
433 /*---------------------------------------------------------------------------
434 snd_trident_write_voice_regs
436 Description: This routine will complete and write the 5 hardware channel
437 registers to hardware.
439 Paramters: trident - pointer to target device class for 4DWave.
440 voice - synthesizer voice structure
443 ---------------------------------------------------------------------------*/
445 void snd_trident_write_voice_regs(struct snd_trident
* trident
,
446 struct snd_trident_voice
* voice
)
448 unsigned int FmcRvolCvol
;
449 unsigned int regs
[5];
451 regs
[1] = voice
->LBA
;
452 regs
[4] = (voice
->GVSel
<< 31) |
453 ((voice
->Pan
& 0x0000007f) << 24) |
454 ((voice
->CTRL
& 0x0000000f) << 12);
455 FmcRvolCvol
= ((voice
->FMC
& 3) << 14) |
456 ((voice
->RVol
& 0x7f) << 7) |
457 (voice
->CVol
& 0x7f);
459 switch (trident
->device
) {
460 case TRIDENT_DEVICE_ID_SI7018
:
461 regs
[4] |= voice
->number
> 31 ?
462 (voice
->Vol
& 0x000003ff) :
463 ((voice
->Vol
& 0x00003fc) << (16-2)) |
464 (voice
->EC
& 0x00000fff);
465 regs
[0] = (voice
->CSO
<< 16) | ((voice
->Alpha
& 0x00000fff) << 4) |
466 (voice
->FMS
& 0x0000000f);
467 regs
[2] = (voice
->ESO
<< 16) | (voice
->Delta
& 0x0ffff);
468 regs
[3] = (voice
->Attribute
<< 16) | FmcRvolCvol
;
470 case TRIDENT_DEVICE_ID_DX
:
471 regs
[4] |= ((voice
->Vol
& 0x000003fc) << (16-2)) |
472 (voice
->EC
& 0x00000fff);
473 regs
[0] = (voice
->CSO
<< 16) | ((voice
->Alpha
& 0x00000fff) << 4) |
474 (voice
->FMS
& 0x0000000f);
475 regs
[2] = (voice
->ESO
<< 16) | (voice
->Delta
& 0x0ffff);
476 regs
[3] = FmcRvolCvol
;
478 case TRIDENT_DEVICE_ID_NX
:
479 regs
[4] |= ((voice
->Vol
& 0x000003fc) << (16-2)) |
480 (voice
->EC
& 0x00000fff);
481 regs
[0] = (voice
->Delta
<< 24) | (voice
->CSO
& 0x00ffffff);
482 regs
[2] = ((voice
->Delta
<< 16) & 0xff000000) |
483 (voice
->ESO
& 0x00ffffff);
484 regs
[3] = (voice
->Alpha
<< 20) |
485 ((voice
->FMS
& 0x0000000f) << 16) | FmcRvolCvol
;
492 outb(voice
->number
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
493 outl(regs
[0], TRID_REG(trident
, CH_START
+ 0));
494 outl(regs
[1], TRID_REG(trident
, CH_START
+ 4));
495 outl(regs
[2], TRID_REG(trident
, CH_START
+ 8));
496 outl(regs
[3], TRID_REG(trident
, CH_START
+ 12));
497 outl(regs
[4], TRID_REG(trident
, CH_START
+ 16));
500 printk("written %i channel:\n", voice
->number
);
501 printk(" regs[0] = 0x%x/0x%x\n", regs
[0], inl(TRID_REG(trident
, CH_START
+ 0)));
502 printk(" regs[1] = 0x%x/0x%x\n", regs
[1], inl(TRID_REG(trident
, CH_START
+ 4)));
503 printk(" regs[2] = 0x%x/0x%x\n", regs
[2], inl(TRID_REG(trident
, CH_START
+ 8)));
504 printk(" regs[3] = 0x%x/0x%x\n", regs
[3], inl(TRID_REG(trident
, CH_START
+ 12)));
505 printk(" regs[4] = 0x%x/0x%x\n", regs
[4], inl(TRID_REG(trident
, CH_START
+ 16)));
509 EXPORT_SYMBOL(snd_trident_write_voice_regs
);
511 /*---------------------------------------------------------------------------
512 snd_trident_write_cso_reg
514 Description: This routine will write the new CSO offset
515 register to hardware.
517 Paramters: trident - pointer to target device class for 4DWave.
518 voice - synthesizer voice structure
521 ---------------------------------------------------------------------------*/
523 static void snd_trident_write_cso_reg(struct snd_trident
* trident
,
524 struct snd_trident_voice
* voice
,
528 outb(voice
->number
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
529 if (trident
->device
!= TRIDENT_DEVICE_ID_NX
) {
530 outw(voice
->CSO
, TRID_REG(trident
, CH_DX_CSO_ALPHA_FMS
) + 2);
532 outl((voice
->Delta
<< 24) |
533 (voice
->CSO
& 0x00ffffff), TRID_REG(trident
, CH_NX_DELTA_CSO
));
537 /*---------------------------------------------------------------------------
538 snd_trident_write_eso_reg
540 Description: This routine will write the new ESO offset
541 register to hardware.
543 Paramters: trident - pointer to target device class for 4DWave.
544 voice - synthesizer voice structure
547 ---------------------------------------------------------------------------*/
549 static void snd_trident_write_eso_reg(struct snd_trident
* trident
,
550 struct snd_trident_voice
* voice
,
554 outb(voice
->number
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
555 if (trident
->device
!= TRIDENT_DEVICE_ID_NX
) {
556 outw(voice
->ESO
, TRID_REG(trident
, CH_DX_ESO_DELTA
) + 2);
558 outl(((voice
->Delta
<< 16) & 0xff000000) | (voice
->ESO
& 0x00ffffff),
559 TRID_REG(trident
, CH_NX_DELTA_ESO
));
563 /*---------------------------------------------------------------------------
564 snd_trident_write_vol_reg
566 Description: This routine will write the new voice volume
567 register to hardware.
569 Paramters: trident - pointer to target device class for 4DWave.
570 voice - synthesizer voice structure
571 Vol - new voice volume
573 ---------------------------------------------------------------------------*/
575 static void snd_trident_write_vol_reg(struct snd_trident
* trident
,
576 struct snd_trident_voice
* voice
,
580 outb(voice
->number
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
581 switch (trident
->device
) {
582 case TRIDENT_DEVICE_ID_DX
:
583 case TRIDENT_DEVICE_ID_NX
:
584 outb(voice
->Vol
>> 2, TRID_REG(trident
, CH_GVSEL_PAN_VOL_CTRL_EC
+ 2));
586 case TRIDENT_DEVICE_ID_SI7018
:
587 // printk("voice->Vol = 0x%x\n", voice->Vol);
588 outw((voice
->CTRL
<< 12) | voice
->Vol
,
589 TRID_REG(trident
, CH_GVSEL_PAN_VOL_CTRL_EC
));
594 /*---------------------------------------------------------------------------
595 snd_trident_write_pan_reg
597 Description: This routine will write the new voice pan
598 register to hardware.
600 Paramters: trident - pointer to target device class for 4DWave.
601 voice - synthesizer voice structure
604 ---------------------------------------------------------------------------*/
606 static void snd_trident_write_pan_reg(struct snd_trident
* trident
,
607 struct snd_trident_voice
* voice
,
611 outb(voice
->number
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
612 outb(((voice
->GVSel
& 0x01) << 7) | (voice
->Pan
& 0x7f),
613 TRID_REG(trident
, CH_GVSEL_PAN_VOL_CTRL_EC
+ 3));
616 /*---------------------------------------------------------------------------
617 snd_trident_write_rvol_reg
619 Description: This routine will write the new reverb volume
620 register to hardware.
622 Paramters: trident - pointer to target device class for 4DWave.
623 voice - synthesizer voice structure
624 RVol - new reverb volume
626 ---------------------------------------------------------------------------*/
628 static void snd_trident_write_rvol_reg(struct snd_trident
* trident
,
629 struct snd_trident_voice
* voice
,
633 outb(voice
->number
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
634 outw(((voice
->FMC
& 0x0003) << 14) | ((voice
->RVol
& 0x007f) << 7) |
635 (voice
->CVol
& 0x007f),
636 TRID_REG(trident
, trident
->device
== TRIDENT_DEVICE_ID_NX
?
637 CH_NX_ALPHA_FMS_FMC_RVOL_CVOL
: CH_DX_FMC_RVOL_CVOL
));
640 /*---------------------------------------------------------------------------
641 snd_trident_write_cvol_reg
643 Description: This routine will write the new chorus volume
644 register to hardware.
646 Paramters: trident - pointer to target device class for 4DWave.
647 voice - synthesizer voice structure
648 CVol - new chorus volume
650 ---------------------------------------------------------------------------*/
652 static void snd_trident_write_cvol_reg(struct snd_trident
* trident
,
653 struct snd_trident_voice
* voice
,
657 outb(voice
->number
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
658 outw(((voice
->FMC
& 0x0003) << 14) | ((voice
->RVol
& 0x007f) << 7) |
659 (voice
->CVol
& 0x007f),
660 TRID_REG(trident
, trident
->device
== TRIDENT_DEVICE_ID_NX
?
661 CH_NX_ALPHA_FMS_FMC_RVOL_CVOL
: CH_DX_FMC_RVOL_CVOL
));
664 /*---------------------------------------------------------------------------
665 snd_trident_convert_rate
667 Description: This routine converts rate in HZ to hardware delta value.
669 Paramters: trident - pointer to target device class for 4DWave.
670 rate - Real or Virtual channel number.
672 Returns: Delta value.
674 ---------------------------------------------------------------------------*/
675 static unsigned int snd_trident_convert_rate(unsigned int rate
)
679 // We special case 44100 and 8000 since rounding with the equation
680 // does not give us an accurate enough value. For 11025 and 22050
681 // the equation gives us the best answer. All other frequencies will
682 // also use the equation. JDW
685 else if (rate
== 8000)
687 else if (rate
== 48000)
690 delta
= (((rate
<< 12) + 24000) / 48000) & 0x0000ffff;
694 /*---------------------------------------------------------------------------
695 snd_trident_convert_adc_rate
697 Description: This routine converts rate in HZ to hardware delta value.
699 Paramters: trident - pointer to target device class for 4DWave.
700 rate - Real or Virtual channel number.
702 Returns: Delta value.
704 ---------------------------------------------------------------------------*/
705 static unsigned int snd_trident_convert_adc_rate(unsigned int rate
)
709 // We special case 44100 and 8000 since rounding with the equation
710 // does not give us an accurate enough value. For 11025 and 22050
711 // the equation gives us the best answer. All other frequencies will
712 // also use the equation. JDW
715 else if (rate
== 8000)
717 else if (rate
== 48000)
720 delta
= ((48000 << 12) / rate
) & 0x0000ffff;
724 /*---------------------------------------------------------------------------
725 snd_trident_spurious_threshold
727 Description: This routine converts rate in HZ to spurious threshold.
729 Paramters: trident - pointer to target device class for 4DWave.
730 rate - Real or Virtual channel number.
732 Returns: Delta value.
734 ---------------------------------------------------------------------------*/
735 static unsigned int snd_trident_spurious_threshold(unsigned int rate
,
736 unsigned int period_size
)
738 unsigned int res
= (rate
* period_size
) / 48000;
746 /*---------------------------------------------------------------------------
747 snd_trident_control_mode
749 Description: This routine returns a control mode for a PCM channel.
751 Paramters: trident - pointer to target device class for 4DWave.
752 substream - PCM substream
754 Returns: Control value.
756 ---------------------------------------------------------------------------*/
757 static unsigned int snd_trident_control_mode(struct snd_pcm_substream
*substream
)
760 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
763 CTRL default: 8-bit (unsigned) mono, loop mode enabled
766 if (snd_pcm_format_width(runtime
->format
) == 16)
767 CTRL
|= 0x00000008; // 16-bit data
768 if (snd_pcm_format_signed(runtime
->format
))
769 CTRL
|= 0x00000002; // signed data
770 if (runtime
->channels
> 1)
771 CTRL
|= 0x00000004; // stereo data
779 /*---------------------------------------------------------------------------
782 Description: Device I/O control handler for playback/capture parameters.
784 Paramters: substream - PCM substream class
785 cmd - what ioctl message to process
786 arg - additional message infoarg
788 Returns: Error status
790 ---------------------------------------------------------------------------*/
792 static int snd_trident_ioctl(struct snd_pcm_substream
*substream
,
796 /* FIXME: it seems that with small periods the behaviour of
797 trident hardware is unpredictable and interrupt generator
799 return snd_pcm_lib_ioctl(substream
, cmd
, arg
);
802 /*---------------------------------------------------------------------------
803 snd_trident_allocate_pcm_mem
805 Description: Allocate PCM ring buffer for given substream
807 Parameters: substream - PCM substream class
808 hw_params - hardware parameters
810 Returns: Error status
812 ---------------------------------------------------------------------------*/
814 static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream
*substream
,
815 struct snd_pcm_hw_params
*hw_params
)
817 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
818 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
819 struct snd_trident_voice
*voice
= runtime
->private_data
;
822 if ((err
= snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
))) < 0)
824 if (trident
->tlb
.entries
) {
825 if (err
> 0) { /* change */
827 snd_trident_free_pages(trident
, voice
->memblk
);
828 voice
->memblk
= snd_trident_alloc_pages(trident
, substream
);
829 if (voice
->memblk
== NULL
)
836 /*---------------------------------------------------------------------------
837 snd_trident_allocate_evoice
839 Description: Allocate extra voice as interrupt generator
841 Parameters: substream - PCM substream class
842 hw_params - hardware parameters
844 Returns: Error status
846 ---------------------------------------------------------------------------*/
848 static int snd_trident_allocate_evoice(struct snd_pcm_substream
*substream
,
849 struct snd_pcm_hw_params
*hw_params
)
851 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
852 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
853 struct snd_trident_voice
*voice
= runtime
->private_data
;
854 struct snd_trident_voice
*evoice
= voice
->extra
;
856 /* voice management */
858 if (params_buffer_size(hw_params
) / 2 != params_period_size(hw_params
)) {
859 if (evoice
== NULL
) {
860 evoice
= snd_trident_alloc_voice(trident
, SNDRV_TRIDENT_VOICE_TYPE_PCM
, 0, 0);
863 voice
->extra
= evoice
;
864 evoice
->substream
= substream
;
867 if (evoice
!= NULL
) {
868 snd_trident_free_voice(trident
, evoice
);
869 voice
->extra
= evoice
= NULL
;
876 /*---------------------------------------------------------------------------
877 snd_trident_hw_params
879 Description: Set the hardware parameters for the playback device.
881 Parameters: substream - PCM substream class
882 hw_params - hardware parameters
884 Returns: Error status
886 ---------------------------------------------------------------------------*/
888 static int snd_trident_hw_params(struct snd_pcm_substream
*substream
,
889 struct snd_pcm_hw_params
*hw_params
)
893 err
= snd_trident_allocate_pcm_mem(substream
, hw_params
);
895 err
= snd_trident_allocate_evoice(substream
, hw_params
);
899 /*---------------------------------------------------------------------------
900 snd_trident_playback_hw_free
902 Description: Release the hardware resources for the playback device.
904 Parameters: substream - PCM substream class
906 Returns: Error status
908 ---------------------------------------------------------------------------*/
910 static int snd_trident_hw_free(struct snd_pcm_substream
*substream
)
912 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
913 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
914 struct snd_trident_voice
*voice
= runtime
->private_data
;
915 struct snd_trident_voice
*evoice
= voice
? voice
->extra
: NULL
;
917 if (trident
->tlb
.entries
) {
918 if (voice
&& voice
->memblk
) {
919 snd_trident_free_pages(trident
, voice
->memblk
);
920 voice
->memblk
= NULL
;
923 snd_pcm_lib_free_pages(substream
);
924 if (evoice
!= NULL
) {
925 snd_trident_free_voice(trident
, evoice
);
931 /*---------------------------------------------------------------------------
932 snd_trident_playback_prepare
934 Description: Prepare playback device for playback.
936 Parameters: substream - PCM substream class
938 Returns: Error status
940 ---------------------------------------------------------------------------*/
942 static int snd_trident_playback_prepare(struct snd_pcm_substream
*substream
)
944 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
945 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
946 struct snd_trident_voice
*voice
= runtime
->private_data
;
947 struct snd_trident_voice
*evoice
= voice
->extra
;
948 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[substream
->number
];
950 spin_lock_irq(&trident
->reg_lock
);
952 /* set delta (rate) value */
953 voice
->Delta
= snd_trident_convert_rate(runtime
->rate
);
954 voice
->spurious_threshold
= snd_trident_spurious_threshold(runtime
->rate
, runtime
->period_size
);
956 /* set Loop Begin Address */
958 voice
->LBA
= voice
->memblk
->offset
;
960 voice
->LBA
= runtime
->dma_addr
;
963 voice
->ESO
= runtime
->buffer_size
- 1; /* in samples */
964 voice
->CTRL
= snd_trident_control_mode(substream
);
970 voice
->Vol
= mix
->vol
;
971 voice
->RVol
= mix
->rvol
;
972 voice
->CVol
= mix
->cvol
;
973 voice
->Pan
= mix
->pan
;
974 voice
->Attribute
= 0;
976 voice
->Attribute
= (1<<(30-16))|(2<<(26-16))|
977 (0<<(24-16))|(0x1f<<(19-16));
979 voice
->Attribute
= 0;
982 snd_trident_write_voice_regs(trident
, voice
);
984 if (evoice
!= NULL
) {
985 evoice
->Delta
= voice
->Delta
;
986 evoice
->spurious_threshold
= voice
->spurious_threshold
;
987 evoice
->LBA
= voice
->LBA
;
989 evoice
->ESO
= (runtime
->period_size
* 2) + 4 - 1; /* in samples */
990 evoice
->CTRL
= voice
->CTRL
;
992 evoice
->GVSel
= trident
->device
== TRIDENT_DEVICE_ID_SI7018
? 0 : 1;
996 evoice
->Vol
= 0x3ff; /* mute */
997 evoice
->RVol
= evoice
->CVol
= 0x7f; /* mute */
998 evoice
->Pan
= 0x7f; /* mute */
1000 evoice
->Attribute
= (1<<(30-16))|(2<<(26-16))|
1001 (0<<(24-16))|(0x1f<<(19-16));
1003 evoice
->Attribute
= 0;
1005 snd_trident_write_voice_regs(trident
, evoice
);
1007 evoice
->isync_mark
= runtime
->period_size
;
1008 evoice
->ESO
= (runtime
->period_size
* 2) - 1;
1011 spin_unlock_irq(&trident
->reg_lock
);
1016 /*---------------------------------------------------------------------------
1017 snd_trident_capture_hw_params
1019 Description: Set the hardware parameters for the capture device.
1021 Parameters: substream - PCM substream class
1022 hw_params - hardware parameters
1024 Returns: Error status
1026 ---------------------------------------------------------------------------*/
1028 static int snd_trident_capture_hw_params(struct snd_pcm_substream
*substream
,
1029 struct snd_pcm_hw_params
*hw_params
)
1031 return snd_trident_allocate_pcm_mem(substream
, hw_params
);
1034 /*---------------------------------------------------------------------------
1035 snd_trident_capture_prepare
1037 Description: Prepare capture device for playback.
1039 Parameters: substream - PCM substream class
1041 Returns: Error status
1043 ---------------------------------------------------------------------------*/
1045 static int snd_trident_capture_prepare(struct snd_pcm_substream
*substream
)
1047 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1048 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1049 struct snd_trident_voice
*voice
= runtime
->private_data
;
1050 unsigned int val
, ESO_bytes
;
1052 spin_lock_irq(&trident
->reg_lock
);
1054 // Initilize the channel and set channel Mode
1055 outb(0, TRID_REG(trident
, LEGACY_DMAR15
));
1057 // Set DMA channel operation mode register
1058 outb(0x54, TRID_REG(trident
, LEGACY_DMAR11
));
1060 // Set channel buffer Address, DMAR0 expects contiguous PCI memory area
1061 voice
->LBA
= runtime
->dma_addr
;
1062 outl(voice
->LBA
, TRID_REG(trident
, LEGACY_DMAR0
));
1064 voice
->LBA
= voice
->memblk
->offset
;
1067 ESO_bytes
= snd_pcm_lib_buffer_bytes(substream
) - 1;
1068 outb((ESO_bytes
& 0x00ff0000) >> 16, TRID_REG(trident
, LEGACY_DMAR6
));
1069 outw((ESO_bytes
& 0x0000ffff), TRID_REG(trident
, LEGACY_DMAR4
));
1072 // Set channel sample rate, 4.12 format
1073 val
= (((unsigned int) 48000L << 12) + (runtime
->rate
/2)) / runtime
->rate
;
1074 outw(val
, TRID_REG(trident
, T4D_SBDELTA_DELTA_R
));
1076 // Set channel interrupt blk length
1077 if (snd_pcm_format_width(runtime
->format
) == 16) {
1078 val
= (unsigned short) ((ESO_bytes
>> 1) - 1);
1080 val
= (unsigned short) (ESO_bytes
- 1);
1083 outl((val
<< 16) | val
, TRID_REG(trident
, T4D_SBBL_SBCL
));
1085 // Right now, set format and start to run captureing,
1086 // continuous run loop enable.
1087 trident
->bDMAStart
= 0x19; // 0001 1001b
1089 if (snd_pcm_format_width(runtime
->format
) == 16)
1090 trident
->bDMAStart
|= 0x80;
1091 if (snd_pcm_format_signed(runtime
->format
))
1092 trident
->bDMAStart
|= 0x20;
1093 if (runtime
->channels
> 1)
1094 trident
->bDMAStart
|= 0x40;
1096 // Prepare capture intr channel
1098 voice
->Delta
= snd_trident_convert_rate(runtime
->rate
);
1099 voice
->spurious_threshold
= snd_trident_spurious_threshold(runtime
->rate
, runtime
->period_size
);
1101 voice
->isync_mark
= runtime
->period_size
;
1102 voice
->isync_max
= runtime
->buffer_size
;
1104 // Set voice parameters
1106 voice
->ESO
= voice
->isync_ESO
= (runtime
->period_size
* 2) + 6 - 1;
1107 voice
->CTRL
= snd_trident_control_mode(substream
);
1112 voice
->Pan
= 0x7f; /* mute */
1113 voice
->Vol
= 0x3ff; /* mute */
1117 voice
->Attribute
= 0;
1119 snd_trident_write_voice_regs(trident
, voice
);
1121 spin_unlock_irq(&trident
->reg_lock
);
1125 /*---------------------------------------------------------------------------
1126 snd_trident_si7018_capture_hw_params
1128 Description: Set the hardware parameters for the capture device.
1130 Parameters: substream - PCM substream class
1131 hw_params - hardware parameters
1133 Returns: Error status
1135 ---------------------------------------------------------------------------*/
1137 static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream
*substream
,
1138 struct snd_pcm_hw_params
*hw_params
)
1142 if ((err
= snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
))) < 0)
1145 return snd_trident_allocate_evoice(substream
, hw_params
);
1148 /*---------------------------------------------------------------------------
1149 snd_trident_si7018_capture_hw_free
1151 Description: Release the hardware resources for the capture device.
1153 Parameters: substream - PCM substream class
1155 Returns: Error status
1157 ---------------------------------------------------------------------------*/
1159 static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream
*substream
)
1161 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1162 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1163 struct snd_trident_voice
*voice
= runtime
->private_data
;
1164 struct snd_trident_voice
*evoice
= voice
? voice
->extra
: NULL
;
1166 snd_pcm_lib_free_pages(substream
);
1167 if (evoice
!= NULL
) {
1168 snd_trident_free_voice(trident
, evoice
);
1169 voice
->extra
= NULL
;
1174 /*---------------------------------------------------------------------------
1175 snd_trident_si7018_capture_prepare
1177 Description: Prepare capture device for playback.
1179 Parameters: substream - PCM substream class
1181 Returns: Error status
1183 ---------------------------------------------------------------------------*/
1185 static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream
*substream
)
1187 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1188 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1189 struct snd_trident_voice
*voice
= runtime
->private_data
;
1190 struct snd_trident_voice
*evoice
= voice
->extra
;
1192 spin_lock_irq(&trident
->reg_lock
);
1194 voice
->LBA
= runtime
->dma_addr
;
1195 voice
->Delta
= snd_trident_convert_adc_rate(runtime
->rate
);
1196 voice
->spurious_threshold
= snd_trident_spurious_threshold(runtime
->rate
, runtime
->period_size
);
1198 // Set voice parameters
1200 voice
->ESO
= runtime
->buffer_size
- 1; /* in samples */
1201 voice
->CTRL
= snd_trident_control_mode(substream
);
1206 voice
->Pan
= T4D_DEFAULT_PCM_PAN
;
1212 voice
->Attribute
= (2 << (30-16)) |
1217 snd_trident_write_voice_regs(trident
, voice
);
1219 if (evoice
!= NULL
) {
1220 evoice
->Delta
= snd_trident_convert_rate(runtime
->rate
);
1221 evoice
->spurious_threshold
= voice
->spurious_threshold
;
1222 evoice
->LBA
= voice
->LBA
;
1224 evoice
->ESO
= (runtime
->period_size
* 2) + 20 - 1; /* in samples, 20 means correction */
1225 evoice
->CTRL
= voice
->CTRL
;
1231 evoice
->Vol
= 0x3ff; /* mute */
1232 evoice
->RVol
= evoice
->CVol
= 0x7f; /* mute */
1233 evoice
->Pan
= 0x7f; /* mute */
1234 evoice
->Attribute
= 0;
1235 snd_trident_write_voice_regs(trident
, evoice
);
1237 evoice
->isync_mark
= runtime
->period_size
;
1238 evoice
->ESO
= (runtime
->period_size
* 2) - 1;
1241 spin_unlock_irq(&trident
->reg_lock
);
1245 /*---------------------------------------------------------------------------
1246 snd_trident_foldback_prepare
1248 Description: Prepare foldback capture device for playback.
1250 Parameters: substream - PCM substream class
1252 Returns: Error status
1254 ---------------------------------------------------------------------------*/
1256 static int snd_trident_foldback_prepare(struct snd_pcm_substream
*substream
)
1258 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1259 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1260 struct snd_trident_voice
*voice
= runtime
->private_data
;
1261 struct snd_trident_voice
*evoice
= voice
->extra
;
1263 spin_lock_irq(&trident
->reg_lock
);
1265 /* Set channel buffer Address */
1267 voice
->LBA
= voice
->memblk
->offset
;
1269 voice
->LBA
= runtime
->dma_addr
;
1271 /* set target ESO for channel */
1272 voice
->ESO
= runtime
->buffer_size
- 1; /* in samples */
1274 /* set sample rate */
1275 voice
->Delta
= 0x1000;
1276 voice
->spurious_threshold
= snd_trident_spurious_threshold(48000, runtime
->period_size
);
1279 voice
->CTRL
= snd_trident_control_mode(substream
);
1284 voice
->Pan
= 0x7f; /* mute */
1285 voice
->Vol
= 0x3ff; /* mute */
1289 voice
->Attribute
= 0;
1291 /* set up capture channel */
1292 outb(((voice
->number
& 0x3f) | 0x80), TRID_REG(trident
, T4D_RCI
+ voice
->foldback_chan
));
1294 snd_trident_write_voice_regs(trident
, voice
);
1296 if (evoice
!= NULL
) {
1297 evoice
->Delta
= voice
->Delta
;
1298 evoice
->spurious_threshold
= voice
->spurious_threshold
;
1299 evoice
->LBA
= voice
->LBA
;
1301 evoice
->ESO
= (runtime
->period_size
* 2) + 4 - 1; /* in samples */
1302 evoice
->CTRL
= voice
->CTRL
;
1304 evoice
->GVSel
= trident
->device
== TRIDENT_DEVICE_ID_SI7018
? 0 : 1;
1308 evoice
->Vol
= 0x3ff; /* mute */
1309 evoice
->RVol
= evoice
->CVol
= 0x7f; /* mute */
1310 evoice
->Pan
= 0x7f; /* mute */
1311 evoice
->Attribute
= 0;
1312 snd_trident_write_voice_regs(trident
, evoice
);
1314 evoice
->isync_mark
= runtime
->period_size
;
1315 evoice
->ESO
= (runtime
->period_size
* 2) - 1;
1318 spin_unlock_irq(&trident
->reg_lock
);
1322 /*---------------------------------------------------------------------------
1323 snd_trident_spdif_hw_params
1325 Description: Set the hardware parameters for the spdif device.
1327 Parameters: substream - PCM substream class
1328 hw_params - hardware parameters
1330 Returns: Error status
1332 ---------------------------------------------------------------------------*/
1334 static int snd_trident_spdif_hw_params(struct snd_pcm_substream
*substream
,
1335 struct snd_pcm_hw_params
*hw_params
)
1337 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1338 unsigned int old_bits
= 0, change
= 0;
1341 err
= snd_trident_allocate_pcm_mem(substream
, hw_params
);
1345 if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
) {
1346 err
= snd_trident_allocate_evoice(substream
, hw_params
);
1351 /* prepare SPDIF channel */
1352 spin_lock_irq(&trident
->reg_lock
);
1353 old_bits
= trident
->spdif_pcm_bits
;
1354 if (old_bits
& IEC958_AES0_PROFESSIONAL
)
1355 trident
->spdif_pcm_bits
&= ~IEC958_AES0_PRO_FS
;
1357 trident
->spdif_pcm_bits
&= ~(IEC958_AES3_CON_FS
<< 24);
1358 if (params_rate(hw_params
) >= 48000) {
1359 trident
->spdif_pcm_ctrl
= 0x3c; // 48000 Hz
1360 trident
->spdif_pcm_bits
|=
1361 trident
->spdif_bits
& IEC958_AES0_PROFESSIONAL
?
1362 IEC958_AES0_PRO_FS_48000
:
1363 (IEC958_AES3_CON_FS_48000
<< 24);
1365 else if (params_rate(hw_params
) >= 44100) {
1366 trident
->spdif_pcm_ctrl
= 0x3e; // 44100 Hz
1367 trident
->spdif_pcm_bits
|=
1368 trident
->spdif_bits
& IEC958_AES0_PROFESSIONAL
?
1369 IEC958_AES0_PRO_FS_44100
:
1370 (IEC958_AES3_CON_FS_44100
<< 24);
1373 trident
->spdif_pcm_ctrl
= 0x3d; // 32000 Hz
1374 trident
->spdif_pcm_bits
|=
1375 trident
->spdif_bits
& IEC958_AES0_PROFESSIONAL
?
1376 IEC958_AES0_PRO_FS_32000
:
1377 (IEC958_AES3_CON_FS_32000
<< 24);
1379 change
= old_bits
!= trident
->spdif_pcm_bits
;
1380 spin_unlock_irq(&trident
->reg_lock
);
1383 snd_ctl_notify(trident
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &trident
->spdif_pcm_ctl
->id
);
1388 /*---------------------------------------------------------------------------
1389 snd_trident_spdif_prepare
1391 Description: Prepare SPDIF device for playback.
1393 Parameters: substream - PCM substream class
1395 Returns: Error status
1397 ---------------------------------------------------------------------------*/
1399 static int snd_trident_spdif_prepare(struct snd_pcm_substream
*substream
)
1401 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1402 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1403 struct snd_trident_voice
*voice
= runtime
->private_data
;
1404 struct snd_trident_voice
*evoice
= voice
->extra
;
1405 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[substream
->number
];
1406 unsigned int RESO
, LBAO
;
1409 spin_lock_irq(&trident
->reg_lock
);
1411 if (trident
->device
!= TRIDENT_DEVICE_ID_SI7018
) {
1413 /* set delta (rate) value */
1414 voice
->Delta
= snd_trident_convert_rate(runtime
->rate
);
1415 voice
->spurious_threshold
= snd_trident_spurious_threshold(runtime
->rate
, runtime
->period_size
);
1417 /* set Loop Back Address */
1418 LBAO
= runtime
->dma_addr
;
1420 voice
->LBA
= voice
->memblk
->offset
;
1426 voice
->isync_mark
= runtime
->period_size
;
1427 voice
->isync_max
= runtime
->buffer_size
;
1429 /* set target ESO for channel */
1430 RESO
= runtime
->buffer_size
- 1;
1431 voice
->ESO
= voice
->isync_ESO
= (runtime
->period_size
* 2) + 6 - 1;
1434 voice
->CTRL
= snd_trident_control_mode(substream
);
1446 voice
->Attribute
= 0;
1448 /* prepare surrogate IRQ channel */
1449 snd_trident_write_voice_regs(trident
, voice
);
1451 outw((RESO
& 0xffff), TRID_REG(trident
, NX_SPESO
));
1452 outb((RESO
>> 16), TRID_REG(trident
, NX_SPESO
+ 2));
1453 outl((LBAO
& 0xfffffffc), TRID_REG(trident
, NX_SPLBA
));
1454 outw((voice
->CSO
& 0xffff), TRID_REG(trident
, NX_SPCTRL_SPCSO
));
1455 outb((voice
->CSO
>> 16), TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 2));
1457 /* set SPDIF setting */
1458 outb(trident
->spdif_pcm_ctrl
, TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 3));
1459 outl(trident
->spdif_pcm_bits
, TRID_REG(trident
, NX_SPCSTATUS
));
1463 /* set delta (rate) value */
1464 voice
->Delta
= 0x800;
1465 voice
->spurious_threshold
= snd_trident_spurious_threshold(48000, runtime
->period_size
);
1467 /* set Loop Begin Address */
1469 voice
->LBA
= voice
->memblk
->offset
;
1471 voice
->LBA
= runtime
->dma_addr
;
1474 voice
->ESO
= runtime
->buffer_size
- 1; /* in samples */
1475 voice
->CTRL
= snd_trident_control_mode(substream
);
1481 voice
->Vol
= mix
->vol
;
1482 voice
->RVol
= mix
->rvol
;
1483 voice
->CVol
= mix
->cvol
;
1484 voice
->Pan
= mix
->pan
;
1485 voice
->Attribute
= (1<<(30-16))|(7<<(26-16))|
1486 (0<<(24-16))|(0<<(19-16));
1488 snd_trident_write_voice_regs(trident
, voice
);
1490 if (evoice
!= NULL
) {
1491 evoice
->Delta
= voice
->Delta
;
1492 evoice
->spurious_threshold
= voice
->spurious_threshold
;
1493 evoice
->LBA
= voice
->LBA
;
1495 evoice
->ESO
= (runtime
->period_size
* 2) + 4 - 1; /* in samples */
1496 evoice
->CTRL
= voice
->CTRL
;
1498 evoice
->GVSel
= trident
->device
== TRIDENT_DEVICE_ID_SI7018
? 0 : 1;
1502 evoice
->Vol
= 0x3ff; /* mute */
1503 evoice
->RVol
= evoice
->CVol
= 0x7f; /* mute */
1504 evoice
->Pan
= 0x7f; /* mute */
1505 evoice
->Attribute
= 0;
1506 snd_trident_write_voice_regs(trident
, evoice
);
1508 evoice
->isync_mark
= runtime
->period_size
;
1509 evoice
->ESO
= (runtime
->period_size
* 2) - 1;
1512 outl(trident
->spdif_pcm_bits
, TRID_REG(trident
, SI_SPDIF_CS
));
1513 temp
= inl(TRID_REG(trident
, T4D_LFO_GC_CIR
));
1515 outl(temp
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
1516 temp
= inl(TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
1518 outl(temp
, TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
1521 spin_unlock_irq(&trident
->reg_lock
);
1526 /*---------------------------------------------------------------------------
1529 Description: Start/stop devices
1531 Parameters: substream - PCM substream class
1532 cmd - trigger command (STOP, GO)
1534 Returns: Error status
1536 ---------------------------------------------------------------------------*/
1538 static int snd_trident_trigger(struct snd_pcm_substream
*substream
,
1542 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1543 struct list_head
*pos
;
1544 struct snd_pcm_substream
*s
;
1545 unsigned int what
, whati
, capture_flag
, spdif_flag
;
1546 struct snd_trident_voice
*voice
, *evoice
;
1547 unsigned int val
, go
;
1550 case SNDRV_PCM_TRIGGER_START
:
1551 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
1552 case SNDRV_PCM_TRIGGER_RESUME
:
1555 case SNDRV_PCM_TRIGGER_STOP
:
1556 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
1557 case SNDRV_PCM_TRIGGER_SUSPEND
:
1563 what
= whati
= capture_flag
= spdif_flag
= 0;
1564 spin_lock(&trident
->reg_lock
);
1565 val
= inl(TRID_REG(trident
, T4D_STIMER
)) & 0x00ffffff;
1566 snd_pcm_group_for_each(pos
, substream
) {
1567 s
= snd_pcm_group_substream_entry(pos
);
1568 if ((struct snd_trident
*) snd_pcm_substream_chip(s
) == trident
) {
1569 voice
= s
->runtime
->private_data
;
1570 evoice
= voice
->extra
;
1571 what
|= 1 << (voice
->number
& 0x1f);
1572 if (evoice
== NULL
) {
1573 whati
|= 1 << (voice
->number
& 0x1f);
1575 what
|= 1 << (evoice
->number
& 0x1f);
1576 whati
|= 1 << (evoice
->number
& 0x1f);
1578 evoice
->stimer
= val
;
1582 voice
->stimer
= val
;
1586 snd_pcm_trigger_done(s
, substream
);
1594 if (trident
->device
!= TRIDENT_DEVICE_ID_SI7018
) {
1595 outl(trident
->spdif_pcm_bits
, TRID_REG(trident
, NX_SPCSTATUS
));
1596 outb(trident
->spdif_pcm_ctrl
, TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 3));
1598 outl(trident
->spdif_pcm_bits
, TRID_REG(trident
, SI_SPDIF_CS
));
1599 val
= inl(TRID_REG(trident
, SI_SERIAL_INTF_CTRL
)) | SPDIF_EN
;
1600 outl(val
, TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
1604 outl(what
, TRID_REG(trident
, T4D_STOP_B
));
1605 val
= inl(TRID_REG(trident
, T4D_AINTEN_B
));
1611 outl(val
, TRID_REG(trident
, T4D_AINTEN_B
));
1613 outl(what
, TRID_REG(trident
, T4D_START_B
));
1615 if (capture_flag
&& trident
->device
!= TRIDENT_DEVICE_ID_SI7018
)
1616 outb(trident
->bDMAStart
, TRID_REG(trident
, T4D_SBCTRL_SBE2R_SBDD
));
1618 if (capture_flag
&& trident
->device
!= TRIDENT_DEVICE_ID_SI7018
)
1619 outb(0x00, TRID_REG(trident
, T4D_SBCTRL_SBE2R_SBDD
));
1621 spin_unlock(&trident
->reg_lock
);
1625 /*---------------------------------------------------------------------------
1626 snd_trident_playback_pointer
1628 Description: This routine return the playback position
1630 Parameters: substream - PCM substream class
1632 Returns: position of buffer
1634 ---------------------------------------------------------------------------*/
1636 static snd_pcm_uframes_t
snd_trident_playback_pointer(struct snd_pcm_substream
*substream
)
1638 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1639 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1640 struct snd_trident_voice
*voice
= runtime
->private_data
;
1643 if (!voice
->running
)
1646 spin_lock(&trident
->reg_lock
);
1648 outb(voice
->number
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
1650 if (trident
->device
!= TRIDENT_DEVICE_ID_NX
) {
1651 cso
= inw(TRID_REG(trident
, CH_DX_CSO_ALPHA_FMS
+ 2));
1652 } else { // ID_4DWAVE_NX
1653 cso
= (unsigned int) inl(TRID_REG(trident
, CH_NX_DELTA_CSO
)) & 0x00ffffff;
1656 spin_unlock(&trident
->reg_lock
);
1658 if (cso
>= runtime
->buffer_size
)
1664 /*---------------------------------------------------------------------------
1665 snd_trident_capture_pointer
1667 Description: This routine return the capture position
1669 Paramters: pcm1 - PCM device class
1671 Returns: position of buffer
1673 ---------------------------------------------------------------------------*/
1675 static snd_pcm_uframes_t
snd_trident_capture_pointer(struct snd_pcm_substream
*substream
)
1677 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1678 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1679 struct snd_trident_voice
*voice
= runtime
->private_data
;
1680 unsigned int result
;
1682 if (!voice
->running
)
1685 result
= inw(TRID_REG(trident
, T4D_SBBL_SBCL
));
1686 if (runtime
->channels
> 1)
1689 result
= runtime
->buffer_size
- result
;
1694 /*---------------------------------------------------------------------------
1695 snd_trident_spdif_pointer
1697 Description: This routine return the SPDIF playback position
1699 Parameters: substream - PCM substream class
1701 Returns: position of buffer
1703 ---------------------------------------------------------------------------*/
1705 static snd_pcm_uframes_t
snd_trident_spdif_pointer(struct snd_pcm_substream
*substream
)
1707 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1708 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1709 struct snd_trident_voice
*voice
= runtime
->private_data
;
1710 unsigned int result
;
1712 if (!voice
->running
)
1715 result
= inl(TRID_REG(trident
, NX_SPCTRL_SPCSO
)) & 0x00ffffff;
1721 * Playback support device description
1724 static struct snd_pcm_hardware snd_trident_playback
=
1726 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1727 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1728 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
|
1729 SNDRV_PCM_INFO_PAUSE
/* | SNDRV_PCM_INFO_RESUME */),
1730 .formats
= (SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
|
1731 SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U16_LE
),
1732 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
1737 .buffer_bytes_max
= (256*1024),
1738 .period_bytes_min
= 64,
1739 .period_bytes_max
= (256*1024),
1741 .periods_max
= 1024,
1746 * Capture support device description
1749 static struct snd_pcm_hardware snd_trident_capture
=
1751 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1752 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1753 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
|
1754 SNDRV_PCM_INFO_PAUSE
/* | SNDRV_PCM_INFO_RESUME */),
1755 .formats
= (SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
|
1756 SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U16_LE
),
1757 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
1762 .buffer_bytes_max
= (128*1024),
1763 .period_bytes_min
= 64,
1764 .period_bytes_max
= (128*1024),
1766 .periods_max
= 1024,
1771 * Foldback capture support device description
1774 static struct snd_pcm_hardware snd_trident_foldback
=
1776 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1777 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1778 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
|
1779 SNDRV_PCM_INFO_PAUSE
/* | SNDRV_PCM_INFO_RESUME */),
1780 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1781 .rates
= SNDRV_PCM_RATE_48000
,
1786 .buffer_bytes_max
= (128*1024),
1787 .period_bytes_min
= 64,
1788 .period_bytes_max
= (128*1024),
1790 .periods_max
= 1024,
1795 * SPDIF playback support device description
1798 static struct snd_pcm_hardware snd_trident_spdif
=
1800 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1801 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1802 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
|
1803 SNDRV_PCM_INFO_PAUSE
/* | SNDRV_PCM_INFO_RESUME */),
1804 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1805 .rates
= (SNDRV_PCM_RATE_32000
| SNDRV_PCM_RATE_44100
|
1806 SNDRV_PCM_RATE_48000
),
1811 .buffer_bytes_max
= (128*1024),
1812 .period_bytes_min
= 64,
1813 .period_bytes_max
= (128*1024),
1815 .periods_max
= 1024,
1819 static struct snd_pcm_hardware snd_trident_spdif_7018
=
1821 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1822 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1823 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_SYNC_START
|
1824 SNDRV_PCM_INFO_PAUSE
/* | SNDRV_PCM_INFO_RESUME */),
1825 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1826 .rates
= SNDRV_PCM_RATE_48000
,
1831 .buffer_bytes_max
= (128*1024),
1832 .period_bytes_min
= 64,
1833 .period_bytes_max
= (128*1024),
1835 .periods_max
= 1024,
1839 static void snd_trident_pcm_free_substream(struct snd_pcm_runtime
*runtime
)
1841 struct snd_trident_voice
*voice
= runtime
->private_data
;
1842 struct snd_trident
*trident
;
1845 trident
= voice
->trident
;
1846 snd_trident_free_voice(trident
, voice
);
1850 static int snd_trident_playback_open(struct snd_pcm_substream
*substream
)
1852 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1853 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1854 struct snd_trident_voice
*voice
;
1856 voice
= snd_trident_alloc_voice(trident
, SNDRV_TRIDENT_VOICE_TYPE_PCM
, 0, 0);
1859 snd_trident_pcm_mixer_build(trident
, voice
, substream
);
1860 voice
->substream
= substream
;
1861 runtime
->private_data
= voice
;
1862 runtime
->private_free
= snd_trident_pcm_free_substream
;
1863 runtime
->hw
= snd_trident_playback
;
1864 snd_pcm_set_sync(substream
);
1865 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_BUFFER_SIZE
, 0, 64*1024);
1869 /*---------------------------------------------------------------------------
1870 snd_trident_playback_close
1872 Description: This routine will close the 4DWave playback device. For now
1873 we will simply free the dma transfer buffer.
1875 Parameters: substream - PCM substream class
1877 ---------------------------------------------------------------------------*/
1878 static int snd_trident_playback_close(struct snd_pcm_substream
*substream
)
1880 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1881 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1882 struct snd_trident_voice
*voice
= runtime
->private_data
;
1884 snd_trident_pcm_mixer_free(trident
, voice
, substream
);
1888 /*---------------------------------------------------------------------------
1889 snd_trident_spdif_open
1891 Description: This routine will open the 4DWave SPDIF device.
1893 Parameters: substream - PCM substream class
1895 Returns: status - success or failure flag
1897 ---------------------------------------------------------------------------*/
1899 static int snd_trident_spdif_open(struct snd_pcm_substream
*substream
)
1901 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1902 struct snd_trident_voice
*voice
;
1903 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1905 voice
= snd_trident_alloc_voice(trident
, SNDRV_TRIDENT_VOICE_TYPE_PCM
, 0, 0);
1909 voice
->substream
= substream
;
1910 spin_lock_irq(&trident
->reg_lock
);
1911 trident
->spdif_pcm_bits
= trident
->spdif_bits
;
1912 spin_unlock_irq(&trident
->reg_lock
);
1914 runtime
->private_data
= voice
;
1915 runtime
->private_free
= snd_trident_pcm_free_substream
;
1916 if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
) {
1917 runtime
->hw
= snd_trident_spdif
;
1919 runtime
->hw
= snd_trident_spdif_7018
;
1922 trident
->spdif_pcm_ctl
->vd
[0].access
&= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE
;
1923 snd_ctl_notify(trident
->card
, SNDRV_CTL_EVENT_MASK_VALUE
|
1924 SNDRV_CTL_EVENT_MASK_INFO
, &trident
->spdif_pcm_ctl
->id
);
1926 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_BUFFER_SIZE
, 0, 64*1024);
1931 /*---------------------------------------------------------------------------
1932 snd_trident_spdif_close
1934 Description: This routine will close the 4DWave SPDIF device.
1936 Parameters: substream - PCM substream class
1938 ---------------------------------------------------------------------------*/
1940 static int snd_trident_spdif_close(struct snd_pcm_substream
*substream
)
1942 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1945 spin_lock_irq(&trident
->reg_lock
);
1946 // restore default SPDIF setting
1947 if (trident
->device
!= TRIDENT_DEVICE_ID_SI7018
) {
1948 outb(trident
->spdif_ctrl
, TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 3));
1949 outl(trident
->spdif_bits
, TRID_REG(trident
, NX_SPCSTATUS
));
1951 outl(trident
->spdif_bits
, TRID_REG(trident
, SI_SPDIF_CS
));
1952 temp
= inl(TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
1953 if (trident
->spdif_ctrl
) {
1958 outl(temp
, TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
1960 spin_unlock_irq(&trident
->reg_lock
);
1961 trident
->spdif_pcm_ctl
->vd
[0].access
|= SNDRV_CTL_ELEM_ACCESS_INACTIVE
;
1962 snd_ctl_notify(trident
->card
, SNDRV_CTL_EVENT_MASK_VALUE
|
1963 SNDRV_CTL_EVENT_MASK_INFO
, &trident
->spdif_pcm_ctl
->id
);
1967 /*---------------------------------------------------------------------------
1968 snd_trident_capture_open
1970 Description: This routine will open the 4DWave capture device.
1972 Parameters: substream - PCM substream class
1974 Returns: status - success or failure flag
1976 ---------------------------------------------------------------------------*/
1978 static int snd_trident_capture_open(struct snd_pcm_substream
*substream
)
1980 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
1981 struct snd_trident_voice
*voice
;
1982 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1984 voice
= snd_trident_alloc_voice(trident
, SNDRV_TRIDENT_VOICE_TYPE_PCM
, 0, 0);
1988 voice
->substream
= substream
;
1989 runtime
->private_data
= voice
;
1990 runtime
->private_free
= snd_trident_pcm_free_substream
;
1991 runtime
->hw
= snd_trident_capture
;
1992 snd_pcm_set_sync(substream
);
1993 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_BUFFER_SIZE
, 0, 64*1024);
1997 /*---------------------------------------------------------------------------
1998 snd_trident_capture_close
2000 Description: This routine will close the 4DWave capture device. For now
2001 we will simply free the dma transfer buffer.
2003 Parameters: substream - PCM substream class
2005 ---------------------------------------------------------------------------*/
2006 static int snd_trident_capture_close(struct snd_pcm_substream
*substream
)
2011 /*---------------------------------------------------------------------------
2012 snd_trident_foldback_open
2014 Description: This routine will open the 4DWave foldback capture device.
2016 Parameters: substream - PCM substream class
2018 Returns: status - success or failure flag
2020 ---------------------------------------------------------------------------*/
2022 static int snd_trident_foldback_open(struct snd_pcm_substream
*substream
)
2024 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
2025 struct snd_trident_voice
*voice
;
2026 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2028 voice
= snd_trident_alloc_voice(trident
, SNDRV_TRIDENT_VOICE_TYPE_PCM
, 0, 0);
2031 voice
->foldback_chan
= substream
->number
;
2032 voice
->substream
= substream
;
2033 runtime
->private_data
= voice
;
2034 runtime
->private_free
= snd_trident_pcm_free_substream
;
2035 runtime
->hw
= snd_trident_foldback
;
2036 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_BUFFER_SIZE
, 0, 64*1024);
2040 /*---------------------------------------------------------------------------
2041 snd_trident_foldback_close
2043 Description: This routine will close the 4DWave foldback capture device.
2044 For now we will simply free the dma transfer buffer.
2046 Parameters: substream - PCM substream class
2048 ---------------------------------------------------------------------------*/
2049 static int snd_trident_foldback_close(struct snd_pcm_substream
*substream
)
2051 struct snd_trident
*trident
= snd_pcm_substream_chip(substream
);
2052 struct snd_trident_voice
*voice
;
2053 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
2054 voice
= runtime
->private_data
;
2056 /* stop capture channel */
2057 spin_lock_irq(&trident
->reg_lock
);
2058 outb(0x00, TRID_REG(trident
, T4D_RCI
+ voice
->foldback_chan
));
2059 spin_unlock_irq(&trident
->reg_lock
);
2063 /*---------------------------------------------------------------------------
2065 ---------------------------------------------------------------------------*/
2067 static struct snd_pcm_ops snd_trident_playback_ops
= {
2068 .open
= snd_trident_playback_open
,
2069 .close
= snd_trident_playback_close
,
2070 .ioctl
= snd_trident_ioctl
,
2071 .hw_params
= snd_trident_hw_params
,
2072 .hw_free
= snd_trident_hw_free
,
2073 .prepare
= snd_trident_playback_prepare
,
2074 .trigger
= snd_trident_trigger
,
2075 .pointer
= snd_trident_playback_pointer
,
2078 static struct snd_pcm_ops snd_trident_nx_playback_ops
= {
2079 .open
= snd_trident_playback_open
,
2080 .close
= snd_trident_playback_close
,
2081 .ioctl
= snd_trident_ioctl
,
2082 .hw_params
= snd_trident_hw_params
,
2083 .hw_free
= snd_trident_hw_free
,
2084 .prepare
= snd_trident_playback_prepare
,
2085 .trigger
= snd_trident_trigger
,
2086 .pointer
= snd_trident_playback_pointer
,
2087 .page
= snd_pcm_sgbuf_ops_page
,
2090 static struct snd_pcm_ops snd_trident_capture_ops
= {
2091 .open
= snd_trident_capture_open
,
2092 .close
= snd_trident_capture_close
,
2093 .ioctl
= snd_trident_ioctl
,
2094 .hw_params
= snd_trident_capture_hw_params
,
2095 .hw_free
= snd_trident_hw_free
,
2096 .prepare
= snd_trident_capture_prepare
,
2097 .trigger
= snd_trident_trigger
,
2098 .pointer
= snd_trident_capture_pointer
,
2101 static struct snd_pcm_ops snd_trident_si7018_capture_ops
= {
2102 .open
= snd_trident_capture_open
,
2103 .close
= snd_trident_capture_close
,
2104 .ioctl
= snd_trident_ioctl
,
2105 .hw_params
= snd_trident_si7018_capture_hw_params
,
2106 .hw_free
= snd_trident_si7018_capture_hw_free
,
2107 .prepare
= snd_trident_si7018_capture_prepare
,
2108 .trigger
= snd_trident_trigger
,
2109 .pointer
= snd_trident_playback_pointer
,
2112 static struct snd_pcm_ops snd_trident_foldback_ops
= {
2113 .open
= snd_trident_foldback_open
,
2114 .close
= snd_trident_foldback_close
,
2115 .ioctl
= snd_trident_ioctl
,
2116 .hw_params
= snd_trident_hw_params
,
2117 .hw_free
= snd_trident_hw_free
,
2118 .prepare
= snd_trident_foldback_prepare
,
2119 .trigger
= snd_trident_trigger
,
2120 .pointer
= snd_trident_playback_pointer
,
2123 static struct snd_pcm_ops snd_trident_nx_foldback_ops
= {
2124 .open
= snd_trident_foldback_open
,
2125 .close
= snd_trident_foldback_close
,
2126 .ioctl
= snd_trident_ioctl
,
2127 .hw_params
= snd_trident_hw_params
,
2128 .hw_free
= snd_trident_hw_free
,
2129 .prepare
= snd_trident_foldback_prepare
,
2130 .trigger
= snd_trident_trigger
,
2131 .pointer
= snd_trident_playback_pointer
,
2132 .page
= snd_pcm_sgbuf_ops_page
,
2135 static struct snd_pcm_ops snd_trident_spdif_ops
= {
2136 .open
= snd_trident_spdif_open
,
2137 .close
= snd_trident_spdif_close
,
2138 .ioctl
= snd_trident_ioctl
,
2139 .hw_params
= snd_trident_spdif_hw_params
,
2140 .hw_free
= snd_trident_hw_free
,
2141 .prepare
= snd_trident_spdif_prepare
,
2142 .trigger
= snd_trident_trigger
,
2143 .pointer
= snd_trident_spdif_pointer
,
2146 static struct snd_pcm_ops snd_trident_spdif_7018_ops
= {
2147 .open
= snd_trident_spdif_open
,
2148 .close
= snd_trident_spdif_close
,
2149 .ioctl
= snd_trident_ioctl
,
2150 .hw_params
= snd_trident_spdif_hw_params
,
2151 .hw_free
= snd_trident_hw_free
,
2152 .prepare
= snd_trident_spdif_prepare
,
2153 .trigger
= snd_trident_trigger
,
2154 .pointer
= snd_trident_playback_pointer
,
2157 /*---------------------------------------------------------------------------
2160 Description: This routine registers the 4DWave device for PCM support.
2162 Paramters: trident - pointer to target device class for 4DWave.
2166 ---------------------------------------------------------------------------*/
2168 int __devinit
snd_trident_pcm(struct snd_trident
* trident
,
2169 int device
, struct snd_pcm
** rpcm
)
2171 struct snd_pcm
*pcm
;
2176 if ((err
= snd_pcm_new(trident
->card
, "trident_dx_nx", device
, trident
->ChanPCM
, 1, &pcm
)) < 0)
2179 pcm
->private_data
= trident
;
2181 if (trident
->tlb
.entries
) {
2182 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_trident_nx_playback_ops
);
2184 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_trident_playback_ops
);
2186 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
,
2187 trident
->device
!= TRIDENT_DEVICE_ID_SI7018
?
2188 &snd_trident_capture_ops
:
2189 &snd_trident_si7018_capture_ops
);
2191 pcm
->info_flags
= 0;
2192 pcm
->dev_subclass
= SNDRV_PCM_SUBCLASS_GENERIC_MIX
;
2193 strcpy(pcm
->name
, "Trident 4DWave");
2196 if (trident
->tlb
.entries
) {
2197 struct snd_pcm_substream
*substream
;
2198 for (substream
= pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
; substream
; substream
= substream
->next
)
2199 snd_pcm_lib_preallocate_pages(substream
, SNDRV_DMA_TYPE_DEV_SG
,
2200 snd_dma_pci_data(trident
->pci
),
2202 snd_pcm_lib_preallocate_pages(pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
,
2203 SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(trident
->pci
),
2206 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
2207 snd_dma_pci_data(trident
->pci
), 64*1024, 128*1024);
2215 /*---------------------------------------------------------------------------
2216 snd_trident_foldback_pcm
2218 Description: This routine registers the 4DWave device for foldback PCM support.
2220 Paramters: trident - pointer to target device class for 4DWave.
2224 ---------------------------------------------------------------------------*/
2226 int __devinit
snd_trident_foldback_pcm(struct snd_trident
* trident
,
2227 int device
, struct snd_pcm
** rpcm
)
2229 struct snd_pcm
*foldback
;
2232 struct snd_pcm_substream
*substream
;
2236 if (trident
->device
== TRIDENT_DEVICE_ID_NX
)
2238 if ((err
= snd_pcm_new(trident
->card
, "trident_dx_nx", device
, 0, num_chan
, &foldback
)) < 0)
2241 foldback
->private_data
= trident
;
2242 if (trident
->tlb
.entries
)
2243 snd_pcm_set_ops(foldback
, SNDRV_PCM_STREAM_CAPTURE
, &snd_trident_nx_foldback_ops
);
2245 snd_pcm_set_ops(foldback
, SNDRV_PCM_STREAM_CAPTURE
, &snd_trident_foldback_ops
);
2246 foldback
->info_flags
= 0;
2247 strcpy(foldback
->name
, "Trident 4DWave");
2248 substream
= foldback
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
;
2249 strcpy(substream
->name
, "Front Mixer");
2250 substream
= substream
->next
;
2251 strcpy(substream
->name
, "Reverb Mixer");
2252 substream
= substream
->next
;
2253 strcpy(substream
->name
, "Chorus Mixer");
2254 if (num_chan
== 4) {
2255 substream
= substream
->next
;
2256 strcpy(substream
->name
, "Second AC'97 ADC");
2258 trident
->foldback
= foldback
;
2260 if (trident
->tlb
.entries
)
2261 snd_pcm_lib_preallocate_pages_for_all(foldback
, SNDRV_DMA_TYPE_DEV_SG
,
2262 snd_dma_pci_data(trident
->pci
), 0, 128*1024);
2264 snd_pcm_lib_preallocate_pages_for_all(foldback
, SNDRV_DMA_TYPE_DEV
,
2265 snd_dma_pci_data(trident
->pci
), 64*1024, 128*1024);
2272 /*---------------------------------------------------------------------------
2275 Description: This routine registers the 4DWave-NX device for SPDIF support.
2277 Paramters: trident - pointer to target device class for 4DWave-NX.
2281 ---------------------------------------------------------------------------*/
2283 int __devinit
snd_trident_spdif_pcm(struct snd_trident
* trident
,
2284 int device
, struct snd_pcm
** rpcm
)
2286 struct snd_pcm
*spdif
;
2291 if ((err
= snd_pcm_new(trident
->card
, "trident_dx_nx IEC958", device
, 1, 0, &spdif
)) < 0)
2294 spdif
->private_data
= trident
;
2295 if (trident
->device
!= TRIDENT_DEVICE_ID_SI7018
) {
2296 snd_pcm_set_ops(spdif
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_trident_spdif_ops
);
2298 snd_pcm_set_ops(spdif
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_trident_spdif_7018_ops
);
2300 spdif
->info_flags
= 0;
2301 strcpy(spdif
->name
, "Trident 4DWave IEC958");
2302 trident
->spdif
= spdif
;
2304 snd_pcm_lib_preallocate_pages_for_all(spdif
, SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(trident
->pci
), 64*1024, 128*1024);
2316 /*---------------------------------------------------------------------------
2317 snd_trident_spdif_control
2319 Description: enable/disable S/PDIF out from ac97 mixer
2320 ---------------------------------------------------------------------------*/
2322 static int snd_trident_spdif_control_info(struct snd_kcontrol
*kcontrol
,
2323 struct snd_ctl_elem_info
*uinfo
)
2325 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2327 uinfo
->value
.integer
.min
= 0;
2328 uinfo
->value
.integer
.max
= 1;
2332 static int snd_trident_spdif_control_get(struct snd_kcontrol
*kcontrol
,
2333 struct snd_ctl_elem_value
*ucontrol
)
2335 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2338 spin_lock_irq(&trident
->reg_lock
);
2339 val
= trident
->spdif_ctrl
;
2340 ucontrol
->value
.integer
.value
[0] = val
== kcontrol
->private_value
;
2341 spin_unlock_irq(&trident
->reg_lock
);
2345 static int snd_trident_spdif_control_put(struct snd_kcontrol
*kcontrol
,
2346 struct snd_ctl_elem_value
*ucontrol
)
2348 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2352 val
= ucontrol
->value
.integer
.value
[0] ? (unsigned char) kcontrol
->private_value
: 0x00;
2353 spin_lock_irq(&trident
->reg_lock
);
2354 /* S/PDIF C Channel bits 0-31 : 48khz, SCMS disabled */
2355 change
= trident
->spdif_ctrl
!= val
;
2356 trident
->spdif_ctrl
= val
;
2357 if (trident
->device
!= TRIDENT_DEVICE_ID_SI7018
) {
2358 if ((inb(TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 3)) & 0x10) == 0) {
2359 outl(trident
->spdif_bits
, TRID_REG(trident
, NX_SPCSTATUS
));
2360 outb(trident
->spdif_ctrl
, TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 3));
2363 if (trident
->spdif
== NULL
) {
2365 outl(trident
->spdif_bits
, TRID_REG(trident
, SI_SPDIF_CS
));
2366 temp
= inl(TRID_REG(trident
, SI_SERIAL_INTF_CTRL
)) & ~SPDIF_EN
;
2369 outl(temp
, TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
2372 spin_unlock_irq(&trident
->reg_lock
);
2376 static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata
=
2378 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2379 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,SWITCH
),
2380 .info
= snd_trident_spdif_control_info
,
2381 .get
= snd_trident_spdif_control_get
,
2382 .put
= snd_trident_spdif_control_put
,
2383 .private_value
= 0x28,
2386 /*---------------------------------------------------------------------------
2387 snd_trident_spdif_default
2389 Description: put/get the S/PDIF default settings
2390 ---------------------------------------------------------------------------*/
2392 static int snd_trident_spdif_default_info(struct snd_kcontrol
*kcontrol
,
2393 struct snd_ctl_elem_info
*uinfo
)
2395 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
2400 static int snd_trident_spdif_default_get(struct snd_kcontrol
*kcontrol
,
2401 struct snd_ctl_elem_value
*ucontrol
)
2403 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2405 spin_lock_irq(&trident
->reg_lock
);
2406 ucontrol
->value
.iec958
.status
[0] = (trident
->spdif_bits
>> 0) & 0xff;
2407 ucontrol
->value
.iec958
.status
[1] = (trident
->spdif_bits
>> 8) & 0xff;
2408 ucontrol
->value
.iec958
.status
[2] = (trident
->spdif_bits
>> 16) & 0xff;
2409 ucontrol
->value
.iec958
.status
[3] = (trident
->spdif_bits
>> 24) & 0xff;
2410 spin_unlock_irq(&trident
->reg_lock
);
2414 static int snd_trident_spdif_default_put(struct snd_kcontrol
*kcontrol
,
2415 struct snd_ctl_elem_value
*ucontrol
)
2417 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2421 val
= (ucontrol
->value
.iec958
.status
[0] << 0) |
2422 (ucontrol
->value
.iec958
.status
[1] << 8) |
2423 (ucontrol
->value
.iec958
.status
[2] << 16) |
2424 (ucontrol
->value
.iec958
.status
[3] << 24);
2425 spin_lock_irq(&trident
->reg_lock
);
2426 change
= trident
->spdif_bits
!= val
;
2427 trident
->spdif_bits
= val
;
2428 if (trident
->device
!= TRIDENT_DEVICE_ID_SI7018
) {
2429 if ((inb(TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 3)) & 0x10) == 0)
2430 outl(trident
->spdif_bits
, TRID_REG(trident
, NX_SPCSTATUS
));
2432 if (trident
->spdif
== NULL
)
2433 outl(trident
->spdif_bits
, TRID_REG(trident
, SI_SPDIF_CS
));
2435 spin_unlock_irq(&trident
->reg_lock
);
2439 static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata
=
2441 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
2442 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
2443 .info
= snd_trident_spdif_default_info
,
2444 .get
= snd_trident_spdif_default_get
,
2445 .put
= snd_trident_spdif_default_put
2448 /*---------------------------------------------------------------------------
2449 snd_trident_spdif_mask
2451 Description: put/get the S/PDIF mask
2452 ---------------------------------------------------------------------------*/
2454 static int snd_trident_spdif_mask_info(struct snd_kcontrol
*kcontrol
,
2455 struct snd_ctl_elem_info
*uinfo
)
2457 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
2462 static int snd_trident_spdif_mask_get(struct snd_kcontrol
*kcontrol
,
2463 struct snd_ctl_elem_value
*ucontrol
)
2465 ucontrol
->value
.iec958
.status
[0] = 0xff;
2466 ucontrol
->value
.iec958
.status
[1] = 0xff;
2467 ucontrol
->value
.iec958
.status
[2] = 0xff;
2468 ucontrol
->value
.iec958
.status
[3] = 0xff;
2472 static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata
=
2474 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
2475 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
2476 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,MASK
),
2477 .info
= snd_trident_spdif_mask_info
,
2478 .get
= snd_trident_spdif_mask_get
,
2481 /*---------------------------------------------------------------------------
2482 snd_trident_spdif_stream
2484 Description: put/get the S/PDIF stream settings
2485 ---------------------------------------------------------------------------*/
2487 static int snd_trident_spdif_stream_info(struct snd_kcontrol
*kcontrol
,
2488 struct snd_ctl_elem_info
*uinfo
)
2490 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
2495 static int snd_trident_spdif_stream_get(struct snd_kcontrol
*kcontrol
,
2496 struct snd_ctl_elem_value
*ucontrol
)
2498 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2500 spin_lock_irq(&trident
->reg_lock
);
2501 ucontrol
->value
.iec958
.status
[0] = (trident
->spdif_pcm_bits
>> 0) & 0xff;
2502 ucontrol
->value
.iec958
.status
[1] = (trident
->spdif_pcm_bits
>> 8) & 0xff;
2503 ucontrol
->value
.iec958
.status
[2] = (trident
->spdif_pcm_bits
>> 16) & 0xff;
2504 ucontrol
->value
.iec958
.status
[3] = (trident
->spdif_pcm_bits
>> 24) & 0xff;
2505 spin_unlock_irq(&trident
->reg_lock
);
2509 static int snd_trident_spdif_stream_put(struct snd_kcontrol
*kcontrol
,
2510 struct snd_ctl_elem_value
*ucontrol
)
2512 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2516 val
= (ucontrol
->value
.iec958
.status
[0] << 0) |
2517 (ucontrol
->value
.iec958
.status
[1] << 8) |
2518 (ucontrol
->value
.iec958
.status
[2] << 16) |
2519 (ucontrol
->value
.iec958
.status
[3] << 24);
2520 spin_lock_irq(&trident
->reg_lock
);
2521 change
= trident
->spdif_pcm_bits
!= val
;
2522 trident
->spdif_pcm_bits
= val
;
2523 if (trident
->spdif
!= NULL
) {
2524 if (trident
->device
!= TRIDENT_DEVICE_ID_SI7018
) {
2525 outl(trident
->spdif_pcm_bits
, TRID_REG(trident
, NX_SPCSTATUS
));
2527 outl(trident
->spdif_bits
, TRID_REG(trident
, SI_SPDIF_CS
));
2530 spin_unlock_irq(&trident
->reg_lock
);
2534 static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata
=
2536 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
| SNDRV_CTL_ELEM_ACCESS_INACTIVE
,
2537 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
2538 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,PCM_STREAM
),
2539 .info
= snd_trident_spdif_stream_info
,
2540 .get
= snd_trident_spdif_stream_get
,
2541 .put
= snd_trident_spdif_stream_put
2544 /*---------------------------------------------------------------------------
2545 snd_trident_ac97_control
2547 Description: enable/disable rear path for ac97
2548 ---------------------------------------------------------------------------*/
2550 static int snd_trident_ac97_control_info(struct snd_kcontrol
*kcontrol
,
2551 struct snd_ctl_elem_info
*uinfo
)
2553 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2555 uinfo
->value
.integer
.min
= 0;
2556 uinfo
->value
.integer
.max
= 1;
2560 static int snd_trident_ac97_control_get(struct snd_kcontrol
*kcontrol
,
2561 struct snd_ctl_elem_value
*ucontrol
)
2563 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2566 spin_lock_irq(&trident
->reg_lock
);
2567 val
= trident
->ac97_ctrl
= inl(TRID_REG(trident
, NX_ACR0_AC97_COM_STAT
));
2568 ucontrol
->value
.integer
.value
[0] = (val
& (1 << kcontrol
->private_value
)) ? 1 : 0;
2569 spin_unlock_irq(&trident
->reg_lock
);
2573 static int snd_trident_ac97_control_put(struct snd_kcontrol
*kcontrol
,
2574 struct snd_ctl_elem_value
*ucontrol
)
2576 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2580 spin_lock_irq(&trident
->reg_lock
);
2581 val
= trident
->ac97_ctrl
= inl(TRID_REG(trident
, NX_ACR0_AC97_COM_STAT
));
2582 val
&= ~(1 << kcontrol
->private_value
);
2583 if (ucontrol
->value
.integer
.value
[0])
2584 val
|= 1 << kcontrol
->private_value
;
2585 change
= val
!= trident
->ac97_ctrl
;
2586 trident
->ac97_ctrl
= val
;
2587 outl(trident
->ac97_ctrl
= val
, TRID_REG(trident
, NX_ACR0_AC97_COM_STAT
));
2588 spin_unlock_irq(&trident
->reg_lock
);
2592 static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata
=
2594 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2595 .name
= "Rear Path",
2596 .info
= snd_trident_ac97_control_info
,
2597 .get
= snd_trident_ac97_control_get
,
2598 .put
= snd_trident_ac97_control_put
,
2602 /*---------------------------------------------------------------------------
2603 snd_trident_vol_control
2605 Description: wave & music volume control
2606 ---------------------------------------------------------------------------*/
2608 static int snd_trident_vol_control_info(struct snd_kcontrol
*kcontrol
,
2609 struct snd_ctl_elem_info
*uinfo
)
2611 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2613 uinfo
->value
.integer
.min
= 0;
2614 uinfo
->value
.integer
.max
= 255;
2618 static int snd_trident_vol_control_get(struct snd_kcontrol
*kcontrol
,
2619 struct snd_ctl_elem_value
*ucontrol
)
2621 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2624 val
= trident
->musicvol_wavevol
;
2625 ucontrol
->value
.integer
.value
[0] = 255 - ((val
>> kcontrol
->private_value
) & 0xff);
2626 ucontrol
->value
.integer
.value
[1] = 255 - ((val
>> (kcontrol
->private_value
+ 8)) & 0xff);
2630 static int snd_trident_vol_control_put(struct snd_kcontrol
*kcontrol
,
2631 struct snd_ctl_elem_value
*ucontrol
)
2633 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2637 spin_lock_irq(&trident
->reg_lock
);
2638 val
= trident
->musicvol_wavevol
;
2639 val
&= ~(0xffff << kcontrol
->private_value
);
2640 val
|= ((255 - (ucontrol
->value
.integer
.value
[0] & 0xff)) |
2641 ((255 - (ucontrol
->value
.integer
.value
[1] & 0xff)) << 8)) << kcontrol
->private_value
;
2642 change
= val
!= trident
->musicvol_wavevol
;
2643 outl(trident
->musicvol_wavevol
= val
, TRID_REG(trident
, T4D_MUSICVOL_WAVEVOL
));
2644 spin_unlock_irq(&trident
->reg_lock
);
2648 static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata
=
2650 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2651 .name
= "Music Playback Volume",
2652 .info
= snd_trident_vol_control_info
,
2653 .get
= snd_trident_vol_control_get
,
2654 .put
= snd_trident_vol_control_put
,
2655 .private_value
= 16,
2658 static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata
=
2660 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2661 .name
= "Wave Playback Volume",
2662 .info
= snd_trident_vol_control_info
,
2663 .get
= snd_trident_vol_control_get
,
2664 .put
= snd_trident_vol_control_put
,
2668 /*---------------------------------------------------------------------------
2669 snd_trident_pcm_vol_control
2671 Description: PCM front volume control
2672 ---------------------------------------------------------------------------*/
2674 static int snd_trident_pcm_vol_control_info(struct snd_kcontrol
*kcontrol
,
2675 struct snd_ctl_elem_info
*uinfo
)
2677 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2679 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2681 uinfo
->value
.integer
.min
= 0;
2682 uinfo
->value
.integer
.max
= 255;
2683 if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
)
2684 uinfo
->value
.integer
.max
= 1023;
2688 static int snd_trident_pcm_vol_control_get(struct snd_kcontrol
*kcontrol
,
2689 struct snd_ctl_elem_value
*ucontrol
)
2691 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2692 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[snd_ctl_get_ioffnum(kcontrol
, &ucontrol
->id
)];
2694 if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
) {
2695 ucontrol
->value
.integer
.value
[0] = 1023 - mix
->vol
;
2697 ucontrol
->value
.integer
.value
[0] = 255 - (mix
->vol
>>2);
2702 static int snd_trident_pcm_vol_control_put(struct snd_kcontrol
*kcontrol
,
2703 struct snd_ctl_elem_value
*ucontrol
)
2705 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2706 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[snd_ctl_get_ioffnum(kcontrol
, &ucontrol
->id
)];
2710 if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
) {
2711 val
= 1023 - (ucontrol
->value
.integer
.value
[0] & 1023);
2713 val
= (255 - (ucontrol
->value
.integer
.value
[0] & 255)) << 2;
2715 spin_lock_irq(&trident
->reg_lock
);
2716 change
= val
!= mix
->vol
;
2718 if (mix
->voice
!= NULL
)
2719 snd_trident_write_vol_reg(trident
, mix
->voice
, val
);
2720 spin_unlock_irq(&trident
->reg_lock
);
2724 static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata
=
2726 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2727 .name
= "PCM Front Playback Volume",
2728 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
| SNDRV_CTL_ELEM_ACCESS_INACTIVE
,
2730 .info
= snd_trident_pcm_vol_control_info
,
2731 .get
= snd_trident_pcm_vol_control_get
,
2732 .put
= snd_trident_pcm_vol_control_put
,
2735 /*---------------------------------------------------------------------------
2736 snd_trident_pcm_pan_control
2738 Description: PCM front pan control
2739 ---------------------------------------------------------------------------*/
2741 static int snd_trident_pcm_pan_control_info(struct snd_kcontrol
*kcontrol
,
2742 struct snd_ctl_elem_info
*uinfo
)
2744 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2746 uinfo
->value
.integer
.min
= 0;
2747 uinfo
->value
.integer
.max
= 127;
2751 static int snd_trident_pcm_pan_control_get(struct snd_kcontrol
*kcontrol
,
2752 struct snd_ctl_elem_value
*ucontrol
)
2754 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2755 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[snd_ctl_get_ioffnum(kcontrol
, &ucontrol
->id
)];
2757 ucontrol
->value
.integer
.value
[0] = mix
->pan
;
2758 if (ucontrol
->value
.integer
.value
[0] & 0x40) {
2759 ucontrol
->value
.integer
.value
[0] = (0x3f - (ucontrol
->value
.integer
.value
[0] & 0x3f));
2761 ucontrol
->value
.integer
.value
[0] |= 0x40;
2766 static int snd_trident_pcm_pan_control_put(struct snd_kcontrol
*kcontrol
,
2767 struct snd_ctl_elem_value
*ucontrol
)
2769 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2770 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[snd_ctl_get_ioffnum(kcontrol
, &ucontrol
->id
)];
2774 if (ucontrol
->value
.integer
.value
[0] & 0x40)
2775 val
= ucontrol
->value
.integer
.value
[0] & 0x3f;
2777 val
= (0x3f - (ucontrol
->value
.integer
.value
[0] & 0x3f)) | 0x40;
2778 spin_lock_irq(&trident
->reg_lock
);
2779 change
= val
!= mix
->pan
;
2781 if (mix
->voice
!= NULL
)
2782 snd_trident_write_pan_reg(trident
, mix
->voice
, val
);
2783 spin_unlock_irq(&trident
->reg_lock
);
2787 static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata
=
2789 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2790 .name
= "PCM Pan Playback Control",
2791 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
| SNDRV_CTL_ELEM_ACCESS_INACTIVE
,
2793 .info
= snd_trident_pcm_pan_control_info
,
2794 .get
= snd_trident_pcm_pan_control_get
,
2795 .put
= snd_trident_pcm_pan_control_put
,
2798 /*---------------------------------------------------------------------------
2799 snd_trident_pcm_rvol_control
2801 Description: PCM reverb volume control
2802 ---------------------------------------------------------------------------*/
2804 static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol
*kcontrol
,
2805 struct snd_ctl_elem_info
*uinfo
)
2807 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2809 uinfo
->value
.integer
.min
= 0;
2810 uinfo
->value
.integer
.max
= 127;
2814 static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol
*kcontrol
,
2815 struct snd_ctl_elem_value
*ucontrol
)
2817 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2818 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[snd_ctl_get_ioffnum(kcontrol
, &ucontrol
->id
)];
2820 ucontrol
->value
.integer
.value
[0] = 127 - mix
->rvol
;
2824 static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol
*kcontrol
,
2825 struct snd_ctl_elem_value
*ucontrol
)
2827 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2828 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[snd_ctl_get_ioffnum(kcontrol
, &ucontrol
->id
)];
2832 val
= 0x7f - (ucontrol
->value
.integer
.value
[0] & 0x7f);
2833 spin_lock_irq(&trident
->reg_lock
);
2834 change
= val
!= mix
->rvol
;
2836 if (mix
->voice
!= NULL
)
2837 snd_trident_write_rvol_reg(trident
, mix
->voice
, val
);
2838 spin_unlock_irq(&trident
->reg_lock
);
2842 static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata
=
2844 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2845 .name
= "PCM Reverb Playback Volume",
2846 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
| SNDRV_CTL_ELEM_ACCESS_INACTIVE
,
2848 .info
= snd_trident_pcm_rvol_control_info
,
2849 .get
= snd_trident_pcm_rvol_control_get
,
2850 .put
= snd_trident_pcm_rvol_control_put
,
2853 /*---------------------------------------------------------------------------
2854 snd_trident_pcm_cvol_control
2856 Description: PCM chorus volume control
2857 ---------------------------------------------------------------------------*/
2859 static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol
*kcontrol
,
2860 struct snd_ctl_elem_info
*uinfo
)
2862 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2864 uinfo
->value
.integer
.min
= 0;
2865 uinfo
->value
.integer
.max
= 127;
2869 static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol
*kcontrol
,
2870 struct snd_ctl_elem_value
*ucontrol
)
2872 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2873 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[snd_ctl_get_ioffnum(kcontrol
, &ucontrol
->id
)];
2875 ucontrol
->value
.integer
.value
[0] = 127 - mix
->cvol
;
2879 static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol
*kcontrol
,
2880 struct snd_ctl_elem_value
*ucontrol
)
2882 struct snd_trident
*trident
= snd_kcontrol_chip(kcontrol
);
2883 struct snd_trident_pcm_mixer
*mix
= &trident
->pcm_mixer
[snd_ctl_get_ioffnum(kcontrol
, &ucontrol
->id
)];
2887 val
= 0x7f - (ucontrol
->value
.integer
.value
[0] & 0x7f);
2888 spin_lock_irq(&trident
->reg_lock
);
2889 change
= val
!= mix
->cvol
;
2891 if (mix
->voice
!= NULL
)
2892 snd_trident_write_cvol_reg(trident
, mix
->voice
, val
);
2893 spin_unlock_irq(&trident
->reg_lock
);
2897 static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata
=
2899 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2900 .name
= "PCM Chorus Playback Volume",
2901 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
| SNDRV_CTL_ELEM_ACCESS_INACTIVE
,
2903 .info
= snd_trident_pcm_cvol_control_info
,
2904 .get
= snd_trident_pcm_cvol_control_get
,
2905 .put
= snd_trident_pcm_cvol_control_put
,
2908 static void snd_trident_notify_pcm_change1(struct snd_card
*card
,
2909 struct snd_kcontrol
*kctl
,
2910 int num
, int activate
)
2912 struct snd_ctl_elem_id id
;
2917 kctl
->vd
[num
].access
&= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE
;
2919 kctl
->vd
[num
].access
|= SNDRV_CTL_ELEM_ACCESS_INACTIVE
;
2920 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
|
2921 SNDRV_CTL_EVENT_MASK_INFO
,
2922 snd_ctl_build_ioff(&id
, kctl
, num
));
2925 static void snd_trident_notify_pcm_change(struct snd_trident
*trident
,
2926 struct snd_trident_pcm_mixer
*tmix
,
2927 int num
, int activate
)
2929 snd_trident_notify_pcm_change1(trident
->card
, trident
->ctl_vol
, num
, activate
);
2930 snd_trident_notify_pcm_change1(trident
->card
, trident
->ctl_pan
, num
, activate
);
2931 snd_trident_notify_pcm_change1(trident
->card
, trident
->ctl_rvol
, num
, activate
);
2932 snd_trident_notify_pcm_change1(trident
->card
, trident
->ctl_cvol
, num
, activate
);
2935 static int snd_trident_pcm_mixer_build(struct snd_trident
*trident
,
2936 struct snd_trident_voice
*voice
,
2937 struct snd_pcm_substream
*substream
)
2939 struct snd_trident_pcm_mixer
*tmix
;
2941 snd_assert(trident
!= NULL
&& voice
!= NULL
&& substream
!= NULL
, return -EINVAL
);
2942 tmix
= &trident
->pcm_mixer
[substream
->number
];
2943 tmix
->voice
= voice
;
2944 tmix
->vol
= T4D_DEFAULT_PCM_VOL
;
2945 tmix
->pan
= T4D_DEFAULT_PCM_PAN
;
2946 tmix
->rvol
= T4D_DEFAULT_PCM_RVOL
;
2947 tmix
->cvol
= T4D_DEFAULT_PCM_CVOL
;
2948 snd_trident_notify_pcm_change(trident
, tmix
, substream
->number
, 1);
2952 static int snd_trident_pcm_mixer_free(struct snd_trident
*trident
, struct snd_trident_voice
*voice
, struct snd_pcm_substream
*substream
)
2954 struct snd_trident_pcm_mixer
*tmix
;
2956 snd_assert(trident
!= NULL
&& substream
!= NULL
, return -EINVAL
);
2957 tmix
= &trident
->pcm_mixer
[substream
->number
];
2959 snd_trident_notify_pcm_change(trident
, tmix
, substream
->number
, 0);
2963 /*---------------------------------------------------------------------------
2966 Description: This routine registers the 4DWave device for mixer support.
2968 Paramters: trident - pointer to target device class for 4DWave.
2972 ---------------------------------------------------------------------------*/
2974 static int __devinit
snd_trident_mixer(struct snd_trident
* trident
, int pcm_spdif_device
)
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
,
2986 uctl
= kzalloc(sizeof(*uctl
), GFP_KERNEL
);
2990 if ((err
= snd_ac97_bus(trident
->card
, 0, &ops
, NULL
, &trident
->ac97_bus
)) < 0)
2993 memset(&_ac97
, 0, sizeof(_ac97
));
2994 _ac97
.private_data
= trident
;
2995 trident
->ac97_detect
= 1;
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)
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) {
3013 err
= snd_ac97_mixer(trident
->ac97_bus
, &_ac97
, &trident
->ac97_sec
);
3015 snd_printk(KERN_ERR
"SI7018: the secondary codec - invalid access\n");
3016 #if 0 // only for my testing purpose --jk
3018 struct snd_ac97
*mc97
;
3019 err
= snd_ac97_modem(trident
->card
, &_ac97
, &mc97
);
3021 snd_printk(KERN_ERR
"snd_ac97_modem returned error %i\n", err
);
3026 trident
->ac97_detect
= 0;
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)
3031 kctl
->put(kctl
, uctl
);
3032 if ((err
= snd_ctl_add(card
, kctl
= snd_ctl_new1(&snd_trident_vol_music_control
, trident
))) < 0)
3034 kctl
->put(kctl
, uctl
);
3035 outl(trident
->musicvol_wavevol
= 0x00000000, TRID_REG(trident
, T4D_MUSICVOL_WAVEVOL
));
3037 outl(trident
->musicvol_wavevol
= 0xffff0000, TRID_REG(trident
, T4D_MUSICVOL_WAVEVOL
));
3040 for (idx
= 0; idx
< 32; idx
++) {
3041 struct snd_trident_pcm_mixer
*tmix
;
3043 tmix
= &trident
->pcm_mixer
[idx
];
3046 if ((trident
->ctl_vol
= snd_ctl_new1(&snd_trident_pcm_vol_control
, trident
)) == NULL
)
3048 if ((err
= snd_ctl_add(card
, trident
->ctl_vol
)))
3051 if ((trident
->ctl_pan
= snd_ctl_new1(&snd_trident_pcm_pan_control
, trident
)) == NULL
)
3053 if ((err
= snd_ctl_add(card
, trident
->ctl_pan
)))
3056 if ((trident
->ctl_rvol
= snd_ctl_new1(&snd_trident_pcm_rvol_control
, trident
)) == NULL
)
3058 if ((err
= snd_ctl_add(card
, trident
->ctl_rvol
)))
3061 if ((trident
->ctl_cvol
= snd_ctl_new1(&snd_trident_pcm_cvol_control
, trident
)) == NULL
)
3063 if ((err
= snd_ctl_add(card
, trident
->ctl_cvol
)))
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)
3069 kctl
->put(kctl
, uctl
);
3071 if (trident
->device
== TRIDENT_DEVICE_ID_NX
|| trident
->device
== TRIDENT_DEVICE_ID_SI7018
) {
3073 kctl
= snd_ctl_new1(&snd_trident_spdif_control
, trident
);
3078 if (trident
->ac97
->ext_id
& AC97_EI_SPDIF
)
3080 if (trident
->ac97_sec
&& (trident
->ac97_sec
->ext_id
& AC97_EI_SPDIF
))
3082 idx
= kctl
->id
.index
;
3083 if ((err
= snd_ctl_add(card
, kctl
)) < 0)
3085 kctl
->put(kctl
, uctl
);
3087 kctl
= snd_ctl_new1(&snd_trident_spdif_default
, trident
);
3092 kctl
->id
.index
= idx
;
3093 kctl
->id
.device
= pcm_spdif_device
;
3094 if ((err
= snd_ctl_add(card
, kctl
)) < 0)
3097 kctl
= snd_ctl_new1(&snd_trident_spdif_mask
, trident
);
3102 kctl
->id
.index
= idx
;
3103 kctl
->id
.device
= pcm_spdif_device
;
3104 if ((err
= snd_ctl_add(card
, kctl
)) < 0)
3107 kctl
= snd_ctl_new1(&snd_trident_spdif_stream
, trident
);
3112 kctl
->id
.index
= idx
;
3113 kctl
->id
.device
= pcm_spdif_device
;
3114 if ((err
= snd_ctl_add(card
, kctl
)) < 0)
3116 trident
->spdif_pcm_ctl
= kctl
;
3132 * gameport interface
3135 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
3137 static unsigned char snd_trident_gameport_read(struct gameport
*gameport
)
3139 struct snd_trident
*chip
= gameport_get_port_data(gameport
);
3141 snd_assert(chip
, return 0);
3142 return inb(TRID_REG(chip
, GAMEPORT_LEGACY
));
3145 static void snd_trident_gameport_trigger(struct gameport
*gameport
)
3147 struct snd_trident
*chip
= gameport_get_port_data(gameport
);
3149 snd_assert(chip
, return);
3150 outb(0xff, TRID_REG(chip
, GAMEPORT_LEGACY
));
3153 static int snd_trident_gameport_cooked_read(struct gameport
*gameport
, int *axes
, int *buttons
)
3155 struct snd_trident
*chip
= gameport_get_port_data(gameport
);
3158 snd_assert(chip
, return 0);
3160 *buttons
= (~inb(TRID_REG(chip
, GAMEPORT_LEGACY
)) >> 4) & 0xf;
3162 for (i
= 0; i
< 4; i
++) {
3163 axes
[i
] = inw(TRID_REG(chip
, GAMEPORT_AXES
+ i
* 2));
3164 if (axes
[i
] == 0xffff) axes
[i
] = -1;
3170 static int snd_trident_gameport_open(struct gameport
*gameport
, int mode
)
3172 struct snd_trident
*chip
= gameport_get_port_data(gameport
);
3174 snd_assert(chip
, return 0);
3177 case GAMEPORT_MODE_COOKED
:
3178 outb(GAMEPORT_MODE_ADC
, TRID_REG(chip
, GAMEPORT_GCR
));
3181 case GAMEPORT_MODE_RAW
:
3182 outb(0, TRID_REG(chip
, GAMEPORT_GCR
));
3189 int __devinit
snd_trident_create_gameport(struct snd_trident
*chip
)
3191 struct gameport
*gp
;
3193 chip
->gameport
= gp
= gameport_allocate_port();
3195 printk(KERN_ERR
"trident: cannot allocate memory for gameport\n");
3199 gameport_set_name(gp
, "Trident 4DWave");
3200 gameport_set_phys(gp
, "pci%s/gameport0", pci_name(chip
->pci
));
3201 gameport_set_dev_parent(gp
, &chip
->pci
->dev
);
3203 gameport_set_port_data(gp
, chip
);
3205 gp
->read
= snd_trident_gameport_read
;
3206 gp
->trigger
= snd_trident_gameport_trigger
;
3207 gp
->cooked_read
= snd_trident_gameport_cooked_read
;
3208 gp
->open
= snd_trident_gameport_open
;
3210 gameport_register_port(gp
);
3215 static inline void snd_trident_free_gameport(struct snd_trident
*chip
)
3217 if (chip
->gameport
) {
3218 gameport_unregister_port(chip
->gameport
);
3219 chip
->gameport
= NULL
;
3223 int __devinit
snd_trident_create_gameport(struct snd_trident
*chip
) { return -ENOSYS
; }
3224 static inline void snd_trident_free_gameport(struct snd_trident
*chip
) { }
3225 #endif /* CONFIG_GAMEPORT */
3230 static inline void do_delay(struct snd_trident
*chip
)
3232 schedule_timeout_uninterruptible(1);
3239 static int snd_trident_sis_reset(struct snd_trident
*trident
)
3241 unsigned long end_time
;
3245 r
= trident
->in_suspend
? 0 : 2; /* count of retries */
3247 pci_write_config_byte(trident
->pci
, 0x46, 0x04); /* SOFTWARE RESET */
3249 pci_write_config_byte(trident
->pci
, 0x46, 0x00);
3251 /* disable AC97 GPIO interrupt */
3252 outb(0x00, TRID_REG(trident
, SI_AC97_GPIO
));
3253 /* initialize serial interface, force cold reset */
3254 i
= PCMOUT
|SURROUT
|CENTEROUT
|LFEOUT
|SECONDARY_ID
|COLD_RESET
;
3255 outl(i
, TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
3257 /* remove cold reset */
3259 outl(i
, TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
3261 /* wait, until the codec is ready */
3262 end_time
= (jiffies
+ (HZ
* 3) / 4) + 1;
3264 if ((inl(TRID_REG(trident
, SI_SERIAL_INTF_CTRL
)) & SI_AC97_PRIMARY_READY
) != 0)
3267 } while (time_after_eq(end_time
, jiffies
));
3268 snd_printk(KERN_ERR
"AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident
, SI_SERIAL_INTF_CTRL
)));
3270 end_time
= jiffies
+ HZ
;
3273 } while (time_after_eq(end_time
, jiffies
));
3274 goto __si7018_retry
;
3277 /* wait for the second codec */
3279 if ((inl(TRID_REG(trident
, SI_SERIAL_INTF_CTRL
)) & SI_AC97_SECONDARY_READY
) != 0)
3282 } while (time_after_eq(end_time
, jiffies
));
3283 /* enable 64 channel mode */
3284 outl(BANK_B_EN
, TRID_REG(trident
, T4D_LFO_GC_CIR
));
3292 static void snd_trident_proc_read(struct snd_info_entry
*entry
,
3293 struct snd_info_buffer
*buffer
)
3295 struct snd_trident
*trident
= entry
->private_data
;
3298 switch (trident
->device
) {
3299 case TRIDENT_DEVICE_ID_SI7018
:
3300 s
= "SiS 7018 Audio";
3302 case TRIDENT_DEVICE_ID_DX
:
3303 s
= "Trident 4DWave PCI DX";
3305 case TRIDENT_DEVICE_ID_NX
:
3306 s
= "Trident 4DWave PCI NX";
3311 snd_iprintf(buffer
, "%s\n\n", s
);
3312 snd_iprintf(buffer
, "Spurious IRQs : %d\n", trident
->spurious_irq_count
);
3313 snd_iprintf(buffer
, "Spurious IRQ dlta: %d\n", trident
->spurious_irq_max_delta
);
3314 if (trident
->device
== TRIDENT_DEVICE_ID_NX
|| trident
->device
== TRIDENT_DEVICE_ID_SI7018
)
3315 snd_iprintf(buffer
, "IEC958 Mixer Out : %s\n", trident
->spdif_ctrl
== 0x28 ? "on" : "off");
3316 if (trident
->device
== TRIDENT_DEVICE_ID_NX
) {
3317 snd_iprintf(buffer
, "Rear Speakers : %s\n", trident
->ac97_ctrl
& 0x00000010 ? "on" : "off");
3318 if (trident
->tlb
.entries
) {
3319 snd_iprintf(buffer
,"\nVirtual Memory\n");
3320 snd_iprintf(buffer
, "Memory Maximum : %d\n", trident
->tlb
.memhdr
->size
);
3321 snd_iprintf(buffer
, "Memory Used : %d\n", trident
->tlb
.memhdr
->used
);
3322 snd_iprintf(buffer
, "Memory Free : %d\n", snd_util_mem_avail(trident
->tlb
.memhdr
));
3325 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
3326 snd_iprintf(buffer
,"\nWavetable Synth\n");
3327 snd_iprintf(buffer
, "Memory Maximum : %d\n", trident
->synth
.max_size
);
3328 snd_iprintf(buffer
, "Memory Used : %d\n", trident
->synth
.current_size
);
3329 snd_iprintf(buffer
, "Memory Free : %d\n", (trident
->synth
.max_size
-trident
->synth
.current_size
));
3333 static void __devinit
snd_trident_proc_init(struct snd_trident
* trident
)
3335 struct snd_info_entry
*entry
;
3336 const char *s
= "trident";
3338 if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
)
3340 if (! snd_card_proc_new(trident
->card
, s
, &entry
))
3341 snd_info_set_text_ops(entry
, trident
, snd_trident_proc_read
);
3344 static int snd_trident_dev_free(struct snd_device
*device
)
3346 struct snd_trident
*trident
= device
->device_data
;
3347 return snd_trident_free(trident
);
3350 /*---------------------------------------------------------------------------
3351 snd_trident_tlb_alloc
3353 Description: Allocate and set up the TLB page table on 4D NX.
3354 Each entry has 4 bytes (physical PCI address).
3356 Paramters: trident - pointer to target device class for 4DWave.
3358 Returns: 0 or negative error code
3360 ---------------------------------------------------------------------------*/
3362 static int __devinit
snd_trident_tlb_alloc(struct snd_trident
*trident
)
3366 /* TLB array must be aligned to 16kB !!! so we allocate
3367 32kB region and correct offset when necessary */
3369 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(trident
->pci
),
3370 2 * SNDRV_TRIDENT_MAX_PAGES
* 4, &trident
->tlb
.buffer
) < 0) {
3371 snd_printk(KERN_ERR
"trident: unable to allocate TLB buffer\n");
3374 trident
->tlb
.entries
= (unsigned int*)(((unsigned long)trident
->tlb
.buffer
.area
+ SNDRV_TRIDENT_MAX_PAGES
* 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES
* 4 - 1));
3375 trident
->tlb
.entries_dmaaddr
= (trident
->tlb
.buffer
.addr
+ SNDRV_TRIDENT_MAX_PAGES
* 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES
* 4 - 1);
3376 /* allocate shadow TLB page table (virtual addresses) */
3377 trident
->tlb
.shadow_entries
= vmalloc(SNDRV_TRIDENT_MAX_PAGES
*sizeof(unsigned long));
3378 if (trident
->tlb
.shadow_entries
== NULL
) {
3379 snd_printk(KERN_ERR
"trident: unable to allocate shadow TLB entries\n");
3382 /* allocate and setup silent page and initialise TLB entries */
3383 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(trident
->pci
),
3384 SNDRV_TRIDENT_PAGE_SIZE
, &trident
->tlb
.silent_page
) < 0) {
3385 snd_printk(KERN_ERR
"trident: unable to allocate silent page\n");
3388 memset(trident
->tlb
.silent_page
.area
, 0, SNDRV_TRIDENT_PAGE_SIZE
);
3389 for (i
= 0; i
< SNDRV_TRIDENT_MAX_PAGES
; i
++) {
3390 trident
->tlb
.entries
[i
] = cpu_to_le32(trident
->tlb
.silent_page
.addr
& ~(SNDRV_TRIDENT_PAGE_SIZE
-1));
3391 trident
->tlb
.shadow_entries
[i
] = (unsigned long)trident
->tlb
.silent_page
.area
;
3394 /* use emu memory block manager code to manage tlb page allocation */
3395 trident
->tlb
.memhdr
= snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE
* SNDRV_TRIDENT_MAX_PAGES
);
3396 if (trident
->tlb
.memhdr
== NULL
)
3399 trident
->tlb
.memhdr
->block_extra_size
= sizeof(struct snd_trident_memblk_arg
);
3404 * initialize 4D DX chip
3407 static void snd_trident_stop_all_voices(struct snd_trident
*trident
)
3409 outl(0xffffffff, TRID_REG(trident
, T4D_STOP_A
));
3410 outl(0xffffffff, TRID_REG(trident
, T4D_STOP_B
));
3411 outl(0, TRID_REG(trident
, T4D_AINTEN_A
));
3412 outl(0, TRID_REG(trident
, T4D_AINTEN_B
));
3415 static int snd_trident_4d_dx_init(struct snd_trident
*trident
)
3417 struct pci_dev
*pci
= trident
->pci
;
3418 unsigned long end_time
;
3420 /* reset the legacy configuration and whole audio/wavetable block */
3421 pci_write_config_dword(pci
, 0x40, 0); /* DDMA */
3422 pci_write_config_byte(pci
, 0x44, 0); /* ports */
3423 pci_write_config_byte(pci
, 0x45, 0); /* Legacy DMA */
3424 pci_write_config_byte(pci
, 0x46, 4); /* reset */
3426 pci_write_config_byte(pci
, 0x46, 0); /* release reset */
3429 /* warm reset of the AC'97 codec */
3430 outl(0x00000001, TRID_REG(trident
, DX_ACR2_AC97_COM_STAT
));
3432 outl(0x00000000, TRID_REG(trident
, DX_ACR2_AC97_COM_STAT
));
3433 /* DAC on, disable SB IRQ and try to force ADC valid signal */
3434 trident
->ac97_ctrl
= 0x0000004a;
3435 outl(trident
->ac97_ctrl
, TRID_REG(trident
, DX_ACR2_AC97_COM_STAT
));
3436 /* wait, until the codec is ready */
3437 end_time
= (jiffies
+ (HZ
* 3) / 4) + 1;
3439 if ((inl(TRID_REG(trident
, DX_ACR2_AC97_COM_STAT
)) & 0x0010) != 0)
3442 } while (time_after_eq(end_time
, jiffies
));
3443 snd_printk(KERN_ERR
"AC'97 codec ready error\n");
3447 snd_trident_stop_all_voices(trident
);
3453 * initialize 4D NX chip
3455 static int snd_trident_4d_nx_init(struct snd_trident
*trident
)
3457 struct pci_dev
*pci
= trident
->pci
;
3458 unsigned long end_time
;
3460 /* reset the legacy configuration and whole audio/wavetable block */
3461 pci_write_config_dword(pci
, 0x40, 0); /* DDMA */
3462 pci_write_config_byte(pci
, 0x44, 0); /* ports */
3463 pci_write_config_byte(pci
, 0x45, 0); /* Legacy DMA */
3465 pci_write_config_byte(pci
, 0x46, 1); /* reset */
3467 pci_write_config_byte(pci
, 0x46, 0); /* release reset */
3470 /* warm reset of the AC'97 codec */
3471 outl(0x00000001, TRID_REG(trident
, NX_ACR0_AC97_COM_STAT
));
3473 outl(0x00000000, TRID_REG(trident
, NX_ACR0_AC97_COM_STAT
));
3474 /* wait, until the codec is ready */
3475 end_time
= (jiffies
+ (HZ
* 3) / 4) + 1;
3477 if ((inl(TRID_REG(trident
, NX_ACR0_AC97_COM_STAT
)) & 0x0008) != 0)
3480 } while (time_after_eq(end_time
, jiffies
));
3481 snd_printk(KERN_ERR
"AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident
, NX_ACR0_AC97_COM_STAT
)));
3486 trident
->ac97_ctrl
= 0x00000002;
3487 outl(trident
->ac97_ctrl
, TRID_REG(trident
, NX_ACR0_AC97_COM_STAT
));
3488 /* disable SB IRQ */
3489 outl(NX_SB_IRQ_DISABLE
, TRID_REG(trident
, T4D_MISCINT
));
3491 snd_trident_stop_all_voices(trident
);
3493 if (trident
->tlb
.entries
!= NULL
) {
3495 /* enable virtual addressing via TLB */
3496 i
= trident
->tlb
.entries_dmaaddr
;
3498 outl(i
, TRID_REG(trident
, NX_TLBC
));
3500 outl(0, TRID_REG(trident
, NX_TLBC
));
3502 /* initialize S/PDIF */
3503 outl(trident
->spdif_bits
, TRID_REG(trident
, NX_SPCSTATUS
));
3504 outb(trident
->spdif_ctrl
, TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 3));
3510 * initialize sis7018 chip
3512 static int snd_trident_sis_init(struct snd_trident
*trident
)
3516 if ((err
= snd_trident_sis_reset(trident
)) < 0)
3519 snd_trident_stop_all_voices(trident
);
3521 /* initialize S/PDIF */
3522 outl(trident
->spdif_bits
, TRID_REG(trident
, SI_SPDIF_CS
));
3527 /*---------------------------------------------------------------------------
3530 Description: This routine will create the device specific class for
3531 the 4DWave card. It will also perform basic initialization.
3533 Paramters: card - which card to create
3534 pci - interface to PCI bus resource info
3535 dma1ptr - playback dma buffer
3536 dma2ptr - capture dma buffer
3537 irqptr - interrupt resource info
3539 Returns: 4DWave device class private data
3541 ---------------------------------------------------------------------------*/
3543 int __devinit
snd_trident_create(struct snd_card
*card
,
3544 struct pci_dev
*pci
,
3546 int pcm_spdif_device
,
3547 int max_wavetable_size
,
3548 struct snd_trident
** rtrident
)
3550 struct snd_trident
*trident
;
3552 struct snd_trident_voice
*voice
;
3553 struct snd_trident_pcm_mixer
*tmix
;
3554 static struct snd_device_ops ops
= {
3555 .dev_free
= snd_trident_dev_free
,
3560 /* enable PCI device */
3561 if ((err
= pci_enable_device(pci
)) < 0)
3563 /* check, if we can restrict PCI DMA transfers to 30 bits */
3564 if (pci_set_dma_mask(pci
, DMA_30BIT_MASK
) < 0 ||
3565 pci_set_consistent_dma_mask(pci
, DMA_30BIT_MASK
) < 0) {
3566 snd_printk(KERN_ERR
"architecture does not support 30bit PCI busmaster DMA\n");
3567 pci_disable_device(pci
);
3571 trident
= kzalloc(sizeof(*trident
), GFP_KERNEL
);
3572 if (trident
== NULL
) {
3573 pci_disable_device(pci
);
3576 trident
->device
= (pci
->vendor
<< 16) | pci
->device
;
3577 trident
->card
= card
;
3579 spin_lock_init(&trident
->reg_lock
);
3580 spin_lock_init(&trident
->event_lock
);
3581 spin_lock_init(&trident
->voice_alloc
);
3582 if (pcm_streams
< 1)
3584 if (pcm_streams
> 32)
3586 trident
->ChanPCM
= pcm_streams
;
3587 if (max_wavetable_size
< 0 )
3588 max_wavetable_size
= 0;
3589 trident
->synth
.max_size
= max_wavetable_size
* 1024;
3592 trident
->midi_port
= TRID_REG(trident
, T4D_MPU401_BASE
);
3593 pci_set_master(pci
);
3595 if ((err
= pci_request_regions(pci
, "Trident Audio")) < 0) {
3597 pci_disable_device(pci
);
3600 trident
->port
= pci_resource_start(pci
, 0);
3602 if (request_irq(pci
->irq
, snd_trident_interrupt
, SA_INTERRUPT
|SA_SHIRQ
,
3603 "Trident Audio", trident
)) {
3604 snd_printk(KERN_ERR
"unable to grab IRQ %d\n", pci
->irq
);
3605 snd_trident_free(trident
);
3608 trident
->irq
= pci
->irq
;
3610 /* allocate 16k-aligned TLB for NX cards */
3611 trident
->tlb
.entries
= NULL
;
3612 trident
->tlb
.buffer
.area
= NULL
;
3613 if (trident
->device
== TRIDENT_DEVICE_ID_NX
) {
3614 if ((err
= snd_trident_tlb_alloc(trident
)) < 0) {
3615 snd_trident_free(trident
);
3620 trident
->spdif_bits
= trident
->spdif_pcm_bits
= SNDRV_PCM_DEFAULT_CON_SPDIF
;
3622 /* initialize chip */
3623 switch (trident
->device
) {
3624 case TRIDENT_DEVICE_ID_DX
:
3625 err
= snd_trident_4d_dx_init(trident
);
3627 case TRIDENT_DEVICE_ID_NX
:
3628 err
= snd_trident_4d_nx_init(trident
);
3630 case TRIDENT_DEVICE_ID_SI7018
:
3631 err
= snd_trident_sis_init(trident
);
3638 snd_trident_free(trident
);
3642 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, trident
, &ops
)) < 0) {
3643 snd_trident_free(trident
);
3647 if ((err
= snd_trident_mixer(trident
, pcm_spdif_device
)) < 0)
3650 /* initialise synth voices */
3651 for (i
= 0; i
< 64; i
++) {
3652 voice
= &trident
->synth
.voices
[i
];
3654 voice
->trident
= trident
;
3656 /* initialize pcm mixer entries */
3657 for (i
= 0; i
< 32; i
++) {
3658 tmix
= &trident
->pcm_mixer
[i
];
3659 tmix
->vol
= T4D_DEFAULT_PCM_VOL
;
3660 tmix
->pan
= T4D_DEFAULT_PCM_PAN
;
3661 tmix
->rvol
= T4D_DEFAULT_PCM_RVOL
;
3662 tmix
->cvol
= T4D_DEFAULT_PCM_CVOL
;
3665 snd_trident_enable_eso(trident
);
3667 snd_trident_proc_init(trident
);
3668 snd_card_set_dev(card
, &pci
->dev
);
3669 *rtrident
= trident
;
3673 /*---------------------------------------------------------------------------
3676 Description: This routine will free the device specific class for
3679 Paramters: trident - device specific private data for 4DWave card
3683 ---------------------------------------------------------------------------*/
3685 static int snd_trident_free(struct snd_trident
*trident
)
3687 snd_trident_free_gameport(trident
);
3688 snd_trident_disable_eso(trident
);
3689 // Disable S/PDIF out
3690 if (trident
->device
== TRIDENT_DEVICE_ID_NX
)
3691 outb(0x00, TRID_REG(trident
, NX_SPCTRL_SPCSO
+ 3));
3692 else if (trident
->device
== TRIDENT_DEVICE_ID_SI7018
) {
3693 outl(0, TRID_REG(trident
, SI_SERIAL_INTF_CTRL
));
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
);
3704 if (trident
->irq
>= 0)
3705 free_irq(trident
->irq
, trident
);
3706 pci_release_regions(trident
->pci
);
3707 pci_disable_device(trident
->pci
);
3712 /*---------------------------------------------------------------------------
3713 snd_trident_interrupt
3715 Description: ISR for Trident 4DWave device
3717 Paramters: trident - device specific private data for 4DWave card
3719 Problems: It seems that Trident chips generates interrupts more than
3720 one time in special cases. The spurious interrupts are
3721 detected via sample timer (T4D_STIMER) and computing
3722 corresponding delta value. The limits are detected with
3723 the method try & fail so it is possible that it won't
3724 work on all computers. [jaroslav]
3728 ---------------------------------------------------------------------------*/
3730 static irqreturn_t
snd_trident_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
3732 struct snd_trident
*trident
= dev_id
;
3733 unsigned int audio_int
, chn_int
, stimer
, channel
, mask
, tmp
;
3735 struct snd_trident_voice
*voice
;
3737 audio_int
= inl(TRID_REG(trident
, T4D_MISCINT
));
3738 if ((audio_int
& (ADDRESS_IRQ
|MPU401_IRQ
)) == 0)
3740 if (audio_int
& ADDRESS_IRQ
) {
3741 // get interrupt status for all channels
3742 spin_lock(&trident
->reg_lock
);
3743 stimer
= inl(TRID_REG(trident
, T4D_STIMER
)) & 0x00ffffff;
3744 chn_int
= inl(TRID_REG(trident
, T4D_AINT_A
));
3747 outl(chn_int
, TRID_REG(trident
, T4D_AINT_A
)); /* ack */
3749 chn_int
= inl(TRID_REG(trident
, T4D_AINT_B
));
3752 for (channel
= 63; channel
>= 32; channel
--) {
3753 mask
= 1 << (channel
&0x1f);
3754 if ((chn_int
& mask
) == 0)
3756 voice
= &trident
->synth
.voices
[channel
];
3757 if (!voice
->pcm
|| voice
->substream
== NULL
) {
3758 outl(mask
, TRID_REG(trident
, T4D_STOP_B
));
3761 delta
= (int)stimer
- (int)voice
->stimer
;
3764 if ((unsigned int)delta
< voice
->spurious_threshold
) {
3765 /* do some statistics here */
3766 trident
->spurious_irq_count
++;
3767 if (trident
->spurious_irq_max_delta
< (unsigned int)delta
)
3768 trident
->spurious_irq_max_delta
= delta
;
3771 voice
->stimer
= stimer
;
3773 if (!voice
->isync3
) {
3774 tmp
= inw(TRID_REG(trident
, T4D_SBBL_SBCL
));
3775 if (trident
->bDMAStart
& 0x40)
3778 tmp
= voice
->isync_max
- tmp
;
3780 tmp
= inl(TRID_REG(trident
, NX_SPCTRL_SPCSO
)) & 0x00ffffff;
3782 if (tmp
< voice
->isync_mark
) {
3784 tmp
= voice
->isync_ESO
- 7;
3786 tmp
= voice
->isync_ESO
+ 2;
3787 /* update ESO for IRQ voice to preserve sync */
3788 snd_trident_stop_voice(trident
, voice
->number
);
3789 snd_trident_write_eso_reg(trident
, voice
, tmp
);
3790 snd_trident_start_voice(trident
, voice
->number
);
3792 } else if (voice
->isync2
) {
3794 /* write original ESO and update CSO for IRQ voice to preserve sync */
3795 snd_trident_stop_voice(trident
, voice
->number
);
3796 snd_trident_write_cso_reg(trident
, voice
, voice
->isync_mark
);
3797 snd_trident_write_eso_reg(trident
, voice
, voice
->ESO
);
3798 snd_trident_start_voice(trident
, voice
->number
);
3802 /* update CSO for extra voice to preserve sync */
3803 snd_trident_stop_voice(trident
, voice
->extra
->number
);
3804 snd_trident_write_cso_reg(trident
, voice
->extra
, 0);
3805 snd_trident_start_voice(trident
, voice
->extra
->number
);
3808 spin_unlock(&trident
->reg_lock
);
3809 snd_pcm_period_elapsed(voice
->substream
);
3810 spin_lock(&trident
->reg_lock
);
3812 outl(chn_int
, TRID_REG(trident
, T4D_AINT_B
)); /* ack */
3814 spin_unlock(&trident
->reg_lock
);
3816 if (audio_int
& MPU401_IRQ
) {
3817 if (trident
->rmidi
) {
3818 snd_mpu401_uart_interrupt(irq
, trident
->rmidi
->private_data
, regs
);
3820 inb(TRID_REG(trident
, T4D_MPUR0
));
3823 // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
3827 /*---------------------------------------------------------------------------
3828 snd_trident_attach_synthesizer
3830 Description: Attach synthesizer hooks
3832 Paramters: trident - device specific private data for 4DWave card
3836 ---------------------------------------------------------------------------*/
3837 int snd_trident_attach_synthesizer(struct snd_trident
*trident
)
3839 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
3840 if (snd_seq_device_new(trident
->card
, 1, SNDRV_SEQ_DEV_ID_TRIDENT
,
3841 sizeof(struct snd_trident
*), &trident
->seq_dev
) >= 0) {
3842 strcpy(trident
->seq_dev
->name
, "4DWave");
3843 *(struct snd_trident
**)SNDRV_SEQ_DEVICE_ARGPTR(trident
->seq_dev
) = trident
;
3849 struct snd_trident_voice
*snd_trident_alloc_voice(struct snd_trident
* trident
, int type
, int client
, int port
)
3851 struct snd_trident_voice
*pvoice
;
3852 unsigned long flags
;
3855 spin_lock_irqsave(&trident
->voice_alloc
, flags
);
3856 if (type
== SNDRV_TRIDENT_VOICE_TYPE_PCM
) {
3857 idx
= snd_trident_allocate_pcm_channel(trident
);
3859 spin_unlock_irqrestore(&trident
->voice_alloc
, flags
);
3862 pvoice
= &trident
->synth
.voices
[idx
];
3865 pvoice
->capture
= 0;
3867 pvoice
->memblk
= NULL
;
3868 pvoice
->substream
= NULL
;
3869 spin_unlock_irqrestore(&trident
->voice_alloc
, flags
);
3872 if (type
== SNDRV_TRIDENT_VOICE_TYPE_SYNTH
) {
3873 idx
= snd_trident_allocate_synth_channel(trident
);
3875 spin_unlock_irqrestore(&trident
->voice_alloc
, flags
);
3878 pvoice
= &trident
->synth
.voices
[idx
];
3881 pvoice
->client
= client
;
3882 pvoice
->port
= port
;
3883 pvoice
->memblk
= NULL
;
3884 spin_unlock_irqrestore(&trident
->voice_alloc
, flags
);
3887 if (type
== SNDRV_TRIDENT_VOICE_TYPE_MIDI
) {
3889 spin_unlock_irqrestore(&trident
->voice_alloc
, flags
);
3893 EXPORT_SYMBOL(snd_trident_alloc_voice
);
3895 void snd_trident_free_voice(struct snd_trident
* trident
, struct snd_trident_voice
*voice
)
3897 unsigned long flags
;
3898 void (*private_free
)(struct snd_trident_voice
*);
3901 if (voice
== NULL
|| !voice
->use
)
3903 snd_trident_clear_voices(trident
, voice
->number
, voice
->number
);
3904 spin_lock_irqsave(&trident
->voice_alloc
, flags
);
3905 private_free
= voice
->private_free
;
3906 private_data
= voice
->private_data
;
3907 voice
->private_free
= NULL
;
3908 voice
->private_data
= NULL
;
3910 snd_trident_free_pcm_channel(trident
, voice
->number
);
3912 snd_trident_free_synth_channel(trident
, voice
->number
);
3913 voice
->use
= voice
->pcm
= voice
->synth
= voice
->midi
= 0;
3914 voice
->capture
= voice
->spdif
= 0;
3915 voice
->sample_ops
= NULL
;
3916 voice
->substream
= NULL
;
3917 voice
->extra
= NULL
;
3918 spin_unlock_irqrestore(&trident
->voice_alloc
, flags
);
3920 private_free(voice
);
3923 EXPORT_SYMBOL(snd_trident_free_voice
);
3925 static void snd_trident_clear_voices(struct snd_trident
* trident
, unsigned short v_min
, unsigned short v_max
)
3927 unsigned int i
, val
, mask
[2] = { 0, 0 };
3929 snd_assert(v_min
<= 63, return);
3930 snd_assert(v_max
<= 63, return);
3931 for (i
= v_min
; i
<= v_max
; i
++)
3932 mask
[i
>> 5] |= 1 << (i
& 0x1f);
3934 outl(mask
[0], TRID_REG(trident
, T4D_STOP_A
));
3935 val
= inl(TRID_REG(trident
, T4D_AINTEN_A
));
3936 outl(val
& ~mask
[0], TRID_REG(trident
, T4D_AINTEN_A
));
3939 outl(mask
[1], TRID_REG(trident
, T4D_STOP_B
));
3940 val
= inl(TRID_REG(trident
, T4D_AINTEN_B
));
3941 outl(val
& ~mask
[1], TRID_REG(trident
, T4D_AINTEN_B
));
3946 int snd_trident_suspend(struct pci_dev
*pci
, pm_message_t state
)
3948 struct snd_card
*card
= pci_get_drvdata(pci
);
3949 struct snd_trident
*trident
= card
->private_data
;
3951 trident
->in_suspend
= 1;
3952 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
3953 snd_pcm_suspend_all(trident
->pcm
);
3954 snd_pcm_suspend_all(trident
->foldback
);
3955 snd_pcm_suspend_all(trident
->spdif
);
3957 snd_ac97_suspend(trident
->ac97
);
3958 snd_ac97_suspend(trident
->ac97_sec
);
3960 switch (trident
->device
) {
3961 case TRIDENT_DEVICE_ID_DX
:
3962 case TRIDENT_DEVICE_ID_NX
:
3964 case TRIDENT_DEVICE_ID_SI7018
:
3967 pci_disable_device(pci
);
3968 pci_save_state(pci
);
3972 int snd_trident_resume(struct pci_dev
*pci
)
3974 struct snd_card
*card
= pci_get_drvdata(pci
);
3975 struct snd_trident
*trident
= card
->private_data
;
3977 pci_restore_state(pci
);
3978 pci_enable_device(pci
);
3979 pci_set_master(pci
); /* to be sure */
3981 switch (trident
->device
) {
3982 case TRIDENT_DEVICE_ID_DX
:
3983 snd_trident_4d_dx_init(trident
);
3985 case TRIDENT_DEVICE_ID_NX
:
3986 snd_trident_4d_nx_init(trident
);
3988 case TRIDENT_DEVICE_ID_SI7018
:
3989 snd_trident_sis_init(trident
);
3993 snd_ac97_resume(trident
->ac97
);
3994 snd_ac97_resume(trident
->ac97_sec
);
3996 /* restore some registers */
3997 outl(trident
->musicvol_wavevol
, TRID_REG(trident
, T4D_MUSICVOL_WAVEVOL
));
3999 snd_trident_enable_eso(trident
);
4001 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
4002 trident
->in_suspend
= 0;
4005 #endif /* CONFIG_PM */