forked from Minki/linux
d81a6d7176
These aren't modules, but they do make use of these macros, so they will need export.h to get that definition. Previously, they got it via the implicit module.h inclusion. Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
3983 lines
122 KiB
C
3983 lines
122 KiB
C
/*
|
|
* 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 */
|