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