sound/pci/echoaudio/echoaudio.c

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