1/*
2 *  Dummy soundcard
3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 *
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.
9 *
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.
14 *
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
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/hrtimer.h>
29#include <linux/math64.h>
30#include <linux/module.h>
31#include <sound/core.h>
32#include <sound/control.h>
33#include <sound/tlv.h>
34#include <sound/pcm.h>
35#include <sound/rawmidi.h>
36#include <sound/info.h>
37#include <sound/initval.h>
38
39MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
40MODULE_DESCRIPTION("Dummy soundcard (/dev/null)");
41MODULE_LICENSE("GPL");
42MODULE_SUPPORTED_DEVICE("{{ALSA,Dummy soundcard}}");
43
44#define MAX_PCM_DEVICES		4
45#define MAX_PCM_SUBSTREAMS	128
46#define MAX_MIDI_DEVICES	2
47
48/* defaults */
49#define MAX_BUFFER_SIZE		(64*1024)
50#define MIN_PERIOD_SIZE		64
51#define MAX_PERIOD_SIZE		MAX_BUFFER_SIZE
52#define USE_FORMATS 		(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE)
53#define USE_RATE		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000
54#define USE_RATE_MIN		5500
55#define USE_RATE_MAX		48000
56#define USE_CHANNELS_MIN 	1
57#define USE_CHANNELS_MAX 	2
58#define USE_PERIODS_MIN 	1
59#define USE_PERIODS_MAX 	1024
60
61static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;	/* Index 0-MAX */
62static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;	/* ID for this card */
63static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
64static char *model[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = NULL};
65static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
66static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8};
67//static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
68#ifdef CONFIG_HIGH_RES_TIMERS
69static bool hrtimer = 1;
70#endif
71static bool fake_buffer = 1;
72
73module_param_array(index, int, NULL, 0444);
74MODULE_PARM_DESC(index, "Index value for dummy soundcard.");
75module_param_array(id, charp, NULL, 0444);
76MODULE_PARM_DESC(id, "ID string for dummy soundcard.");
77module_param_array(enable, bool, NULL, 0444);
78MODULE_PARM_DESC(enable, "Enable this dummy soundcard.");
79module_param_array(model, charp, NULL, 0444);
80MODULE_PARM_DESC(model, "Soundcard model.");
81module_param_array(pcm_devs, int, NULL, 0444);
82MODULE_PARM_DESC(pcm_devs, "PCM devices # (0-4) for dummy driver.");
83module_param_array(pcm_substreams, int, NULL, 0444);
84MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-128) for dummy driver.");
85//module_param_array(midi_devs, int, NULL, 0444);
86//MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver.");
87module_param(fake_buffer, bool, 0444);
88MODULE_PARM_DESC(fake_buffer, "Fake buffer allocations.");
89#ifdef CONFIG_HIGH_RES_TIMERS
90module_param(hrtimer, bool, 0644);
91MODULE_PARM_DESC(hrtimer, "Use hrtimer as the timer source.");
92#endif
93
94static struct platform_device *devices[SNDRV_CARDS];
95
96#define MIXER_ADDR_MASTER	0
97#define MIXER_ADDR_LINE		1
98#define MIXER_ADDR_MIC		2
99#define MIXER_ADDR_SYNTH	3
100#define MIXER_ADDR_CD		4
101#define MIXER_ADDR_LAST		4
102
103struct dummy_timer_ops {
104	int (*create)(struct snd_pcm_substream *);
105	void (*free)(struct snd_pcm_substream *);
106	int (*prepare)(struct snd_pcm_substream *);
107	int (*start)(struct snd_pcm_substream *);
108	int (*stop)(struct snd_pcm_substream *);
109	snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *);
110};
111
112#define get_dummy_ops(substream) \
113	(*(const struct dummy_timer_ops **)(substream)->runtime->private_data)
114
115struct dummy_model {
116	const char *name;
117	int (*playback_constraints)(struct snd_pcm_runtime *runtime);
118	int (*capture_constraints)(struct snd_pcm_runtime *runtime);
119	u64 formats;
120	size_t buffer_bytes_max;
121	size_t period_bytes_min;
122	size_t period_bytes_max;
123	unsigned int periods_min;
124	unsigned int periods_max;
125	unsigned int rates;
126	unsigned int rate_min;
127	unsigned int rate_max;
128	unsigned int channels_min;
129	unsigned int channels_max;
130};
131
132struct snd_dummy {
133	struct snd_card *card;
134	struct dummy_model *model;
135	struct snd_pcm *pcm;
136	struct snd_pcm_hardware pcm_hw;
137	spinlock_t mixer_lock;
138	int mixer_volume[MIXER_ADDR_LAST+1][2];
139	int capture_source[MIXER_ADDR_LAST+1][2];
140	int iobox;
141	struct snd_kcontrol *cd_volume_ctl;
142	struct snd_kcontrol *cd_switch_ctl;
143};
144
145/*
146 * card models
147 */
148
149static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime)
150{
151	int err;
152	err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
153	if (err < 0)
154		return err;
155	err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 256, UINT_MAX);
156	if (err < 0)
157		return err;
158	return 0;
159}
160
161struct dummy_model model_emu10k1 = {
162	.name = "emu10k1",
163	.playback_constraints = emu10k1_playback_constraints,
164	.buffer_bytes_max = 128 * 1024,
165};
166
167struct dummy_model model_rme9652 = {
168	.name = "rme9652",
169	.buffer_bytes_max = 26 * 64 * 1024,
170	.formats = SNDRV_PCM_FMTBIT_S32_LE,
171	.channels_min = 26,
172	.channels_max = 26,
173	.periods_min = 2,
174	.periods_max = 2,
175};
176
177struct dummy_model model_ice1712 = {
178	.name = "ice1712",
179	.buffer_bytes_max = 256 * 1024,
180	.formats = SNDRV_PCM_FMTBIT_S32_LE,
181	.channels_min = 10,
182	.channels_max = 10,
183	.periods_min = 1,
184	.periods_max = 1024,
185};
186
187struct dummy_model model_uda1341 = {
188	.name = "uda1341",
189	.buffer_bytes_max = 16380,
190	.formats = SNDRV_PCM_FMTBIT_S16_LE,
191	.channels_min = 2,
192	.channels_max = 2,
193	.periods_min = 2,
194	.periods_max = 255,
195};
196
197struct dummy_model model_ac97 = {
198	.name = "ac97",
199	.formats = SNDRV_PCM_FMTBIT_S16_LE,
200	.channels_min = 2,
201	.channels_max = 2,
202	.rates = SNDRV_PCM_RATE_48000,
203	.rate_min = 48000,
204	.rate_max = 48000,
205};
206
207struct dummy_model model_ca0106 = {
208	.name = "ca0106",
209	.formats = SNDRV_PCM_FMTBIT_S16_LE,
210	.buffer_bytes_max = ((65536-64)*8),
211	.period_bytes_max = (65536-64),
212	.periods_min = 2,
213	.periods_max = 8,
214	.channels_min = 2,
215	.channels_max = 2,
216	.rates = SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_96000|SNDRV_PCM_RATE_192000,
217	.rate_min = 48000,
218	.rate_max = 192000,
219};
220
221struct dummy_model *dummy_models[] = {
222	&model_emu10k1,
223	&model_rme9652,
224	&model_ice1712,
225	&model_uda1341,
226	&model_ac97,
227	&model_ca0106,
228	NULL
229};
230
231/*
232 * system timer interface
233 */
234
235struct dummy_systimer_pcm {
236	/* ops must be the first item */
237	const struct dummy_timer_ops *timer_ops;
238	spinlock_t lock;
239	struct timer_list timer;
240	unsigned long base_time;
241	unsigned int frac_pos;	/* fractional sample position (based HZ) */
242	unsigned int frac_period_rest;
243	unsigned int frac_buffer_size;	/* buffer_size * HZ */
244	unsigned int frac_period_size;	/* period_size * HZ */
245	unsigned int rate;
246	int elapsed;
247	struct snd_pcm_substream *substream;
248};
249
250static void dummy_systimer_rearm(struct dummy_systimer_pcm *dpcm)
251{
252	mod_timer(&dpcm->timer, jiffies +
253		(dpcm->frac_period_rest + dpcm->rate - 1) / dpcm->rate);
254}
255
256static void dummy_systimer_update(struct dummy_systimer_pcm *dpcm)
257{
258	unsigned long delta;
259
260	delta = jiffies - dpcm->base_time;
261	if (!delta)
262		return;
263	dpcm->base_time += delta;
264	delta *= dpcm->rate;
265	dpcm->frac_pos += delta;
266	while (dpcm->frac_pos >= dpcm->frac_buffer_size)
267		dpcm->frac_pos -= dpcm->frac_buffer_size;
268	while (dpcm->frac_period_rest <= delta) {
269		dpcm->elapsed++;
270		dpcm->frac_period_rest += dpcm->frac_period_size;
271	}
272	dpcm->frac_period_rest -= delta;
273}
274
275static int dummy_systimer_start(struct snd_pcm_substream *substream)
276{
277	struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
278	spin_lock(&dpcm->lock);
279	dpcm->base_time = jiffies;
280	dummy_systimer_rearm(dpcm);
281	spin_unlock(&dpcm->lock);
282	return 0;
283}
284
285static int dummy_systimer_stop(struct snd_pcm_substream *substream)
286{
287	struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
288	spin_lock(&dpcm->lock);
289	del_timer(&dpcm->timer);
290	spin_unlock(&dpcm->lock);
291	return 0;
292}
293
294static int dummy_systimer_prepare(struct snd_pcm_substream *substream)
295{
296	struct snd_pcm_runtime *runtime = substream->runtime;
297	struct dummy_systimer_pcm *dpcm = runtime->private_data;
298
299	dpcm->frac_pos = 0;
300	dpcm->rate = runtime->rate;
301	dpcm->frac_buffer_size = runtime->buffer_size * HZ;
302	dpcm->frac_period_size = runtime->period_size * HZ;
303	dpcm->frac_period_rest = dpcm->frac_period_size;
304	dpcm->elapsed = 0;
305
306	return 0;
307}
308
309static void dummy_systimer_callback(unsigned long data)
310{
311	struct dummy_systimer_pcm *dpcm = (struct dummy_systimer_pcm *)data;
312	unsigned long flags;
313	int elapsed = 0;
314
315	spin_lock_irqsave(&dpcm->lock, flags);
316	dummy_systimer_update(dpcm);
317	dummy_systimer_rearm(dpcm);
318	elapsed = dpcm->elapsed;
319	dpcm->elapsed = 0;
320	spin_unlock_irqrestore(&dpcm->lock, flags);
321	if (elapsed)
322		snd_pcm_period_elapsed(dpcm->substream);
323}
324
325static snd_pcm_uframes_t
326dummy_systimer_pointer(struct snd_pcm_substream *substream)
327{
328	struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
329	snd_pcm_uframes_t pos;
330
331	spin_lock(&dpcm->lock);
332	dummy_systimer_update(dpcm);
333	pos = dpcm->frac_pos / HZ;
334	spin_unlock(&dpcm->lock);
335	return pos;
336}
337
338static int dummy_systimer_create(struct snd_pcm_substream *substream)
339{
340	struct dummy_systimer_pcm *dpcm;
341
342	dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
343	if (!dpcm)
344		return -ENOMEM;
345	substream->runtime->private_data = dpcm;
346	setup_timer(&dpcm->timer, dummy_systimer_callback,
347			(unsigned long) dpcm);
348	spin_lock_init(&dpcm->lock);
349	dpcm->substream = substream;
350	return 0;
351}
352
353static void dummy_systimer_free(struct snd_pcm_substream *substream)
354{
355	kfree(substream->runtime->private_data);
356}
357
358static struct dummy_timer_ops dummy_systimer_ops = {
359	.create =	dummy_systimer_create,
360	.free =		dummy_systimer_free,
361	.prepare =	dummy_systimer_prepare,
362	.start =	dummy_systimer_start,
363	.stop =		dummy_systimer_stop,
364	.pointer =	dummy_systimer_pointer,
365};
366
367#ifdef CONFIG_HIGH_RES_TIMERS
368/*
369 * hrtimer interface
370 */
371
372struct dummy_hrtimer_pcm {
373	/* ops must be the first item */
374	const struct dummy_timer_ops *timer_ops;
375	ktime_t base_time;
376	ktime_t period_time;
377	atomic_t running;
378	struct hrtimer timer;
379	struct tasklet_struct tasklet;
380	struct snd_pcm_substream *substream;
381};
382
383static void dummy_hrtimer_pcm_elapsed(unsigned long priv)
384{
385	struct dummy_hrtimer_pcm *dpcm = (struct dummy_hrtimer_pcm *)priv;
386	if (atomic_read(&dpcm->running))
387		snd_pcm_period_elapsed(dpcm->substream);
388}
389
390static enum hrtimer_restart dummy_hrtimer_callback(struct hrtimer *timer)
391{
392	struct dummy_hrtimer_pcm *dpcm;
393
394	dpcm = container_of(timer, struct dummy_hrtimer_pcm, timer);
395	if (!atomic_read(&dpcm->running))
396		return HRTIMER_NORESTART;
397	tasklet_schedule(&dpcm->tasklet);
398	hrtimer_forward_now(timer, dpcm->period_time);
399	return HRTIMER_RESTART;
400}
401
402static int dummy_hrtimer_start(struct snd_pcm_substream *substream)
403{
404	struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
405
406	dpcm->base_time = hrtimer_cb_get_time(&dpcm->timer);
407	hrtimer_start(&dpcm->timer, dpcm->period_time, HRTIMER_MODE_REL);
408	atomic_set(&dpcm->running, 1);
409	return 0;
410}
411
412static int dummy_hrtimer_stop(struct snd_pcm_substream *substream)
413{
414	struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
415
416	atomic_set(&dpcm->running, 0);
417	hrtimer_cancel(&dpcm->timer);
418	return 0;
419}
420
421static inline void dummy_hrtimer_sync(struct dummy_hrtimer_pcm *dpcm)
422{
423	tasklet_kill(&dpcm->tasklet);
424}
425
426static snd_pcm_uframes_t
427dummy_hrtimer_pointer(struct snd_pcm_substream *substream)
428{
429	struct snd_pcm_runtime *runtime = substream->runtime;
430	struct dummy_hrtimer_pcm *dpcm = runtime->private_data;
431	u64 delta;
432	u32 pos;
433
434	delta = ktime_us_delta(hrtimer_cb_get_time(&dpcm->timer),
435			       dpcm->base_time);
436	delta = div_u64(delta * runtime->rate + 999999, 1000000);
437	div_u64_rem(delta, runtime->buffer_size, &pos);
438	return pos;
439}
440
441static int dummy_hrtimer_prepare(struct snd_pcm_substream *substream)
442{
443	struct snd_pcm_runtime *runtime = substream->runtime;
444	struct dummy_hrtimer_pcm *dpcm = runtime->private_data;
445	unsigned int period, rate;
446	long sec;
447	unsigned long nsecs;
448
449	dummy_hrtimer_sync(dpcm);
450	period = runtime->period_size;
451	rate = runtime->rate;
452	sec = period / rate;
453	period %= rate;
454	nsecs = div_u64((u64)period * 1000000000UL + rate - 1, rate);
455	dpcm->period_time = ktime_set(sec, nsecs);
456
457	return 0;
458}
459
460static int dummy_hrtimer_create(struct snd_pcm_substream *substream)
461{
462	struct dummy_hrtimer_pcm *dpcm;
463
464	dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
465	if (!dpcm)
466		return -ENOMEM;
467	substream->runtime->private_data = dpcm;
468	hrtimer_init(&dpcm->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
469	dpcm->timer.function = dummy_hrtimer_callback;
470	dpcm->substream = substream;
471	atomic_set(&dpcm->running, 0);
472	tasklet_init(&dpcm->tasklet, dummy_hrtimer_pcm_elapsed,
473		     (unsigned long)dpcm);
474	return 0;
475}
476
477static void dummy_hrtimer_free(struct snd_pcm_substream *substream)
478{
479	struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
480	dummy_hrtimer_sync(dpcm);
481	kfree(dpcm);
482}
483
484static struct dummy_timer_ops dummy_hrtimer_ops = {
485	.create =	dummy_hrtimer_create,
486	.free =		dummy_hrtimer_free,
487	.prepare =	dummy_hrtimer_prepare,
488	.start =	dummy_hrtimer_start,
489	.stop =		dummy_hrtimer_stop,
490	.pointer =	dummy_hrtimer_pointer,
491};
492
493#endif /* CONFIG_HIGH_RES_TIMERS */
494
495/*
496 * PCM interface
497 */
498
499static int dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
500{
501	switch (cmd) {
502	case SNDRV_PCM_TRIGGER_START:
503	case SNDRV_PCM_TRIGGER_RESUME:
504		return get_dummy_ops(substream)->start(substream);
505	case SNDRV_PCM_TRIGGER_STOP:
506	case SNDRV_PCM_TRIGGER_SUSPEND:
507		return get_dummy_ops(substream)->stop(substream);
508	}
509	return -EINVAL;
510}
511
512static int dummy_pcm_prepare(struct snd_pcm_substream *substream)
513{
514	return get_dummy_ops(substream)->prepare(substream);
515}
516
517static snd_pcm_uframes_t dummy_pcm_pointer(struct snd_pcm_substream *substream)
518{
519	return get_dummy_ops(substream)->pointer(substream);
520}
521
522static struct snd_pcm_hardware dummy_pcm_hardware = {
523	.info =			(SNDRV_PCM_INFO_MMAP |
524				 SNDRV_PCM_INFO_INTERLEAVED |
525				 SNDRV_PCM_INFO_RESUME |
526				 SNDRV_PCM_INFO_MMAP_VALID),
527	.formats =		USE_FORMATS,
528	.rates =		USE_RATE,
529	.rate_min =		USE_RATE_MIN,
530	.rate_max =		USE_RATE_MAX,
531	.channels_min =		USE_CHANNELS_MIN,
532	.channels_max =		USE_CHANNELS_MAX,
533	.buffer_bytes_max =	MAX_BUFFER_SIZE,
534	.period_bytes_min =	MIN_PERIOD_SIZE,
535	.period_bytes_max =	MAX_PERIOD_SIZE,
536	.periods_min =		USE_PERIODS_MIN,
537	.periods_max =		USE_PERIODS_MAX,
538	.fifo_size =		0,
539};
540
541static int dummy_pcm_hw_params(struct snd_pcm_substream *substream,
542			       struct snd_pcm_hw_params *hw_params)
543{
544	if (fake_buffer) {
545		/* runtime->dma_bytes has to be set manually to allow mmap */
546		substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
547		return 0;
548	}
549	return snd_pcm_lib_malloc_pages(substream,
550					params_buffer_bytes(hw_params));
551}
552
553static int dummy_pcm_hw_free(struct snd_pcm_substream *substream)
554{
555	if (fake_buffer)
556		return 0;
557	return snd_pcm_lib_free_pages(substream);
558}
559
560static int dummy_pcm_open(struct snd_pcm_substream *substream)
561{
562	struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
563	struct dummy_model *model = dummy->model;
564	struct snd_pcm_runtime *runtime = substream->runtime;
565	const struct dummy_timer_ops *ops;
566	int err;
567
568	ops = &dummy_systimer_ops;
569#ifdef CONFIG_HIGH_RES_TIMERS
570	if (hrtimer)
571		ops = &dummy_hrtimer_ops;
572#endif
573
574	err = ops->create(substream);
575	if (err < 0)
576		return err;
577	get_dummy_ops(substream) = ops;
578
579	runtime->hw = dummy->pcm_hw;
580	if (substream->pcm->device & 1) {
581		runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
582		runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
583	}
584	if (substream->pcm->device & 2)
585		runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP |
586				      SNDRV_PCM_INFO_MMAP_VALID);
587
588	if (model == NULL)
589		return 0;
590
591	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
592		if (model->playback_constraints)
593			err = model->playback_constraints(substream->runtime);
594	} else {
595		if (model->capture_constraints)
596			err = model->capture_constraints(substream->runtime);
597	}
598	if (err < 0) {
599		get_dummy_ops(substream)->free(substream);
600		return err;
601	}
602	return 0;
603}
604
605static int dummy_pcm_close(struct snd_pcm_substream *substream)
606{
607	get_dummy_ops(substream)->free(substream);
608	return 0;
609}
610
611/*
612 * dummy buffer handling
613 */
614
615static void *dummy_page[2];
616
617static void free_fake_buffer(void)
618{
619	if (fake_buffer) {
620		int i;
621		for (i = 0; i < 2; i++)
622			if (dummy_page[i]) {
623				free_page((unsigned long)dummy_page[i]);
624				dummy_page[i] = NULL;
625			}
626	}
627}
628
629static int alloc_fake_buffer(void)
630{
631	int i;
632
633	if (!fake_buffer)
634		return 0;
635	for (i = 0; i < 2; i++) {
636		dummy_page[i] = (void *)get_zeroed_page(GFP_KERNEL);
637		if (!dummy_page[i]) {
638			free_fake_buffer();
639			return -ENOMEM;
640		}
641	}
642	return 0;
643}
644
645static int dummy_pcm_copy(struct snd_pcm_substream *substream,
646			  int channel, snd_pcm_uframes_t pos,
647			  void __user *dst, snd_pcm_uframes_t count)
648{
649	return 0; /* do nothing */
650}
651
652static int dummy_pcm_silence(struct snd_pcm_substream *substream,
653			     int channel, snd_pcm_uframes_t pos,
654			     snd_pcm_uframes_t count)
655{
656	return 0; /* do nothing */
657}
658
659static struct page *dummy_pcm_page(struct snd_pcm_substream *substream,
660				   unsigned long offset)
661{
662	return virt_to_page(dummy_page[substream->stream]); /* the same page */
663}
664
665static struct snd_pcm_ops dummy_pcm_ops = {
666	.open =		dummy_pcm_open,
667	.close =	dummy_pcm_close,
668	.ioctl =	snd_pcm_lib_ioctl,
669	.hw_params =	dummy_pcm_hw_params,
670	.hw_free =	dummy_pcm_hw_free,
671	.prepare =	dummy_pcm_prepare,
672	.trigger =	dummy_pcm_trigger,
673	.pointer =	dummy_pcm_pointer,
674};
675
676static struct snd_pcm_ops dummy_pcm_ops_no_buf = {
677	.open =		dummy_pcm_open,
678	.close =	dummy_pcm_close,
679	.ioctl =	snd_pcm_lib_ioctl,
680	.hw_params =	dummy_pcm_hw_params,
681	.hw_free =	dummy_pcm_hw_free,
682	.prepare =	dummy_pcm_prepare,
683	.trigger =	dummy_pcm_trigger,
684	.pointer =	dummy_pcm_pointer,
685	.copy =		dummy_pcm_copy,
686	.silence =	dummy_pcm_silence,
687	.page =		dummy_pcm_page,
688};
689
690static int snd_card_dummy_pcm(struct snd_dummy *dummy, int device,
691			      int substreams)
692{
693	struct snd_pcm *pcm;
694	struct snd_pcm_ops *ops;
695	int err;
696
697	err = snd_pcm_new(dummy->card, "Dummy PCM", device,
698			       substreams, substreams, &pcm);
699	if (err < 0)
700		return err;
701	dummy->pcm = pcm;
702	if (fake_buffer)
703		ops = &dummy_pcm_ops_no_buf;
704	else
705		ops = &dummy_pcm_ops;
706	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, ops);
707	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, ops);
708	pcm->private_data = dummy;
709	pcm->info_flags = 0;
710	strcpy(pcm->name, "Dummy PCM");
711	if (!fake_buffer) {
712		snd_pcm_lib_preallocate_pages_for_all(pcm,
713			SNDRV_DMA_TYPE_CONTINUOUS,
714			snd_dma_continuous_data(GFP_KERNEL),
715			0, 64*1024);
716	}
717	return 0;
718}
719
720/*
721 * mixer interface
722 */
723
724#define DUMMY_VOLUME(xname, xindex, addr) \
725{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
726  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
727  .name = xname, .index = xindex, \
728  .info = snd_dummy_volume_info, \
729  .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \
730  .private_value = addr, \
731  .tlv = { .p = db_scale_dummy } }
732
733static int snd_dummy_volume_info(struct snd_kcontrol *kcontrol,
734				 struct snd_ctl_elem_info *uinfo)
735{
736	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
737	uinfo->count = 2;
738	uinfo->value.integer.min = -50;
739	uinfo->value.integer.max = 100;
740	return 0;
741}
742
743static int snd_dummy_volume_get(struct snd_kcontrol *kcontrol,
744				struct snd_ctl_elem_value *ucontrol)
745{
746	struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
747	int addr = kcontrol->private_value;
748
749	spin_lock_irq(&dummy->mixer_lock);
750	ucontrol->value.integer.value[0] = dummy->mixer_volume[addr][0];
751	ucontrol->value.integer.value[1] = dummy->mixer_volume[addr][1];
752	spin_unlock_irq(&dummy->mixer_lock);
753	return 0;
754}
755
756static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol,
757				struct snd_ctl_elem_value *ucontrol)
758{
759	struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
760	int change, addr = kcontrol->private_value;
761	int left, right;
762
763	left = ucontrol->value.integer.value[0];
764	if (left < -50)
765		left = -50;
766	if (left > 100)
767		left = 100;
768	right = ucontrol->value.integer.value[1];
769	if (right < -50)
770		right = -50;
771	if (right > 100)
772		right = 100;
773	spin_lock_irq(&dummy->mixer_lock);
774	change = dummy->mixer_volume[addr][0] != left ||
775	         dummy->mixer_volume[addr][1] != right;
776	dummy->mixer_volume[addr][0] = left;
777	dummy->mixer_volume[addr][1] = right;
778	spin_unlock_irq(&dummy->mixer_lock);
779	return change;
780}
781
782static const DECLARE_TLV_DB_SCALE(db_scale_dummy, -4500, 30, 0);
783
784#define DUMMY_CAPSRC(xname, xindex, addr) \
785{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
786  .info = snd_dummy_capsrc_info, \
787  .get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \
788  .private_value = addr }
789
790#define snd_dummy_capsrc_info	snd_ctl_boolean_stereo_info
791
792static int snd_dummy_capsrc_get(struct snd_kcontrol *kcontrol,
793				struct snd_ctl_elem_value *ucontrol)
794{
795	struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
796	int addr = kcontrol->private_value;
797
798	spin_lock_irq(&dummy->mixer_lock);
799	ucontrol->value.integer.value[0] = dummy->capture_source[addr][0];
800	ucontrol->value.integer.value[1] = dummy->capture_source[addr][1];
801	spin_unlock_irq(&dummy->mixer_lock);
802	return 0;
803}
804
805static int snd_dummy_capsrc_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
806{
807	struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
808	int change, addr = kcontrol->private_value;
809	int left, right;
810
811	left = ucontrol->value.integer.value[0] & 1;
812	right = ucontrol->value.integer.value[1] & 1;
813	spin_lock_irq(&dummy->mixer_lock);
814	change = dummy->capture_source[addr][0] != left &&
815	         dummy->capture_source[addr][1] != right;
816	dummy->capture_source[addr][0] = left;
817	dummy->capture_source[addr][1] = right;
818	spin_unlock_irq(&dummy->mixer_lock);
819	return change;
820}
821
822static int snd_dummy_iobox_info(struct snd_kcontrol *kcontrol,
823				struct snd_ctl_elem_info *info)
824{
825	const char *const names[] = { "None", "CD Player" };
826
827	return snd_ctl_enum_info(info, 1, 2, names);
828}
829
830static int snd_dummy_iobox_get(struct snd_kcontrol *kcontrol,
831			       struct snd_ctl_elem_value *value)
832{
833	struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
834
835	value->value.enumerated.item[0] = dummy->iobox;
836	return 0;
837}
838
839static int snd_dummy_iobox_put(struct snd_kcontrol *kcontrol,
840			       struct snd_ctl_elem_value *value)
841{
842	struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
843	int changed;
844
845	if (value->value.enumerated.item[0] > 1)
846		return -EINVAL;
847
848	changed = value->value.enumerated.item[0] != dummy->iobox;
849	if (changed) {
850		dummy->iobox = value->value.enumerated.item[0];
851
852		if (dummy->iobox) {
853			dummy->cd_volume_ctl->vd[0].access &=
854				~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
855			dummy->cd_switch_ctl->vd[0].access &=
856				~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
857		} else {
858			dummy->cd_volume_ctl->vd[0].access |=
859				SNDRV_CTL_ELEM_ACCESS_INACTIVE;
860			dummy->cd_switch_ctl->vd[0].access |=
861				SNDRV_CTL_ELEM_ACCESS_INACTIVE;
862		}
863
864		snd_ctl_notify(dummy->card, SNDRV_CTL_EVENT_MASK_INFO,
865			       &dummy->cd_volume_ctl->id);
866		snd_ctl_notify(dummy->card, SNDRV_CTL_EVENT_MASK_INFO,
867			       &dummy->cd_switch_ctl->id);
868	}
869
870	return changed;
871}
872
873static struct snd_kcontrol_new snd_dummy_controls[] = {
874DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER),
875DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER),
876DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH),
877DUMMY_CAPSRC("Synth Capture Switch", 0, MIXER_ADDR_SYNTH),
878DUMMY_VOLUME("Line Volume", 0, MIXER_ADDR_LINE),
879DUMMY_CAPSRC("Line Capture Switch", 0, MIXER_ADDR_LINE),
880DUMMY_VOLUME("Mic Volume", 0, MIXER_ADDR_MIC),
881DUMMY_CAPSRC("Mic Capture Switch", 0, MIXER_ADDR_MIC),
882DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD),
883DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_CD),
884{
885	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
886	.name  = "External I/O Box",
887	.info  = snd_dummy_iobox_info,
888	.get   = snd_dummy_iobox_get,
889	.put   = snd_dummy_iobox_put,
890},
891};
892
893static int snd_card_dummy_new_mixer(struct snd_dummy *dummy)
894{
895	struct snd_card *card = dummy->card;
896	struct snd_kcontrol *kcontrol;
897	unsigned int idx;
898	int err;
899
900	spin_lock_init(&dummy->mixer_lock);
901	strcpy(card->mixername, "Dummy Mixer");
902	dummy->iobox = 1;
903
904	for (idx = 0; idx < ARRAY_SIZE(snd_dummy_controls); idx++) {
905		kcontrol = snd_ctl_new1(&snd_dummy_controls[idx], dummy);
906		err = snd_ctl_add(card, kcontrol);
907		if (err < 0)
908			return err;
909		if (!strcmp(kcontrol->id.name, "CD Volume"))
910			dummy->cd_volume_ctl = kcontrol;
911		else if (!strcmp(kcontrol->id.name, "CD Capture Switch"))
912			dummy->cd_switch_ctl = kcontrol;
913
914	}
915	return 0;
916}
917
918#if defined(CONFIG_SND_DEBUG) && defined(CONFIG_PROC_FS)
919/*
920 * proc interface
921 */
922static void print_formats(struct snd_dummy *dummy,
923			  struct snd_info_buffer *buffer)
924{
925	int i;
926
927	for (i = 0; i < SNDRV_PCM_FORMAT_LAST; i++) {
928		if (dummy->pcm_hw.formats & (1ULL << i))
929			snd_iprintf(buffer, " %s", snd_pcm_format_name(i));
930	}
931}
932
933static void print_rates(struct snd_dummy *dummy,
934			struct snd_info_buffer *buffer)
935{
936	static int rates[] = {
937		5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
938		64000, 88200, 96000, 176400, 192000,
939	};
940	int i;
941
942	if (dummy->pcm_hw.rates & SNDRV_PCM_RATE_CONTINUOUS)
943		snd_iprintf(buffer, " continuous");
944	if (dummy->pcm_hw.rates & SNDRV_PCM_RATE_KNOT)
945		snd_iprintf(buffer, " knot");
946	for (i = 0; i < ARRAY_SIZE(rates); i++)
947		if (dummy->pcm_hw.rates & (1 << i))
948			snd_iprintf(buffer, " %d", rates[i]);
949}
950
951#define get_dummy_int_ptr(dummy, ofs) \
952	(unsigned int *)((char *)&((dummy)->pcm_hw) + (ofs))
953#define get_dummy_ll_ptr(dummy, ofs) \
954	(unsigned long long *)((char *)&((dummy)->pcm_hw) + (ofs))
955
956struct dummy_hw_field {
957	const char *name;
958	const char *format;
959	unsigned int offset;
960	unsigned int size;
961};
962#define FIELD_ENTRY(item, fmt) {		   \
963	.name = #item,				   \
964	.format = fmt,				   \
965	.offset = offsetof(struct snd_pcm_hardware, item), \
966	.size = sizeof(dummy_pcm_hardware.item) }
967
968static struct dummy_hw_field fields[] = {
969	FIELD_ENTRY(formats, "%#llx"),
970	FIELD_ENTRY(rates, "%#x"),
971	FIELD_ENTRY(rate_min, "%d"),
972	FIELD_ENTRY(rate_max, "%d"),
973	FIELD_ENTRY(channels_min, "%d"),
974	FIELD_ENTRY(channels_max, "%d"),
975	FIELD_ENTRY(buffer_bytes_max, "%ld"),
976	FIELD_ENTRY(period_bytes_min, "%ld"),
977	FIELD_ENTRY(period_bytes_max, "%ld"),
978	FIELD_ENTRY(periods_min, "%d"),
979	FIELD_ENTRY(periods_max, "%d"),
980};
981
982static void dummy_proc_read(struct snd_info_entry *entry,
983			    struct snd_info_buffer *buffer)
984{
985	struct snd_dummy *dummy = entry->private_data;
986	int i;
987
988	for (i = 0; i < ARRAY_SIZE(fields); i++) {
989		snd_iprintf(buffer, "%s ", fields[i].name);
990		if (fields[i].size == sizeof(int))
991			snd_iprintf(buffer, fields[i].format,
992				*get_dummy_int_ptr(dummy, fields[i].offset));
993		else
994			snd_iprintf(buffer, fields[i].format,
995				*get_dummy_ll_ptr(dummy, fields[i].offset));
996		if (!strcmp(fields[i].name, "formats"))
997			print_formats(dummy, buffer);
998		else if (!strcmp(fields[i].name, "rates"))
999			print_rates(dummy, buffer);
1000		snd_iprintf(buffer, "\n");
1001	}
1002}
1003
1004static void dummy_proc_write(struct snd_info_entry *entry,
1005			     struct snd_info_buffer *buffer)
1006{
1007	struct snd_dummy *dummy = entry->private_data;
1008	char line[64];
1009
1010	while (!snd_info_get_line(buffer, line, sizeof(line))) {
1011		char item[20];
1012		const char *ptr;
1013		unsigned long long val;
1014		int i;
1015
1016		ptr = snd_info_get_str(item, line, sizeof(item));
1017		for (i = 0; i < ARRAY_SIZE(fields); i++) {
1018			if (!strcmp(item, fields[i].name))
1019				break;
1020		}
1021		if (i >= ARRAY_SIZE(fields))
1022			continue;
1023		snd_info_get_str(item, ptr, sizeof(item));
1024		if (kstrtoull(item, 0, &val))
1025			continue;
1026		if (fields[i].size == sizeof(int))
1027			*get_dummy_int_ptr(dummy, fields[i].offset) = val;
1028		else
1029			*get_dummy_ll_ptr(dummy, fields[i].offset) = val;
1030	}
1031}
1032
1033static void dummy_proc_init(struct snd_dummy *chip)
1034{
1035	struct snd_info_entry *entry;
1036
1037	if (!snd_card_proc_new(chip->card, "dummy_pcm", &entry)) {
1038		snd_info_set_text_ops(entry, chip, dummy_proc_read);
1039		entry->c.text.write = dummy_proc_write;
1040		entry->mode |= S_IWUSR;
1041		entry->private_data = chip;
1042	}
1043}
1044#else
1045#define dummy_proc_init(x)
1046#endif /* CONFIG_SND_DEBUG && CONFIG_PROC_FS */
1047
1048static int snd_dummy_probe(struct platform_device *devptr)
1049{
1050	struct snd_card *card;
1051	struct snd_dummy *dummy;
1052	struct dummy_model *m = NULL, **mdl;
1053	int idx, err;
1054	int dev = devptr->id;
1055
1056	err = snd_card_new(&devptr->dev, index[dev], id[dev], THIS_MODULE,
1057			   sizeof(struct snd_dummy), &card);
1058	if (err < 0)
1059		return err;
1060	dummy = card->private_data;
1061	dummy->card = card;
1062	for (mdl = dummy_models; *mdl && model[dev]; mdl++) {
1063		if (strcmp(model[dev], (*mdl)->name) == 0) {
1064			printk(KERN_INFO
1065				"snd-dummy: Using model '%s' for card %i\n",
1066				(*mdl)->name, card->number);
1067			m = dummy->model = *mdl;
1068			break;
1069		}
1070	}
1071	for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) {
1072		if (pcm_substreams[dev] < 1)
1073			pcm_substreams[dev] = 1;
1074		if (pcm_substreams[dev] > MAX_PCM_SUBSTREAMS)
1075			pcm_substreams[dev] = MAX_PCM_SUBSTREAMS;
1076		err = snd_card_dummy_pcm(dummy, idx, pcm_substreams[dev]);
1077		if (err < 0)
1078			goto __nodev;
1079	}
1080
1081	dummy->pcm_hw = dummy_pcm_hardware;
1082	if (m) {
1083		if (m->formats)
1084			dummy->pcm_hw.formats = m->formats;
1085		if (m->buffer_bytes_max)
1086			dummy->pcm_hw.buffer_bytes_max = m->buffer_bytes_max;
1087		if (m->period_bytes_min)
1088			dummy->pcm_hw.period_bytes_min = m->period_bytes_min;
1089		if (m->period_bytes_max)
1090			dummy->pcm_hw.period_bytes_max = m->period_bytes_max;
1091		if (m->periods_min)
1092			dummy->pcm_hw.periods_min = m->periods_min;
1093		if (m->periods_max)
1094			dummy->pcm_hw.periods_max = m->periods_max;
1095		if (m->rates)
1096			dummy->pcm_hw.rates = m->rates;
1097		if (m->rate_min)
1098			dummy->pcm_hw.rate_min = m->rate_min;
1099		if (m->rate_max)
1100			dummy->pcm_hw.rate_max = m->rate_max;
1101		if (m->channels_min)
1102			dummy->pcm_hw.channels_min = m->channels_min;
1103		if (m->channels_max)
1104			dummy->pcm_hw.channels_max = m->channels_max;
1105	}
1106
1107	err = snd_card_dummy_new_mixer(dummy);
1108	if (err < 0)
1109		goto __nodev;
1110	strcpy(card->driver, "Dummy");
1111	strcpy(card->shortname, "Dummy");
1112	sprintf(card->longname, "Dummy %i", dev + 1);
1113
1114	dummy_proc_init(dummy);
1115
1116	err = snd_card_register(card);
1117	if (err == 0) {
1118		platform_set_drvdata(devptr, card);
1119		return 0;
1120	}
1121      __nodev:
1122	snd_card_free(card);
1123	return err;
1124}
1125
1126static int snd_dummy_remove(struct platform_device *devptr)
1127{
1128	snd_card_free(platform_get_drvdata(devptr));
1129	return 0;
1130}
1131
1132#ifdef CONFIG_PM_SLEEP
1133static int snd_dummy_suspend(struct device *pdev)
1134{
1135	struct snd_card *card = dev_get_drvdata(pdev);
1136	struct snd_dummy *dummy = card->private_data;
1137
1138	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1139	snd_pcm_suspend_all(dummy->pcm);
1140	return 0;
1141}
1142
1143static int snd_dummy_resume(struct device *pdev)
1144{
1145	struct snd_card *card = dev_get_drvdata(pdev);
1146
1147	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1148	return 0;
1149}
1150
1151static SIMPLE_DEV_PM_OPS(snd_dummy_pm, snd_dummy_suspend, snd_dummy_resume);
1152#define SND_DUMMY_PM_OPS	&snd_dummy_pm
1153#else
1154#define SND_DUMMY_PM_OPS	NULL
1155#endif
1156
1157#define SND_DUMMY_DRIVER	"snd_dummy"
1158
1159static struct platform_driver snd_dummy_driver = {
1160	.probe		= snd_dummy_probe,
1161	.remove		= snd_dummy_remove,
1162	.driver		= {
1163		.name	= SND_DUMMY_DRIVER,
1164		.pm	= SND_DUMMY_PM_OPS,
1165	},
1166};
1167
1168static void snd_dummy_unregister_all(void)
1169{
1170	int i;
1171
1172	for (i = 0; i < ARRAY_SIZE(devices); ++i)
1173		platform_device_unregister(devices[i]);
1174	platform_driver_unregister(&snd_dummy_driver);
1175	free_fake_buffer();
1176}
1177
1178static int __init alsa_card_dummy_init(void)
1179{
1180	int i, cards, err;
1181
1182	err = platform_driver_register(&snd_dummy_driver);
1183	if (err < 0)
1184		return err;
1185
1186	err = alloc_fake_buffer();
1187	if (err < 0) {
1188		platform_driver_unregister(&snd_dummy_driver);
1189		return err;
1190	}
1191
1192	cards = 0;
1193	for (i = 0; i < SNDRV_CARDS; i++) {
1194		struct platform_device *device;
1195		if (! enable[i])
1196			continue;
1197		device = platform_device_register_simple(SND_DUMMY_DRIVER,
1198							 i, NULL, 0);
1199		if (IS_ERR(device))
1200			continue;
1201		if (!platform_get_drvdata(device)) {
1202			platform_device_unregister(device);
1203			continue;
1204		}
1205		devices[i] = device;
1206		cards++;
1207	}
1208	if (!cards) {
1209#ifdef MODULE
1210		printk(KERN_ERR "Dummy soundcard not found or device busy\n");
1211#endif
1212		snd_dummy_unregister_all();
1213		return -ENODEV;
1214	}
1215	return 0;
1216}
1217
1218static void __exit alsa_card_dummy_exit(void)
1219{
1220	snd_dummy_unregister_all();
1221}
1222
1223module_init(alsa_card_dummy_init)
1224module_exit(alsa_card_dummy_exit)
1225