mirror of
https://github.com/torvalds/linux.git
synced 2024-11-22 20:22:09 +00:00
[ALSA] Adds Capture to P16V chip.
EMU10K1/EMU10K2 driver One can select which capture source, but one cannot yet set volumes. Signed-off-by: James Courtier-Dutton <James@superbug.co.uk>
This commit is contained in:
James Courtier-Dutton
Jaroslav Kysela
parent
d05b2817d8
commit
6e4abc40fc
@ -83,7 +83,8 @@
|
||||
#define IPR 0x08 /* Global interrupt pending register */
|
||||
/* Clear pending interrupts by writing a 1 to */
|
||||
/* the relevant bits and zero to the other bits */
|
||||
|
||||
#define IPR_P16V 0x80000000 /* Bit set when the CA0151 P16V chip wishes
|
||||
to interrupt */
|
||||
#define IPR_GPIOMSG 0x20000000 /* GPIO message interrupt (RE'd, still not sure
|
||||
which INTE bits enable it) */
|
||||
|
||||
@ -1109,7 +1110,9 @@ struct _snd_emu10k1 {
|
||||
|
||||
emu10k1_voice_t voices[NUM_G];
|
||||
emu10k1_voice_t p16v_voices[4];
|
||||
emu10k1_voice_t p16v_capture_voice;
|
||||
int p16v_device_offset;
|
||||
u32 p16v_capture_source;
|
||||
emu10k1_pcm_mixer_t pcm_mixer[32];
|
||||
emu10k1_pcm_mixer_t efx_pcm_mixer[NUM_EFX_PLAYBACK];
|
||||
snd_kcontrol_t *ctl_send_routing;
|
||||
|
||||
@ -37,7 +37,7 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
|
||||
int handled = 0;
|
||||
|
||||
while ((status = inl(emu->port + IPR)) != 0) {
|
||||
// printk("irq - status = 0x%x\n", status);
|
||||
//printk("emu10k1 irq - status = 0x%x\n", status);
|
||||
orig_status = status;
|
||||
handled = 1;
|
||||
if (status & IPR_PCIERROR) {
|
||||
@ -147,9 +147,36 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
|
||||
snd_emu10k1_intr_disable(emu, INTE_FXDSPENABLE);
|
||||
status &= ~IPR_FXDSP;
|
||||
}
|
||||
if (status & IPR_P16V) {
|
||||
while ((status2 = inl(emu->port + IPR2)) != 0) {
|
||||
u32 mask = INTE2_PLAYBACK_CH_0_LOOP; /* Full Loop */
|
||||
emu10k1_voice_t *pvoice = &(emu->p16v_voices[0]);
|
||||
emu10k1_voice_t *cvoice = &(emu->p16v_capture_voice);
|
||||
|
||||
//printk(KERN_INFO "status2=0x%x\n", status2);
|
||||
orig_status2 = status2;
|
||||
if(status2 & mask) {
|
||||
if(pvoice->use) {
|
||||
snd_pcm_period_elapsed(pvoice->epcm->substream);
|
||||
} else {
|
||||
snd_printk(KERN_ERR "p16v: status: 0x%08x, mask=0x%08x, pvoice=%p, use=%d\n", status2, mask, pvoice, pvoice->use);
|
||||
}
|
||||
}
|
||||
if(status2 & 0x110000) {
|
||||
//printk(KERN_INFO "capture int found\n");
|
||||
if(cvoice->use) {
|
||||
//printk(KERN_INFO "capture period_elapsed\n");
|
||||
snd_pcm_period_elapsed(cvoice->epcm->substream);
|
||||
}
|
||||
}
|
||||
outl(orig_status2, emu->port + IPR2); /* ack all */
|
||||
}
|
||||
status &= ~IPR_P16V;
|
||||
}
|
||||
|
||||
if (status) {
|
||||
unsigned int bits;
|
||||
//snd_printk(KERN_ERR "emu10k1: unhandled interrupt: 0x%08x\n", status);
|
||||
snd_printk(KERN_ERR "emu10k1: unhandled interrupt: 0x%08x\n", status);
|
||||
//make sure any interrupts we don't handle are disabled:
|
||||
bits = INTE_FXDSPENABLE |
|
||||
INTE_PCIERRORENABLE |
|
||||
@ -170,20 +197,5 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
|
||||
}
|
||||
outl(orig_status, emu->port + IPR); /* ack all */
|
||||
}
|
||||
if (emu->audigy && emu->revision == 4) { /* P16V */
|
||||
while ((status2 = inl(emu->port + IPR2)) != 0) {
|
||||
u32 mask = INTE2_PLAYBACK_CH_0_LOOP; /* Full Loop */
|
||||
emu10k1_voice_t *pvoice = &(emu->p16v_voices[0]);
|
||||
orig_status2 = status2;
|
||||
if(status2 & mask) {
|
||||
if(pvoice->use) {
|
||||
snd_pcm_period_elapsed(pvoice->epcm->substream);
|
||||
} else {
|
||||
snd_printk(KERN_ERR "p16v: status: 0x%08x, mask=0x%08x, pvoice=%p, use=%d\n", status2, mask, pvoice, pvoice->use);
|
||||
}
|
||||
}
|
||||
outl(orig_status2, emu->port + IPR2); /* ack all */
|
||||
}
|
||||
}
|
||||
return IRQ_RETVAL(handled);
|
||||
}
|
||||
|
||||
@ -132,9 +132,29 @@ static snd_pcm_hardware_t snd_p16v_playback_hw = {
|
||||
.fifo_size = 0,
|
||||
};
|
||||
|
||||
static snd_pcm_hardware_t snd_p16v_capture_hw = {
|
||||
.info = (SNDRV_PCM_INFO_MMAP |
|
||||
SNDRV_PCM_INFO_INTERLEAVED |
|
||||
SNDRV_PCM_INFO_BLOCK_TRANSFER |
|
||||
SNDRV_PCM_INFO_MMAP_VALID),
|
||||
.formats = SNDRV_PCM_FMTBIT_S32_LE,
|
||||
.rates = SNDRV_PCM_RATE_48000,
|
||||
.rate_min = 48000,
|
||||
.rate_max = 48000,
|
||||
.channels_min = 2,
|
||||
.channels_max = 2,
|
||||
.buffer_bytes_max = (32*1024),
|
||||
.period_bytes_min = 64,
|
||||
.period_bytes_max = (16*1024),
|
||||
.periods_min = 2,
|
||||
.periods_max = 2,
|
||||
.fifo_size = 0,
|
||||
};
|
||||
|
||||
|
||||
static void snd_p16v_pcm_free_substream(snd_pcm_runtime_t *runtime)
|
||||
{
|
||||
snd_pcm_t *epcm = runtime->private_data;
|
||||
emu10k1_pcm_t *epcm = runtime->private_data;
|
||||
|
||||
if (epcm) {
|
||||
//snd_printk("epcm free: %p\n", epcm);
|
||||
@ -178,15 +198,63 @@ static int snd_p16v_pcm_open_playback_channel(snd_pcm_substream_t *substream, in
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* open_capture callback */
|
||||
static int snd_p16v_pcm_open_capture_channel(snd_pcm_substream_t *substream, int channel_id)
|
||||
{
|
||||
emu10k1_t *emu = snd_pcm_substream_chip(substream);
|
||||
emu10k1_voice_t *channel = &(emu->p16v_capture_voice);
|
||||
emu10k1_pcm_t *epcm;
|
||||
snd_pcm_runtime_t *runtime = substream->runtime;
|
||||
int err;
|
||||
|
||||
epcm = kcalloc(1, sizeof(*epcm), GFP_KERNEL);
|
||||
//snd_printk("epcm kcalloc: %p\n", epcm);
|
||||
|
||||
if (epcm == NULL)
|
||||
return -ENOMEM;
|
||||
epcm->emu = emu;
|
||||
epcm->substream = substream;
|
||||
//snd_printk("epcm device=%d, channel_id=%d\n", substream->pcm->device, channel_id);
|
||||
|
||||
runtime->private_data = epcm;
|
||||
runtime->private_free = snd_p16v_pcm_free_substream;
|
||||
|
||||
runtime->hw = snd_p16v_capture_hw;
|
||||
|
||||
channel->emu = emu;
|
||||
channel->number = channel_id;
|
||||
|
||||
channel->use=1;
|
||||
//snd_printk("p16v: open channel_id=%d, channel=%p, use=0x%x\n", channel_id, channel, channel->use);
|
||||
//printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
|
||||
//channel->interrupt = snd_p16v_pcm_channel_interrupt;
|
||||
channel->epcm=epcm;
|
||||
if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
|
||||
return err;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* close callback */
|
||||
static int snd_p16v_pcm_close_playback(snd_pcm_substream_t *substream)
|
||||
{
|
||||
emu10k1_t *emu = snd_pcm_substream_chip(substream);
|
||||
//snd_pcm_runtime_t *runtime = substream->runtime;
|
||||
//emu10k1_pcm_t *epcm = runtime->private_data;
|
||||
emu->p16v_voices[substream->pcm->device - emu->p16v_device_offset].use=0;
|
||||
/* FIXME: maybe zero others */
|
||||
//emu10k1_pcm_t *epcm = runtime->private_data;
|
||||
emu->p16v_voices[substream->pcm->device - emu->p16v_device_offset].use=0;
|
||||
/* FIXME: maybe zero others */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* close callback */
|
||||
static int snd_p16v_pcm_close_capture(snd_pcm_substream_t *substream)
|
||||
{
|
||||
emu10k1_t *emu = snd_pcm_substream_chip(substream);
|
||||
//snd_pcm_runtime_t *runtime = substream->runtime;
|
||||
//emu10k1_pcm_t *epcm = runtime->private_data;
|
||||
emu->p16v_capture_voice.use=0;
|
||||
/* FIXME: maybe zero others */
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -195,36 +263,55 @@ static int snd_p16v_pcm_open_playback_front(snd_pcm_substream_t *substream)
|
||||
return snd_p16v_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL);
|
||||
}
|
||||
|
||||
static int snd_p16v_pcm_open_capture(snd_pcm_substream_t *substream)
|
||||
{
|
||||
// Only using channel 0 for now, but the card has 2 channels.
|
||||
return snd_p16v_pcm_open_capture_channel(substream, 0);
|
||||
}
|
||||
|
||||
/* hw_params callback */
|
||||
static int snd_p16v_pcm_hw_params_playback(snd_pcm_substream_t *substream,
|
||||
snd_pcm_hw_params_t * hw_params)
|
||||
{
|
||||
int result;
|
||||
//snd_printk("hw_params alloc: substream=%p\n", substream);
|
||||
result = snd_pcm_lib_malloc_pages(substream,
|
||||
params_buffer_bytes(hw_params));
|
||||
//snd_printk("hw_params alloc: result=%d\n", result);
|
||||
//dump_stack();
|
||||
return result;
|
||||
}
|
||||
|
||||
/* hw_params callback */
|
||||
static int snd_p16v_pcm_hw_params_capture(snd_pcm_substream_t *substream,
|
||||
snd_pcm_hw_params_t * hw_params)
|
||||
{
|
||||
int result;
|
||||
result = snd_pcm_lib_malloc_pages(substream,
|
||||
params_buffer_bytes(hw_params));
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* hw_free callback */
|
||||
static int snd_p16v_pcm_hw_free_playback(snd_pcm_substream_t *substream)
|
||||
{
|
||||
int result;
|
||||
//snd_printk("hw_params free: substream=%p\n", substream);
|
||||
result = snd_pcm_lib_free_pages(substream);
|
||||
//snd_printk("hw_params free: result=%d\n", result);
|
||||
//dump_stack();
|
||||
return result;
|
||||
}
|
||||
|
||||
/* hw_free callback */
|
||||
static int snd_p16v_pcm_hw_free_capture(snd_pcm_substream_t *substream)
|
||||
{
|
||||
int result;
|
||||
result = snd_pcm_lib_free_pages(substream);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* prepare playback callback */
|
||||
static int snd_p16v_pcm_prepare_playback(snd_pcm_substream_t *substream)
|
||||
{
|
||||
emu10k1_t *emu = snd_pcm_substream_chip(substream);
|
||||
snd_pcm_runtime_t *runtime = substream->runtime;
|
||||
//emu10k1_pcm_t *epcm = runtime->private_data;
|
||||
int channel = substream->pcm->device - emu->p16v_device_offset;
|
||||
u32 *table_base = (u32 *)(emu->p16v_buffer.area+(8*16*channel));
|
||||
u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
|
||||
@ -253,7 +340,7 @@ static int snd_p16v_pcm_prepare_playback(snd_pcm_substream_t *substream)
|
||||
break;
|
||||
}
|
||||
/* FIXME: Check emu->buffer.size before actually writing to it. */
|
||||
for(i=0; i < runtime->periods; i++) {
|
||||
for(i=0; i < runtime->periods; i++) {
|
||||
table_base[i*2]=runtime->dma_addr+(i*period_size_bytes);
|
||||
table_base[(i*2)+1]=period_size_bytes<<16;
|
||||
}
|
||||
@ -270,6 +357,23 @@ static int snd_p16v_pcm_prepare_playback(snd_pcm_substream_t *substream)
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* prepare capture callback */
|
||||
static int snd_p16v_pcm_prepare_capture(snd_pcm_substream_t *substream)
|
||||
{
|
||||
emu10k1_t *emu = snd_pcm_substream_chip(substream);
|
||||
snd_pcm_runtime_t *runtime = substream->runtime;
|
||||
int channel = substream->pcm->device - emu->p16v_device_offset;
|
||||
//printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, frames_to_bytes(runtime, 1));
|
||||
snd_emu10k1_ptr20_write(emu, 0x13, channel, 0);
|
||||
snd_emu10k1_ptr20_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr);
|
||||
snd_emu10k1_ptr20_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size)<<16); // buffer size in bytes
|
||||
snd_emu10k1_ptr20_write(emu, CAPTURE_POINTER, channel, 0);
|
||||
//snd_emu10k1_ptr20_write(emu, CAPTURE_SOURCE, 0x0, 0x333300e4); /* Select MIC or Line in */
|
||||
//snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void snd_p16v_intr_enable(emu10k1_t *emu, unsigned int intrenb)
|
||||
{
|
||||
unsigned long flags;
|
||||
@ -345,6 +449,36 @@ static int snd_p16v_pcm_trigger_playback(snd_pcm_substream_t *substream,
|
||||
return result;
|
||||
}
|
||||
|
||||
/* trigger_capture callback */
|
||||
static int snd_p16v_pcm_trigger_capture(snd_pcm_substream_t *substream,
|
||||
int cmd)
|
||||
{
|
||||
emu10k1_t *emu = snd_pcm_substream_chip(substream);
|
||||
snd_pcm_runtime_t *runtime = substream->runtime;
|
||||
emu10k1_pcm_t *epcm = runtime->private_data;
|
||||
int channel = 0;
|
||||
int result = 0;
|
||||
u32 inte = INTE2_CAPTURE_CH_0_LOOP | INTE2_CAPTURE_CH_0_HALF_LOOP;
|
||||
|
||||
switch (cmd) {
|
||||
case SNDRV_PCM_TRIGGER_START:
|
||||
snd_p16v_intr_enable(emu, inte);
|
||||
snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel));
|
||||
epcm->running = 1;
|
||||
break;
|
||||
case SNDRV_PCM_TRIGGER_STOP:
|
||||
snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel));
|
||||
snd_p16v_intr_disable(emu, inte);
|
||||
//snd_emu10k1_ptr20_write(emu, EXTENDED_INT_MASK, 0, snd_emu10k1_ptr20_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
|
||||
epcm->running = 0;
|
||||
break;
|
||||
default:
|
||||
result = -EINVAL;
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/* pointer_playback callback */
|
||||
static snd_pcm_uframes_t
|
||||
snd_p16v_pcm_pointer_playback(snd_pcm_substream_t *substream)
|
||||
@ -370,6 +504,31 @@ snd_p16v_pcm_pointer_playback(snd_pcm_substream_t *substream)
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/* pointer_capture callback */
|
||||
static snd_pcm_uframes_t
|
||||
snd_p16v_pcm_pointer_capture(snd_pcm_substream_t *substream)
|
||||
{
|
||||
emu10k1_t *emu = snd_pcm_substream_chip(substream);
|
||||
snd_pcm_runtime_t *runtime = substream->runtime;
|
||||
emu10k1_pcm_t *epcm = runtime->private_data;
|
||||
snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
|
||||
int channel = 0;
|
||||
|
||||
if (!epcm->running)
|
||||
return 0;
|
||||
|
||||
ptr1 = snd_emu10k1_ptr20_read(emu, CAPTURE_POINTER, channel);
|
||||
ptr2 = bytes_to_frames(runtime, ptr1);
|
||||
ptr=ptr2;
|
||||
if (ptr >= runtime->buffer_size) {
|
||||
ptr -= runtime->buffer_size;
|
||||
printk("buffer capture limited!\n");
|
||||
}
|
||||
//printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate);
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/* operators */
|
||||
static snd_pcm_ops_t snd_p16v_playback_front_ops = {
|
||||
.open = snd_p16v_pcm_open_playback_front,
|
||||
@ -382,6 +541,18 @@ static snd_pcm_ops_t snd_p16v_playback_front_ops = {
|
||||
.pointer = snd_p16v_pcm_pointer_playback,
|
||||
};
|
||||
|
||||
static snd_pcm_ops_t snd_p16v_capture_ops = {
|
||||
.open = snd_p16v_pcm_open_capture,
|
||||
.close = snd_p16v_pcm_close_capture,
|
||||
.ioctl = snd_pcm_lib_ioctl,
|
||||
.hw_params = snd_p16v_pcm_hw_params_capture,
|
||||
.hw_free = snd_p16v_pcm_hw_free_capture,
|
||||
.prepare = snd_p16v_pcm_prepare_capture,
|
||||
.trigger = snd_p16v_pcm_trigger_capture,
|
||||
.pointer = snd_p16v_pcm_pointer_capture,
|
||||
};
|
||||
|
||||
|
||||
int snd_p16v_free(emu10k1_t *chip)
|
||||
{
|
||||
// release the data
|
||||
@ -405,20 +576,22 @@ int snd_p16v_pcm(emu10k1_t *emu, int device, snd_pcm_t **rpcm)
|
||||
snd_pcm_t *pcm;
|
||||
snd_pcm_substream_t *substream;
|
||||
int err;
|
||||
int capture=0;
|
||||
int capture=1;
|
||||
|
||||
//snd_printk("snd_p16v_pcm called. device=%d\n", device);
|
||||
emu->p16v_device_offset = device;
|
||||
if (rpcm)
|
||||
*rpcm = NULL;
|
||||
//if (device == 0) capture=1;
|
||||
|
||||
if ((err = snd_pcm_new(emu->card, "p16v", device, 1, capture, &pcm)) < 0)
|
||||
return err;
|
||||
|
||||
pcm->private_data = emu;
|
||||
pcm->private_free = snd_p16v_pcm_free;
|
||||
|
||||
// Single playback 8 channel device.
|
||||
// Single capture 2 channel device.
|
||||
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_p16v_playback_front_ops);
|
||||
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_p16v_capture_ops);
|
||||
|
||||
pcm->info_flags = 0;
|
||||
pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
|
||||
@ -694,6 +867,56 @@ static snd_kcontrol_new_t snd_p16v_volume_control_spdif_rear =
|
||||
.put = snd_p16v_volume_put_spdif_rear
|
||||
};
|
||||
|
||||
static int snd_p16v_capture_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
|
||||
{
|
||||
static char *texts[8] = { "SPDIF", "I2S", "SRC48", "SRCMulti_SPDIF", "SRCMulti_I2S", "CDIF", "FX", "AC97" };
|
||||
|
||||
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
||||
uinfo->count = 1;
|
||||
uinfo->value.enumerated.items = 8;
|
||||
if (uinfo->value.enumerated.item > 7)
|
||||
uinfo->value.enumerated.item = 7;
|
||||
strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_p16v_capture_source_get(snd_kcontrol_t * kcontrol,
|
||||
snd_ctl_elem_value_t * ucontrol)
|
||||
{
|
||||
emu10k1_t *emu = snd_kcontrol_chip(kcontrol);
|
||||
|
||||
ucontrol->value.enumerated.item[0] = emu->p16v_capture_source;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_p16v_capture_source_put(snd_kcontrol_t * kcontrol,
|
||||
snd_ctl_elem_value_t * ucontrol)
|
||||
{
|
||||
emu10k1_t *emu = snd_kcontrol_chip(kcontrol);
|
||||
unsigned int val;
|
||||
int change = 0;
|
||||
u32 mask;
|
||||
u32 source;
|
||||
|
||||
val = ucontrol->value.enumerated.item[0] ;
|
||||
change = (emu->p16v_capture_source != val);
|
||||
if (change) {
|
||||
emu->p16v_capture_source = val;
|
||||
source = (val << 28) | (val << 24) | (val << 20) | (val << 16);
|
||||
mask = snd_emu10k1_ptr20_read(emu, BASIC_INTERRUPT, 0) & 0xffff;
|
||||
snd_emu10k1_ptr20_write(emu, BASIC_INTERRUPT, 0, source | mask);
|
||||
}
|
||||
return change;
|
||||
}
|
||||
|
||||
static snd_kcontrol_new_t snd_p16v_capture_source __devinitdata =
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "HD Capture source",
|
||||
.info = snd_p16v_capture_source_info,
|
||||
.get = snd_p16v_capture_source_get,
|
||||
.put = snd_p16v_capture_source_put
|
||||
};
|
||||
int snd_p16v_mixer(emu10k1_t *emu)
|
||||
{
|
||||
int err;
|
||||
@ -731,6 +954,10 @@ int snd_p16v_mixer(emu10k1_t *emu)
|
||||
return -ENOMEM;
|
||||
if ((err = snd_ctl_add(card, kctl)))
|
||||
return err;
|
||||
if ((kctl = snd_ctl_new1(&snd_p16v_capture_source, emu)) == NULL)
|
||||
return -ENOMEM;
|
||||
if ((err = snd_ctl_add(card, kctl)))
|
||||
return err;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user