Lines Matching refs:trident
31 #include "trident.h"
34 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
37 static int snd_trident_pcm_mixer_free(struct snd_trident *trident,
41 static int snd_trident_sis_reset(struct snd_trident *trident);
43 static void snd_trident_clear_voices(struct snd_trident * trident,
53 static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)
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));
77 val = inl(TRID_REG(trident, CH_NX_DELTA_CSO));
79 dev_dbg(trident->card->dev, "CSO: 0x%x\n", val & 0x00ffffff);
80 val = inl(TRID_REG(trident, CH_NX_DELTA_ESO));
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);
111 struct snd_trident *trident = ac97->private_data;
113 spin_lock_irqsave(&trident->reg_lock, flags);
114 if (trident->device == TRIDENT_DEVICE_ID_DX) {
116 outl(data, TRID_REG(trident, DX_ACR1_AC97_R));
118 data = inl(TRID_REG(trident, DX_ACR1_AC97_R));
122 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
125 outl(data, TRID_REG(trident, treg));
127 data = inl(TRID_REG(trident, treg));
131 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
135 outl(data, TRID_REG(trident, SI_AC97_READ));
137 data = inl(TRID_REG(trident, SI_AC97_READ));
143 if (count == 0 && !trident->ac97_detect) {
144 dev_err(trident->card->dev,
150 spin_unlock_irqrestore(&trident->reg_lock, flags);
174 struct snd_trident *trident = ac97->private_data;
178 spin_lock_irqsave(&trident->reg_lock, flags);
179 if (trident->device == TRIDENT_DEVICE_ID_DX) {
184 if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0)
189 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
194 if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0)
199 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
204 if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0)
217 spin_unlock_irqrestore(&trident->reg_lock, flags);
220 outl(data, TRID_REG(trident, address));
221 spin_unlock_irqrestore(&trident->reg_lock, flags);
225 void snd_trident_enable_eso(struct snd_trident *trident)
232 Parameters: trident - pointer to target device class for 4DWave.
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));
249 void snd_trident_disable_eso(struct snd_trident *trident)
257 trident - pointer to target device class for 4DWave.
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));
274 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
281 trident - pointer to target device class for 4DWave.
287 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
292 outl(mask, TRID_REG(trident, reg));
298 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
305 trident - pointer to target device class for 4DWave.
311 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
316 outl(mask, TRID_REG(trident, reg));
322 int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
326 Parameters : trident - pointer to target device class for 4DWave.
332 static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
336 if (trident->ChanPCMcnt >= trident->ChanPCM)
339 if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) {
340 trident->ChanMap[T4D_BANK_B] |= 1 << idx;
341 trident->ChanPCMcnt++;
353 Parameters : trident - pointer to target device class for 4DWave.
360 static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
365 if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) {
366 trident->ChanMap[T4D_BANK_B] &= ~(1 << channel);
367 trident->ChanPCMcnt--;
376 Parameters : trident - pointer to target device class for 4DWave.
382 static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
387 if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) {
388 trident->ChanMap[T4D_BANK_A] |= 1 << idx;
389 trident->synth.ChanSynthCount++;
401 Parameters : trident - pointer to target device class for 4DWave.
408 static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
413 if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) {
414 trident->ChanMap[T4D_BANK_A] &= ~(1 << channel);
415 trident->synth.ChanSynthCount--;
425 Parameters: trident - pointer to target device class for 4DWave.
431 void snd_trident_write_voice_regs(struct snd_trident * trident,
445 switch (trident->device) {
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)));
508 Parameters: trident - pointer to target device class for 4DWave.
514 static void snd_trident_write_cso_reg(struct snd_trident * trident,
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);
524 (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
534 Parameters: trident - pointer to target device class for 4DWave.
540 static void snd_trident_write_eso_reg(struct snd_trident * trident,
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);
550 TRID_REG(trident, CH_NX_DELTA_ESO));
560 Parameters: trident - pointer to target device class for 4DWave.
566 static void snd_trident_write_vol_reg(struct snd_trident * trident,
571 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
572 switch (trident->device) {
575 outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
578 /* dev_dbg(trident->card->dev, "voice->Vol = 0x%x\n", voice->Vol); */
580 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
591 Parameters: trident - pointer to target device class for 4DWave.
597 static void snd_trident_write_pan_reg(struct snd_trident * trident,
602 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
604 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
613 Parameters: trident - pointer to target device class for 4DWave.
619 static void snd_trident_write_rvol_reg(struct snd_trident * trident,
624 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
627 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
637 Parameters: trident - pointer to target device class for 4DWave.
643 static void snd_trident_write_cvol_reg(struct snd_trident * trident,
648 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
651 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
660 Parameters: trident - pointer to target device class for 4DWave.
690 Parameters: trident - pointer to target device class for 4DWave.
720 Parameters: trident - pointer to target device class for 4DWave.
742 Parameters: trident - pointer to target device class for 4DWave.
785 struct snd_trident *trident = snd_pcm_substream_chip(substream);
789 if (trident->tlb.entries) {
792 snd_trident_free_pages(trident, voice->memblk);
793 voice->memblk = snd_trident_alloc_pages(trident, substream);
816 struct snd_trident *trident = snd_pcm_substream_chip(substream);
825 evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
833 snd_trident_free_voice(trident, evoice);
877 struct snd_trident *trident = snd_pcm_substream_chip(substream);
882 if (trident->tlb.entries) {
884 snd_trident_free_pages(trident, voice->memblk);
889 snd_trident_free_voice(trident, evoice);
908 struct snd_trident *trident = snd_pcm_substream_chip(substream);
912 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
914 spin_lock_irq(&trident->reg_lock);
946 snd_trident_write_voice_regs(trident, voice);
956 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
969 snd_trident_write_voice_regs(trident, evoice);
975 spin_unlock_irq(&trident->reg_lock);
1011 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1016 spin_lock_irq(&trident->reg_lock);
1019 outb(0, TRID_REG(trident, LEGACY_DMAR15));
1022 outb(0x54, TRID_REG(trident, LEGACY_DMAR11));
1026 outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
1032 outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6));
1033 outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4));
1038 outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R));
1047 outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL));
1051 trident->bDMAStart = 0x19; // 0001 1001b
1054 trident->bDMAStart |= 0x80;
1056 trident->bDMAStart |= 0x20;
1058 trident->bDMAStart |= 0x40;
1083 snd_trident_write_voice_regs(trident, voice);
1085 spin_unlock_irq(&trident->reg_lock);
1120 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1126 snd_trident_free_voice(trident, evoice);
1145 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1150 spin_lock_irq(&trident->reg_lock);
1175 snd_trident_write_voice_regs(trident, voice);
1193 snd_trident_write_voice_regs(trident, evoice);
1199 spin_unlock_irq(&trident->reg_lock);
1216 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1221 spin_lock_irq(&trident->reg_lock);
1250 outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan));
1252 snd_trident_write_voice_regs(trident, voice);
1262 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1270 snd_trident_write_voice_regs(trident, evoice);
1276 spin_unlock_irq(&trident->reg_lock);
1295 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1303 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1310 spin_lock_irq(&trident->reg_lock);
1311 old_bits = trident->spdif_pcm_bits;
1313 trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS;
1315 trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24);
1317 trident->spdif_pcm_ctrl = 0x3c; // 48000 Hz
1318 trident->spdif_pcm_bits |=
1319 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1324 trident->spdif_pcm_ctrl = 0x3e; // 44100 Hz
1325 trident->spdif_pcm_bits |=
1326 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1331 trident->spdif_pcm_ctrl = 0x3d; // 32000 Hz
1332 trident->spdif_pcm_bits |=
1333 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1337 change = old_bits != trident->spdif_pcm_bits;
1338 spin_unlock_irq(&trident->reg_lock);
1341 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id);
1359 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1363 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
1367 spin_lock_irq(&trident->reg_lock);
1369 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1407 snd_trident_write_voice_regs(trident, voice);
1409 outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO));
1410 outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2));
1411 outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA));
1412 outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO));
1413 outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2));
1416 outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1417 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1446 snd_trident_write_voice_regs(trident, voice);
1456 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1464 snd_trident_write_voice_regs(trident, evoice);
1470 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1471 temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
1473 outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR));
1474 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1476 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1479 spin_unlock_irq(&trident->reg_lock);
1500 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1521 spin_lock(&trident->reg_lock);
1522 val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
1524 if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
1550 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1551 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1552 val = trident->spdif_pcm_ctrl;
1555 outb(val, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1557 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1558 val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN;
1559 outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1563 outl(what, TRID_REG(trident, T4D_STOP_B));
1564 val = inl(TRID_REG(trident, T4D_AINTEN_B));
1570 outl(val, TRID_REG(trident, T4D_AINTEN_B));
1572 outl(what, TRID_REG(trident, T4D_START_B));
1574 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1575 outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1577 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1578 outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1580 spin_unlock(&trident->reg_lock);
1597 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1605 spin_lock(&trident->reg_lock);
1607 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
1609 if (trident->device != TRIDENT_DEVICE_ID_NX) {
1610 cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2));
1612 cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff;
1615 spin_unlock(&trident->reg_lock);
1636 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1644 result = inw(TRID_REG(trident, T4D_SBBL_SBCL));
1666 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1674 result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
1801 struct snd_trident *trident;
1804 trident = voice->trident;
1805 snd_trident_free_voice(trident, voice);
1811 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1815 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1818 snd_trident_pcm_mixer_build(trident, voice, substream);
1839 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1843 snd_trident_pcm_mixer_free(trident, voice, substream);
1860 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1864 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1869 spin_lock_irq(&trident->reg_lock);
1870 trident->spdif_pcm_bits = trident->spdif_bits;
1871 spin_unlock_irq(&trident->reg_lock);
1875 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1881 trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1882 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1883 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1901 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1904 spin_lock_irq(&trident->reg_lock);
1906 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1907 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1908 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
1910 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
1911 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1912 if (trident->spdif_ctrl) {
1917 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1919 spin_unlock_irq(&trident->reg_lock);
1920 trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1921 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1922 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1939 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1943 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1983 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1987 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
2010 struct snd_trident *trident = snd_pcm_substream_chip(substream);
2016 spin_lock_irq(&trident->reg_lock);
2017 outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan));
2018 spin_unlock_irq(&trident->reg_lock);
2111 Parameters: trident - pointer to target device class for 4DWave.
2117 int snd_trident_pcm(struct snd_trident *trident, int device)
2122 err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm);
2126 pcm->private_data = trident;
2128 if (trident->tlb.entries) {
2134 trident->device != TRIDENT_DEVICE_ID_SI7018 ?
2141 trident->pcm = pcm;
2143 if (trident->tlb.entries) {
2147 &trident->pci->dev,
2151 &trident->pci->dev,
2155 &trident->pci->dev,
2167 Parameters: trident - pointer to target device class for 4DWave.
2173 int snd_trident_foldback_pcm(struct snd_trident *trident, int device)
2180 if (trident->device == TRIDENT_DEVICE_ID_NX)
2182 err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback);
2186 foldback->private_data = trident;
2187 if (trident->tlb.entries)
2203 trident->foldback = foldback;
2205 if (trident->tlb.entries)
2207 &trident->pci->dev,
2211 &trident->pci->dev,
2222 Parameters: trident - pointer to target device class for 4DWave-NX.
2228 int snd_trident_spdif_pcm(struct snd_trident *trident, int device)
2233 err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif);
2237 spdif->private_data = trident;
2238 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2245 trident->spdif = spdif;
2248 &trident->pci->dev, 64*1024, 128*1024);
2269 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2272 spin_lock_irq(&trident->reg_lock);
2273 val = trident->spdif_ctrl;
2275 spin_unlock_irq(&trident->reg_lock);
2282 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2287 spin_lock_irq(&trident->reg_lock);
2289 change = trident->spdif_ctrl != val;
2290 trident->spdif_ctrl = val;
2291 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2292 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) {
2293 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2294 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
2297 if (trident->spdif == NULL) {
2299 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2300 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN;
2303 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
2306 spin_unlock_irq(&trident->reg_lock);
2337 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2339 spin_lock_irq(&trident->reg_lock);
2340 ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
2341 ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
2342 ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
2343 ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
2344 spin_unlock_irq(&trident->reg_lock);
2351 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2359 spin_lock_irq(&trident->reg_lock);
2360 change = trident->spdif_bits != val;
2361 trident->spdif_bits = val;
2362 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2363 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0)
2364 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2366 if (trident->spdif == NULL)
2367 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2369 spin_unlock_irq(&trident->reg_lock);
2432 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2434 spin_lock_irq(&trident->reg_lock);
2435 ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
2436 ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
2437 ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
2438 ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
2439 spin_unlock_irq(&trident->reg_lock);
2446 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2454 spin_lock_irq(&trident->reg_lock);
2455 change = trident->spdif_pcm_bits != val;
2456 trident->spdif_pcm_bits = val;
2457 if (trident->spdif != NULL) {
2458 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2459 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
2461 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2464 spin_unlock_irq(&trident->reg_lock);
2489 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2492 spin_lock_irq(&trident->reg_lock);
2493 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2495 spin_unlock_irq(&trident->reg_lock);
2502 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2506 spin_lock_irq(&trident->reg_lock);
2507 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2511 change = val != trident->ac97_ctrl;
2512 trident->ac97_ctrl = val;
2513 outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2514 spin_unlock_irq(&trident->reg_lock);
2547 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2550 val = trident->musicvol_wavevol;
2561 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2565 spin_lock_irq(&trident->reg_lock);
2566 val = trident->musicvol_wavevol;
2570 change = val != trident->musicvol_wavevol;
2571 outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2572 spin_unlock_irq(&trident->reg_lock);
2607 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2613 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
2621 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2622 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2624 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2635 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2636 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2640 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2645 spin_lock_irq(&trident->reg_lock);
2649 snd_trident_write_vol_reg(trident, mix->voice, val);
2650 spin_unlock_irq(&trident->reg_lock);
2685 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2686 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2700 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2701 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2709 spin_lock_irq(&trident->reg_lock);
2713 snd_trident_write_pan_reg(trident, mix->voice, val);
2714 spin_unlock_irq(&trident->reg_lock);
2748 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2749 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2758 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2759 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2764 spin_lock_irq(&trident->reg_lock);
2768 snd_trident_write_rvol_reg(trident, mix->voice, val);
2769 spin_unlock_irq(&trident->reg_lock);
2806 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2807 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2816 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2817 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2822 spin_lock_irq(&trident->reg_lock);
2826 snd_trident_write_cvol_reg(trident, mix->voice, val);
2827 spin_unlock_irq(&trident->reg_lock);
2860 static void snd_trident_notify_pcm_change(struct snd_trident *trident,
2864 snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
2865 snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
2866 snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate);
2867 snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
2870 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
2876 if (snd_BUG_ON(!trident || !voice || !substream))
2878 tmix = &trident->pcm_mixer[substream->number];
2884 snd_trident_notify_pcm_change(trident, tmix, substream->number, 1);
2888 static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
2892 if (snd_BUG_ON(!trident || !substream))
2894 tmix = &trident->pcm_mixer[substream->number];
2896 snd_trident_notify_pcm_change(trident, tmix, substream->number, 0);
2905 Parameters: trident - pointer to target device class for 4DWave.
2911 static int snd_trident_mixer(struct snd_trident *trident, int pcm_spdif_device)
2914 struct snd_card *card = trident->card;
2927 err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus);
2932 _ac97.private_data = trident;
2933 trident->ac97_detect = 1;
2936 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97);
2938 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2939 err = snd_trident_sis_reset(trident);
2950 if (trident->device == TRIDENT_DEVICE_ID_SI7018 &&
2951 (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) {
2953 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
2955 dev_err(trident->card->dev,
2960 err = snd_ac97_modem(trident->card, &_ac97, &mc97);
2962 dev_err(trident->card->dev,
2968 trident->ac97_detect = 0;
2970 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2971 kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident);
2976 kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident);
2981 outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2983 outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2989 tmix = &trident->pcm_mixer[idx];
2992 trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident);
2993 if (!trident->ctl_vol)
2995 err = snd_ctl_add(card, trident->ctl_vol);
2999 trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident);
3000 if (!trident->ctl_pan)
3002 err = snd_ctl_add(card, trident->ctl_pan);
3006 trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident);
3007 if (!trident->ctl_rvol)
3009 err = snd_ctl_add(card, trident->ctl_rvol);
3013 trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident);
3014 if (!trident->ctl_cvol)
3016 err = snd_ctl_add(card, trident->ctl_cvol);
3020 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3021 kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident);
3027 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
3029 kctl = snd_ctl_new1(&snd_trident_spdif_control, trident);
3034 if (trident->ac97->ext_id & AC97_EI_SPDIF)
3036 if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF))
3044 kctl = snd_ctl_new1(&snd_trident_spdif_default, trident);
3055 kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident);
3066 kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident);
3076 trident->spdif_pcm_ctl = kctl;
3204 static int snd_trident_sis_reset(struct snd_trident *trident)
3210 r = trident->in_suspend ? 0 : 2; /* count of retries */
3212 pci_write_config_byte(trident->pci, 0x46, 0x04); /* SOFTWARE RESET */
3214 pci_write_config_byte(trident->pci, 0x46, 0x00);
3217 outb(0x00, TRID_REG(trident, SI_AC97_GPIO));
3220 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3224 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3229 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0)
3231 do_delay(trident);
3233 dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3234 inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
3238 do_delay(trident);
3245 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0)
3247 do_delay(trident);
3250 outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR));
3261 struct snd_trident *trident = entry->private_data;
3264 switch (trident->device) {
3278 snd_iprintf(buffer, "Spurious IRQs : %d\n", trident->spurious_irq_count);
3279 snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta);
3280 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018)
3281 snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", trident->spdif_ctrl == 0x28 ? "on" : "off");
3282 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3283 snd_iprintf(buffer, "Rear Speakers : %s\n", trident->ac97_ctrl & 0x00000010 ? "on" : "off");
3284 if (trident->tlb.entries) {
3286 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size);
3287 snd_iprintf(buffer, "Memory Used : %d\n", trident->tlb.memhdr->used);
3288 snd_iprintf(buffer, "Memory Free : %d\n", snd_util_mem_avail(trident->tlb.memhdr));
3293 static void snd_trident_proc_init(struct snd_trident *trident)
3295 const char *s = "trident";
3297 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
3299 snd_card_ro_proc_new(trident->card, s, trident, snd_trident_proc_read);
3308 Parameters: trident - pointer to target device class for 4DWave.
3314 static int snd_trident_tlb_alloc(struct snd_trident *trident)
3321 trident->tlb.buffer =
3322 snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
3324 if (!trident->tlb.buffer) {
3325 dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
3328 trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer->area, SNDRV_TRIDENT_MAX_PAGES * 4);
3329 trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer->addr, SNDRV_TRIDENT_MAX_PAGES * 4);
3332 trident->tlb.silent_page =
3333 snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
3335 if (!trident->tlb.silent_page) {
3336 dev_err(trident->card->dev, "unable to allocate silent page\n");
3339 memset(trident->tlb.silent_page->area, 0, SNDRV_TRIDENT_PAGE_SIZE);
3341 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page->addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
3344 trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES);
3345 if (trident->tlb.memhdr == NULL)
3348 trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
3356 static void snd_trident_stop_all_voices(struct snd_trident *trident)
3358 outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
3359 outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
3360 outl(0, TRID_REG(trident, T4D_AINTEN_A));
3361 outl(0, TRID_REG(trident, T4D_AINTEN_B));
3364 static int snd_trident_4d_dx_init(struct snd_trident *trident)
3366 struct pci_dev *pci = trident->pci;
3379 outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3381 outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3383 trident->ac97_ctrl = 0x0000004a;
3384 outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3388 if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0)
3390 do_delay(trident);
3392 dev_err(trident->card->dev, "AC'97 codec ready error\n");
3396 snd_trident_stop_all_voices(trident);
3404 static int snd_trident_4d_nx_init(struct snd_trident *trident)
3406 struct pci_dev *pci = trident->pci;
3420 outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3422 outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3426 if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0)
3428 do_delay(trident);
3430 dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3431 inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
3436 trident->ac97_ctrl = 0x00000002;
3437 outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3439 outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT));
3441 snd_trident_stop_all_voices(trident);
3443 if (trident->tlb.entries != NULL) {
3446 i = trident->tlb.entries_dmaaddr;
3448 outl(i, TRID_REG(trident, NX_TLBC));
3450 outl(0, TRID_REG(trident, NX_TLBC));
3453 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
3454 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3462 static int snd_trident_sis_init(struct snd_trident *trident)
3466 err = snd_trident_sis_reset(trident);
3470 snd_trident_stop_all_voices(trident);
3473 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
3500 struct snd_trident *trident = card->private_data;
3516 trident->device = (pci->vendor << 16) | pci->device;
3517 trident->card = card;
3518 trident->pci = pci;
3519 spin_lock_init(&trident->reg_lock);
3520 spin_lock_init(&trident->event_lock);
3521 spin_lock_init(&trident->voice_alloc);
3526 trident->ChanPCM = pcm_streams;
3529 trident->synth.max_size = max_wavetable_size * 1024;
3530 trident->irq = -1;
3533 trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
3539 trident->port = pci_resource_start(pci, 0);
3542 IRQF_SHARED, KBUILD_MODNAME, trident)) {
3546 trident->irq = pci->irq;
3547 card->sync_irq = trident->irq;
3550 trident->tlb.entries = NULL;
3551 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3552 err = snd_trident_tlb_alloc(trident);
3557 trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF;
3560 switch (trident->device) {
3562 err = snd_trident_4d_dx_init(trident);
3565 err = snd_trident_4d_nx_init(trident);
3568 err = snd_trident_sis_init(trident);
3577 err = snd_trident_mixer(trident, pcm_spdif_device);
3583 voice = &trident->synth.voices[i];
3585 voice->trident = trident;
3589 tmix = &trident->pcm_mixer[i];
3596 snd_trident_enable_eso(trident);
3598 snd_trident_proc_init(trident);
3616 struct snd_trident *trident = card->private_data;
3618 snd_trident_free_gameport(trident);
3619 snd_trident_disable_eso(trident);
3621 if (trident->device == TRIDENT_DEVICE_ID_NX)
3622 outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3623 else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
3624 outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3626 if (trident->tlb.buffer) {
3627 outl(0, TRID_REG(trident, NX_TLBC));
3628 snd_util_memhdr_free(trident->tlb.memhdr);
3637 Parameters: trident - device specific private data for 4DWave card
3652 struct snd_trident *trident = dev_id;
3657 audio_int = inl(TRID_REG(trident, T4D_MISCINT));
3662 spin_lock(&trident->reg_lock);
3663 stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
3664 chn_int = inl(TRID_REG(trident, T4D_AINT_A));
3667 outl(chn_int, TRID_REG(trident, T4D_AINT_A)); /* ack */
3669 chn_int = inl(TRID_REG(trident, T4D_AINT_B));
3676 voice = &trident->synth.voices[channel];
3678 outl(mask, TRID_REG(trident, T4D_STOP_B));
3686 trident->spurious_irq_count++;
3687 if (trident->spurious_irq_max_delta < (unsigned int)delta)
3688 trident->spurious_irq_max_delta = delta;
3694 tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL));
3695 if (trident->bDMAStart & 0x40)
3700 tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
3708 snd_trident_stop_voice(trident, voice->number);
3709 snd_trident_write_eso_reg(trident, voice, tmp);
3710 snd_trident_start_voice(trident, voice->number);
3715 snd_trident_stop_voice(trident, voice->number);
3716 snd_trident_write_cso_reg(trident, voice, voice->isync_mark);
3717 snd_trident_write_eso_reg(trident, voice, voice->ESO);
3718 snd_trident_start_voice(trident, voice->number);
3723 snd_trident_stop_voice(trident, voice->extra->number);
3724 snd_trident_write_cso_reg(trident, voice->extra, 0);
3725 snd_trident_start_voice(trident, voice->extra->number);
3728 spin_unlock(&trident->reg_lock);
3730 spin_lock(&trident->reg_lock);
3732 outl(chn_int, TRID_REG(trident, T4D_AINT_B)); /* ack */
3734 spin_unlock(&trident->reg_lock);
3737 if (trident->rmidi) {
3738 snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);
3740 inb(TRID_REG(trident, T4D_MPUR0));
3743 // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
3747 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
3753 spin_lock_irqsave(&trident->voice_alloc, flags);
3755 idx = snd_trident_allocate_pcm_channel(trident);
3757 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3760 pvoice = &trident->synth.voices[idx];
3767 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3771 idx = snd_trident_allocate_synth_channel(trident);
3773 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3776 pvoice = &trident->synth.voices[idx];
3782 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3787 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3793 void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
3800 snd_trident_clear_voices(trident, voice->number, voice->number);
3801 spin_lock_irqsave(&trident->voice_alloc, flags);
3806 snd_trident_free_pcm_channel(trident, voice->number);
3808 snd_trident_free_synth_channel(trident, voice->number);
3814 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3821 static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
3830 outl(mask[0], TRID_REG(trident, T4D_STOP_A));
3831 val = inl(TRID_REG(trident, T4D_AINTEN_A));
3832 outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A));
3835 outl(mask[1], TRID_REG(trident, T4D_STOP_B));
3836 val = inl(TRID_REG(trident, T4D_AINTEN_B));
3837 outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B));
3845 struct snd_trident *trident = card->private_data;
3847 trident->in_suspend = 1;
3849 snd_ac97_suspend(trident->ac97);
3850 snd_ac97_suspend(trident->ac97_sec);
3857 struct snd_trident *trident = card->private_data;
3859 switch (trident->device) {
3861 snd_trident_4d_dx_init(trident);
3864 snd_trident_4d_nx_init(trident);
3867 snd_trident_sis_init(trident);
3871 snd_ac97_resume(trident->ac97);
3872 snd_ac97_resume(trident->ac97_sec);
3875 outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3877 snd_trident_enable_eso(trident);
3880 trident->in_suspend = 0;