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/moduleparam.h> 29 #include <sound/core.h> 30 #include <sound/control.h> 31 #include <sound/tlv.h> 32 #include <sound/pcm.h> 33 #include <sound/rawmidi.h> 34 #include <sound/initval.h> 35 36 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 37 MODULE_DESCRIPTION("Dummy soundcard (/dev/null)"); 38 MODULE_LICENSE("GPL"); 39 MODULE_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) 47 static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime) 48 { 49 int err; 50 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) 51 return err; 52 if ((err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 256, UINT_MAX)) < 0) 53 return err; 54 return 0; 55 } 56 #define add_playback_constraints emu10k1_playback_constraints 57 #endif 58 59 #if 0 /* 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 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 108 109 /* defaults */ 110 #ifndef MAX_BUFFER_SIZE 111 #define MAX_BUFFER_SIZE (64*1024) 112 #endif 113 #ifndef MAX_PERIOD_SIZE 114 #define MAX_PERIOD_SIZE MAX_BUFFER_SIZE 115 #endif 116 #ifndef USE_FORMATS 117 #define USE_FORMATS (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE) 118 #endif 119 #ifndef USE_RATE 120 #define USE_RATE SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000 121 #define USE_RATE_MIN 5500 122 #define USE_RATE_MAX 48000 123 #endif 124 #ifndef USE_CHANNELS_MIN 125 #define USE_CHANNELS_MIN 1 126 #endif 127 #ifndef USE_CHANNELS_MAX 128 #define USE_CHANNELS_MAX 2 129 #endif 130 #ifndef USE_PERIODS_MIN 131 #define USE_PERIODS_MIN 1 132 #endif 133 #ifndef USE_PERIODS_MAX 134 #define USE_PERIODS_MAX 1024 135 #endif 136 #ifndef add_playback_constraints 137 #define add_playback_constraints(x) 0 138 #endif 139 #ifndef add_capture_constraints 140 #define add_capture_constraints(x) 0 141 #endif 142 143 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 144 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 145 static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0}; 146 static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; 147 static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8}; 148 //static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2}; 149 150 module_param_array(index, int, NULL, 0444); 151 MODULE_PARM_DESC(index, "Index value for dummy soundcard."); 152 module_param_array(id, charp, NULL, 0444); 153 MODULE_PARM_DESC(id, "ID string for dummy soundcard."); 154 module_param_array(enable, bool, NULL, 0444); 155 MODULE_PARM_DESC(enable, "Enable this dummy soundcard."); 156 module_param_array(pcm_devs, int, NULL, 0444); 157 MODULE_PARM_DESC(pcm_devs, "PCM devices # (0-4) for dummy driver."); 158 module_param_array(pcm_substreams, int, NULL, 0444); 159 MODULE_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 163 static struct platform_device *devices[SNDRV_CARDS]; 164 165 #define MIXER_ADDR_MASTER 0 166 #define MIXER_ADDR_LINE 1 167 #define MIXER_ADDR_MIC 2 168 #define MIXER_ADDR_SYNTH 3 169 #define MIXER_ADDR_CD 4 170 #define MIXER_ADDR_LAST 4 171 172 struct snd_dummy { 173 struct snd_card *card; 174 struct snd_pcm *pcm; 175 spinlock_t mixer_lock; 176 int mixer_volume[MIXER_ADDR_LAST+1][2]; 177 int capture_source[MIXER_ADDR_LAST+1][2]; 178 }; 179 180 struct snd_dummy_pcm { 181 struct snd_dummy *dummy; 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 */ 190 struct snd_pcm_substream *substream; 191 }; 192 193 194 static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm) 195 { 196 dpcm->timer.expires = 1 + jiffies; 197 add_timer(&dpcm->timer); 198 } 199 200 static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm) 201 { 202 del_timer(&dpcm->timer); 203 } 204 205 static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 206 { 207 struct snd_pcm_runtime *runtime = substream->runtime; 208 struct snd_dummy_pcm *dpcm = runtime->private_data; 209 int err = 0; 210 211 spin_lock(&dpcm->lock); 212 switch (cmd) { 213 case SNDRV_PCM_TRIGGER_START: 214 case SNDRV_PCM_TRIGGER_RESUME: 215 snd_card_dummy_pcm_timer_start(dpcm); 216 break; 217 case SNDRV_PCM_TRIGGER_STOP: 218 case SNDRV_PCM_TRIGGER_SUSPEND: 219 snd_card_dummy_pcm_timer_stop(dpcm); 220 break; 221 default: 222 err = -EINVAL; 223 break; 224 } 225 spin_unlock(&dpcm->lock); 226 return 0; 227 } 228 229 static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream) 230 { 231 struct snd_pcm_runtime *runtime = substream->runtime; 232 struct snd_dummy_pcm *dpcm = runtime->private_data; 233 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 249 static void snd_card_dummy_pcm_timer_function(unsigned long data) 250 { 251 struct snd_dummy_pcm *dpcm = (struct snd_dummy_pcm *)data; 252 unsigned long flags; 253 254 spin_lock_irqsave(&dpcm->lock, flags); 255 dpcm->timer.expires = 1 + jiffies; 256 add_timer(&dpcm->timer); 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; 262 spin_unlock_irqrestore(&dpcm->lock, flags); 263 snd_pcm_period_elapsed(dpcm->substream); 264 } else 265 spin_unlock_irqrestore(&dpcm->lock, flags); 266 } 267 268 static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(struct snd_pcm_substream *substream) 269 { 270 struct snd_pcm_runtime *runtime = substream->runtime; 271 struct snd_dummy_pcm *dpcm = runtime->private_data; 272 273 return bytes_to_frames(runtime, dpcm->pcm_buf_pos); 274 } 275 276 static struct snd_pcm_hardware snd_card_dummy_playback = 277 { 278 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 279 SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), 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, 288 .period_bytes_max = MAX_PERIOD_SIZE, 289 .periods_min = USE_PERIODS_MIN, 290 .periods_max = USE_PERIODS_MAX, 291 .fifo_size = 0, 292 }; 293 294 static struct snd_pcm_hardware snd_card_dummy_capture = 295 { 296 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 297 SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), 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, 306 .period_bytes_max = MAX_PERIOD_SIZE, 307 .periods_min = USE_PERIODS_MIN, 308 .periods_max = USE_PERIODS_MAX, 309 .fifo_size = 0, 310 }; 311 312 static void snd_card_dummy_runtime_free(struct snd_pcm_runtime *runtime) 313 { 314 kfree(runtime->private_data); 315 } 316 317 static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream, 318 struct snd_pcm_hw_params *hw_params) 319 { 320 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); 321 } 322 323 static int snd_card_dummy_hw_free(struct snd_pcm_substream *substream) 324 { 325 return snd_pcm_lib_free_pages(substream); 326 } 327 328 static struct snd_dummy_pcm *new_pcm_stream(struct snd_pcm_substream *substream) 329 { 330 struct snd_dummy_pcm *dpcm; 331 332 dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL); 333 if (! dpcm) 334 return dpcm; 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; 340 return dpcm; 341 } 342 343 static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream) 344 { 345 struct snd_pcm_runtime *runtime = substream->runtime; 346 struct snd_dummy_pcm *dpcm; 347 int err; 348 349 if ((dpcm = new_pcm_stream(substream)) == NULL) 350 return -ENOMEM; 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 368 static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream) 369 { 370 struct snd_pcm_runtime *runtime = substream->runtime; 371 struct snd_dummy_pcm *dpcm; 372 int err; 373 374 if ((dpcm = new_pcm_stream(substream)) == NULL) 375 return -ENOMEM; 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 393 static int snd_card_dummy_playback_close(struct snd_pcm_substream *substream) 394 { 395 return 0; 396 } 397 398 static int snd_card_dummy_capture_close(struct snd_pcm_substream *substream) 399 { 400 return 0; 401 } 402 403 static struct snd_pcm_ops snd_card_dummy_playback_ops = { 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, 409 .prepare = snd_card_dummy_pcm_prepare, 410 .trigger = snd_card_dummy_pcm_trigger, 411 .pointer = snd_card_dummy_pcm_pointer, 412 }; 413 414 static struct snd_pcm_ops snd_card_dummy_capture_ops = { 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, 420 .prepare = snd_card_dummy_pcm_prepare, 421 .trigger = snd_card_dummy_pcm_trigger, 422 .pointer = snd_card_dummy_pcm_pointer, 423 }; 424 425 static int __devinit snd_card_dummy_pcm(struct snd_dummy *dummy, int device, 426 int substreams) 427 { 428 struct snd_pcm *pcm; 429 int err; 430 431 if ((err = snd_pcm_new(dummy->card, "Dummy PCM", device, 432 substreams, substreams, &pcm)) < 0) 433 return err; 434 dummy->pcm = pcm; 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) \ 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, \ 450 .info = snd_dummy_volume_info, \ 451 .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \ 452 .private_value = addr, \ 453 .tlv = { .p = db_scale_dummy } } 454 455 static int snd_dummy_volume_info(struct snd_kcontrol *kcontrol, 456 struct snd_ctl_elem_info *uinfo) 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 465 static int snd_dummy_volume_get(struct snd_kcontrol *kcontrol, 466 struct snd_ctl_elem_value *ucontrol) 467 { 468 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol); 469 int addr = kcontrol->private_value; 470 471 spin_lock_irq(&dummy->mixer_lock); 472 ucontrol->value.integer.value[0] = dummy->mixer_volume[addr][0]; 473 ucontrol->value.integer.value[1] = dummy->mixer_volume[addr][1]; 474 spin_unlock_irq(&dummy->mixer_lock); 475 return 0; 476 } 477 478 static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol, 479 struct snd_ctl_elem_value *ucontrol) 480 { 481 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol); 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; 495 spin_lock_irq(&dummy->mixer_lock); 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; 500 spin_unlock_irq(&dummy->mixer_lock); 501 return change; 502 } 503 504 static const DECLARE_TLV_DB_SCALE(db_scale_dummy, -4500, 30, 0); 505 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 512 #define snd_dummy_capsrc_info snd_ctl_boolean_stereo_info 513 514 static int snd_dummy_capsrc_get(struct snd_kcontrol *kcontrol, 515 struct snd_ctl_elem_value *ucontrol) 516 { 517 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol); 518 int addr = kcontrol->private_value; 519 520 spin_lock_irq(&dummy->mixer_lock); 521 ucontrol->value.integer.value[0] = dummy->capture_source[addr][0]; 522 ucontrol->value.integer.value[1] = dummy->capture_source[addr][1]; 523 spin_unlock_irq(&dummy->mixer_lock); 524 return 0; 525 } 526 527 static int snd_dummy_capsrc_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 528 { 529 struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol); 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; 535 spin_lock_irq(&dummy->mixer_lock); 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; 540 spin_unlock_irq(&dummy->mixer_lock); 541 return change; 542 } 543 544 static struct snd_kcontrol_new snd_dummy_controls[] = { 545 DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER), 546 DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER), 547 DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH), 548 DUMMY_CAPSRC("Synth Capture Switch", 0, MIXER_ADDR_SYNTH), 549 DUMMY_VOLUME("Line Volume", 0, MIXER_ADDR_LINE), 550 DUMMY_CAPSRC("Line Capture Switch", 0, MIXER_ADDR_LINE), 551 DUMMY_VOLUME("Mic Volume", 0, MIXER_ADDR_MIC), 552 DUMMY_CAPSRC("Mic Capture Switch", 0, MIXER_ADDR_MIC), 553 DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD), 554 DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_CD) 555 }; 556 557 static int __devinit snd_card_dummy_new_mixer(struct snd_dummy *dummy) 558 { 559 struct snd_card *card = dummy->card; 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 574 static int __devinit snd_dummy_probe(struct platform_device *devptr) 575 { 576 struct snd_card *card; 577 struct snd_dummy *dummy; 578 int idx, err; 579 int dev = devptr->id; 580 581 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 582 sizeof(struct snd_dummy)); 583 if (card == NULL) 584 return -ENOMEM; 585 dummy = card->private_data; 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); 600 601 snd_card_set_dev(card, &devptr->dev); 602 603 if ((err = snd_card_register(card)) == 0) { 604 platform_set_drvdata(devptr, card); 605 return 0; 606 } 607 __nodev: 608 snd_card_free(card); 609 return err; 610 } 611 612 static int __devexit snd_dummy_remove(struct platform_device *devptr) 613 { 614 snd_card_free(platform_get_drvdata(devptr)); 615 platform_set_drvdata(devptr, NULL); 616 return 0; 617 } 618 619 #ifdef CONFIG_PM 620 static int snd_dummy_suspend(struct platform_device *pdev, pm_message_t state) 621 { 622 struct snd_card *card = platform_get_drvdata(pdev); 623 struct snd_dummy *dummy = card->private_data; 624 625 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 626 snd_pcm_suspend_all(dummy->pcm); 627 return 0; 628 } 629 630 static 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 641 static struct platform_driver snd_dummy_driver = { 642 .probe = snd_dummy_probe, 643 .remove = __devexit_p(snd_dummy_remove), 644 #ifdef CONFIG_PM 645 .suspend = snd_dummy_suspend, 646 .resume = snd_dummy_resume, 647 #endif 648 .driver = { 649 .name = SND_DUMMY_DRIVER 650 }, 651 }; 652 653 static void snd_dummy_unregister_all(void) 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 662 static 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; 670 for (i = 0; i < SNDRV_CARDS; i++) { 671 struct platform_device *device; 672 if (! enable[i]) 673 continue; 674 device = platform_device_register_simple(SND_DUMMY_DRIVER, 675 i, NULL, 0); 676 if (IS_ERR(device)) 677 continue; 678 if (!platform_get_drvdata(device)) { 679 platform_device_unregister(device); 680 continue; 681 } 682 devices[i] = device; 683 cards++; 684 } 685 if (!cards) { 686 #ifdef MODULE 687 printk(KERN_ERR "Dummy soundcard not found or device busy\n"); 688 #endif 689 snd_dummy_unregister_all(); 690 return -ENODEV; 691 } 692 return 0; 693 } 694 695 static void __exit alsa_card_dummy_exit(void) 696 { 697 snd_dummy_unregister_all(); 698 } 699 700 module_init(alsa_card_dummy_init) 701 module_exit(alsa_card_dummy_exit) 702