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