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 static struct platform_device
*devices
[SNDRV_CARDS
];
149 #define MIXER_ADDR_MASTER 0
150 #define MIXER_ADDR_LINE 1
151 #define MIXER_ADDR_MIC 2
152 #define MIXER_ADDR_SYNTH 3
153 #define MIXER_ADDR_CD 4
154 #define MIXER_ADDR_LAST 4
157 struct snd_card
*card
;
159 spinlock_t mixer_lock
;
160 int mixer_volume
[MIXER_ADDR_LAST
+1][2];
161 int capture_source
[MIXER_ADDR_LAST
+1][2];
164 struct snd_dummy_pcm
{
165 struct snd_dummy
*dummy
;
167 struct timer_list timer
;
168 unsigned int pcm_size
;
169 unsigned int pcm_count
;
170 unsigned int pcm_bps
; /* bytes per second */
171 unsigned int pcm_jiffie
; /* bytes per one jiffie */
172 unsigned int pcm_irq_pos
; /* IRQ position */
173 unsigned int pcm_buf_pos
; /* position in buffer */
174 struct snd_pcm_substream
*substream
;
178 static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm
*dpcm
)
180 dpcm
->timer
.expires
= 1 + jiffies
;
181 add_timer(&dpcm
->timer
);
184 static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm
*dpcm
)
186 del_timer(&dpcm
->timer
);
189 static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
191 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
192 struct snd_dummy_pcm
*dpcm
= runtime
->private_data
;
195 spin_lock(&dpcm
->lock
);
197 case SNDRV_PCM_TRIGGER_START
:
198 case SNDRV_PCM_TRIGGER_RESUME
:
199 snd_card_dummy_pcm_timer_start(dpcm
);
201 case SNDRV_PCM_TRIGGER_STOP
:
202 case SNDRV_PCM_TRIGGER_SUSPEND
:
203 snd_card_dummy_pcm_timer_stop(dpcm
);
209 spin_unlock(&dpcm
->lock
);
213 static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream
*substream
)
215 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
216 struct snd_dummy_pcm
*dpcm
= runtime
->private_data
;
219 bps
= runtime
->rate
* runtime
->channels
;
220 bps
*= snd_pcm_format_width(runtime
->format
);
225 dpcm
->pcm_jiffie
= bps
/ HZ
;
226 dpcm
->pcm_size
= snd_pcm_lib_buffer_bytes(substream
);
227 dpcm
->pcm_count
= snd_pcm_lib_period_bytes(substream
);
228 dpcm
->pcm_irq_pos
= 0;
229 dpcm
->pcm_buf_pos
= 0;
233 static void snd_card_dummy_pcm_timer_function(unsigned long data
)
235 struct snd_dummy_pcm
*dpcm
= (struct snd_dummy_pcm
*)data
;
238 spin_lock_irqsave(&dpcm
->lock
, flags
);
239 dpcm
->timer
.expires
= 1 + jiffies
;
240 add_timer(&dpcm
->timer
);
241 dpcm
->pcm_irq_pos
+= dpcm
->pcm_jiffie
;
242 dpcm
->pcm_buf_pos
+= dpcm
->pcm_jiffie
;
243 dpcm
->pcm_buf_pos
%= dpcm
->pcm_size
;
244 if (dpcm
->pcm_irq_pos
>= dpcm
->pcm_count
) {
245 dpcm
->pcm_irq_pos
%= dpcm
->pcm_count
;
246 spin_unlock_irqrestore(&dpcm
->lock
, flags
);
247 snd_pcm_period_elapsed(dpcm
->substream
);
249 spin_unlock_irqrestore(&dpcm
->lock
, flags
);
252 static snd_pcm_uframes_t
snd_card_dummy_pcm_pointer(struct snd_pcm_substream
*substream
)
254 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
255 struct snd_dummy_pcm
*dpcm
= runtime
->private_data
;
257 return bytes_to_frames(runtime
, dpcm
->pcm_buf_pos
);
260 static struct snd_pcm_hardware snd_card_dummy_playback
=
262 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
263 SNDRV_PCM_INFO_RESUME
| SNDRV_PCM_INFO_MMAP_VALID
),
264 .formats
= USE_FORMATS
,
266 .rate_min
= USE_RATE_MIN
,
267 .rate_max
= USE_RATE_MAX
,
268 .channels_min
= USE_CHANNELS_MIN
,
269 .channels_max
= USE_CHANNELS_MAX
,
270 .buffer_bytes_max
= MAX_BUFFER_SIZE
,
271 .period_bytes_min
= 64,
272 .period_bytes_max
= MAX_BUFFER_SIZE
,
273 .periods_min
= USE_PERIODS_MIN
,
274 .periods_max
= USE_PERIODS_MAX
,
278 static struct snd_pcm_hardware snd_card_dummy_capture
=
280 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
281 SNDRV_PCM_INFO_RESUME
| SNDRV_PCM_INFO_MMAP_VALID
),
282 .formats
= USE_FORMATS
,
284 .rate_min
= USE_RATE_MIN
,
285 .rate_max
= USE_RATE_MAX
,
286 .channels_min
= USE_CHANNELS_MIN
,
287 .channels_max
= USE_CHANNELS_MAX
,
288 .buffer_bytes_max
= MAX_BUFFER_SIZE
,
289 .period_bytes_min
= 64,
290 .period_bytes_max
= MAX_BUFFER_SIZE
,
291 .periods_min
= USE_PERIODS_MIN
,
292 .periods_max
= USE_PERIODS_MAX
,
296 static void snd_card_dummy_runtime_free(struct snd_pcm_runtime
*runtime
)
298 kfree(runtime
->private_data
);
301 static int snd_card_dummy_hw_params(struct snd_pcm_substream
*substream
,
302 struct snd_pcm_hw_params
*hw_params
)
304 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
307 static int snd_card_dummy_hw_free(struct snd_pcm_substream
*substream
)
309 return snd_pcm_lib_free_pages(substream
);
312 static struct snd_dummy_pcm
*new_pcm_stream(struct snd_pcm_substream
*substream
)
314 struct snd_dummy_pcm
*dpcm
;
316 dpcm
= kzalloc(sizeof(*dpcm
), GFP_KERNEL
);
319 init_timer(&dpcm
->timer
);
320 dpcm
->timer
.data
= (unsigned long) dpcm
;
321 dpcm
->timer
.function
= snd_card_dummy_pcm_timer_function
;
322 spin_lock_init(&dpcm
->lock
);
323 dpcm
->substream
= substream
;
327 static int snd_card_dummy_playback_open(struct snd_pcm_substream
*substream
)
329 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
330 struct snd_dummy_pcm
*dpcm
;
333 if ((dpcm
= new_pcm_stream(substream
)) == NULL
)
335 runtime
->private_data
= dpcm
;
336 runtime
->private_free
= snd_card_dummy_runtime_free
;
337 runtime
->hw
= snd_card_dummy_playback
;
338 if (substream
->pcm
->device
& 1) {
339 runtime
->hw
.info
&= ~SNDRV_PCM_INFO_INTERLEAVED
;
340 runtime
->hw
.info
|= SNDRV_PCM_INFO_NONINTERLEAVED
;
342 if (substream
->pcm
->device
& 2)
343 runtime
->hw
.info
&= ~(SNDRV_PCM_INFO_MMAP
|SNDRV_PCM_INFO_MMAP_VALID
);
344 if ((err
= add_playback_constraints(runtime
)) < 0) {
352 static int snd_card_dummy_capture_open(struct snd_pcm_substream
*substream
)
354 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
355 struct snd_dummy_pcm
*dpcm
;
358 if ((dpcm
= new_pcm_stream(substream
)) == NULL
)
360 runtime
->private_data
= dpcm
;
361 runtime
->private_free
= snd_card_dummy_runtime_free
;
362 runtime
->hw
= snd_card_dummy_capture
;
363 if (substream
->pcm
->device
== 1) {
364 runtime
->hw
.info
&= ~SNDRV_PCM_INFO_INTERLEAVED
;
365 runtime
->hw
.info
|= SNDRV_PCM_INFO_NONINTERLEAVED
;
367 if (substream
->pcm
->device
& 2)
368 runtime
->hw
.info
&= ~(SNDRV_PCM_INFO_MMAP
|SNDRV_PCM_INFO_MMAP_VALID
);
369 if ((err
= add_capture_constraints(runtime
)) < 0) {
377 static int snd_card_dummy_playback_close(struct snd_pcm_substream
*substream
)
382 static int snd_card_dummy_capture_close(struct snd_pcm_substream
*substream
)
387 static struct snd_pcm_ops snd_card_dummy_playback_ops
= {
388 .open
= snd_card_dummy_playback_open
,
389 .close
= snd_card_dummy_playback_close
,
390 .ioctl
= snd_pcm_lib_ioctl
,
391 .hw_params
= snd_card_dummy_hw_params
,
392 .hw_free
= snd_card_dummy_hw_free
,
393 .prepare
= snd_card_dummy_pcm_prepare
,
394 .trigger
= snd_card_dummy_pcm_trigger
,
395 .pointer
= snd_card_dummy_pcm_pointer
,
398 static struct snd_pcm_ops snd_card_dummy_capture_ops
= {
399 .open
= snd_card_dummy_capture_open
,
400 .close
= snd_card_dummy_capture_close
,
401 .ioctl
= snd_pcm_lib_ioctl
,
402 .hw_params
= snd_card_dummy_hw_params
,
403 .hw_free
= snd_card_dummy_hw_free
,
404 .prepare
= snd_card_dummy_pcm_prepare
,
405 .trigger
= snd_card_dummy_pcm_trigger
,
406 .pointer
= snd_card_dummy_pcm_pointer
,
409 static int __init
snd_card_dummy_pcm(struct snd_dummy
*dummy
, int device
, int substreams
)
414 if ((err
= snd_pcm_new(dummy
->card
, "Dummy PCM", device
,
415 substreams
, substreams
, &pcm
)) < 0)
418 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_card_dummy_playback_ops
);
419 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_card_dummy_capture_ops
);
420 pcm
->private_data
= dummy
;
422 strcpy(pcm
->name
, "Dummy PCM");
423 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_CONTINUOUS
,
424 snd_dma_continuous_data(GFP_KERNEL
),
429 #define DUMMY_VOLUME(xname, xindex, addr) \
430 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
431 .info = snd_dummy_volume_info, \
432 .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \
433 .private_value = addr }
435 static int snd_dummy_volume_info(struct snd_kcontrol
*kcontrol
,
436 struct snd_ctl_elem_info
*uinfo
)
438 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
440 uinfo
->value
.integer
.min
= -50;
441 uinfo
->value
.integer
.max
= 100;
445 static int snd_dummy_volume_get(struct snd_kcontrol
*kcontrol
,
446 struct snd_ctl_elem_value
*ucontrol
)
448 struct snd_dummy
*dummy
= snd_kcontrol_chip(kcontrol
);
449 int addr
= kcontrol
->private_value
;
451 spin_lock_irq(&dummy
->mixer_lock
);
452 ucontrol
->value
.integer
.value
[0] = dummy
->mixer_volume
[addr
][0];
453 ucontrol
->value
.integer
.value
[1] = dummy
->mixer_volume
[addr
][1];
454 spin_unlock_irq(&dummy
->mixer_lock
);
458 static int snd_dummy_volume_put(struct snd_kcontrol
*kcontrol
,
459 struct snd_ctl_elem_value
*ucontrol
)
461 struct snd_dummy
*dummy
= snd_kcontrol_chip(kcontrol
);
462 int change
, addr
= kcontrol
->private_value
;
465 left
= ucontrol
->value
.integer
.value
[0];
470 right
= ucontrol
->value
.integer
.value
[1];
475 spin_lock_irq(&dummy
->mixer_lock
);
476 change
= dummy
->mixer_volume
[addr
][0] != left
||
477 dummy
->mixer_volume
[addr
][1] != right
;
478 dummy
->mixer_volume
[addr
][0] = left
;
479 dummy
->mixer_volume
[addr
][1] = right
;
480 spin_unlock_irq(&dummy
->mixer_lock
);
484 #define DUMMY_CAPSRC(xname, xindex, addr) \
485 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
486 .info = snd_dummy_capsrc_info, \
487 .get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \
488 .private_value = addr }
490 static int snd_dummy_capsrc_info(struct snd_kcontrol
*kcontrol
,
491 struct snd_ctl_elem_info
*uinfo
)
493 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
495 uinfo
->value
.integer
.min
= 0;
496 uinfo
->value
.integer
.max
= 1;
500 static int snd_dummy_capsrc_get(struct snd_kcontrol
*kcontrol
,
501 struct snd_ctl_elem_value
*ucontrol
)
503 struct snd_dummy
*dummy
= snd_kcontrol_chip(kcontrol
);
504 int addr
= kcontrol
->private_value
;
506 spin_lock_irq(&dummy
->mixer_lock
);
507 ucontrol
->value
.integer
.value
[0] = dummy
->capture_source
[addr
][0];
508 ucontrol
->value
.integer
.value
[1] = dummy
->capture_source
[addr
][1];
509 spin_unlock_irq(&dummy
->mixer_lock
);
513 static int snd_dummy_capsrc_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
515 struct snd_dummy
*dummy
= snd_kcontrol_chip(kcontrol
);
516 int change
, addr
= kcontrol
->private_value
;
519 left
= ucontrol
->value
.integer
.value
[0] & 1;
520 right
= ucontrol
->value
.integer
.value
[1] & 1;
521 spin_lock_irq(&dummy
->mixer_lock
);
522 change
= dummy
->capture_source
[addr
][0] != left
&&
523 dummy
->capture_source
[addr
][1] != right
;
524 dummy
->capture_source
[addr
][0] = left
;
525 dummy
->capture_source
[addr
][1] = right
;
526 spin_unlock_irq(&dummy
->mixer_lock
);
530 static struct snd_kcontrol_new snd_dummy_controls
[] = {
531 DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER
),
532 DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER
),
533 DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH
),
534 DUMMY_CAPSRC("Synth Capture Switch", 0, MIXER_ADDR_MASTER
),
535 DUMMY_VOLUME("Line Volume", 0, MIXER_ADDR_LINE
),
536 DUMMY_CAPSRC("Line Capture Switch", 0, MIXER_ADDR_MASTER
),
537 DUMMY_VOLUME("Mic Volume", 0, MIXER_ADDR_MIC
),
538 DUMMY_CAPSRC("Mic Capture Switch", 0, MIXER_ADDR_MASTER
),
539 DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD
),
540 DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_MASTER
)
543 static int __init
snd_card_dummy_new_mixer(struct snd_dummy
*dummy
)
545 struct snd_card
*card
= dummy
->card
;
549 snd_assert(dummy
!= NULL
, return -EINVAL
);
550 spin_lock_init(&dummy
->mixer_lock
);
551 strcpy(card
->mixername
, "Dummy Mixer");
553 for (idx
= 0; idx
< ARRAY_SIZE(snd_dummy_controls
); idx
++) {
554 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&snd_dummy_controls
[idx
], dummy
))) < 0)
560 static int __init
snd_dummy_probe(struct platform_device
*devptr
)
562 struct snd_card
*card
;
563 struct snd_dummy
*dummy
;
565 int dev
= devptr
->id
;
567 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
,
568 sizeof(struct snd_dummy
));
571 dummy
= card
->private_data
;
573 for (idx
= 0; idx
< MAX_PCM_DEVICES
&& idx
< pcm_devs
[dev
]; idx
++) {
574 if (pcm_substreams
[dev
] < 1)
575 pcm_substreams
[dev
] = 1;
576 if (pcm_substreams
[dev
] > MAX_PCM_SUBSTREAMS
)
577 pcm_substreams
[dev
] = MAX_PCM_SUBSTREAMS
;
578 if ((err
= snd_card_dummy_pcm(dummy
, idx
, pcm_substreams
[dev
])) < 0)
581 if ((err
= snd_card_dummy_new_mixer(dummy
)) < 0)
583 strcpy(card
->driver
, "Dummy");
584 strcpy(card
->shortname
, "Dummy");
585 sprintf(card
->longname
, "Dummy %i", dev
+ 1);
587 snd_card_set_dev(card
, &devptr
->dev
);
589 if ((err
= snd_card_register(card
)) == 0) {
590 platform_set_drvdata(devptr
, card
);
598 static int snd_dummy_remove(struct platform_device
*devptr
)
600 snd_card_free(platform_get_drvdata(devptr
));
601 platform_set_drvdata(devptr
, NULL
);
606 static int snd_dummy_suspend(struct platform_device
*pdev
, pm_message_t state
)
608 struct snd_card
*card
= platform_get_drvdata(pdev
);
609 struct snd_dummy
*dummy
= card
->private_data
;
611 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
612 snd_pcm_suspend_all(dummy
->pcm
);
616 static int snd_dummy_resume(struct platform_device
*pdev
)
618 struct snd_card
*card
= platform_get_drvdata(pdev
);
620 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
625 #define SND_DUMMY_DRIVER "snd_dummy"
627 static struct platform_driver snd_dummy_driver
= {
628 .probe
= snd_dummy_probe
,
629 .remove
= snd_dummy_remove
,
631 .suspend
= snd_dummy_suspend
,
632 .resume
= snd_dummy_resume
,
635 .name
= SND_DUMMY_DRIVER
639 static void __init_or_module
snd_dummy_unregister_all(void)
643 for (i
= 0; i
< ARRAY_SIZE(devices
); ++i
)
644 platform_device_unregister(devices
[i
]);
645 platform_driver_unregister(&snd_dummy_driver
);
648 static int __init
alsa_card_dummy_init(void)
652 if ((err
= platform_driver_register(&snd_dummy_driver
)) < 0)
656 for (i
= 0; i
< SNDRV_CARDS
&& enable
[i
]; i
++) {
657 struct platform_device
*device
;
658 device
= platform_device_register_simple(SND_DUMMY_DRIVER
,
660 if (IS_ERR(device
)) {
661 err
= PTR_ERR(device
);
669 printk(KERN_ERR
"Dummy soundcard not found or device busy\n");
677 snd_dummy_unregister_all();
681 static void __exit
alsa_card_dummy_exit(void)
683 snd_dummy_unregister_all();
686 module_init(alsa_card_dummy_init
)
687 module_exit(alsa_card_dummy_exit
)