lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ALSA: dummy - Support high-res timer mode

Browse Source 
Allow snd-dummy driver to use high-res timer as its timing source
instead of the system timer.  The new module option "hrtimer" is added
to turn on/off the high-res timer support.  It can be switched even
dynamically via sysfs.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai
2009-09-03 15:59:26 +02:00
parent 326ba5010a
commit c631d03c68
1 changed files with 280 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

447
sound/drivers/dummy.c
View File

@@ -25,6 +25,8 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/wait.h> #include <linux/wait.h>
#include <linux/hrtimer.h>
#include <linux/math64.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/control.h> #include <sound/control.h>
@@ -148,6 +150,9 @@ static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8}; static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8};
//static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2}; //static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
#ifdef CONFIG_HIGH_RES_TIMERS
static int hrtimer = 1;
#endif
module_param_array(index, int, NULL, 0444); module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "Index value for dummy soundcard."); MODULE_PARM_DESC(index, "Index value for dummy soundcard.");
@@ -161,6 +166,10 @@ module_param_array(pcm_substreams, int, NULL, 0444);
MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-16) for dummy driver."); MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-16) for dummy driver.");
//module_param_array(midi_devs, int, NULL, 0444); //module_param_array(midi_devs, int, NULL, 0444);
//MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver."); //MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver.");
#ifdef CONFIG_HIGH_RES_TIMERS
module_param(hrtimer, bool, 0644);
MODULE_PARM_DESC(hrtimer, "Use hrtimer as the timer source.");
#endif
static struct platform_device *devices[SNDRV_CARDS]; static struct platform_device *devices[SNDRV_CARDS];
@@ -171,16 +180,29 @@ static struct platform_device *devices[SNDRV_CARDS];
#define MIXER_ADDR_CD 4 #define MIXER_ADDR_CD 4
#define MIXER_ADDR_LAST 4 #define MIXER_ADDR_LAST 4
struct dummy_timer_ops {
int (*create)(struct snd_pcm_substream *);
void (*free)(struct snd_pcm_substream *);
int (*prepare)(struct snd_pcm_substream *);
int (*start)(struct snd_pcm_substream *);
int (*stop)(struct snd_pcm_substream *);
snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *);
};
struct snd_dummy { struct snd_dummy {
struct snd_card *card; struct snd_card *card;
struct snd_pcm *pcm; struct snd_pcm *pcm;
spinlock_t mixer_lock; spinlock_t mixer_lock;
int mixer_volume[MIXER_ADDR_LAST+1][2]; int mixer_volume[MIXER_ADDR_LAST+1][2];
int capture_source[MIXER_ADDR_LAST+1][2]; int capture_source[MIXER_ADDR_LAST+1][2];
const struct dummy_timer_ops *timer_ops;
}; };
struct snd_dummy_pcm { /*
struct snd_dummy *dummy; * system timer interface
*/
struct dummy_systimer_pcm {
spinlock_t lock; spinlock_t lock;
struct timer_list timer; struct timer_list timer;
unsigned int pcm_buffer_size; unsigned int pcm_buffer_size;
@@ -192,46 +214,29 @@ struct snd_dummy_pcm {
struct snd_pcm_substream *substream; struct snd_pcm_substream *substream;
}; };
static int dummy_systimer_start(struct snd_pcm_substream *substream)
static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm)
{ {
struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
spin_lock(&dpcm->lock);
dpcm->timer.expires = 1 + jiffies; dpcm->timer.expires = 1 + jiffies;
add_timer(&dpcm->timer); add_timer(&dpcm->timer);
}
static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm)
{
del_timer(&dpcm->timer);
}
static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_dummy_pcm *dpcm = runtime->private_data;
int err = 0;
spin_lock(&dpcm->lock);
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
case SNDRV_PCM_TRIGGER_RESUME:
snd_card_dummy_pcm_timer_start(dpcm);
break;
case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND:
snd_card_dummy_pcm_timer_stop(dpcm);
break;
default:
err = -EINVAL;
break;
}
spin_unlock(&dpcm->lock); spin_unlock(&dpcm->lock);
return 0; return 0;
} }
static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream) static int dummy_systimer_stop(struct snd_pcm_substream *substream)
{
struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
spin_lock(&dpcm->lock);
del_timer(&dpcm->timer);
spin_unlock(&dpcm->lock);
return 0;
}
static int dummy_systimer_prepare(struct snd_pcm_substream *substream)
{ {
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_dummy_pcm *dpcm = runtime->private_data; struct dummy_systimer_pcm *dpcm = runtime->private_data;
int bps; int bps;
bps = snd_pcm_format_width(runtime->format) * runtime->rate * bps = snd_pcm_format_width(runtime->format) * runtime->rate *
@@ -247,15 +252,12 @@ static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream)
dpcm->pcm_irq_pos = 0; dpcm->pcm_irq_pos = 0;
dpcm->pcm_buf_pos = 0; dpcm->pcm_buf_pos = 0;
snd_pcm_format_set_silence(runtime->format, runtime->dma_area,
bytes_to_samples(runtime, runtime->dma_bytes));
return 0; return 0;
} }
static void snd_card_dummy_pcm_timer_function(unsigned long data) static void dummy_systimer_callback(unsigned long data)
{ {
struct snd_dummy_pcm *dpcm = (struct snd_dummy_pcm *)data; struct dummy_systimer_pcm *dpcm = (struct dummy_systimer_pcm *)data;
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&dpcm->lock, flags); spin_lock_irqsave(&dpcm->lock, flags);
@@ -272,161 +274,290 @@ static void snd_card_dummy_pcm_timer_function(unsigned long data)
spin_unlock_irqrestore(&dpcm->lock, flags); spin_unlock_irqrestore(&dpcm->lock, flags);
} }
static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(struct snd_pcm_substream *substream) static snd_pcm_uframes_t
dummy_systimer_pointer(struct snd_pcm_substream *substream)
{ {
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_dummy_pcm *dpcm = runtime->private_data; struct dummy_systimer_pcm *dpcm = runtime->private_data;
return bytes_to_frames(runtime, dpcm->pcm_buf_pos / dpcm->pcm_hz); return bytes_to_frames(runtime, dpcm->pcm_buf_pos / dpcm->pcm_hz);
} }
static struct snd_pcm_hardware snd_card_dummy_playback = static int dummy_systimer_create(struct snd_pcm_substream *substream)
{ {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | struct dummy_systimer_pcm *dpcm;
SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
.formats = USE_FORMATS,
.rates = USE_RATE,
.rate_min = USE_RATE_MIN,
.rate_max = USE_RATE_MAX,
.channels_min = USE_CHANNELS_MIN,
.channels_max = USE_CHANNELS_MAX,
.buffer_bytes_max = MAX_BUFFER_SIZE,
.period_bytes_min = 64,
.period_bytes_max = MAX_PERIOD_SIZE,
.periods_min = USE_PERIODS_MIN,
.periods_max = USE_PERIODS_MAX,
.fifo_size = 0,
};
static struct snd_pcm_hardware snd_card_dummy_capture = dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
{ if (!dpcm)
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | return -ENOMEM;
SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), substream->runtime->private_data = dpcm;
.formats = USE_FORMATS, init_timer(&dpcm->timer);
.rates = USE_RATE, dpcm->timer.data = (unsigned long) dpcm;
.rate_min = USE_RATE_MIN, dpcm->timer.function = dummy_systimer_callback;
.rate_max = USE_RATE_MAX, spin_lock_init(&dpcm->lock);
.channels_min = USE_CHANNELS_MIN, dpcm->substream = substream;
.channels_max = USE_CHANNELS_MAX, return 0;
.buffer_bytes_max = MAX_BUFFER_SIZE,
.period_bytes_min = 64,
.period_bytes_max = MAX_PERIOD_SIZE,
.periods_min = USE_PERIODS_MIN,
.periods_max = USE_PERIODS_MAX,
.fifo_size = 0,
};
static void snd_card_dummy_runtime_free(struct snd_pcm_runtime *runtime)
{
kfree(runtime->private_data);
} }
static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream, static void dummy_systimer_free(struct snd_pcm_substream *substream)
{
kfree(substream->runtime->private_data);
}
static struct dummy_timer_ops dummy_systimer_ops = {
.create = dummy_systimer_create,
.free = dummy_systimer_free,
.prepare = dummy_systimer_prepare,
.start = dummy_systimer_start,
.stop = dummy_systimer_stop,
.pointer = dummy_systimer_pointer,
};
#ifdef CONFIG_HIGH_RES_TIMERS
/*
* hrtimer interface
*/
struct dummy_hrtimer_pcm {
ktime_t base_time;
ktime_t period_time;
atomic_t running;
struct hrtimer timer;
struct tasklet_struct tasklet;
struct snd_pcm_substream *substream;
};
static void dummy_hrtimer_pcm_elapsed(unsigned long priv)
{
struct dummy_hrtimer_pcm *dpcm = (struct dummy_hrtimer_pcm *)priv;
if (atomic_read(&dpcm->running))
snd_pcm_period_elapsed(dpcm->substream);
}
static enum hrtimer_restart dummy_hrtimer_callback(struct hrtimer *timer)
{
struct dummy_hrtimer_pcm *dpcm;
dpcm = container_of(timer, struct dummy_hrtimer_pcm, timer);
if (!atomic_read(&dpcm->running))
return HRTIMER_NORESTART;
tasklet_schedule(&dpcm->tasklet);
hrtimer_forward_now(timer, dpcm->period_time);
return HRTIMER_RESTART;
}
static int dummy_hrtimer_start(struct snd_pcm_substream *substream)
{
struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
dpcm->base_time = hrtimer_cb_get_time(&dpcm->timer);
hrtimer_start(&dpcm->timer, dpcm->period_time, HRTIMER_MODE_REL);
atomic_set(&dpcm->running, 1);
return 0;
}
static int dummy_hrtimer_stop(struct snd_pcm_substream *substream)
{
struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
atomic_set(&dpcm->running, 0);
hrtimer_cancel(&dpcm->timer);
return 0;
}
static inline void dummy_hrtimer_sync(struct dummy_hrtimer_pcm *dpcm)
{
tasklet_kill(&dpcm->tasklet);
}
static snd_pcm_uframes_t
dummy_hrtimer_pointer(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct dummy_hrtimer_pcm *dpcm = runtime->private_data;
u64 delta;
u32 pos;
delta = ktime_us_delta(hrtimer_cb_get_time(&dpcm->timer),
dpcm->base_time);
delta = div_u64(delta * runtime->rate + 999999, 1000000);
div_u64_rem(delta, runtime->buffer_size, &pos);
return pos;
}
static int dummy_hrtimer_prepare(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct dummy_hrtimer_pcm *dpcm = runtime->private_data;
unsigned int period, rate;
long sec;
unsigned long nsecs;
dummy_hrtimer_sync(dpcm);
period = runtime->period_size;
rate = runtime->rate;
sec = period / rate;
period %= rate;
nsecs = div_u64((u64)period * 1000000000UL + rate - 1, rate);
dpcm->period_time = ktime_set(sec, nsecs);
return 0;
}
static int dummy_hrtimer_create(struct snd_pcm_substream *substream)
{
struct dummy_hrtimer_pcm *dpcm;
dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
if (!dpcm)
return -ENOMEM;
substream->runtime->private_data = dpcm;
hrtimer_init(&dpcm->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
dpcm->timer.function = dummy_hrtimer_callback;
dpcm->substream = substream;
atomic_set(&dpcm->running, 0);
tasklet_init(&dpcm->tasklet, dummy_hrtimer_pcm_elapsed,
(unsigned long)dpcm);
return 0;
}
static void dummy_hrtimer_free(struct snd_pcm_substream *substream)
{
struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
dummy_hrtimer_sync(dpcm);
kfree(dpcm);
}
static struct dummy_timer_ops dummy_hrtimer_ops = {
.create = dummy_hrtimer_create,
.free = dummy_hrtimer_free,
.prepare = dummy_hrtimer_prepare,
.start = dummy_hrtimer_start,
.stop = dummy_hrtimer_stop,
.pointer = dummy_hrtimer_pointer,
};
#endif /* CONFIG_HIGH_RES_TIMERS */
/*
* PCM interface
*/
static int dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
case SNDRV_PCM_TRIGGER_RESUME:
return dummy->timer_ops->start(substream);
case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND:
return dummy->timer_ops->stop(substream);
}
return -EINVAL;
}
static int dummy_pcm_prepare(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
snd_pcm_format_set_silence(runtime->format, runtime->dma_area,
bytes_to_samples(runtime, runtime->dma_bytes));
return dummy->timer_ops->prepare(substream);
}
static snd_pcm_uframes_t dummy_pcm_pointer(struct snd_pcm_substream *substream)
{
struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
return dummy->timer_ops->pointer(substream);
}
static struct snd_pcm_hardware dummy_pcm_hardware = {
.info = (SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_RESUME |
SNDRV_PCM_INFO_MMAP_VALID),
.formats = USE_FORMATS,
.rates = USE_RATE,
.rate_min = USE_RATE_MIN,
.rate_max = USE_RATE_MAX,
.channels_min = USE_CHANNELS_MIN,
.channels_max = USE_CHANNELS_MAX,
.buffer_bytes_max = MAX_BUFFER_SIZE,
.period_bytes_min = 64,
.period_bytes_max = MAX_PERIOD_SIZE,
.periods_min = USE_PERIODS_MIN,
.periods_max = USE_PERIODS_MAX,
.fifo_size = 0,
};
static int dummy_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *hw_params) struct snd_pcm_hw_params *hw_params)
{ {
return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); return snd_pcm_lib_malloc_pages(substream,
params_buffer_bytes(hw_params));
} }
static int snd_card_dummy_hw_free(struct snd_pcm_substream *substream) static int dummy_pcm_hw_free(struct snd_pcm_substream *substream)
{ {
return snd_pcm_lib_free_pages(substream); return snd_pcm_lib_free_pages(substream);
} }
static struct snd_dummy_pcm *new_pcm_stream(struct snd_pcm_substream *substream) static int dummy_pcm_open(struct snd_pcm_substream *substream)
{
struct snd_dummy_pcm *dpcm;
dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
if (! dpcm)
return dpcm;
init_timer(&dpcm->timer);
dpcm->timer.data = (unsigned long) dpcm;
dpcm->timer.function = snd_card_dummy_pcm_timer_function;
spin_lock_init(&dpcm->lock);
dpcm->substream = substream;
return dpcm;
}
static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream)
{ {
struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_dummy_pcm *dpcm;
int err; int err;
if ((dpcm = new_pcm_stream(substream)) == NULL) dummy->timer_ops = &dummy_systimer_ops;
return -ENOMEM; #ifdef CONFIG_HIGH_RES_TIMERS
runtime->private_data = dpcm; if (hrtimer)
/* makes the infrastructure responsible for freeing dpcm */ dummy->timer_ops = &dummy_hrtimer_ops;
runtime->private_free = snd_card_dummy_runtime_free; #endif
runtime->hw = snd_card_dummy_playback;
err = dummy->timer_ops->create(substream);
if (err < 0)
return err;
runtime->hw = dummy_pcm_hardware;
if (substream->pcm->device & 1) { if (substream->pcm->device & 1) {
runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED; runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED; runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
} }
if (substream->pcm->device & 2) if (substream->pcm->device & 2)
runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID); runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP |
err = add_playback_constraints(runtime); SNDRV_PCM_INFO_MMAP_VALID);
if (err < 0)
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
err = add_playback_constraints(substream->runtime);
else
err = add_capture_constraints(substream->runtime);
if (err < 0) {
dummy->timer_ops->free(substream);
return err; return err;
return 0;
}
static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_dummy_pcm *dpcm;
int err;
if ((dpcm = new_pcm_stream(substream)) == NULL)
return -ENOMEM;
runtime->private_data = dpcm;
/* makes the infrastructure responsible for freeing dpcm */
runtime->private_free = snd_card_dummy_runtime_free;
runtime->hw = snd_card_dummy_capture;
if (substream->pcm->device == 1) {
runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
} }
if (substream->pcm->device & 2)
runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
err = add_capture_constraints(runtime);
if (err < 0)
return err;
return 0; return 0;
} }
static int snd_card_dummy_playback_close(struct snd_pcm_substream *substream) static int dummy_pcm_close(struct snd_pcm_substream *substream)
{ {
struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
dummy->timer_ops->free(substream);
return 0; return 0;
} }
static int snd_card_dummy_capture_close(struct snd_pcm_substream *substream) static struct snd_pcm_ops dummy_pcm_ops = {
{ .open = dummy_pcm_open,
return 0; .close = dummy_pcm_close,
}
static struct snd_pcm_ops snd_card_dummy_playback_ops = {
.open = snd_card_dummy_playback_open,
.close = snd_card_dummy_playback_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
.hw_params = snd_card_dummy_hw_params, .hw_params = dummy_pcm_hw_params,
.hw_free = snd_card_dummy_hw_free, .hw_free = dummy_pcm_hw_free,
.prepare = snd_card_dummy_pcm_prepare, .prepare = dummy_pcm_prepare,
.trigger = snd_card_dummy_pcm_trigger, .trigger = dummy_pcm_trigger,
.pointer = snd_card_dummy_pcm_pointer, .pointer = dummy_pcm_pointer,
};
static struct snd_pcm_ops snd_card_dummy_capture_ops = {
.open = snd_card_dummy_capture_open,
.close = snd_card_dummy_capture_close,
.ioctl = snd_pcm_lib_ioctl,
.hw_params = snd_card_dummy_hw_params,
.hw_free = snd_card_dummy_hw_free,
.prepare = snd_card_dummy_pcm_prepare,
.trigger = snd_card_dummy_pcm_trigger,
.pointer = snd_card_dummy_pcm_pointer,
}; };
static int __devinit snd_card_dummy_pcm(struct snd_dummy *dummy, int device, static int __devinit snd_card_dummy_pcm(struct snd_dummy *dummy, int device,
@@ -440,8 +571,8 @@ static int __devinit snd_card_dummy_pcm(struct snd_dummy *dummy, int device,
if (err < 0) if (err < 0)
return err; return err;
dummy->pcm = pcm; dummy->pcm = pcm;
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &dummy_pcm_ops);
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &dummy_pcm_ops);
pcm->private_data = dummy; pcm->private_data = dummy;
pcm->info_flags = 0; pcm->info_flags = 0;
strcpy(pcm->name, "Dummy PCM"); strcpy(pcm->name, "Dummy PCM");