1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Maintained by Jaroslav Kysela <perex@perex.cz>
4 * Originated by audio@tridentmicro.com
5 * Fri Feb 19 15:55:28 MST 1999
6 * Routines for control of Trident 4DWave (DX and NX) chip
13 * SiS7018 S/PDIF support by Thomas Winischhofer <thomas@winischhofer.net>
16 #include <linux/delay.h>
17 #include <linux/init.h>
18 #include <linux/interrupt.h>
19 #include <linux/pci.h>
20 #include <linux/slab.h>
21 #include <linux/vmalloc.h>
22 #include <linux/gameport.h>
23 #include <linux/dma-mapping.h>
24 #include <linux/export.h>
27 #include <sound/core.h>
28 #include <sound/info.h>
29 #include <sound/control.h>
30 #include <sound/tlv.h>
32 #include <sound/asoundef.h>
34 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
35 struct snd_trident_voice * voice,
36 struct snd_pcm_substream *substream);
37 static int snd_trident_pcm_mixer_free(struct snd_trident *trident,
38 struct snd_trident_voice * voice,
39 struct snd_pcm_substream *substream);
40 static irqreturn_t snd_trident_interrupt(int irq, void *dev_id);
41 static int snd_trident_sis_reset(struct snd_trident *trident);
43 static void snd_trident_clear_voices(struct snd_trident * trident,
44 unsigned short v_min, unsigned short v_max);
45 static int snd_trident_free(struct snd_trident *trident);
53 static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)
55 unsigned int val, tmp;
57 dev_dbg(trident->card->dev, "Trident voice %i:\n", voice);
58 outb(voice, TRID_REG(trident, T4D_LFO_GC_CIR));
59 val = inl(TRID_REG(trident, CH_LBA));
60 dev_dbg(trident->card->dev, "LBA: 0x%x\n", val);
61 val = inl(TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
62 dev_dbg(trident->card->dev, "GVSel: %i\n", val >> 31);
63 dev_dbg(trident->card->dev, "Pan: 0x%x\n", (val >> 24) & 0x7f);
64 dev_dbg(trident->card->dev, "Vol: 0x%x\n", (val >> 16) & 0xff);
65 dev_dbg(trident->card->dev, "CTRL: 0x%x\n", (val >> 12) & 0x0f);
66 dev_dbg(trident->card->dev, "EC: 0x%x\n", val & 0x0fff);
67 if (trident->device != TRIDENT_DEVICE_ID_NX) {
68 val = inl(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS));
69 dev_dbg(trident->card->dev, "CSO: 0x%x\n", val >> 16);
70 dev_dbg(trident->card->dev, "Alpha: 0x%x\n", (val >> 4) & 0x0fff);
71 dev_dbg(trident->card->dev, "FMS: 0x%x\n", val & 0x0f);
72 val = inl(TRID_REG(trident, CH_DX_ESO_DELTA));
73 dev_dbg(trident->card->dev, "ESO: 0x%x\n", val >> 16);
74 dev_dbg(trident->card->dev, "Delta: 0x%x\n", val & 0xffff);
75 val = inl(TRID_REG(trident, CH_DX_FMC_RVOL_CVOL));
76 } else { // TRIDENT_DEVICE_ID_NX
77 val = inl(TRID_REG(trident, CH_NX_DELTA_CSO));
78 tmp = (val >> 24) & 0xff;
79 dev_dbg(trident->card->dev, "CSO: 0x%x\n", val & 0x00ffffff);
80 val = inl(TRID_REG(trident, CH_NX_DELTA_ESO));
81 tmp |= (val >> 16) & 0xff00;
82 dev_dbg(trident->card->dev, "Delta: 0x%x\n", tmp);
83 dev_dbg(trident->card->dev, "ESO: 0x%x\n", val & 0x00ffffff);
84 val = inl(TRID_REG(trident, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL));
85 dev_dbg(trident->card->dev, "Alpha: 0x%x\n", val >> 20);
86 dev_dbg(trident->card->dev, "FMS: 0x%x\n", (val >> 16) & 0x0f);
88 dev_dbg(trident->card->dev, "FMC: 0x%x\n", (val >> 14) & 3);
89 dev_dbg(trident->card->dev, "RVol: 0x%x\n", (val >> 7) & 0x7f);
90 dev_dbg(trident->card->dev, "CVol: 0x%x\n", val & 0x7f);
94 /*---------------------------------------------------------------------------
95 unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
97 Description: This routine will do all of the reading from the external
100 Parameters: ac97 - ac97 codec structure
101 reg - CODEC register index, from AC97 Hal.
103 returns: 16 bit value read from the AC97.
105 ---------------------------------------------------------------------------*/
106 static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)
108 unsigned int data = 0, treg;
109 unsigned short count = 0xffff;
111 struct snd_trident *trident = ac97->private_data;
113 spin_lock_irqsave(&trident->reg_lock, flags);
114 if (trident->device == TRIDENT_DEVICE_ID_DX) {
115 data = (DX_AC97_BUSY_READ | (reg & 0x000000ff));
116 outl(data, TRID_REG(trident, DX_ACR1_AC97_R));
118 data = inl(TRID_REG(trident, DX_ACR1_AC97_R));
119 if ((data & DX_AC97_BUSY_READ) == 0)
122 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
123 data = (NX_AC97_BUSY_READ | (reg & 0x000000ff));
124 treg = ac97->num == 0 ? NX_ACR2_AC97_R_PRIMARY : NX_ACR3_AC97_R_SECONDARY;
125 outl(data, TRID_REG(trident, treg));
127 data = inl(TRID_REG(trident, treg));
128 if ((data & 0x00000C00) == 0)
131 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
132 data = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
134 data |= SI_AC97_SECONDARY;
135 outl(data, TRID_REG(trident, SI_AC97_READ));
137 data = inl(TRID_REG(trident, SI_AC97_READ));
138 if ((data & (SI_AC97_BUSY_READ)) == 0)
143 if (count == 0 && !trident->ac97_detect) {
144 dev_err(trident->card->dev,
145 "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
150 spin_unlock_irqrestore(&trident->reg_lock, flags);
151 return ((unsigned short) (data >> 16));
154 /*---------------------------------------------------------------------------
155 void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
156 unsigned short wdata)
158 Description: This routine will do all of the writing to the external
161 Parameters: ac97 - ac97 codec structure
162 reg - CODEC register index, from AC97 Hal.
163 data - Lower 16 bits are the data to write to CODEC.
165 returns: TRUE if everything went ok, else FALSE.
167 ---------------------------------------------------------------------------*/
168 static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
169 unsigned short wdata)
171 unsigned int address, data;
172 unsigned short count = 0xffff;
174 struct snd_trident *trident = ac97->private_data;
176 data = ((unsigned long) wdata) << 16;
178 spin_lock_irqsave(&trident->reg_lock, flags);
179 if (trident->device == TRIDENT_DEVICE_ID_DX) {
180 address = DX_ACR0_AC97_W;
182 /* read AC-97 write register status */
184 if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0)
188 data |= (DX_AC97_BUSY_WRITE | (reg & 0x000000ff));
189 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
190 address = NX_ACR1_AC97_W;
192 /* read AC-97 write register status */
194 if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0)
198 data |= (NX_AC97_BUSY_WRITE | (ac97->num << 8) | (reg & 0x000000ff));
199 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
200 address = SI_AC97_WRITE;
202 /* read AC-97 write register status */
204 if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0)
208 data |= SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
210 data |= SI_AC97_SECONDARY;
212 address = 0; /* keep GCC happy */
213 count = 0; /* return */
217 spin_unlock_irqrestore(&trident->reg_lock, flags);
220 outl(data, TRID_REG(trident, address));
221 spin_unlock_irqrestore(&trident->reg_lock, flags);
224 /*---------------------------------------------------------------------------
225 void snd_trident_enable_eso(struct snd_trident *trident)
227 Description: This routine will enable end of loop interrupts.
228 End of loop interrupts will occur when a running
230 Also enables middle of loop interrupts.
232 Parameters: trident - pointer to target device class for 4DWave.
234 ---------------------------------------------------------------------------*/
236 static void snd_trident_enable_eso(struct snd_trident * trident)
240 val = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
243 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
245 outl(val, TRID_REG(trident, T4D_LFO_GC_CIR));
248 /*---------------------------------------------------------------------------
249 void snd_trident_disable_eso(struct snd_trident *trident)
251 Description: This routine will disable end of loop interrupts.
252 End of loop interrupts will occur when a running
254 Also disables middle of loop interrupts.
257 trident - pointer to target device class for 4DWave.
259 returns: TRUE if everything went ok, else FALSE.
261 ---------------------------------------------------------------------------*/
263 static void snd_trident_disable_eso(struct snd_trident * trident)
267 tmp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
270 outl(tmp, TRID_REG(trident, T4D_LFO_GC_CIR));
273 /*---------------------------------------------------------------------------
274 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
276 Description: Start a voice, any channel 0 thru 63.
277 This routine automatically handles the fact that there are
278 more than 32 channels available.
280 Parameters : voice - Voice number 0 thru n.
281 trident - pointer to target device class for 4DWave.
285 ---------------------------------------------------------------------------*/
287 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
289 unsigned int mask = 1 << (voice & 0x1f);
290 unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A;
292 outl(mask, TRID_REG(trident, reg));
295 EXPORT_SYMBOL(snd_trident_start_voice);
297 /*---------------------------------------------------------------------------
298 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
300 Description: Stop a voice, any channel 0 thru 63.
301 This routine automatically handles the fact that there are
302 more than 32 channels available.
304 Parameters : voice - Voice number 0 thru n.
305 trident - pointer to target device class for 4DWave.
309 ---------------------------------------------------------------------------*/
311 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
313 unsigned int mask = 1 << (voice & 0x1f);
314 unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A;
316 outl(mask, TRID_REG(trident, reg));
319 EXPORT_SYMBOL(snd_trident_stop_voice);
321 /*---------------------------------------------------------------------------
322 int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
324 Description: Allocate hardware channel in Bank B (32-63).
326 Parameters : trident - pointer to target device class for 4DWave.
328 Return Value: hardware channel - 32-63 or -1 when no channel is available
330 ---------------------------------------------------------------------------*/
332 static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
336 if (trident->ChanPCMcnt >= trident->ChanPCM)
338 for (idx = 31; idx >= 0; idx--) {
339 if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) {
340 trident->ChanMap[T4D_BANK_B] |= 1 << idx;
341 trident->ChanPCMcnt++;
348 /*---------------------------------------------------------------------------
349 void snd_trident_free_pcm_channel(int channel)
351 Description: Free hardware channel in Bank B (32-63)
353 Parameters : trident - pointer to target device class for 4DWave.
354 channel - hardware channel number 0-63
358 ---------------------------------------------------------------------------*/
360 static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
362 if (channel < 32 || channel > 63)
365 if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) {
366 trident->ChanMap[T4D_BANK_B] &= ~(1 << channel);
367 trident->ChanPCMcnt--;
371 /*---------------------------------------------------------------------------
372 unsigned int snd_trident_allocate_synth_channel(void)
374 Description: Allocate hardware channel in Bank A (0-31).
376 Parameters : trident - pointer to target device class for 4DWave.
378 Return Value: hardware channel - 0-31 or -1 when no channel is available
380 ---------------------------------------------------------------------------*/
382 static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
386 for (idx = 31; idx >= 0; idx--) {
387 if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) {
388 trident->ChanMap[T4D_BANK_A] |= 1 << idx;
389 trident->synth.ChanSynthCount++;
396 /*---------------------------------------------------------------------------
397 void snd_trident_free_synth_channel( int channel )
399 Description: Free hardware channel in Bank B (0-31).
401 Parameters : trident - pointer to target device class for 4DWave.
402 channel - hardware channel number 0-63
406 ---------------------------------------------------------------------------*/
408 static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
410 if (channel < 0 || channel > 31)
413 if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) {
414 trident->ChanMap[T4D_BANK_A] &= ~(1 << channel);
415 trident->synth.ChanSynthCount--;
419 /*---------------------------------------------------------------------------
420 snd_trident_write_voice_regs
422 Description: This routine will complete and write the 5 hardware channel
423 registers to hardware.
425 Parameters: trident - pointer to target device class for 4DWave.
426 voice - synthesizer voice structure
429 ---------------------------------------------------------------------------*/
431 void snd_trident_write_voice_regs(struct snd_trident * trident,
432 struct snd_trident_voice * voice)
434 unsigned int FmcRvolCvol;
435 unsigned int regs[5];
437 regs[1] = voice->LBA;
438 regs[4] = (voice->GVSel << 31) |
439 ((voice->Pan & 0x0000007f) << 24) |
440 ((voice->CTRL & 0x0000000f) << 12);
441 FmcRvolCvol = ((voice->FMC & 3) << 14) |
442 ((voice->RVol & 0x7f) << 7) |
443 (voice->CVol & 0x7f);
445 switch (trident->device) {
446 case TRIDENT_DEVICE_ID_SI7018:
447 regs[4] |= voice->number > 31 ?
448 (voice->Vol & 0x000003ff) :
449 ((voice->Vol & 0x00003fc) << (16-2)) |
450 (voice->EC & 0x00000fff);
451 regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
452 (voice->FMS & 0x0000000f);
453 regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
454 regs[3] = (voice->Attribute << 16) | FmcRvolCvol;
456 case TRIDENT_DEVICE_ID_DX:
457 regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
458 (voice->EC & 0x00000fff);
459 regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
460 (voice->FMS & 0x0000000f);
461 regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
462 regs[3] = FmcRvolCvol;
464 case TRIDENT_DEVICE_ID_NX:
465 regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
466 (voice->EC & 0x00000fff);
467 regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff);
468 regs[2] = ((voice->Delta << 16) & 0xff000000) |
469 (voice->ESO & 0x00ffffff);
470 regs[3] = (voice->Alpha << 20) |
471 ((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol;
478 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
479 outl(regs[0], TRID_REG(trident, CH_START + 0));
480 outl(regs[1], TRID_REG(trident, CH_START + 4));
481 outl(regs[2], TRID_REG(trident, CH_START + 8));
482 outl(regs[3], TRID_REG(trident, CH_START + 12));
483 outl(regs[4], TRID_REG(trident, CH_START + 16));
486 dev_dbg(trident->card->dev, "written %i channel:\n", voice->number);
487 dev_dbg(trident->card->dev, " regs[0] = 0x%x/0x%x\n",
488 regs[0], inl(TRID_REG(trident, CH_START + 0)));
489 dev_dbg(trident->card->dev, " regs[1] = 0x%x/0x%x\n",
490 regs[1], inl(TRID_REG(trident, CH_START + 4)));
491 dev_dbg(trident->card->dev, " regs[2] = 0x%x/0x%x\n",
492 regs[2], inl(TRID_REG(trident, CH_START + 8)));
493 dev_dbg(trident->card->dev, " regs[3] = 0x%x/0x%x\n",
494 regs[3], inl(TRID_REG(trident, CH_START + 12)));
495 dev_dbg(trident->card->dev, " regs[4] = 0x%x/0x%x\n",
496 regs[4], inl(TRID_REG(trident, CH_START + 16)));
500 EXPORT_SYMBOL(snd_trident_write_voice_regs);
502 /*---------------------------------------------------------------------------
503 snd_trident_write_cso_reg
505 Description: This routine will write the new CSO offset
506 register to hardware.
508 Parameters: trident - pointer to target device class for 4DWave.
509 voice - synthesizer voice structure
512 ---------------------------------------------------------------------------*/
514 static void snd_trident_write_cso_reg(struct snd_trident * trident,
515 struct snd_trident_voice * voice,
519 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
520 if (trident->device != TRIDENT_DEVICE_ID_NX) {
521 outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2);
523 outl((voice->Delta << 24) |
524 (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
528 /*---------------------------------------------------------------------------
529 snd_trident_write_eso_reg
531 Description: This routine will write the new ESO offset
532 register to hardware.
534 Parameters: trident - pointer to target device class for 4DWave.
535 voice - synthesizer voice structure
538 ---------------------------------------------------------------------------*/
540 static void snd_trident_write_eso_reg(struct snd_trident * trident,
541 struct snd_trident_voice * voice,
545 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
546 if (trident->device != TRIDENT_DEVICE_ID_NX) {
547 outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2);
549 outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff),
550 TRID_REG(trident, CH_NX_DELTA_ESO));
554 /*---------------------------------------------------------------------------
555 snd_trident_write_vol_reg
557 Description: This routine will write the new voice volume
558 register to hardware.
560 Parameters: trident - pointer to target device class for 4DWave.
561 voice - synthesizer voice structure
562 Vol - new voice volume
564 ---------------------------------------------------------------------------*/
566 static void snd_trident_write_vol_reg(struct snd_trident * trident,
567 struct snd_trident_voice * voice,
571 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
572 switch (trident->device) {
573 case TRIDENT_DEVICE_ID_DX:
574 case TRIDENT_DEVICE_ID_NX:
575 outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
577 case TRIDENT_DEVICE_ID_SI7018:
578 /* dev_dbg(trident->card->dev, "voice->Vol = 0x%x\n", voice->Vol); */
579 outw((voice->CTRL << 12) | voice->Vol,
580 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
585 /*---------------------------------------------------------------------------
586 snd_trident_write_pan_reg
588 Description: This routine will write the new voice pan
589 register to hardware.
591 Parameters: trident - pointer to target device class for 4DWave.
592 voice - synthesizer voice structure
595 ---------------------------------------------------------------------------*/
597 static void snd_trident_write_pan_reg(struct snd_trident * trident,
598 struct snd_trident_voice * voice,
602 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
603 outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f),
604 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
607 /*---------------------------------------------------------------------------
608 snd_trident_write_rvol_reg
610 Description: This routine will write the new reverb volume
611 register to hardware.
613 Parameters: trident - pointer to target device class for 4DWave.
614 voice - synthesizer voice structure
615 RVol - new reverb volume
617 ---------------------------------------------------------------------------*/
619 static void snd_trident_write_rvol_reg(struct snd_trident * trident,
620 struct snd_trident_voice * voice,
624 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
625 outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
626 (voice->CVol & 0x007f),
627 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
628 CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
631 /*---------------------------------------------------------------------------
632 snd_trident_write_cvol_reg
634 Description: This routine will write the new chorus volume
635 register to hardware.
637 Parameters: trident - pointer to target device class for 4DWave.
638 voice - synthesizer voice structure
639 CVol - new chorus volume
641 ---------------------------------------------------------------------------*/
643 static void snd_trident_write_cvol_reg(struct snd_trident * trident,
644 struct snd_trident_voice * voice,
648 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
649 outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
650 (voice->CVol & 0x007f),
651 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
652 CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));
655 /*---------------------------------------------------------------------------
656 snd_trident_convert_rate
658 Description: This routine converts rate in HZ to hardware delta value.
660 Parameters: trident - pointer to target device class for 4DWave.
661 rate - Real or Virtual channel number.
663 Returns: Delta value.
665 ---------------------------------------------------------------------------*/
666 static unsigned int snd_trident_convert_rate(unsigned int rate)
670 // We special case 44100 and 8000 since rounding with the equation
671 // does not give us an accurate enough value. For 11025 and 22050
672 // the equation gives us the best answer. All other frequencies will
673 // also use the equation. JDW
676 else if (rate == 8000)
678 else if (rate == 48000)
681 delta = (((rate << 12) + 24000) / 48000) & 0x0000ffff;
685 /*---------------------------------------------------------------------------
686 snd_trident_convert_adc_rate
688 Description: This routine converts rate in HZ to hardware delta value.
690 Parameters: trident - pointer to target device class for 4DWave.
691 rate - Real or Virtual channel number.
693 Returns: Delta value.
695 ---------------------------------------------------------------------------*/
696 static unsigned int snd_trident_convert_adc_rate(unsigned int rate)
700 // We special case 44100 and 8000 since rounding with the equation
701 // does not give us an accurate enough value. For 11025 and 22050
702 // the equation gives us the best answer. All other frequencies will
703 // also use the equation. JDW
706 else if (rate == 8000)
708 else if (rate == 48000)
711 delta = ((48000 << 12) / rate) & 0x0000ffff;
715 /*---------------------------------------------------------------------------
716 snd_trident_spurious_threshold
718 Description: This routine converts rate in HZ to spurious threshold.
720 Parameters: trident - pointer to target device class for 4DWave.
721 rate - Real or Virtual channel number.
723 Returns: Delta value.
725 ---------------------------------------------------------------------------*/
726 static unsigned int snd_trident_spurious_threshold(unsigned int rate,
727 unsigned int period_size)
729 unsigned int res = (rate * period_size) / 48000;
737 /*---------------------------------------------------------------------------
738 snd_trident_control_mode
740 Description: This routine returns a control mode for a PCM channel.
742 Parameters: trident - pointer to target device class for 4DWave.
743 substream - PCM substream
745 Returns: Control value.
747 ---------------------------------------------------------------------------*/
748 static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream)
751 struct snd_pcm_runtime *runtime = substream->runtime;
754 CTRL default: 8-bit (unsigned) mono, loop mode enabled
757 if (snd_pcm_format_width(runtime->format) == 16)
758 CTRL |= 0x00000008; // 16-bit data
759 if (snd_pcm_format_signed(runtime->format))
760 CTRL |= 0x00000002; // signed data
761 if (runtime->channels > 1)
762 CTRL |= 0x00000004; // stereo data
770 /*---------------------------------------------------------------------------
773 Description: Device I/O control handler for playback/capture parameters.
775 Parameters: substream - PCM substream class
776 cmd - what ioctl message to process
777 arg - additional message infoarg
779 Returns: Error status
781 ---------------------------------------------------------------------------*/
783 static int snd_trident_ioctl(struct snd_pcm_substream *substream,
787 /* FIXME: it seems that with small periods the behaviour of
788 trident hardware is unpredictable and interrupt generator
790 return snd_pcm_lib_ioctl(substream, cmd, arg);
793 /*---------------------------------------------------------------------------
794 snd_trident_allocate_pcm_mem
796 Description: Allocate PCM ring buffer for given substream
798 Parameters: substream - PCM substream class
799 hw_params - hardware parameters
801 Returns: Error status
803 ---------------------------------------------------------------------------*/
805 static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream,
806 struct snd_pcm_hw_params *hw_params)
808 struct snd_trident *trident = snd_pcm_substream_chip(substream);
809 struct snd_pcm_runtime *runtime = substream->runtime;
810 struct snd_trident_voice *voice = runtime->private_data;
813 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
815 if (trident->tlb.entries) {
816 if (err > 0) { /* change */
818 snd_trident_free_pages(trident, voice->memblk);
819 voice->memblk = snd_trident_alloc_pages(trident, substream);
820 if (voice->memblk == NULL)
827 /*---------------------------------------------------------------------------
828 snd_trident_allocate_evoice
830 Description: Allocate extra voice as interrupt generator
832 Parameters: substream - PCM substream class
833 hw_params - hardware parameters
835 Returns: Error status
837 ---------------------------------------------------------------------------*/
839 static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream,
840 struct snd_pcm_hw_params *hw_params)
842 struct snd_trident *trident = snd_pcm_substream_chip(substream);
843 struct snd_pcm_runtime *runtime = substream->runtime;
844 struct snd_trident_voice *voice = runtime->private_data;
845 struct snd_trident_voice *evoice = voice->extra;
847 /* voice management */
849 if (params_buffer_size(hw_params) / 2 != params_period_size(hw_params)) {
850 if (evoice == NULL) {
851 evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
854 voice->extra = evoice;
855 evoice->substream = substream;
858 if (evoice != NULL) {
859 snd_trident_free_voice(trident, evoice);
860 voice->extra = evoice = NULL;
867 /*---------------------------------------------------------------------------
868 snd_trident_hw_params
870 Description: Set the hardware parameters for the playback device.
872 Parameters: substream - PCM substream class
873 hw_params - hardware parameters
875 Returns: Error status
877 ---------------------------------------------------------------------------*/
879 static int snd_trident_hw_params(struct snd_pcm_substream *substream,
880 struct snd_pcm_hw_params *hw_params)
884 err = snd_trident_allocate_pcm_mem(substream, hw_params);
886 err = snd_trident_allocate_evoice(substream, hw_params);
890 /*---------------------------------------------------------------------------
891 snd_trident_playback_hw_free
893 Description: Release the hardware resources for the playback device.
895 Parameters: substream - PCM substream class
897 Returns: Error status
899 ---------------------------------------------------------------------------*/
901 static int snd_trident_hw_free(struct snd_pcm_substream *substream)
903 struct snd_trident *trident = snd_pcm_substream_chip(substream);
904 struct snd_pcm_runtime *runtime = substream->runtime;
905 struct snd_trident_voice *voice = runtime->private_data;
906 struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
908 if (trident->tlb.entries) {
909 if (voice && voice->memblk) {
910 snd_trident_free_pages(trident, voice->memblk);
911 voice->memblk = NULL;
914 snd_pcm_lib_free_pages(substream);
915 if (evoice != NULL) {
916 snd_trident_free_voice(trident, evoice);
922 /*---------------------------------------------------------------------------
923 snd_trident_playback_prepare
925 Description: Prepare playback device for playback.
927 Parameters: substream - PCM substream class
929 Returns: Error status
931 ---------------------------------------------------------------------------*/
933 static int snd_trident_playback_prepare(struct snd_pcm_substream *substream)
935 struct snd_trident *trident = snd_pcm_substream_chip(substream);
936 struct snd_pcm_runtime *runtime = substream->runtime;
937 struct snd_trident_voice *voice = runtime->private_data;
938 struct snd_trident_voice *evoice = voice->extra;
939 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
941 spin_lock_irq(&trident->reg_lock);
943 /* set delta (rate) value */
944 voice->Delta = snd_trident_convert_rate(runtime->rate);
945 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
947 /* set Loop Begin Address */
949 voice->LBA = voice->memblk->offset;
951 voice->LBA = runtime->dma_addr;
954 voice->ESO = runtime->buffer_size - 1; /* in samples */
955 voice->CTRL = snd_trident_control_mode(substream);
961 voice->Vol = mix->vol;
962 voice->RVol = mix->rvol;
963 voice->CVol = mix->cvol;
964 voice->Pan = mix->pan;
965 voice->Attribute = 0;
967 voice->Attribute = (1<<(30-16))|(2<<(26-16))|
968 (0<<(24-16))|(0x1f<<(19-16));
970 voice->Attribute = 0;
973 snd_trident_write_voice_regs(trident, voice);
975 if (evoice != NULL) {
976 evoice->Delta = voice->Delta;
977 evoice->spurious_threshold = voice->spurious_threshold;
978 evoice->LBA = voice->LBA;
980 evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
981 evoice->CTRL = voice->CTRL;
983 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
987 evoice->Vol = 0x3ff; /* mute */
988 evoice->RVol = evoice->CVol = 0x7f; /* mute */
989 evoice->Pan = 0x7f; /* mute */
991 evoice->Attribute = (1<<(30-16))|(2<<(26-16))|
992 (0<<(24-16))|(0x1f<<(19-16));
994 evoice->Attribute = 0;
996 snd_trident_write_voice_regs(trident, evoice);
998 evoice->isync_mark = runtime->period_size;
999 evoice->ESO = (runtime->period_size * 2) - 1;
1002 spin_unlock_irq(&trident->reg_lock);
1007 /*---------------------------------------------------------------------------
1008 snd_trident_capture_hw_params
1010 Description: Set the hardware parameters for the capture device.
1012 Parameters: substream - PCM substream class
1013 hw_params - hardware parameters
1015 Returns: Error status
1017 ---------------------------------------------------------------------------*/
1019 static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream,
1020 struct snd_pcm_hw_params *hw_params)
1022 return snd_trident_allocate_pcm_mem(substream, hw_params);
1025 /*---------------------------------------------------------------------------
1026 snd_trident_capture_prepare
1028 Description: Prepare capture device for playback.
1030 Parameters: substream - PCM substream class
1032 Returns: Error status
1034 ---------------------------------------------------------------------------*/
1036 static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)
1038 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1039 struct snd_pcm_runtime *runtime = substream->runtime;
1040 struct snd_trident_voice *voice = runtime->private_data;
1041 unsigned int val, ESO_bytes;
1043 spin_lock_irq(&trident->reg_lock);
1045 // Initialize the channel and set channel Mode
1046 outb(0, TRID_REG(trident, LEGACY_DMAR15));
1048 // Set DMA channel operation mode register
1049 outb(0x54, TRID_REG(trident, LEGACY_DMAR11));
1051 // Set channel buffer Address, DMAR0 expects contiguous PCI memory area
1052 voice->LBA = runtime->dma_addr;
1053 outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
1055 voice->LBA = voice->memblk->offset;
1058 ESO_bytes = snd_pcm_lib_buffer_bytes(substream) - 1;
1059 outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6));
1060 outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4));
1063 // Set channel sample rate, 4.12 format
1064 val = (((unsigned int) 48000L << 12) + (runtime->rate/2)) / runtime->rate;
1065 outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R));
1067 // Set channel interrupt blk length
1068 if (snd_pcm_format_width(runtime->format) == 16) {
1069 val = (unsigned short) ((ESO_bytes >> 1) - 1);
1071 val = (unsigned short) (ESO_bytes - 1);
1074 outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL));
1076 // Right now, set format and start to run captureing,
1077 // continuous run loop enable.
1078 trident->bDMAStart = 0x19; // 0001 1001b
1080 if (snd_pcm_format_width(runtime->format) == 16)
1081 trident->bDMAStart |= 0x80;
1082 if (snd_pcm_format_signed(runtime->format))
1083 trident->bDMAStart |= 0x20;
1084 if (runtime->channels > 1)
1085 trident->bDMAStart |= 0x40;
1087 // Prepare capture intr channel
1089 voice->Delta = snd_trident_convert_rate(runtime->rate);
1090 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1092 voice->isync_mark = runtime->period_size;
1093 voice->isync_max = runtime->buffer_size;
1095 // Set voice parameters
1097 voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
1098 voice->CTRL = snd_trident_control_mode(substream);
1103 voice->Pan = 0x7f; /* mute */
1104 voice->Vol = 0x3ff; /* mute */
1108 voice->Attribute = 0;
1110 snd_trident_write_voice_regs(trident, voice);
1112 spin_unlock_irq(&trident->reg_lock);
1116 /*---------------------------------------------------------------------------
1117 snd_trident_si7018_capture_hw_params
1119 Description: Set the hardware parameters for the capture device.
1121 Parameters: substream - PCM substream class
1122 hw_params - hardware parameters
1124 Returns: Error status
1126 ---------------------------------------------------------------------------*/
1128 static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream,
1129 struct snd_pcm_hw_params *hw_params)
1133 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
1136 return snd_trident_allocate_evoice(substream, hw_params);
1139 /*---------------------------------------------------------------------------
1140 snd_trident_si7018_capture_hw_free
1142 Description: Release the hardware resources for the capture device.
1144 Parameters: substream - PCM substream class
1146 Returns: Error status
1148 ---------------------------------------------------------------------------*/
1150 static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream)
1152 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1153 struct snd_pcm_runtime *runtime = substream->runtime;
1154 struct snd_trident_voice *voice = runtime->private_data;
1155 struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
1157 snd_pcm_lib_free_pages(substream);
1158 if (evoice != NULL) {
1159 snd_trident_free_voice(trident, evoice);
1160 voice->extra = NULL;
1165 /*---------------------------------------------------------------------------
1166 snd_trident_si7018_capture_prepare
1168 Description: Prepare capture device for playback.
1170 Parameters: substream - PCM substream class
1172 Returns: Error status
1174 ---------------------------------------------------------------------------*/
1176 static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream)
1178 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1179 struct snd_pcm_runtime *runtime = substream->runtime;
1180 struct snd_trident_voice *voice = runtime->private_data;
1181 struct snd_trident_voice *evoice = voice->extra;
1183 spin_lock_irq(&trident->reg_lock);
1185 voice->LBA = runtime->dma_addr;
1186 voice->Delta = snd_trident_convert_adc_rate(runtime->rate);
1187 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1189 // Set voice parameters
1191 voice->ESO = runtime->buffer_size - 1; /* in samples */
1192 voice->CTRL = snd_trident_control_mode(substream);
1197 voice->Pan = T4D_DEFAULT_PCM_PAN;
1203 voice->Attribute = (2 << (30-16)) |
1208 snd_trident_write_voice_regs(trident, voice);
1210 if (evoice != NULL) {
1211 evoice->Delta = snd_trident_convert_rate(runtime->rate);
1212 evoice->spurious_threshold = voice->spurious_threshold;
1213 evoice->LBA = voice->LBA;
1215 evoice->ESO = (runtime->period_size * 2) + 20 - 1; /* in samples, 20 means correction */
1216 evoice->CTRL = voice->CTRL;
1222 evoice->Vol = 0x3ff; /* mute */
1223 evoice->RVol = evoice->CVol = 0x7f; /* mute */
1224 evoice->Pan = 0x7f; /* mute */
1225 evoice->Attribute = 0;
1226 snd_trident_write_voice_regs(trident, evoice);
1228 evoice->isync_mark = runtime->period_size;
1229 evoice->ESO = (runtime->period_size * 2) - 1;
1232 spin_unlock_irq(&trident->reg_lock);
1236 /*---------------------------------------------------------------------------
1237 snd_trident_foldback_prepare
1239 Description: Prepare foldback capture device for playback.
1241 Parameters: substream - PCM substream class
1243 Returns: Error status
1245 ---------------------------------------------------------------------------*/
1247 static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream)
1249 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1250 struct snd_pcm_runtime *runtime = substream->runtime;
1251 struct snd_trident_voice *voice = runtime->private_data;
1252 struct snd_trident_voice *evoice = voice->extra;
1254 spin_lock_irq(&trident->reg_lock);
1256 /* Set channel buffer Address */
1258 voice->LBA = voice->memblk->offset;
1260 voice->LBA = runtime->dma_addr;
1262 /* set target ESO for channel */
1263 voice->ESO = runtime->buffer_size - 1; /* in samples */
1265 /* set sample rate */
1266 voice->Delta = 0x1000;
1267 voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
1270 voice->CTRL = snd_trident_control_mode(substream);
1275 voice->Pan = 0x7f; /* mute */
1276 voice->Vol = 0x3ff; /* mute */
1280 voice->Attribute = 0;
1282 /* set up capture channel */
1283 outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan));
1285 snd_trident_write_voice_regs(trident, voice);
1287 if (evoice != NULL) {
1288 evoice->Delta = voice->Delta;
1289 evoice->spurious_threshold = voice->spurious_threshold;
1290 evoice->LBA = voice->LBA;
1292 evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
1293 evoice->CTRL = voice->CTRL;
1295 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1299 evoice->Vol = 0x3ff; /* mute */
1300 evoice->RVol = evoice->CVol = 0x7f; /* mute */
1301 evoice->Pan = 0x7f; /* mute */
1302 evoice->Attribute = 0;
1303 snd_trident_write_voice_regs(trident, evoice);
1305 evoice->isync_mark = runtime->period_size;
1306 evoice->ESO = (runtime->period_size * 2) - 1;
1309 spin_unlock_irq(&trident->reg_lock);
1313 /*---------------------------------------------------------------------------
1314 snd_trident_spdif_hw_params
1316 Description: Set the hardware parameters for the spdif device.
1318 Parameters: substream - PCM substream class
1319 hw_params - hardware parameters
1321 Returns: Error status
1323 ---------------------------------------------------------------------------*/
1325 static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream,
1326 struct snd_pcm_hw_params *hw_params)
1328 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1329 unsigned int old_bits = 0, change = 0;
1332 err = snd_trident_allocate_pcm_mem(substream, hw_params);
1336 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1337 err = snd_trident_allocate_evoice(substream, hw_params);
1342 /* prepare SPDIF channel */
1343 spin_lock_irq(&trident->reg_lock);
1344 old_bits = trident->spdif_pcm_bits;
1345 if (old_bits & IEC958_AES0_PROFESSIONAL)
1346 trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS;
1348 trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24);
1349 if (params_rate(hw_params) >= 48000) {
1350 trident->spdif_pcm_ctrl = 0x3c; // 48000 Hz
1351 trident->spdif_pcm_bits |=
1352 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1353 IEC958_AES0_PRO_FS_48000 :
1354 (IEC958_AES3_CON_FS_48000 << 24);
1356 else if (params_rate(hw_params) >= 44100) {
1357 trident->spdif_pcm_ctrl = 0x3e; // 44100 Hz
1358 trident->spdif_pcm_bits |=
1359 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1360 IEC958_AES0_PRO_FS_44100 :
1361 (IEC958_AES3_CON_FS_44100 << 24);
1364 trident->spdif_pcm_ctrl = 0x3d; // 32000 Hz
1365 trident->spdif_pcm_bits |=
1366 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1367 IEC958_AES0_PRO_FS_32000 :
1368 (IEC958_AES3_CON_FS_32000 << 24);
1370 change = old_bits != trident->spdif_pcm_bits;
1371 spin_unlock_irq(&trident->reg_lock);
1374 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id);
1379 /*---------------------------------------------------------------------------
1380 snd_trident_spdif_prepare
1382 Description: Prepare SPDIF device for playback.
1384 Parameters: substream - PCM substream class
1386 Returns: Error status
1388 ---------------------------------------------------------------------------*/
1390 static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream)
1392 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1393 struct snd_pcm_runtime *runtime = substream->runtime;
1394 struct snd_trident_voice *voice = runtime->private_data;
1395 struct snd_trident_voice *evoice = voice->extra;
1396 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
1397 unsigned int RESO, LBAO;
1400 spin_lock_irq(&trident->reg_lock);
1402 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1404 /* set delta (rate) value */
1405 voice->Delta = snd_trident_convert_rate(runtime->rate);
1406 voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
1408 /* set Loop Back Address */
1409 LBAO = runtime->dma_addr;
1411 voice->LBA = voice->memblk->offset;
1417 voice->isync_mark = runtime->period_size;
1418 voice->isync_max = runtime->buffer_size;
1420 /* set target ESO for channel */
1421 RESO = runtime->buffer_size - 1;
1422 voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
1425 voice->CTRL = snd_trident_control_mode(substream);
1437 voice->Attribute = 0;
1439 /* prepare surrogate IRQ channel */
1440 snd_trident_write_voice_regs(trident, voice);
1442 outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO));
1443 outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2));
1444 outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA));
1445 outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO));
1446 outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2));
1448 /* set SPDIF setting */
1449 outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1450 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1454 /* set delta (rate) value */
1455 voice->Delta = 0x800;
1456 voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
1458 /* set Loop Begin Address */
1460 voice->LBA = voice->memblk->offset;
1462 voice->LBA = runtime->dma_addr;
1465 voice->ESO = runtime->buffer_size - 1; /* in samples */
1466 voice->CTRL = snd_trident_control_mode(substream);
1472 voice->Vol = mix->vol;
1473 voice->RVol = mix->rvol;
1474 voice->CVol = mix->cvol;
1475 voice->Pan = mix->pan;
1476 voice->Attribute = (1<<(30-16))|(7<<(26-16))|
1477 (0<<(24-16))|(0<<(19-16));
1479 snd_trident_write_voice_regs(trident, voice);
1481 if (evoice != NULL) {
1482 evoice->Delta = voice->Delta;
1483 evoice->spurious_threshold = voice->spurious_threshold;
1484 evoice->LBA = voice->LBA;
1486 evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
1487 evoice->CTRL = voice->CTRL;
1489 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1493 evoice->Vol = 0x3ff; /* mute */
1494 evoice->RVol = evoice->CVol = 0x7f; /* mute */
1495 evoice->Pan = 0x7f; /* mute */
1496 evoice->Attribute = 0;
1497 snd_trident_write_voice_regs(trident, evoice);
1499 evoice->isync_mark = runtime->period_size;
1500 evoice->ESO = (runtime->period_size * 2) - 1;
1503 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1504 temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
1506 outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR));
1507 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1509 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1512 spin_unlock_irq(&trident->reg_lock);
1517 /*---------------------------------------------------------------------------
1520 Description: Start/stop devices
1522 Parameters: substream - PCM substream class
1523 cmd - trigger command (STOP, GO)
1525 Returns: Error status
1527 ---------------------------------------------------------------------------*/
1529 static int snd_trident_trigger(struct snd_pcm_substream *substream,
1533 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1534 struct snd_pcm_substream *s;
1535 unsigned int what, whati, capture_flag, spdif_flag;
1536 struct snd_trident_voice *voice, *evoice;
1537 unsigned int val, go;
1540 case SNDRV_PCM_TRIGGER_START:
1541 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1542 case SNDRV_PCM_TRIGGER_RESUME:
1545 case SNDRV_PCM_TRIGGER_STOP:
1546 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1547 case SNDRV_PCM_TRIGGER_SUSPEND:
1553 what = whati = capture_flag = spdif_flag = 0;
1554 spin_lock(&trident->reg_lock);
1555 val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
1556 snd_pcm_group_for_each_entry(s, substream) {
1557 if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
1558 voice = s->runtime->private_data;
1559 evoice = voice->extra;
1560 what |= 1 << (voice->number & 0x1f);
1561 if (evoice == NULL) {
1562 whati |= 1 << (voice->number & 0x1f);
1564 what |= 1 << (evoice->number & 0x1f);
1565 whati |= 1 << (evoice->number & 0x1f);
1567 evoice->stimer = val;
1571 voice->stimer = val;
1575 snd_pcm_trigger_done(s, substream);
1583 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1584 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1585 val = trident->spdif_pcm_ctrl;
1588 outb(val, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1590 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1591 val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN;
1592 outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1596 outl(what, TRID_REG(trident, T4D_STOP_B));
1597 val = inl(TRID_REG(trident, T4D_AINTEN_B));
1603 outl(val, TRID_REG(trident, T4D_AINTEN_B));
1605 outl(what, TRID_REG(trident, T4D_START_B));
1607 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1608 outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1610 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1611 outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1613 spin_unlock(&trident->reg_lock);
1617 /*---------------------------------------------------------------------------
1618 snd_trident_playback_pointer
1620 Description: This routine return the playback position
1622 Parameters: substream - PCM substream class
1624 Returns: position of buffer
1626 ---------------------------------------------------------------------------*/
1628 static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream)
1630 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1631 struct snd_pcm_runtime *runtime = substream->runtime;
1632 struct snd_trident_voice *voice = runtime->private_data;
1635 if (!voice->running)
1638 spin_lock(&trident->reg_lock);
1640 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
1642 if (trident->device != TRIDENT_DEVICE_ID_NX) {
1643 cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2));
1644 } else { // ID_4DWAVE_NX
1645 cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff;
1648 spin_unlock(&trident->reg_lock);
1650 if (cso >= runtime->buffer_size)
1656 /*---------------------------------------------------------------------------
1657 snd_trident_capture_pointer
1659 Description: This routine return the capture position
1661 Parameters: pcm1 - PCM device class
1663 Returns: position of buffer
1665 ---------------------------------------------------------------------------*/
1667 static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream)
1669 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1670 struct snd_pcm_runtime *runtime = substream->runtime;
1671 struct snd_trident_voice *voice = runtime->private_data;
1672 unsigned int result;
1674 if (!voice->running)
1677 result = inw(TRID_REG(trident, T4D_SBBL_SBCL));
1678 if (runtime->channels > 1)
1681 result = runtime->buffer_size - result;
1686 /*---------------------------------------------------------------------------
1687 snd_trident_spdif_pointer
1689 Description: This routine return the SPDIF playback position
1691 Parameters: substream - PCM substream class
1693 Returns: position of buffer
1695 ---------------------------------------------------------------------------*/
1697 static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream)
1699 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1700 struct snd_pcm_runtime *runtime = substream->runtime;
1701 struct snd_trident_voice *voice = runtime->private_data;
1702 unsigned int result;
1704 if (!voice->running)
1707 result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
1713 * Playback support device description
1716 static const struct snd_pcm_hardware snd_trident_playback =
1718 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1719 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1720 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1721 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1722 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1723 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1724 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1729 .buffer_bytes_max = (256*1024),
1730 .period_bytes_min = 64,
1731 .period_bytes_max = (256*1024),
1733 .periods_max = 1024,
1738 * Capture support device description
1741 static const struct snd_pcm_hardware snd_trident_capture =
1743 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1744 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1745 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1746 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1747 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
1748 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
1749 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
1754 .buffer_bytes_max = (128*1024),
1755 .period_bytes_min = 64,
1756 .period_bytes_max = (128*1024),
1758 .periods_max = 1024,
1763 * Foldback capture support device description
1766 static const struct snd_pcm_hardware snd_trident_foldback =
1768 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1769 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1770 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1771 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1772 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1773 .rates = SNDRV_PCM_RATE_48000,
1778 .buffer_bytes_max = (128*1024),
1779 .period_bytes_min = 64,
1780 .period_bytes_max = (128*1024),
1782 .periods_max = 1024,
1787 * SPDIF playback support device description
1790 static const struct snd_pcm_hardware snd_trident_spdif =
1792 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1793 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1794 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1795 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1796 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1797 .rates = (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
1798 SNDRV_PCM_RATE_48000),
1803 .buffer_bytes_max = (128*1024),
1804 .period_bytes_min = 64,
1805 .period_bytes_max = (128*1024),
1807 .periods_max = 1024,
1811 static const struct snd_pcm_hardware snd_trident_spdif_7018 =
1813 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1814 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1815 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |
1816 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),
1817 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1818 .rates = SNDRV_PCM_RATE_48000,
1823 .buffer_bytes_max = (128*1024),
1824 .period_bytes_min = 64,
1825 .period_bytes_max = (128*1024),
1827 .periods_max = 1024,
1831 static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime)
1833 struct snd_trident_voice *voice = runtime->private_data;
1834 struct snd_trident *trident;
1837 trident = voice->trident;
1838 snd_trident_free_voice(trident, voice);
1842 static int snd_trident_playback_open(struct snd_pcm_substream *substream)
1844 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1845 struct snd_pcm_runtime *runtime = substream->runtime;
1846 struct snd_trident_voice *voice;
1848 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1851 snd_trident_pcm_mixer_build(trident, voice, substream);
1852 voice->substream = substream;
1853 runtime->private_data = voice;
1854 runtime->private_free = snd_trident_pcm_free_substream;
1855 runtime->hw = snd_trident_playback;
1856 snd_pcm_set_sync(substream);
1857 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1861 /*---------------------------------------------------------------------------
1862 snd_trident_playback_close
1864 Description: This routine will close the 4DWave playback device. For now
1865 we will simply free the dma transfer buffer.
1867 Parameters: substream - PCM substream class
1869 ---------------------------------------------------------------------------*/
1870 static int snd_trident_playback_close(struct snd_pcm_substream *substream)
1872 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1873 struct snd_pcm_runtime *runtime = substream->runtime;
1874 struct snd_trident_voice *voice = runtime->private_data;
1876 snd_trident_pcm_mixer_free(trident, voice, substream);
1880 /*---------------------------------------------------------------------------
1881 snd_trident_spdif_open
1883 Description: This routine will open the 4DWave SPDIF device.
1885 Parameters: substream - PCM substream class
1887 Returns: status - success or failure flag
1889 ---------------------------------------------------------------------------*/
1891 static int snd_trident_spdif_open(struct snd_pcm_substream *substream)
1893 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1894 struct snd_trident_voice *voice;
1895 struct snd_pcm_runtime *runtime = substream->runtime;
1897 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1901 voice->substream = substream;
1902 spin_lock_irq(&trident->reg_lock);
1903 trident->spdif_pcm_bits = trident->spdif_bits;
1904 spin_unlock_irq(&trident->reg_lock);
1906 runtime->private_data = voice;
1907 runtime->private_free = snd_trident_pcm_free_substream;
1908 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1909 runtime->hw = snd_trident_spdif;
1911 runtime->hw = snd_trident_spdif_7018;
1914 trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1915 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1916 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1918 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1923 /*---------------------------------------------------------------------------
1924 snd_trident_spdif_close
1926 Description: This routine will close the 4DWave SPDIF device.
1928 Parameters: substream - PCM substream class
1930 ---------------------------------------------------------------------------*/
1932 static int snd_trident_spdif_close(struct snd_pcm_substream *substream)
1934 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1937 spin_lock_irq(&trident->reg_lock);
1938 // restore default SPDIF setting
1939 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1940 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1941 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
1943 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
1944 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1945 if (trident->spdif_ctrl) {
1950 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1952 spin_unlock_irq(&trident->reg_lock);
1953 trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1954 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1955 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1959 /*---------------------------------------------------------------------------
1960 snd_trident_capture_open
1962 Description: This routine will open the 4DWave capture device.
1964 Parameters: substream - PCM substream class
1966 Returns: status - success or failure flag
1968 ---------------------------------------------------------------------------*/
1970 static int snd_trident_capture_open(struct snd_pcm_substream *substream)
1972 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1973 struct snd_trident_voice *voice;
1974 struct snd_pcm_runtime *runtime = substream->runtime;
1976 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1980 voice->substream = substream;
1981 runtime->private_data = voice;
1982 runtime->private_free = snd_trident_pcm_free_substream;
1983 runtime->hw = snd_trident_capture;
1984 snd_pcm_set_sync(substream);
1985 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
1989 /*---------------------------------------------------------------------------
1990 snd_trident_capture_close
1992 Description: This routine will close the 4DWave capture device. For now
1993 we will simply free the dma transfer buffer.
1995 Parameters: substream - PCM substream class
1997 ---------------------------------------------------------------------------*/
1998 static int snd_trident_capture_close(struct snd_pcm_substream *substream)
2003 /*---------------------------------------------------------------------------
2004 snd_trident_foldback_open
2006 Description: This routine will open the 4DWave foldback capture device.
2008 Parameters: substream - PCM substream class
2010 Returns: status - success or failure flag
2012 ---------------------------------------------------------------------------*/
2014 static int snd_trident_foldback_open(struct snd_pcm_substream *substream)
2016 struct snd_trident *trident = snd_pcm_substream_chip(substream);
2017 struct snd_trident_voice *voice;
2018 struct snd_pcm_runtime *runtime = substream->runtime;
2020 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
2023 voice->foldback_chan = substream->number;
2024 voice->substream = substream;
2025 runtime->private_data = voice;
2026 runtime->private_free = snd_trident_pcm_free_substream;
2027 runtime->hw = snd_trident_foldback;
2028 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
2032 /*---------------------------------------------------------------------------
2033 snd_trident_foldback_close
2035 Description: This routine will close the 4DWave foldback capture device.
2036 For now we will simply free the dma transfer buffer.
2038 Parameters: substream - PCM substream class
2040 ---------------------------------------------------------------------------*/
2041 static int snd_trident_foldback_close(struct snd_pcm_substream *substream)
2043 struct snd_trident *trident = snd_pcm_substream_chip(substream);
2044 struct snd_trident_voice *voice;
2045 struct snd_pcm_runtime *runtime = substream->runtime;
2046 voice = runtime->private_data;
2048 /* stop capture channel */
2049 spin_lock_irq(&trident->reg_lock);
2050 outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan));
2051 spin_unlock_irq(&trident->reg_lock);
2055 /*---------------------------------------------------------------------------
2057 ---------------------------------------------------------------------------*/
2059 static const struct snd_pcm_ops snd_trident_playback_ops = {
2060 .open = snd_trident_playback_open,
2061 .close = snd_trident_playback_close,
2062 .ioctl = snd_trident_ioctl,
2063 .hw_params = snd_trident_hw_params,
2064 .hw_free = snd_trident_hw_free,
2065 .prepare = snd_trident_playback_prepare,
2066 .trigger = snd_trident_trigger,
2067 .pointer = snd_trident_playback_pointer,
2070 static const struct snd_pcm_ops snd_trident_nx_playback_ops = {
2071 .open = snd_trident_playback_open,
2072 .close = snd_trident_playback_close,
2073 .ioctl = snd_trident_ioctl,
2074 .hw_params = snd_trident_hw_params,
2075 .hw_free = snd_trident_hw_free,
2076 .prepare = snd_trident_playback_prepare,
2077 .trigger = snd_trident_trigger,
2078 .pointer = snd_trident_playback_pointer,
2081 static const struct snd_pcm_ops snd_trident_capture_ops = {
2082 .open = snd_trident_capture_open,
2083 .close = snd_trident_capture_close,
2084 .ioctl = snd_trident_ioctl,
2085 .hw_params = snd_trident_capture_hw_params,
2086 .hw_free = snd_trident_hw_free,
2087 .prepare = snd_trident_capture_prepare,
2088 .trigger = snd_trident_trigger,
2089 .pointer = snd_trident_capture_pointer,
2092 static const struct snd_pcm_ops snd_trident_si7018_capture_ops = {
2093 .open = snd_trident_capture_open,
2094 .close = snd_trident_capture_close,
2095 .ioctl = snd_trident_ioctl,
2096 .hw_params = snd_trident_si7018_capture_hw_params,
2097 .hw_free = snd_trident_si7018_capture_hw_free,
2098 .prepare = snd_trident_si7018_capture_prepare,
2099 .trigger = snd_trident_trigger,
2100 .pointer = snd_trident_playback_pointer,
2103 static const struct snd_pcm_ops snd_trident_foldback_ops = {
2104 .open = snd_trident_foldback_open,
2105 .close = snd_trident_foldback_close,
2106 .ioctl = snd_trident_ioctl,
2107 .hw_params = snd_trident_hw_params,
2108 .hw_free = snd_trident_hw_free,
2109 .prepare = snd_trident_foldback_prepare,
2110 .trigger = snd_trident_trigger,
2111 .pointer = snd_trident_playback_pointer,
2114 static const struct snd_pcm_ops snd_trident_nx_foldback_ops = {
2115 .open = snd_trident_foldback_open,
2116 .close = snd_trident_foldback_close,
2117 .ioctl = snd_trident_ioctl,
2118 .hw_params = snd_trident_hw_params,
2119 .hw_free = snd_trident_hw_free,
2120 .prepare = snd_trident_foldback_prepare,
2121 .trigger = snd_trident_trigger,
2122 .pointer = snd_trident_playback_pointer,
2125 static const struct snd_pcm_ops snd_trident_spdif_ops = {
2126 .open = snd_trident_spdif_open,
2127 .close = snd_trident_spdif_close,
2128 .ioctl = snd_trident_ioctl,
2129 .hw_params = snd_trident_spdif_hw_params,
2130 .hw_free = snd_trident_hw_free,
2131 .prepare = snd_trident_spdif_prepare,
2132 .trigger = snd_trident_trigger,
2133 .pointer = snd_trident_spdif_pointer,
2136 static const struct snd_pcm_ops snd_trident_spdif_7018_ops = {
2137 .open = snd_trident_spdif_open,
2138 .close = snd_trident_spdif_close,
2139 .ioctl = snd_trident_ioctl,
2140 .hw_params = snd_trident_spdif_hw_params,
2141 .hw_free = snd_trident_hw_free,
2142 .prepare = snd_trident_spdif_prepare,
2143 .trigger = snd_trident_trigger,
2144 .pointer = snd_trident_playback_pointer,
2147 /*---------------------------------------------------------------------------
2150 Description: This routine registers the 4DWave device for PCM support.
2152 Parameters: trident - pointer to target device class for 4DWave.
2156 ---------------------------------------------------------------------------*/
2158 int snd_trident_pcm(struct snd_trident *trident, int device)
2160 struct snd_pcm *pcm;
2163 if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0)
2166 pcm->private_data = trident;
2168 if (trident->tlb.entries) {
2169 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops);
2171 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_playback_ops);
2173 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
2174 trident->device != TRIDENT_DEVICE_ID_SI7018 ?
2175 &snd_trident_capture_ops :
2176 &snd_trident_si7018_capture_ops);
2178 pcm->info_flags = 0;
2179 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
2180 strcpy(pcm->name, "Trident 4DWave");
2183 if (trident->tlb.entries) {
2184 struct snd_pcm_substream *substream;
2185 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
2186 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
2189 snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
2194 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
2202 /*---------------------------------------------------------------------------
2203 snd_trident_foldback_pcm
2205 Description: This routine registers the 4DWave device for foldback PCM support.
2207 Parameters: trident - pointer to target device class for 4DWave.
2211 ---------------------------------------------------------------------------*/
2213 int snd_trident_foldback_pcm(struct snd_trident *trident, int device)
2215 struct snd_pcm *foldback;
2218 struct snd_pcm_substream *substream;
2220 if (trident->device == TRIDENT_DEVICE_ID_NX)
2222 if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0)
2225 foldback->private_data = trident;
2226 if (trident->tlb.entries)
2227 snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops);
2229 snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_foldback_ops);
2230 foldback->info_flags = 0;
2231 strcpy(foldback->name, "Trident 4DWave");
2232 substream = foldback->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
2233 strcpy(substream->name, "Front Mixer");
2234 substream = substream->next;
2235 strcpy(substream->name, "Reverb Mixer");
2236 substream = substream->next;
2237 strcpy(substream->name, "Chorus Mixer");
2238 if (num_chan == 4) {
2239 substream = substream->next;
2240 strcpy(substream->name, "Second AC'97 ADC");
2242 trident->foldback = foldback;
2244 if (trident->tlb.entries)
2245 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV_SG,
2249 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV,
2256 /*---------------------------------------------------------------------------
2259 Description: This routine registers the 4DWave-NX device for SPDIF support.
2261 Parameters: trident - pointer to target device class for 4DWave-NX.
2265 ---------------------------------------------------------------------------*/
2267 int snd_trident_spdif_pcm(struct snd_trident *trident, int device)
2269 struct snd_pcm *spdif;
2272 if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0)
2275 spdif->private_data = trident;
2276 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2277 snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops);
2279 snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_7018_ops);
2281 spdif->info_flags = 0;
2282 strcpy(spdif->name, "Trident 4DWave IEC958");
2283 trident->spdif = spdif;
2285 snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV,
2297 /*---------------------------------------------------------------------------
2298 snd_trident_spdif_control
2300 Description: enable/disable S/PDIF out from ac97 mixer
2301 ---------------------------------------------------------------------------*/
2303 #define snd_trident_spdif_control_info snd_ctl_boolean_mono_info
2305 static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol,
2306 struct snd_ctl_elem_value *ucontrol)
2308 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2311 spin_lock_irq(&trident->reg_lock);
2312 val = trident->spdif_ctrl;
2313 ucontrol->value.integer.value[0] = val == kcontrol->private_value;
2314 spin_unlock_irq(&trident->reg_lock);
2318 static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol,
2319 struct snd_ctl_elem_value *ucontrol)
2321 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2325 val = ucontrol->value.integer.value[0] ? (unsigned char) kcontrol->private_value : 0x00;
2326 spin_lock_irq(&trident->reg_lock);
2327 /* S/PDIF C Channel bits 0-31 : 48khz, SCMS disabled */
2328 change = trident->spdif_ctrl != val;
2329 trident->spdif_ctrl = val;
2330 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2331 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) {
2332 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2333 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
2336 if (trident->spdif == NULL) {
2338 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2339 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN;
2342 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
2345 spin_unlock_irq(&trident->reg_lock);
2349 static const struct snd_kcontrol_new snd_trident_spdif_control =
2351 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2352 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
2353 .info = snd_trident_spdif_control_info,
2354 .get = snd_trident_spdif_control_get,
2355 .put = snd_trident_spdif_control_put,
2356 .private_value = 0x28,
2359 /*---------------------------------------------------------------------------
2360 snd_trident_spdif_default
2362 Description: put/get the S/PDIF default settings
2363 ---------------------------------------------------------------------------*/
2365 static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol,
2366 struct snd_ctl_elem_info *uinfo)
2368 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2373 static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol,
2374 struct snd_ctl_elem_value *ucontrol)
2376 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2378 spin_lock_irq(&trident->reg_lock);
2379 ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
2380 ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
2381 ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
2382 ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
2383 spin_unlock_irq(&trident->reg_lock);
2387 static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol,
2388 struct snd_ctl_elem_value *ucontrol)
2390 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2394 val = (ucontrol->value.iec958.status[0] << 0) |
2395 (ucontrol->value.iec958.status[1] << 8) |
2396 (ucontrol->value.iec958.status[2] << 16) |
2397 (ucontrol->value.iec958.status[3] << 24);
2398 spin_lock_irq(&trident->reg_lock);
2399 change = trident->spdif_bits != val;
2400 trident->spdif_bits = val;
2401 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2402 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0)
2403 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2405 if (trident->spdif == NULL)
2406 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2408 spin_unlock_irq(&trident->reg_lock);
2412 static const struct snd_kcontrol_new snd_trident_spdif_default =
2414 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2415 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
2416 .info = snd_trident_spdif_default_info,
2417 .get = snd_trident_spdif_default_get,
2418 .put = snd_trident_spdif_default_put
2421 /*---------------------------------------------------------------------------
2422 snd_trident_spdif_mask
2424 Description: put/get the S/PDIF mask
2425 ---------------------------------------------------------------------------*/
2427 static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol,
2428 struct snd_ctl_elem_info *uinfo)
2430 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2435 static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol,
2436 struct snd_ctl_elem_value *ucontrol)
2438 ucontrol->value.iec958.status[0] = 0xff;
2439 ucontrol->value.iec958.status[1] = 0xff;
2440 ucontrol->value.iec958.status[2] = 0xff;
2441 ucontrol->value.iec958.status[3] = 0xff;
2445 static const struct snd_kcontrol_new snd_trident_spdif_mask =
2447 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2448 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2449 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
2450 .info = snd_trident_spdif_mask_info,
2451 .get = snd_trident_spdif_mask_get,
2454 /*---------------------------------------------------------------------------
2455 snd_trident_spdif_stream
2457 Description: put/get the S/PDIF stream settings
2458 ---------------------------------------------------------------------------*/
2460 static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol,
2461 struct snd_ctl_elem_info *uinfo)
2463 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
2468 static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol,
2469 struct snd_ctl_elem_value *ucontrol)
2471 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2473 spin_lock_irq(&trident->reg_lock);
2474 ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
2475 ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
2476 ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
2477 ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
2478 spin_unlock_irq(&trident->reg_lock);
2482 static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol,
2483 struct snd_ctl_elem_value *ucontrol)
2485 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2489 val = (ucontrol->value.iec958.status[0] << 0) |
2490 (ucontrol->value.iec958.status[1] << 8) |
2491 (ucontrol->value.iec958.status[2] << 16) |
2492 (ucontrol->value.iec958.status[3] << 24);
2493 spin_lock_irq(&trident->reg_lock);
2494 change = trident->spdif_pcm_bits != val;
2495 trident->spdif_pcm_bits = val;
2496 if (trident->spdif != NULL) {
2497 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2498 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
2500 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2503 spin_unlock_irq(&trident->reg_lock);
2507 static const struct snd_kcontrol_new snd_trident_spdif_stream =
2509 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2510 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2511 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
2512 .info = snd_trident_spdif_stream_info,
2513 .get = snd_trident_spdif_stream_get,
2514 .put = snd_trident_spdif_stream_put
2517 /*---------------------------------------------------------------------------
2518 snd_trident_ac97_control
2520 Description: enable/disable rear path for ac97
2521 ---------------------------------------------------------------------------*/
2523 #define snd_trident_ac97_control_info snd_ctl_boolean_mono_info
2525 static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol,
2526 struct snd_ctl_elem_value *ucontrol)
2528 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2531 spin_lock_irq(&trident->reg_lock);
2532 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2533 ucontrol->value.integer.value[0] = (val & (1 << kcontrol->private_value)) ? 1 : 0;
2534 spin_unlock_irq(&trident->reg_lock);
2538 static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol,
2539 struct snd_ctl_elem_value *ucontrol)
2541 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2545 spin_lock_irq(&trident->reg_lock);
2546 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2547 val &= ~(1 << kcontrol->private_value);
2548 if (ucontrol->value.integer.value[0])
2549 val |= 1 << kcontrol->private_value;
2550 change = val != trident->ac97_ctrl;
2551 trident->ac97_ctrl = val;
2552 outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2553 spin_unlock_irq(&trident->reg_lock);
2557 static const struct snd_kcontrol_new snd_trident_ac97_rear_control =
2559 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2560 .name = "Rear Path",
2561 .info = snd_trident_ac97_control_info,
2562 .get = snd_trident_ac97_control_get,
2563 .put = snd_trident_ac97_control_put,
2567 /*---------------------------------------------------------------------------
2568 snd_trident_vol_control
2570 Description: wave & music volume control
2571 ---------------------------------------------------------------------------*/
2573 static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol,
2574 struct snd_ctl_elem_info *uinfo)
2576 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2578 uinfo->value.integer.min = 0;
2579 uinfo->value.integer.max = 255;
2583 static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol,
2584 struct snd_ctl_elem_value *ucontrol)
2586 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2589 val = trident->musicvol_wavevol;
2590 ucontrol->value.integer.value[0] = 255 - ((val >> kcontrol->private_value) & 0xff);
2591 ucontrol->value.integer.value[1] = 255 - ((val >> (kcontrol->private_value + 8)) & 0xff);
2595 static const DECLARE_TLV_DB_SCALE(db_scale_gvol, -6375, 25, 0);
2597 static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol,
2598 struct snd_ctl_elem_value *ucontrol)
2600 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2604 spin_lock_irq(&trident->reg_lock);
2605 val = trident->musicvol_wavevol;
2606 val &= ~(0xffff << kcontrol->private_value);
2607 val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) |
2608 ((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value;
2609 change = val != trident->musicvol_wavevol;
2610 outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2611 spin_unlock_irq(&trident->reg_lock);
2615 static const struct snd_kcontrol_new snd_trident_vol_music_control =
2617 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2618 .name = "Music Playback Volume",
2619 .info = snd_trident_vol_control_info,
2620 .get = snd_trident_vol_control_get,
2621 .put = snd_trident_vol_control_put,
2622 .private_value = 16,
2623 .tlv = { .p = db_scale_gvol },
2626 static const struct snd_kcontrol_new snd_trident_vol_wave_control =
2628 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2629 .name = "Wave Playback Volume",
2630 .info = snd_trident_vol_control_info,
2631 .get = snd_trident_vol_control_get,
2632 .put = snd_trident_vol_control_put,
2634 .tlv = { .p = db_scale_gvol },
2637 /*---------------------------------------------------------------------------
2638 snd_trident_pcm_vol_control
2640 Description: PCM front volume control
2641 ---------------------------------------------------------------------------*/
2643 static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol,
2644 struct snd_ctl_elem_info *uinfo)
2646 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2648 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2650 uinfo->value.integer.min = 0;
2651 uinfo->value.integer.max = 255;
2652 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
2653 uinfo->value.integer.max = 1023;
2657 static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol,
2658 struct snd_ctl_elem_value *ucontrol)
2660 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2661 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2663 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2664 ucontrol->value.integer.value[0] = 1023 - mix->vol;
2666 ucontrol->value.integer.value[0] = 255 - (mix->vol>>2);
2671 static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol,
2672 struct snd_ctl_elem_value *ucontrol)
2674 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2675 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2679 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2680 val = 1023 - (ucontrol->value.integer.value[0] & 1023);
2682 val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2;
2684 spin_lock_irq(&trident->reg_lock);
2685 change = val != mix->vol;
2687 if (mix->voice != NULL)
2688 snd_trident_write_vol_reg(trident, mix->voice, val);
2689 spin_unlock_irq(&trident->reg_lock);
2693 static const struct snd_kcontrol_new snd_trident_pcm_vol_control =
2695 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2696 .name = "PCM Front Playback Volume",
2697 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2699 .info = snd_trident_pcm_vol_control_info,
2700 .get = snd_trident_pcm_vol_control_get,
2701 .put = snd_trident_pcm_vol_control_put,
2702 /* FIXME: no tlv yet */
2705 /*---------------------------------------------------------------------------
2706 snd_trident_pcm_pan_control
2708 Description: PCM front pan control
2709 ---------------------------------------------------------------------------*/
2711 static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol,
2712 struct snd_ctl_elem_info *uinfo)
2714 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2716 uinfo->value.integer.min = 0;
2717 uinfo->value.integer.max = 127;
2721 static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol,
2722 struct snd_ctl_elem_value *ucontrol)
2724 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2725 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2727 ucontrol->value.integer.value[0] = mix->pan;
2728 if (ucontrol->value.integer.value[0] & 0x40) {
2729 ucontrol->value.integer.value[0] = (0x3f - (ucontrol->value.integer.value[0] & 0x3f));
2731 ucontrol->value.integer.value[0] |= 0x40;
2736 static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol,
2737 struct snd_ctl_elem_value *ucontrol)
2739 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2740 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2744 if (ucontrol->value.integer.value[0] & 0x40)
2745 val = ucontrol->value.integer.value[0] & 0x3f;
2747 val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40;
2748 spin_lock_irq(&trident->reg_lock);
2749 change = val != mix->pan;
2751 if (mix->voice != NULL)
2752 snd_trident_write_pan_reg(trident, mix->voice, val);
2753 spin_unlock_irq(&trident->reg_lock);
2757 static const struct snd_kcontrol_new snd_trident_pcm_pan_control =
2759 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2760 .name = "PCM Pan Playback Control",
2761 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2763 .info = snd_trident_pcm_pan_control_info,
2764 .get = snd_trident_pcm_pan_control_get,
2765 .put = snd_trident_pcm_pan_control_put,
2768 /*---------------------------------------------------------------------------
2769 snd_trident_pcm_rvol_control
2771 Description: PCM reverb volume control
2772 ---------------------------------------------------------------------------*/
2774 static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol,
2775 struct snd_ctl_elem_info *uinfo)
2777 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2779 uinfo->value.integer.min = 0;
2780 uinfo->value.integer.max = 127;
2784 static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol,
2785 struct snd_ctl_elem_value *ucontrol)
2787 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2788 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2790 ucontrol->value.integer.value[0] = 127 - mix->rvol;
2794 static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol,
2795 struct snd_ctl_elem_value *ucontrol)
2797 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2798 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2802 val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
2803 spin_lock_irq(&trident->reg_lock);
2804 change = val != mix->rvol;
2806 if (mix->voice != NULL)
2807 snd_trident_write_rvol_reg(trident, mix->voice, val);
2808 spin_unlock_irq(&trident->reg_lock);
2812 static const DECLARE_TLV_DB_SCALE(db_scale_crvol, -3175, 25, 1);
2814 static const struct snd_kcontrol_new snd_trident_pcm_rvol_control =
2816 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2817 .name = "PCM Reverb Playback Volume",
2818 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2820 .info = snd_trident_pcm_rvol_control_info,
2821 .get = snd_trident_pcm_rvol_control_get,
2822 .put = snd_trident_pcm_rvol_control_put,
2823 .tlv = { .p = db_scale_crvol },
2826 /*---------------------------------------------------------------------------
2827 snd_trident_pcm_cvol_control
2829 Description: PCM chorus volume control
2830 ---------------------------------------------------------------------------*/
2832 static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol,
2833 struct snd_ctl_elem_info *uinfo)
2835 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2837 uinfo->value.integer.min = 0;
2838 uinfo->value.integer.max = 127;
2842 static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol,
2843 struct snd_ctl_elem_value *ucontrol)
2845 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2846 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2848 ucontrol->value.integer.value[0] = 127 - mix->cvol;
2852 static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol,
2853 struct snd_ctl_elem_value *ucontrol)
2855 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2856 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2860 val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
2861 spin_lock_irq(&trident->reg_lock);
2862 change = val != mix->cvol;
2864 if (mix->voice != NULL)
2865 snd_trident_write_cvol_reg(trident, mix->voice, val);
2866 spin_unlock_irq(&trident->reg_lock);
2870 static const struct snd_kcontrol_new snd_trident_pcm_cvol_control =
2872 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2873 .name = "PCM Chorus Playback Volume",
2874 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
2876 .info = snd_trident_pcm_cvol_control_info,
2877 .get = snd_trident_pcm_cvol_control_get,
2878 .put = snd_trident_pcm_cvol_control_put,
2879 .tlv = { .p = db_scale_crvol },
2882 static void snd_trident_notify_pcm_change1(struct snd_card *card,
2883 struct snd_kcontrol *kctl,
2884 int num, int activate)
2886 struct snd_ctl_elem_id id;
2891 kctl->vd[num].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2893 kctl->vd[num].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
2894 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE |
2895 SNDRV_CTL_EVENT_MASK_INFO,
2896 snd_ctl_build_ioff(&id, kctl, num));
2899 static void snd_trident_notify_pcm_change(struct snd_trident *trident,
2900 struct snd_trident_pcm_mixer *tmix,
2901 int num, int activate)
2903 snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
2904 snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
2905 snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate);
2906 snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
2909 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
2910 struct snd_trident_voice *voice,
2911 struct snd_pcm_substream *substream)
2913 struct snd_trident_pcm_mixer *tmix;
2915 if (snd_BUG_ON(!trident || !voice || !substream))
2917 tmix = &trident->pcm_mixer[substream->number];
2918 tmix->voice = voice;
2919 tmix->vol = T4D_DEFAULT_PCM_VOL;
2920 tmix->pan = T4D_DEFAULT_PCM_PAN;
2921 tmix->rvol = T4D_DEFAULT_PCM_RVOL;
2922 tmix->cvol = T4D_DEFAULT_PCM_CVOL;
2923 snd_trident_notify_pcm_change(trident, tmix, substream->number, 1);
2927 static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
2929 struct snd_trident_pcm_mixer *tmix;
2931 if (snd_BUG_ON(!trident || !substream))
2933 tmix = &trident->pcm_mixer[substream->number];
2935 snd_trident_notify_pcm_change(trident, tmix, substream->number, 0);
2939 /*---------------------------------------------------------------------------
2942 Description: This routine registers the 4DWave device for mixer support.
2944 Parameters: trident - pointer to target device class for 4DWave.
2948 ---------------------------------------------------------------------------*/
2950 static int snd_trident_mixer(struct snd_trident *trident, int pcm_spdif_device)
2952 struct snd_ac97_template _ac97;
2953 struct snd_card *card = trident->card;
2954 struct snd_kcontrol *kctl;
2955 struct snd_ctl_elem_value *uctl;
2956 int idx, err, retries = 2;
2957 static struct snd_ac97_bus_ops ops = {
2958 .write = snd_trident_codec_write,
2959 .read = snd_trident_codec_read,
2962 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
2966 if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0)
2969 memset(&_ac97, 0, sizeof(_ac97));
2970 _ac97.private_data = trident;
2971 trident->ac97_detect = 1;
2974 if ((err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97)) < 0) {
2975 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2976 if ((err = snd_trident_sis_reset(trident)) < 0)
2985 /* secondary codec? */
2986 if (trident->device == TRIDENT_DEVICE_ID_SI7018 &&
2987 (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) {
2989 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
2991 dev_err(trident->card->dev,
2992 "SI7018: the secondary codec - invalid access\n");
2993 #if 0 // only for my testing purpose --jk
2995 struct snd_ac97 *mc97;
2996 err = snd_ac97_modem(trident->card, &_ac97, &mc97);
2998 dev_err(trident->card->dev,
2999 "snd_ac97_modem returned error %i\n", err);
3004 trident->ac97_detect = 0;
3006 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
3007 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident))) < 0)
3009 kctl->put(kctl, uctl);
3010 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident))) < 0)
3012 kctl->put(kctl, uctl);
3013 outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3015 outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3018 for (idx = 0; idx < 32; idx++) {
3019 struct snd_trident_pcm_mixer *tmix;
3021 tmix = &trident->pcm_mixer[idx];
3024 if ((trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident)) == NULL)
3026 if ((err = snd_ctl_add(card, trident->ctl_vol)))
3029 if ((trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident)) == NULL)
3031 if ((err = snd_ctl_add(card, trident->ctl_pan)))
3034 if ((trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident)) == NULL)
3036 if ((err = snd_ctl_add(card, trident->ctl_rvol)))
3039 if ((trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident)) == NULL)
3041 if ((err = snd_ctl_add(card, trident->ctl_cvol)))
3044 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3045 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident))) < 0)
3047 kctl->put(kctl, uctl);
3049 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
3051 kctl = snd_ctl_new1(&snd_trident_spdif_control, trident);
3056 if (trident->ac97->ext_id & AC97_EI_SPDIF)
3058 if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF))
3060 idx = kctl->id.index;
3061 if ((err = snd_ctl_add(card, kctl)) < 0)
3063 kctl->put(kctl, uctl);
3065 kctl = snd_ctl_new1(&snd_trident_spdif_default, trident);
3070 kctl->id.index = idx;
3071 kctl->id.device = pcm_spdif_device;
3072 if ((err = snd_ctl_add(card, kctl)) < 0)
3075 kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident);
3080 kctl->id.index = idx;
3081 kctl->id.device = pcm_spdif_device;
3082 if ((err = snd_ctl_add(card, kctl)) < 0)
3085 kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident);
3090 kctl->id.index = idx;
3091 kctl->id.device = pcm_spdif_device;
3092 if ((err = snd_ctl_add(card, kctl)) < 0)
3094 trident->spdif_pcm_ctl = kctl;
3110 * gameport interface
3113 #if IS_REACHABLE(CONFIG_GAMEPORT)
3115 static unsigned char snd_trident_gameport_read(struct gameport *gameport)
3117 struct snd_trident *chip = gameport_get_port_data(gameport);
3119 if (snd_BUG_ON(!chip))
3121 return inb(TRID_REG(chip, GAMEPORT_LEGACY));
3124 static void snd_trident_gameport_trigger(struct gameport *gameport)
3126 struct snd_trident *chip = gameport_get_port_data(gameport);
3128 if (snd_BUG_ON(!chip))
3130 outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY));
3133 static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
3135 struct snd_trident *chip = gameport_get_port_data(gameport);
3138 if (snd_BUG_ON(!chip))
3141 *buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf;
3143 for (i = 0; i < 4; i++) {
3144 axes[i] = inw(TRID_REG(chip, GAMEPORT_AXES + i * 2));
3145 if (axes[i] == 0xffff) axes[i] = -1;
3151 static int snd_trident_gameport_open(struct gameport *gameport, int mode)
3153 struct snd_trident *chip = gameport_get_port_data(gameport);
3155 if (snd_BUG_ON(!chip))
3159 case GAMEPORT_MODE_COOKED:
3160 outb(GAMEPORT_MODE_ADC, TRID_REG(chip, GAMEPORT_GCR));
3163 case GAMEPORT_MODE_RAW:
3164 outb(0, TRID_REG(chip, GAMEPORT_GCR));
3171 int snd_trident_create_gameport(struct snd_trident *chip)
3173 struct gameport *gp;
3175 chip->gameport = gp = gameport_allocate_port();
3177 dev_err(chip->card->dev,
3178 "cannot allocate memory for gameport\n");
3182 gameport_set_name(gp, "Trident 4DWave");
3183 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
3184 gameport_set_dev_parent(gp, &chip->pci->dev);
3186 gameport_set_port_data(gp, chip);
3188 gp->read = snd_trident_gameport_read;
3189 gp->trigger = snd_trident_gameport_trigger;
3190 gp->cooked_read = snd_trident_gameport_cooked_read;
3191 gp->open = snd_trident_gameport_open;
3193 gameport_register_port(gp);
3198 static inline void snd_trident_free_gameport(struct snd_trident *chip)
3200 if (chip->gameport) {
3201 gameport_unregister_port(chip->gameport);
3202 chip->gameport = NULL;
3206 int snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; }
3207 static inline void snd_trident_free_gameport(struct snd_trident *chip) { }
3208 #endif /* CONFIG_GAMEPORT */
3213 static inline void do_delay(struct snd_trident *chip)
3215 schedule_timeout_uninterruptible(1);
3222 static int snd_trident_sis_reset(struct snd_trident *trident)
3224 unsigned long end_time;
3228 r = trident->in_suspend ? 0 : 2; /* count of retries */
3230 pci_write_config_byte(trident->pci, 0x46, 0x04); /* SOFTWARE RESET */
3232 pci_write_config_byte(trident->pci, 0x46, 0x00);
3234 /* disable AC97 GPIO interrupt */
3235 outb(0x00, TRID_REG(trident, SI_AC97_GPIO));
3236 /* initialize serial interface, force cold reset */
3237 i = PCMOUT|SURROUT|CENTEROUT|LFEOUT|SECONDARY_ID|COLD_RESET;
3238 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3240 /* remove cold reset */
3242 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3244 /* wait, until the codec is ready */
3245 end_time = (jiffies + (HZ * 3) / 4) + 1;
3247 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0)
3250 } while (time_after_eq(end_time, jiffies));
3251 dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3252 inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
3254 end_time = jiffies + HZ;
3257 } while (time_after_eq(end_time, jiffies));
3258 goto __si7018_retry;
3261 /* wait for the second codec */
3263 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0)
3266 } while (time_after_eq(end_time, jiffies));
3267 /* enable 64 channel mode */
3268 outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR));
3276 static void snd_trident_proc_read(struct snd_info_entry *entry,
3277 struct snd_info_buffer *buffer)
3279 struct snd_trident *trident = entry->private_data;
3282 switch (trident->device) {
3283 case TRIDENT_DEVICE_ID_SI7018:
3284 s = "SiS 7018 Audio";
3286 case TRIDENT_DEVICE_ID_DX:
3287 s = "Trident 4DWave PCI DX";
3289 case TRIDENT_DEVICE_ID_NX:
3290 s = "Trident 4DWave PCI NX";
3295 snd_iprintf(buffer, "%s\n\n", s);
3296 snd_iprintf(buffer, "Spurious IRQs : %d\n", trident->spurious_irq_count);
3297 snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta);
3298 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018)
3299 snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", trident->spdif_ctrl == 0x28 ? "on" : "off");
3300 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3301 snd_iprintf(buffer, "Rear Speakers : %s\n", trident->ac97_ctrl & 0x00000010 ? "on" : "off");
3302 if (trident->tlb.entries) {
3303 snd_iprintf(buffer,"\nVirtual Memory\n");
3304 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size);
3305 snd_iprintf(buffer, "Memory Used : %d\n", trident->tlb.memhdr->used);
3306 snd_iprintf(buffer, "Memory Free : %d\n", snd_util_mem_avail(trident->tlb.memhdr));
3311 static void snd_trident_proc_init(struct snd_trident *trident)
3313 const char *s = "trident";
3315 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
3317 snd_card_ro_proc_new(trident->card, s, trident, snd_trident_proc_read);
3320 static int snd_trident_dev_free(struct snd_device *device)
3322 struct snd_trident *trident = device->device_data;
3323 return snd_trident_free(trident);
3326 /*---------------------------------------------------------------------------
3327 snd_trident_tlb_alloc
3329 Description: Allocate and set up the TLB page table on 4D NX.
3330 Each entry has 4 bytes (physical PCI address).
3332 Parameters: trident - pointer to target device class for 4DWave.
3334 Returns: 0 or negative error code
3336 ---------------------------------------------------------------------------*/
3338 static int snd_trident_tlb_alloc(struct snd_trident *trident)
3342 /* TLB array must be aligned to 16kB !!! so we allocate
3343 32kB region and correct offset when necessary */
3345 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
3346 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
3347 dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
3350 trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
3351 trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4);
3352 /* allocate shadow TLB page table (virtual addresses) */
3353 trident->tlb.shadow_entries =
3354 vmalloc(array_size(SNDRV_TRIDENT_MAX_PAGES,
3355 sizeof(unsigned long)));
3356 if (!trident->tlb.shadow_entries)
3359 /* allocate and setup silent page and initialise TLB entries */
3360 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
3361 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
3362 dev_err(trident->card->dev, "unable to allocate silent page\n");
3365 memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE);
3366 for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++) {
3367 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
3368 trident->tlb.shadow_entries[i] = (unsigned long)trident->tlb.silent_page.area;
3371 /* use emu memory block manager code to manage tlb page allocation */
3372 trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES);
3373 if (trident->tlb.memhdr == NULL)
3376 trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
3381 * initialize 4D DX chip
3384 static void snd_trident_stop_all_voices(struct snd_trident *trident)
3386 outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
3387 outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
3388 outl(0, TRID_REG(trident, T4D_AINTEN_A));
3389 outl(0, TRID_REG(trident, T4D_AINTEN_B));
3392 static int snd_trident_4d_dx_init(struct snd_trident *trident)
3394 struct pci_dev *pci = trident->pci;
3395 unsigned long end_time;
3397 /* reset the legacy configuration and whole audio/wavetable block */
3398 pci_write_config_dword(pci, 0x40, 0); /* DDMA */
3399 pci_write_config_byte(pci, 0x44, 0); /* ports */
3400 pci_write_config_byte(pci, 0x45, 0); /* Legacy DMA */
3401 pci_write_config_byte(pci, 0x46, 4); /* reset */
3403 pci_write_config_byte(pci, 0x46, 0); /* release reset */
3406 /* warm reset of the AC'97 codec */
3407 outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3409 outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3410 /* DAC on, disable SB IRQ and try to force ADC valid signal */
3411 trident->ac97_ctrl = 0x0000004a;
3412 outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3413 /* wait, until the codec is ready */
3414 end_time = (jiffies + (HZ * 3) / 4) + 1;
3416 if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0)
3419 } while (time_after_eq(end_time, jiffies));
3420 dev_err(trident->card->dev, "AC'97 codec ready error\n");
3424 snd_trident_stop_all_voices(trident);
3430 * initialize 4D NX chip
3432 static int snd_trident_4d_nx_init(struct snd_trident *trident)
3434 struct pci_dev *pci = trident->pci;
3435 unsigned long end_time;
3437 /* reset the legacy configuration and whole audio/wavetable block */
3438 pci_write_config_dword(pci, 0x40, 0); /* DDMA */
3439 pci_write_config_byte(pci, 0x44, 0); /* ports */
3440 pci_write_config_byte(pci, 0x45, 0); /* Legacy DMA */
3442 pci_write_config_byte(pci, 0x46, 1); /* reset */
3444 pci_write_config_byte(pci, 0x46, 0); /* release reset */
3447 /* warm reset of the AC'97 codec */
3448 outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3450 outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3451 /* wait, until the codec is ready */
3452 end_time = (jiffies + (HZ * 3) / 4) + 1;
3454 if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0)
3457 } while (time_after_eq(end_time, jiffies));
3458 dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3459 inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
3464 trident->ac97_ctrl = 0x00000002;
3465 outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3466 /* disable SB IRQ */
3467 outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT));
3469 snd_trident_stop_all_voices(trident);
3471 if (trident->tlb.entries != NULL) {
3473 /* enable virtual addressing via TLB */
3474 i = trident->tlb.entries_dmaaddr;
3476 outl(i, TRID_REG(trident, NX_TLBC));
3478 outl(0, TRID_REG(trident, NX_TLBC));
3480 /* initialize S/PDIF */
3481 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
3482 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3488 * initialize sis7018 chip
3490 static int snd_trident_sis_init(struct snd_trident *trident)
3494 if ((err = snd_trident_sis_reset(trident)) < 0)
3497 snd_trident_stop_all_voices(trident);
3499 /* initialize S/PDIF */
3500 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
3505 /*---------------------------------------------------------------------------
3508 Description: This routine will create the device specific class for
3509 the 4DWave card. It will also perform basic initialization.
3511 Parameters: card - which card to create
3512 pci - interface to PCI bus resource info
3513 dma1ptr - playback dma buffer
3514 dma2ptr - capture dma buffer
3515 irqptr - interrupt resource info
3517 Returns: 4DWave device class private data
3519 ---------------------------------------------------------------------------*/
3521 int snd_trident_create(struct snd_card *card,
3522 struct pci_dev *pci,
3524 int pcm_spdif_device,
3525 int max_wavetable_size,
3526 struct snd_trident ** rtrident)
3528 struct snd_trident *trident;
3530 struct snd_trident_voice *voice;
3531 struct snd_trident_pcm_mixer *tmix;
3532 static struct snd_device_ops ops = {
3533 .dev_free = snd_trident_dev_free,
3538 /* enable PCI device */
3539 if ((err = pci_enable_device(pci)) < 0)
3541 /* check, if we can restrict PCI DMA transfers to 30 bits */
3542 if (dma_set_mask(&pci->dev, DMA_BIT_MASK(30)) < 0 ||
3543 dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(30)) < 0) {
3545 "architecture does not support 30bit PCI busmaster DMA\n");
3546 pci_disable_device(pci);
3550 trident = kzalloc(sizeof(*trident), GFP_KERNEL);
3551 if (trident == NULL) {
3552 pci_disable_device(pci);
3555 trident->device = (pci->vendor << 16) | pci->device;
3556 trident->card = card;
3558 spin_lock_init(&trident->reg_lock);
3559 spin_lock_init(&trident->event_lock);
3560 spin_lock_init(&trident->voice_alloc);
3561 if (pcm_streams < 1)
3563 if (pcm_streams > 32)
3565 trident->ChanPCM = pcm_streams;
3566 if (max_wavetable_size < 0 )
3567 max_wavetable_size = 0;
3568 trident->synth.max_size = max_wavetable_size * 1024;
3571 trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
3572 pci_set_master(pci);
3574 if ((err = pci_request_regions(pci, "Trident Audio")) < 0) {
3576 pci_disable_device(pci);
3579 trident->port = pci_resource_start(pci, 0);
3581 if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
3582 KBUILD_MODNAME, trident)) {
3583 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
3584 snd_trident_free(trident);
3587 trident->irq = pci->irq;
3589 /* allocate 16k-aligned TLB for NX cards */
3590 trident->tlb.entries = NULL;
3591 trident->tlb.buffer.area = NULL;
3592 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3593 if ((err = snd_trident_tlb_alloc(trident)) < 0) {
3594 snd_trident_free(trident);
3599 trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF;
3601 /* initialize chip */
3602 switch (trident->device) {
3603 case TRIDENT_DEVICE_ID_DX:
3604 err = snd_trident_4d_dx_init(trident);
3606 case TRIDENT_DEVICE_ID_NX:
3607 err = snd_trident_4d_nx_init(trident);
3609 case TRIDENT_DEVICE_ID_SI7018:
3610 err = snd_trident_sis_init(trident);
3617 snd_trident_free(trident);
3621 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) {
3622 snd_trident_free(trident);
3626 if ((err = snd_trident_mixer(trident, pcm_spdif_device)) < 0)
3629 /* initialise synth voices */
3630 for (i = 0; i < 64; i++) {
3631 voice = &trident->synth.voices[i];
3633 voice->trident = trident;
3635 /* initialize pcm mixer entries */
3636 for (i = 0; i < 32; i++) {
3637 tmix = &trident->pcm_mixer[i];
3638 tmix->vol = T4D_DEFAULT_PCM_VOL;
3639 tmix->pan = T4D_DEFAULT_PCM_PAN;
3640 tmix->rvol = T4D_DEFAULT_PCM_RVOL;
3641 tmix->cvol = T4D_DEFAULT_PCM_CVOL;
3644 snd_trident_enable_eso(trident);
3646 snd_trident_proc_init(trident);
3647 *rtrident = trident;
3651 /*---------------------------------------------------------------------------
3654 Description: This routine will free the device specific class for
3657 Parameters: trident - device specific private data for 4DWave card
3661 ---------------------------------------------------------------------------*/
3663 static int snd_trident_free(struct snd_trident *trident)
3665 snd_trident_free_gameport(trident);
3666 snd_trident_disable_eso(trident);
3667 // Disable S/PDIF out
3668 if (trident->device == TRIDENT_DEVICE_ID_NX)
3669 outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3670 else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
3671 outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3673 if (trident->irq >= 0)
3674 free_irq(trident->irq, trident);
3675 if (trident->tlb.buffer.area) {
3676 outl(0, TRID_REG(trident, NX_TLBC));
3677 snd_util_memhdr_free(trident->tlb.memhdr);
3678 if (trident->tlb.silent_page.area)
3679 snd_dma_free_pages(&trident->tlb.silent_page);
3680 vfree(trident->tlb.shadow_entries);
3681 snd_dma_free_pages(&trident->tlb.buffer);
3683 pci_release_regions(trident->pci);
3684 pci_disable_device(trident->pci);
3689 /*---------------------------------------------------------------------------
3690 snd_trident_interrupt
3692 Description: ISR for Trident 4DWave device
3694 Parameters: trident - device specific private data for 4DWave card
3696 Problems: It seems that Trident chips generates interrupts more than
3697 one time in special cases. The spurious interrupts are
3698 detected via sample timer (T4D_STIMER) and computing
3699 corresponding delta value. The limits are detected with
3700 the method try & fail so it is possible that it won't
3701 work on all computers. [jaroslav]
3705 ---------------------------------------------------------------------------*/
3707 static irqreturn_t snd_trident_interrupt(int irq, void *dev_id)
3709 struct snd_trident *trident = dev_id;
3710 unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
3712 struct snd_trident_voice *voice;
3714 audio_int = inl(TRID_REG(trident, T4D_MISCINT));
3715 if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
3717 if (audio_int & ADDRESS_IRQ) {
3718 // get interrupt status for all channels
3719 spin_lock(&trident->reg_lock);
3720 stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
3721 chn_int = inl(TRID_REG(trident, T4D_AINT_A));
3724 outl(chn_int, TRID_REG(trident, T4D_AINT_A)); /* ack */
3726 chn_int = inl(TRID_REG(trident, T4D_AINT_B));
3729 for (channel = 63; channel >= 32; channel--) {
3730 mask = 1 << (channel&0x1f);
3731 if ((chn_int & mask) == 0)
3733 voice = &trident->synth.voices[channel];
3734 if (!voice->pcm || voice->substream == NULL) {
3735 outl(mask, TRID_REG(trident, T4D_STOP_B));
3738 delta = (int)stimer - (int)voice->stimer;
3741 if ((unsigned int)delta < voice->spurious_threshold) {
3742 /* do some statistics here */
3743 trident->spurious_irq_count++;
3744 if (trident->spurious_irq_max_delta < (unsigned int)delta)
3745 trident->spurious_irq_max_delta = delta;
3748 voice->stimer = stimer;
3750 if (!voice->isync3) {
3751 tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL));
3752 if (trident->bDMAStart & 0x40)
3755 tmp = voice->isync_max - tmp;
3757 tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
3759 if (tmp < voice->isync_mark) {
3761 tmp = voice->isync_ESO - 7;
3763 tmp = voice->isync_ESO + 2;
3764 /* update ESO for IRQ voice to preserve sync */
3765 snd_trident_stop_voice(trident, voice->number);
3766 snd_trident_write_eso_reg(trident, voice, tmp);
3767 snd_trident_start_voice(trident, voice->number);
3769 } else if (voice->isync2) {
3771 /* write original ESO and update CSO for IRQ voice to preserve sync */
3772 snd_trident_stop_voice(trident, voice->number);
3773 snd_trident_write_cso_reg(trident, voice, voice->isync_mark);
3774 snd_trident_write_eso_reg(trident, voice, voice->ESO);
3775 snd_trident_start_voice(trident, voice->number);
3779 /* update CSO for extra voice to preserve sync */
3780 snd_trident_stop_voice(trident, voice->extra->number);
3781 snd_trident_write_cso_reg(trident, voice->extra, 0);
3782 snd_trident_start_voice(trident, voice->extra->number);
3785 spin_unlock(&trident->reg_lock);
3786 snd_pcm_period_elapsed(voice->substream);
3787 spin_lock(&trident->reg_lock);
3789 outl(chn_int, TRID_REG(trident, T4D_AINT_B)); /* ack */
3791 spin_unlock(&trident->reg_lock);
3793 if (audio_int & MPU401_IRQ) {
3794 if (trident->rmidi) {
3795 snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);
3797 inb(TRID_REG(trident, T4D_MPUR0));
3800 // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
3804 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
3806 struct snd_trident_voice *pvoice;
3807 unsigned long flags;
3810 spin_lock_irqsave(&trident->voice_alloc, flags);
3811 if (type == SNDRV_TRIDENT_VOICE_TYPE_PCM) {
3812 idx = snd_trident_allocate_pcm_channel(trident);
3814 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3817 pvoice = &trident->synth.voices[idx];
3820 pvoice->capture = 0;
3822 pvoice->memblk = NULL;
3823 pvoice->substream = NULL;
3824 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3827 if (type == SNDRV_TRIDENT_VOICE_TYPE_SYNTH) {
3828 idx = snd_trident_allocate_synth_channel(trident);
3830 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3833 pvoice = &trident->synth.voices[idx];
3836 pvoice->client = client;
3837 pvoice->port = port;
3838 pvoice->memblk = NULL;
3839 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3842 if (type == SNDRV_TRIDENT_VOICE_TYPE_MIDI) {
3844 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3848 EXPORT_SYMBOL(snd_trident_alloc_voice);
3850 void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
3852 unsigned long flags;
3853 void (*private_free)(struct snd_trident_voice *);
3855 if (voice == NULL || !voice->use)
3857 snd_trident_clear_voices(trident, voice->number, voice->number);
3858 spin_lock_irqsave(&trident->voice_alloc, flags);
3859 private_free = voice->private_free;
3860 voice->private_free = NULL;
3861 voice->private_data = NULL;
3863 snd_trident_free_pcm_channel(trident, voice->number);
3865 snd_trident_free_synth_channel(trident, voice->number);
3866 voice->use = voice->pcm = voice->synth = voice->midi = 0;
3867 voice->capture = voice->spdif = 0;
3868 voice->sample_ops = NULL;
3869 voice->substream = NULL;
3870 voice->extra = NULL;
3871 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3873 private_free(voice);
3876 EXPORT_SYMBOL(snd_trident_free_voice);
3878 static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
3880 unsigned int i, val, mask[2] = { 0, 0 };
3882 if (snd_BUG_ON(v_min > 63 || v_max > 63))
3884 for (i = v_min; i <= v_max; i++)
3885 mask[i >> 5] |= 1 << (i & 0x1f);
3887 outl(mask[0], TRID_REG(trident, T4D_STOP_A));
3888 val = inl(TRID_REG(trident, T4D_AINTEN_A));
3889 outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A));
3892 outl(mask[1], TRID_REG(trident, T4D_STOP_B));
3893 val = inl(TRID_REG(trident, T4D_AINTEN_B));
3894 outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B));
3898 #ifdef CONFIG_PM_SLEEP
3899 static int snd_trident_suspend(struct device *dev)
3901 struct snd_card *card = dev_get_drvdata(dev);
3902 struct snd_trident *trident = card->private_data;
3904 trident->in_suspend = 1;
3905 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
3906 snd_ac97_suspend(trident->ac97);
3907 snd_ac97_suspend(trident->ac97_sec);
3911 static int snd_trident_resume(struct device *dev)
3913 struct snd_card *card = dev_get_drvdata(dev);
3914 struct snd_trident *trident = card->private_data;
3916 switch (trident->device) {
3917 case TRIDENT_DEVICE_ID_DX:
3918 snd_trident_4d_dx_init(trident);
3920 case TRIDENT_DEVICE_ID_NX:
3921 snd_trident_4d_nx_init(trident);
3923 case TRIDENT_DEVICE_ID_SI7018:
3924 snd_trident_sis_init(trident);
3928 snd_ac97_resume(trident->ac97);
3929 snd_ac97_resume(trident->ac97_sec);
3931 /* restore some registers */
3932 outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3934 snd_trident_enable_eso(trident);
3936 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
3937 trident->in_suspend = 0;
3941 SIMPLE_DEV_PM_OPS(snd_trident_pm, snd_trident_suspend, snd_trident_resume);
3942 #endif /* CONFIG_PM_SLEEP */