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