Lines Matching defs: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);
110 struct snd_trident *trident = ac97->private_data;
112 guard(spinlock_irqsave)(&trident->reg_lock);
113 if (trident->device == TRIDENT_DEVICE_ID_DX) {
115 outl(data, TRID_REG(trident, DX_ACR1_AC97_R));
117 data = inl(TRID_REG(trident, DX_ACR1_AC97_R));
121 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
124 outl(data, TRID_REG(trident, treg));
126 data = inl(TRID_REG(trident, treg));
130 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
134 outl(data, TRID_REG(trident, SI_AC97_READ));
136 data = inl(TRID_REG(trident, SI_AC97_READ));
142 if (count == 0 && !trident->ac97_detect) {
143 dev_err(trident->card->dev,
171 struct snd_trident *trident = ac97->private_data;
175 guard(spinlock_irqsave)(&trident->reg_lock);
176 if (trident->device == TRIDENT_DEVICE_ID_DX) {
181 if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0)
186 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
191 if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0)
196 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
201 if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0)
215 outl(data, TRID_REG(trident, address));
219 void snd_trident_enable_eso(struct snd_trident *trident)
226 Parameters: trident - pointer to target device class for 4DWave.
230 static void snd_trident_enable_eso(struct snd_trident * trident)
234 val = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
237 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
239 outl(val, TRID_REG(trident, T4D_LFO_GC_CIR));
243 void snd_trident_disable_eso(struct snd_trident *trident)
251 trident - pointer to target device class for 4DWave.
257 static void snd_trident_disable_eso(struct snd_trident * trident)
261 tmp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
264 outl(tmp, TRID_REG(trident, T4D_LFO_GC_CIR));
268 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
275 trident - pointer to target device class for 4DWave.
281 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
286 outl(mask, TRID_REG(trident, reg));
292 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
299 trident - pointer to target device class for 4DWave.
305 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
310 outl(mask, TRID_REG(trident, reg));
316 int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
320 Parameters : trident - pointer to target device class for 4DWave.
326 static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
330 if (trident->ChanPCMcnt >= trident->ChanPCM)
333 if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) {
334 trident->ChanMap[T4D_BANK_B] |= 1 << idx;
335 trident->ChanPCMcnt++;
347 Parameters : trident - pointer to target device class for 4DWave.
354 static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
359 if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) {
360 trident->ChanMap[T4D_BANK_B] &= ~(1 << channel);
361 trident->ChanPCMcnt--;
370 Parameters : trident - pointer to target device class for 4DWave.
376 static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
381 if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) {
382 trident->ChanMap[T4D_BANK_A] |= 1 << idx;
383 trident->synth.ChanSynthCount++;
395 Parameters : trident - pointer to target device class for 4DWave.
402 static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
407 if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) {
408 trident->ChanMap[T4D_BANK_A] &= ~(1 << channel);
409 trident->synth.ChanSynthCount--;
419 Parameters: trident - pointer to target device class for 4DWave.
425 void snd_trident_write_voice_regs(struct snd_trident * trident,
439 switch (trident->device) {
472 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
473 outl(regs[0], TRID_REG(trident, CH_START + 0));
474 outl(regs[1], TRID_REG(trident, CH_START + 4));
475 outl(regs[2], TRID_REG(trident, CH_START + 8));
476 outl(regs[3], TRID_REG(trident, CH_START + 12));
477 outl(regs[4], TRID_REG(trident, CH_START + 16));
480 dev_dbg(trident->card->dev, "written %i channel:\n", voice->number);
481 dev_dbg(trident->card->dev, " regs[0] = 0x%x/0x%x\n",
482 regs[0], inl(TRID_REG(trident, CH_START + 0)));
483 dev_dbg(trident->card->dev, " regs[1] = 0x%x/0x%x\n",
484 regs[1], inl(TRID_REG(trident, CH_START + 4)));
485 dev_dbg(trident->card->dev, " regs[2] = 0x%x/0x%x\n",
486 regs[2], inl(TRID_REG(trident, CH_START + 8)));
487 dev_dbg(trident->card->dev, " regs[3] = 0x%x/0x%x\n",
488 regs[3], inl(TRID_REG(trident, CH_START + 12)));
489 dev_dbg(trident->card->dev, " regs[4] = 0x%x/0x%x\n",
490 regs[4], inl(TRID_REG(trident, CH_START + 16)));
502 Parameters: trident - pointer to target device class for 4DWave.
508 static void snd_trident_write_cso_reg(struct snd_trident * trident,
513 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
514 if (trident->device != TRIDENT_DEVICE_ID_NX) {
515 outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2);
518 (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
528 Parameters: trident - pointer to target device class for 4DWave.
534 static void snd_trident_write_eso_reg(struct snd_trident * trident,
539 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
540 if (trident->device != TRIDENT_DEVICE_ID_NX) {
541 outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2);
544 TRID_REG(trident, CH_NX_DELTA_ESO));
554 Parameters: trident - pointer to target device class for 4DWave.
560 static void snd_trident_write_vol_reg(struct snd_trident * trident,
565 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
566 switch (trident->device) {
569 outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
572 /* dev_dbg(trident->card->dev, "voice->Vol = 0x%x\n", voice->Vol); */
574 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
585 Parameters: trident - pointer to target device class for 4DWave.
591 static void snd_trident_write_pan_reg(struct snd_trident * trident,
596 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
598 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
607 Parameters: trident - pointer to target device class for 4DWave.
613 static void snd_trident_write_rvol_reg(struct snd_trident * trident,
618 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
621 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
631 Parameters: trident - pointer to target device class for 4DWave.
637 static void snd_trident_write_cvol_reg(struct snd_trident * trident,
642 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
645 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
654 Parameters: trident - pointer to target device class for 4DWave.
684 Parameters: trident - pointer to target device class for 4DWave.
714 Parameters: trident - pointer to target device class for 4DWave.
736 Parameters: trident - pointer to target device class for 4DWave.
779 struct snd_trident *trident = snd_pcm_substream_chip(substream);
783 if (trident->tlb.entries) {
786 snd_trident_free_pages(trident, voice->memblk);
787 voice->memblk = snd_trident_alloc_pages(trident, substream);
810 struct snd_trident *trident = snd_pcm_substream_chip(substream);
819 evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
827 snd_trident_free_voice(trident, evoice);
871 struct snd_trident *trident = snd_pcm_substream_chip(substream);
876 if (trident->tlb.entries) {
878 snd_trident_free_pages(trident, voice->memblk);
883 snd_trident_free_voice(trident, evoice);
902 struct snd_trident *trident = snd_pcm_substream_chip(substream);
906 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
908 guard(spinlock_irq)(&trident->reg_lock);
940 snd_trident_write_voice_regs(trident, voice);
950 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
963 snd_trident_write_voice_regs(trident, evoice);
1003 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1008 guard(spinlock_irq)(&trident->reg_lock);
1011 outb(0, TRID_REG(trident, LEGACY_DMAR15));
1014 outb(0x54, TRID_REG(trident, LEGACY_DMAR11));
1018 outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
1024 outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6));
1025 outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4));
1030 outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R));
1039 outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL));
1043 trident->bDMAStart = 0x19; // 0001 1001b
1046 trident->bDMAStart |= 0x80;
1048 trident->bDMAStart |= 0x20;
1050 trident->bDMAStart |= 0x40;
1075 snd_trident_write_voice_regs(trident, voice);
1111 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1117 snd_trident_free_voice(trident, evoice);
1136 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1141 guard(spinlock_irq)(&trident->reg_lock);
1166 snd_trident_write_voice_regs(trident, voice);
1184 snd_trident_write_voice_regs(trident, evoice);
1206 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1211 guard(spinlock_irq)(&trident->reg_lock);
1240 outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan));
1242 snd_trident_write_voice_regs(trident, voice);
1252 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1260 snd_trident_write_voice_regs(trident, evoice);
1284 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1292 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1299 scoped_guard(spinlock_irq, &trident->reg_lock) {
1300 old_bits = trident->spdif_pcm_bits;
1302 trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS;
1304 trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24);
1306 trident->spdif_pcm_ctrl = 0x3c; // 48000 Hz
1307 trident->spdif_pcm_bits |=
1308 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1312 trident->spdif_pcm_ctrl = 0x3e; // 44100 Hz
1313 trident->spdif_pcm_bits |=
1314 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1318 trident->spdif_pcm_ctrl = 0x3d; // 32000 Hz
1319 trident->spdif_pcm_bits |=
1320 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1324 change = old_bits != trident->spdif_pcm_bits;
1328 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id);
1346 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1350 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
1354 guard(spinlock_irq)(&trident->reg_lock);
1356 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1394 snd_trident_write_voice_regs(trident, voice);
1396 outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO));
1397 outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2));
1398 outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA));
1399 outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO));
1400 outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2));
1403 outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1404 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1433 snd_trident_write_voice_regs(trident, voice);
1443 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1451 snd_trident_write_voice_regs(trident, evoice);
1457 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1458 temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
1460 outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR));
1461 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1463 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1485 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1506 guard(spinlock)(&trident->reg_lock);
1507 val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
1509 if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
1535 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1536 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1537 val = trident->spdif_pcm_ctrl;
1540 outb(val, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1542 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1543 val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN;
1544 outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1548 outl(what, TRID_REG(trident, T4D_STOP_B));
1549 val = inl(TRID_REG(trident, T4D_AINTEN_B));
1555 outl(val, TRID_REG(trident, T4D_AINTEN_B));
1557 outl(what, TRID_REG(trident, T4D_START_B));
1559 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1560 outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1562 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1563 outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1581 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1589 guard(spinlock)(&trident->reg_lock);
1591 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
1593 if (trident->device != TRIDENT_DEVICE_ID_NX) {
1594 cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2));
1596 cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff;
1618 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1626 result = inw(TRID_REG(trident, T4D_SBBL_SBCL));
1648 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1656 result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
1783 struct snd_trident *trident;
1786 trident = voice->trident;
1787 snd_trident_free_voice(trident, voice);
1793 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1797 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1800 snd_trident_pcm_mixer_build(trident, voice, substream);
1821 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1825 snd_trident_pcm_mixer_free(trident, voice, substream);
1842 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1846 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1851 scoped_guard(spinlock_irq, &trident->reg_lock) {
1852 trident->spdif_pcm_bits = trident->spdif_bits;
1857 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1863 trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1864 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1865 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1883 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1886 scoped_guard(spinlock_irq, &trident->reg_lock) {
1888 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1889 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1890 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
1892 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
1893 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1894 if (trident->spdif_ctrl) {
1899 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1902 trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1903 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1904 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1921 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1925 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1965 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1969 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1992 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1998 guard(spinlock_irq)(&trident->reg_lock);
1999 outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan));
2092 Parameters: trident - pointer to target device class for 4DWave.
2098 int snd_trident_pcm(struct snd_trident *trident, int device)
2103 err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm);
2107 pcm->private_data = trident;
2109 if (trident->tlb.entries) {
2115 trident->device != TRIDENT_DEVICE_ID_SI7018 ?
2122 trident->pcm = pcm;
2124 if (trident->tlb.entries) {
2128 &trident->pci->dev,
2132 &trident->pci->dev,
2136 &trident->pci->dev,
2148 Parameters: trident - pointer to target device class for 4DWave.
2154 int snd_trident_foldback_pcm(struct snd_trident *trident, int device)
2161 if (trident->device == TRIDENT_DEVICE_ID_NX)
2163 err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback);
2167 foldback->private_data = trident;
2168 if (trident->tlb.entries)
2184 trident->foldback = foldback;
2186 if (trident->tlb.entries)
2188 &trident->pci->dev,
2192 &trident->pci->dev,
2203 Parameters: trident - pointer to target device class for 4DWave-NX.
2209 int snd_trident_spdif_pcm(struct snd_trident *trident, int device)
2214 err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif);
2218 spdif->private_data = trident;
2219 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2226 trident->spdif = spdif;
2229 &trident->pci->dev, 64*1024, 128*1024);
2250 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2253 guard(spinlock_irq)(&trident->reg_lock);
2254 val = trident->spdif_ctrl;
2262 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2267 guard(spinlock_irq)(&trident->reg_lock);
2269 change = trident->spdif_ctrl != val;
2270 trident->spdif_ctrl = val;
2271 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2272 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) {
2273 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2274 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
2277 if (trident->spdif == NULL) {
2279 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2280 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN;
2283 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
2316 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2318 guard(spinlock_irq)(&trident->reg_lock);
2319 ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
2320 ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
2321 ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
2322 ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
2329 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2337 guard(spinlock_irq)(&trident->reg_lock);
2338 change = trident->spdif_bits != val;
2339 trident->spdif_bits = val;
2340 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2341 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0)
2342 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2344 if (trident->spdif == NULL)
2345 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2409 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2411 guard(spinlock_irq)(&trident->reg_lock);
2412 ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
2413 ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
2414 ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
2415 ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
2422 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2430 guard(spinlock_irq)(&trident->reg_lock);
2431 change = trident->spdif_pcm_bits != val;
2432 trident->spdif_pcm_bits = val;
2433 if (trident->spdif != NULL) {
2434 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2435 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
2437 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2464 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2467 guard(spinlock_irq)(&trident->reg_lock);
2468 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2476 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2480 guard(spinlock_irq)(&trident->reg_lock);
2481 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2485 change = val != trident->ac97_ctrl;
2486 trident->ac97_ctrl = val;
2487 outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2520 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2523 val = trident->musicvol_wavevol;
2534 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2538 guard(spinlock_irq)(&trident->reg_lock);
2539 val = trident->musicvol_wavevol;
2543 change = val != trident->musicvol_wavevol;
2544 outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2579 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2585 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
2593 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2594 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2596 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2607 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2608 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2612 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2617 guard(spinlock_irq)(&trident->reg_lock);
2621 snd_trident_write_vol_reg(trident, mix->voice, val);
2656 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2657 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2671 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2672 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2680 guard(spinlock_irq)(&trident->reg_lock);
2684 snd_trident_write_pan_reg(trident, mix->voice, val);
2718 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2719 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2728 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2729 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2734 guard(spinlock_irq)(&trident->reg_lock);
2738 snd_trident_write_rvol_reg(trident, mix->voice, val);
2775 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2776 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2785 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2786 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2791 guard(spinlock_irq)(&trident->reg_lock);
2795 snd_trident_write_cvol_reg(trident, mix->voice, val);
2828 static void snd_trident_notify_pcm_change(struct snd_trident *trident,
2832 snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
2833 snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
2834 snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate);
2835 snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
2838 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
2844 if (snd_BUG_ON(!trident || !voice || !substream))
2846 tmix = &trident->pcm_mixer[substream->number];
2852 snd_trident_notify_pcm_change(trident, tmix, substream->number, 1);
2856 static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
2860 if (snd_BUG_ON(!trident || !substream))
2862 tmix = &trident->pcm_mixer[substream->number];
2864 snd_trident_notify_pcm_change(trident, tmix, substream->number, 0);
2873 Parameters: trident - pointer to target device class for 4DWave.
2879 static int snd_trident_mixer(struct snd_trident *trident, int pcm_spdif_device)
2882 struct snd_card *card = trident->card;
2895 err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus);
2900 _ac97.private_data = trident;
2901 trident->ac97_detect = 1;
2904 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97);
2906 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2907 err = snd_trident_sis_reset(trident);
2918 if (trident->device == TRIDENT_DEVICE_ID_SI7018 &&
2919 (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) {
2921 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
2923 dev_err(trident->card->dev,
2928 err = snd_ac97_modem(trident->card, &_ac97, &mc97);
2930 dev_err(trident->card->dev,
2936 trident->ac97_detect = 0;
2938 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2939 kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident);
2944 kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident);
2949 outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2951 outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2957 tmix = &trident->pcm_mixer[idx];
2960 trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident);
2961 if (!trident->ctl_vol)
2963 err = snd_ctl_add(card, trident->ctl_vol);
2967 trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident);
2968 if (!trident->ctl_pan)
2970 err = snd_ctl_add(card, trident->ctl_pan);
2974 trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident);
2975 if (!trident->ctl_rvol)
2977 err = snd_ctl_add(card, trident->ctl_rvol);
2981 trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident);
2982 if (!trident->ctl_cvol)
2984 err = snd_ctl_add(card, trident->ctl_cvol);
2988 if (trident->device == TRIDENT_DEVICE_ID_NX) {
2989 kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident);
2995 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
2997 kctl = snd_ctl_new1(&snd_trident_spdif_control, trident);
3002 if (trident->ac97->ext_id & AC97_EI_SPDIF)
3004 if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF))
3012 kctl = snd_ctl_new1(&snd_trident_spdif_default, trident);
3023 kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident);
3034 kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident);
3044 trident->spdif_pcm_ctl = kctl;
3172 static int snd_trident_sis_reset(struct snd_trident *trident)
3178 r = trident->in_suspend ? 0 : 2; /* count of retries */
3180 pci_write_config_byte(trident->pci, 0x46, 0x04); /* SOFTWARE RESET */
3182 pci_write_config_byte(trident->pci, 0x46, 0x00);
3185 outb(0x00, TRID_REG(trident, SI_AC97_GPIO));
3188 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3192 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3197 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0)
3199 do_delay(trident);
3201 dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3202 inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
3206 do_delay(trident);
3213 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0)
3215 do_delay(trident);
3218 outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR));
3229 struct snd_trident *trident = entry->private_data;
3232 switch (trident->device) {
3246 snd_iprintf(buffer, "Spurious IRQs : %d\n", trident->spurious_irq_count);
3247 snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta);
3248 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018)
3249 snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", str_on_off(trident->spdif_ctrl == 0x28));
3250 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3251 snd_iprintf(buffer, "Rear Speakers : %s\n", str_on_off(trident->ac97_ctrl & 0x00000010));
3252 if (trident->tlb.entries) {
3254 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size);
3255 snd_iprintf(buffer, "Memory Used : %d\n", trident->tlb.memhdr->used);
3256 snd_iprintf(buffer, "Memory Free : %d\n", snd_util_mem_avail(trident->tlb.memhdr));
3261 static void snd_trident_proc_init(struct snd_trident *trident)
3263 const char *s = "trident";
3265 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
3267 snd_card_ro_proc_new(trident->card, s, trident, snd_trident_proc_read);
3276 Parameters: trident - pointer to target device class for 4DWave.
3282 static int snd_trident_tlb_alloc(struct snd_trident *trident)
3289 trident->tlb.buffer =
3290 snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
3292 if (!trident->tlb.buffer) {
3293 dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
3296 trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer->area, SNDRV_TRIDENT_MAX_PAGES * 4);
3297 trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer->addr, SNDRV_TRIDENT_MAX_PAGES * 4);
3300 trident->tlb.silent_page =
3301 snd_devm_alloc_pages(&trident->pci->dev, SNDRV_DMA_TYPE_DEV,
3303 if (!trident->tlb.silent_page) {
3304 dev_err(trident->card->dev, "unable to allocate silent page\n");
3307 memset(trident->tlb.silent_page->area, 0, SNDRV_TRIDENT_PAGE_SIZE);
3309 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page->addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
3312 trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES);
3313 if (trident->tlb.memhdr == NULL)
3316 trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
3324 static void snd_trident_stop_all_voices(struct snd_trident *trident)
3326 outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
3327 outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
3328 outl(0, TRID_REG(trident, T4D_AINTEN_A));
3329 outl(0, TRID_REG(trident, T4D_AINTEN_B));
3332 static int snd_trident_4d_dx_init(struct snd_trident *trident)
3334 struct pci_dev *pci = trident->pci;
3347 outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3349 outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3351 trident->ac97_ctrl = 0x0000004a;
3352 outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3356 if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0)
3358 do_delay(trident);
3360 dev_err(trident->card->dev, "AC'97 codec ready error\n");
3364 snd_trident_stop_all_voices(trident);
3372 static int snd_trident_4d_nx_init(struct snd_trident *trident)
3374 struct pci_dev *pci = trident->pci;
3388 outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3390 outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3394 if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0)
3396 do_delay(trident);
3398 dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
3399 inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
3404 trident->ac97_ctrl = 0x00000002;
3405 outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3407 outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT));
3409 snd_trident_stop_all_voices(trident);
3411 if (trident->tlb.entries != NULL) {
3414 i = trident->tlb.entries_dmaaddr;
3416 outl(i, TRID_REG(trident, NX_TLBC));
3418 outl(0, TRID_REG(trident, NX_TLBC));
3421 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
3422 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3430 static int snd_trident_sis_init(struct snd_trident *trident)
3434 err = snd_trident_sis_reset(trident);
3438 snd_trident_stop_all_voices(trident);
3441 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
3468 struct snd_trident *trident = card->private_data;
3484 trident->device = (pci->vendor << 16) | pci->device;
3485 trident->card = card;
3486 trident->pci = pci;
3487 spin_lock_init(&trident->reg_lock);
3488 spin_lock_init(&trident->event_lock);
3489 spin_lock_init(&trident->voice_alloc);
3494 trident->ChanPCM = pcm_streams;
3497 trident->synth.max_size = max_wavetable_size * 1024;
3498 trident->irq = -1;
3501 trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
3507 trident->port = pci_resource_start(pci, 0);
3510 IRQF_SHARED, KBUILD_MODNAME, trident)) {
3514 trident->irq = pci->irq;
3515 card->sync_irq = trident->irq;
3518 trident->tlb.entries = NULL;
3519 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3520 err = snd_trident_tlb_alloc(trident);
3525 trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF;
3528 switch (trident->device) {
3530 err = snd_trident_4d_dx_init(trident);
3533 err = snd_trident_4d_nx_init(trident);
3536 err = snd_trident_sis_init(trident);
3545 err = snd_trident_mixer(trident, pcm_spdif_device);
3551 voice = &trident->synth.voices[i];
3553 voice->trident = trident;
3557 tmix = &trident->pcm_mixer[i];
3564 snd_trident_enable_eso(trident);
3566 snd_trident_proc_init(trident);
3584 struct snd_trident *trident = card->private_data;
3586 snd_trident_free_gameport(trident);
3587 snd_trident_disable_eso(trident);
3589 if (trident->device == TRIDENT_DEVICE_ID_NX)
3590 outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3591 else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
3592 outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3594 if (trident->tlb.buffer) {
3595 outl(0, TRID_REG(trident, NX_TLBC));
3596 snd_util_memhdr_free(trident->tlb.memhdr);
3605 Parameters: trident - device specific private data for 4DWave card
3620 struct snd_trident *trident = dev_id;
3625 audio_int = inl(TRID_REG(trident, T4D_MISCINT));
3630 scoped_guard(spinlock, &trident->reg_lock) {
3631 stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
3632 chn_int = inl(TRID_REG(trident, T4D_AINT_A));
3634 outl(chn_int, TRID_REG(trident, T4D_AINT_A)); /* ack */
3635 chn_int = inl(TRID_REG(trident, T4D_AINT_B));
3642 voice = &trident->synth.voices[channel];
3644 outl(mask, TRID_REG(trident, T4D_STOP_B));
3652 trident->spurious_irq_count++;
3653 if (trident->spurious_irq_max_delta < (unsigned int)delta)
3654 trident->spurious_irq_max_delta = delta;
3660 tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL));
3661 if (trident->bDMAStart & 0x40)
3666 tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
3674 snd_trident_stop_voice(trident, voice->number);
3675 snd_trident_write_eso_reg(trident, voice, tmp);
3676 snd_trident_start_voice(trident, voice->number);
3681 snd_trident_stop_voice(trident, voice->number);
3682 snd_trident_write_cso_reg(trident, voice, voice->isync_mark);
3683 snd_trident_write_eso_reg(trident, voice, voice->ESO);
3684 snd_trident_start_voice(trident, voice->number);
3689 snd_trident_stop_voice(trident, voice->extra->number);
3690 snd_trident_write_cso_reg(trident, voice->extra, 0);
3691 snd_trident_start_voice(trident, voice->extra->number);
3694 spin_unlock(&trident->reg_lock);
3696 spin_lock(&trident->reg_lock);
3698 outl(chn_int, TRID_REG(trident, T4D_AINT_B)); /* ack */
3702 if (trident->rmidi) {
3703 snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);
3705 inb(TRID_REG(trident, T4D_MPUR0));
3708 // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
3712 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
3717 guard(spinlock_irqsave)(&trident->voice_alloc);
3719 idx = snd_trident_allocate_pcm_channel(trident);
3722 pvoice = &trident->synth.voices[idx];
3732 idx = snd_trident_allocate_synth_channel(trident);
3735 pvoice = &trident->synth.voices[idx];
3750 void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
3756 snd_trident_clear_voices(trident, voice->number, voice->number);
3757 scoped_guard(spinlock_irqsave, &trident->voice_alloc) {
3762 snd_trident_free_pcm_channel(trident, voice->number);
3764 snd_trident_free_synth_channel(trident, voice->number);
3777 static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
3786 outl(mask[0], TRID_REG(trident, T4D_STOP_A));
3787 val = inl(TRID_REG(trident, T4D_AINTEN_A));
3788 outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A));
3791 outl(mask[1], TRID_REG(trident, T4D_STOP_B));
3792 val = inl(TRID_REG(trident, T4D_AINTEN_B));
3793 outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B));
3801 struct snd_trident *trident = card->private_data;
3803 trident->in_suspend = 1;
3805 snd_ac97_suspend(trident->ac97);
3806 snd_ac97_suspend(trident->ac97_sec);
3813 struct snd_trident *trident = card->private_data;
3815 switch (trident->device) {
3817 snd_trident_4d_dx_init(trident);
3820 snd_trident_4d_nx_init(trident);
3823 snd_trident_sis_init(trident);
3827 snd_ac97_resume(trident->ac97);
3828 snd_ac97_resume(trident->ac97_sec);
3831 outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3833 snd_trident_enable_eso(trident);
3836 trident->in_suspend = 0;