diff options
Diffstat (limited to 'ANDROID_3.4.5/sound/pci/trident/trident_main.c')
| -rw-r--r-- | ANDROID_3.4.5/sound/pci/trident/trident_main.c | 3982 |
1 files changed, 0 insertions, 3982 deletions
diff --git a/ANDROID_3.4.5/sound/pci/trident/trident_main.c b/ANDROID_3.4.5/sound/pci/trident/trident_main.c deleted file mode 100644 index 61d3c0e8..00000000 --- a/ANDROID_3.4.5/sound/pci/trident/trident_main.c +++ /dev/null @@ -1,3982 +0,0 @@ -/* - * Maintained by Jaroslav Kysela <perex@perex.cz> - * Originated by audio@tridentmicro.com - * Fri Feb 19 15:55:28 MST 1999 - * Routines for control of Trident 4DWave (DX and NX) chip - * - * BUGS: - * - * TODO: - * --- - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * - * SiS7018 S/PDIF support by Thomas Winischhofer <thomas@winischhofer.net> - */ - -#include <linux/delay.h> -#include <linux/init.h> -#include <linux/interrupt.h> -#include <linux/pci.h> -#include <linux/slab.h> -#include <linux/vmalloc.h> -#include <linux/gameport.h> -#include <linux/dma-mapping.h> -#include <linux/export.h> - -#include <sound/core.h> -#include <sound/info.h> -#include <sound/control.h> -#include <sound/tlv.h> -#include <sound/trident.h> -#include <sound/asoundef.h> - -#include <asm/io.h> - -static int snd_trident_pcm_mixer_build(struct snd_trident *trident, - struct snd_trident_voice * voice, - struct snd_pcm_substream *substream); -static int snd_trident_pcm_mixer_free(struct snd_trident *trident, - struct snd_trident_voice * voice, - struct snd_pcm_substream *substream); -static irqreturn_t snd_trident_interrupt(int irq, void *dev_id); -static int snd_trident_sis_reset(struct snd_trident *trident); - -static void snd_trident_clear_voices(struct snd_trident * trident, - unsigned short v_min, unsigned short v_max); -static int snd_trident_free(struct snd_trident *trident); - -/* - * common I/O routines - */ - - -#if 0 -static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice) -{ - unsigned int val, tmp; - - printk(KERN_DEBUG "Trident voice %i:\n", voice); - outb(voice, TRID_REG(trident, T4D_LFO_GC_CIR)); - val = inl(TRID_REG(trident, CH_LBA)); - printk(KERN_DEBUG "LBA: 0x%x\n", val); - val = inl(TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC)); - printk(KERN_DEBUG "GVSel: %i\n", val >> 31); - printk(KERN_DEBUG "Pan: 0x%x\n", (val >> 24) & 0x7f); - printk(KERN_DEBUG "Vol: 0x%x\n", (val >> 16) & 0xff); - printk(KERN_DEBUG "CTRL: 0x%x\n", (val >> 12) & 0x0f); - printk(KERN_DEBUG "EC: 0x%x\n", val & 0x0fff); - if (trident->device != TRIDENT_DEVICE_ID_NX) { - val = inl(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS)); - printk(KERN_DEBUG "CSO: 0x%x\n", val >> 16); - printk("Alpha: 0x%x\n", (val >> 4) & 0x0fff); - printk(KERN_DEBUG "FMS: 0x%x\n", val & 0x0f); - val = inl(TRID_REG(trident, CH_DX_ESO_DELTA)); - printk(KERN_DEBUG "ESO: 0x%x\n", val >> 16); - printk(KERN_DEBUG "Delta: 0x%x\n", val & 0xffff); - val = inl(TRID_REG(trident, CH_DX_FMC_RVOL_CVOL)); - } else { // TRIDENT_DEVICE_ID_NX - val = inl(TRID_REG(trident, CH_NX_DELTA_CSO)); - tmp = (val >> 24) & 0xff; - printk(KERN_DEBUG "CSO: 0x%x\n", val & 0x00ffffff); - val = inl(TRID_REG(trident, CH_NX_DELTA_ESO)); - tmp |= (val >> 16) & 0xff00; - printk(KERN_DEBUG "Delta: 0x%x\n", tmp); - printk(KERN_DEBUG "ESO: 0x%x\n", val & 0x00ffffff); - val = inl(TRID_REG(trident, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL)); - printk(KERN_DEBUG "Alpha: 0x%x\n", val >> 20); - printk(KERN_DEBUG "FMS: 0x%x\n", (val >> 16) & 0x0f); - } - printk(KERN_DEBUG "FMC: 0x%x\n", (val >> 14) & 3); - printk(KERN_DEBUG "RVol: 0x%x\n", (val >> 7) & 0x7f); - printk(KERN_DEBUG "CVol: 0x%x\n", val & 0x7f); -} -#endif - -/*--------------------------------------------------------------------------- - unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg) - - Description: This routine will do all of the reading from the external - CODEC (AC97). - - Parameters: ac97 - ac97 codec structure - reg - CODEC register index, from AC97 Hal. - - returns: 16 bit value read from the AC97. - - ---------------------------------------------------------------------------*/ -static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg) -{ - unsigned int data = 0, treg; - unsigned short count = 0xffff; - unsigned long flags; - struct snd_trident *trident = ac97->private_data; - - spin_lock_irqsave(&trident->reg_lock, flags); - if (trident->device == TRIDENT_DEVICE_ID_DX) { - data = (DX_AC97_BUSY_READ | (reg & 0x000000ff)); - outl(data, TRID_REG(trident, DX_ACR1_AC97_R)); - do { - data = inl(TRID_REG(trident, DX_ACR1_AC97_R)); - if ((data & DX_AC97_BUSY_READ) == 0) - break; - } while (--count); - } else if (trident->device == TRIDENT_DEVICE_ID_NX) { - data = (NX_AC97_BUSY_READ | (reg & 0x000000ff)); - treg = ac97->num == 0 ? NX_ACR2_AC97_R_PRIMARY : NX_ACR3_AC97_R_SECONDARY; - outl(data, TRID_REG(trident, treg)); - do { - data = inl(TRID_REG(trident, treg)); - if ((data & 0x00000C00) == 0) - break; - } while (--count); - } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) { - data = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff); - if (ac97->num == 1) - data |= SI_AC97_SECONDARY; - outl(data, TRID_REG(trident, SI_AC97_READ)); - do { - data = inl(TRID_REG(trident, SI_AC97_READ)); - if ((data & (SI_AC97_BUSY_READ)) == 0) - break; - } while (--count); - } - - if (count == 0 && !trident->ac97_detect) { - snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n", - reg, data); - data = 0; - } - - spin_unlock_irqrestore(&trident->reg_lock, flags); - return ((unsigned short) (data >> 16)); -} - -/*--------------------------------------------------------------------------- - void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg, - unsigned short wdata) - - Description: This routine will do all of the writing to the external - CODEC (AC97). - - Parameters: ac97 - ac97 codec structure - reg - CODEC register index, from AC97 Hal. - data - Lower 16 bits are the data to write to CODEC. - - returns: TRUE if everything went ok, else FALSE. - - ---------------------------------------------------------------------------*/ -static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg, - unsigned short wdata) -{ - unsigned int address, data; - unsigned short count = 0xffff; - unsigned long flags; - struct snd_trident *trident = ac97->private_data; - - data = ((unsigned long) wdata) << 16; - - spin_lock_irqsave(&trident->reg_lock, flags); - if (trident->device == TRIDENT_DEVICE_ID_DX) { - address = DX_ACR0_AC97_W; - - /* read AC-97 write register status */ - do { - if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0) - break; - } while (--count); - - data |= (DX_AC97_BUSY_WRITE | (reg & 0x000000ff)); - } else if (trident->device == TRIDENT_DEVICE_ID_NX) { - address = NX_ACR1_AC97_W; - - /* read AC-97 write register status */ - do { - if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0) - break; - } while (--count); - - data |= (NX_AC97_BUSY_WRITE | (ac97->num << 8) | (reg & 0x000000ff)); - } else if (trident->device == TRIDENT_DEVICE_ID_SI7018) { - address = SI_AC97_WRITE; - - /* read AC-97 write register status */ - do { - if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0) - break; - } while (--count); - - data |= SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff); - if (ac97->num == 1) - data |= SI_AC97_SECONDARY; - } else { - address = 0; /* keep GCC happy */ - count = 0; /* return */ - } - - if (count == 0) { - spin_unlock_irqrestore(&trident->reg_lock, flags); - return; - } - outl(data, TRID_REG(trident, address)); - spin_unlock_irqrestore(&trident->reg_lock, flags); -} - -/*--------------------------------------------------------------------------- - void snd_trident_enable_eso(struct snd_trident *trident) - - Description: This routine will enable end of loop interrupts. - End of loop interrupts will occur when a running - channel reaches ESO. - Also enables middle of loop interrupts. - - Parameters: trident - pointer to target device class for 4DWave. - - ---------------------------------------------------------------------------*/ - -static void snd_trident_enable_eso(struct snd_trident * trident) -{ - unsigned int val; - - val = inl(TRID_REG(trident, T4D_LFO_GC_CIR)); - val |= ENDLP_IE; - val |= MIDLP_IE; - if (trident->device == TRIDENT_DEVICE_ID_SI7018) - val |= BANK_B_EN; - outl(val, TRID_REG(trident, T4D_LFO_GC_CIR)); -} - -/*--------------------------------------------------------------------------- - void snd_trident_disable_eso(struct snd_trident *trident) - - Description: This routine will disable end of loop interrupts. - End of loop interrupts will occur when a running - channel reaches ESO. - Also disables middle of loop interrupts. - - Parameters: - trident - pointer to target device class for 4DWave. - - returns: TRUE if everything went ok, else FALSE. - - ---------------------------------------------------------------------------*/ - -static void snd_trident_disable_eso(struct snd_trident * trident) -{ - unsigned int tmp; - - tmp = inl(TRID_REG(trident, T4D_LFO_GC_CIR)); - tmp &= ~ENDLP_IE; - tmp &= ~MIDLP_IE; - outl(tmp, TRID_REG(trident, T4D_LFO_GC_CIR)); -} - -/*--------------------------------------------------------------------------- - void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice) - - Description: Start a voice, any channel 0 thru 63. - This routine automatically handles the fact that there are - more than 32 channels available. - - Parameters : voice - Voice number 0 thru n. - trident - pointer to target device class for 4DWave. - - Return Value: None. - - ---------------------------------------------------------------------------*/ - -void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice) -{ - unsigned int mask = 1 << (voice & 0x1f); - unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A; - - outl(mask, TRID_REG(trident, reg)); -} - -EXPORT_SYMBOL(snd_trident_start_voice); - -/*--------------------------------------------------------------------------- - void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice) - - Description: Stop a voice, any channel 0 thru 63. - This routine automatically handles the fact that there are - more than 32 channels available. - - Parameters : voice - Voice number 0 thru n. - trident - pointer to target device class for 4DWave. - - Return Value: None. - - ---------------------------------------------------------------------------*/ - -void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice) -{ - unsigned int mask = 1 << (voice & 0x1f); - unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A; - - outl(mask, TRID_REG(trident, reg)); -} - -EXPORT_SYMBOL(snd_trident_stop_voice); - -/*--------------------------------------------------------------------------- - int snd_trident_allocate_pcm_channel(struct snd_trident *trident) - - Description: Allocate hardware channel in Bank B (32-63). - - Parameters : trident - pointer to target device class for 4DWave. - - Return Value: hardware channel - 32-63 or -1 when no channel is available - - ---------------------------------------------------------------------------*/ - -static int snd_trident_allocate_pcm_channel(struct snd_trident * trident) -{ - int idx; - - if (trident->ChanPCMcnt >= trident->ChanPCM) - return -1; - for (idx = 31; idx >= 0; idx--) { - if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) { - trident->ChanMap[T4D_BANK_B] |= 1 << idx; - trident->ChanPCMcnt++; - return idx + 32; - } - } - return -1; -} - -/*--------------------------------------------------------------------------- - void snd_trident_free_pcm_channel(int channel) - - Description: Free hardware channel in Bank B (32-63) - - Parameters : trident - pointer to target device class for 4DWave. - channel - hardware channel number 0-63 - - Return Value: none - - ---------------------------------------------------------------------------*/ - -static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel) -{ - if (channel < 32 || channel > 63) - return; - channel &= 0x1f; - if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) { - trident->ChanMap[T4D_BANK_B] &= ~(1 << channel); - trident->ChanPCMcnt--; - } -} - -/*--------------------------------------------------------------------------- - unsigned int snd_trident_allocate_synth_channel(void) - - Description: Allocate hardware channel in Bank A (0-31). - - Parameters : trident - pointer to target device class for 4DWave. - - Return Value: hardware channel - 0-31 or -1 when no channel is available - - ---------------------------------------------------------------------------*/ - -static int snd_trident_allocate_synth_channel(struct snd_trident * trident) -{ - int idx; - - for (idx = 31; idx >= 0; idx--) { - if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) { - trident->ChanMap[T4D_BANK_A] |= 1 << idx; - trident->synth.ChanSynthCount++; - return idx; - } - } - return -1; -} - -/*--------------------------------------------------------------------------- - void snd_trident_free_synth_channel( int channel ) - - Description: Free hardware channel in Bank B (0-31). - - Parameters : trident - pointer to target device class for 4DWave. - channel - hardware channel number 0-63 - - Return Value: none - - ---------------------------------------------------------------------------*/ - -static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel) -{ - if (channel < 0 || channel > 31) - return; - channel &= 0x1f; - if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) { - trident->ChanMap[T4D_BANK_A] &= ~(1 << channel); - trident->synth.ChanSynthCount--; - } -} - -/*--------------------------------------------------------------------------- - snd_trident_write_voice_regs - - Description: This routine will complete and write the 5 hardware channel - registers to hardware. - - Parameters: trident - pointer to target device class for 4DWave. - voice - synthesizer voice structure - Each register field. - - ---------------------------------------------------------------------------*/ - -void snd_trident_write_voice_regs(struct snd_trident * trident, - struct snd_trident_voice * voice) -{ - unsigned int FmcRvolCvol; - unsigned int regs[5]; - - regs[1] = voice->LBA; - regs[4] = (voice->GVSel << 31) | - ((voice->Pan & 0x0000007f) << 24) | - ((voice->CTRL & 0x0000000f) << 12); - FmcRvolCvol = ((voice->FMC & 3) << 14) | - ((voice->RVol & 0x7f) << 7) | - (voice->CVol & 0x7f); - - switch (trident->device) { - case TRIDENT_DEVICE_ID_SI7018: - regs[4] |= voice->number > 31 ? - (voice->Vol & 0x000003ff) : - ((voice->Vol & 0x00003fc) << (16-2)) | - (voice->EC & 0x00000fff); - regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | - (voice->FMS & 0x0000000f); - regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff); - regs[3] = (voice->Attribute << 16) | FmcRvolCvol; - break; - case TRIDENT_DEVICE_ID_DX: - regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) | - (voice->EC & 0x00000fff); - regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | - (voice->FMS & 0x0000000f); - regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff); - regs[3] = FmcRvolCvol; - break; - case TRIDENT_DEVICE_ID_NX: - regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) | - (voice->EC & 0x00000fff); - regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff); - regs[2] = ((voice->Delta << 16) & 0xff000000) | - (voice->ESO & 0x00ffffff); - regs[3] = (voice->Alpha << 20) | - ((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol; - break; - default: - snd_BUG(); - return; - } - - outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - outl(regs[0], TRID_REG(trident, CH_START + 0)); - outl(regs[1], TRID_REG(trident, CH_START + 4)); - outl(regs[2], TRID_REG(trident, CH_START + 8)); - outl(regs[3], TRID_REG(trident, CH_START + 12)); - outl(regs[4], TRID_REG(trident, CH_START + 16)); - -#if 0 - printk(KERN_DEBUG "written %i channel:\n", voice->number); - printk(KERN_DEBUG " regs[0] = 0x%x/0x%x\n", - regs[0], inl(TRID_REG(trident, CH_START + 0))); - printk(KERN_DEBUG " regs[1] = 0x%x/0x%x\n", - regs[1], inl(TRID_REG(trident, CH_START + 4))); - printk(KERN_DEBUG " regs[2] = 0x%x/0x%x\n", - regs[2], inl(TRID_REG(trident, CH_START + 8))); - printk(KERN_DEBUG " regs[3] = 0x%x/0x%x\n", - regs[3], inl(TRID_REG(trident, CH_START + 12))); - printk(KERN_DEBUG " regs[4] = 0x%x/0x%x\n", - regs[4], inl(TRID_REG(trident, CH_START + 16))); -#endif -} - -EXPORT_SYMBOL(snd_trident_write_voice_regs); - -/*--------------------------------------------------------------------------- - snd_trident_write_cso_reg - - Description: This routine will write the new CSO offset - register to hardware. - - Parameters: trident - pointer to target device class for 4DWave. - voice - synthesizer voice structure - CSO - new CSO value - - ---------------------------------------------------------------------------*/ - -static void snd_trident_write_cso_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int CSO) -{ - voice->CSO = CSO; - outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - if (trident->device != TRIDENT_DEVICE_ID_NX) { - outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2); - } else { - outl((voice->Delta << 24) | - (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO)); - } -} - -/*--------------------------------------------------------------------------- - snd_trident_write_eso_reg - - Description: This routine will write the new ESO offset - register to hardware. - - Parameters: trident - pointer to target device class for 4DWave. - voice - synthesizer voice structure - ESO - new ESO value - - ---------------------------------------------------------------------------*/ - -static void snd_trident_write_eso_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int ESO) -{ - voice->ESO = ESO; - outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - if (trident->device != TRIDENT_DEVICE_ID_NX) { - outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2); - } else { - outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff), - TRID_REG(trident, CH_NX_DELTA_ESO)); - } -} - -/*--------------------------------------------------------------------------- - snd_trident_write_vol_reg - - Description: This routine will write the new voice volume - register to hardware. - - Parameters: trident - pointer to target device class for 4DWave. - voice - synthesizer voice structure - Vol - new voice volume - - ---------------------------------------------------------------------------*/ - -static void snd_trident_write_vol_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int Vol) -{ - voice->Vol = Vol; - outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - switch (trident->device) { - case TRIDENT_DEVICE_ID_DX: - case TRIDENT_DEVICE_ID_NX: - outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2)); - break; - case TRIDENT_DEVICE_ID_SI7018: - /* printk(KERN_DEBUG "voice->Vol = 0x%x\n", voice->Vol); */ - outw((voice->CTRL << 12) | voice->Vol, - TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC)); - break; - } -} - -/*--------------------------------------------------------------------------- - snd_trident_write_pan_reg - - Description: This routine will write the new voice pan - register to hardware. - - Parameters: trident - pointer to target device class for 4DWave. - voice - synthesizer voice structure - Pan - new pan value - - ---------------------------------------------------------------------------*/ - -static void snd_trident_write_pan_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int Pan) -{ - voice->Pan = Pan; - outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f), - TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3)); -} - -/*--------------------------------------------------------------------------- - snd_trident_write_rvol_reg - - Description: This routine will write the new reverb volume - register to hardware. - - Parameters: trident - pointer to target device class for 4DWave. - voice - synthesizer voice structure - RVol - new reverb volume - - ---------------------------------------------------------------------------*/ - -static void snd_trident_write_rvol_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int RVol) -{ - voice->RVol = RVol; - outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) | - (voice->CVol & 0x007f), - TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ? - CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL)); -} - -/*--------------------------------------------------------------------------- - snd_trident_write_cvol_reg - - Description: This routine will write the new chorus volume - register to hardware. - - Parameters: trident - pointer to target device class for 4DWave. - voice - synthesizer voice structure - CVol - new chorus volume - - ---------------------------------------------------------------------------*/ - -static void snd_trident_write_cvol_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int CVol) -{ - voice->CVol = CVol; - outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) | - (voice->CVol & 0x007f), - TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ? - CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL)); -} - -/*--------------------------------------------------------------------------- - snd_trident_convert_rate - - Description: This routine converts rate in HZ to hardware delta value. - - Parameters: trident - pointer to target device class for 4DWave. - rate - Real or Virtual channel number. - - Returns: Delta value. - - ---------------------------------------------------------------------------*/ -static unsigned int snd_trident_convert_rate(unsigned int rate) -{ - unsigned int delta; - - // We special case 44100 and 8000 since rounding with the equation - // does not give us an accurate enough value. For 11025 and 22050 - // the equation gives us the best answer. All other frequencies will - // also use the equation. JDW - if (rate == 44100) - delta = 0xeb3; - else if (rate == 8000) - delta = 0x2ab; - else if (rate == 48000) - delta = 0x1000; - else - delta = (((rate << 12) + 24000) / 48000) & 0x0000ffff; - return delta; -} - -/*--------------------------------------------------------------------------- - snd_trident_convert_adc_rate - - Description: This routine converts rate in HZ to hardware delta value. - - Parameters: trident - pointer to target device class for 4DWave. - rate - Real or Virtual channel number. - - Returns: Delta value. - - ---------------------------------------------------------------------------*/ -static unsigned int snd_trident_convert_adc_rate(unsigned int rate) -{ - unsigned int delta; - - // We special case 44100 and 8000 since rounding with the equation - // does not give us an accurate enough value. For 11025 and 22050 - // the equation gives us the best answer. All other frequencies will - // also use the equation. JDW - if (rate == 44100) - delta = 0x116a; - else if (rate == 8000) - delta = 0x6000; - else if (rate == 48000) - delta = 0x1000; - else - delta = ((48000 << 12) / rate) & 0x0000ffff; - return delta; -} - -/*--------------------------------------------------------------------------- - snd_trident_spurious_threshold - - Description: This routine converts rate in HZ to spurious threshold. - - Parameters: trident - pointer to target device class for 4DWave. - rate - Real or Virtual channel number. - - Returns: Delta value. - - ---------------------------------------------------------------------------*/ -static unsigned int snd_trident_spurious_threshold(unsigned int rate, - unsigned int period_size) -{ - unsigned int res = (rate * period_size) / 48000; - if (res < 64) - res = res / 2; - else - res -= 32; - return res; -} - -/*--------------------------------------------------------------------------- - snd_trident_control_mode - - Description: This routine returns a control mode for a PCM channel. - - Parameters: trident - pointer to target device class for 4DWave. - substream - PCM substream - - Returns: Control value. - - ---------------------------------------------------------------------------*/ -static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream) -{ - unsigned int CTRL; - struct snd_pcm_runtime *runtime = substream->runtime; - - /* set ctrl mode - CTRL default: 8-bit (unsigned) mono, loop mode enabled - */ - CTRL = 0x00000001; - if (snd_pcm_format_width(runtime->format) == 16) - CTRL |= 0x00000008; // 16-bit data - if (snd_pcm_format_signed(runtime->format)) - CTRL |= 0x00000002; // signed data - if (runtime->channels > 1) - CTRL |= 0x00000004; // stereo data - return CTRL; -} - -/* - * PCM part - */ - -/*--------------------------------------------------------------------------- - snd_trident_ioctl - - Description: Device I/O control handler for playback/capture parameters. - - Parameters: substream - PCM substream class - cmd - what ioctl message to process - arg - additional message infoarg - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_ioctl(struct snd_pcm_substream *substream, - unsigned int cmd, - void *arg) -{ - /* FIXME: it seems that with small periods the behaviour of - trident hardware is unpredictable and interrupt generator - is broken */ - return snd_pcm_lib_ioctl(substream, cmd, arg); -} - -/*--------------------------------------------------------------------------- - snd_trident_allocate_pcm_mem - - Description: Allocate PCM ring buffer for given substream - - Parameters: substream - PCM substream class - hw_params - hardware parameters - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - int err; - - if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) - return err; - if (trident->tlb.entries) { - if (err > 0) { /* change */ - if (voice->memblk) - snd_trident_free_pages(trident, voice->memblk); - voice->memblk = snd_trident_alloc_pages(trident, substream); - if (voice->memblk == NULL) - return -ENOMEM; - } - } - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_allocate_evoice - - Description: Allocate extra voice as interrupt generator - - Parameters: substream - PCM substream class - hw_params - hardware parameters - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; - - /* voice management */ - - if (params_buffer_size(hw_params) / 2 != params_period_size(hw_params)) { - if (evoice == NULL) { - evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); - if (evoice == NULL) - return -ENOMEM; - voice->extra = evoice; - evoice->substream = substream; - } - } else { - if (evoice != NULL) { - snd_trident_free_voice(trident, evoice); - voice->extra = evoice = NULL; - } - } - - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_hw_params - - Description: Set the hardware parameters for the playback device. - - Parameters: substream - PCM substream class - hw_params - hardware parameters - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - int err; - - err = snd_trident_allocate_pcm_mem(substream, hw_params); - if (err >= 0) - err = snd_trident_allocate_evoice(substream, hw_params); - return err; -} - -/*--------------------------------------------------------------------------- - snd_trident_playback_hw_free - - Description: Release the hardware resources for the playback device. - - Parameters: substream - PCM substream class - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_hw_free(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice ? voice->extra : NULL; - - if (trident->tlb.entries) { - if (voice && voice->memblk) { - snd_trident_free_pages(trident, voice->memblk); - voice->memblk = NULL; - } - } - snd_pcm_lib_free_pages(substream); - if (evoice != NULL) { - snd_trident_free_voice(trident, evoice); - voice->extra = NULL; - } - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_playback_prepare - - Description: Prepare playback device for playback. - - Parameters: substream - PCM substream class - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_playback_prepare(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number]; - - spin_lock_irq(&trident->reg_lock); - - /* set delta (rate) value */ - voice->Delta = snd_trident_convert_rate(runtime->rate); - voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size); - - /* set Loop Begin Address */ - if (voice->memblk) - voice->LBA = voice->memblk->offset; - else - voice->LBA = runtime->dma_addr; - - voice->CSO = 0; - voice->ESO = runtime->buffer_size - 1; /* in samples */ - voice->CTRL = snd_trident_control_mode(substream); - voice->FMC = 3; - voice->GVSel = 1; - voice->EC = 0; - voice->Alpha = 0; - voice->FMS = 0; - voice->Vol = mix->vol; - voice->RVol = mix->rvol; - voice->CVol = mix->cvol; - voice->Pan = mix->pan; - voice->Attribute = 0; -#if 0 - voice->Attribute = (1<<(30-16))|(2<<(26-16))| - (0<<(24-16))|(0x1f<<(19-16)); -#else - voice->Attribute = 0; -#endif - - snd_trident_write_voice_regs(trident, voice); - - if (evoice != NULL) { - evoice->Delta = voice->Delta; - evoice->spurious_threshold = voice->spurious_threshold; - evoice->LBA = voice->LBA; - evoice->CSO = 0; - evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */ - evoice->CTRL = voice->CTRL; - evoice->FMC = 3; - evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1; - evoice->EC = 0; - evoice->Alpha = 0; - evoice->FMS = 0; - evoice->Vol = 0x3ff; /* mute */ - evoice->RVol = evoice->CVol = 0x7f; /* mute */ - evoice->Pan = 0x7f; /* mute */ -#if 0 - evoice->Attribute = (1<<(30-16))|(2<<(26-16))| - (0<<(24-16))|(0x1f<<(19-16)); -#else - evoice->Attribute = 0; -#endif - snd_trident_write_voice_regs(trident, evoice); - evoice->isync2 = 1; - evoice->isync_mark = runtime->period_size; - evoice->ESO = (runtime->period_size * 2) - 1; - } - - spin_unlock_irq(&trident->reg_lock); - - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_capture_hw_params - - Description: Set the hardware parameters for the capture device. - - Parameters: substream - PCM substream class - hw_params - hardware parameters - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - return snd_trident_allocate_pcm_mem(substream, hw_params); -} - -/*--------------------------------------------------------------------------- - snd_trident_capture_prepare - - Description: Prepare capture device for playback. - - Parameters: substream - PCM substream class - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_capture_prepare(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - unsigned int val, ESO_bytes; - - spin_lock_irq(&trident->reg_lock); - - // Initialize the channel and set channel Mode - outb(0, TRID_REG(trident, LEGACY_DMAR15)); - - // Set DMA channel operation mode register - outb(0x54, TRID_REG(trident, LEGACY_DMAR11)); - - // Set channel buffer Address, DMAR0 expects contiguous PCI memory area - voice->LBA = runtime->dma_addr; - outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0)); - if (voice->memblk) - voice->LBA = voice->memblk->offset; - - // set ESO - ESO_bytes = snd_pcm_lib_buffer_bytes(substream) - 1; - outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6)); - outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4)); - ESO_bytes++; - - // Set channel sample rate, 4.12 format - val = (((unsigned int) 48000L << 12) + (runtime->rate/2)) / runtime->rate; - outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R)); - - // Set channel interrupt blk length - if (snd_pcm_format_width(runtime->format) == 16) { - val = (unsigned short) ((ESO_bytes >> 1) - 1); - } else { - val = (unsigned short) (ESO_bytes - 1); - } - - outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL)); - - // Right now, set format and start to run captureing, - // continuous run loop enable. - trident->bDMAStart = 0x19; // 0001 1001b - - if (snd_pcm_format_width(runtime->format) == 16) - trident->bDMAStart |= 0x80; - if (snd_pcm_format_signed(runtime->format)) - trident->bDMAStart |= 0x20; - if (runtime->channels > 1) - trident->bDMAStart |= 0x40; - - // Prepare capture intr channel - - voice->Delta = snd_trident_convert_rate(runtime->rate); - voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size); - voice->isync = 1; - voice->isync_mark = runtime->period_size; - voice->isync_max = runtime->buffer_size; - - // Set voice parameters - voice->CSO = 0; - voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1; - voice->CTRL = snd_trident_control_mode(substream); - voice->FMC = 3; - voice->RVol = 0x7f; - voice->CVol = 0x7f; - voice->GVSel = 1; - voice->Pan = 0x7f; /* mute */ - voice->Vol = 0x3ff; /* mute */ - voice->EC = 0; - voice->Alpha = 0; - voice->FMS = 0; - voice->Attribute = 0; - - snd_trident_write_voice_regs(trident, voice); - - spin_unlock_irq(&trident->reg_lock); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_si7018_capture_hw_params - - Description: Set the hardware parameters for the capture device. - - Parameters: substream - PCM substream class - hw_params - hardware parameters - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - int err; - - if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) - return err; - - return snd_trident_allocate_evoice(substream, hw_params); -} - -/*--------------------------------------------------------------------------- - snd_trident_si7018_capture_hw_free - - Description: Release the hardware resources for the capture device. - - Parameters: substream - PCM substream class - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice ? voice->extra : NULL; - - snd_pcm_lib_free_pages(substream); - if (evoice != NULL) { - snd_trident_free_voice(trident, evoice); - voice->extra = NULL; - } - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_si7018_capture_prepare - - Description: Prepare capture device for playback. - - Parameters: substream - PCM substream class - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; - - spin_lock_irq(&trident->reg_lock); - - voice->LBA = runtime->dma_addr; - voice->Delta = snd_trident_convert_adc_rate(runtime->rate); - voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size); - - // Set voice parameters - voice->CSO = 0; - voice->ESO = runtime->buffer_size - 1; /* in samples */ - voice->CTRL = snd_trident_control_mode(substream); - voice->FMC = 0; - voice->RVol = 0; - voice->CVol = 0; - voice->GVSel = 1; - voice->Pan = T4D_DEFAULT_PCM_PAN; - voice->Vol = 0; - voice->EC = 0; - voice->Alpha = 0; - voice->FMS = 0; - - voice->Attribute = (2 << (30-16)) | - (2 << (26-16)) | - (2 << (24-16)) | - (1 << (23-16)); - - snd_trident_write_voice_regs(trident, voice); - - if (evoice != NULL) { - evoice->Delta = snd_trident_convert_rate(runtime->rate); - evoice->spurious_threshold = voice->spurious_threshold; - evoice->LBA = voice->LBA; - evoice->CSO = 0; - evoice->ESO = (runtime->period_size * 2) + 20 - 1; /* in samples, 20 means correction */ - evoice->CTRL = voice->CTRL; - evoice->FMC = 3; - evoice->GVSel = 0; - evoice->EC = 0; - evoice->Alpha = 0; - evoice->FMS = 0; - evoice->Vol = 0x3ff; /* mute */ - evoice->RVol = evoice->CVol = 0x7f; /* mute */ - evoice->Pan = 0x7f; /* mute */ - evoice->Attribute = 0; - snd_trident_write_voice_regs(trident, evoice); - evoice->isync2 = 1; - evoice->isync_mark = runtime->period_size; - evoice->ESO = (runtime->period_size * 2) - 1; - } - - spin_unlock_irq(&trident->reg_lock); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_foldback_prepare - - Description: Prepare foldback capture device for playback. - - Parameters: substream - PCM substream class - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; - - spin_lock_irq(&trident->reg_lock); - - /* Set channel buffer Address */ - if (voice->memblk) - voice->LBA = voice->memblk->offset; - else - voice->LBA = runtime->dma_addr; - - /* set target ESO for channel */ - voice->ESO = runtime->buffer_size - 1; /* in samples */ - - /* set sample rate */ - voice->Delta = 0x1000; - voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size); - - voice->CSO = 0; - voice->CTRL = snd_trident_control_mode(substream); - voice->FMC = 3; - voice->RVol = 0x7f; - voice->CVol = 0x7f; - voice->GVSel = 1; - voice->Pan = 0x7f; /* mute */ - voice->Vol = 0x3ff; /* mute */ - voice->EC = 0; - voice->Alpha = 0; - voice->FMS = 0; - voice->Attribute = 0; - - /* set up capture channel */ - outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan)); - - snd_trident_write_voice_regs(trident, voice); - - if (evoice != NULL) { - evoice->Delta = voice->Delta; - evoice->spurious_threshold = voice->spurious_threshold; - evoice->LBA = voice->LBA; - evoice->CSO = 0; - evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */ - evoice->CTRL = voice->CTRL; - evoice->FMC = 3; - evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1; - evoice->EC = 0; - evoice->Alpha = 0; - evoice->FMS = 0; - evoice->Vol = 0x3ff; /* mute */ - evoice->RVol = evoice->CVol = 0x7f; /* mute */ - evoice->Pan = 0x7f; /* mute */ - evoice->Attribute = 0; - snd_trident_write_voice_regs(trident, evoice); - evoice->isync2 = 1; - evoice->isync_mark = runtime->period_size; - evoice->ESO = (runtime->period_size * 2) - 1; - } - - spin_unlock_irq(&trident->reg_lock); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_spdif_hw_params - - Description: Set the hardware parameters for the spdif device. - - Parameters: substream - PCM substream class - hw_params - hardware parameters - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - unsigned int old_bits = 0, change = 0; - int err; - - err = snd_trident_allocate_pcm_mem(substream, hw_params); - if (err < 0) - return err; - - if (trident->device == TRIDENT_DEVICE_ID_SI7018) { - err = snd_trident_allocate_evoice(substream, hw_params); - if (err < 0) - return err; - } - - /* prepare SPDIF channel */ - spin_lock_irq(&trident->reg_lock); - old_bits = trident->spdif_pcm_bits; - if (old_bits & IEC958_AES0_PROFESSIONAL) - trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS; - else - trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24); - if (params_rate(hw_params) >= 48000) { - trident->spdif_pcm_ctrl = 0x3c; // 48000 Hz - trident->spdif_pcm_bits |= - trident->spdif_bits & IEC958_AES0_PROFESSIONAL ? - IEC958_AES0_PRO_FS_48000 : - (IEC958_AES3_CON_FS_48000 << 24); - } - else if (params_rate(hw_params) >= 44100) { - trident->spdif_pcm_ctrl = 0x3e; // 44100 Hz - trident->spdif_pcm_bits |= - trident->spdif_bits & IEC958_AES0_PROFESSIONAL ? - IEC958_AES0_PRO_FS_44100 : - (IEC958_AES3_CON_FS_44100 << 24); - } - else { - trident->spdif_pcm_ctrl = 0x3d; // 32000 Hz - trident->spdif_pcm_bits |= - trident->spdif_bits & IEC958_AES0_PROFESSIONAL ? - IEC958_AES0_PRO_FS_32000 : - (IEC958_AES3_CON_FS_32000 << 24); - } - change = old_bits != trident->spdif_pcm_bits; - spin_unlock_irq(&trident->reg_lock); - - if (change) - snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id); - - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_spdif_prepare - - Description: Prepare SPDIF device for playback. - - Parameters: substream - PCM substream class - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number]; - unsigned int RESO, LBAO; - unsigned int temp; - - spin_lock_irq(&trident->reg_lock); - - if (trident->device != TRIDENT_DEVICE_ID_SI7018) { - - /* set delta (rate) value */ - voice->Delta = snd_trident_convert_rate(runtime->rate); - voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size); - - /* set Loop Back Address */ - LBAO = runtime->dma_addr; - if (voice->memblk) - voice->LBA = voice->memblk->offset; - else - voice->LBA = LBAO; - - voice->isync = 1; - voice->isync3 = 1; - voice->isync_mark = runtime->period_size; - voice->isync_max = runtime->buffer_size; - - /* set target ESO for channel */ - RESO = runtime->buffer_size - 1; - voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1; - - /* set ctrl mode */ - voice->CTRL = snd_trident_control_mode(substream); - - voice->FMC = 3; - voice->RVol = 0x7f; - voice->CVol = 0x7f; - voice->GVSel = 1; - voice->Pan = 0x7f; - voice->Vol = 0x3ff; - voice->EC = 0; - voice->CSO = 0; - voice->Alpha = 0; - voice->FMS = 0; - voice->Attribute = 0; - - /* prepare surrogate IRQ channel */ - snd_trident_write_voice_regs(trident, voice); - - outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO)); - outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2)); - outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA)); - outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO)); - outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2)); - - /* set SPDIF setting */ - outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); - outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS)); - - } else { /* SiS */ - - /* set delta (rate) value */ - voice->Delta = 0x800; - voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size); - - /* set Loop Begin Address */ - if (voice->memblk) - voice->LBA = voice->memblk->offset; - else - voice->LBA = runtime->dma_addr; - - voice->CSO = 0; - voice->ESO = runtime->buffer_size - 1; /* in samples */ - voice->CTRL = snd_trident_control_mode(substream); - voice->FMC = 3; - voice->GVSel = 1; - voice->EC = 0; - voice->Alpha = 0; - voice->FMS = 0; - voice->Vol = mix->vol; - voice->RVol = mix->rvol; - voice->CVol = mix->cvol; - voice->Pan = mix->pan; - voice->Attribute = (1<<(30-16))|(7<<(26-16))| - (0<<(24-16))|(0<<(19-16)); - - snd_trident_write_voice_regs(trident, voice); - - if (evoice != NULL) { - evoice->Delta = voice->Delta; - evoice->spurious_threshold = voice->spurious_threshold; - evoice->LBA = voice->LBA; - evoice->CSO = 0; - evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */ - evoice->CTRL = voice->CTRL; - evoice->FMC = 3; - evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1; - evoice->EC = 0; - evoice->Alpha = 0; - evoice->FMS = 0; - evoice->Vol = 0x3ff; /* mute */ - evoice->RVol = evoice->CVol = 0x7f; /* mute */ - evoice->Pan = 0x7f; /* mute */ - evoice->Attribute = 0; - snd_trident_write_voice_regs(trident, evoice); - evoice->isync2 = 1; - evoice->isync_mark = runtime->period_size; - evoice->ESO = (runtime->period_size * 2) - 1; - } - - outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS)); - temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR)); - temp &= ~(1<<19); - outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR)); - temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - temp |= SPDIF_EN; - outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - } - - spin_unlock_irq(&trident->reg_lock); - - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_trigger - - Description: Start/stop devices - - Parameters: substream - PCM substream class - cmd - trigger command (STOP, GO) - - Returns: Error status - - ---------------------------------------------------------------------------*/ - -static int snd_trident_trigger(struct snd_pcm_substream *substream, - int cmd) - -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_substream *s; - unsigned int what, whati, capture_flag, spdif_flag; - struct snd_trident_voice *voice, *evoice; - unsigned int val, go; - - switch (cmd) { - case SNDRV_PCM_TRIGGER_START: - case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - case SNDRV_PCM_TRIGGER_RESUME: - go = 1; - break; - case SNDRV_PCM_TRIGGER_STOP: - case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - case SNDRV_PCM_TRIGGER_SUSPEND: - go = 0; - break; - default: - return -EINVAL; - } - what = whati = capture_flag = spdif_flag = 0; - spin_lock(&trident->reg_lock); - val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff; - snd_pcm_group_for_each_entry(s, substream) { - if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) { - voice = s->runtime->private_data; - evoice = voice->extra; - what |= 1 << (voice->number & 0x1f); - if (evoice == NULL) { - whati |= 1 << (voice->number & 0x1f); - } else { - what |= 1 << (evoice->number & 0x1f); - whati |= 1 << (evoice->number & 0x1f); - if (go) - evoice->stimer = val; - } - if (go) { - voice->running = 1; - voice->stimer = val; - } else { - voice->running = 0; - } - snd_pcm_trigger_done(s, substream); - if (voice->capture) - capture_flag = 1; - if (voice->spdif) - spdif_flag = 1; - } - } - if (spdif_flag) { - if (trident->device != TRIDENT_DEVICE_ID_SI7018) { - outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS)); - val = trident->spdif_pcm_ctrl; - if (!go) - val &= ~(0x28); - outb(val, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); - } else { - outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS)); - val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN; - outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - } - } - if (!go) - outl(what, TRID_REG(trident, T4D_STOP_B)); - val = inl(TRID_REG(trident, T4D_AINTEN_B)); - if (go) { - val |= whati; - } else { - val &= ~whati; - } - outl(val, TRID_REG(trident, T4D_AINTEN_B)); - if (go) { - outl(what, TRID_REG(trident, T4D_START_B)); - - if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018) - outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD)); - } else { - if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018) - outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD)); - } - spin_unlock(&trident->reg_lock); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_playback_pointer - - Description: This routine return the playback position - - Parameters: substream - PCM substream class - - Returns: position of buffer - - ---------------------------------------------------------------------------*/ - -static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - unsigned int cso; - - if (!voice->running) - return 0; - - spin_lock(&trident->reg_lock); - - outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - - if (trident->device != TRIDENT_DEVICE_ID_NX) { - cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2)); - } else { // ID_4DWAVE_NX - cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff; - } - - spin_unlock(&trident->reg_lock); - - if (cso >= runtime->buffer_size) - cso = 0; - - return cso; -} - -/*--------------------------------------------------------------------------- - snd_trident_capture_pointer - - Description: This routine return the capture position - - Parameters: pcm1 - PCM device class - - Returns: position of buffer - - ---------------------------------------------------------------------------*/ - -static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - unsigned int result; - - if (!voice->running) - return 0; - - result = inw(TRID_REG(trident, T4D_SBBL_SBCL)); - if (runtime->channels > 1) - result >>= 1; - if (result > 0) - result = runtime->buffer_size - result; - - return result; -} - -/*--------------------------------------------------------------------------- - snd_trident_spdif_pointer - - Description: This routine return the SPDIF playback position - - Parameters: substream - PCM substream class - - Returns: position of buffer - - ---------------------------------------------------------------------------*/ - -static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - unsigned int result; - - if (!voice->running) - return 0; - - result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff; - - return result; -} - -/* - * Playback support device description - */ - -static struct snd_pcm_hardware snd_trident_playback = -{ - .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | - SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), - .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | - SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), - .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, - .rate_min = 4000, - .rate_max = 48000, - .channels_min = 1, - .channels_max = 2, - .buffer_bytes_max = (256*1024), - .period_bytes_min = 64, - .period_bytes_max = (256*1024), - .periods_min = 1, - .periods_max = 1024, - .fifo_size = 0, -}; - -/* - * Capture support device description - */ - -static struct snd_pcm_hardware snd_trident_capture = -{ - .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | - SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), - .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | - SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), - .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, - .rate_min = 4000, - .rate_max = 48000, - .channels_min = 1, - .channels_max = 2, - .buffer_bytes_max = (128*1024), - .period_bytes_min = 64, - .period_bytes_max = (128*1024), - .periods_min = 1, - .periods_max = 1024, - .fifo_size = 0, -}; - -/* - * Foldback capture support device description - */ - -static struct snd_pcm_hardware snd_trident_foldback = -{ - .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | - SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), - .formats = SNDRV_PCM_FMTBIT_S16_LE, - .rates = SNDRV_PCM_RATE_48000, - .rate_min = 48000, - .rate_max = 48000, - .channels_min = 2, - .channels_max = 2, - .buffer_bytes_max = (128*1024), - .period_bytes_min = 64, - .period_bytes_max = (128*1024), - .periods_min = 1, - .periods_max = 1024, - .fifo_size = 0, -}; - -/* - * SPDIF playback support device description - */ - -static struct snd_pcm_hardware snd_trident_spdif = -{ - .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | - SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), - .formats = SNDRV_PCM_FMTBIT_S16_LE, - .rates = (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | - SNDRV_PCM_RATE_48000), - .rate_min = 32000, - .rate_max = 48000, - .channels_min = 2, - .channels_max = 2, - .buffer_bytes_max = (128*1024), - .period_bytes_min = 64, - .period_bytes_max = (128*1024), - .periods_min = 1, - .periods_max = 1024, - .fifo_size = 0, -}; - -static struct snd_pcm_hardware snd_trident_spdif_7018 = -{ - .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | - SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */), - .formats = SNDRV_PCM_FMTBIT_S16_LE, - .rates = SNDRV_PCM_RATE_48000, - .rate_min = 48000, - .rate_max = 48000, - .channels_min = 2, - .channels_max = 2, - .buffer_bytes_max = (128*1024), - .period_bytes_min = 64, - .period_bytes_max = (128*1024), - .periods_min = 1, - .periods_max = 1024, - .fifo_size = 0, -}; - -static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime) -{ - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident *trident; - - if (voice) { - trident = voice->trident; - snd_trident_free_voice(trident, voice); - } -} - -static int snd_trident_playback_open(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice; - - voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); - if (voice == NULL) - return -EAGAIN; - snd_trident_pcm_mixer_build(trident, voice, substream); - voice->substream = substream; - runtime->private_data = voice; - runtime->private_free = snd_trident_pcm_free_substream; - runtime->hw = snd_trident_playback; - snd_pcm_set_sync(substream); - snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_playback_close - - Description: This routine will close the 4DWave playback device. For now - we will simply free the dma transfer buffer. - - Parameters: substream - PCM substream class - - ---------------------------------------------------------------------------*/ -static int snd_trident_playback_close(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - - snd_trident_pcm_mixer_free(trident, voice, substream); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_spdif_open - - Description: This routine will open the 4DWave SPDIF device. - - Parameters: substream - PCM substream class - - Returns: status - success or failure flag - - ---------------------------------------------------------------------------*/ - -static int snd_trident_spdif_open(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_trident_voice *voice; - struct snd_pcm_runtime *runtime = substream->runtime; - - voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); - if (voice == NULL) - return -EAGAIN; - voice->spdif = 1; - voice->substream = substream; - spin_lock_irq(&trident->reg_lock); - trident->spdif_pcm_bits = trident->spdif_bits; - spin_unlock_irq(&trident->reg_lock); - - runtime->private_data = voice; - runtime->private_free = snd_trident_pcm_free_substream; - if (trident->device == TRIDENT_DEVICE_ID_SI7018) { - runtime->hw = snd_trident_spdif; - } else { - runtime->hw = snd_trident_spdif_7018; - } - - trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; - snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE | - SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id); - - snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024); - return 0; -} - - -/*--------------------------------------------------------------------------- - snd_trident_spdif_close - - Description: This routine will close the 4DWave SPDIF device. - - Parameters: substream - PCM substream class - - ---------------------------------------------------------------------------*/ - -static int snd_trident_spdif_close(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - unsigned int temp; - - spin_lock_irq(&trident->reg_lock); - // restore default SPDIF setting - if (trident->device != TRIDENT_DEVICE_ID_SI7018) { - outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); - outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); - } else { - outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); - temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - if (trident->spdif_ctrl) { - temp |= SPDIF_EN; - } else { - temp &= ~SPDIF_EN; - } - outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - } - spin_unlock_irq(&trident->reg_lock); - trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; - snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE | - SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_capture_open - - Description: This routine will open the 4DWave capture device. - - Parameters: substream - PCM substream class - - Returns: status - success or failure flag - - ---------------------------------------------------------------------------*/ - -static int snd_trident_capture_open(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_trident_voice *voice; - struct snd_pcm_runtime *runtime = substream->runtime; - - voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); - if (voice == NULL) - return -EAGAIN; - voice->capture = 1; - voice->substream = substream; - runtime->private_data = voice; - runtime->private_free = snd_trident_pcm_free_substream; - runtime->hw = snd_trident_capture; - snd_pcm_set_sync(substream); - snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_capture_close - - Description: This routine will close the 4DWave capture device. For now - we will simply free the dma transfer buffer. - - Parameters: substream - PCM substream class - - ---------------------------------------------------------------------------*/ -static int snd_trident_capture_close(struct snd_pcm_substream *substream) -{ - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_foldback_open - - Description: This routine will open the 4DWave foldback capture device. - - Parameters: substream - PCM substream class - - Returns: status - success or failure flag - - ---------------------------------------------------------------------------*/ - -static int snd_trident_foldback_open(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_trident_voice *voice; - struct snd_pcm_runtime *runtime = substream->runtime; - - voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); - if (voice == NULL) - return -EAGAIN; - voice->foldback_chan = substream->number; - voice->substream = substream; - runtime->private_data = voice; - runtime->private_free = snd_trident_pcm_free_substream; - runtime->hw = snd_trident_foldback; - snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_foldback_close - - Description: This routine will close the 4DWave foldback capture device. - For now we will simply free the dma transfer buffer. - - Parameters: substream - PCM substream class - - ---------------------------------------------------------------------------*/ -static int snd_trident_foldback_close(struct snd_pcm_substream *substream) -{ - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_trident_voice *voice; - struct snd_pcm_runtime *runtime = substream->runtime; - voice = runtime->private_data; - - /* stop capture channel */ - spin_lock_irq(&trident->reg_lock); - outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan)); - spin_unlock_irq(&trident->reg_lock); - return 0; -} - -/*--------------------------------------------------------------------------- - PCM operations - ---------------------------------------------------------------------------*/ - -static struct snd_pcm_ops snd_trident_playback_ops = { - .open = snd_trident_playback_open, - .close = snd_trident_playback_close, - .ioctl = snd_trident_ioctl, - .hw_params = snd_trident_hw_params, - .hw_free = snd_trident_hw_free, - .prepare = snd_trident_playback_prepare, - .trigger = snd_trident_trigger, - .pointer = snd_trident_playback_pointer, -}; - -static struct snd_pcm_ops snd_trident_nx_playback_ops = { - .open = snd_trident_playback_open, - .close = snd_trident_playback_close, - .ioctl = snd_trident_ioctl, - .hw_params = snd_trident_hw_params, - .hw_free = snd_trident_hw_free, - .prepare = snd_trident_playback_prepare, - .trigger = snd_trident_trigger, - .pointer = snd_trident_playback_pointer, - .page = snd_pcm_sgbuf_ops_page, -}; - -static struct snd_pcm_ops snd_trident_capture_ops = { - .open = snd_trident_capture_open, - .close = snd_trident_capture_close, - .ioctl = snd_trident_ioctl, - .hw_params = snd_trident_capture_hw_params, - .hw_free = snd_trident_hw_free, - .prepare = snd_trident_capture_prepare, - .trigger = snd_trident_trigger, - .pointer = snd_trident_capture_pointer, -}; - -static struct snd_pcm_ops snd_trident_si7018_capture_ops = { - .open = snd_trident_capture_open, - .close = snd_trident_capture_close, - .ioctl = snd_trident_ioctl, - .hw_params = snd_trident_si7018_capture_hw_params, - .hw_free = snd_trident_si7018_capture_hw_free, - .prepare = snd_trident_si7018_capture_prepare, - .trigger = snd_trident_trigger, - .pointer = snd_trident_playback_pointer, -}; - -static struct snd_pcm_ops snd_trident_foldback_ops = { - .open = snd_trident_foldback_open, - .close = snd_trident_foldback_close, - .ioctl = snd_trident_ioctl, - .hw_params = snd_trident_hw_params, - .hw_free = snd_trident_hw_free, - .prepare = snd_trident_foldback_prepare, - .trigger = snd_trident_trigger, - .pointer = snd_trident_playback_pointer, -}; - -static struct snd_pcm_ops snd_trident_nx_foldback_ops = { - .open = snd_trident_foldback_open, - .close = snd_trident_foldback_close, - .ioctl = snd_trident_ioctl, - .hw_params = snd_trident_hw_params, - .hw_free = snd_trident_hw_free, - .prepare = snd_trident_foldback_prepare, - .trigger = snd_trident_trigger, - .pointer = snd_trident_playback_pointer, - .page = snd_pcm_sgbuf_ops_page, -}; - -static struct snd_pcm_ops snd_trident_spdif_ops = { - .open = snd_trident_spdif_open, - .close = snd_trident_spdif_close, - .ioctl = snd_trident_ioctl, - .hw_params = snd_trident_spdif_hw_params, - .hw_free = snd_trident_hw_free, - .prepare = snd_trident_spdif_prepare, - .trigger = snd_trident_trigger, - .pointer = snd_trident_spdif_pointer, -}; - -static struct snd_pcm_ops snd_trident_spdif_7018_ops = { - .open = snd_trident_spdif_open, - .close = snd_trident_spdif_close, - .ioctl = snd_trident_ioctl, - .hw_params = snd_trident_spdif_hw_params, - .hw_free = snd_trident_hw_free, - .prepare = snd_trident_spdif_prepare, - .trigger = snd_trident_trigger, - .pointer = snd_trident_playback_pointer, -}; - -/*--------------------------------------------------------------------------- - snd_trident_pcm - - Description: This routine registers the 4DWave device for PCM support. - - Parameters: trident - pointer to target device class for 4DWave. - - Returns: None - - ---------------------------------------------------------------------------*/ - -int __devinit snd_trident_pcm(struct snd_trident * trident, - int device, struct snd_pcm ** rpcm) -{ - struct snd_pcm *pcm; - int err; - - if (rpcm) - *rpcm = NULL; - if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0) - return err; - - pcm->private_data = trident; - - if (trident->tlb.entries) { - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops); - } else { - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_playback_ops); - } - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, - trident->device != TRIDENT_DEVICE_ID_SI7018 ? - &snd_trident_capture_ops : - &snd_trident_si7018_capture_ops); - - pcm->info_flags = 0; - pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX; - strcpy(pcm->name, "Trident 4DWave"); - trident->pcm = pcm; - - if (trident->tlb.entries) { - struct snd_pcm_substream *substream; - for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) - snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG, - snd_dma_pci_data(trident->pci), - 64*1024, 128*1024); - snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, - SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), - 64*1024, 128*1024); - } else { - snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(trident->pci), 64*1024, 128*1024); - } - - if (rpcm) - *rpcm = pcm; - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_foldback_pcm - - Description: This routine registers the 4DWave device for foldback PCM support. - - Parameters: trident - pointer to target device class for 4DWave. - - Returns: None - - ---------------------------------------------------------------------------*/ - -int __devinit snd_trident_foldback_pcm(struct snd_trident * trident, - int device, struct snd_pcm ** rpcm) -{ - struct snd_pcm *foldback; - int err; - int num_chan = 3; - struct snd_pcm_substream *substream; - - if (rpcm) - *rpcm = NULL; - if (trident->device == TRIDENT_DEVICE_ID_NX) - num_chan = 4; - if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0) - return err; - - foldback->private_data = trident; - if (trident->tlb.entries) - snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops); - else - snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_foldback_ops); - foldback->info_flags = 0; - strcpy(foldback->name, "Trident 4DWave"); - substream = foldback->streams[SNDRV_PCM_STREAM_CAPTURE].substream; - strcpy(substream->name, "Front Mixer"); - substream = substream->next; - strcpy(substream->name, "Reverb Mixer"); - substream = substream->next; - strcpy(substream->name, "Chorus Mixer"); - if (num_chan == 4) { - substream = substream->next; - strcpy(substream->name, "Second AC'97 ADC"); - } - trident->foldback = foldback; - - if (trident->tlb.entries) - snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV_SG, - snd_dma_pci_data(trident->pci), 0, 128*1024); - else - snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(trident->pci), 64*1024, 128*1024); - - if (rpcm) - *rpcm = foldback; - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_spdif - - Description: This routine registers the 4DWave-NX device for SPDIF support. - - Parameters: trident - pointer to target device class for 4DWave-NX. - - Returns: None - - ---------------------------------------------------------------------------*/ - -int __devinit snd_trident_spdif_pcm(struct snd_trident * trident, - int device, struct snd_pcm ** rpcm) -{ - struct snd_pcm *spdif; - int err; - - if (rpcm) - *rpcm = NULL; - if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0) - return err; - - spdif->private_data = trident; - if (trident->device != TRIDENT_DEVICE_ID_SI7018) { - snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops); - } else { - snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_7018_ops); - } - spdif->info_flags = 0; - strcpy(spdif->name, "Trident 4DWave IEC958"); - trident->spdif = spdif; - - snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024); - - if (rpcm) - *rpcm = spdif; - return 0; -} - -/* - * Mixer part - */ - - -/*--------------------------------------------------------------------------- - snd_trident_spdif_control - - Description: enable/disable S/PDIF out from ac97 mixer - ---------------------------------------------------------------------------*/ - -#define snd_trident_spdif_control_info snd_ctl_boolean_mono_info - -static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - unsigned char val; - - spin_lock_irq(&trident->reg_lock); - val = trident->spdif_ctrl; - ucontrol->value.integer.value[0] = val == kcontrol->private_value; - spin_unlock_irq(&trident->reg_lock); - return 0; -} - -static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - unsigned char val; - int change; - - val = ucontrol->value.integer.value[0] ? (unsigned char) kcontrol->private_value : 0x00; - spin_lock_irq(&trident->reg_lock); - /* S/PDIF C Channel bits 0-31 : 48khz, SCMS disabled */ - change = trident->spdif_ctrl != val; - trident->spdif_ctrl = val; - if (trident->device != TRIDENT_DEVICE_ID_SI7018) { - if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) { - outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); - outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); - } - } else { - if (trident->spdif == NULL) { - unsigned int temp; - outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); - temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN; - if (val) - temp |= SPDIF_EN; - outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - } - } - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), - .info = snd_trident_spdif_control_info, - .get = snd_trident_spdif_control_get, - .put = snd_trident_spdif_control_put, - .private_value = 0x28, -}; - -/*--------------------------------------------------------------------------- - snd_trident_spdif_default - - Description: put/get the S/PDIF default settings - ---------------------------------------------------------------------------*/ - -static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; - uinfo->count = 1; - return 0; -} - -static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - - spin_lock_irq(&trident->reg_lock); - ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff; - ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff; - ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff; - ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff; - spin_unlock_irq(&trident->reg_lock); - return 0; -} - -static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - unsigned int val; - int change; - - val = (ucontrol->value.iec958.status[0] << 0) | - (ucontrol->value.iec958.status[1] << 8) | - (ucontrol->value.iec958.status[2] << 16) | - (ucontrol->value.iec958.status[3] << 24); - spin_lock_irq(&trident->reg_lock); - change = trident->spdif_bits != val; - trident->spdif_bits = val; - if (trident->device != TRIDENT_DEVICE_ID_SI7018) { - if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) - outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); - } else { - if (trident->spdif == NULL) - outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); - } - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), - .info = snd_trident_spdif_default_info, - .get = snd_trident_spdif_default_get, - .put = snd_trident_spdif_default_put -}; - -/*--------------------------------------------------------------------------- - snd_trident_spdif_mask - - Description: put/get the S/PDIF mask - ---------------------------------------------------------------------------*/ - -static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; - uinfo->count = 1; - return 0; -} - -static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - ucontrol->value.iec958.status[0] = 0xff; - ucontrol->value.iec958.status[1] = 0xff; - ucontrol->value.iec958.status[2] = 0xff; - ucontrol->value.iec958.status[3] = 0xff; - return 0; -} - -static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata = -{ - .access = SNDRV_CTL_ELEM_ACCESS_READ, - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), - .info = snd_trident_spdif_mask_info, - .get = snd_trident_spdif_mask_get, -}; - -/*--------------------------------------------------------------------------- - snd_trident_spdif_stream - - Description: put/get the S/PDIF stream settings - ---------------------------------------------------------------------------*/ - -static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; - uinfo->count = 1; - return 0; -} - -static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - - spin_lock_irq(&trident->reg_lock); - ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff; - ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff; - ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff; - ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff; - spin_unlock_irq(&trident->reg_lock); - return 0; -} - -static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - unsigned int val; - int change; - - val = (ucontrol->value.iec958.status[0] << 0) | - (ucontrol->value.iec958.status[1] << 8) | - (ucontrol->value.iec958.status[2] << 16) | - (ucontrol->value.iec958.status[3] << 24); - spin_lock_irq(&trident->reg_lock); - change = trident->spdif_pcm_bits != val; - trident->spdif_pcm_bits = val; - if (trident->spdif != NULL) { - if (trident->device != TRIDENT_DEVICE_ID_SI7018) { - outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS)); - } else { - outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); - } - } - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata = -{ - .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM), - .info = snd_trident_spdif_stream_info, - .get = snd_trident_spdif_stream_get, - .put = snd_trident_spdif_stream_put -}; - -/*--------------------------------------------------------------------------- - snd_trident_ac97_control - - Description: enable/disable rear path for ac97 - ---------------------------------------------------------------------------*/ - -#define snd_trident_ac97_control_info snd_ctl_boolean_mono_info - -static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - unsigned char val; - - spin_lock_irq(&trident->reg_lock); - val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); - ucontrol->value.integer.value[0] = (val & (1 << kcontrol->private_value)) ? 1 : 0; - spin_unlock_irq(&trident->reg_lock); - return 0; -} - -static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - unsigned char val; - int change = 0; - - spin_lock_irq(&trident->reg_lock); - val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); - val &= ~(1 << kcontrol->private_value); - if (ucontrol->value.integer.value[0]) - val |= 1 << kcontrol->private_value; - change = val != trident->ac97_ctrl; - trident->ac97_ctrl = val; - outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Rear Path", - .info = snd_trident_ac97_control_info, - .get = snd_trident_ac97_control_get, - .put = snd_trident_ac97_control_put, - .private_value = 4, -}; - -/*--------------------------------------------------------------------------- - snd_trident_vol_control - - Description: wave & music volume control - ---------------------------------------------------------------------------*/ - -static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - uinfo->count = 2; - uinfo->value.integer.min = 0; - uinfo->value.integer.max = 255; - return 0; -} - -static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - unsigned int val; - - val = trident->musicvol_wavevol; - ucontrol->value.integer.value[0] = 255 - ((val >> kcontrol->private_value) & 0xff); - ucontrol->value.integer.value[1] = 255 - ((val >> (kcontrol->private_value + 8)) & 0xff); - return 0; -} - -static const DECLARE_TLV_DB_SCALE(db_scale_gvol, -6375, 25, 0); - -static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - unsigned int val; - int change = 0; - - spin_lock_irq(&trident->reg_lock); - val = trident->musicvol_wavevol; - val &= ~(0xffff << kcontrol->private_value); - val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) | - ((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value; - change = val != trident->musicvol_wavevol; - outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Music Playback Volume", - .info = snd_trident_vol_control_info, - .get = snd_trident_vol_control_get, - .put = snd_trident_vol_control_put, - .private_value = 16, - .tlv = { .p = db_scale_gvol }, -}; - -static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Wave Playback Volume", - .info = snd_trident_vol_control_info, - .get = snd_trident_vol_control_get, - .put = snd_trident_vol_control_put, - .private_value = 0, - .tlv = { .p = db_scale_gvol }, -}; - -/*--------------------------------------------------------------------------- - snd_trident_pcm_vol_control - - Description: PCM front volume control - ---------------------------------------------------------------------------*/ - -static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - - uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - uinfo->count = 1; - uinfo->value.integer.min = 0; - uinfo->value.integer.max = 255; - if (trident->device == TRIDENT_DEVICE_ID_SI7018) - uinfo->value.integer.max = 1023; - return 0; -} - -static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; - - if (trident->device == TRIDENT_DEVICE_ID_SI7018) { - ucontrol->value.integer.value[0] = 1023 - mix->vol; - } else { - ucontrol->value.integer.value[0] = 255 - (mix->vol>>2); - } - return 0; -} - -static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; - unsigned int val; - int change = 0; - - if (trident->device == TRIDENT_DEVICE_ID_SI7018) { - val = 1023 - (ucontrol->value.integer.value[0] & 1023); - } else { - val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2; - } - spin_lock_irq(&trident->reg_lock); - change = val != mix->vol; - mix->vol = val; - if (mix->voice != NULL) - snd_trident_write_vol_reg(trident, mix->voice, val); - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "PCM Front Playback Volume", - .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, - .count = 32, - .info = snd_trident_pcm_vol_control_info, - .get = snd_trident_pcm_vol_control_get, - .put = snd_trident_pcm_vol_control_put, - /* FIXME: no tlv yet */ -}; - -/*--------------------------------------------------------------------------- - snd_trident_pcm_pan_control - - Description: PCM front pan control - ---------------------------------------------------------------------------*/ - -static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - uinfo->count = 1; - uinfo->value.integer.min = 0; - uinfo->value.integer.max = 127; - return 0; -} - -static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; - - ucontrol->value.integer.value[0] = mix->pan; - if (ucontrol->value.integer.value[0] & 0x40) { - ucontrol->value.integer.value[0] = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)); - } else { - ucontrol->value.integer.value[0] |= 0x40; - } - return 0; -} - -static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; - unsigned char val; - int change = 0; - - if (ucontrol->value.integer.value[0] & 0x40) - val = ucontrol->value.integer.value[0] & 0x3f; - else - val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40; - spin_lock_irq(&trident->reg_lock); - change = val != mix->pan; - mix->pan = val; - if (mix->voice != NULL) - snd_trident_write_pan_reg(trident, mix->voice, val); - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "PCM Pan Playback Control", - .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, - .count = 32, - .info = snd_trident_pcm_pan_control_info, - .get = snd_trident_pcm_pan_control_get, - .put = snd_trident_pcm_pan_control_put, -}; - -/*--------------------------------------------------------------------------- - snd_trident_pcm_rvol_control - - Description: PCM reverb volume control - ---------------------------------------------------------------------------*/ - -static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - uinfo->count = 1; - uinfo->value.integer.min = 0; - uinfo->value.integer.max = 127; - return 0; -} - -static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; - - ucontrol->value.integer.value[0] = 127 - mix->rvol; - return 0; -} - -static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; - unsigned short val; - int change = 0; - - val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f); - spin_lock_irq(&trident->reg_lock); - change = val != mix->rvol; - mix->rvol = val; - if (mix->voice != NULL) - snd_trident_write_rvol_reg(trident, mix->voice, val); - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static const DECLARE_TLV_DB_SCALE(db_scale_crvol, -3175, 25, 1); - -static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "PCM Reverb Playback Volume", - .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, - .count = 32, - .info = snd_trident_pcm_rvol_control_info, - .get = snd_trident_pcm_rvol_control_get, - .put = snd_trident_pcm_rvol_control_put, - .tlv = { .p = db_scale_crvol }, -}; - -/*--------------------------------------------------------------------------- - snd_trident_pcm_cvol_control - - Description: PCM chorus volume control - ---------------------------------------------------------------------------*/ - -static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - uinfo->count = 1; - uinfo->value.integer.min = 0; - uinfo->value.integer.max = 127; - return 0; -} - -static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; - - ucontrol->value.integer.value[0] = 127 - mix->cvol; - return 0; -} - -static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; - unsigned short val; - int change = 0; - - val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f); - spin_lock_irq(&trident->reg_lock); - change = val != mix->cvol; - mix->cvol = val; - if (mix->voice != NULL) - snd_trident_write_cvol_reg(trident, mix->voice, val); - spin_unlock_irq(&trident->reg_lock); - return change; -} - -static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "PCM Chorus Playback Volume", - .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, - .count = 32, - .info = snd_trident_pcm_cvol_control_info, - .get = snd_trident_pcm_cvol_control_get, - .put = snd_trident_pcm_cvol_control_put, - .tlv = { .p = db_scale_crvol }, -}; - -static void snd_trident_notify_pcm_change1(struct snd_card *card, - struct snd_kcontrol *kctl, - int num, int activate) -{ - struct snd_ctl_elem_id id; - - if (! kctl) - return; - if (activate) - kctl->vd[num].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; - else - kctl->vd[num].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; - snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE | - SNDRV_CTL_EVENT_MASK_INFO, - snd_ctl_build_ioff(&id, kctl, num)); -} - -static void snd_trident_notify_pcm_change(struct snd_trident *trident, - struct snd_trident_pcm_mixer *tmix, - int num, int activate) -{ - snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate); - snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate); - snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate); - snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate); -} - -static int snd_trident_pcm_mixer_build(struct snd_trident *trident, - struct snd_trident_voice *voice, - struct snd_pcm_substream *substream) -{ - struct snd_trident_pcm_mixer *tmix; - - if (snd_BUG_ON(!trident || !voice || !substream)) - return -EINVAL; - tmix = &trident->pcm_mixer[substream->number]; - tmix->voice = voice; - tmix->vol = T4D_DEFAULT_PCM_VOL; - tmix->pan = T4D_DEFAULT_PCM_PAN; - tmix->rvol = T4D_DEFAULT_PCM_RVOL; - tmix->cvol = T4D_DEFAULT_PCM_CVOL; - snd_trident_notify_pcm_change(trident, tmix, substream->number, 1); - return 0; -} - -static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream) -{ - struct snd_trident_pcm_mixer *tmix; - - if (snd_BUG_ON(!trident || !substream)) - return -EINVAL; - tmix = &trident->pcm_mixer[substream->number]; - tmix->voice = NULL; - snd_trident_notify_pcm_change(trident, tmix, substream->number, 0); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_mixer - - Description: This routine registers the 4DWave device for mixer support. - - Parameters: trident - pointer to target device class for 4DWave. - - Returns: None - - ---------------------------------------------------------------------------*/ - -static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device) -{ - struct snd_ac97_template _ac97; - struct snd_card *card = trident->card; - struct snd_kcontrol *kctl; - struct snd_ctl_elem_value *uctl; - int idx, err, retries = 2; - static struct snd_ac97_bus_ops ops = { - .write = snd_trident_codec_write, - .read = snd_trident_codec_read, - }; - - uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); - if (!uctl) - return -ENOMEM; - - if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0) - goto __out; - - memset(&_ac97, 0, sizeof(_ac97)); - _ac97.private_data = trident; - trident->ac97_detect = 1; - - __again: - if ((err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97)) < 0) { - if (trident->device == TRIDENT_DEVICE_ID_SI7018) { - if ((err = snd_trident_sis_reset(trident)) < 0) - goto __out; - if (retries-- > 0) - goto __again; - err = -EIO; - } - goto __out; - } - - /* secondary codec? */ - if (trident->device == TRIDENT_DEVICE_ID_SI7018 && - (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) { - _ac97.num = 1; - err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec); - if (err < 0) - snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n"); -#if 0 // only for my testing purpose --jk - { - struct snd_ac97 *mc97; - err = snd_ac97_modem(trident->card, &_ac97, &mc97); - if (err < 0) - snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err); - } -#endif - } - - trident->ac97_detect = 0; - - if (trident->device != TRIDENT_DEVICE_ID_SI7018) { - if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident))) < 0) - goto __out; - kctl->put(kctl, uctl); - if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident))) < 0) - goto __out; - kctl->put(kctl, uctl); - outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); - } else { - outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); - } - - for (idx = 0; idx < 32; idx++) { - struct snd_trident_pcm_mixer *tmix; - - tmix = &trident->pcm_mixer[idx]; - tmix->voice = NULL; - } - if ((trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident)) == NULL) - goto __nomem; - if ((err = snd_ctl_add(card, trident->ctl_vol))) - goto __out; - - if ((trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident)) == NULL) - goto __nomem; - if ((err = snd_ctl_add(card, trident->ctl_pan))) - goto __out; - - if ((trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident)) == NULL) - goto __nomem; - if ((err = snd_ctl_add(card, trident->ctl_rvol))) - goto __out; - - if ((trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident)) == NULL) - goto __nomem; - if ((err = snd_ctl_add(card, trident->ctl_cvol))) - goto __out; - - if (trident->device == TRIDENT_DEVICE_ID_NX) { - if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident))) < 0) - goto __out; - kctl->put(kctl, uctl); - } - if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) { - - kctl = snd_ctl_new1(&snd_trident_spdif_control, trident); - if (kctl == NULL) { - err = -ENOMEM; - goto __out; - } - if (trident->ac97->ext_id & AC97_EI_SPDIF) - kctl->id.index++; - if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF)) - kctl->id.index++; - idx = kctl->id.index; - if ((err = snd_ctl_add(card, kctl)) < 0) - goto __out; - kctl->put(kctl, uctl); - - kctl = snd_ctl_new1(&snd_trident_spdif_default, trident); - if (kctl == NULL) { - err = -ENOMEM; - goto __out; - } - kctl->id.index = idx; - kctl->id.device = pcm_spdif_device; - if ((err = snd_ctl_add(card, kctl)) < 0) - goto __out; - - kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident); - if (kctl == NULL) { - err = -ENOMEM; - goto __out; - } - kctl->id.index = idx; - kctl->id.device = pcm_spdif_device; - if ((err = snd_ctl_add(card, kctl)) < 0) - goto __out; - - kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident); - if (kctl == NULL) { - err = -ENOMEM; - goto __out; - } - kctl->id.index = idx; - kctl->id.device = pcm_spdif_device; - if ((err = snd_ctl_add(card, kctl)) < 0) - goto __out; - trident->spdif_pcm_ctl = kctl; - } - - err = 0; - goto __out; - - __nomem: - err = -ENOMEM; - - __out: - kfree(uctl); - - return err; -} - -/* - * gameport interface - */ - -#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE)) - -static unsigned char snd_trident_gameport_read(struct gameport *gameport) -{ - struct snd_trident *chip = gameport_get_port_data(gameport); - - if (snd_BUG_ON(!chip)) - return 0; - return inb(TRID_REG(chip, GAMEPORT_LEGACY)); -} - -static void snd_trident_gameport_trigger(struct gameport *gameport) -{ - struct snd_trident *chip = gameport_get_port_data(gameport); - - if (snd_BUG_ON(!chip)) - return; - outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY)); -} - -static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons) -{ - struct snd_trident *chip = gameport_get_port_data(gameport); - int i; - - if (snd_BUG_ON(!chip)) - return 0; - - *buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf; - - for (i = 0; i < 4; i++) { - axes[i] = inw(TRID_REG(chip, GAMEPORT_AXES + i * 2)); - if (axes[i] == 0xffff) axes[i] = -1; - } - - return 0; -} - -static int snd_trident_gameport_open(struct gameport *gameport, int mode) -{ - struct snd_trident *chip = gameport_get_port_data(gameport); - - if (snd_BUG_ON(!chip)) - return 0; - - switch (mode) { - case GAMEPORT_MODE_COOKED: - outb(GAMEPORT_MODE_ADC, TRID_REG(chip, GAMEPORT_GCR)); - msleep(20); - return 0; - case GAMEPORT_MODE_RAW: - outb(0, TRID_REG(chip, GAMEPORT_GCR)); - return 0; - default: - return -1; - } -} - -int __devinit snd_trident_create_gameport(struct snd_trident *chip) -{ - struct gameport *gp; - - chip->gameport = gp = gameport_allocate_port(); - if (!gp) { - printk(KERN_ERR "trident: cannot allocate memory for gameport\n"); - return -ENOMEM; - } - - gameport_set_name(gp, "Trident 4DWave"); - gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); - gameport_set_dev_parent(gp, &chip->pci->dev); - - gameport_set_port_data(gp, chip); - gp->fuzz = 64; - gp->read = snd_trident_gameport_read; - gp->trigger = snd_trident_gameport_trigger; - gp->cooked_read = snd_trident_gameport_cooked_read; - gp->open = snd_trident_gameport_open; - - gameport_register_port(gp); - - return 0; -} - -static inline void snd_trident_free_gameport(struct snd_trident *chip) -{ - if (chip->gameport) { - gameport_unregister_port(chip->gameport); - chip->gameport = NULL; - } -} -#else -int __devinit snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; } -static inline void snd_trident_free_gameport(struct snd_trident *chip) { } -#endif /* CONFIG_GAMEPORT */ - -/* - * delay for 1 tick - */ -static inline void do_delay(struct snd_trident *chip) -{ - schedule_timeout_uninterruptible(1); -} - -/* - * SiS reset routine - */ - -static int snd_trident_sis_reset(struct snd_trident *trident) -{ - unsigned long end_time; - unsigned int i; - int r; - - r = trident->in_suspend ? 0 : 2; /* count of retries */ - __si7018_retry: - pci_write_config_byte(trident->pci, 0x46, 0x04); /* SOFTWARE RESET */ - udelay(100); - pci_write_config_byte(trident->pci, 0x46, 0x00); - udelay(100); - /* disable AC97 GPIO interrupt */ - outb(0x00, TRID_REG(trident, SI_AC97_GPIO)); - /* initialize serial interface, force cold reset */ - i = PCMOUT|SURROUT|CENTEROUT|LFEOUT|SECONDARY_ID|COLD_RESET; - outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - udelay(1000); - /* remove cold reset */ - i &= ~COLD_RESET; - outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - udelay(2000); - /* wait, until the codec is ready */ - end_time = (jiffies + (HZ * 3) / 4) + 1; - do { - if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) - goto __si7018_ok; - do_delay(trident); - } while (time_after_eq(end_time, jiffies)); - snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL))); - if (r-- > 0) { - end_time = jiffies + HZ; - do { - do_delay(trident); - } while (time_after_eq(end_time, jiffies)); - goto __si7018_retry; - } - __si7018_ok: - /* wait for the second codec */ - do { - if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0) - break; - do_delay(trident); - } while (time_after_eq(end_time, jiffies)); - /* enable 64 channel mode */ - outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR)); - return 0; -} - -/* - * /proc interface - */ - -static void snd_trident_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) -{ - struct snd_trident *trident = entry->private_data; - char *s; - - switch (trident->device) { - case TRIDENT_DEVICE_ID_SI7018: - s = "SiS 7018 Audio"; - break; - case TRIDENT_DEVICE_ID_DX: - s = "Trident 4DWave PCI DX"; - break; - case TRIDENT_DEVICE_ID_NX: - s = "Trident 4DWave PCI NX"; - break; - default: - s = "???"; - } - snd_iprintf(buffer, "%s\n\n", s); - snd_iprintf(buffer, "Spurious IRQs : %d\n", trident->spurious_irq_count); - snd_iprintf(buffer, "Spurious IRQ dlta: %d\n", trident->spurious_irq_max_delta); - if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) - snd_iprintf(buffer, "IEC958 Mixer Out : %s\n", trident->spdif_ctrl == 0x28 ? "on" : "off"); - if (trident->device == TRIDENT_DEVICE_ID_NX) { - snd_iprintf(buffer, "Rear Speakers : %s\n", trident->ac97_ctrl & 0x00000010 ? "on" : "off"); - if (trident->tlb.entries) { - snd_iprintf(buffer,"\nVirtual Memory\n"); - snd_iprintf(buffer, "Memory Maximum : %d\n", trident->tlb.memhdr->size); - snd_iprintf(buffer, "Memory Used : %d\n", trident->tlb.memhdr->used); - snd_iprintf(buffer, "Memory Free : %d\n", snd_util_mem_avail(trident->tlb.memhdr)); - } - } -} - -static void __devinit snd_trident_proc_init(struct snd_trident * trident) -{ - struct snd_info_entry *entry; - const char *s = "trident"; - - if (trident->device == TRIDENT_DEVICE_ID_SI7018) - s = "sis7018"; - if (! snd_card_proc_new(trident->card, s, &entry)) - snd_info_set_text_ops(entry, trident, snd_trident_proc_read); -} - -static int snd_trident_dev_free(struct snd_device *device) -{ - struct snd_trident *trident = device->device_data; - return snd_trident_free(trident); -} - -/*--------------------------------------------------------------------------- - snd_trident_tlb_alloc - - Description: Allocate and set up the TLB page table on 4D NX. - Each entry has 4 bytes (physical PCI address). - - Parameters: trident - pointer to target device class for 4DWave. - - Returns: 0 or negative error code - - ---------------------------------------------------------------------------*/ - -static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident) -{ - int i; - - /* TLB array must be aligned to 16kB !!! so we allocate - 32kB region and correct offset when necessary */ - - if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), - 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) { - snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n"); - return -ENOMEM; - } - trident->tlb.entries = (unsigned int*)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4); - trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4); - /* allocate shadow TLB page table (virtual addresses) */ - trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long)); - if (trident->tlb.shadow_entries == NULL) { - snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n"); - return -ENOMEM; - } - /* allocate and setup silent page and initialise TLB entries */ - if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), - SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) { - snd_printk(KERN_ERR "trident: unable to allocate silent page\n"); - return -ENOMEM; - } - memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE); - for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++) { - trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1)); - trident->tlb.shadow_entries[i] = (unsigned long)trident->tlb.silent_page.area; - } - - /* use emu memory block manager code to manage tlb page allocation */ - trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES); - if (trident->tlb.memhdr == NULL) - return -ENOMEM; - - trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg); - return 0; -} - -/* - * initialize 4D DX chip - */ - -static void snd_trident_stop_all_voices(struct snd_trident *trident) -{ - outl(0xffffffff, TRID_REG(trident, T4D_STOP_A)); - outl(0xffffffff, TRID_REG(trident, T4D_STOP_B)); - outl(0, TRID_REG(trident, T4D_AINTEN_A)); - outl(0, TRID_REG(trident, T4D_AINTEN_B)); -} - -static int snd_trident_4d_dx_init(struct snd_trident *trident) -{ - struct pci_dev *pci = trident->pci; - unsigned long end_time; - - /* reset the legacy configuration and whole audio/wavetable block */ - pci_write_config_dword(pci, 0x40, 0); /* DDMA */ - pci_write_config_byte(pci, 0x44, 0); /* ports */ - pci_write_config_byte(pci, 0x45, 0); /* Legacy DMA */ - pci_write_config_byte(pci, 0x46, 4); /* reset */ - udelay(100); - pci_write_config_byte(pci, 0x46, 0); /* release reset */ - udelay(100); - - /* warm reset of the AC'97 codec */ - outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); - udelay(100); - outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); - /* DAC on, disable SB IRQ and try to force ADC valid signal */ - trident->ac97_ctrl = 0x0000004a; - outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT)); - /* wait, until the codec is ready */ - end_time = (jiffies + (HZ * 3) / 4) + 1; - do { - if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0) - goto __dx_ok; - do_delay(trident); - } while (time_after_eq(end_time, jiffies)); - snd_printk(KERN_ERR "AC'97 codec ready error\n"); - return -EIO; - - __dx_ok: - snd_trident_stop_all_voices(trident); - - return 0; -} - -/* - * initialize 4D NX chip - */ -static int snd_trident_4d_nx_init(struct snd_trident *trident) -{ - struct pci_dev *pci = trident->pci; - unsigned long end_time; - - /* reset the legacy configuration and whole audio/wavetable block */ - pci_write_config_dword(pci, 0x40, 0); /* DDMA */ - pci_write_config_byte(pci, 0x44, 0); /* ports */ - pci_write_config_byte(pci, 0x45, 0); /* Legacy DMA */ - - pci_write_config_byte(pci, 0x46, 1); /* reset */ - udelay(100); - pci_write_config_byte(pci, 0x46, 0); /* release reset */ - udelay(100); - - /* warm reset of the AC'97 codec */ - outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); - udelay(100); - outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); - /* wait, until the codec is ready */ - end_time = (jiffies + (HZ * 3) / 4) + 1; - do { - if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0) - goto __nx_ok; - do_delay(trident); - } while (time_after_eq(end_time, jiffies)); - snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT))); - return -EIO; - - __nx_ok: - /* DAC on */ - trident->ac97_ctrl = 0x00000002; - outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT)); - /* disable SB IRQ */ - outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT)); - - snd_trident_stop_all_voices(trident); - - if (trident->tlb.entries != NULL) { - unsigned int i; - /* enable virtual addressing via TLB */ - i = trident->tlb.entries_dmaaddr; - i |= 0x00000001; - outl(i, TRID_REG(trident, NX_TLBC)); - } else { - outl(0, TRID_REG(trident, NX_TLBC)); - } - /* initialize S/PDIF */ - outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS)); - outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); - - return 0; -} - -/* - * initialize sis7018 chip - */ -static int snd_trident_sis_init(struct snd_trident *trident) -{ - int err; - - if ((err = snd_trident_sis_reset(trident)) < 0) - return err; - - snd_trident_stop_all_voices(trident); - - /* initialize S/PDIF */ - outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS)); - - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_create - - Description: This routine will create the device specific class for - the 4DWave card. It will also perform basic initialization. - - Parameters: card - which card to create - pci - interface to PCI bus resource info - dma1ptr - playback dma buffer - dma2ptr - capture dma buffer - irqptr - interrupt resource info - - Returns: 4DWave device class private data - - ---------------------------------------------------------------------------*/ - -int __devinit snd_trident_create(struct snd_card *card, - struct pci_dev *pci, - int pcm_streams, - int pcm_spdif_device, - int max_wavetable_size, - struct snd_trident ** rtrident) -{ - struct snd_trident *trident; - int i, err; - struct snd_trident_voice *voice; - struct snd_trident_pcm_mixer *tmix; - static struct snd_device_ops ops = { - .dev_free = snd_trident_dev_free, - }; - - *rtrident = NULL; - - /* enable PCI device */ - if ((err = pci_enable_device(pci)) < 0) - return err; - /* check, if we can restrict PCI DMA transfers to 30 bits */ - if (pci_set_dma_mask(pci, DMA_BIT_MASK(30)) < 0 || - pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(30)) < 0) { - snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n"); - pci_disable_device(pci); - return -ENXIO; - } - - trident = kzalloc(sizeof(*trident), GFP_KERNEL); - if (trident == NULL) { - pci_disable_device(pci); - return -ENOMEM; - } - trident->device = (pci->vendor << 16) | pci->device; - trident->card = card; - trident->pci = pci; - spin_lock_init(&trident->reg_lock); - spin_lock_init(&trident->event_lock); - spin_lock_init(&trident->voice_alloc); - if (pcm_streams < 1) - pcm_streams = 1; - if (pcm_streams > 32) - pcm_streams = 32; - trident->ChanPCM = pcm_streams; - if (max_wavetable_size < 0 ) - max_wavetable_size = 0; - trident->synth.max_size = max_wavetable_size * 1024; - trident->irq = -1; - - trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE); - pci_set_master(pci); - - if ((err = pci_request_regions(pci, "Trident Audio")) < 0) { - kfree(trident); - pci_disable_device(pci); - return err; - } - trident->port = pci_resource_start(pci, 0); - - if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED, - KBUILD_MODNAME, trident)) { - snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); - snd_trident_free(trident); - return -EBUSY; - } - trident->irq = pci->irq; - - /* allocate 16k-aligned TLB for NX cards */ - trident->tlb.entries = NULL; - trident->tlb.buffer.area = NULL; - if (trident->device == TRIDENT_DEVICE_ID_NX) { - if ((err = snd_trident_tlb_alloc(trident)) < 0) { - snd_trident_free(trident); - return err; - } - } - - trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF; - - /* initialize chip */ - switch (trident->device) { - case TRIDENT_DEVICE_ID_DX: - err = snd_trident_4d_dx_init(trident); - break; - case TRIDENT_DEVICE_ID_NX: - err = snd_trident_4d_nx_init(trident); - break; - case TRIDENT_DEVICE_ID_SI7018: - err = snd_trident_sis_init(trident); - break; - default: - snd_BUG(); - break; - } - if (err < 0) { - snd_trident_free(trident); - return err; - } - - if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) { - snd_trident_free(trident); - return err; - } - - if ((err = snd_trident_mixer(trident, pcm_spdif_device)) < 0) - return err; - - /* initialise synth voices */ - for (i = 0; i < 64; i++) { - voice = &trident->synth.voices[i]; - voice->number = i; - voice->trident = trident; - } - /* initialize pcm mixer entries */ - for (i = 0; i < 32; i++) { - tmix = &trident->pcm_mixer[i]; - tmix->vol = T4D_DEFAULT_PCM_VOL; - tmix->pan = T4D_DEFAULT_PCM_PAN; - tmix->rvol = T4D_DEFAULT_PCM_RVOL; - tmix->cvol = T4D_DEFAULT_PCM_CVOL; - } - - snd_trident_enable_eso(trident); - - snd_trident_proc_init(trident); - snd_card_set_dev(card, &pci->dev); - *rtrident = trident; - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_free - - Description: This routine will free the device specific class for - the 4DWave card. - - Parameters: trident - device specific private data for 4DWave card - - Returns: None. - - ---------------------------------------------------------------------------*/ - -static int snd_trident_free(struct snd_trident *trident) -{ - snd_trident_free_gameport(trident); - snd_trident_disable_eso(trident); - // Disable S/PDIF out - if (trident->device == TRIDENT_DEVICE_ID_NX) - outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3)); - else if (trident->device == TRIDENT_DEVICE_ID_SI7018) { - outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL)); - } - if (trident->irq >= 0) - free_irq(trident->irq, trident); - if (trident->tlb.buffer.area) { - outl(0, TRID_REG(trident, NX_TLBC)); - if (trident->tlb.memhdr) - snd_util_memhdr_free(trident->tlb.memhdr); - if (trident->tlb.silent_page.area) - snd_dma_free_pages(&trident->tlb.silent_page); - vfree(trident->tlb.shadow_entries); - snd_dma_free_pages(&trident->tlb.buffer); - } - pci_release_regions(trident->pci); - pci_disable_device(trident->pci); - kfree(trident); - return 0; -} - -/*--------------------------------------------------------------------------- - snd_trident_interrupt - - Description: ISR for Trident 4DWave device - - Parameters: trident - device specific private data for 4DWave card - - Problems: It seems that Trident chips generates interrupts more than - one time in special cases. The spurious interrupts are - detected via sample timer (T4D_STIMER) and computing - corresponding delta value. The limits are detected with - the method try & fail so it is possible that it won't - work on all computers. [jaroslav] - - Returns: None. - - ---------------------------------------------------------------------------*/ - -static irqreturn_t snd_trident_interrupt(int irq, void *dev_id) -{ - struct snd_trident *trident = dev_id; - unsigned int audio_int, chn_int, stimer, channel, mask, tmp; - int delta; - struct snd_trident_voice *voice; - - audio_int = inl(TRID_REG(trident, T4D_MISCINT)); - if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0) - return IRQ_NONE; - if (audio_int & ADDRESS_IRQ) { - // get interrupt status for all channels - spin_lock(&trident->reg_lock); - stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff; - chn_int = inl(TRID_REG(trident, T4D_AINT_A)); - if (chn_int == 0) - goto __skip1; - outl(chn_int, TRID_REG(trident, T4D_AINT_A)); /* ack */ - __skip1: - chn_int = inl(TRID_REG(trident, T4D_AINT_B)); - if (chn_int == 0) - goto __skip2; - for (channel = 63; channel >= 32; channel--) { - mask = 1 << (channel&0x1f); - if ((chn_int & mask) == 0) - continue; - voice = &trident->synth.voices[channel]; - if (!voice->pcm || voice->substream == NULL) { - outl(mask, TRID_REG(trident, T4D_STOP_B)); - continue; - } - delta = (int)stimer - (int)voice->stimer; - if (delta < 0) - delta = -delta; - if ((unsigned int)delta < voice->spurious_threshold) { - /* do some statistics here */ - trident->spurious_irq_count++; - if (trident->spurious_irq_max_delta < (unsigned int)delta) - trident->spurious_irq_max_delta = delta; - continue; - } - voice->stimer = stimer; - if (voice->isync) { - if (!voice->isync3) { - tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL)); - if (trident->bDMAStart & 0x40) - tmp >>= 1; - if (tmp > 0) - tmp = voice->isync_max - tmp; - } else { - tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff; - } - if (tmp < voice->isync_mark) { - if (tmp > 0x10) - tmp = voice->isync_ESO - 7; - else - tmp = voice->isync_ESO + 2; - /* update ESO for IRQ voice to preserve sync */ - snd_trident_stop_voice(trident, voice->number); - snd_trident_write_eso_reg(trident, voice, tmp); - snd_trident_start_voice(trident, voice->number); - } - } else if (voice->isync2) { - voice->isync2 = 0; - /* write original ESO and update CSO for IRQ voice to preserve sync */ - snd_trident_stop_voice(trident, voice->number); - snd_trident_write_cso_reg(trident, voice, voice->isync_mark); - snd_trident_write_eso_reg(trident, voice, voice->ESO); - snd_trident_start_voice(trident, voice->number); - } -#if 0 - if (voice->extra) { - /* update CSO for extra voice to preserve sync */ - snd_trident_stop_voice(trident, voice->extra->number); - snd_trident_write_cso_reg(trident, voice->extra, 0); - snd_trident_start_voice(trident, voice->extra->number); - } -#endif - spin_unlock(&trident->reg_lock); - snd_pcm_period_elapsed(voice->substream); - spin_lock(&trident->reg_lock); - } - outl(chn_int, TRID_REG(trident, T4D_AINT_B)); /* ack */ - __skip2: - spin_unlock(&trident->reg_lock); - } - if (audio_int & MPU401_IRQ) { - if (trident->rmidi) { - snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data); - } else { - inb(TRID_REG(trident, T4D_MPUR0)); - } - } - // outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT)); - return IRQ_HANDLED; -} - -struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port) -{ - struct snd_trident_voice *pvoice; - unsigned long flags; - int idx; - - spin_lock_irqsave(&trident->voice_alloc, flags); - if (type == SNDRV_TRIDENT_VOICE_TYPE_PCM) { - idx = snd_trident_allocate_pcm_channel(trident); - if(idx < 0) { - spin_unlock_irqrestore(&trident->voice_alloc, flags); - return NULL; - } - pvoice = &trident->synth.voices[idx]; - pvoice->use = 1; - pvoice->pcm = 1; - pvoice->capture = 0; - pvoice->spdif = 0; - pvoice->memblk = NULL; - pvoice->substream = NULL; - spin_unlock_irqrestore(&trident->voice_alloc, flags); - return pvoice; - } - if (type == SNDRV_TRIDENT_VOICE_TYPE_SYNTH) { - idx = snd_trident_allocate_synth_channel(trident); - if(idx < 0) { - spin_unlock_irqrestore(&trident->voice_alloc, flags); - return NULL; - } - pvoice = &trident->synth.voices[idx]; - pvoice->use = 1; - pvoice->synth = 1; - pvoice->client = client; - pvoice->port = port; - pvoice->memblk = NULL; - spin_unlock_irqrestore(&trident->voice_alloc, flags); - return pvoice; - } - if (type == SNDRV_TRIDENT_VOICE_TYPE_MIDI) { - } - spin_unlock_irqrestore(&trident->voice_alloc, flags); - return NULL; -} - -EXPORT_SYMBOL(snd_trident_alloc_voice); - -void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice) -{ - unsigned long flags; - void (*private_free)(struct snd_trident_voice *); - void *private_data; - - if (voice == NULL || !voice->use) - return; - snd_trident_clear_voices(trident, voice->number, voice->number); - spin_lock_irqsave(&trident->voice_alloc, flags); - private_free = voice->private_free; - private_data = voice->private_data; - voice->private_free = NULL; - voice->private_data = NULL; - if (voice->pcm) - snd_trident_free_pcm_channel(trident, voice->number); - if (voice->synth) - snd_trident_free_synth_channel(trident, voice->number); - voice->use = voice->pcm = voice->synth = voice->midi = 0; - voice->capture = voice->spdif = 0; - voice->sample_ops = NULL; - voice->substream = NULL; - voice->extra = NULL; - spin_unlock_irqrestore(&trident->voice_alloc, flags); - if (private_free) - private_free(voice); -} - -EXPORT_SYMBOL(snd_trident_free_voice); - -static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max) -{ - unsigned int i, val, mask[2] = { 0, 0 }; - - if (snd_BUG_ON(v_min > 63 || v_max > 63)) - return; - for (i = v_min; i <= v_max; i++) - mask[i >> 5] |= 1 << (i & 0x1f); - if (mask[0]) { - outl(mask[0], TRID_REG(trident, T4D_STOP_A)); - val = inl(TRID_REG(trident, T4D_AINTEN_A)); - outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A)); - } - if (mask[1]) { - outl(mask[1], TRID_REG(trident, T4D_STOP_B)); - val = inl(TRID_REG(trident, T4D_AINTEN_B)); - outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B)); - } -} - -#ifdef CONFIG_PM -int snd_trident_suspend(struct pci_dev *pci, pm_message_t state) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_trident *trident = card->private_data; - - trident->in_suspend = 1; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(trident->pcm); - snd_pcm_suspend_all(trident->foldback); - snd_pcm_suspend_all(trident->spdif); - - snd_ac97_suspend(trident->ac97); - snd_ac97_suspend(trident->ac97_sec); - - pci_disable_device(pci); - pci_save_state(pci); - pci_set_power_state(pci, pci_choose_state(pci, state)); - return 0; -} - -int snd_trident_resume(struct pci_dev *pci) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_trident *trident = card->private_data; - - pci_set_power_state(pci, PCI_D0); - pci_restore_state(pci); - if (pci_enable_device(pci) < 0) { - printk(KERN_ERR "trident: pci_enable_device failed, " - "disabling device\n"); - snd_card_disconnect(card); - return -EIO; - } - pci_set_master(pci); - - switch (trident->device) { - case TRIDENT_DEVICE_ID_DX: - snd_trident_4d_dx_init(trident); - break; - case TRIDENT_DEVICE_ID_NX: - snd_trident_4d_nx_init(trident); - break; - case TRIDENT_DEVICE_ID_SI7018: - snd_trident_sis_init(trident); - break; - } - - snd_ac97_resume(trident->ac97); - snd_ac97_resume(trident->ac97_sec); - - /* restore some registers */ - outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); - - snd_trident_enable_eso(trident); - - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - trident->in_suspend = 0; - return 0; -} -#endif /* CONFIG_PM */ |