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