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