1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/init.h>
22#include <linux/err.h>
23#include <linux/platform_device.h>
24#include <linux/jiffies.h>
25#include <linux/slab.h>
26#include <linux/time.h>
27#include <linux/wait.h>
28#include <linux/moduleparam.h>
29#include <sound/core.h>
30#include <sound/control.h>
31#include <sound/tlv.h>
32#include <sound/pcm.h>
33#include <sound/rawmidi.h>
34#include <sound/initval.h>
35
36MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
37MODULE_DESCRIPTION("Dummy soundcard (/dev/null)");
38MODULE_LICENSE("GPL");
39MODULE_SUPPORTED_DEVICE("{{ALSA,Dummy soundcard}}");
40
41#define MAX_PCM_DEVICES 4
42#define MAX_PCM_SUBSTREAMS 16
43#define MAX_MIDI_DEVICES 2
44
45#if 0
46#define MAX_BUFFER_SIZE (128 * 1024)
47static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime)
48{
49 int err;
50 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
51 return err;
52 if ((err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 256, UINT_MAX)) < 0)
53 return err;
54 return 0;
55}
56#define add_playback_constraints emu10k1_playback_constraints
57#endif
58
59#if 0
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
66#endif
67
68#if 0
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
75#endif
76
77#if 0
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
84#endif
85
86#if 0
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
93#endif
94
95#if 0
96#define USE_FORMATS SNDRV_PCM_FMTBIT_S16_LE
97#define USE_CHANNELS_MIN 2
98#define USE_CHANNELS_MAX 2
99#define USE_RATE (SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_96000|SNDRV_PCM_RATE_192000)
100#define USE_RATE_MIN 48000
101#define USE_RATE_MAX 192000
102#define MAX_BUFFER_SIZE ((65536-64)*8)
103#define MAX_PERIOD_SIZE (65536-64)
104#define USE_PERIODS_MIN 2
105#define USE_PERIODS_MAX 8
106#endif
107
108
109
110#ifndef MAX_BUFFER_SIZE
111#define MAX_BUFFER_SIZE (64*1024)
112#endif
113#ifndef MAX_PERIOD_SIZE
114#define MAX_PERIOD_SIZE MAX_BUFFER_SIZE
115#endif
116#ifndef USE_FORMATS
117#define USE_FORMATS (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE)
118#endif
119#ifndef USE_RATE
120#define USE_RATE SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000
121#define USE_RATE_MIN 5500
122#define USE_RATE_MAX 48000
123#endif
124#ifndef USE_CHANNELS_MIN
125#define USE_CHANNELS_MIN 1
126#endif
127#ifndef USE_CHANNELS_MAX
128#define USE_CHANNELS_MAX 2
129#endif
130#ifndef USE_PERIODS_MIN
131#define USE_PERIODS_MIN 1
132#endif
133#ifndef USE_PERIODS_MAX
134#define USE_PERIODS_MAX 1024
135#endif
136#ifndef add_playback_constraints
137#define add_playback_constraints(x) 0
138#endif
139#ifndef add_capture_constraints
140#define add_capture_constraints(x) 0
141#endif
142
143static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
144static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
145static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
146static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
147static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8};
148
149
150module_param_array(index, int, NULL, 0444);
151MODULE_PARM_DESC(index, "Index value for dummy soundcard.");
152module_param_array(id, charp, NULL, 0444);
153MODULE_PARM_DESC(id, "ID string for dummy soundcard.");
154module_param_array(enable, bool, NULL, 0444);
155MODULE_PARM_DESC(enable, "Enable this dummy soundcard.");
156module_param_array(pcm_devs, int, NULL, 0444);
157MODULE_PARM_DESC(pcm_devs, "PCM devices # (0-4) for dummy driver.");
158module_param_array(pcm_substreams, int, NULL, 0444);
159MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-16) for dummy driver.");
160
161
162
163static struct platform_device *devices[SNDRV_CARDS];
164
165#define MIXER_ADDR_MASTER 0
166#define MIXER_ADDR_LINE 1
167#define MIXER_ADDR_MIC 2
168#define MIXER_ADDR_SYNTH 3
169#define MIXER_ADDR_CD 4
170#define MIXER_ADDR_LAST 4
171
172struct snd_dummy {
173 struct snd_card *card;
174 struct snd_pcm *pcm;
175 spinlock_t mixer_lock;
176 int mixer_volume[MIXER_ADDR_LAST+1][2];
177 int capture_source[MIXER_ADDR_LAST+1][2];
178};
179
180struct snd_dummy_pcm {
181 struct snd_dummy *dummy;
182 spinlock_t lock;
183 struct timer_list timer;
184 unsigned int pcm_buffer_size;
185 unsigned int pcm_period_size;
186 unsigned int pcm_bps;
187 unsigned int pcm_hz;
188 unsigned int pcm_irq_pos;
189 unsigned int pcm_buf_pos;
190 struct snd_pcm_substream *substream;
191};
192
193
194static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm)
195{
196 dpcm->timer.expires = 1 + jiffies;
197 add_timer(&dpcm->timer);
198}
199
200static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm)
201{
202 del_timer(&dpcm->timer);
203}
204
205static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
206{
207 struct snd_pcm_runtime *runtime = substream->runtime;
208 struct snd_dummy_pcm *dpcm = runtime->private_data;
209 int err = 0;
210
211 spin_lock(&dpcm->lock);
212 switch (cmd) {
213 case SNDRV_PCM_TRIGGER_START:
214 case SNDRV_PCM_TRIGGER_RESUME:
215 snd_card_dummy_pcm_timer_start(dpcm);
216 break;
217 case SNDRV_PCM_TRIGGER_STOP:
218 case SNDRV_PCM_TRIGGER_SUSPEND:
219 snd_card_dummy_pcm_timer_stop(dpcm);
220 break;
221 default:
222 err = -EINVAL;
223 break;
224 }
225 spin_unlock(&dpcm->lock);
226 return 0;
227}
228
229static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream)
230{
231 struct snd_pcm_runtime *runtime = substream->runtime;
232 struct snd_dummy_pcm *dpcm = runtime->private_data;
233 int bps;
234
235 bps = snd_pcm_format_width(runtime->format) * runtime->rate *
236 runtime->channels / 8;
237
238 if (bps <= 0)
239 return -EINVAL;
240
241 dpcm->pcm_bps = bps;
242 dpcm->pcm_hz = HZ;
243 dpcm->pcm_buffer_size = snd_pcm_lib_buffer_bytes(substream);
244 dpcm->pcm_period_size = snd_pcm_lib_period_bytes(substream);
245 dpcm->pcm_irq_pos = 0;
246 dpcm->pcm_buf_pos = 0;
247
248 snd_pcm_format_set_silence(runtime->format, runtime->dma_area,
249 bytes_to_samples(runtime, runtime->dma_bytes));
250
251 return 0;
252}
253
254static void snd_card_dummy_pcm_timer_function(unsigned long data)
255{
256 struct snd_dummy_pcm *dpcm = (struct snd_dummy_pcm *)data;
257 unsigned long flags;
258
259 spin_lock_irqsave(&dpcm->lock, flags);
260 dpcm->timer.expires = 1 + jiffies;
261 add_timer(&dpcm->timer);
262 dpcm->pcm_irq_pos += dpcm->pcm_bps;
263 dpcm->pcm_buf_pos += dpcm->pcm_bps;
264 dpcm->pcm_buf_pos %= dpcm->pcm_buffer_size * dpcm->pcm_hz;
265 if (dpcm->pcm_irq_pos >= dpcm->pcm_period_size * dpcm->pcm_hz) {
266 dpcm->pcm_irq_pos %= dpcm->pcm_period_size * dpcm->pcm_hz;
267 spin_unlock_irqrestore(&dpcm->lock, flags);
268 snd_pcm_period_elapsed(dpcm->substream);
269 } else
270 spin_unlock_irqrestore(&dpcm->lock, flags);
271}
272
273static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(struct snd_pcm_substream *substream)
274{
275 struct snd_pcm_runtime *runtime = substream->runtime;
276 struct snd_dummy_pcm *dpcm = runtime->private_data;
277
278 return bytes_to_frames(runtime, dpcm->pcm_buf_pos / dpcm->pcm_hz);
279}
280
281static struct snd_pcm_hardware snd_card_dummy_playback =
282{
283 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
284 SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
285 .formats = USE_FORMATS,
286 .rates = USE_RATE,
287 .rate_min = USE_RATE_MIN,
288 .rate_max = USE_RATE_MAX,
289 .channels_min = USE_CHANNELS_MIN,
290 .channels_max = USE_CHANNELS_MAX,
291 .buffer_bytes_max = MAX_BUFFER_SIZE,
292 .period_bytes_min = 64,
293 .period_bytes_max = MAX_PERIOD_SIZE,
294 .periods_min = USE_PERIODS_MIN,
295 .periods_max = USE_PERIODS_MAX,
296 .fifo_size = 0,
297};
298
299static struct snd_pcm_hardware snd_card_dummy_capture =
300{
301 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
302 SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
303 .formats = USE_FORMATS,
304 .rates = USE_RATE,
305 .rate_min = USE_RATE_MIN,
306 .rate_max = USE_RATE_MAX,
307 .channels_min = USE_CHANNELS_MIN,
308 .channels_max = USE_CHANNELS_MAX,
309 .buffer_bytes_max = MAX_BUFFER_SIZE,
310 .period_bytes_min = 64,
311 .period_bytes_max = MAX_PERIOD_SIZE,
312 .periods_min = USE_PERIODS_MIN,
313 .periods_max = USE_PERIODS_MAX,
314 .fifo_size = 0,
315};
316
317static void snd_card_dummy_runtime_free(struct snd_pcm_runtime *runtime)
318{
319 kfree(runtime->private_data);
320}
321
322static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream,
323 struct snd_pcm_hw_params *hw_params)
324{
325 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
326}
327
328static int snd_card_dummy_hw_free(struct snd_pcm_substream *substream)
329{
330 return snd_pcm_lib_free_pages(substream);
331}
332
333static struct snd_dummy_pcm *new_pcm_stream(struct snd_pcm_substream *substream)
334{
335 struct snd_dummy_pcm *dpcm;
336
337 dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
338 if (! dpcm)
339 return dpcm;
340 init_timer(&dpcm->timer);
341 dpcm->timer.data = (unsigned long) dpcm;
342 dpcm->timer.function = snd_card_dummy_pcm_timer_function;
343 spin_lock_init(&dpcm->lock);
344 dpcm->substream = substream;
345 return dpcm;
346}
347
348static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream)
349{
350 struct snd_pcm_runtime *runtime = substream->runtime;
351 struct snd_dummy_pcm *dpcm;
352 int err;
353
354 if ((dpcm = new_pcm_stream(substream)) == NULL)
355 return -ENOMEM;
356 runtime->private_data = dpcm;
357 runtime->private_free = snd_card_dummy_runtime_free;
358 runtime->hw = snd_card_dummy_playback;
359 if (substream->pcm->device & 1) {
360 runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
361 runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
362 }
363 if (substream->pcm->device & 2)
364 runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
365 if ((err = add_playback_constraints(runtime)) < 0) {
366 kfree(dpcm);
367 return err;
368 }
369
370 return 0;
371}
372
373static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream)
374{
375 struct snd_pcm_runtime *runtime = substream->runtime;
376 struct snd_dummy_pcm *dpcm;
377 int err;
378
379 if ((dpcm = new_pcm_stream(substream)) == NULL)
380 return -ENOMEM;
381 runtime->private_data = dpcm;
382 runtime->private_free = snd_card_dummy_runtime_free;
383 runtime->hw = snd_card_dummy_capture;
384 if (substream->pcm->device == 1) {
385 runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
386 runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
387 }
388 if (substream->pcm->device & 2)
389 runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
390 if ((err = add_capture_constraints(runtime)) < 0) {
391 kfree(dpcm);
392 return err;
393 }
394
395 return 0;
396}
397
398static int snd_card_dummy_playback_close(struct snd_pcm_substream *substream)
399{
400 return 0;
401}
402
403static int snd_card_dummy_capture_close(struct snd_pcm_substream *substream)
404{
405 return 0;
406}
407
408static struct snd_pcm_ops snd_card_dummy_playback_ops = {
409 .open = snd_card_dummy_playback_open,
410 .close = snd_card_dummy_playback_close,
411 .ioctl = snd_pcm_lib_ioctl,
412 .hw_params = snd_card_dummy_hw_params,
413 .hw_free = snd_card_dummy_hw_free,
414 .prepare = snd_card_dummy_pcm_prepare,
415 .trigger = snd_card_dummy_pcm_trigger,
416 .pointer = snd_card_dummy_pcm_pointer,
417};
418
419static struct snd_pcm_ops snd_card_dummy_capture_ops = {
420 .open = snd_card_dummy_capture_open,
421 .close = snd_card_dummy_capture_close,
422 .ioctl = snd_pcm_lib_ioctl,
423 .hw_params = snd_card_dummy_hw_params,
424 .hw_free = snd_card_dummy_hw_free,
425 .prepare = snd_card_dummy_pcm_prepare,
426 .trigger = snd_card_dummy_pcm_trigger,
427 .pointer = snd_card_dummy_pcm_pointer,
428};
429
430static int __devinit snd_card_dummy_pcm(struct snd_dummy *dummy, int device,
431 int substreams)
432{
433 struct snd_pcm *pcm;
434 int err;
435
436 if ((err = snd_pcm_new(dummy->card, "Dummy PCM", device,
437 substreams, substreams, &pcm)) < 0)
438 return err;
439 dummy->pcm = pcm;
440 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops);
441 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops);
442 pcm->private_data = dummy;
443 pcm->info_flags = 0;
444 strcpy(pcm->name, "Dummy PCM");
445 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
446 snd_dma_continuous_data(GFP_KERNEL),
447 0, 64*1024);
448 return 0;
449}
450
451#define DUMMY_VOLUME(xname, xindex, addr) \
452{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
453 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
454 .name = xname, .index = xindex, \
455 .info = snd_dummy_volume_info, \
456 .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \
457 .private_value = addr, \
458 .tlv = { .p = db_scale_dummy } }
459
460static int snd_dummy_volume_info(struct snd_kcontrol *kcontrol,
461 struct snd_ctl_elem_info *uinfo)
462{
463 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
464 uinfo->count = 2;
465 uinfo->value.integer.min = -50;
466 uinfo->value.integer.max = 100;
467 return 0;
468}
469
470static int snd_dummy_volume_get(struct snd_kcontrol *kcontrol,
471 struct snd_ctl_elem_value *ucontrol)
472{
473 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
474 int addr = kcontrol->private_value;
475
476 spin_lock_irq(&dummy->mixer_lock);
477 ucontrol->value.integer.value[0] = dummy->mixer_volume[addr][0];
478 ucontrol->value.integer.value[1] = dummy->mixer_volume[addr][1];
479 spin_unlock_irq(&dummy->mixer_lock);
480 return 0;
481}
482
483static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol,
484 struct snd_ctl_elem_value *ucontrol)
485{
486 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
487 int change, addr = kcontrol->private_value;
488 int left, right;
489
490 left = ucontrol->value.integer.value[0];
491 if (left < -50)
492 left = -50;
493 if (left > 100)
494 left = 100;
495 right = ucontrol->value.integer.value[1];
496 if (right < -50)
497 right = -50;
498 if (right > 100)
499 right = 100;
500 spin_lock_irq(&dummy->mixer_lock);
501 change = dummy->mixer_volume[addr][0] != left ||
502 dummy->mixer_volume[addr][1] != right;
503 dummy->mixer_volume[addr][0] = left;
504 dummy->mixer_volume[addr][1] = right;
505 spin_unlock_irq(&dummy->mixer_lock);
506 return change;
507}
508
509static const DECLARE_TLV_DB_SCALE(db_scale_dummy, -4500, 30, 0);
510
511#define DUMMY_CAPSRC(xname, xindex, addr) \
512{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
513 .info = snd_dummy_capsrc_info, \
514 .get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \
515 .private_value = addr }
516
517#define snd_dummy_capsrc_info snd_ctl_boolean_stereo_info
518
519static int snd_dummy_capsrc_get(struct snd_kcontrol *kcontrol,
520 struct snd_ctl_elem_value *ucontrol)
521{
522 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
523 int addr = kcontrol->private_value;
524
525 spin_lock_irq(&dummy->mixer_lock);
526 ucontrol->value.integer.value[0] = dummy->capture_source[addr][0];
527 ucontrol->value.integer.value[1] = dummy->capture_source[addr][1];
528 spin_unlock_irq(&dummy->mixer_lock);
529 return 0;
530}
531
532static int snd_dummy_capsrc_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
533{
534 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
535 int change, addr = kcontrol->private_value;
536 int left, right;
537
538 left = ucontrol->value.integer.value[0] & 1;
539 right = ucontrol->value.integer.value[1] & 1;
540 spin_lock_irq(&dummy->mixer_lock);
541 change = dummy->capture_source[addr][0] != left &&
542 dummy->capture_source[addr][1] != right;
543 dummy->capture_source[addr][0] = left;
544 dummy->capture_source[addr][1] = right;
545 spin_unlock_irq(&dummy->mixer_lock);
546 return change;
547}
548
549static struct snd_kcontrol_new snd_dummy_controls[] = {
550DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER),
551DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER),
552DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH),
553DUMMY_CAPSRC("Synth Capture Switch", 0, MIXER_ADDR_SYNTH),
554DUMMY_VOLUME("Line Volume", 0, MIXER_ADDR_LINE),
555DUMMY_CAPSRC("Line Capture Switch", 0, MIXER_ADDR_LINE),
556DUMMY_VOLUME("Mic Volume", 0, MIXER_ADDR_MIC),
557DUMMY_CAPSRC("Mic Capture Switch", 0, MIXER_ADDR_MIC),
558DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD),
559DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_CD)
560};
561
562static int __devinit snd_card_dummy_new_mixer(struct snd_dummy *dummy)
563{
564 struct snd_card *card = dummy->card;
565 unsigned int idx;
566 int err;
567
568 snd_assert(dummy != NULL, return -EINVAL);
569 spin_lock_init(&dummy->mixer_lock);
570 strcpy(card->mixername, "Dummy Mixer");
571
572 for (idx = 0; idx < ARRAY_SIZE(snd_dummy_controls); idx++) {
573 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_dummy_controls[idx], dummy))) < 0)
574 return err;
575 }
576 return 0;
577}
578
579static int __devinit snd_dummy_probe(struct platform_device *devptr)
580{
581 struct snd_card *card;
582 struct snd_dummy *dummy;
583 int idx, err;
584 int dev = devptr->id;
585
586 card = snd_card_new(index[dev], id[dev], THIS_MODULE,
587 sizeof(struct snd_dummy));
588 if (card == NULL)
589 return -ENOMEM;
590 dummy = card->private_data;
591 dummy->card = card;
592 for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) {
593 if (pcm_substreams[dev] < 1)
594 pcm_substreams[dev] = 1;
595 if (pcm_substreams[dev] > MAX_PCM_SUBSTREAMS)
596 pcm_substreams[dev] = MAX_PCM_SUBSTREAMS;
597 if ((err = snd_card_dummy_pcm(dummy, idx, pcm_substreams[dev])) < 0)
598 goto __nodev;
599 }
600 if ((err = snd_card_dummy_new_mixer(dummy)) < 0)
601 goto __nodev;
602 strcpy(card->driver, "Dummy");
603 strcpy(card->shortname, "Dummy");
604 sprintf(card->longname, "Dummy %i", dev + 1);
605
606 snd_card_set_dev(card, &devptr->dev);
607
608 if ((err = snd_card_register(card)) == 0) {
609 platform_set_drvdata(devptr, card);
610 return 0;
611 }
612 __nodev:
613 snd_card_free(card);
614 return err;
615}
616
617static int __devexit snd_dummy_remove(struct platform_device *devptr)
618{
619 snd_card_free(platform_get_drvdata(devptr));
620 platform_set_drvdata(devptr, NULL);
621 return 0;
622}
623
624#ifdef CONFIG_PM
625static int snd_dummy_suspend(struct platform_device *pdev, pm_message_t state)
626{
627 struct snd_card *card = platform_get_drvdata(pdev);
628 struct snd_dummy *dummy = card->private_data;
629
630 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
631 snd_pcm_suspend_all(dummy->pcm);
632 return 0;
633}
634
635static int snd_dummy_resume(struct platform_device *pdev)
636{
637 struct snd_card *card = platform_get_drvdata(pdev);
638
639 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
640 return 0;
641}
642#endif
643
644#define SND_DUMMY_DRIVER "snd_dummy"
645
646static struct platform_driver snd_dummy_driver = {
647 .probe = snd_dummy_probe,
648 .remove = __devexit_p(snd_dummy_remove),
649#ifdef CONFIG_PM
650 .suspend = snd_dummy_suspend,
651 .resume = snd_dummy_resume,
652#endif
653 .driver = {
654 .name = SND_DUMMY_DRIVER
655 },
656};
657
658static void snd_dummy_unregister_all(void)
659{
660 int i;
661
662 for (i = 0; i < ARRAY_SIZE(devices); ++i)
663 platform_device_unregister(devices[i]);
664 platform_driver_unregister(&snd_dummy_driver);
665}
666
667static int __init alsa_card_dummy_init(void)
668{
669 int i, cards, err;
670
671 if ((err = platform_driver_register(&snd_dummy_driver)) < 0)
672 return err;
673
674 cards = 0;
675 for (i = 0; i < SNDRV_CARDS; i++) {
676 struct platform_device *device;
677 if (! enable[i])
678 continue;
679 device = platform_device_register_simple(SND_DUMMY_DRIVER,
680 i, NULL, 0);
681 if (IS_ERR(device))
682 continue;
683 if (!platform_get_drvdata(device)) {
684 platform_device_unregister(device);
685 continue;
686 }
687 devices[i] = device;
688 cards++;
689 }
690 if (!cards) {
691#ifdef MODULE
692 printk(KERN_ERR "Dummy soundcard not found or device busy\n");
693#endif
694 snd_dummy_unregister_all();
695 return -ENODEV;
696 }
697 return 0;
698}
699
700static void __exit alsa_card_dummy_exit(void)
701{
702 snd_dummy_unregister_all();
703}
704
705module_init(alsa_card_dummy_init)
706module_exit(alsa_card_dummy_exit)
707
