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