git.oblomov.eu Git - linux-2.6/blob - 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 #ifndef ECHOCARD_HAS_VMIXER
 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 static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
1007         .name = "PCM Playback Volume",
1008         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1009         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1010         .info = snd_echo_output_gain_info,
1011         .get = snd_echo_output_gain_get,
1012         .put = snd_echo_output_gain_put,
1013         .tlv = {.p = db_scale_output_gain},
1014 };
1015
1016 #endif
1017
1018
1019
1020 #ifdef ECHOCARD_HAS_INPUT_GAIN
1021
1022 /******************* Analog input volume *******************/
1023 static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1024                                     struct snd_ctl_elem_info *uinfo)
1025 {
1026         struct echoaudio *chip;
1027
1028         chip = snd_kcontrol_chip(kcontrol);
1029         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1030         uinfo->count = num_analog_busses_in(chip);
1031         uinfo->value.integer.min = ECHOGAIN_MININP;
1032         uinfo->value.integer.max = ECHOGAIN_MAXINP;
1033         return 0;
1034 }
1035
1036 static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1037                                    struct snd_ctl_elem_value *ucontrol)
1038 {
1039         struct echoaudio *chip;
1040         int c;
1041
1042         chip = snd_kcontrol_chip(kcontrol);
1043         for (c = 0; c < num_analog_busses_in(chip); c++)
1044                 ucontrol->value.integer.value[c] = chip->input_gain[c];
1045         return 0;
1046 }
1047
1048 static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1049                                    struct snd_ctl_elem_value *ucontrol)
1050 {
1051         struct echoaudio *chip;
1052         int c, gain, changed;
1053
1054         changed = 0;
1055         chip = snd_kcontrol_chip(kcontrol);
1056         spin_lock_irq(&chip->lock);
1057         for (c = 0; c < num_analog_busses_in(chip); c++) {
1058                 gain = ucontrol->value.integer.value[c];
1059                 /* Ignore out of range values */
1060                 if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1061                         continue;
1062                 if (chip->input_gain[c] != gain) {
1063                         set_input_gain(chip, c, gain);
1064                         changed = 1;
1065                 }
1066         }
1067         if (changed)
1068                 update_input_line_level(chip);
1069         spin_unlock_irq(&chip->lock);
1070         return changed;
1071 }
1072
1073 static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
1074
1075 static struct snd_kcontrol_new snd_echo_line_input_gain __devinitdata = {
1076         .name = "Line Capture Volume",
1077         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1078         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1079         .info = snd_echo_input_gain_info,
1080         .get = snd_echo_input_gain_get,
1081         .put = snd_echo_input_gain_put,
1082         .tlv = {.p = db_scale_input_gain},
1083 };
1084
1085 #endif /* ECHOCARD_HAS_INPUT_GAIN */
1086
1087
1088
1089 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1090
1091 /************ Analog output nominal level (+4dBu / -10dBV) ***************/
1092 static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1093                                          struct snd_ctl_elem_info *uinfo)
1094 {
1095         struct echoaudio *chip;
1096
1097         chip = snd_kcontrol_chip(kcontrol);
1098         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1099         uinfo->count = num_analog_busses_out(chip);
1100         uinfo->value.integer.min = 0;
1101         uinfo->value.integer.max = 1;
1102         return 0;
1103 }
1104
1105 static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1106                                        struct snd_ctl_elem_value *ucontrol)
1107 {
1108         struct echoaudio *chip;
1109         int c;
1110
1111         chip = snd_kcontrol_chip(kcontrol);
1112         for (c = 0; c < num_analog_busses_out(chip); c++)
1113                 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1114         return 0;
1115 }
1116
1117 static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1118                                        struct snd_ctl_elem_value *ucontrol)
1119 {
1120         struct echoaudio *chip;
1121         int c, changed;
1122
1123         changed = 0;
1124         chip = snd_kcontrol_chip(kcontrol);
1125         spin_lock_irq(&chip->lock);
1126         for (c = 0; c < num_analog_busses_out(chip); c++) {
1127                 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1128                         set_nominal_level(chip, c,
1129                                           ucontrol->value.integer.value[c]);
1130                         changed = 1;
1131                 }
1132         }
1133         if (changed)
1134                 update_output_line_level(chip);
1135         spin_unlock_irq(&chip->lock);
1136         return changed;
1137 }
1138
1139 static struct snd_kcontrol_new snd_echo_output_nominal_level __devinitdata = {
1140         .name = "Line Playback Switch (-10dBV)",
1141         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1142         .info = snd_echo_output_nominal_info,
1143         .get = snd_echo_output_nominal_get,
1144         .put = snd_echo_output_nominal_put,
1145 };
1146
1147 #endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1148
1149
1150
1151 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1152
1153 /*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1154 static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1155                                        struct snd_ctl_elem_info *uinfo)
1156 {
1157         struct echoaudio *chip;
1158
1159         chip = snd_kcontrol_chip(kcontrol);
1160         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1161         uinfo->count = num_analog_busses_in(chip);
1162         uinfo->value.integer.min = 0;
1163         uinfo->value.integer.max = 1;
1164         return 0;
1165 }
1166
1167 static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1168                                       struct snd_ctl_elem_value *ucontrol)
1169 {
1170         struct echoaudio *chip;
1171         int c;
1172
1173         chip = snd_kcontrol_chip(kcontrol);
1174         for (c = 0; c < num_analog_busses_in(chip); c++)
1175                 ucontrol->value.integer.value[c] =
1176                         chip->nominal_level[bx_analog_in(chip) + c];
1177         return 0;
1178 }
1179
1180 static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1181                                       struct snd_ctl_elem_value *ucontrol)
1182 {
1183         struct echoaudio *chip;
1184         int c, changed;
1185
1186         changed = 0;
1187         chip = snd_kcontrol_chip(kcontrol);
1188         spin_lock_irq(&chip->lock);
1189         for (c = 0; c < num_analog_busses_in(chip); c++) {
1190                 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1191                     ucontrol->value.integer.value[c]) {
1192                         set_nominal_level(chip, bx_analog_in(chip) + c,
1193                                           ucontrol->value.integer.value[c]);
1194                         changed = 1;
1195                 }
1196         }
1197         if (changed)
1198                 update_output_line_level(chip); /* "Output" is not a mistake
1199                                                  * here.
1200                                                  */
1201         spin_unlock_irq(&chip->lock);
1202         return changed;
1203 }
1204
1205 static struct snd_kcontrol_new snd_echo_intput_nominal_level __devinitdata = {
1206         .name = "Line Capture Switch (-10dBV)",
1207         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1208         .info = snd_echo_input_nominal_info,
1209         .get = snd_echo_input_nominal_get,
1210         .put = snd_echo_input_nominal_put,
1211 };
1212
1213 #endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1214
1215
1216
1217 #ifdef ECHOCARD_HAS_MONITOR
1218
1219 /******************* Monitor mixer *******************/
1220 static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1221                                struct snd_ctl_elem_info *uinfo)
1222 {
1223         struct echoaudio *chip;
1224
1225         chip = snd_kcontrol_chip(kcontrol);
1226         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1227         uinfo->count = 1;
1228         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1229         uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1230         uinfo->dimen.d[0] = num_busses_out(chip);
1231         uinfo->dimen.d[1] = num_busses_in(chip);
1232         return 0;
1233 }
1234
1235 static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1236                               struct snd_ctl_elem_value *ucontrol)
1237 {
1238         struct echoaudio *chip;
1239
1240         chip = snd_kcontrol_chip(kcontrol);
1241         ucontrol->value.integer.value[0] =
1242                 chip->monitor_gain[ucontrol->id.index / num_busses_in(chip)]
1243                         [ucontrol->id.index % num_busses_in(chip)];
1244         return 0;
1245 }
1246
1247 static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1248                               struct snd_ctl_elem_value *ucontrol)
1249 {
1250         struct echoaudio *chip;
1251         int changed,  gain;
1252         short out, in;
1253
1254         changed = 0;
1255         chip = snd_kcontrol_chip(kcontrol);
1256         out = ucontrol->id.index / num_busses_in(chip);
1257         in = ucontrol->id.index % num_busses_in(chip);
1258         gain = ucontrol->value.integer.value[0];
1259         if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1260                 return -EINVAL;
1261         if (chip->monitor_gain[out][in] != gain) {
1262                 spin_lock_irq(&chip->lock);
1263                 set_monitor_gain(chip, out, in, gain);
1264                 update_output_line_level(chip);
1265                 spin_unlock_irq(&chip->lock);
1266                 changed = 1;
1267         }
1268         return changed;
1269 }
1270
1271 static struct snd_kcontrol_new snd_echo_monitor_mixer __devinitdata = {
1272         .name = "Monitor Mixer Volume",
1273         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1274         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1275         .info = snd_echo_mixer_info,
1276         .get = snd_echo_mixer_get,
1277         .put = snd_echo_mixer_put,
1278         .tlv = {.p = db_scale_output_gain},
1279 };
1280
1281 #endif /* ECHOCARD_HAS_MONITOR */
1282
1283
1284
1285 #ifdef ECHOCARD_HAS_VMIXER
1286
1287 /******************* Vmixer *******************/
1288 static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1289                                 struct snd_ctl_elem_info *uinfo)
1290 {
1291         struct echoaudio *chip;
1292
1293         chip = snd_kcontrol_chip(kcontrol);
1294         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1295         uinfo->count = 1;
1296         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1297         uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1298         uinfo->dimen.d[0] = num_busses_out(chip);
1299         uinfo->dimen.d[1] = num_pipes_out(chip);
1300         return 0;
1301 }
1302
1303 static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1304                                struct snd_ctl_elem_value *ucontrol)
1305 {
1306         struct echoaudio *chip;
1307
1308         chip = snd_kcontrol_chip(kcontrol);
1309         ucontrol->value.integer.value[0] =
1310                 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1311                         [ucontrol->id.index % num_pipes_out(chip)];
1312         return 0;
1313 }
1314
1315 static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1316                                struct snd_ctl_elem_value *ucontrol)
1317 {
1318         struct echoaudio *chip;
1319         int gain, changed;
1320         short vch, out;
1321
1322         changed = 0;
1323         chip = snd_kcontrol_chip(kcontrol);
1324         out = ucontrol->id.index / num_pipes_out(chip);
1325         vch = ucontrol->id.index % num_pipes_out(chip);
1326         gain = ucontrol->value.integer.value[0];
1327         if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1328                 return -EINVAL;
1329         if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1330                 spin_lock_irq(&chip->lock);
1331                 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1332                 update_vmixer_level(chip);
1333                 spin_unlock_irq(&chip->lock);
1334                 changed = 1;
1335         }
1336         return changed;
1337 }
1338
1339 static struct snd_kcontrol_new snd_echo_vmixer __devinitdata = {
1340         .name = "VMixer Volume",
1341         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1342         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1343         .info = snd_echo_vmixer_info,
1344         .get = snd_echo_vmixer_get,
1345         .put = snd_echo_vmixer_put,
1346         .tlv = {.p = db_scale_output_gain},
1347 };
1348
1349 #endif /* ECHOCARD_HAS_VMIXER */
1350
1351
1352
1353 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1354
1355 /******************* Digital mode switch *******************/
1356 static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1357                                       struct snd_ctl_elem_info *uinfo)
1358 {
1359         static char *names[4] = {
1360                 "S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1361                 "S/PDIF Cdrom"
1362         };
1363         struct echoaudio *chip;
1364
1365         chip = snd_kcontrol_chip(kcontrol);
1366         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1367         uinfo->value.enumerated.items = chip->num_digital_modes;
1368         uinfo->count = 1;
1369         if (uinfo->value.enumerated.item >= chip->num_digital_modes)
1370                 uinfo->value.enumerated.item = chip->num_digital_modes - 1;
1371         strcpy(uinfo->value.enumerated.name, names[
1372                         chip->digital_mode_list[uinfo->value.enumerated.item]]);
1373         return 0;
1374 }
1375
1376 static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1377                                      struct snd_ctl_elem_value *ucontrol)
1378 {
1379         struct echoaudio *chip;
1380         int i, mode;
1381
1382         chip = snd_kcontrol_chip(kcontrol);
1383         mode = chip->digital_mode;
1384         for (i = chip->num_digital_modes - 1; i >= 0; i--)
1385                 if (mode == chip->digital_mode_list[i]) {
1386                         ucontrol->value.enumerated.item[0] = i;
1387                         break;
1388                 }
1389         return 0;
1390 }
1391
1392 static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1393                                      struct snd_ctl_elem_value *ucontrol)
1394 {
1395         struct echoaudio *chip;
1396         int changed;
1397         unsigned short emode, dmode;
1398
1399         changed = 0;
1400         chip = snd_kcontrol_chip(kcontrol);
1401
1402         emode = ucontrol->value.enumerated.item[0];
1403         if (emode >= chip->num_digital_modes)
1404                 return -EINVAL;
1405         dmode = chip->digital_mode_list[emode];
1406
1407         if (dmode != chip->digital_mode) {
1408                 /* mode_mutex is required to make this operation atomic wrt
1409                 pcm_digital_*_open() and set_input_clock() functions. */
1410                 mutex_lock(&chip->mode_mutex);
1411
1412                 /* Do not allow the user to change the digital mode when a pcm
1413                 device is open because it also changes the number of channels
1414                 and the allowed sample rates */
1415                 if (atomic_read(&chip->opencount)) {
1416                         changed = -EAGAIN;
1417                 } else {
1418                         changed = set_digital_mode(chip, dmode);
1419                         /* If we had to change the clock source, report it */
1420                         if (changed > 0 && chip->clock_src_ctl) {
1421                                 snd_ctl_notify(chip->card,
1422                                                SNDRV_CTL_EVENT_MASK_VALUE,
1423                                                &chip->clock_src_ctl->id);
1424                                 DE_ACT(("SDM() =%d\n", changed));
1425                         }
1426                         if (changed >= 0)
1427                                 changed = 1;    /* No errors */
1428                 }
1429                 mutex_unlock(&chip->mode_mutex);
1430         }
1431         return changed;
1432 }
1433
1434 static struct snd_kcontrol_new snd_echo_digital_mode_switch __devinitdata = {
1435         .name = "Digital mode Switch",
1436         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1437         .info = snd_echo_digital_mode_info,
1438         .get = snd_echo_digital_mode_get,
1439         .put = snd_echo_digital_mode_put,
1440 };
1441
1442 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1443
1444
1445
1446 #ifdef ECHOCARD_HAS_DIGITAL_IO
1447
1448 /******************* S/PDIF mode switch *******************/
1449 static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1450                                     struct snd_ctl_elem_info *uinfo)
1451 {
1452         static char *names[2] = {"Consumer", "Professional"};
1453
1454         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1455         uinfo->value.enumerated.items = 2;
1456         uinfo->count = 1;
1457         if (uinfo->value.enumerated.item)
1458                 uinfo->value.enumerated.item = 1;
1459         strcpy(uinfo->value.enumerated.name,
1460                names[uinfo->value.enumerated.item]);
1461         return 0;
1462 }
1463
1464 static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1465                                    struct snd_ctl_elem_value *ucontrol)
1466 {
1467         struct echoaudio *chip;
1468
1469         chip = snd_kcontrol_chip(kcontrol);
1470         ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1471         return 0;
1472 }
1473
1474 static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1475                                    struct snd_ctl_elem_value *ucontrol)
1476 {
1477         struct echoaudio *chip;
1478         int mode;
1479
1480         chip = snd_kcontrol_chip(kcontrol);
1481         mode = !!ucontrol->value.enumerated.item[0];
1482         if (mode != chip->professional_spdif) {
1483                 spin_lock_irq(&chip->lock);
1484                 set_professional_spdif(chip, mode);
1485                 spin_unlock_irq(&chip->lock);
1486                 return 1;
1487         }
1488         return 0;
1489 }
1490
1491 static struct snd_kcontrol_new snd_echo_spdif_mode_switch __devinitdata = {
1492         .name = "S/PDIF mode Switch",
1493         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1494         .info = snd_echo_spdif_mode_info,
1495         .get = snd_echo_spdif_mode_get,
1496         .put = snd_echo_spdif_mode_put,
1497 };
1498
1499 #endif /* ECHOCARD_HAS_DIGITAL_IO */
1500
1501
1502
1503 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1504
1505 /******************* Select input clock source *******************/
1506 static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1507                                       struct snd_ctl_elem_info *uinfo)
1508 {
1509         static char *names[8] = {
1510                 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1511                 "ESync96", "MTC"
1512         };
1513         struct echoaudio *chip;
1514
1515         chip = snd_kcontrol_chip(kcontrol);
1516         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1517         uinfo->value.enumerated.items = chip->num_clock_sources;
1518         uinfo->count = 1;
1519         if (uinfo->value.enumerated.item >= chip->num_clock_sources)
1520                 uinfo->value.enumerated.item = chip->num_clock_sources - 1;
1521         strcpy(uinfo->value.enumerated.name, names[
1522                         chip->clock_source_list[uinfo->value.enumerated.item]]);
1523         return 0;
1524 }
1525
1526 static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1527                                      struct snd_ctl_elem_value *ucontrol)
1528 {
1529         struct echoaudio *chip;
1530         int i, clock;
1531
1532         chip = snd_kcontrol_chip(kcontrol);
1533         clock = chip->input_clock;
1534
1535         for (i = 0; i < chip->num_clock_sources; i++)
1536                 if (clock == chip->clock_source_list[i])
1537                         ucontrol->value.enumerated.item[0] = i;
1538
1539         return 0;
1540 }
1541
1542 static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1543                                      struct snd_ctl_elem_value *ucontrol)
1544 {
1545         struct echoaudio *chip;
1546         int changed;
1547         unsigned int eclock, dclock;
1548
1549         changed = 0;
1550         chip = snd_kcontrol_chip(kcontrol);
1551         eclock = ucontrol->value.enumerated.item[0];
1552         if (eclock >= chip->input_clock_types)
1553                 return -EINVAL;
1554         dclock = chip->clock_source_list[eclock];
1555         if (chip->input_clock != dclock) {
1556                 mutex_lock(&chip->mode_mutex);
1557                 spin_lock_irq(&chip->lock);
1558                 if ((changed = set_input_clock(chip, dclock)) == 0)
1559                         changed = 1;    /* no errors */
1560                 spin_unlock_irq(&chip->lock);
1561                 mutex_unlock(&chip->mode_mutex);
1562         }
1563
1564         if (changed < 0)
1565                 DE_ACT(("seticlk val%d err 0x%x\n", dclock, changed));
1566
1567         return changed;
1568 }
1569
1570 static struct snd_kcontrol_new snd_echo_clock_source_switch __devinitdata = {
1571         .name = "Sample Clock Source",
1572         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1573         .info = snd_echo_clock_source_info,
1574         .get = snd_echo_clock_source_get,
1575         .put = snd_echo_clock_source_put,
1576 };
1577
1578 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1579
1580
1581
1582 #ifdef ECHOCARD_HAS_PHANTOM_POWER
1583
1584 /******************* Phantom power switch *******************/
1585 #define snd_echo_phantom_power_info     snd_ctl_boolean_mono_info
1586
1587 static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1588                                       struct snd_ctl_elem_value *ucontrol)
1589 {
1590         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1591
1592         ucontrol->value.integer.value[0] = chip->phantom_power;
1593         return 0;
1594 }
1595
1596 static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1597                                       struct snd_ctl_elem_value *ucontrol)
1598 {
1599         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1600         int power, changed = 0;
1601
1602         power = !!ucontrol->value.integer.value[0];
1603         if (chip->phantom_power != power) {
1604                 spin_lock_irq(&chip->lock);
1605                 changed = set_phantom_power(chip, power);
1606                 spin_unlock_irq(&chip->lock);
1607                 if (changed == 0)
1608                         changed = 1;    /* no errors */
1609         }
1610         return changed;
1611 }
1612
1613 static struct snd_kcontrol_new snd_echo_phantom_power_switch __devinitdata = {
1614         .name = "Phantom power Switch",
1615         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1616         .info = snd_echo_phantom_power_info,
1617         .get = snd_echo_phantom_power_get,
1618         .put = snd_echo_phantom_power_put,
1619 };
1620
1621 #endif /* ECHOCARD_HAS_PHANTOM_POWER */
1622
1623
1624
1625 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1626
1627 /******************* Digital input automute switch *******************/
1628 #define snd_echo_automute_info          snd_ctl_boolean_mono_info
1629
1630 static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1631                                  struct snd_ctl_elem_value *ucontrol)
1632 {
1633         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1634
1635         ucontrol->value.integer.value[0] = chip->digital_in_automute;
1636         return 0;
1637 }
1638
1639 static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1640                                  struct snd_ctl_elem_value *ucontrol)
1641 {
1642         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1643         int automute, changed = 0;
1644
1645         automute = !!ucontrol->value.integer.value[0];
1646         if (chip->digital_in_automute != automute) {
1647                 spin_lock_irq(&chip->lock);
1648                 changed = set_input_auto_mute(chip, automute);
1649                 spin_unlock_irq(&chip->lock);
1650                 if (changed == 0)
1651                         changed = 1;    /* no errors */
1652         }
1653         return changed;
1654 }
1655
1656 static struct snd_kcontrol_new snd_echo_automute_switch __devinitdata = {
1657         .name = "Digital Capture Switch (automute)",
1658         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1659         .info = snd_echo_automute_info,
1660         .get = snd_echo_automute_get,
1661         .put = snd_echo_automute_put,
1662 };
1663
1664 #endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1665
1666
1667
1668 /******************* VU-meters switch *******************/
1669 #define snd_echo_vumeters_switch_info           snd_ctl_boolean_mono_info
1670
1671 static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1672                                         struct snd_ctl_elem_value *ucontrol)
1673 {
1674         struct echoaudio *chip;
1675
1676         chip = snd_kcontrol_chip(kcontrol);
1677         spin_lock_irq(&chip->lock);
1678         set_meters_on(chip, ucontrol->value.integer.value[0]);
1679         spin_unlock_irq(&chip->lock);
1680         return 1;
1681 }
1682
1683 static struct snd_kcontrol_new snd_echo_vumeters_switch __devinitdata = {
1684         .name = "VU-meters Switch",
1685         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1686         .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1687         .info = snd_echo_vumeters_switch_info,
1688         .put = snd_echo_vumeters_switch_put,
1689 };
1690
1691
1692
1693 /***** Read VU-meters (input, output, analog and digital together) *****/
1694 static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1695                                   struct snd_ctl_elem_info *uinfo)
1696 {
1697         struct echoaudio *chip;
1698
1699         chip = snd_kcontrol_chip(kcontrol);
1700         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1701         uinfo->count = 96;
1702         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1703         uinfo->value.integer.max = 0;
1704 #ifdef ECHOCARD_HAS_VMIXER
1705         uinfo->dimen.d[0] = 3;  /* Out, In, Virt */
1706 #else
1707         uinfo->dimen.d[0] = 2;  /* Out, In */
1708 #endif
1709         uinfo->dimen.d[1] = 16; /* 16 channels */
1710         uinfo->dimen.d[2] = 2;  /* 0=level, 1=peak */
1711         return 0;
1712 }
1713
1714 static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1715                                  struct snd_ctl_elem_value *ucontrol)
1716 {
1717         struct echoaudio *chip;
1718
1719         chip = snd_kcontrol_chip(kcontrol);
1720         get_audio_meters(chip, ucontrol->value.integer.value);
1721         return 0;
1722 }
1723
1724 static struct snd_kcontrol_new snd_echo_vumeters __devinitdata = {
1725         .name = "VU-meters",
1726         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1727         .access = SNDRV_CTL_ELEM_ACCESS_READ |
1728                   SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1729                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1730         .info = snd_echo_vumeters_info,
1731         .get = snd_echo_vumeters_get,
1732         .tlv = {.p = db_scale_output_gain},
1733 };
1734
1735
1736
1737 /*** Channels info - it exports informations about the number of channels ***/
1738 static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1739                                        struct snd_ctl_elem_info *uinfo)
1740 {
1741         struct echoaudio *chip;
1742
1743         chip = snd_kcontrol_chip(kcontrol);
1744         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1745         uinfo->count = 6;
1746         uinfo->value.integer.min = 0;
1747         uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1748         return 0;
1749 }
1750
1751 static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1752                                       struct snd_ctl_elem_value *ucontrol)
1753 {
1754         struct echoaudio *chip;
1755         int detected, clocks, bit, src;
1756
1757         chip = snd_kcontrol_chip(kcontrol);
1758         ucontrol->value.integer.value[0] = num_busses_in(chip);
1759         ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1760         ucontrol->value.integer.value[2] = num_busses_out(chip);
1761         ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1762         ucontrol->value.integer.value[4] = num_pipes_out(chip);
1763
1764         /* Compute the bitmask of the currently valid input clocks */
1765         detected = detect_input_clocks(chip);
1766         clocks = 0;
1767         src = chip->num_clock_sources - 1;
1768         for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1769                 if (detected & (1 << bit))
1770                         for (; src >= 0; src--)
1771                                 if (bit == chip->clock_source_list[src]) {
1772                                         clocks |= 1 << src;
1773                                         break;
1774                                 }
1775         ucontrol->value.integer.value[5] = clocks;
1776
1777         return 0;
1778 }
1779
1780 static struct snd_kcontrol_new snd_echo_channels_info __devinitdata = {
1781         .name = "Channels info",
1782         .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1783         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1784         .info = snd_echo_channels_info_info,
1785         .get = snd_echo_channels_info_get,
1786 };
1787
1788
1789
1790
1791 /******************************************************************************
1792         IRQ Handler
1793 ******************************************************************************/
1794
1795 static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
1796 {
1797         struct echoaudio *chip = dev_id;
1798         struct snd_pcm_substream *substream;
1799         int period, ss, st;
1800
1801         spin_lock(&chip->lock);
1802         st = service_irq(chip);
1803         if (st < 0) {
1804                 spin_unlock(&chip->lock);
1805                 return IRQ_NONE;
1806         }
1807         /* The hardware doesn't tell us which substream caused the irq,
1808         thus we have to check all running substreams. */
1809         for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1810                 if ((substream = chip->substream[ss])) {
1811                         period = pcm_pointer(substream) /
1812                                 substream->runtime->period_size;
1813                         if (period != chip->last_period[ss]) {
1814                                 chip->last_period[ss] = period;
1815                                 spin_unlock(&chip->lock);
1816                                 snd_pcm_period_elapsed(substream);
1817                                 spin_lock(&chip->lock);
1818                         }
1819                 }
1820         }
1821         spin_unlock(&chip->lock);
1822
1823 #ifdef ECHOCARD_HAS_MIDI
1824         if (st > 0 && chip->midi_in) {
1825                 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1826                 DE_MID(("rawmidi_iread=%d\n", st));
1827         }
1828 #endif
1829         return IRQ_HANDLED;
1830 }
1831
1832
1833
1834
1835 /******************************************************************************
1836         Module construction / destruction
1837 ******************************************************************************/
1838
1839 static int snd_echo_free(struct echoaudio *chip)
1840 {
1841         DE_INIT(("Stop DSP...\n"));
1842         if (chip->comm_page)
1843                 rest_in_peace(chip);
1844         DE_INIT(("Stopped.\n"));
1845
1846         if (chip->irq >= 0)
1847                 free_irq(chip->irq, chip);
1848
1849         if (chip->comm_page)
1850                 snd_dma_free_pages(&chip->commpage_dma_buf);
1851
1852         if (chip->dsp_registers)
1853                 iounmap(chip->dsp_registers);
1854
1855         if (chip->iores)
1856                 release_and_free_resource(chip->iores);
1857
1858         DE_INIT(("MMIO freed.\n"));
1859
1860         pci_disable_device(chip->pci);
1861
1862         /* release chip data */
1863         kfree(chip);
1864         DE_INIT(("Chip freed.\n"));
1865         return 0;
1866 }
1867
1868
1869
1870 static int snd_echo_dev_free(struct snd_device *device)
1871 {
1872         struct echoaudio *chip = device->device_data;
1873
1874         DE_INIT(("snd_echo_dev_free()...\n"));
1875         return snd_echo_free(chip);
1876 }
1877
1878
1879
1880 /* <--snd_echo_probe() */
1881 static __devinit int snd_echo_create(struct snd_card *card,
1882                                      struct pci_dev *pci,
1883                                      struct echoaudio **rchip)
1884 {
1885         struct echoaudio *chip;
1886         int err;
1887         size_t sz;
1888         static struct snd_device_ops ops = {
1889                 .dev_free = snd_echo_dev_free,
1890         };
1891
1892         *rchip = NULL;
1893
1894         pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1895
1896         if ((err = pci_enable_device(pci)) < 0)
1897                 return err;
1898         pci_set_master(pci);
1899
1900         /* allocate a chip-specific data */
1901         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1902         if (!chip) {
1903                 pci_disable_device(pci);
1904                 return -ENOMEM;
1905         }
1906         DE_INIT(("chip=%p\n", chip));
1907
1908         spin_lock_init(&chip->lock);
1909         chip->card = card;
1910         chip->pci = pci;
1911         chip->irq = -1;
1912
1913         /* PCI resource allocation */
1914         chip->dsp_registers_phys = pci_resource_start(pci, 0);
1915         sz = pci_resource_len(pci, 0);
1916         if (sz > PAGE_SIZE)
1917                 sz = PAGE_SIZE;         /* We map only the required part */
1918
1919         if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1920                                               ECHOCARD_NAME)) == NULL) {
1921                 snd_echo_free(chip);
1922                 snd_printk(KERN_ERR "cannot get memory region\n");
1923                 return -EBUSY;
1924         }
1925         chip->dsp_registers = (volatile u32 __iomem *)
1926                 ioremap_nocache(chip->dsp_registers_phys, sz);
1927
1928         if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1929                         ECHOCARD_NAME, chip)) {
1930                 snd_echo_free(chip);
1931                 snd_printk(KERN_ERR "cannot grab irq\n");
1932                 return -EBUSY;
1933         }
1934         chip->irq = pci->irq;
1935         DE_INIT(("pci=%p irq=%d subdev=%04x Init hardware...\n",
1936                  chip->pci, chip->irq, chip->pci->subsystem_device));
1937
1938         /* Create the DSP comm page - this is the area of memory used for most
1939         of the communication with the DSP, which accesses it via bus mastering */
1940         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
1941                                 sizeof(struct comm_page),
1942                                 &chip->commpage_dma_buf) < 0) {
1943                 snd_echo_free(chip);
1944                 snd_printk(KERN_ERR "cannot allocate the comm page\n");
1945                 return -ENOMEM;
1946         }
1947         chip->comm_page_phys = chip->commpage_dma_buf.addr;
1948         chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1949
1950         err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1951         if (err) {
1952                 DE_INIT(("init_hw err=%d\n", err));
1953                 snd_echo_free(chip);
1954                 return err;
1955         }
1956         DE_INIT(("Card init OK\n"));
1957
1958         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1959                 snd_echo_free(chip);
1960                 return err;
1961         }
1962         atomic_set(&chip->opencount, 0);
1963         mutex_init(&chip->mode_mutex);
1964         chip->can_set_rate = 1;
1965         *rchip = chip;
1966         /* Init done ! */
1967         return 0;
1968 }
1969
1970
1971
1972 /* constructor */
1973 static int __devinit snd_echo_probe(struct pci_dev *pci,
1974                                     const struct pci_device_id *pci_id)
1975 {
1976         static int dev;
1977         struct snd_card *card;
1978         struct echoaudio *chip;
1979         char *dsp;
1980         int i, err;
1981
1982         if (dev >= SNDRV_CARDS)
1983                 return -ENODEV;
1984         if (!enable[dev]) {
1985                 dev++;
1986                 return -ENOENT;
1987         }
1988
1989         DE_INIT(("Echoaudio driver starting...\n"));
1990         i = 0;
1991         err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
1992         if (err < 0)
1993                 return err;
1994
1995         snd_card_set_dev(card, &pci->dev);
1996
1997         if ((err = snd_echo_create(card, pci, &chip)) < 0) {
1998                 snd_card_free(card);
1999                 return err;
2000         }
2001
2002         strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2003         strcpy(card->shortname, chip->card_name);
2004
2005         dsp = "56301";
2006         if (pci_id->device == 0x3410)
2007                 dsp = "56361";
2008
2009         sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2010                 card->shortname, pci_id->subdevice & 0x000f, dsp,
2011                 chip->dsp_registers_phys, chip->irq);
2012
2013         if ((err = snd_echo_new_pcm(chip)) < 0) {
2014                 snd_printk(KERN_ERR "new pcm error %d\n", err);
2015                 snd_card_free(card);
2016                 return err;
2017         }
2018
2019 #ifdef ECHOCARD_HAS_MIDI
2020         if (chip->has_midi) {   /* Some Mia's do not have midi */
2021                 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2022                         snd_printk(KERN_ERR "new midi error %d\n", err);
2023                         snd_card_free(card);
2024                         return err;
2025                 }
2026         }
2027 #endif
2028
2029 #ifdef ECHOCARD_HAS_VMIXER
2030         snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
2031         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2032                 goto ctl_error;
2033 #else
2034         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_pcm_output_gain, chip))) < 0)
2035                 goto ctl_error;
2036 #endif
2037
2038 #ifdef ECHOCARD_HAS_INPUT_GAIN
2039         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2040                 goto ctl_error;
2041 #endif
2042
2043 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2044         if (!chip->hasnt_input_nominal_level)
2045                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2046                         goto ctl_error;
2047 #endif
2048
2049 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2050         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2051                 goto ctl_error;
2052 #endif
2053
2054         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2055                 goto ctl_error;
2056
2057         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2058                 goto ctl_error;
2059
2060 #ifdef ECHOCARD_HAS_MONITOR
2061         snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2062         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2063                 goto ctl_error;
2064 #endif
2065
2066 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2067         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2068                 goto ctl_error;
2069 #endif
2070
2071         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2072                 goto ctl_error;
2073
2074 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2075         /* Creates a list of available digital modes */
2076         chip->num_digital_modes = 0;
2077         for (i = 0; i < 6; i++)
2078                 if (chip->digital_modes & (1 << i))
2079                         chip->digital_mode_list[chip->num_digital_modes++] = i;
2080
2081         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2082                 goto ctl_error;
2083 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2084
2085 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2086         /* Creates a list of available clock sources */
2087         chip->num_clock_sources = 0;
2088         for (i = 0; i < 10; i++)
2089                 if (chip->input_clock_types & (1 << i))
2090                         chip->clock_source_list[chip->num_clock_sources++] = i;
2091
2092         if (chip->num_clock_sources > 1) {
2093                 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2094                 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2095                         goto ctl_error;
2096         }
2097 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2098
2099 #ifdef ECHOCARD_HAS_DIGITAL_IO
2100         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2101                 goto ctl_error;
2102 #endif
2103
2104 #ifdef ECHOCARD_HAS_PHANTOM_POWER
2105         if (chip->has_phantom_power)
2106                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2107                         goto ctl_error;
2108 #endif
2109
2110         if ((err = snd_card_register(card)) < 0) {
2111                 snd_card_free(card);
2112                 goto ctl_error;
2113         }
2114         snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
2115
2116         pci_set_drvdata(pci, chip);
2117         dev++;
2118         return 0;
2119
2120 ctl_error:
2121         snd_printk(KERN_ERR "new control error %d\n", err);
2122         snd_card_free(card);
2123         return err;
2124 }
2125
2126
2127
2128 static void __devexit snd_echo_remove(struct pci_dev *pci)
2129 {
2130         struct echoaudio *chip;
2131
2132         chip = pci_get_drvdata(pci);
2133         if (chip)
2134                 snd_card_free(chip->card);
2135         pci_set_drvdata(pci, NULL);
2136 }
2137
2138
2139
2140 /******************************************************************************
2141         Everything starts and ends here
2142 ******************************************************************************/
2143
2144 /* pci_driver definition */
2145 static struct pci_driver driver = {
2146         .name = "Echoaudio " ECHOCARD_NAME,
2147         .id_table = snd_echo_ids,
2148         .probe = snd_echo_probe,
2149         .remove = __devexit_p(snd_echo_remove),
2150 };
2151
2152
2153
2154 /* initialization of the module */
2155 static int __init alsa_card_echo_init(void)
2156 {
2157         return pci_register_driver(&driver);
2158 }
2159
2160
2161
2162 /* clean up the module */
2163 static void __exit alsa_card_echo_exit(void)
2164 {
2165         pci_unregister_driver(&driver);
2166 }
2167
2168
2169 module_init(alsa_card_echo_init)
2170 module_exit(alsa_card_echo_exit)