projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[ALSA] Add dB scale information to trident driver
[linux-2.6-block.git] / sound / drivers / dummy.c
CommitLineData
1da177e4
LT		 1/*
2 * Dummy soundcard
3 * Copyright (c) by Jaroslav Kysela <perex@suse.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 <sound/driver.h>
22#include <linux/init.h>
6e65c1cc
TI		 23#include <linux/err.h>
24#include <linux/platform_device.h>
1da177e4
LT		 25#include <linux/jiffies.h>
26#include <linux/slab.h>
27#include <linux/time.h>
28#include <linux/wait.h>
29#include <linux/moduleparam.h>
30#include <sound/core.h>
31#include <sound/control.h>
32#include <sound/pcm.h>
33#include <sound/rawmidi.h>
34#include <sound/initval.h>
35
36MODULE_AUTHOR("Jaroslav Kysela <perex@suse.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 /* emu10k1 emulation */
46#define MAX_BUFFER_SIZE (128 * 1024)
4a4d2cfd 47static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime)
1da177e4
LT		 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 /* RME9652 emulation */
60#define MAX_BUFFER_SIZE (26 * 64 * 1024)
61#define USE_FORMATS SNDRV_PCM_FMTBIT_S32_LE
62#define USE_CHANNELS_MIN 26
63#define USE_CHANNELS_MAX 26
64#define USE_PERIODS_MIN 2
65#define USE_PERIODS_MAX 2
66#endif
67
68#if 0 /* ICE1712 emulation */
69#define MAX_BUFFER_SIZE (256 * 1024)
70#define USE_FORMATS SNDRV_PCM_FMTBIT_S32_LE
71#define USE_CHANNELS_MIN 10
72#define USE_CHANNELS_MAX 10
73#define USE_PERIODS_MIN 1
74#define USE_PERIODS_MAX 1024
75#endif
76
77#if 0 /* UDA1341 emulation */
78#define MAX_BUFFER_SIZE (16380)
79#define USE_FORMATS SNDRV_PCM_FMTBIT_S16_LE
80#define USE_CHANNELS_MIN 2
81#define USE_CHANNELS_MAX 2
82#define USE_PERIODS_MIN 2
83#define USE_PERIODS_MAX 255
84#endif
85
86#if 0 /* simple AC97 bridge (intel8x0) with 48kHz AC97 only codec */
87#define USE_FORMATS SNDRV_PCM_FMTBIT_S16_LE
88#define USE_CHANNELS_MIN 2
89#define USE_CHANNELS_MAX 2
90#define USE_RATE SNDRV_PCM_RATE_48000
91#define USE_RATE_MIN 48000
92#define USE_RATE_MAX 48000
93#endif
94
2ad5dd8d
JK		 95#if 0 /* CA0106 */
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
1da177e4
LT		 108
109/* defaults */
110#ifndef MAX_BUFFER_SIZE
111#define MAX_BUFFER_SIZE (64*1024)
112#endif
2ad5dd8d
JK		 113#ifndef MAX_PERIOD_SIZE
114#define MAX_PERIOD_SIZE MAX_BUFFER_SIZE
115#endif
1da177e4
LT		 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; /* Index 0-MAX */
144static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
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//static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
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//module_param_array(midi_devs, int, NULL, 0444);
161//MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver.");
162
f7a9275d
CL		 163static struct platform_device *devices[SNDRV_CARDS];
164
1da177e4
LT		 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
4a4d2cfd
TI		 172struct snd_dummy {
173 struct snd_card *card;
6e65c1cc 174 struct snd_pcm *pcm;
1da177e4
LT		 175 spinlock_t mixer_lock;
176 int mixer_volume[MIXER_ADDR_LAST+1][2];
177 int capture_source[MIXER_ADDR_LAST+1][2];
4a4d2cfd 178};
1da177e4 179
4a4d2cfd
TI		 180struct snd_dummy_pcm {
181 struct snd_dummy *dummy;
1da177e4
LT		 182 spinlock_t lock;
183 struct timer_list timer;
184 unsigned int pcm_size;
185 unsigned int pcm_count;
186 unsigned int pcm_bps; /* bytes per second */
187 unsigned int pcm_jiffie; /* bytes per one jiffie */
188 unsigned int pcm_irq_pos; /* IRQ position */
189 unsigned int pcm_buf_pos; /* position in buffer */
4a4d2cfd
TI		 190 struct snd_pcm_substream *substream;
191};
1da177e4 192
1da177e4 193
4a4d2cfd 194static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm)
1da177e4 195{
1da177e4
LT		 196 dpcm->timer.expires = 1 + jiffies;
197 add_timer(&dpcm->timer);
198}
199
4a4d2cfd 200static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm)
1da177e4 201{
1da177e4
LT		 202 del_timer(&dpcm->timer);
203}
204
4a4d2cfd 205static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1da177e4 206{
4a4d2cfd
TI		 207 struct snd_pcm_runtime *runtime = substream->runtime;
208 struct snd_dummy_pcm *dpcm = runtime->private_data;
c8eb6ba1 209 int err = 0;
1da177e4 210
c8eb6ba1 211 spin_lock(&dpcm->lock);
6e65c1cc
TI		 212 switch (cmd) {
213 case SNDRV_PCM_TRIGGER_START:
214 case SNDRV_PCM_TRIGGER_RESUME:
c8eb6ba1 215 snd_card_dummy_pcm_timer_start(dpcm);
6e65c1cc
TI		 216 break;
217 case SNDRV_PCM_TRIGGER_STOP:
218 case SNDRV_PCM_TRIGGER_SUSPEND:
c8eb6ba1 219 snd_card_dummy_pcm_timer_stop(dpcm);
6e65c1cc
TI		 220 break;
221 default:
c8eb6ba1 222 err = -EINVAL;
6e65c1cc 223 break;
1da177e4 224 }
c8eb6ba1 225 spin_unlock(&dpcm->lock);
6e65c1cc 226 return 0;
1da177e4
LT		 227}
228
4a4d2cfd 229static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream)
1da177e4 230{
4a4d2cfd
TI		 231 struct snd_pcm_runtime *runtime = substream->runtime;
232 struct snd_dummy_pcm *dpcm = runtime->private_data;
1da177e4
LT		 233 unsigned int bps;
234
235 bps = runtime->rate * runtime->channels;
236 bps *= snd_pcm_format_width(runtime->format);
237 bps /= 8;
238 if (bps <= 0)
239 return -EINVAL;
240 dpcm->pcm_bps = bps;
241 dpcm->pcm_jiffie = bps / HZ;
242 dpcm->pcm_size = snd_pcm_lib_buffer_bytes(substream);
243 dpcm->pcm_count = snd_pcm_lib_period_bytes(substream);
244 dpcm->pcm_irq_pos = 0;
245 dpcm->pcm_buf_pos = 0;
246 return 0;
247}
248
1da177e4
LT		 249static void snd_card_dummy_pcm_timer_function(unsigned long data)
250{
4a4d2cfd 251 struct snd_dummy_pcm *dpcm = (struct snd_dummy_pcm *)data;
b32425ac 252 unsigned long flags;
1da177e4 253
b32425ac 254 spin_lock_irqsave(&dpcm->lock, flags);
1da177e4
LT		 255 dpcm->timer.expires = 1 + jiffies;
256 add_timer(&dpcm->timer);
1da177e4
LT		 257 dpcm->pcm_irq_pos += dpcm->pcm_jiffie;
258 dpcm->pcm_buf_pos += dpcm->pcm_jiffie;
259 dpcm->pcm_buf_pos %= dpcm->pcm_size;
260 if (dpcm->pcm_irq_pos >= dpcm->pcm_count) {
261 dpcm->pcm_irq_pos %= dpcm->pcm_count;
b32425ac 262 spin_unlock_irqrestore(&dpcm->lock, flags);
1da177e4 263 snd_pcm_period_elapsed(dpcm->substream);
b32425ac
TI		 264 } else
265 spin_unlock_irqrestore(&dpcm->lock, flags);
1da177e4
LT		 266}
267
4a4d2cfd 268static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(struct snd_pcm_substream *substream)
1da177e4 269{
4a4d2cfd
TI		 270 struct snd_pcm_runtime *runtime = substream->runtime;
271 struct snd_dummy_pcm *dpcm = runtime->private_data;
1da177e4
LT		 272
273 return bytes_to_frames(runtime, dpcm->pcm_buf_pos);
274}
275
4a4d2cfd 276static struct snd_pcm_hardware snd_card_dummy_playback =
1da177e4
LT		 277{
278 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
6e65c1cc 279 SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
1da177e4
LT		 280 .formats = USE_FORMATS,
281 .rates = USE_RATE,
282 .rate_min = USE_RATE_MIN,
283 .rate_max = USE_RATE_MAX,
284 .channels_min = USE_CHANNELS_MIN,
285 .channels_max = USE_CHANNELS_MAX,
286 .buffer_bytes_max = MAX_BUFFER_SIZE,
287 .period_bytes_min = 64,
e05d6964 288 .period_bytes_max = MAX_PERIOD_SIZE,
1da177e4
LT		 289 .periods_min = USE_PERIODS_MIN,
290 .periods_max = USE_PERIODS_MAX,
291 .fifo_size = 0,
292};
293
4a4d2cfd 294static struct snd_pcm_hardware snd_card_dummy_capture =
1da177e4
LT		 295{
296 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
6e65c1cc 297 SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
1da177e4
LT		 298 .formats = USE_FORMATS,
299 .rates = USE_RATE,
300 .rate_min = USE_RATE_MIN,
301 .rate_max = USE_RATE_MAX,
302 .channels_min = USE_CHANNELS_MIN,
303 .channels_max = USE_CHANNELS_MAX,
304 .buffer_bytes_max = MAX_BUFFER_SIZE,
305 .period_bytes_min = 64,
2ad5dd8d 306 .period_bytes_max = MAX_PERIOD_SIZE,
1da177e4
LT		 307 .periods_min = USE_PERIODS_MIN,
308 .periods_max = USE_PERIODS_MAX,
309 .fifo_size = 0,
310};
311
4a4d2cfd 312static void snd_card_dummy_runtime_free(struct snd_pcm_runtime *runtime)
1da177e4 313{
c8eb6ba1 314 kfree(runtime->private_data);
1da177e4
LT		 315}
316
4a4d2cfd
TI		 317static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream,
318 struct snd_pcm_hw_params *hw_params)
1da177e4
LT		 319{
320 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
321}
322
4a4d2cfd 323static int snd_card_dummy_hw_free(struct snd_pcm_substream *substream)
1da177e4
LT		 324{
325 return snd_pcm_lib_free_pages(substream);
326}
327
4a4d2cfd 328static struct snd_dummy_pcm *new_pcm_stream(struct snd_pcm_substream *substream)
1da177e4 329{
4a4d2cfd 330 struct snd_dummy_pcm *dpcm;
1da177e4 331
561b220a 332 dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
c8eb6ba1
TI		 333 if (! dpcm)
334 return dpcm;
1da177e4
LT		 335 init_timer(&dpcm->timer);
336 dpcm->timer.data = (unsigned long) dpcm;
337 dpcm->timer.function = snd_card_dummy_pcm_timer_function;
338 spin_lock_init(&dpcm->lock);
339 dpcm->substream = substream;
c8eb6ba1
TI		 340 return dpcm;
341}
342
4a4d2cfd 343static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream)
c8eb6ba1 344{
4a4d2cfd
TI		 345 struct snd_pcm_runtime *runtime = substream->runtime;
346 struct snd_dummy_pcm *dpcm;
c8eb6ba1
TI		 347 int err;
348
349 if ((dpcm = new_pcm_stream(substream)) == NULL)
350 return -ENOMEM;
1da177e4
LT		 351 runtime->private_data = dpcm;
352 runtime->private_free = snd_card_dummy_runtime_free;
353 runtime->hw = snd_card_dummy_playback;
354 if (substream->pcm->device & 1) {
355 runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
356 runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
357 }
358 if (substream->pcm->device & 2)
359 runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
360 if ((err = add_playback_constraints(runtime)) < 0) {
361 kfree(dpcm);
362 return err;
363 }
364
365 return 0;
366}
367
4a4d2cfd 368static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream)
1da177e4 369{
4a4d2cfd
TI		 370 struct snd_pcm_runtime *runtime = substream->runtime;
371 struct snd_dummy_pcm *dpcm;
1da177e4
LT		 372 int err;
373
c8eb6ba1 374 if ((dpcm = new_pcm_stream(substream)) == NULL)
1da177e4 375 return -ENOMEM;
1da177e4
LT		 376 runtime->private_data = dpcm;
377 runtime->private_free = snd_card_dummy_runtime_free;
378 runtime->hw = snd_card_dummy_capture;
379 if (substream->pcm->device == 1) {
380 runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
381 runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
382 }
383 if (substream->pcm->device & 2)
384 runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
385 if ((err = add_capture_constraints(runtime)) < 0) {
386 kfree(dpcm);
387 return err;
388 }
389
390 return 0;
391}
392
4a4d2cfd 393static int snd_card_dummy_playback_close(struct snd_pcm_substream *substream)
1da177e4
LT		 394{
395 return 0;
396}
397
4a4d2cfd 398static int snd_card_dummy_capture_close(struct snd_pcm_substream *substream)
1da177e4
LT		 399{
400 return 0;
401}
402
4a4d2cfd 403static struct snd_pcm_ops snd_card_dummy_playback_ops = {
1da177e4
LT		 404 .open = snd_card_dummy_playback_open,
405 .close = snd_card_dummy_playback_close,
406 .ioctl = snd_pcm_lib_ioctl,
407 .hw_params = snd_card_dummy_hw_params,
408 .hw_free = snd_card_dummy_hw_free,
c8eb6ba1
TI		 409 .prepare = snd_card_dummy_pcm_prepare,
410 .trigger = snd_card_dummy_pcm_trigger,
411 .pointer = snd_card_dummy_pcm_pointer,
1da177e4
LT		 412};
413
4a4d2cfd 414static struct snd_pcm_ops snd_card_dummy_capture_ops = {
1da177e4
LT		 415 .open = snd_card_dummy_capture_open,
416 .close = snd_card_dummy_capture_close,
417 .ioctl = snd_pcm_lib_ioctl,
418 .hw_params = snd_card_dummy_hw_params,
419 .hw_free = snd_card_dummy_hw_free,
c8eb6ba1
TI		 420 .prepare = snd_card_dummy_pcm_prepare,
421 .trigger = snd_card_dummy_pcm_trigger,
422 .pointer = snd_card_dummy_pcm_pointer,
1da177e4
LT		 423};
424
4a4d2cfd 425static int __init snd_card_dummy_pcm(struct snd_dummy *dummy, int device, int substreams)
1da177e4 426{
4a4d2cfd 427 struct snd_pcm *pcm;
1da177e4
LT		 428 int err;
429
4a4d2cfd
TI		 430 if ((err = snd_pcm_new(dummy->card, "Dummy PCM", device,
431 substreams, substreams, &pcm)) < 0)
1da177e4 432 return err;
6e65c1cc 433 dummy->pcm = pcm;
1da177e4
LT		 434 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops);
435 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops);
436 pcm->private_data = dummy;
437 pcm->info_flags = 0;
438 strcpy(pcm->name, "Dummy PCM");
439 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
440 snd_dma_continuous_data(GFP_KERNEL),
441 0, 64*1024);
442 return 0;
443}
444
445#define DUMMY_VOLUME(xname, xindex, addr) \
446{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
447 .info = snd_dummy_volume_info, \
448 .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \
449 .private_value = addr }
450
4a4d2cfd
TI		 451static int snd_dummy_volume_info(struct snd_kcontrol *kcontrol,
452 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 453{
454 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
455 uinfo->count = 2;
456 uinfo->value.integer.min = -50;
457 uinfo->value.integer.max = 100;
458 return 0;
459}
460
4a4d2cfd
TI		 461static int snd_dummy_volume_get(struct snd_kcontrol *kcontrol,
462 struct snd_ctl_elem_value *ucontrol)
1da177e4 463{
4a4d2cfd 464 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 465 int addr = kcontrol->private_value;
466
c8eb6ba1 467 spin_lock_irq(&dummy->mixer_lock);
1da177e4
LT		 468 ucontrol->value.integer.value[0] = dummy->mixer_volume[addr][0];
469 ucontrol->value.integer.value[1] = dummy->mixer_volume[addr][1];
c8eb6ba1 470 spin_unlock_irq(&dummy->mixer_lock);
1da177e4
LT		 471 return 0;
472}
473
4a4d2cfd
TI		 474static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol,
475 struct snd_ctl_elem_value *ucontrol)
1da177e4 476{
4a4d2cfd 477 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 478 int change, addr = kcontrol->private_value;
479 int left, right;
480
481 left = ucontrol->value.integer.value[0];
482 if (left < -50)
483 left = -50;
484 if (left > 100)
485 left = 100;
486 right = ucontrol->value.integer.value[1];
487 if (right < -50)
488 right = -50;
489 if (right > 100)
490 right = 100;
c8eb6ba1 491 spin_lock_irq(&dummy->mixer_lock);
1da177e4
LT		 492 change = dummy->mixer_volume[addr][0] != left ||
493 dummy->mixer_volume[addr][1] != right;
494 dummy->mixer_volume[addr][0] = left;
495 dummy->mixer_volume[addr][1] = right;
c8eb6ba1 496 spin_unlock_irq(&dummy->mixer_lock);
1da177e4
LT		 497 return change;
498}
499
500#define DUMMY_CAPSRC(xname, xindex, addr) \
501{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
502 .info = snd_dummy_capsrc_info, \
503 .get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \
504 .private_value = addr }
505
4a4d2cfd
TI		 506static int snd_dummy_capsrc_info(struct snd_kcontrol *kcontrol,
507 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 508{
509 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
510 uinfo->count = 2;
511 uinfo->value.integer.min = 0;
512 uinfo->value.integer.max = 1;
513 return 0;
514}
515
4a4d2cfd
TI		 516static int snd_dummy_capsrc_get(struct snd_kcontrol *kcontrol,
517 struct snd_ctl_elem_value *ucontrol)
1da177e4 518{
4a4d2cfd 519 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 520 int addr = kcontrol->private_value;
521
c8eb6ba1 522 spin_lock_irq(&dummy->mixer_lock);
1da177e4
LT		 523 ucontrol->value.integer.value[0] = dummy->capture_source[addr][0];
524 ucontrol->value.integer.value[1] = dummy->capture_source[addr][1];
c8eb6ba1 525 spin_unlock_irq(&dummy->mixer_lock);
1da177e4
LT		 526 return 0;
527}
528
4a4d2cfd 529static int snd_dummy_capsrc_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 530{
4a4d2cfd 531 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 532 int change, addr = kcontrol->private_value;
533 int left, right;
534
535 left = ucontrol->value.integer.value[0] & 1;
536 right = ucontrol->value.integer.value[1] & 1;
c8eb6ba1 537 spin_lock_irq(&dummy->mixer_lock);
1da177e4
LT		 538 change = dummy->capture_source[addr][0] != left &&
539 dummy->capture_source[addr][1] != right;
540 dummy->capture_source[addr][0] = left;
541 dummy->capture_source[addr][1] = right;
c8eb6ba1 542 spin_unlock_irq(&dummy->mixer_lock);
1da177e4
LT		 543 return change;
544}
545
4a4d2cfd 546static struct snd_kcontrol_new snd_dummy_controls[] = {
1da177e4
LT		 547DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER),
548DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER),
549DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH),
e05d6964 550DUMMY_CAPSRC("Synth Capture Switch", 0, MIXER_ADDR_SYNTH),
1da177e4 551DUMMY_VOLUME("Line Volume", 0, MIXER_ADDR_LINE),
e05d6964 552DUMMY_CAPSRC("Line Capture Switch", 0, MIXER_ADDR_LINE),
1da177e4 553DUMMY_VOLUME("Mic Volume", 0, MIXER_ADDR_MIC),
e05d6964 554DUMMY_CAPSRC("Mic Capture Switch", 0, MIXER_ADDR_MIC),
1da177e4 555DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD),
e05d6964 556DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_CD)
1da177e4
LT		 557};
558
4a4d2cfd 559static int __init snd_card_dummy_new_mixer(struct snd_dummy *dummy)
1da177e4 560{
4a4d2cfd 561 struct snd_card *card = dummy->card;
1da177e4
LT		 562 unsigned int idx;
563 int err;
564
565 snd_assert(dummy != NULL, return -EINVAL);
566 spin_lock_init(&dummy->mixer_lock);
567 strcpy(card->mixername, "Dummy Mixer");
568
569 for (idx = 0; idx < ARRAY_SIZE(snd_dummy_controls); idx++) {
570 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_dummy_controls[idx], dummy))) < 0)
571 return err;
572 }
573 return 0;
574}
575
6e65c1cc 576static int __init snd_dummy_probe(struct platform_device *devptr)
1da177e4 577{
4a4d2cfd
TI		 578 struct snd_card *card;
579 struct snd_dummy *dummy;
1da177e4 580 int idx, err;
6e65c1cc 581 int dev = devptr->id;
1da177e4 582
1da177e4 583 card = snd_card_new(index[dev], id[dev], THIS_MODULE,
4a4d2cfd 584 sizeof(struct snd_dummy));
1da177e4
LT		 585 if (card == NULL)
586 return -ENOMEM;
4a4d2cfd 587 dummy = card->private_data;
1da177e4
LT		 588 dummy->card = card;
589 for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) {
590 if (pcm_substreams[dev] < 1)
591 pcm_substreams[dev] = 1;
592 if (pcm_substreams[dev] > MAX_PCM_SUBSTREAMS)
593 pcm_substreams[dev] = MAX_PCM_SUBSTREAMS;
594 if ((err = snd_card_dummy_pcm(dummy, idx, pcm_substreams[dev])) < 0)
595 goto __nodev;
596 }
597 if ((err = snd_card_dummy_new_mixer(dummy)) < 0)
598 goto __nodev;
599 strcpy(card->driver, "Dummy");
600 strcpy(card->shortname, "Dummy");
601 sprintf(card->longname, "Dummy %i", dev + 1);
16dab54b 602
6e65c1cc 603 snd_card_set_dev(card, &devptr->dev);
16dab54b 604
1da177e4 605 if ((err = snd_card_register(card)) == 0) {
6e65c1cc 606 platform_set_drvdata(devptr, card);
1da177e4
LT		 607 return 0;
608 }
609 __nodev:
610 snd_card_free(card);
611 return err;
612}
613
6e65c1cc
TI		 614static int snd_dummy_remove(struct platform_device *devptr)
615{
616 snd_card_free(platform_get_drvdata(devptr));
617 platform_set_drvdata(devptr, NULL);
618 return 0;
619}
620
621#ifdef CONFIG_PM
622static int snd_dummy_suspend(struct platform_device *pdev, pm_message_t state)
1da177e4 623{
6e65c1cc
TI		 624 struct snd_card *card = platform_get_drvdata(pdev);
625 struct snd_dummy *dummy = card->private_data;
1da177e4 626
6e65c1cc
TI		 627 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
628 snd_pcm_suspend_all(dummy->pcm);
629 return 0;
630}
631
632static int snd_dummy_resume(struct platform_device *pdev)
633{
634 struct snd_card *card = platform_get_drvdata(pdev);
635
636 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
637 return 0;
638}
639#endif
640
641#define SND_DUMMY_DRIVER "snd_dummy"
642
643static struct platform_driver snd_dummy_driver = {
644 .probe = snd_dummy_probe,
645 .remove = snd_dummy_remove,
646#ifdef CONFIG_PM
647 .suspend = snd_dummy_suspend,
648 .resume = snd_dummy_resume,
1da177e4 649#endif
6e65c1cc
TI		 650 .driver = {
651 .name = SND_DUMMY_DRIVER
652 },
653};
654
f7a9275d
CL		 655static void __init_or_module snd_dummy_unregister_all(void)
656{
657 int i;
658
659 for (i = 0; i < ARRAY_SIZE(devices); ++i)
660 platform_device_unregister(devices[i]);
661 platform_driver_unregister(&snd_dummy_driver);
662}
663
6e65c1cc
TI		 664static int __init alsa_card_dummy_init(void)
665{
666 int i, cards, err;
667
668 if ((err = platform_driver_register(&snd_dummy_driver)) < 0)
669 return err;
670
671 cards = 0;
8278ca8f 672 for (i = 0; i < SNDRV_CARDS; i++) {
6e65c1cc 673 struct platform_device *device;
8278ca8f
TI		 674 if (! enable[i])
675 continue;
6e65c1cc
TI		 676 device = platform_device_register_simple(SND_DUMMY_DRIVER,
677 i, NULL, 0);
a182ee98
RH		 678 if (IS_ERR(device))
679 continue;
7152447d
RH		 680 if (!platform_get_drvdata(device)) {
681 platform_device_unregister(device);
682 continue;
683 }
f7a9275d 684 devices[i] = device;
1da177e4
LT		 685 cards++;
686 }
687 if (!cards) {
688#ifdef MODULE
689 printk(KERN_ERR "Dummy soundcard not found or device busy\n");
690#endif
a182ee98
RH		 691 snd_dummy_unregister_all();
692 return -ENODEV;
1da177e4
LT		 693 }
694 return 0;
695}
696
697static void __exit alsa_card_dummy_exit(void)
698{
f7a9275d 699 snd_dummy_unregister_all();
1da177e4
LT		 700}
701
702module_init(alsa_card_dummy_init)
703module_exit(alsa_card_dummy_exit)
Linux 6.x block layer and io_uring tree(s)