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