sound/pci/echoaudio/echoaudio.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  ALSA driver for Echoaudio soundcards.
   4  *  Copyright (C) 2003-2004 Giuliano Pochini <pochini@shiny.it>
   5  */
   6
   7 #include <linux/module.h>
   8
   9 MODULE_AUTHOR("Giuliano Pochini <pochini@shiny.it>");
  10 MODULE_LICENSE("GPL v2");
  11 MODULE_DESCRIPTION("Echoaudio " ECHOCARD_NAME " soundcards driver");
  12 MODULE_SUPPORTED_DEVICE("{{Echoaudio," ECHOCARD_NAME "}}");
  13 MODULE_DEVICE_TABLE(pci, snd_echo_ids);
  14
  15 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
  16 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
  17 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  18
  19 module_param_array(index, int, NULL, 0444);
  20 MODULE_PARM_DESC(index, "Index value for " ECHOCARD_NAME " soundcard.");
  21 module_param_array(id, charp, NULL, 0444);
  22 MODULE_PARM_DESC(id, "ID string for " ECHOCARD_NAME " soundcard.");
  23 module_param_array(enable, bool, NULL, 0444);
  24 MODULE_PARM_DESC(enable, "Enable " ECHOCARD_NAME " soundcard.");
  25
  26 static unsigned int channels_list[10] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 999999};
  27 static const DECLARE_TLV_DB_SCALE(db_scale_output_gain, -12800, 100, 1);
  28
  29
  30
  31 static int get_firmware(const struct firmware **fw_entry,
  32                         struct echoaudio *chip, const short fw_index)
  33 {
  34         int err;
  35         char name[30];
  36
  37 #ifdef CONFIG_PM_SLEEP
  38         if (chip->fw_cache[fw_index]) {
  39                 dev_dbg(chip->card->dev,
  40                         "firmware requested: %s is cached\n",
  41                         card_fw[fw_index].data);
  42                 *fw_entry = chip->fw_cache[fw_index];
  43                 return 0;
  44         }
  45 #endif
  46
  47         dev_dbg(chip->card->dev,
  48                 "firmware requested: %s\n", card_fw[fw_index].data);
  49         snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data);
  50         err = request_firmware(fw_entry, name, &chip->pci->dev);
  51         if (err < 0)
  52                 dev_err(chip->card->dev,
  53                         "get_firmware(): Firmware not available (%d)\n", err);
  54 #ifdef CONFIG_PM_SLEEP
  55         else
  56                 chip->fw_cache[fw_index] = *fw_entry;
  57 #endif
  58         return err;
  59 }
  60
  61
  62
  63 static void free_firmware(const struct firmware *fw_entry,
  64                           struct echoaudio *chip)
  65 {
  66 #ifdef CONFIG_PM_SLEEP
  67         dev_dbg(chip->card->dev, "firmware not released (kept in cache)\n");
  68 #else
  69         release_firmware(fw_entry);
  70 #endif
  71 }
  72
  73
  74
  75 static void free_firmware_cache(struct echoaudio *chip)
  76 {
  77 #ifdef CONFIG_PM_SLEEP
  78         int i;
  79
  80         for (i = 0; i < 8 ; i++)
  81                 if (chip->fw_cache[i]) {
  82                         release_firmware(chip->fw_cache[i]);
  83                         dev_dbg(chip->card->dev, "release_firmware(%d)\n", i);
  84                 }
  85
  86 #endif
  87 }
  88
  89
  90
  91 /******************************************************************************
  92         PCM interface
  93 ******************************************************************************/
  94
  95 static void audiopipe_free(struct snd_pcm_runtime *runtime)
  96 {
  97         struct audiopipe *pipe = runtime->private_data;
  98
  99         if (pipe->sgpage.area)
 100                 snd_dma_free_pages(&pipe->sgpage);
 101         kfree(pipe);
 102 }
 103
 104
 105
 106 static int hw_rule_capture_format_by_channels(struct snd_pcm_hw_params *params,
 107                                               struct snd_pcm_hw_rule *rule)
 108 {
 109         struct snd_interval *c = hw_param_interval(params,
 110                                                    SNDRV_PCM_HW_PARAM_CHANNELS);
 111         struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 112         struct snd_mask fmt;
 113
 114         snd_mask_any(&fmt);
 115
 116 #ifndef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 117         /* >=2 channels cannot be S32_BE */
 118         if (c->min == 2) {
 119                 fmt.bits[0] &= ~SNDRV_PCM_FMTBIT_S32_BE;
 120                 return snd_mask_refine(f, &fmt);
 121         }
 122 #endif
 123         /* > 2 channels cannot be U8 and S32_BE */
 124         if (c->min > 2) {
 125                 fmt.bits[0] &= ~(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S32_BE);
 126                 return snd_mask_refine(f, &fmt);
 127         }
 128         /* Mono is ok with any format */
 129         return 0;
 130 }
 131
 132
 133
 134 static int hw_rule_capture_channels_by_format(struct snd_pcm_hw_params *params,
 135                                               struct snd_pcm_hw_rule *rule)
 136 {
 137         struct snd_interval *c = hw_param_interval(params,
 138                                                    SNDRV_PCM_HW_PARAM_CHANNELS);
 139         struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 140         struct snd_interval ch;
 141
 142         snd_interval_any(&ch);
 143
 144         /* S32_BE is mono (and stereo) only */
 145         if (f->bits[0] == SNDRV_PCM_FMTBIT_S32_BE) {
 146                 ch.min = 1;
 147 #ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 148                 ch.max = 2;
 149 #else
 150                 ch.max = 1;
 151 #endif
 152                 ch.integer = 1;
 153                 return snd_interval_refine(c, &ch);
 154         }
 155         /* U8 can be only mono or stereo */
 156         if (f->bits[0] == SNDRV_PCM_FMTBIT_U8) {
 157                 ch.min = 1;
 158                 ch.max = 2;
 159                 ch.integer = 1;
 160                 return snd_interval_refine(c, &ch);
 161         }
 162         /* S16_LE, S24_3LE and S32_LE support any number of channels. */
 163         return 0;
 164 }
 165
 166
 167
 168 static int hw_rule_playback_format_by_channels(struct snd_pcm_hw_params *params,
 169                                                struct snd_pcm_hw_rule *rule)
 170 {
 171         struct snd_interval *c = hw_param_interval(params,
 172                                                    SNDRV_PCM_HW_PARAM_CHANNELS);
 173         struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 174         struct snd_mask fmt;
 175         u64 fmask;
 176         snd_mask_any(&fmt);
 177
 178         fmask = fmt.bits[0] + ((u64)fmt.bits[1] << 32);
 179
 180         /* >2 channels must be S16_LE, S24_3LE or S32_LE */
 181         if (c->min > 2) {
 182                 fmask &= SNDRV_PCM_FMTBIT_S16_LE |
 183                          SNDRV_PCM_FMTBIT_S24_3LE |
 184                          SNDRV_PCM_FMTBIT_S32_LE;
 185         /* 1 channel must be S32_BE or S32_LE */
 186         } else if (c->max == 1)
 187                 fmask &= SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE;
 188 #ifndef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 189         /* 2 channels cannot be S32_BE */
 190         else if (c->min == 2 && c->max == 2)
 191                 fmask &= ~SNDRV_PCM_FMTBIT_S32_BE;
 192 #endif
 193         else
 194                 return 0;
 195
 196         fmt.bits[0] &= (u32)fmask;
 197         fmt.bits[1] &= (u32)(fmask >> 32);
 198         return snd_mask_refine(f, &fmt);
 199 }
 200
 201
 202
 203 static int hw_rule_playback_channels_by_format(struct snd_pcm_hw_params *params,
 204                                                struct snd_pcm_hw_rule *rule)
 205 {
 206         struct snd_interval *c = hw_param_interval(params,
 207                                                    SNDRV_PCM_HW_PARAM_CHANNELS);
 208         struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 209         struct snd_interval ch;
 210         u64 fmask;
 211
 212         snd_interval_any(&ch);
 213         ch.integer = 1;
 214         fmask = f->bits[0] + ((u64)f->bits[1] << 32);
 215
 216         /* S32_BE is mono (and stereo) only */
 217         if (fmask == SNDRV_PCM_FMTBIT_S32_BE) {
 218                 ch.min = 1;
 219 #ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 220                 ch.max = 2;
 221 #else
 222                 ch.max = 1;
 223 #endif
 224         /* U8 is stereo only */
 225         } else if (fmask == SNDRV_PCM_FMTBIT_U8)
 226                 ch.min = ch.max = 2;
 227         /* S16_LE and S24_3LE must be at least stereo */
 228         else if (!(fmask & ~(SNDRV_PCM_FMTBIT_S16_LE |
 229                                SNDRV_PCM_FMTBIT_S24_3LE)))
 230                 ch.min = 2;
 231         else
 232                 return 0;
 233
 234         return snd_interval_refine(c, &ch);
 235 }
 236
 237
 238
 239 /* Since the sample rate is a global setting, do allow the user to change the
 240 sample rate only if there is only one pcm device open. */
 241 static int hw_rule_sample_rate(struct snd_pcm_hw_params *params,
 242                                struct snd_pcm_hw_rule *rule)
 243 {
 244         struct snd_interval *rate = hw_param_interval(params,
 245                                                       SNDRV_PCM_HW_PARAM_RATE);
 246         struct echoaudio *chip = rule->private;
 247         struct snd_interval fixed;
 248
 249         if (!chip->can_set_rate) {
 250                 snd_interval_any(&fixed);
 251                 fixed.min = fixed.max = chip->sample_rate;
 252                 return snd_interval_refine(rate, &fixed);
 253         }
 254         return 0;
 255 }
 256
 257
 258 static int pcm_open(struct snd_pcm_substream *substream,
 259                     signed char max_channels)
 260 {
 261         struct echoaudio *chip;
 262         struct snd_pcm_runtime *runtime;
 263         struct audiopipe *pipe;
 264         int err, i;
 265
 266         if (max_channels <= 0)
 267                 return -EAGAIN;
 268
 269         chip = snd_pcm_substream_chip(substream);
 270         runtime = substream->runtime;
 271
 272         pipe = kzalloc(sizeof(struct audiopipe), GFP_KERNEL);
 273         if (!pipe)
 274                 return -ENOMEM;
 275         pipe->index = -1;               /* Not configured yet */
 276
 277         /* Set up hw capabilities and contraints */
 278         memcpy(&pipe->hw, &pcm_hardware_skel, sizeof(struct snd_pcm_hardware));
 279         dev_dbg(chip->card->dev, "max_channels=%d\n", max_channels);
 280         pipe->constr.list = channels_list;
 281         pipe->constr.mask = 0;
 282         for (i = 0; channels_list[i] <= max_channels; i++);
 283         pipe->constr.count = i;
 284         if (pipe->hw.channels_max > max_channels)
 285                 pipe->hw.channels_max = max_channels;
 286         if (chip->digital_mode == DIGITAL_MODE_ADAT) {
 287                 pipe->hw.rate_max = 48000;
 288                 pipe->hw.rates &= SNDRV_PCM_RATE_8000_48000;
 289         }
 290
 291         runtime->hw = pipe->hw;
 292         runtime->private_data = pipe;
 293         runtime->private_free = audiopipe_free;
 294         snd_pcm_set_sync(substream);
 295
 296         /* Only mono and any even number of channels are allowed */
 297         if ((err = snd_pcm_hw_constraint_list(runtime, 0,
 298                                               SNDRV_PCM_HW_PARAM_CHANNELS,
 299                                               &pipe->constr)) < 0)
 300                 return err;
 301
 302         /* All periods should have the same size */
 303         if ((err = snd_pcm_hw_constraint_integer(runtime,
 304                                                  SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
 305                 return err;
 306
 307         /* The hw accesses memory in chunks 32 frames long and they should be
 308         32-bytes-aligned. It's not a requirement, but it seems that IRQs are
 309         generated with a resolution of 32 frames. Thus we need the following */
 310         if ((err = snd_pcm_hw_constraint_step(runtime, 0,
 311                                               SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
 312                                               32)) < 0)
 313                 return err;
 314         if ((err = snd_pcm_hw_constraint_step(runtime, 0,
 315                                               SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
 316                                               32)) < 0)
 317                 return err;
 318
 319         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 320                                        SNDRV_PCM_HW_PARAM_RATE,
 321                                         hw_rule_sample_rate, chip,
 322                                        SNDRV_PCM_HW_PARAM_RATE, -1)) < 0)
 323                 return err;
 324
 325         /* Finally allocate a page for the scatter-gather list */
 326         if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
 327                                        snd_dma_pci_data(chip->pci),
 328                                        PAGE_SIZE, &pipe->sgpage)) < 0) {
 329                 dev_err(chip->card->dev, "s-g list allocation failed\n");
 330                 return err;
 331         }
 332
 333         return 0;
 334 }
 335
 336
 337
 338 static int pcm_analog_in_open(struct snd_pcm_substream *substream)
 339 {
 340         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 341         int err;
 342
 343         if ((err = pcm_open(substream, num_analog_busses_in(chip) -
 344                             substream->number)) < 0)
 345                 return err;
 346         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 347                                        SNDRV_PCM_HW_PARAM_CHANNELS,
 348                                        hw_rule_capture_channels_by_format, NULL,
 349                                        SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
 350                 return err;
 351         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 352                                        SNDRV_PCM_HW_PARAM_FORMAT,
 353                                        hw_rule_capture_format_by_channels, NULL,
 354                                        SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
 355                 return err;
 356         atomic_inc(&chip->opencount);
 357         if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
 358                 chip->can_set_rate=0;
 359         dev_dbg(chip->card->dev, "pcm_analog_in_open  cs=%d  oc=%d  r=%d\n",
 360                 chip->can_set_rate, atomic_read(&chip->opencount),
 361                 chip->sample_rate);
 362         return 0;
 363 }
 364
 365
 366
 367 static int pcm_analog_out_open(struct snd_pcm_substream *substream)
 368 {
 369         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 370         int max_channels, err;
 371
 372 #ifdef ECHOCARD_HAS_VMIXER
 373         max_channels = num_pipes_out(chip);
 374 #else
 375         max_channels = num_analog_busses_out(chip);
 376 #endif
 377         if ((err = pcm_open(substream, max_channels - substream->number)) < 0)
 378                 return err;
 379         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 380                                        SNDRV_PCM_HW_PARAM_CHANNELS,
 381                                        hw_rule_playback_channels_by_format,
 382                                        NULL,
 383                                        SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
 384                 return err;
 385         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 386                                        SNDRV_PCM_HW_PARAM_FORMAT,
 387                                        hw_rule_playback_format_by_channels,
 388                                        NULL,
 389                                        SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
 390                 return err;
 391         atomic_inc(&chip->opencount);
 392         if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
 393                 chip->can_set_rate=0;
 394         dev_dbg(chip->card->dev, "pcm_analog_out_open  cs=%d  oc=%d  r=%d\n",
 395                 chip->can_set_rate, atomic_read(&chip->opencount),
 396                 chip->sample_rate);
 397         return 0;
 398 }
 399
 400
 401
 402 #ifdef ECHOCARD_HAS_DIGITAL_IO
 403
 404 static int pcm_digital_in_open(struct snd_pcm_substream *substream)
 405 {
 406         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 407         int err, max_channels;
 408
 409         max_channels = num_digital_busses_in(chip) - substream->number;
 410         mutex_lock(&chip->mode_mutex);
 411         if (chip->digital_mode == DIGITAL_MODE_ADAT)
 412                 err = pcm_open(substream, max_channels);
 413         else    /* If the card has ADAT, subtract the 6 channels
 414                  * that S/PDIF doesn't have
 415                  */
 416                 err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
 417
 418         if (err < 0)
 419                 goto din_exit;
 420
 421         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 422                                        SNDRV_PCM_HW_PARAM_CHANNELS,
 423                                        hw_rule_capture_channels_by_format, NULL,
 424                                        SNDRV_PCM_HW_PARAM_FORMAT, -1)) < 0)
 425                 goto din_exit;
 426         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 427                                        SNDRV_PCM_HW_PARAM_FORMAT,
 428                                        hw_rule_capture_format_by_channels, NULL,
 429                                        SNDRV_PCM_HW_PARAM_CHANNELS, -1)) < 0)
 430                 goto din_exit;
 431
 432         atomic_inc(&chip->opencount);
 433         if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
 434                 chip->can_set_rate=0;
 435
 436 din_exit:
 437         mutex_unlock(&chip->mode_mutex);
 438         return err;
 439 }
 440
 441
 442
 443 #ifndef ECHOCARD_HAS_VMIXER     /* See the note in snd_echo_new_pcm() */
 444
 445 static int pcm_digital_out_open(struct snd_pcm_substream *substream)
 446 {
 447         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 448         int err, max_channels;
 449
 450         max_channels = num_digital_busses_out(chip) - substream->number;
 451         mutex_lock(&chip->mode_mutex);
 452         if (chip->digital_mode == DIGITAL_MODE_ADAT)
 453                 err = pcm_open(substream, max_channels);
 454         else    /* If the card has ADAT, subtract the 6 channels
 455                  * that S/PDIF doesn't have
 456                  */
 457                 err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
 458
 459         if (err < 0)
 460                 goto dout_exit;
 461
 462         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 463                                        SNDRV_PCM_HW_PARAM_CHANNELS,
 464                                        hw_rule_playback_channels_by_format,
 465                                        NULL, SNDRV_PCM_HW_PARAM_FORMAT,
 466                                        -1)) < 0)
 467                 goto dout_exit;
 468         if ((err = snd_pcm_hw_rule_add(substream->runtime, 0,
 469                                        SNDRV_PCM_HW_PARAM_FORMAT,
 470                                        hw_rule_playback_format_by_channels,
 471                                        NULL, SNDRV_PCM_HW_PARAM_CHANNELS,
 472                                        -1)) < 0)
 473                 goto dout_exit;
 474         atomic_inc(&chip->opencount);
 475         if (atomic_read(&chip->opencount) > 1 && chip->rate_set)
 476                 chip->can_set_rate=0;
 477 dout_exit:
 478         mutex_unlock(&chip->mode_mutex);
 479         return err;
 480 }
 481
 482 #endif /* !ECHOCARD_HAS_VMIXER */
 483
 484 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 485
 486
 487
 488 static int pcm_close(struct snd_pcm_substream *substream)
 489 {
 490         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 491         int oc;
 492
 493         /* Nothing to do here. Audio is already off and pipe will be
 494          * freed by its callback
 495          */
 496
 497         atomic_dec(&chip->opencount);
 498         oc = atomic_read(&chip->opencount);
 499         dev_dbg(chip->card->dev, "pcm_close  oc=%d  cs=%d  rs=%d\n", oc,
 500                 chip->can_set_rate, chip->rate_set);
 501         if (oc < 2)
 502                 chip->can_set_rate = 1;
 503         if (oc == 0)
 504                 chip->rate_set = 0;
 505         dev_dbg(chip->card->dev, "pcm_close2 oc=%d  cs=%d  rs=%d\n", oc,
 506                 chip->can_set_rate, chip->rate_set);
 507
 508         return 0;
 509 }
 510
 511
 512
 513 /* Channel allocation and scatter-gather list setup */
 514 static int init_engine(struct snd_pcm_substream *substream,
 515                        struct snd_pcm_hw_params *hw_params,
 516                        int pipe_index, int interleave)
 517 {
 518         struct echoaudio *chip;
 519         int err, per, rest, page, edge, offs;
 520         struct audiopipe *pipe;
 521
 522         chip = snd_pcm_substream_chip(substream);
 523         pipe = (struct audiopipe *) substream->runtime->private_data;
 524
 525         /* Sets up che hardware. If it's already initialized, reset and
 526          * redo with the new parameters
 527          */
 528         spin_lock_irq(&chip->lock);
 529         if (pipe->index >= 0) {
 530                 dev_dbg(chip->card->dev, "hwp_ie free(%d)\n", pipe->index);
 531                 err = free_pipes(chip, pipe);
 532                 snd_BUG_ON(err);
 533                 chip->substream[pipe->index] = NULL;
 534         }
 535
 536         err = allocate_pipes(chip, pipe, pipe_index, interleave);
 537         if (err < 0) {
 538                 spin_unlock_irq(&chip->lock);
 539                 dev_err(chip->card->dev, "allocate_pipes(%d) err=%d\n",
 540                         pipe_index, err);
 541                 return err;
 542         }
 543         spin_unlock_irq(&chip->lock);
 544         dev_dbg(chip->card->dev, "allocate_pipes()=%d\n", pipe_index);
 545
 546         dev_dbg(chip->card->dev,
 547                 "pcm_hw_params (bufsize=%dB periods=%d persize=%dB)\n",
 548                 params_buffer_bytes(hw_params), params_periods(hw_params),
 549                 params_period_bytes(hw_params));
 550         err = snd_pcm_lib_malloc_pages(substream,
 551                                        params_buffer_bytes(hw_params));
 552         if (err < 0) {
 553                 dev_err(chip->card->dev, "malloc_pages err=%d\n", err);
 554                 spin_lock_irq(&chip->lock);
 555                 free_pipes(chip, pipe);
 556                 spin_unlock_irq(&chip->lock);
 557                 pipe->index = -1;
 558                 return err;
 559         }
 560
 561         sglist_init(chip, pipe);
 562         edge = PAGE_SIZE;
 563         for (offs = page = per = 0; offs < params_buffer_bytes(hw_params);
 564              per++) {
 565                 rest = params_period_bytes(hw_params);
 566                 if (offs + rest > params_buffer_bytes(hw_params))
 567                         rest = params_buffer_bytes(hw_params) - offs;
 568                 while (rest) {
 569                         dma_addr_t addr;
 570                         addr = snd_pcm_sgbuf_get_addr(substream, offs);
 571                         if (rest <= edge - offs) {
 572                                 sglist_add_mapping(chip, pipe, addr, rest);
 573                                 sglist_add_irq(chip, pipe);
 574                                 offs += rest;
 575                                 rest = 0;
 576                         } else {
 577                                 sglist_add_mapping(chip, pipe, addr,
 578                                                    edge - offs);
 579                                 rest -= edge - offs;
 580                                 offs = edge;
 581                         }
 582                         if (offs == edge) {
 583                                 edge += PAGE_SIZE;
 584                                 page++;
 585                         }
 586                 }
 587         }
 588
 589         /* Close the ring buffer */
 590         sglist_wrap(chip, pipe);
 591
 592         /* This stuff is used by the irq handler, so it must be
 593          * initialized before chip->substream
 594          */
 595         chip->last_period[pipe_index] = 0;
 596         pipe->last_counter = 0;
 597         pipe->position = 0;
 598         smp_wmb();
 599         chip->substream[pipe_index] = substream;
 600         chip->rate_set = 1;
 601         spin_lock_irq(&chip->lock);
 602         set_sample_rate(chip, hw_params->rate_num / hw_params->rate_den);
 603         spin_unlock_irq(&chip->lock);
 604         return 0;
 605 }
 606
 607
 608
 609 static int pcm_analog_in_hw_params(struct snd_pcm_substream *substream,
 610                                    struct snd_pcm_hw_params *hw_params)
 611 {
 612         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 613
 614         return init_engine(substream, hw_params, px_analog_in(chip) +
 615                         substream->number, params_channels(hw_params));
 616 }
 617
 618
 619
 620 static int pcm_analog_out_hw_params(struct snd_pcm_substream *substream,
 621                                     struct snd_pcm_hw_params *hw_params)
 622 {
 623         return init_engine(substream, hw_params, substream->number,
 624                            params_channels(hw_params));
 625 }
 626
 627
 628
 629 #ifdef ECHOCARD_HAS_DIGITAL_IO
 630
 631 static int pcm_digital_in_hw_params(struct snd_pcm_substream *substream,
 632                                     struct snd_pcm_hw_params *hw_params)
 633 {
 634         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 635
 636         return init_engine(substream, hw_params, px_digital_in(chip) +
 637                         substream->number, params_channels(hw_params));
 638 }
 639
 640
 641
 642 #ifndef ECHOCARD_HAS_VMIXER     /* See the note in snd_echo_new_pcm() */
 643 static int pcm_digital_out_hw_params(struct snd_pcm_substream *substream,
 644                                      struct snd_pcm_hw_params *hw_params)
 645 {
 646         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 647
 648         return init_engine(substream, hw_params, px_digital_out(chip) +
 649                         substream->number, params_channels(hw_params));
 650 }
 651 #endif /* !ECHOCARD_HAS_VMIXER */
 652
 653 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 654
 655
 656
 657 static int pcm_hw_free(struct snd_pcm_substream *substream)
 658 {
 659         struct echoaudio *chip;
 660         struct audiopipe *pipe;
 661
 662         chip = snd_pcm_substream_chip(substream);
 663         pipe = (struct audiopipe *) substream->runtime->private_data;
 664
 665         spin_lock_irq(&chip->lock);
 666         if (pipe->index >= 0) {
 667                 dev_dbg(chip->card->dev, "pcm_hw_free(%d)\n", pipe->index);
 668                 free_pipes(chip, pipe);
 669                 chip->substream[pipe->index] = NULL;
 670                 pipe->index = -1;
 671         }
 672         spin_unlock_irq(&chip->lock);
 673
 674         snd_pcm_lib_free_pages(substream);
 675         return 0;
 676 }
 677
 678
 679
 680 static int pcm_prepare(struct snd_pcm_substream *substream)
 681 {
 682         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 683         struct snd_pcm_runtime *runtime = substream->runtime;
 684         struct audioformat format;
 685         int pipe_index = ((struct audiopipe *)runtime->private_data)->index;
 686
 687         dev_dbg(chip->card->dev, "Prepare rate=%d format=%d channels=%d\n",
 688                 runtime->rate, runtime->format, runtime->channels);
 689         format.interleave = runtime->channels;
 690         format.data_are_bigendian = 0;
 691         format.mono_to_stereo = 0;
 692         switch (runtime->format) {
 693         case SNDRV_PCM_FORMAT_U8:
 694                 format.bits_per_sample = 8;
 695                 break;
 696         case SNDRV_PCM_FORMAT_S16_LE:
 697                 format.bits_per_sample = 16;
 698                 break;
 699         case SNDRV_PCM_FORMAT_S24_3LE:
 700                 format.bits_per_sample = 24;
 701                 break;
 702         case SNDRV_PCM_FORMAT_S32_BE:
 703                 format.data_are_bigendian = 1;
 704                 /* fall through */
 705         case SNDRV_PCM_FORMAT_S32_LE:
 706                 format.bits_per_sample = 32;
 707                 break;
 708         default:
 709                 dev_err(chip->card->dev,
 710                         "Prepare error: unsupported format %d\n",
 711                         runtime->format);
 712                 return -EINVAL;
 713         }
 714
 715         if (snd_BUG_ON(pipe_index >= px_num(chip)))
 716                 return -EINVAL;
 717         if (snd_BUG_ON(!is_pipe_allocated(chip, pipe_index)))
 718                 return -EINVAL;
 719         set_audio_format(chip, pipe_index, &format);
 720         return 0;
 721 }
 722
 723
 724
 725 static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 726 {
 727         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 728         struct audiopipe *pipe;
 729         int i, err;
 730         u32 channelmask = 0;
 731         struct snd_pcm_substream *s;
 732
 733         snd_pcm_group_for_each_entry(s, substream) {
 734                 for (i = 0; i < DSP_MAXPIPES; i++) {
 735                         if (s == chip->substream[i]) {
 736                                 channelmask |= 1 << i;
 737                                 snd_pcm_trigger_done(s, substream);
 738                         }
 739                 }
 740         }
 741
 742         spin_lock(&chip->lock);
 743         switch (cmd) {
 744         case SNDRV_PCM_TRIGGER_RESUME:
 745         case SNDRV_PCM_TRIGGER_START:
 746         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 747                 for (i = 0; i < DSP_MAXPIPES; i++) {
 748                         if (channelmask & (1 << i)) {
 749                                 pipe = chip->substream[i]->runtime->private_data;
 750                                 switch (pipe->state) {
 751                                 case PIPE_STATE_STOPPED:
 752                                         chip->last_period[i] = 0;
 753                                         pipe->last_counter = 0;
 754                                         pipe->position = 0;
 755                                         *pipe->dma_counter = 0;
 756                                         /* fall through */
 757                                 case PIPE_STATE_PAUSED:
 758                                         pipe->state = PIPE_STATE_STARTED;
 759                                         break;
 760                                 case PIPE_STATE_STARTED:
 761                                         break;
 762                                 }
 763                         }
 764                 }
 765                 err = start_transport(chip, channelmask,
 766                                       chip->pipe_cyclic_mask);
 767                 break;
 768         case SNDRV_PCM_TRIGGER_SUSPEND:
 769         case SNDRV_PCM_TRIGGER_STOP:
 770                 for (i = 0; i < DSP_MAXPIPES; i++) {
 771                         if (channelmask & (1 << i)) {
 772                                 pipe = chip->substream[i]->runtime->private_data;
 773                                 pipe->state = PIPE_STATE_STOPPED;
 774                         }
 775                 }
 776                 err = stop_transport(chip, channelmask);
 777                 break;
 778         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 779                 for (i = 0; i < DSP_MAXPIPES; i++) {
 780                         if (channelmask & (1 << i)) {
 781                                 pipe = chip->substream[i]->runtime->private_data;
 782                                 pipe->state = PIPE_STATE_PAUSED;
 783                         }
 784                 }
 785                 err = pause_transport(chip, channelmask);
 786                 break;
 787         default:
 788                 err = -EINVAL;
 789         }
 790         spin_unlock(&chip->lock);
 791         return err;
 792 }
 793
 794
 795
 796 static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
 797 {
 798         struct snd_pcm_runtime *runtime = substream->runtime;
 799         struct audiopipe *pipe = runtime->private_data;
 800         size_t cnt, bufsize, pos;
 801
 802         cnt = le32_to_cpu(*pipe->dma_counter);
 803         pipe->position += cnt - pipe->last_counter;
 804         pipe->last_counter = cnt;
 805         bufsize = substream->runtime->buffer_size;
 806         pos = bytes_to_frames(substream->runtime, pipe->position);
 807
 808         while (pos >= bufsize) {
 809                 pipe->position -= frames_to_bytes(substream->runtime, bufsize);
 810                 pos -= bufsize;
 811         }
 812         return pos;
 813 }
 814
 815
 816
 817 /* pcm *_ops structures */
 818 static const struct snd_pcm_ops analog_playback_ops = {
 819         .open = pcm_analog_out_open,
 820         .close = pcm_close,
 821         .ioctl = snd_pcm_lib_ioctl,
 822         .hw_params = pcm_analog_out_hw_params,
 823         .hw_free = pcm_hw_free,
 824         .prepare = pcm_prepare,
 825         .trigger = pcm_trigger,
 826         .pointer = pcm_pointer,
 827         .page = snd_pcm_sgbuf_ops_page,
 828 };
 829 static const struct snd_pcm_ops analog_capture_ops = {
 830         .open = pcm_analog_in_open,
 831         .close = pcm_close,
 832         .ioctl = snd_pcm_lib_ioctl,
 833         .hw_params = pcm_analog_in_hw_params,
 834         .hw_free = pcm_hw_free,
 835         .prepare = pcm_prepare,
 836         .trigger = pcm_trigger,
 837         .pointer = pcm_pointer,
 838         .page = snd_pcm_sgbuf_ops_page,
 839 };
 840 #ifdef ECHOCARD_HAS_DIGITAL_IO
 841 #ifndef ECHOCARD_HAS_VMIXER
 842 static const struct snd_pcm_ops digital_playback_ops = {
 843         .open = pcm_digital_out_open,
 844         .close = pcm_close,
 845         .ioctl = snd_pcm_lib_ioctl,
 846         .hw_params = pcm_digital_out_hw_params,
 847         .hw_free = pcm_hw_free,
 848         .prepare = pcm_prepare,
 849         .trigger = pcm_trigger,
 850         .pointer = pcm_pointer,
 851         .page = snd_pcm_sgbuf_ops_page,
 852 };
 853 #endif /* !ECHOCARD_HAS_VMIXER */
 854 static const struct snd_pcm_ops digital_capture_ops = {
 855         .open = pcm_digital_in_open,
 856         .close = pcm_close,
 857         .ioctl = snd_pcm_lib_ioctl,
 858         .hw_params = pcm_digital_in_hw_params,
 859         .hw_free = pcm_hw_free,
 860         .prepare = pcm_prepare,
 861         .trigger = pcm_trigger,
 862         .pointer = pcm_pointer,
 863         .page = snd_pcm_sgbuf_ops_page,
 864 };
 865 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 866
 867
 868
 869 /* Preallocate memory only for the first substream because it's the most
 870  * used one
 871  */
 872 static int snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
 873 {
 874         struct snd_pcm_substream *ss;
 875         int stream;
 876
 877         for (stream = 0; stream < 2; stream++)
 878                 for (ss = pcm->streams[stream].substream; ss; ss = ss->next)
 879                         snd_pcm_lib_preallocate_pages(ss, SNDRV_DMA_TYPE_DEV_SG,
 880                                                       dev,
 881                                                       ss->number ? 0 : 128<<10,
 882                                                       256<<10);
 883
 884         return 0;
 885 }
 886
 887
 888
 889 /*<--snd_echo_probe() */
 890 static int snd_echo_new_pcm(struct echoaudio *chip)
 891 {
 892         struct snd_pcm *pcm;
 893         int err;
 894
 895 #ifdef ECHOCARD_HAS_VMIXER
 896         /* This card has a Vmixer, that is there is no direct mapping from PCM
 897         streams to physical outputs. The user can mix the streams as he wishes
 898         via control interface and it's possible to send any stream to any
 899         output, thus it makes no sense to keep analog and digital outputs
 900         separated */
 901
 902         /* PCM#0 Virtual outputs and analog inputs */
 903         if ((err = snd_pcm_new(chip->card, "PCM", 0, num_pipes_out(chip),
 904                                 num_analog_busses_in(chip), &pcm)) < 0)
 905                 return err;
 906         pcm->private_data = chip;
 907         chip->analog_pcm = pcm;
 908         strcpy(pcm->name, chip->card->shortname);
 909         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
 910         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
 911         if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
 912                 return err;
 913
 914 #ifdef ECHOCARD_HAS_DIGITAL_IO
 915         /* PCM#1 Digital inputs, no outputs */
 916         if ((err = snd_pcm_new(chip->card, "Digital PCM", 1, 0,
 917                                num_digital_busses_in(chip), &pcm)) < 0)
 918                 return err;
 919         pcm->private_data = chip;
 920         chip->digital_pcm = pcm;
 921         strcpy(pcm->name, chip->card->shortname);
 922         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
 923         if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
 924                 return err;
 925 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 926
 927 #else /* ECHOCARD_HAS_VMIXER */
 928
 929         /* The card can manage substreams formed by analog and digital channels
 930         at the same time, but I prefer to keep analog and digital channels
 931         separated, because that mixed thing is confusing and useless. So we
 932         register two PCM devices: */
 933
 934         /* PCM#0 Analog i/o */
 935         if ((err = snd_pcm_new(chip->card, "Analog PCM", 0,
 936                                num_analog_busses_out(chip),
 937                                num_analog_busses_in(chip), &pcm)) < 0)
 938                 return err;
 939         pcm->private_data = chip;
 940         chip->analog_pcm = pcm;
 941         strcpy(pcm->name, chip->card->shortname);
 942         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
 943         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
 944         if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
 945                 return err;
 946
 947 #ifdef ECHOCARD_HAS_DIGITAL_IO
 948         /* PCM#1 Digital i/o */
 949         if ((err = snd_pcm_new(chip->card, "Digital PCM", 1,
 950                                num_digital_busses_out(chip),
 951                                num_digital_busses_in(chip), &pcm)) < 0)
 952                 return err;
 953         pcm->private_data = chip;
 954         chip->digital_pcm = pcm;
 955         strcpy(pcm->name, chip->card->shortname);
 956         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &digital_playback_ops);
 957         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
 958         if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
 959                 return err;
 960 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 961
 962 #endif /* ECHOCARD_HAS_VMIXER */
 963
 964         return 0;
 965 }
 966
 967
 968
 969
 970 /******************************************************************************
 971         Control interface
 972 ******************************************************************************/
 973
 974 #if !defined(ECHOCARD_HAS_VMIXER) || defined(ECHOCARD_HAS_LINE_OUT_GAIN)
 975
 976 /******************* PCM output volume *******************/
 977 static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
 978                                      struct snd_ctl_elem_info *uinfo)
 979 {
 980         struct echoaudio *chip;
 981
 982         chip = snd_kcontrol_chip(kcontrol);
 983         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 984         uinfo->count = num_busses_out(chip);
 985         uinfo->value.integer.min = ECHOGAIN_MINOUT;
 986         uinfo->value.integer.max = ECHOGAIN_MAXOUT;
 987         return 0;
 988 }
 989
 990 static int snd_echo_output_gain_get(struct snd_kcontrol *kcontrol,
 991                                     struct snd_ctl_elem_value *ucontrol)
 992 {
 993         struct echoaudio *chip;
 994         int c;
 995
 996         chip = snd_kcontrol_chip(kcontrol);
 997         for (c = 0; c < num_busses_out(chip); c++)
 998                 ucontrol->value.integer.value[c] = chip->output_gain[c];
 999         return 0;
1000 }
1001
1002 static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
1003                                     struct snd_ctl_elem_value *ucontrol)
1004 {
1005         struct echoaudio *chip;
1006         int c, changed, gain;
1007
1008         changed = 0;
1009         chip = snd_kcontrol_chip(kcontrol);
1010         spin_lock_irq(&chip->lock);
1011         for (c = 0; c < num_busses_out(chip); c++) {
1012                 gain = ucontrol->value.integer.value[c];
1013                 /* Ignore out of range values */
1014                 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1015                         continue;
1016                 if (chip->output_gain[c] != gain) {
1017                         set_output_gain(chip, c, gain);
1018                         changed = 1;
1019                 }
1020         }
1021         if (changed)
1022                 update_output_line_level(chip);
1023         spin_unlock_irq(&chip->lock);
1024         return changed;
1025 }
1026
1027 #ifdef ECHOCARD_HAS_LINE_OUT_GAIN
1028 /* On the Mia this one controls the line-out volume */
1029 static const struct snd_kcontrol_new snd_echo_line_output_gain = {
1030         .name = "Line Playback Volume",
1031         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1032         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1033                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1034         .info = snd_echo_output_gain_info,
1035         .get = snd_echo_output_gain_get,
1036         .put = snd_echo_output_gain_put,
1037         .tlv = {.p = db_scale_output_gain},
1038 };
1039 #else
1040 static const struct snd_kcontrol_new snd_echo_pcm_output_gain = {
1041         .name = "PCM Playback Volume",
1042         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1043         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1044         .info = snd_echo_output_gain_info,
1045         .get = snd_echo_output_gain_get,
1046         .put = snd_echo_output_gain_put,
1047         .tlv = {.p = db_scale_output_gain},
1048 };
1049 #endif
1050
1051 #endif /* !ECHOCARD_HAS_VMIXER || ECHOCARD_HAS_LINE_OUT_GAIN */
1052
1053
1054
1055 #ifdef ECHOCARD_HAS_INPUT_GAIN
1056
1057 /******************* Analog input volume *******************/
1058 static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1059                                     struct snd_ctl_elem_info *uinfo)
1060 {
1061         struct echoaudio *chip;
1062
1063         chip = snd_kcontrol_chip(kcontrol);
1064         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1065         uinfo->count = num_analog_busses_in(chip);
1066         uinfo->value.integer.min = ECHOGAIN_MININP;
1067         uinfo->value.integer.max = ECHOGAIN_MAXINP;
1068         return 0;
1069 }
1070
1071 static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1072                                    struct snd_ctl_elem_value *ucontrol)
1073 {
1074         struct echoaudio *chip;
1075         int c;
1076
1077         chip = snd_kcontrol_chip(kcontrol);
1078         for (c = 0; c < num_analog_busses_in(chip); c++)
1079                 ucontrol->value.integer.value[c] = chip->input_gain[c];
1080         return 0;
1081 }
1082
1083 static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1084                                    struct snd_ctl_elem_value *ucontrol)
1085 {
1086         struct echoaudio *chip;
1087         int c, gain, changed;
1088
1089         changed = 0;
1090         chip = snd_kcontrol_chip(kcontrol);
1091         spin_lock_irq(&chip->lock);
1092         for (c = 0; c < num_analog_busses_in(chip); c++) {
1093                 gain = ucontrol->value.integer.value[c];
1094                 /* Ignore out of range values */
1095                 if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1096                         continue;
1097                 if (chip->input_gain[c] != gain) {
1098                         set_input_gain(chip, c, gain);
1099                         changed = 1;
1100                 }
1101         }
1102         if (changed)
1103                 update_input_line_level(chip);
1104         spin_unlock_irq(&chip->lock);
1105         return changed;
1106 }
1107
1108 static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
1109
1110 static const struct snd_kcontrol_new snd_echo_line_input_gain = {
1111         .name = "Line Capture Volume",
1112         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1113         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1114         .info = snd_echo_input_gain_info,
1115         .get = snd_echo_input_gain_get,
1116         .put = snd_echo_input_gain_put,
1117         .tlv = {.p = db_scale_input_gain},
1118 };
1119
1120 #endif /* ECHOCARD_HAS_INPUT_GAIN */
1121
1122
1123
1124 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1125
1126 /************ Analog output nominal level (+4dBu / -10dBV) ***************/
1127 static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1128                                          struct snd_ctl_elem_info *uinfo)
1129 {
1130         struct echoaudio *chip;
1131
1132         chip = snd_kcontrol_chip(kcontrol);
1133         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1134         uinfo->count = num_analog_busses_out(chip);
1135         uinfo->value.integer.min = 0;
1136         uinfo->value.integer.max = 1;
1137         return 0;
1138 }
1139
1140 static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1141                                        struct snd_ctl_elem_value *ucontrol)
1142 {
1143         struct echoaudio *chip;
1144         int c;
1145
1146         chip = snd_kcontrol_chip(kcontrol);
1147         for (c = 0; c < num_analog_busses_out(chip); c++)
1148                 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1149         return 0;
1150 }
1151
1152 static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1153                                        struct snd_ctl_elem_value *ucontrol)
1154 {
1155         struct echoaudio *chip;
1156         int c, changed;
1157
1158         changed = 0;
1159         chip = snd_kcontrol_chip(kcontrol);
1160         spin_lock_irq(&chip->lock);
1161         for (c = 0; c < num_analog_busses_out(chip); c++) {
1162                 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1163                         set_nominal_level(chip, c,
1164                                           ucontrol->value.integer.value[c]);
1165                         changed = 1;
1166                 }
1167         }
1168         if (changed)
1169                 update_output_line_level(chip);
1170         spin_unlock_irq(&chip->lock);
1171         return changed;
1172 }
1173
1174 static const struct snd_kcontrol_new snd_echo_output_nominal_level = {
1175         .name = "Line Playback Switch (-10dBV)",
1176         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1177         .info = snd_echo_output_nominal_info,
1178         .get = snd_echo_output_nominal_get,
1179         .put = snd_echo_output_nominal_put,
1180 };
1181
1182 #endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1183
1184
1185
1186 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1187
1188 /*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1189 static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1190                                        struct snd_ctl_elem_info *uinfo)
1191 {
1192         struct echoaudio *chip;
1193
1194         chip = snd_kcontrol_chip(kcontrol);
1195         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1196         uinfo->count = num_analog_busses_in(chip);
1197         uinfo->value.integer.min = 0;
1198         uinfo->value.integer.max = 1;
1199         return 0;
1200 }
1201
1202 static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1203                                       struct snd_ctl_elem_value *ucontrol)
1204 {
1205         struct echoaudio *chip;
1206         int c;
1207
1208         chip = snd_kcontrol_chip(kcontrol);
1209         for (c = 0; c < num_analog_busses_in(chip); c++)
1210                 ucontrol->value.integer.value[c] =
1211                         chip->nominal_level[bx_analog_in(chip) + c];
1212         return 0;
1213 }
1214
1215 static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1216                                       struct snd_ctl_elem_value *ucontrol)
1217 {
1218         struct echoaudio *chip;
1219         int c, changed;
1220
1221         changed = 0;
1222         chip = snd_kcontrol_chip(kcontrol);
1223         spin_lock_irq(&chip->lock);
1224         for (c = 0; c < num_analog_busses_in(chip); c++) {
1225                 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1226                     ucontrol->value.integer.value[c]) {
1227                         set_nominal_level(chip, bx_analog_in(chip) + c,
1228                                           ucontrol->value.integer.value[c]);
1229                         changed = 1;
1230                 }
1231         }
1232         if (changed)
1233                 update_output_line_level(chip); /* "Output" is not a mistake
1234                                                  * here.
1235                                                  */
1236         spin_unlock_irq(&chip->lock);
1237         return changed;
1238 }
1239
1240 static const struct snd_kcontrol_new snd_echo_intput_nominal_level = {
1241         .name = "Line Capture Switch (-10dBV)",
1242         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1243         .info = snd_echo_input_nominal_info,
1244         .get = snd_echo_input_nominal_get,
1245         .put = snd_echo_input_nominal_put,
1246 };
1247
1248 #endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1249
1250
1251
1252 #ifdef ECHOCARD_HAS_MONITOR
1253
1254 /******************* Monitor mixer *******************/
1255 static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1256                                struct snd_ctl_elem_info *uinfo)
1257 {
1258         struct echoaudio *chip;
1259
1260         chip = snd_kcontrol_chip(kcontrol);
1261         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1262         uinfo->count = 1;
1263         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1264         uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1265         uinfo->dimen.d[0] = num_busses_out(chip);
1266         uinfo->dimen.d[1] = num_busses_in(chip);
1267         return 0;
1268 }
1269
1270 static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1271                               struct snd_ctl_elem_value *ucontrol)
1272 {
1273         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1274         unsigned int out = ucontrol->id.index / num_busses_in(chip);
1275         unsigned int in = ucontrol->id.index % num_busses_in(chip);
1276
1277         if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1278                 return -EINVAL;
1279
1280         ucontrol->value.integer.value[0] = chip->monitor_gain[out][in];
1281         return 0;
1282 }
1283
1284 static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1285                               struct snd_ctl_elem_value *ucontrol)
1286 {
1287         struct echoaudio *chip;
1288         int changed,  gain;
1289         unsigned int out, in;
1290
1291         changed = 0;
1292         chip = snd_kcontrol_chip(kcontrol);
1293         out = ucontrol->id.index / num_busses_in(chip);
1294         in = ucontrol->id.index % num_busses_in(chip);
1295         if (out >= ECHO_MAXAUDIOOUTPUTS || in >= ECHO_MAXAUDIOINPUTS)
1296                 return -EINVAL;
1297         gain = ucontrol->value.integer.value[0];
1298         if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1299                 return -EINVAL;
1300         if (chip->monitor_gain[out][in] != gain) {
1301                 spin_lock_irq(&chip->lock);
1302                 set_monitor_gain(chip, out, in, gain);
1303                 update_output_line_level(chip);
1304                 spin_unlock_irq(&chip->lock);
1305                 changed = 1;
1306         }
1307         return changed;
1308 }
1309
1310 static struct snd_kcontrol_new snd_echo_monitor_mixer = {
1311         .name = "Monitor Mixer Volume",
1312         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1313         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1314         .info = snd_echo_mixer_info,
1315         .get = snd_echo_mixer_get,
1316         .put = snd_echo_mixer_put,
1317         .tlv = {.p = db_scale_output_gain},
1318 };
1319
1320 #endif /* ECHOCARD_HAS_MONITOR */
1321
1322
1323
1324 #ifdef ECHOCARD_HAS_VMIXER
1325
1326 /******************* Vmixer *******************/
1327 static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1328                                 struct snd_ctl_elem_info *uinfo)
1329 {
1330         struct echoaudio *chip;
1331
1332         chip = snd_kcontrol_chip(kcontrol);
1333         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1334         uinfo->count = 1;
1335         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1336         uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1337         uinfo->dimen.d[0] = num_busses_out(chip);
1338         uinfo->dimen.d[1] = num_pipes_out(chip);
1339         return 0;
1340 }
1341
1342 static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1343                                struct snd_ctl_elem_value *ucontrol)
1344 {
1345         struct echoaudio *chip;
1346
1347         chip = snd_kcontrol_chip(kcontrol);
1348         ucontrol->value.integer.value[0] =
1349                 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1350                         [ucontrol->id.index % num_pipes_out(chip)];
1351         return 0;
1352 }
1353
1354 static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1355                                struct snd_ctl_elem_value *ucontrol)
1356 {
1357         struct echoaudio *chip;
1358         int gain, changed;
1359         short vch, out;
1360
1361         changed = 0;
1362         chip = snd_kcontrol_chip(kcontrol);
1363         out = ucontrol->id.index / num_pipes_out(chip);
1364         vch = ucontrol->id.index % num_pipes_out(chip);
1365         gain = ucontrol->value.integer.value[0];
1366         if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1367                 return -EINVAL;
1368         if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1369                 spin_lock_irq(&chip->lock);
1370                 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1371                 update_vmixer_level(chip);
1372                 spin_unlock_irq(&chip->lock);
1373                 changed = 1;
1374         }
1375         return changed;
1376 }
1377
1378 static struct snd_kcontrol_new snd_echo_vmixer = {
1379         .name = "VMixer Volume",
1380         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1381         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1382         .info = snd_echo_vmixer_info,
1383         .get = snd_echo_vmixer_get,
1384         .put = snd_echo_vmixer_put,
1385         .tlv = {.p = db_scale_output_gain},
1386 };
1387
1388 #endif /* ECHOCARD_HAS_VMIXER */
1389
1390
1391
1392 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1393
1394 /******************* Digital mode switch *******************/
1395 static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1396                                       struct snd_ctl_elem_info *uinfo)
1397 {
1398         static const char * const names[4] = {
1399                 "S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1400                 "S/PDIF Cdrom"
1401         };
1402         struct echoaudio *chip;
1403
1404         chip = snd_kcontrol_chip(kcontrol);
1405         return snd_ctl_enum_info(uinfo, 1, chip->num_digital_modes, names);
1406 }
1407
1408 static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1409                                      struct snd_ctl_elem_value *ucontrol)
1410 {
1411         struct echoaudio *chip;
1412         int i, mode;
1413
1414         chip = snd_kcontrol_chip(kcontrol);
1415         mode = chip->digital_mode;
1416         for (i = chip->num_digital_modes - 1; i >= 0; i--)
1417                 if (mode == chip->digital_mode_list[i]) {
1418                         ucontrol->value.enumerated.item[0] = i;
1419                         break;
1420                 }
1421         return 0;
1422 }
1423
1424 static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1425                                      struct snd_ctl_elem_value *ucontrol)
1426 {
1427         struct echoaudio *chip;
1428         int changed;
1429         unsigned short emode, dmode;
1430
1431         changed = 0;
1432         chip = snd_kcontrol_chip(kcontrol);
1433
1434         emode = ucontrol->value.enumerated.item[0];
1435         if (emode >= chip->num_digital_modes)
1436                 return -EINVAL;
1437         dmode = chip->digital_mode_list[emode];
1438
1439         if (dmode != chip->digital_mode) {
1440                 /* mode_mutex is required to make this operation atomic wrt
1441                 pcm_digital_*_open() and set_input_clock() functions. */
1442                 mutex_lock(&chip->mode_mutex);
1443
1444                 /* Do not allow the user to change the digital mode when a pcm
1445                 device is open because it also changes the number of channels
1446                 and the allowed sample rates */
1447                 if (atomic_read(&chip->opencount)) {
1448                         changed = -EAGAIN;
1449                 } else {
1450                         changed = set_digital_mode(chip, dmode);
1451                         /* If we had to change the clock source, report it */
1452                         if (changed > 0 && chip->clock_src_ctl) {
1453                                 snd_ctl_notify(chip->card,
1454                                                SNDRV_CTL_EVENT_MASK_VALUE,
1455                                                &chip->clock_src_ctl->id);
1456                                 dev_dbg(chip->card->dev,
1457                                         "SDM() =%d\n", changed);
1458                         }
1459                         if (changed >= 0)
1460                                 changed = 1;    /* No errors */
1461                 }
1462                 mutex_unlock(&chip->mode_mutex);
1463         }
1464         return changed;
1465 }
1466
1467 static const struct snd_kcontrol_new snd_echo_digital_mode_switch = {
1468         .name = "Digital mode Switch",
1469         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1470         .info = snd_echo_digital_mode_info,
1471         .get = snd_echo_digital_mode_get,
1472         .put = snd_echo_digital_mode_put,
1473 };
1474
1475 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1476
1477
1478
1479 #ifdef ECHOCARD_HAS_DIGITAL_IO
1480
1481 /******************* S/PDIF mode switch *******************/
1482 static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1483                                     struct snd_ctl_elem_info *uinfo)
1484 {
1485         static const char * const names[2] = {"Consumer", "Professional"};
1486
1487         return snd_ctl_enum_info(uinfo, 1, 2, names);
1488 }
1489
1490 static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1491                                    struct snd_ctl_elem_value *ucontrol)
1492 {
1493         struct echoaudio *chip;
1494
1495         chip = snd_kcontrol_chip(kcontrol);
1496         ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1497         return 0;
1498 }
1499
1500 static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1501                                    struct snd_ctl_elem_value *ucontrol)
1502 {
1503         struct echoaudio *chip;
1504         int mode;
1505
1506         chip = snd_kcontrol_chip(kcontrol);
1507         mode = !!ucontrol->value.enumerated.item[0];
1508         if (mode != chip->professional_spdif) {
1509                 spin_lock_irq(&chip->lock);
1510                 set_professional_spdif(chip, mode);
1511                 spin_unlock_irq(&chip->lock);
1512                 return 1;
1513         }
1514         return 0;
1515 }
1516
1517 static const struct snd_kcontrol_new snd_echo_spdif_mode_switch = {
1518         .name = "S/PDIF mode Switch",
1519         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1520         .info = snd_echo_spdif_mode_info,
1521         .get = snd_echo_spdif_mode_get,
1522         .put = snd_echo_spdif_mode_put,
1523 };
1524
1525 #endif /* ECHOCARD_HAS_DIGITAL_IO */
1526
1527
1528
1529 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1530
1531 /******************* Select input clock source *******************/
1532 static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1533                                       struct snd_ctl_elem_info *uinfo)
1534 {
1535         static const char * const names[8] = {
1536                 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1537                 "ESync96", "MTC"
1538         };
1539         struct echoaudio *chip;
1540
1541         chip = snd_kcontrol_chip(kcontrol);
1542         return snd_ctl_enum_info(uinfo, 1, chip->num_clock_sources, names);
1543 }
1544
1545 static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1546                                      struct snd_ctl_elem_value *ucontrol)
1547 {
1548         struct echoaudio *chip;
1549         int i, clock;
1550
1551         chip = snd_kcontrol_chip(kcontrol);
1552         clock = chip->input_clock;
1553
1554         for (i = 0; i < chip->num_clock_sources; i++)
1555                 if (clock == chip->clock_source_list[i])
1556                         ucontrol->value.enumerated.item[0] = i;
1557
1558         return 0;
1559 }
1560
1561 static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1562                                      struct snd_ctl_elem_value *ucontrol)
1563 {
1564         struct echoaudio *chip;
1565         int changed;
1566         unsigned int eclock, dclock;
1567
1568         changed = 0;
1569         chip = snd_kcontrol_chip(kcontrol);
1570         eclock = ucontrol->value.enumerated.item[0];
1571         if (eclock >= chip->input_clock_types)
1572                 return -EINVAL;
1573         dclock = chip->clock_source_list[eclock];
1574         if (chip->input_clock != dclock) {
1575                 mutex_lock(&chip->mode_mutex);
1576                 spin_lock_irq(&chip->lock);
1577                 if ((changed = set_input_clock(chip, dclock)) == 0)
1578                         changed = 1;    /* no errors */
1579                 spin_unlock_irq(&chip->lock);
1580                 mutex_unlock(&chip->mode_mutex);
1581         }
1582
1583         if (changed < 0)
1584                 dev_dbg(chip->card->dev,
1585                         "seticlk val%d err 0x%x\n", dclock, changed);
1586
1587         return changed;
1588 }
1589
1590 static const struct snd_kcontrol_new snd_echo_clock_source_switch = {
1591         .name = "Sample Clock Source",
1592         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1593         .info = snd_echo_clock_source_info,
1594         .get = snd_echo_clock_source_get,
1595         .put = snd_echo_clock_source_put,
1596 };
1597
1598 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1599
1600
1601
1602 #ifdef ECHOCARD_HAS_PHANTOM_POWER
1603
1604 /******************* Phantom power switch *******************/
1605 #define snd_echo_phantom_power_info     snd_ctl_boolean_mono_info
1606
1607 static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1608                                       struct snd_ctl_elem_value *ucontrol)
1609 {
1610         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1611
1612         ucontrol->value.integer.value[0] = chip->phantom_power;
1613         return 0;
1614 }
1615
1616 static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1617                                       struct snd_ctl_elem_value *ucontrol)
1618 {
1619         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1620         int power, changed = 0;
1621
1622         power = !!ucontrol->value.integer.value[0];
1623         if (chip->phantom_power != power) {
1624                 spin_lock_irq(&chip->lock);
1625                 changed = set_phantom_power(chip, power);
1626                 spin_unlock_irq(&chip->lock);
1627                 if (changed == 0)
1628                         changed = 1;    /* no errors */
1629         }
1630         return changed;
1631 }
1632
1633 static const struct snd_kcontrol_new snd_echo_phantom_power_switch = {
1634         .name = "Phantom power Switch",
1635         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1636         .info = snd_echo_phantom_power_info,
1637         .get = snd_echo_phantom_power_get,
1638         .put = snd_echo_phantom_power_put,
1639 };
1640
1641 #endif /* ECHOCARD_HAS_PHANTOM_POWER */
1642
1643
1644
1645 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1646
1647 /******************* Digital input automute switch *******************/
1648 #define snd_echo_automute_info          snd_ctl_boolean_mono_info
1649
1650 static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1651                                  struct snd_ctl_elem_value *ucontrol)
1652 {
1653         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1654
1655         ucontrol->value.integer.value[0] = chip->digital_in_automute;
1656         return 0;
1657 }
1658
1659 static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1660                                  struct snd_ctl_elem_value *ucontrol)
1661 {
1662         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1663         int automute, changed = 0;
1664
1665         automute = !!ucontrol->value.integer.value[0];
1666         if (chip->digital_in_automute != automute) {
1667                 spin_lock_irq(&chip->lock);
1668                 changed = set_input_auto_mute(chip, automute);
1669                 spin_unlock_irq(&chip->lock);
1670                 if (changed == 0)
1671                         changed = 1;    /* no errors */
1672         }
1673         return changed;
1674 }
1675
1676 static const struct snd_kcontrol_new snd_echo_automute_switch = {
1677         .name = "Digital Capture Switch (automute)",
1678         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1679         .info = snd_echo_automute_info,
1680         .get = snd_echo_automute_get,
1681         .put = snd_echo_automute_put,
1682 };
1683
1684 #endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1685
1686
1687
1688 /******************* VU-meters switch *******************/
1689 #define snd_echo_vumeters_switch_info           snd_ctl_boolean_mono_info
1690
1691 static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1692                                         struct snd_ctl_elem_value *ucontrol)
1693 {
1694         struct echoaudio *chip;
1695
1696         chip = snd_kcontrol_chip(kcontrol);
1697         spin_lock_irq(&chip->lock);
1698         set_meters_on(chip, ucontrol->value.integer.value[0]);
1699         spin_unlock_irq(&chip->lock);
1700         return 1;
1701 }
1702
1703 static const struct snd_kcontrol_new snd_echo_vumeters_switch = {
1704         .name = "VU-meters Switch",
1705         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1706         .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1707         .info = snd_echo_vumeters_switch_info,
1708         .put = snd_echo_vumeters_switch_put,
1709 };
1710
1711
1712
1713 /***** Read VU-meters (input, output, analog and digital together) *****/
1714 static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1715                                   struct snd_ctl_elem_info *uinfo)
1716 {
1717         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1718         uinfo->count = 96;
1719         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1720         uinfo->value.integer.max = 0;
1721 #ifdef ECHOCARD_HAS_VMIXER
1722         uinfo->dimen.d[0] = 3;  /* Out, In, Virt */
1723 #else
1724         uinfo->dimen.d[0] = 2;  /* Out, In */
1725 #endif
1726         uinfo->dimen.d[1] = 16; /* 16 channels */
1727         uinfo->dimen.d[2] = 2;  /* 0=level, 1=peak */
1728         return 0;
1729 }
1730
1731 static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1732                                  struct snd_ctl_elem_value *ucontrol)
1733 {
1734         struct echoaudio *chip;
1735
1736         chip = snd_kcontrol_chip(kcontrol);
1737         get_audio_meters(chip, ucontrol->value.integer.value);
1738         return 0;
1739 }
1740
1741 static const struct snd_kcontrol_new snd_echo_vumeters = {
1742         .name = "VU-meters",
1743         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1744         .access = SNDRV_CTL_ELEM_ACCESS_READ |
1745                   SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1746                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1747         .info = snd_echo_vumeters_info,
1748         .get = snd_echo_vumeters_get,
1749         .tlv = {.p = db_scale_output_gain},
1750 };
1751
1752
1753
1754 /*** Channels info - it exports informations about the number of channels ***/
1755 static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1756                                        struct snd_ctl_elem_info *uinfo)
1757 {
1758         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1759         uinfo->count = 6;
1760         uinfo->value.integer.min = 0;
1761         uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1762         return 0;
1763 }
1764
1765 static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1766                                       struct snd_ctl_elem_value *ucontrol)
1767 {
1768         struct echoaudio *chip;
1769         int detected, clocks, bit, src;
1770
1771         chip = snd_kcontrol_chip(kcontrol);
1772         ucontrol->value.integer.value[0] = num_busses_in(chip);
1773         ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1774         ucontrol->value.integer.value[2] = num_busses_out(chip);
1775         ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1776         ucontrol->value.integer.value[4] = num_pipes_out(chip);
1777
1778         /* Compute the bitmask of the currently valid input clocks */
1779         detected = detect_input_clocks(chip);
1780         clocks = 0;
1781         src = chip->num_clock_sources - 1;
1782         for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1783                 if (detected & (1 << bit))
1784                         for (; src >= 0; src--)
1785                                 if (bit == chip->clock_source_list[src]) {
1786                                         clocks |= 1 << src;
1787                                         break;
1788                                 }
1789         ucontrol->value.integer.value[5] = clocks;
1790
1791         return 0;
1792 }
1793
1794 static const struct snd_kcontrol_new snd_echo_channels_info = {
1795         .name = "Channels info",
1796         .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1797         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1798         .info = snd_echo_channels_info_info,
1799         .get = snd_echo_channels_info_get,
1800 };
1801
1802
1803
1804
1805 /******************************************************************************
1806         IRQ Handler
1807 ******************************************************************************/
1808
1809 static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
1810 {
1811         struct echoaudio *chip = dev_id;
1812         struct snd_pcm_substream *substream;
1813         int period, ss, st;
1814
1815         spin_lock(&chip->lock);
1816         st = service_irq(chip);
1817         if (st < 0) {
1818                 spin_unlock(&chip->lock);
1819                 return IRQ_NONE;
1820         }
1821         /* The hardware doesn't tell us which substream caused the irq,
1822         thus we have to check all running substreams. */
1823         for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1824                 substream = chip->substream[ss];
1825                 if (substream && ((struct audiopipe *)substream->runtime->
1826                                 private_data)->state == PIPE_STATE_STARTED) {
1827                         period = pcm_pointer(substream) /
1828                                 substream->runtime->period_size;
1829                         if (period != chip->last_period[ss]) {
1830                                 chip->last_period[ss] = period;
1831                                 spin_unlock(&chip->lock);
1832                                 snd_pcm_period_elapsed(substream);
1833                                 spin_lock(&chip->lock);
1834                         }
1835                 }
1836         }
1837         spin_unlock(&chip->lock);
1838
1839 #ifdef ECHOCARD_HAS_MIDI
1840         if (st > 0 && chip->midi_in) {
1841                 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1842                 dev_dbg(chip->card->dev, "rawmidi_iread=%d\n", st);
1843         }
1844 #endif
1845         return IRQ_HANDLED;
1846 }
1847
1848
1849
1850
1851 /******************************************************************************
1852         Module construction / destruction
1853 ******************************************************************************/
1854
1855 static int snd_echo_free(struct echoaudio *chip)
1856 {
1857         if (chip->comm_page)
1858                 rest_in_peace(chip);
1859
1860         if (chip->irq >= 0)
1861                 free_irq(chip->irq, chip);
1862
1863         if (chip->comm_page)
1864                 snd_dma_free_pages(&chip->commpage_dma_buf);
1865
1866         iounmap(chip->dsp_registers);
1867         release_and_free_resource(chip->iores);
1868         pci_disable_device(chip->pci);
1869
1870         /* release chip data */
1871         free_firmware_cache(chip);
1872         kfree(chip);
1873         return 0;
1874 }
1875
1876
1877
1878 static int snd_echo_dev_free(struct snd_device *device)
1879 {
1880         struct echoaudio *chip = device->device_data;
1881
1882         return snd_echo_free(chip);
1883 }
1884
1885
1886
1887 /* <--snd_echo_probe() */
1888 static int snd_echo_create(struct snd_card *card,
1889                            struct pci_dev *pci,
1890                            struct echoaudio **rchip)
1891 {
1892         struct echoaudio *chip;
1893         int err;
1894         size_t sz;
1895         static struct snd_device_ops ops = {
1896                 .dev_free = snd_echo_dev_free,
1897         };
1898
1899         *rchip = NULL;
1900
1901         pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1902
1903         if ((err = pci_enable_device(pci)) < 0)
1904                 return err;
1905         pci_set_master(pci);
1906
1907         /* Allocate chip if needed */
1908         if (!*rchip) {
1909                 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1910                 if (!chip) {
1911                         pci_disable_device(pci);
1912                         return -ENOMEM;
1913                 }
1914                 dev_dbg(card->dev, "chip=%p\n", chip);
1915                 spin_lock_init(&chip->lock);
1916                 chip->card = card;
1917                 chip->pci = pci;
1918                 chip->irq = -1;
1919                 atomic_set(&chip->opencount, 0);
1920                 mutex_init(&chip->mode_mutex);
1921                 chip->can_set_rate = 1;
1922         } else {
1923                 /* If this was called from the resume function, chip is
1924                  * already allocated and it contains current card settings.
1925                  */
1926                 chip = *rchip;
1927         }
1928
1929         /* PCI resource allocation */
1930         chip->dsp_registers_phys = pci_resource_start(pci, 0);
1931         sz = pci_resource_len(pci, 0);
1932         if (sz > PAGE_SIZE)
1933                 sz = PAGE_SIZE;         /* We map only the required part */
1934
1935         if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1936                                               ECHOCARD_NAME)) == NULL) {
1937                 dev_err(chip->card->dev, "cannot get memory region\n");
1938                 snd_echo_free(chip);
1939                 return -EBUSY;
1940         }
1941         chip->dsp_registers = (volatile u32 __iomem *)
1942                 ioremap_nocache(chip->dsp_registers_phys, sz);
1943         if (!chip->dsp_registers) {
1944                 dev_err(chip->card->dev, "ioremap failed\n");
1945                 snd_echo_free(chip);
1946                 return -ENOMEM;
1947         }
1948
1949         if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1950                         KBUILD_MODNAME, chip)) {
1951                 dev_err(chip->card->dev, "cannot grab irq\n");
1952                 snd_echo_free(chip);
1953                 return -EBUSY;
1954         }
1955         chip->irq = pci->irq;
1956         dev_dbg(card->dev, "pci=%p irq=%d subdev=%04x Init hardware...\n",
1957                 chip->pci, chip->irq, chip->pci->subsystem_device);
1958
1959         /* Create the DSP comm page - this is the area of memory used for most
1960         of the communication with the DSP, which accesses it via bus mastering */
1961         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
1962                                 sizeof(struct comm_page),
1963                                 &chip->commpage_dma_buf) < 0) {
1964                 dev_err(chip->card->dev, "cannot allocate the comm page\n");
1965                 snd_echo_free(chip);
1966                 return -ENOMEM;
1967         }
1968         chip->comm_page_phys = chip->commpage_dma_buf.addr;
1969         chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1970
1971         err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1972         if (err >= 0)
1973                 err = set_mixer_defaults(chip);
1974         if (err < 0) {
1975                 dev_err(card->dev, "init_hw err=%d\n", err);
1976                 snd_echo_free(chip);
1977                 return err;
1978         }
1979
1980         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1981                 snd_echo_free(chip);
1982                 return err;
1983         }
1984         *rchip = chip;
1985         /* Init done ! */
1986         return 0;
1987 }
1988
1989
1990
1991 /* constructor */
1992 static int snd_echo_probe(struct pci_dev *pci,
1993                           const struct pci_device_id *pci_id)
1994 {
1995         static int dev;
1996         struct snd_card *card;
1997         struct echoaudio *chip;
1998         char *dsp;
1999         int i, err;
2000
2001         if (dev >= SNDRV_CARDS)
2002                 return -ENODEV;
2003         if (!enable[dev]) {
2004                 dev++;
2005                 return -ENOENT;
2006         }
2007
2008         i = 0;
2009         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
2010                            0, &card);
2011         if (err < 0)
2012                 return err;
2013
2014         chip = NULL;    /* Tells snd_echo_create to allocate chip */
2015         if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2016                 snd_card_free(card);
2017                 return err;
2018         }
2019
2020         strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2021         strcpy(card->shortname, chip->card_name);
2022
2023         dsp = "56301";
2024         if (pci_id->device == 0x3410)
2025                 dsp = "56361";
2026
2027         sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2028                 card->shortname, pci_id->subdevice & 0x000f, dsp,
2029                 chip->dsp_registers_phys, chip->irq);
2030
2031         if ((err = snd_echo_new_pcm(chip)) < 0) {
2032                 dev_err(chip->card->dev, "new pcm error %d\n", err);
2033                 snd_card_free(card);
2034                 return err;
2035         }
2036
2037 #ifdef ECHOCARD_HAS_MIDI
2038         if (chip->has_midi) {   /* Some Mia's do not have midi */
2039                 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2040                         dev_err(chip->card->dev, "new midi error %d\n", err);
2041                         snd_card_free(card);
2042                         return err;
2043                 }
2044         }
2045 #endif
2046
2047 #ifdef ECHOCARD_HAS_VMIXER
2048         snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
2049         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2050                 goto ctl_error;
2051 #ifdef ECHOCARD_HAS_LINE_OUT_GAIN
2052         err = snd_ctl_add(chip->card,
2053                           snd_ctl_new1(&snd_echo_line_output_gain, chip));
2054         if (err < 0)
2055                 goto ctl_error;
2056 #endif
2057 #else /* ECHOCARD_HAS_VMIXER */
2058         err = snd_ctl_add(chip->card,
2059                           snd_ctl_new1(&snd_echo_pcm_output_gain, chip));
2060         if (err < 0)
2061                 goto ctl_error;
2062 #endif /* ECHOCARD_HAS_VMIXER */
2063
2064 #ifdef ECHOCARD_HAS_INPUT_GAIN
2065         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2066                 goto ctl_error;
2067 #endif
2068
2069 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2070         if (!chip->hasnt_input_nominal_level)
2071                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2072                         goto ctl_error;
2073 #endif
2074
2075 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2076         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2077                 goto ctl_error;
2078 #endif
2079
2080         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2081                 goto ctl_error;
2082
2083         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2084                 goto ctl_error;
2085
2086 #ifdef ECHOCARD_HAS_MONITOR
2087         snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2088         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2089                 goto ctl_error;
2090 #endif
2091
2092 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2093         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2094                 goto ctl_error;
2095 #endif
2096
2097         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2098                 goto ctl_error;
2099
2100 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2101         /* Creates a list of available digital modes */
2102         chip->num_digital_modes = 0;
2103         for (i = 0; i < 6; i++)
2104                 if (chip->digital_modes & (1 << i))
2105                         chip->digital_mode_list[chip->num_digital_modes++] = i;
2106
2107         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2108                 goto ctl_error;
2109 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2110
2111 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2112         /* Creates a list of available clock sources */
2113         chip->num_clock_sources = 0;
2114         for (i = 0; i < 10; i++)
2115                 if (chip->input_clock_types & (1 << i))
2116                         chip->clock_source_list[chip->num_clock_sources++] = i;
2117
2118         if (chip->num_clock_sources > 1) {
2119                 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2120                 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2121                         goto ctl_error;
2122         }
2123 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2124
2125 #ifdef ECHOCARD_HAS_DIGITAL_IO
2126         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2127                 goto ctl_error;
2128 #endif
2129
2130 #ifdef ECHOCARD_HAS_PHANTOM_POWER
2131         if (chip->has_phantom_power)
2132                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2133                         goto ctl_error;
2134 #endif
2135
2136         err = snd_card_register(card);
2137         if (err < 0)
2138                 goto ctl_error;
2139         dev_info(card->dev, "Card registered: %s\n", card->longname);
2140
2141         pci_set_drvdata(pci, chip);
2142         dev++;
2143         return 0;
2144
2145 ctl_error:
2146         dev_err(card->dev, "new control error %d\n", err);
2147         snd_card_free(card);
2148         return err;
2149 }
2150
2151
2152
2153 #if defined(CONFIG_PM_SLEEP)
2154
2155 static int snd_echo_suspend(struct device *dev)
2156 {
2157         struct echoaudio *chip = dev_get_drvdata(dev);
2158
2159 #ifdef ECHOCARD_HAS_MIDI
2160         /* This call can sleep */
2161         if (chip->midi_out)
2162                 snd_echo_midi_output_trigger(chip->midi_out, 0);
2163 #endif
2164         spin_lock_irq(&chip->lock);
2165         if (wait_handshake(chip)) {
2166                 spin_unlock_irq(&chip->lock);
2167                 return -EIO;
2168         }
2169         clear_handshake(chip);
2170         if (send_vector(chip, DSP_VC_GO_COMATOSE) < 0) {
2171                 spin_unlock_irq(&chip->lock);
2172                 return -EIO;
2173         }
2174         spin_unlock_irq(&chip->lock);
2175
2176         chip->dsp_code = NULL;
2177         free_irq(chip->irq, chip);
2178         chip->irq = -1;
2179         return 0;
2180 }
2181
2182
2183
2184 static int snd_echo_resume(struct device *dev)
2185 {
2186         struct pci_dev *pci = to_pci_dev(dev);
2187         struct echoaudio *chip = dev_get_drvdata(dev);
2188         struct comm_page *commpage, *commpage_bak;
2189         u32 pipe_alloc_mask;
2190         int err;
2191
2192         commpage_bak = kmalloc(sizeof(*commpage), GFP_KERNEL);
2193         if (commpage_bak == NULL)
2194                 return -ENOMEM;
2195         commpage = chip->comm_page;
2196         memcpy(commpage_bak, commpage, sizeof(*commpage));
2197
2198         err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
2199         if (err < 0) {
2200                 kfree(commpage_bak);
2201                 dev_err(dev, "resume init_hw err=%d\n", err);
2202                 snd_echo_free(chip);
2203                 return err;
2204         }
2205
2206         /* Temporarily set chip->pipe_alloc_mask=0 otherwise
2207          * restore_dsp_settings() fails.
2208          */
2209         pipe_alloc_mask = chip->pipe_alloc_mask;
2210         chip->pipe_alloc_mask = 0;
2211         err = restore_dsp_rettings(chip);
2212         chip->pipe_alloc_mask = pipe_alloc_mask;
2213         if (err < 0) {
2214                 kfree(commpage_bak);
2215                 return err;
2216         }
2217
2218         memcpy(&commpage->audio_format, &commpage_bak->audio_format,
2219                 sizeof(commpage->audio_format));
2220         memcpy(&commpage->sglist_addr, &commpage_bak->sglist_addr,
2221                 sizeof(commpage->sglist_addr));
2222         memcpy(&commpage->midi_output, &commpage_bak->midi_output,
2223                 sizeof(commpage->midi_output));
2224         kfree(commpage_bak);
2225
2226         if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
2227                         KBUILD_MODNAME, chip)) {
2228                 dev_err(chip->card->dev, "cannot grab irq\n");
2229                 snd_echo_free(chip);
2230                 return -EBUSY;
2231         }
2232         chip->irq = pci->irq;
2233         dev_dbg(dev, "resume irq=%d\n", chip->irq);
2234
2235 #ifdef ECHOCARD_HAS_MIDI
2236         if (chip->midi_input_enabled)
2237                 enable_midi_input(chip, true);
2238         if (chip->midi_out)
2239                 snd_echo_midi_output_trigger(chip->midi_out, 1);
2240 #endif
2241
2242         return 0;
2243 }
2244
2245 static SIMPLE_DEV_PM_OPS(snd_echo_pm, snd_echo_suspend, snd_echo_resume);
2246 #define SND_ECHO_PM_OPS &snd_echo_pm
2247 #else
2248 #define SND_ECHO_PM_OPS NULL
2249 #endif /* CONFIG_PM_SLEEP */
2250
2251
2252 static void snd_echo_remove(struct pci_dev *pci)
2253 {
2254         struct echoaudio *chip;
2255
2256         chip = pci_get_drvdata(pci);
2257         if (chip)
2258                 snd_card_free(chip->card);
2259 }
2260
2261
2262
2263 /******************************************************************************
2264         Everything starts and ends here
2265 ******************************************************************************/
2266
2267 /* pci_driver definition */
2268 static struct pci_driver echo_driver = {
2269         .name = KBUILD_MODNAME,
2270         .id_table = snd_echo_ids,
2271         .probe = snd_echo_probe,
2272         .remove = snd_echo_remove,
2273         .driver = {
2274                 .pm = SND_ECHO_PM_OPS,
2275         },
2276 };
2277
2278 module_pci_driver(echo_driver);