Lines Matching defs:trident
44 #include <sound/trident.h>
49 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
52 static int snd_trident_pcm_mixer_free(struct snd_trident *trident,
56 static int snd_trident_sis_reset(struct snd_trident *trident);
58 static void snd_trident_clear_voices(struct snd_trident * trident,
60 static int snd_trident_free(struct snd_trident *trident);
85 struct snd_trident *trident = ac97->private_data;
87 spin_lock_irqsave(&trident->reg_lock, flags);
88 if (trident->device == TRIDENT_DEVICE_ID_DX) {
90 outl(data, TRID_REG(trident, DX_ACR1_AC97_R));
92 data = inl(TRID_REG(trident, DX_ACR1_AC97_R));
96 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
99 outl(data, TRID_REG(trident, treg));
101 data = inl(TRID_REG(trident, treg));
105 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
109 outl(data, TRID_REG(trident, SI_AC97_READ));
111 data = inl(TRID_REG(trident, SI_AC97_READ));
117 if (count == 0 && !trident->ac97_detect) {
123 spin_unlock_irqrestore(&trident->reg_lock, flags);
147 struct snd_trident *trident = ac97->private_data;
151 spin_lock_irqsave(&trident->reg_lock, flags);
152 if (trident->device == TRIDENT_DEVICE_ID_DX) {
157 if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0)
162 } else if (trident->device == TRIDENT_DEVICE_ID_NX) {
167 if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0)
172 } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
177 if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0)
190 spin_unlock_irqrestore(&trident->reg_lock, flags);
193 outl(data, TRID_REG(trident, address));
194 spin_unlock_irqrestore(&trident->reg_lock, flags);
198 void snd_trident_enable_eso(struct snd_trident *trident)
205 Parameters: trident - pointer to target device class for 4DWave.
209 static void snd_trident_enable_eso(struct snd_trident * trident)
213 val = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
216 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
218 outl(val, TRID_REG(trident, T4D_LFO_GC_CIR));
222 void snd_trident_disable_eso(struct snd_trident *trident)
230 trident - pointer to target device class for 4DWave.
236 static void snd_trident_disable_eso(struct snd_trident * trident)
240 tmp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
243 outl(tmp, TRID_REG(trident, T4D_LFO_GC_CIR));
247 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
254 trident - pointer to target device class for 4DWave.
260 void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
265 outl(mask, TRID_REG(trident, reg));
271 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
278 trident - pointer to target device class for 4DWave.
284 void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
289 outl(mask, TRID_REG(trident, reg));
295 int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
299 Parameters : trident - pointer to target device class for 4DWave.
305 static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
309 if (trident->ChanPCMcnt >= trident->ChanPCM)
312 if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) {
313 trident->ChanMap[T4D_BANK_B] |= 1 << idx;
314 trident->ChanPCMcnt++;
326 Parameters : trident - pointer to target device class for 4DWave.
333 static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
338 if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) {
339 trident->ChanMap[T4D_BANK_B] &= ~(1 << channel);
340 trident->ChanPCMcnt--;
349 Parameters : trident - pointer to target device class for 4DWave.
355 static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
360 if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) {
361 trident->ChanMap[T4D_BANK_A] |= 1 << idx;
362 trident->synth.ChanSynthCount++;
374 Parameters : trident - pointer to target device class for 4DWave.
381 static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
386 if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) {
387 trident->ChanMap[T4D_BANK_A] &= ~(1 << channel);
388 trident->synth.ChanSynthCount--;
398 Paramters: trident - pointer to target device class for 4DWave.
404 void snd_trident_write_voice_regs(struct snd_trident * trident,
418 switch (trident->device) {
451 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
452 outl(regs[0], TRID_REG(trident, CH_START + 0));
453 outl(regs[1], TRID_REG(trident, CH_START + 4));
454 outl(regs[2], TRID_REG(trident, CH_START + 8));
455 outl(regs[3], TRID_REG(trident, CH_START + 12));
456 outl(regs[4], TRID_REG(trident, CH_START + 16));
468 Paramters: trident - pointer to target device class for 4DWave.
474 static void snd_trident_write_cso_reg(struct snd_trident * trident,
479 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
480 if (trident->device != TRIDENT_DEVICE_ID_NX) {
481 outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2);
484 (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
494 Paramters: trident - pointer to target device class for 4DWave.
500 static void snd_trident_write_eso_reg(struct snd_trident * trident,
505 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
506 if (trident->device != TRIDENT_DEVICE_ID_NX) {
507 outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2);
510 TRID_REG(trident, CH_NX_DELTA_ESO));
520 Paramters: trident - pointer to target device class for 4DWave.
526 static void snd_trident_write_vol_reg(struct snd_trident * trident,
531 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
532 switch (trident->device) {
535 outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
540 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
551 Paramters: trident - pointer to target device class for 4DWave.
557 static void snd_trident_write_pan_reg(struct snd_trident * trident,
562 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
564 TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
573 Paramters: trident - pointer to target device class for 4DWave.
579 static void snd_trident_write_rvol_reg(struct snd_trident * trident,
584 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
587 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
597 Paramters: trident - pointer to target device class for 4DWave.
603 static void snd_trident_write_cvol_reg(struct snd_trident * trident,
608 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
611 TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
620 Paramters: trident - pointer to target device class for 4DWave.
650 Paramters: trident - pointer to target device class for 4DWave.
680 Paramters: trident - pointer to target device class for 4DWave.
702 Paramters: trident - pointer to target device class for 4DWave.
765 struct snd_trident *trident = snd_pcm_substream_chip(substream);
772 if (trident->tlb.entries) {
775 snd_trident_free_pages(trident, voice->memblk);
776 voice->memblk = snd_trident_alloc_pages(trident, substream);
799 struct snd_trident *trident = snd_pcm_substream_chip(substream);
808 evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
816 snd_trident_free_voice(trident, evoice);
860 struct snd_trident *trident = snd_pcm_substream_chip(substream);
865 if (trident->tlb.entries) {
867 snd_trident_free_pages(trident, voice->memblk);
873 snd_trident_free_voice(trident, evoice);
892 struct snd_trident *trident = snd_pcm_substream_chip(substream);
896 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
898 spin_lock_irq(&trident->reg_lock);
925 snd_trident_write_voice_regs(trident, voice);
935 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
943 snd_trident_write_voice_regs(trident, evoice);
949 spin_unlock_irq(&trident->reg_lock);
985 struct snd_trident *trident = snd_pcm_substream_chip(substream);
990 spin_lock_irq(&trident->reg_lock);
993 outb(0, TRID_REG(trident, LEGACY_DMAR15));
996 outb(0x54, TRID_REG(trident, LEGACY_DMAR11));
1000 outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
1006 outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6));
1007 outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4));
1012 outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R));
1021 outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL));
1025 trident->bDMAStart = 0x19; // 0001 1001b
1028 trident->bDMAStart |= 0x80;
1030 trident->bDMAStart |= 0x20;
1032 trident->bDMAStart |= 0x40;
1057 snd_trident_write_voice_regs(trident, voice);
1059 spin_unlock_irq(&trident->reg_lock);
1099 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1106 snd_trident_free_voice(trident, evoice);
1125 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1130 spin_lock_irq(&trident->reg_lock);
1155 snd_trident_write_voice_regs(trident, voice);
1173 snd_trident_write_voice_regs(trident, evoice);
1179 spin_unlock_irq(&trident->reg_lock);
1196 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1201 spin_lock_irq(&trident->reg_lock);
1230 outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan));
1232 snd_trident_write_voice_regs(trident, voice);
1242 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1250 snd_trident_write_voice_regs(trident, evoice);
1256 spin_unlock_irq(&trident->reg_lock);
1275 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1283 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1290 spin_lock_irq(&trident->reg_lock);
1291 old_bits = trident->spdif_pcm_bits;
1293 trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS;
1295 trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24);
1297 trident->spdif_pcm_ctrl = 0x3c; // 48000 Hz
1298 trident->spdif_pcm_bits |=
1299 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1304 trident->spdif_pcm_ctrl = 0x3e; // 44100 Hz
1305 trident->spdif_pcm_bits |=
1306 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1311 trident->spdif_pcm_ctrl = 0x3d; // 32000 Hz
1312 trident->spdif_pcm_bits |=
1313 trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
1317 change = old_bits != trident->spdif_pcm_bits;
1318 spin_unlock_irq(&trident->reg_lock);
1321 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id);
1339 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1343 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];
1347 spin_lock_irq(&trident->reg_lock);
1349 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1387 snd_trident_write_voice_regs(trident, voice);
1389 outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO));
1390 outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2));
1391 outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA));
1392 outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO));
1393 outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2));
1396 outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1397 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1426 snd_trident_write_voice_regs(trident, voice);
1436 evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
1444 snd_trident_write_voice_regs(trident, evoice);
1450 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1451 temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
1453 outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR));
1454 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1456 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1459 spin_unlock_irq(&trident->reg_lock);
1480 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1501 spin_lock(&trident->reg_lock);
1502 val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
1504 if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
1530 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1531 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
1532 outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1534 outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
1535 val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN;
1536 outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1540 outl(what, TRID_REG(trident, T4D_STOP_B));
1541 val = inl(TRID_REG(trident, T4D_AINTEN_B));
1547 outl(val, TRID_REG(trident, T4D_AINTEN_B));
1549 outl(what, TRID_REG(trident, T4D_START_B));
1551 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1552 outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1554 if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
1555 outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
1557 spin_unlock(&trident->reg_lock);
1574 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1582 spin_lock(&trident->reg_lock);
1584 outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
1586 if (trident->device != TRIDENT_DEVICE_ID_NX) {
1587 cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2));
1589 cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff;
1592 spin_unlock(&trident->reg_lock);
1613 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1621 result = inw(TRID_REG(trident, T4D_SBBL_SBCL));
1643 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1651 result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
1778 struct snd_trident *trident;
1781 trident = voice->trident;
1782 snd_trident_free_voice(trident, voice);
1788 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1792 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1795 snd_trident_pcm_mixer_build(trident, voice, substream);
1816 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1820 snd_trident_pcm_mixer_free(trident, voice, substream);
1837 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1841 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1846 spin_lock_irq(&trident->reg_lock);
1847 trident->spdif_pcm_bits = trident->spdif_bits;
1848 spin_unlock_irq(&trident->reg_lock);
1852 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
1858 trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1859 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1860 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1878 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1881 spin_lock_irq(&trident->reg_lock);
1883 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
1884 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
1885 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
1887 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
1888 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1889 if (trident->spdif_ctrl) {
1894 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
1896 spin_unlock_irq(&trident->reg_lock);
1897 trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1898 snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
1899 SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
1916 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1920 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1960 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1964 voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
1987 struct snd_trident *trident = snd_pcm_substream_chip(substream);
1993 spin_lock_irq(&trident->reg_lock);
1994 outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan));
1995 spin_unlock_irq(&trident->reg_lock);
2098 Paramters: trident - pointer to target device class for 4DWave.
2104 int __devinit snd_trident_pcm(struct snd_trident * trident,
2112 if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0)
2115 pcm->private_data = trident;
2117 if (trident->tlb.entries) {
2123 trident->device != TRIDENT_DEVICE_ID_SI7018 ?
2130 trident->pcm = pcm;
2132 if (trident->tlb.entries) {
2136 snd_dma_pci_data(trident->pci),
2139 SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
2143 snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2156 Paramters: trident - pointer to target device class for 4DWave.
2162 int __devinit snd_trident_foldback_pcm(struct snd_trident * trident,
2172 if (trident->device == TRIDENT_DEVICE_ID_NX)
2174 if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0)
2177 foldback->private_data = trident;
2178 if (trident->tlb.entries)
2194 trident->foldback = foldback;
2196 if (trident->tlb.entries)
2198 snd_dma_pci_data(trident->pci), 0, 128*1024);
2201 snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2213 Paramters: trident - pointer to target device class for 4DWave-NX.
2219 int __devinit snd_trident_spdif_pcm(struct snd_trident * trident,
2227 if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0)
2230 spdif->private_data = trident;
2231 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2238 trident->spdif = spdif;
2240 snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
2271 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2274 spin_lock_irq(&trident->reg_lock);
2275 val = trident->spdif_ctrl;
2277 spin_unlock_irq(&trident->reg_lock);
2284 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2289 spin_lock_irq(&trident->reg_lock);
2291 change = trident->spdif_ctrl != val;
2292 trident->spdif_ctrl = val;
2293 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2294 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) {
2295 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2296 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
2299 if (trident->spdif == NULL) {
2301 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2302 temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN;
2305 outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
2308 spin_unlock_irq(&trident->reg_lock);
2339 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2341 spin_lock_irq(&trident->reg_lock);
2342 ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
2343 ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
2344 ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
2345 ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
2346 spin_unlock_irq(&trident->reg_lock);
2353 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2361 spin_lock_irq(&trident->reg_lock);
2362 change = trident->spdif_bits != val;
2363 trident->spdif_bits = val;
2364 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2365 if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0)
2366 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
2368 if (trident->spdif == NULL)
2369 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2371 spin_unlock_irq(&trident->reg_lock);
2434 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2436 spin_lock_irq(&trident->reg_lock);
2437 ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
2438 ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
2439 ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
2440 ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
2441 spin_unlock_irq(&trident->reg_lock);
2448 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2456 spin_lock_irq(&trident->reg_lock);
2457 change = trident->spdif_pcm_bits != val;
2458 trident->spdif_pcm_bits = val;
2459 if (trident->spdif != NULL) {
2460 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2461 outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
2463 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
2466 spin_unlock_irq(&trident->reg_lock);
2499 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2502 spin_lock_irq(&trident->reg_lock);
2503 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2505 spin_unlock_irq(&trident->reg_lock);
2512 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2516 spin_lock_irq(&trident->reg_lock);
2517 val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2521 change = val != trident->ac97_ctrl;
2522 trident->ac97_ctrl = val;
2523 outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
2524 spin_unlock_irq(&trident->reg_lock);
2557 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2560 val = trident->musicvol_wavevol;
2571 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2575 spin_lock_irq(&trident->reg_lock);
2576 val = trident->musicvol_wavevol;
2580 change = val != trident->musicvol_wavevol;
2581 outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2582 spin_unlock_irq(&trident->reg_lock);
2617 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2623 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
2631 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2632 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2634 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2645 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2646 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2650 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2655 spin_lock_irq(&trident->reg_lock);
2659 snd_trident_write_vol_reg(trident, mix->voice, val);
2660 spin_unlock_irq(&trident->reg_lock);
2694 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2695 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2709 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2710 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2718 spin_lock_irq(&trident->reg_lock);
2722 snd_trident_write_pan_reg(trident, mix->voice, val);
2723 spin_unlock_irq(&trident->reg_lock);
2757 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2758 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2767 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2768 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2773 spin_lock_irq(&trident->reg_lock);
2777 snd_trident_write_rvol_reg(trident, mix->voice, val);
2778 spin_unlock_irq(&trident->reg_lock);
2815 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2816 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2825 struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
2826 struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
2831 spin_lock_irq(&trident->reg_lock);
2835 snd_trident_write_cvol_reg(trident, mix->voice, val);
2836 spin_unlock_irq(&trident->reg_lock);
2869 static void snd_trident_notify_pcm_change(struct snd_trident *trident,
2873 snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
2874 snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
2875 snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate);
2876 snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
2879 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
2885 snd_assert(trident != NULL && voice != NULL && substream != NULL, return -EINVAL);
2886 tmix = &trident->pcm_mixer[substream->number];
2892 snd_trident_notify_pcm_change(trident, tmix, substream->number, 1);
2896 static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
2900 snd_assert(trident != NULL && substream != NULL, return -EINVAL);
2901 tmix = &trident->pcm_mixer[substream->number];
2903 snd_trident_notify_pcm_change(trident, tmix, substream->number, 0);
2912 Paramters: trident - pointer to target device class for 4DWave.
2918 static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device)
2921 struct snd_card *card = trident->card;
2934 if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0)
2938 _ac97.private_data = trident;
2939 trident->ac97_detect = 1;
2942 if ((err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97)) < 0) {
2943 if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
2944 if ((err = snd_trident_sis_reset(trident)) < 0)
2954 if (trident->device == TRIDENT_DEVICE_ID_SI7018 &&
2955 (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) {
2957 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
2962 trident->ac97_detect = 0;
2964 if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
2965 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident))) < 0)
2968 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident))) < 0)
2971 outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2973 outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
2979 tmix = &trident->pcm_mixer[idx];
2982 if ((trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident)) == NULL)
2984 if ((err = snd_ctl_add(card, trident->ctl_vol)))
2987 if ((trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident)) == NULL)
2989 if ((err = snd_ctl_add(card, trident->ctl_pan)))
2992 if ((trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident)) == NULL)
2994 if ((err = snd_ctl_add(card, trident->ctl_rvol)))
2997 if ((trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident)) == NULL)
2999 if ((err = snd_ctl_add(card, trident->ctl_cvol)))
3002 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3003 if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident))) < 0)
3007 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
3009 kctl = snd_ctl_new1(&snd_trident_spdif_control, trident);
3014 if (trident->ac97->ext_id & AC97_EI_SPDIF)
3016 if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF))
3023 kctl = snd_ctl_new1(&snd_trident_spdif_default, trident);
3033 kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident);
3043 kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident);
3052 trident->spdif_pcm_ctl = kctl;
3131 printk(KERN_ERR "trident: cannot allocate memory for gameport\n");
3175 static int snd_trident_sis_reset(struct snd_trident *trident)
3181 r = trident->in_suspend ? 0 : 2; /* count of retries */
3183 pci_write_config_byte(trident->pci, 0x46, 0x04); /* SOFTWARE RESET */
3185 pci_write_config_byte(trident->pci, 0x46, 0x00);
3188 outb(0x00, TRID_REG(trident, SI_AC97_GPIO));
3191 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3195 outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3200 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0)
3202 do_delay(trident);
3204 snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
3208 do_delay(trident);
3215 if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0)
3217 do_delay(trident);
3220 outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR));
3231 struct snd_trident *trident = entry->private_data;
3234 switch (trident->device) {
3248 snd_iprintf(buffer, "Spurious IRQs : %d\n", trident->spurious_irq_count);
3249 snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta);
3250 if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018)
3251 snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", trident->spdif_ctrl == 0x28 ? "on" : "off");
3252 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3253 snd_iprintf(buffer, "Rear Speakers : %s\n", trident->ac97_ctrl & 0x00000010 ? "on" : "off");
3254 if (trident->tlb.entries) {
3256 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size);
3257 snd_iprintf(buffer, "Memory Used : %d\n", trident->tlb.memhdr->used);
3258 snd_iprintf(buffer, "Memory Free : %d\n", snd_util_mem_avail(trident->tlb.memhdr));
3264 snd_iprintf(buffer, "Memory Maximum : %d\n", trident->synth.max_size);
3265 snd_iprintf(buffer, "Memory Used : %d\n", trident->synth.current_size);
3266 snd_iprintf(buffer, "Memory Free : %d\n", (trident->synth.max_size-trident->synth.current_size));
3270 static void __devinit snd_trident_proc_init(struct snd_trident * trident)
3273 const char *s = "trident";
3275 if (trident->device == TRIDENT_DEVICE_ID_SI7018)
3277 if (! snd_card_proc_new(trident->card, s, &entry))
3278 snd_info_set_text_ops(entry, trident, snd_trident_proc_read);
3283 struct snd_trident *trident = device->device_data;
3284 return snd_trident_free(trident);
3293 Paramters: trident - pointer to target device class for 4DWave.
3299 static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident)
3306 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
3307 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
3308 snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n");
3311 trident->tlb.entries = (unsigned int*)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
3312 trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4);
3314 trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long));
3315 if (trident->tlb.shadow_entries == NULL) {
3316 snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n");
3320 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
3321 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
3322 snd_printk(KERN_ERR "trident: unable to allocate silent page\n");
3325 memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE);
3327 trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
3328 trident->tlb.shadow_entries[i] = (unsigned long)trident->tlb.silent_page.area;
3332 trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES);
3333 if (trident->tlb.memhdr == NULL)
3336 trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
3344 static void snd_trident_stop_all_voices(struct snd_trident *trident)
3346 outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
3347 outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
3348 outl(0, TRID_REG(trident, T4D_AINTEN_A));
3349 outl(0, TRID_REG(trident, T4D_AINTEN_B));
3352 static int snd_trident_4d_dx_init(struct snd_trident *trident)
3354 struct pci_dev *pci = trident->pci;
3367 outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3369 outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3371 trident->ac97_ctrl = 0x0000004a;
3372 outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
3376 if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0)
3378 do_delay(trident);
3384 snd_trident_stop_all_voices(trident);
3392 static int snd_trident_4d_nx_init(struct snd_trident *trident)
3394 struct pci_dev *pci = trident->pci;
3408 outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3410 outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3414 if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0)
3416 do_delay(trident);
3418 snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
3423 trident->ac97_ctrl = 0x00000002;
3424 outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
3426 outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT));
3428 snd_trident_stop_all_voices(trident);
3430 if (trident->tlb.entries != NULL) {
3433 i = trident->tlb.entries_dmaaddr;
3435 outl(i, TRID_REG(trident, NX_TLBC));
3437 outl(0, TRID_REG(trident, NX_TLBC));
3440 outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
3441 outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3449 static int snd_trident_sis_init(struct snd_trident *trident)
3453 if ((err = snd_trident_sis_reset(trident)) < 0)
3456 snd_trident_stop_all_voices(trident);
3459 outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
3487 struct snd_trident *trident;
3508 trident = kzalloc(sizeof(*trident), GFP_KERNEL);
3509 if (trident == NULL) {
3513 trident->device = (pci->vendor << 16) | pci->device;
3514 trident->card = card;
3515 trident->pci = pci;
3516 spin_lock_init(&trident->reg_lock);
3517 spin_lock_init(&trident->event_lock);
3518 spin_lock_init(&trident->voice_alloc);
3523 trident->ChanPCM = pcm_streams;
3526 trident->synth.max_size = max_wavetable_size * 1024;
3527 trident->irq = -1;
3529 trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
3533 kfree(trident);
3537 trident->port = pci_resource_start(pci, 0);
3540 "Trident Audio", trident)) {
3542 snd_trident_free(trident);
3545 trident->irq = pci->irq;
3548 trident->tlb.entries = NULL;
3549 trident->tlb.buffer.area = NULL;
3550 if (trident->device == TRIDENT_DEVICE_ID_NX) {
3551 if ((err = snd_trident_tlb_alloc(trident)) < 0) {
3552 snd_trident_free(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);
3575 snd_trident_free(trident);
3579 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) {
3580 snd_trident_free(trident);
3584 if ((err = snd_trident_mixer(trident, pcm_spdif_device)) < 0)
3589 voice = &trident->synth.voices[i];
3591 voice->trident = trident;
3595 tmix = &trident->pcm_mixer[i];
3602 snd_trident_enable_eso(trident);
3604 snd_trident_proc_init(trident);
3606 *rtrident = trident;
3616 Paramters: trident - device specific private data for 4DWave card
3622 static int snd_trident_free(struct snd_trident *trident)
3624 snd_trident_free_gameport(trident);
3625 snd_trident_disable_eso(trident);
3627 if (trident->device == TRIDENT_DEVICE_ID_NX)
3628 outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
3629 else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
3630 outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
3632 if (trident->tlb.buffer.area) {
3633 outl(0, TRID_REG(trident, NX_TLBC));
3634 if (trident->tlb.memhdr)
3635 snd_util_memhdr_free(trident->tlb.memhdr);
3636 if (trident->tlb.silent_page.area)
3637 snd_dma_free_pages(&trident->tlb.silent_page);
3638 vfree(trident->tlb.shadow_entries);
3639 snd_dma_free_pages(&trident->tlb.buffer);
3641 if (trident->irq >= 0)
3642 free_irq(trident->irq, trident);
3643 pci_release_regions(trident->pci);
3644 pci_disable_device(trident->pci);
3645 kfree(trident);
3654 Paramters: trident - device specific private data for 4DWave card
3669 struct snd_trident *trident = dev_id;
3674 audio_int = inl(TRID_REG(trident, T4D_MISCINT));
3679 spin_lock(&trident->reg_lock);
3680 stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
3681 chn_int = inl(TRID_REG(trident, T4D_AINT_A));
3684 outl(chn_int, TRID_REG(trident, T4D_AINT_A)); /* ack */
3686 chn_int = inl(TRID_REG(trident, T4D_AINT_B));
3693 voice = &trident->synth.voices[channel];
3695 outl(mask, TRID_REG(trident, T4D_STOP_B));
3703 trident->spurious_irq_count++;
3704 if (trident->spurious_irq_max_delta < (unsigned int)delta)
3705 trident->spurious_irq_max_delta = delta;
3711 tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL));
3712 if (trident->bDMAStart & 0x40)
3717 tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
3725 snd_trident_stop_voice(trident, voice->number);
3726 snd_trident_write_eso_reg(trident, voice, tmp);
3727 snd_trident_start_voice(trident, voice->number);
3732 snd_trident_stop_voice(trident, voice->number);
3733 snd_trident_write_cso_reg(trident, voice, voice->isync_mark);
3734 snd_trident_write_eso_reg(trident, voice, voice->ESO);
3735 snd_trident_start_voice(trident, voice->number);
3737 spin_unlock(&trident->reg_lock);
3739 spin_lock(&trident->reg_lock);
3741 outl(chn_int, TRID_REG(trident, T4D_AINT_B)); /* ack */
3743 spin_unlock(&trident->reg_lock);
3746 if (trident->rmidi) {
3747 snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);
3749 inb(TRID_REG(trident, T4D_MPUR0));
3752 // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
3761 Paramters: trident - device specific private data for 4DWave card
3766 int snd_trident_attach_synthesizer(struct snd_trident *trident)
3770 if (snd_seq_device_new(trident->card, 1, SNDRV_SEQ_DEV_ID_TRIDENT,
3771 sizeof(struct snd_trident *), &trident->seq_dev) >= 0) {
3772 strcpy(trident->seq_dev->name, "4DWave");
3773 *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(trident->seq_dev) = trident;
3779 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
3785 spin_lock_irqsave(&trident->voice_alloc, flags);
3787 idx = snd_trident_allocate_pcm_channel(trident);
3789 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3792 pvoice = &trident->synth.voices[idx];
3799 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3803 idx = snd_trident_allocate_synth_channel(trident);
3805 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3808 pvoice = &trident->synth.voices[idx];
3814 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3819 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3825 void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
3833 snd_trident_clear_voices(trident, voice->number, voice->number);
3834 spin_lock_irqsave(&trident->voice_alloc, flags);
3840 snd_trident_free_pcm_channel(trident, voice->number);
3842 snd_trident_free_synth_channel(trident, voice->number);
3848 spin_unlock_irqrestore(&trident->voice_alloc, flags);
3855 static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
3864 outl(mask[0], TRID_REG(trident, T4D_STOP_A));
3865 val = inl(TRID_REG(trident, T4D_AINTEN_A));
3866 outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A));
3869 outl(mask[1], TRID_REG(trident, T4D_STOP_B));
3870 val = inl(TRID_REG(trident, T4D_AINTEN_B));
3871 outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B));
3879 struct snd_trident *trident = card->private_data;
3881 trident->in_suspend = 1;
3883 snd_pcm_suspend_all(trident->pcm);
3884 snd_pcm_suspend_all(trident->foldback);
3885 snd_pcm_suspend_all(trident->spdif);
3887 snd_ac97_suspend(trident->ac97);
3888 snd_ac97_suspend(trident->ac97_sec);
3899 struct snd_trident *trident = card->private_data;
3904 printk(KERN_ERR "trident: pci_enable_device failed, "
3911 switch (trident->device) {
3913 snd_trident_4d_dx_init(trident);
3916 snd_trident_4d_nx_init(trident);
3919 snd_trident_sis_init(trident);
3923 snd_ac97_resume(trident->ac97);
3924 snd_ac97_resume(trident->ac97_sec);
3927 outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
3929 snd_trident_enable_eso(trident);
3932 trident->in_suspend = 0;