3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <sound/driver.h>
22 #include <linux/init.h>
23 #include <linux/err.h>
24 #include <linux/platform_device.h>
25 #include <linux/jiffies.h>
26 #include <linux/slab.h>
27 #include <linux/time.h>
28 #include <linux/wait.h>
29 #include <linux/moduleparam.h>
30 #include <sound/core.h>
31 #include <sound/control.h>
32 #include <sound/pcm.h>
33 #include <sound/rawmidi.h>
34 #include <sound/initval.h>
36 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
37 MODULE_DESCRIPTION("Dummy soundcard (/dev/null)");
38 MODULE_LICENSE("GPL");
39 MODULE_SUPPORTED_DEVICE("{{ALSA,Dummy soundcard}}");
41 #define MAX_PCM_DEVICES 4
42 #define MAX_PCM_SUBSTREAMS 16
43 #define MAX_MIDI_DEVICES 2
45 #if 0 /* emu10k1 emulation */
46 #define MAX_BUFFER_SIZE (128 * 1024)
47 static int emu10k1_playback_constraints(struct snd_pcm_runtime
*runtime
)
50 if ((err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
)) < 0)
52 if ((err
= snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_BUFFER_BYTES
, 256, UINT_MAX
)) < 0)
56 #define add_playback_constraints emu10k1_playback_constraints
59 #if 0 /* RME9652 emulation */
60 #define MAX_BUFFER_SIZE (26 * 64 * 1024)
61 #define USE_FORMATS SNDRV_PCM_FMTBIT_S32_LE
62 #define USE_CHANNELS_MIN 26
63 #define USE_CHANNELS_MAX 26
64 #define USE_PERIODS_MIN 2
65 #define USE_PERIODS_MAX 2
68 #if 0 /* ICE1712 emulation */
69 #define MAX_BUFFER_SIZE (256 * 1024)
70 #define USE_FORMATS SNDRV_PCM_FMTBIT_S32_LE
71 #define USE_CHANNELS_MIN 10
72 #define USE_CHANNELS_MAX 10
73 #define USE_PERIODS_MIN 1
74 #define USE_PERIODS_MAX 1024
77 #if 0 /* UDA1341 emulation */
78 #define MAX_BUFFER_SIZE (16380)
79 #define USE_FORMATS SNDRV_PCM_FMTBIT_S16_LE
80 #define USE_CHANNELS_MIN 2
81 #define USE_CHANNELS_MAX 2
82 #define USE_PERIODS_MIN 2
83 #define USE_PERIODS_MAX 255
86 #if 0 /* simple AC97 bridge (intel8x0) with 48kHz AC97 only codec */
87 #define USE_FORMATS SNDRV_PCM_FMTBIT_S16_LE
88 #define USE_CHANNELS_MIN 2
89 #define USE_CHANNELS_MAX 2
90 #define USE_RATE SNDRV_PCM_RATE_48000
91 #define USE_RATE_MIN 48000
92 #define USE_RATE_MAX 48000
97 #ifndef MAX_BUFFER_SIZE
98 #define MAX_BUFFER_SIZE (64*1024)
101 #define USE_FORMATS (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE)
104 #define USE_RATE SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000
105 #define USE_RATE_MIN 5500
106 #define USE_RATE_MAX 48000
108 #ifndef USE_CHANNELS_MIN
109 #define USE_CHANNELS_MIN 1
111 #ifndef USE_CHANNELS_MAX
112 #define USE_CHANNELS_MAX 2
114 #ifndef USE_PERIODS_MIN
115 #define USE_PERIODS_MIN 1
117 #ifndef USE_PERIODS_MAX
118 #define USE_PERIODS_MAX 1024
120 #ifndef add_playback_constraints
121 #define add_playback_constraints(x) 0
123 #ifndef add_capture_constraints
124 #define add_capture_constraints(x) 0
127 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
128 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
129 static int enable
[SNDRV_CARDS
] = {1, [1 ... (SNDRV_CARDS
- 1)] = 0};
130 static int pcm_devs
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
131 static int pcm_substreams
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 8};
132 //static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
134 module_param_array(index
, int, NULL
, 0444);
135 MODULE_PARM_DESC(index
, "Index value for dummy soundcard.");
136 module_param_array(id
, charp
, NULL
, 0444);
137 MODULE_PARM_DESC(id
, "ID string for dummy soundcard.");
138 module_param_array(enable
, bool, NULL
, 0444);
139 MODULE_PARM_DESC(enable
, "Enable this dummy soundcard.");
140 module_param_array(pcm_devs
, int, NULL
, 0444);
141 MODULE_PARM_DESC(pcm_devs
, "PCM devices # (0-4) for dummy driver.");
142 module_param_array(pcm_substreams
, int, NULL
, 0444);
143 MODULE_PARM_DESC(pcm_substreams
, "PCM substreams # (1-16) for dummy driver.");
144 //module_param_array(midi_devs, int, NULL, 0444);
145 //MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver.");
147 #define MIXER_ADDR_MASTER 0
148 #define MIXER_ADDR_LINE 1
149 #define MIXER_ADDR_MIC 2
150 #define MIXER_ADDR_SYNTH 3
151 #define MIXER_ADDR_CD 4
152 #define MIXER_ADDR_LAST 4
155 struct snd_card
*card
;
157 spinlock_t mixer_lock
;
158 int mixer_volume
[MIXER_ADDR_LAST
+1][2];
159 int capture_source
[MIXER_ADDR_LAST
+1][2];
162 struct snd_dummy_pcm
{
163 struct snd_dummy
*dummy
;
165 struct timer_list timer
;
166 unsigned int pcm_size
;
167 unsigned int pcm_count
;
168 unsigned int pcm_bps
; /* bytes per second */
169 unsigned int pcm_jiffie
; /* bytes per one jiffie */
170 unsigned int pcm_irq_pos
; /* IRQ position */
171 unsigned int pcm_buf_pos
; /* position in buffer */
172 struct snd_pcm_substream
*substream
;
176 static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm
*dpcm
)
178 dpcm
->timer
.expires
= 1 + jiffies
;
179 add_timer(&dpcm
->timer
);
182 static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm
*dpcm
)
184 del_timer(&dpcm
->timer
);
187 static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
189 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
190 struct snd_dummy_pcm
*dpcm
= runtime
->private_data
;
193 spin_lock(&dpcm
->lock
);
195 case SNDRV_PCM_TRIGGER_START
:
196 case SNDRV_PCM_TRIGGER_RESUME
:
197 snd_card_dummy_pcm_timer_start(dpcm
);
199 case SNDRV_PCM_TRIGGER_STOP
:
200 case SNDRV_PCM_TRIGGER_SUSPEND
:
201 snd_card_dummy_pcm_timer_stop(dpcm
);
207 spin_unlock(&dpcm
->lock
);
211 static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream
*substream
)
213 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
214 struct snd_dummy_pcm
*dpcm
= runtime
->private_data
;
217 bps
= runtime
->rate
* runtime
->channels
;
218 bps
*= snd_pcm_format_width(runtime
->format
);
223 dpcm
->pcm_jiffie
= bps
/ HZ
;
224 dpcm
->pcm_size
= snd_pcm_lib_buffer_bytes(substream
);
225 dpcm
->pcm_count
= snd_pcm_lib_period_bytes(substream
);
226 dpcm
->pcm_irq_pos
= 0;
227 dpcm
->pcm_buf_pos
= 0;
231 static void snd_card_dummy_pcm_timer_function(unsigned long data
)
233 struct snd_dummy_pcm
*dpcm
= (struct snd_dummy_pcm
*)data
;
235 spin_lock(&dpcm
->lock
);
236 dpcm
->timer
.expires
= 1 + jiffies
;
237 add_timer(&dpcm
->timer
);
238 dpcm
->pcm_irq_pos
+= dpcm
->pcm_jiffie
;
239 dpcm
->pcm_buf_pos
+= dpcm
->pcm_jiffie
;
240 dpcm
->pcm_buf_pos
%= dpcm
->pcm_size
;
241 if (dpcm
->pcm_irq_pos
>= dpcm
->pcm_count
) {
242 dpcm
->pcm_irq_pos
%= dpcm
->pcm_count
;
243 spin_unlock(&dpcm
->lock
);
244 snd_pcm_period_elapsed(dpcm
->substream
);
245 spin_lock(&dpcm
->lock
);
247 spin_unlock(&dpcm
->lock
);
250 static snd_pcm_uframes_t
snd_card_dummy_pcm_pointer(struct snd_pcm_substream
*substream
)
252 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
253 struct snd_dummy_pcm
*dpcm
= runtime
->private_data
;
255 return bytes_to_frames(runtime
, dpcm
->pcm_buf_pos
);
258 static struct snd_pcm_hardware snd_card_dummy_playback
=
260 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
261 SNDRV_PCM_INFO_RESUME
| SNDRV_PCM_INFO_MMAP_VALID
),
262 .formats
= USE_FORMATS
,
264 .rate_min
= USE_RATE_MIN
,
265 .rate_max
= USE_RATE_MAX
,
266 .channels_min
= USE_CHANNELS_MIN
,
267 .channels_max
= USE_CHANNELS_MAX
,
268 .buffer_bytes_max
= MAX_BUFFER_SIZE
,
269 .period_bytes_min
= 64,
270 .period_bytes_max
= MAX_BUFFER_SIZE
,
271 .periods_min
= USE_PERIODS_MIN
,
272 .periods_max
= USE_PERIODS_MAX
,
276 static struct snd_pcm_hardware snd_card_dummy_capture
=
278 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
279 SNDRV_PCM_INFO_RESUME
| SNDRV_PCM_INFO_MMAP_VALID
),
280 .formats
= USE_FORMATS
,
282 .rate_min
= USE_RATE_MIN
,
283 .rate_max
= USE_RATE_MAX
,
284 .channels_min
= USE_CHANNELS_MIN
,
285 .channels_max
= USE_CHANNELS_MAX
,
286 .buffer_bytes_max
= MAX_BUFFER_SIZE
,
287 .period_bytes_min
= 64,
288 .period_bytes_max
= MAX_BUFFER_SIZE
,
289 .periods_min
= USE_PERIODS_MIN
,
290 .periods_max
= USE_PERIODS_MAX
,
294 static void snd_card_dummy_runtime_free(struct snd_pcm_runtime
*runtime
)
296 kfree(runtime
->private_data
);
299 static int snd_card_dummy_hw_params(struct snd_pcm_substream
*substream
,
300 struct snd_pcm_hw_params
*hw_params
)
302 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
305 static int snd_card_dummy_hw_free(struct snd_pcm_substream
*substream
)
307 return snd_pcm_lib_free_pages(substream
);
310 static struct snd_dummy_pcm
*new_pcm_stream(struct snd_pcm_substream
*substream
)
312 struct snd_dummy_pcm
*dpcm
;
314 dpcm
= kzalloc(sizeof(*dpcm
), GFP_KERNEL
);
317 init_timer(&dpcm
->timer
);
318 dpcm
->timer
.data
= (unsigned long) dpcm
;
319 dpcm
->timer
.function
= snd_card_dummy_pcm_timer_function
;
320 spin_lock_init(&dpcm
->lock
);
321 dpcm
->substream
= substream
;
325 static int snd_card_dummy_playback_open(struct snd_pcm_substream
*substream
)
327 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
328 struct snd_dummy_pcm
*dpcm
;
331 if ((dpcm
= new_pcm_stream(substream
)) == NULL
)
333 runtime
->private_data
= dpcm
;
334 runtime
->private_free
= snd_card_dummy_runtime_free
;
335 runtime
->hw
= snd_card_dummy_playback
;
336 if (substream
->pcm
->device
& 1) {
337 runtime
->hw
.info
&= ~SNDRV_PCM_INFO_INTERLEAVED
;
338 runtime
->hw
.info
|= SNDRV_PCM_INFO_NONINTERLEAVED
;
340 if (substream
->pcm
->device
& 2)
341 runtime
->hw
.info
&= ~(SNDRV_PCM_INFO_MMAP
|SNDRV_PCM_INFO_MMAP_VALID
);
342 if ((err
= add_playback_constraints(runtime
)) < 0) {
350 static int snd_card_dummy_capture_open(struct snd_pcm_substream
*substream
)
352 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
353 struct snd_dummy_pcm
*dpcm
;
356 if ((dpcm
= new_pcm_stream(substream
)) == NULL
)
358 runtime
->private_data
= dpcm
;
359 runtime
->private_free
= snd_card_dummy_runtime_free
;
360 runtime
->hw
= snd_card_dummy_capture
;
361 if (substream
->pcm
->device
== 1) {
362 runtime
->hw
.info
&= ~SNDRV_PCM_INFO_INTERLEAVED
;
363 runtime
->hw
.info
|= SNDRV_PCM_INFO_NONINTERLEAVED
;
365 if (substream
->pcm
->device
& 2)
366 runtime
->hw
.info
&= ~(SNDRV_PCM_INFO_MMAP
|SNDRV_PCM_INFO_MMAP_VALID
);
367 if ((err
= add_capture_constraints(runtime
)) < 0) {
375 static int snd_card_dummy_playback_close(struct snd_pcm_substream
*substream
)
380 static int snd_card_dummy_capture_close(struct snd_pcm_substream
*substream
)
385 static struct snd_pcm_ops snd_card_dummy_playback_ops
= {
386 .open
= snd_card_dummy_playback_open
,
387 .close
= snd_card_dummy_playback_close
,
388 .ioctl
= snd_pcm_lib_ioctl
,
389 .hw_params
= snd_card_dummy_hw_params
,
390 .hw_free
= snd_card_dummy_hw_free
,
391 .prepare
= snd_card_dummy_pcm_prepare
,
392 .trigger
= snd_card_dummy_pcm_trigger
,
393 .pointer
= snd_card_dummy_pcm_pointer
,
396 static struct snd_pcm_ops snd_card_dummy_capture_ops
= {
397 .open
= snd_card_dummy_capture_open
,
398 .close
= snd_card_dummy_capture_close
,
399 .ioctl
= snd_pcm_lib_ioctl
,
400 .hw_params
= snd_card_dummy_hw_params
,
401 .hw_free
= snd_card_dummy_hw_free
,
402 .prepare
= snd_card_dummy_pcm_prepare
,
403 .trigger
= snd_card_dummy_pcm_trigger
,
404 .pointer
= snd_card_dummy_pcm_pointer
,
407 static int __init
snd_card_dummy_pcm(struct snd_dummy
*dummy
, int device
, int substreams
)
412 if ((err
= snd_pcm_new(dummy
->card
, "Dummy PCM", device
,
413 substreams
, substreams
, &pcm
)) < 0)
416 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_card_dummy_playback_ops
);
417 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_card_dummy_capture_ops
);
418 pcm
->private_data
= dummy
;
420 strcpy(pcm
->name
, "Dummy PCM");
421 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_CONTINUOUS
,
422 snd_dma_continuous_data(GFP_KERNEL
),
427 #define DUMMY_VOLUME(xname, xindex, addr) \
428 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
429 .info = snd_dummy_volume_info, \
430 .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \
431 .private_value = addr }
433 static int snd_dummy_volume_info(struct snd_kcontrol
*kcontrol
,
434 struct snd_ctl_elem_info
*uinfo
)
436 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
438 uinfo
->value
.integer
.min
= -50;
439 uinfo
->value
.integer
.max
= 100;
443 static int snd_dummy_volume_get(struct snd_kcontrol
*kcontrol
,
444 struct snd_ctl_elem_value
*ucontrol
)
446 struct snd_dummy
*dummy
= snd_kcontrol_chip(kcontrol
);
447 int addr
= kcontrol
->private_value
;
449 spin_lock_irq(&dummy
->mixer_lock
);
450 ucontrol
->value
.integer
.value
[0] = dummy
->mixer_volume
[addr
][0];
451 ucontrol
->value
.integer
.value
[1] = dummy
->mixer_volume
[addr
][1];
452 spin_unlock_irq(&dummy
->mixer_lock
);
456 static int snd_dummy_volume_put(struct snd_kcontrol
*kcontrol
,
457 struct snd_ctl_elem_value
*ucontrol
)
459 struct snd_dummy
*dummy
= snd_kcontrol_chip(kcontrol
);
460 int change
, addr
= kcontrol
->private_value
;
463 left
= ucontrol
->value
.integer
.value
[0];
468 right
= ucontrol
->value
.integer
.value
[1];
473 spin_lock_irq(&dummy
->mixer_lock
);
474 change
= dummy
->mixer_volume
[addr
][0] != left
||
475 dummy
->mixer_volume
[addr
][1] != right
;
476 dummy
->mixer_volume
[addr
][0] = left
;
477 dummy
->mixer_volume
[addr
][1] = right
;
478 spin_unlock_irq(&dummy
->mixer_lock
);
482 #define DUMMY_CAPSRC(xname, xindex, addr) \
483 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
484 .info = snd_dummy_capsrc_info, \
485 .get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \
486 .private_value = addr }
488 static int snd_dummy_capsrc_info(struct snd_kcontrol
*kcontrol
,
489 struct snd_ctl_elem_info
*uinfo
)
491 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
493 uinfo
->value
.integer
.min
= 0;
494 uinfo
->value
.integer
.max
= 1;
498 static int snd_dummy_capsrc_get(struct snd_kcontrol
*kcontrol
,
499 struct snd_ctl_elem_value
*ucontrol
)
501 struct snd_dummy
*dummy
= snd_kcontrol_chip(kcontrol
);
502 int addr
= kcontrol
->private_value
;
504 spin_lock_irq(&dummy
->mixer_lock
);
505 ucontrol
->value
.integer
.value
[0] = dummy
->capture_source
[addr
][0];
506 ucontrol
->value
.integer
.value
[1] = dummy
->capture_source
[addr
][1];
507 spin_unlock_irq(&dummy
->mixer_lock
);
511 static int snd_dummy_capsrc_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
513 struct snd_dummy
*dummy
= snd_kcontrol_chip(kcontrol
);
514 int change
, addr
= kcontrol
->private_value
;
517 left
= ucontrol
->value
.integer
.value
[0] & 1;
518 right
= ucontrol
->value
.integer
.value
[1] & 1;
519 spin_lock_irq(&dummy
->mixer_lock
);
520 change
= dummy
->capture_source
[addr
][0] != left
&&
521 dummy
->capture_source
[addr
][1] != right
;
522 dummy
->capture_source
[addr
][0] = left
;
523 dummy
->capture_source
[addr
][1] = right
;
524 spin_unlock_irq(&dummy
->mixer_lock
);
528 static struct snd_kcontrol_new snd_dummy_controls
[] = {
529 DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER
),
530 DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER
),
531 DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH
),
532 DUMMY_CAPSRC("Synth Capture Switch", 0, MIXER_ADDR_MASTER
),
533 DUMMY_VOLUME("Line Volume", 0, MIXER_ADDR_LINE
),
534 DUMMY_CAPSRC("Line Capture Switch", 0, MIXER_ADDR_MASTER
),
535 DUMMY_VOLUME("Mic Volume", 0, MIXER_ADDR_MIC
),
536 DUMMY_CAPSRC("Mic Capture Switch", 0, MIXER_ADDR_MASTER
),
537 DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD
),
538 DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_MASTER
)
541 static int __init
snd_card_dummy_new_mixer(struct snd_dummy
*dummy
)
543 struct snd_card
*card
= dummy
->card
;
547 snd_assert(dummy
!= NULL
, return -EINVAL
);
548 spin_lock_init(&dummy
->mixer_lock
);
549 strcpy(card
->mixername
, "Dummy Mixer");
551 for (idx
= 0; idx
< ARRAY_SIZE(snd_dummy_controls
); idx
++) {
552 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&snd_dummy_controls
[idx
], dummy
))) < 0)
558 static int __init
snd_dummy_probe(struct platform_device
*devptr
)
560 struct snd_card
*card
;
561 struct snd_dummy
*dummy
;
563 int dev
= devptr
->id
;
565 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
,
566 sizeof(struct snd_dummy
));
569 dummy
= card
->private_data
;
571 for (idx
= 0; idx
< MAX_PCM_DEVICES
&& idx
< pcm_devs
[dev
]; idx
++) {
572 if (pcm_substreams
[dev
] < 1)
573 pcm_substreams
[dev
] = 1;
574 if (pcm_substreams
[dev
] > MAX_PCM_SUBSTREAMS
)
575 pcm_substreams
[dev
] = MAX_PCM_SUBSTREAMS
;
576 if ((err
= snd_card_dummy_pcm(dummy
, idx
, pcm_substreams
[dev
])) < 0)
579 if ((err
= snd_card_dummy_new_mixer(dummy
)) < 0)
581 strcpy(card
->driver
, "Dummy");
582 strcpy(card
->shortname
, "Dummy");
583 sprintf(card
->longname
, "Dummy %i", dev
+ 1);
585 snd_card_set_dev(card
, &devptr
->dev
);
587 if ((err
= snd_card_register(card
)) == 0) {
588 platform_set_drvdata(devptr
, card
);
596 static int snd_dummy_remove(struct platform_device
*devptr
)
598 snd_card_free(platform_get_drvdata(devptr
));
599 platform_set_drvdata(devptr
, NULL
);
604 static int snd_dummy_suspend(struct platform_device
*pdev
, pm_message_t state
)
606 struct snd_card
*card
= platform_get_drvdata(pdev
);
607 struct snd_dummy
*dummy
= card
->private_data
;
609 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
610 snd_pcm_suspend_all(dummy
->pcm
);
614 static int snd_dummy_resume(struct platform_device
*pdev
)
616 struct snd_card
*card
= platform_get_drvdata(pdev
);
618 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
623 #define SND_DUMMY_DRIVER "snd_dummy"
625 static struct platform_driver snd_dummy_driver
= {
626 .probe
= snd_dummy_probe
,
627 .remove
= snd_dummy_remove
,
629 .suspend
= snd_dummy_suspend
,
630 .resume
= snd_dummy_resume
,
633 .name
= SND_DUMMY_DRIVER
637 static int __init
alsa_card_dummy_init(void)
641 if ((err
= platform_driver_register(&snd_dummy_driver
)) < 0)
645 for (i
= 0; i
< SNDRV_CARDS
&& enable
[i
]; i
++) {
646 struct platform_device
*device
;
647 device
= platform_device_register_simple(SND_DUMMY_DRIVER
,
649 if (IS_ERR(device
)) {
650 err
= PTR_ERR(device
);
657 printk(KERN_ERR
"Dummy soundcard not found or device busy\n");
665 platform_driver_unregister(&snd_dummy_driver
);
669 static void __exit
alsa_card_dummy_exit(void)
671 platform_driver_unregister(&snd_dummy_driver
);
674 module_init(alsa_card_dummy_init
)
675 module_exit(alsa_card_dummy_exit
)