projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-linus' of git://git.infradead.org/~dedekind/ubi-2.6
[deliverable/linux.git] / sound / drivers / dummy.c
CommitLineData
1da177e4
LT		 1/*
2 * Dummy soundcard
c1017a4c 3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
1da177e4
LT		 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
1da177e4 21#include <linux/init.h>
6e65c1cc
TI		 22#include <linux/err.h>
23#include <linux/platform_device.h>
1da177e4
LT		 24#include <linux/jiffies.h>
25#include <linux/slab.h>
26#include <linux/time.h>
27#include <linux/wait.h>
28#include <linux/moduleparam.h>
29#include <sound/core.h>
30#include <sound/control.h>
fb567a8e 31#include <sound/tlv.h>
1da177e4
LT		 32#include <sound/pcm.h>
33#include <sound/rawmidi.h>
34#include <sound/initval.h>
35
c1017a4c 36MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
1da177e4
LT		 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
788c6043
PB		 425static int __devinit snd_card_dummy_pcm(struct snd_dummy *dummy, int device,
426 int substreams)
1da177e4 427{
4a4d2cfd 428 struct snd_pcm *pcm;
1da177e4
LT		 429 int err;
430
4a4d2cfd
TI		 431 if ((err = snd_pcm_new(dummy->card, "Dummy PCM", device,
432 substreams, substreams, &pcm)) < 0)
1da177e4 433 return err;
6e65c1cc 434 dummy->pcm = pcm;
1da177e4
LT		 435 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops);
436 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops);
437 pcm->private_data = dummy;
438 pcm->info_flags = 0;
439 strcpy(pcm->name, "Dummy PCM");
440 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
441 snd_dma_continuous_data(GFP_KERNEL),
442 0, 64*1024);
443 return 0;
444}
445
446#define DUMMY_VOLUME(xname, xindex, addr) \
fb567a8e
TI		 447{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
448 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
449 .name = xname, .index = xindex, \
1da177e4
LT		 450 .info = snd_dummy_volume_info, \
451 .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \
fb567a8e
TI		 452 .private_value = addr, \
453 .tlv = { .p = db_scale_dummy } }
1da177e4 454
4a4d2cfd
TI		 455static int snd_dummy_volume_info(struct snd_kcontrol *kcontrol,
456 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 457{
458 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
459 uinfo->count = 2;
460 uinfo->value.integer.min = -50;
461 uinfo->value.integer.max = 100;
462 return 0;
463}
464
4a4d2cfd
TI		 465static int snd_dummy_volume_get(struct snd_kcontrol *kcontrol,
466 struct snd_ctl_elem_value *ucontrol)
1da177e4 467{
4a4d2cfd 468 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 469 int addr = kcontrol->private_value;
470
c8eb6ba1 471 spin_lock_irq(&dummy->mixer_lock);
1da177e4
LT		 472 ucontrol->value.integer.value[0] = dummy->mixer_volume[addr][0];
473 ucontrol->value.integer.value[1] = dummy->mixer_volume[addr][1];
c8eb6ba1 474 spin_unlock_irq(&dummy->mixer_lock);
1da177e4
LT		 475 return 0;
476}
477
4a4d2cfd
TI		 478static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol,
479 struct snd_ctl_elem_value *ucontrol)
1da177e4 480{
4a4d2cfd 481 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 482 int change, addr = kcontrol->private_value;
483 int left, right;
484
485 left = ucontrol->value.integer.value[0];
486 if (left < -50)
487 left = -50;
488 if (left > 100)
489 left = 100;
490 right = ucontrol->value.integer.value[1];
491 if (right < -50)
492 right = -50;
493 if (right > 100)
494 right = 100;
c8eb6ba1 495 spin_lock_irq(&dummy->mixer_lock);
1da177e4
LT		 496 change = dummy->mixer_volume[addr][0] != left ||
497 dummy->mixer_volume[addr][1] != right;
498 dummy->mixer_volume[addr][0] = left;
499 dummy->mixer_volume[addr][1] = right;
c8eb6ba1 500 spin_unlock_irq(&dummy->mixer_lock);
1da177e4
LT		 501 return change;
502}
503
0cb29ea0 504static const DECLARE_TLV_DB_SCALE(db_scale_dummy, -4500, 30, 0);
fb567a8e 505
1da177e4
LT		 506#define DUMMY_CAPSRC(xname, xindex, addr) \
507{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
508 .info = snd_dummy_capsrc_info, \
509 .get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \
510 .private_value = addr }
511
a5ce8890 512#define snd_dummy_capsrc_info snd_ctl_boolean_stereo_info
1da177e4 513
4a4d2cfd
TI		 514static int snd_dummy_capsrc_get(struct snd_kcontrol *kcontrol,
515 struct snd_ctl_elem_value *ucontrol)
1da177e4 516{
4a4d2cfd 517 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 518 int addr = kcontrol->private_value;
519
c8eb6ba1 520 spin_lock_irq(&dummy->mixer_lock);
1da177e4
LT		 521 ucontrol->value.integer.value[0] = dummy->capture_source[addr][0];
522 ucontrol->value.integer.value[1] = dummy->capture_source[addr][1];
c8eb6ba1 523 spin_unlock_irq(&dummy->mixer_lock);
1da177e4
LT		 524 return 0;
525}
526
4a4d2cfd 527static int snd_dummy_capsrc_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 528{
4a4d2cfd 529 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 530 int change, addr = kcontrol->private_value;
531 int left, right;
532
533 left = ucontrol->value.integer.value[0] & 1;
534 right = ucontrol->value.integer.value[1] & 1;
c8eb6ba1 535 spin_lock_irq(&dummy->mixer_lock);
1da177e4
LT		 536 change = dummy->capture_source[addr][0] != left &&
537 dummy->capture_source[addr][1] != right;
538 dummy->capture_source[addr][0] = left;
539 dummy->capture_source[addr][1] = right;
c8eb6ba1 540 spin_unlock_irq(&dummy->mixer_lock);
1da177e4
LT		 541 return change;
542}
543
4a4d2cfd 544static struct snd_kcontrol_new snd_dummy_controls[] = {
1da177e4
LT		 545DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER),
546DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER),
547DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH),
e05d6964 548DUMMY_CAPSRC("Synth Capture Switch", 0, MIXER_ADDR_SYNTH),
1da177e4 549DUMMY_VOLUME("Line Volume", 0, MIXER_ADDR_LINE),
e05d6964 550DUMMY_CAPSRC("Line Capture Switch", 0, MIXER_ADDR_LINE),
1da177e4 551DUMMY_VOLUME("Mic Volume", 0, MIXER_ADDR_MIC),
e05d6964 552DUMMY_CAPSRC("Mic Capture Switch", 0, MIXER_ADDR_MIC),
1da177e4 553DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD),
e05d6964 554DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_CD)
1da177e4
LT		 555};
556
788c6043 557static int __devinit snd_card_dummy_new_mixer(struct snd_dummy *dummy)
1da177e4 558{
4a4d2cfd 559 struct snd_card *card = dummy->card;
1da177e4
LT		 560 unsigned int idx;
561 int err;
562
563 snd_assert(dummy != NULL, return -EINVAL);
564 spin_lock_init(&dummy->mixer_lock);
565 strcpy(card->mixername, "Dummy Mixer");
566
567 for (idx = 0; idx < ARRAY_SIZE(snd_dummy_controls); idx++) {
568 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_dummy_controls[idx], dummy))) < 0)
569 return err;
570 }
571 return 0;
572}
573
788c6043 574static int __devinit snd_dummy_probe(struct platform_device *devptr)
1da177e4 575{
4a4d2cfd
TI		 576 struct snd_card *card;
577 struct snd_dummy *dummy;
1da177e4 578 int idx, err;
6e65c1cc 579 int dev = devptr->id;
1da177e4 580
1da177e4 581 card = snd_card_new(index[dev], id[dev], THIS_MODULE,
4a4d2cfd 582 sizeof(struct snd_dummy));
1da177e4
LT		 583 if (card == NULL)
584 return -ENOMEM;
4a4d2cfd 585 dummy = card->private_data;
1da177e4
LT		 586 dummy->card = card;
587 for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) {
588 if (pcm_substreams[dev] < 1)
589 pcm_substreams[dev] = 1;
590 if (pcm_substreams[dev] > MAX_PCM_SUBSTREAMS)
591 pcm_substreams[dev] = MAX_PCM_SUBSTREAMS;
592 if ((err = snd_card_dummy_pcm(dummy, idx, pcm_substreams[dev])) < 0)
593 goto __nodev;
594 }
595 if ((err = snd_card_dummy_new_mixer(dummy)) < 0)
596 goto __nodev;
597 strcpy(card->driver, "Dummy");
598 strcpy(card->shortname, "Dummy");
599 sprintf(card->longname, "Dummy %i", dev + 1);
16dab54b 600
6e65c1cc 601 snd_card_set_dev(card, &devptr->dev);
16dab54b 602
1da177e4 603 if ((err = snd_card_register(card)) == 0) {
6e65c1cc 604 platform_set_drvdata(devptr, card);
1da177e4
LT		 605 return 0;
606 }
607 __nodev:
608 snd_card_free(card);
609 return err;
610}
611
788c6043 612static int __devexit snd_dummy_remove(struct platform_device *devptr)
6e65c1cc
TI		 613{
614 snd_card_free(platform_get_drvdata(devptr));
615 platform_set_drvdata(devptr, NULL);
616 return 0;
617}
618
619#ifdef CONFIG_PM
620static int snd_dummy_suspend(struct platform_device *pdev, pm_message_t state)
1da177e4 621{
6e65c1cc
TI		 622 struct snd_card *card = platform_get_drvdata(pdev);
623 struct snd_dummy *dummy = card->private_data;
1da177e4 624
6e65c1cc
TI		 625 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
626 snd_pcm_suspend_all(dummy->pcm);
627 return 0;
628}
629
630static int snd_dummy_resume(struct platform_device *pdev)
631{
632 struct snd_card *card = platform_get_drvdata(pdev);
633
634 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
635 return 0;
636}
637#endif
638
639#define SND_DUMMY_DRIVER "snd_dummy"
640
641static struct platform_driver snd_dummy_driver = {
642 .probe = snd_dummy_probe,
788c6043 643 .remove = __devexit_p(snd_dummy_remove),
6e65c1cc
TI		 644#ifdef CONFIG_PM
645 .suspend = snd_dummy_suspend,
646 .resume = snd_dummy_resume,
1da177e4 647#endif
6e65c1cc
TI		 648 .driver = {
649 .name = SND_DUMMY_DRIVER
650 },
651};
652
c12aad6e 653static void snd_dummy_unregister_all(void)
f7a9275d
CL		 654{
655 int i;
656
657 for (i = 0; i < ARRAY_SIZE(devices); ++i)
658 platform_device_unregister(devices[i]);
659 platform_driver_unregister(&snd_dummy_driver);
660}
661
6e65c1cc
TI		 662static int __init alsa_card_dummy_init(void)
663{
664 int i, cards, err;
665
666 if ((err = platform_driver_register(&snd_dummy_driver)) < 0)
667 return err;
668
669 cards = 0;
8278ca8f 670 for (i = 0; i < SNDRV_CARDS; i++) {
6e65c1cc 671 struct platform_device *device;
8278ca8f
TI		 672 if (! enable[i])
673 continue;
6e65c1cc
TI		 674 device = platform_device_register_simple(SND_DUMMY_DRIVER,
675 i, NULL, 0);
a182ee98
RH		 676 if (IS_ERR(device))
677 continue;
7152447d
RH		 678 if (!platform_get_drvdata(device)) {
679 platform_device_unregister(device);
680 continue;
681 }
f7a9275d 682 devices[i] = device;
1da177e4
LT		 683 cards++;
684 }
685 if (!cards) {
686#ifdef MODULE
687 printk(KERN_ERR "Dummy soundcard not found or device busy\n");
688#endif
a182ee98
RH		 689 snd_dummy_unregister_all();
690 return -ENODEV;
1da177e4
LT		 691 }
692 return 0;
693}
694
695static void __exit alsa_card_dummy_exit(void)
696{
f7a9275d 697 snd_dummy_unregister_all();
1da177e4
LT		 698}
699
700module_init(alsa_card_dummy_init)
701module_exit(alsa_card_dummy_exit)
Linux kernel - Deliverables
This page took 0.527017 seconds and 5 git commands to generate.