SAFE public projects git trees. - safe/jmp/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         down(&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         up(&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         down(&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         up(&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 snd_sg_buf *sgbuf;
 494         struct audiopipe *pipe;
 495
 496         chip = snd_pcm_substream_chip(substream);
 497         pipe = (struct audiopipe *) substream->runtime->private_data;
 498
 499         /* Sets up che hardware. If it's already initialized, reset and
 500          * redo with the new parameters
 501          */
 502         spin_lock_irq(&chip->lock);
 503         if (pipe->index >= 0) {
 504                 DE_HWP(("hwp_ie free(%d)\n", pipe->index));
 505                 err = free_pipes(chip, pipe);
 506                 snd_assert(!err);
 507                 chip->substream[pipe->index] = NULL;
 508         }
 509
 510         err = allocate_pipes(chip, pipe, pipe_index, interleave);
 511         if (err < 0) {
 512                 spin_unlock_irq(&chip->lock);
 513                 DE_ACT((KERN_NOTICE "allocate_pipes(%d) err=%d\n",
 514                         pipe_index, err));
 515                 return err;
 516         }
 517         spin_unlock_irq(&chip->lock);
 518         DE_ACT((KERN_NOTICE "allocate_pipes()=%d\n", pipe_index));
 519
 520         DE_HWP(("pcm_hw_params (bufsize=%dB periods=%d persize=%dB)\n",
 521                 params_buffer_bytes(hw_params), params_periods(hw_params),
 522                 params_period_bytes(hw_params)));
 523         err = snd_pcm_lib_malloc_pages(substream,
 524                                        params_buffer_bytes(hw_params));
 525         if (err < 0) {
 526                 snd_printk(KERN_ERR "malloc_pages err=%d\n", err);
 527                 spin_lock_irq(&chip->lock);
 528                 free_pipes(chip, pipe);
 529                 spin_unlock_irq(&chip->lock);
 530                 pipe->index = -1;
 531                 return err;
 532         }
 533
 534         sgbuf = snd_pcm_substream_sgbuf(substream);
 535
 536         DE_HWP(("pcm_hw_params table size=%d pages=%d\n",
 537                 sgbuf->size, sgbuf->pages));
 538         sglist_init(chip, pipe);
 539         edge = PAGE_SIZE;
 540         for (offs = page = per = 0; offs < params_buffer_bytes(hw_params);
 541              per++) {
 542                 rest = params_period_bytes(hw_params);
 543                 if (offs + rest > params_buffer_bytes(hw_params))
 544                         rest = params_buffer_bytes(hw_params) - offs;
 545                 while (rest) {
 546                         if (rest <= edge - offs) {
 547                                 sglist_add_mapping(chip, pipe,
 548                                                    snd_sgbuf_get_addr(sgbuf, offs),
 549                                                    rest);
 550                                 sglist_add_irq(chip, pipe);
 551                                 offs += rest;
 552                                 rest = 0;
 553                         } else {
 554                                 sglist_add_mapping(chip, pipe,
 555                                                    snd_sgbuf_get_addr(sgbuf, offs),
 556                                                    edge - offs);
 557                                 rest -= edge - offs;
 558                                 offs = edge;
 559                         }
 560                         if (offs == edge) {
 561                                 edge += PAGE_SIZE;
 562                                 page++;
 563                         }
 564                 }
 565         }
 566
 567         /* Close the ring buffer */
 568         sglist_wrap(chip, pipe);
 569
 570         /* This stuff is used by the irq handler, so it must be
 571          * initialized before chip->substream
 572          */
 573         chip->last_period[pipe_index] = 0;
 574         pipe->last_counter = 0;
 575         pipe->position = 0;
 576         smp_wmb();
 577         chip->substream[pipe_index] = substream;
 578         chip->rate_set = 1;
 579         spin_lock_irq(&chip->lock);
 580         set_sample_rate(chip, hw_params->rate_num / hw_params->rate_den);
 581         spin_unlock_irq(&chip->lock);
 582         DE_HWP(("pcm_hw_params ok\n"));
 583         return 0;
 584 }
 585
 586
 587
 588 static int pcm_analog_in_hw_params(struct snd_pcm_substream *substream,
 589                                    struct snd_pcm_hw_params *hw_params)
 590 {
 591         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 592
 593         return init_engine(substream, hw_params, px_analog_in(chip) +
 594                         substream->number, params_channels(hw_params));
 595 }
 596
 597
 598
 599 static int pcm_analog_out_hw_params(struct snd_pcm_substream *substream,
 600                                     struct snd_pcm_hw_params *hw_params)
 601 {
 602         return init_engine(substream, hw_params, substream->number,
 603                            params_channels(hw_params));
 604 }
 605
 606
 607
 608 #ifdef ECHOCARD_HAS_DIGITAL_IO
 609
 610 static int pcm_digital_in_hw_params(struct snd_pcm_substream *substream,
 611                                     struct snd_pcm_hw_params *hw_params)
 612 {
 613         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 614
 615         return init_engine(substream, hw_params, px_digital_in(chip) +
 616                         substream->number, params_channels(hw_params));
 617 }
 618
 619
 620
 621 #ifndef ECHOCARD_HAS_VMIXER     /* See the note in snd_echo_new_pcm() */
 622 static int pcm_digital_out_hw_params(struct snd_pcm_substream *substream,
 623                                      struct snd_pcm_hw_params *hw_params)
 624 {
 625         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 626
 627         return init_engine(substream, hw_params, px_digital_out(chip) +
 628                         substream->number, params_channels(hw_params));
 629 }
 630 #endif /* !ECHOCARD_HAS_VMIXER */
 631
 632 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 633
 634
 635
 636 static int pcm_hw_free(struct snd_pcm_substream *substream)
 637 {
 638         struct echoaudio *chip;
 639         struct audiopipe *pipe;
 640
 641         chip = snd_pcm_substream_chip(substream);
 642         pipe = (struct audiopipe *) substream->runtime->private_data;
 643
 644         spin_lock_irq(&chip->lock);
 645         if (pipe->index >= 0) {
 646                 DE_HWP(("pcm_hw_free(%d)\n", pipe->index));
 647                 free_pipes(chip, pipe);
 648                 chip->substream[pipe->index] = NULL;
 649                 pipe->index = -1;
 650         }
 651         spin_unlock_irq(&chip->lock);
 652
 653         DE_HWP(("pcm_hw_freed\n"));
 654         snd_pcm_lib_free_pages(substream);
 655         return 0;
 656 }
 657
 658
 659
 660 static int pcm_prepare(struct snd_pcm_substream *substream)
 661 {
 662         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 663         struct snd_pcm_runtime *runtime = substream->runtime;
 664         struct audioformat format;
 665         int pipe_index = ((struct audiopipe *)runtime->private_data)->index;
 666
 667         DE_HWP(("Prepare rate=%d format=%d channels=%d\n",
 668                 runtime->rate, runtime->format, runtime->channels));
 669         format.interleave = runtime->channels;
 670         format.data_are_bigendian = 0;
 671         format.mono_to_stereo = 0;
 672         switch (runtime->format) {
 673         case SNDRV_PCM_FORMAT_U8:
 674                 format.bits_per_sample = 8;
 675                 break;
 676         case SNDRV_PCM_FORMAT_S16_LE:
 677                 format.bits_per_sample = 16;
 678                 break;
 679         case SNDRV_PCM_FORMAT_S24_3LE:
 680                 format.bits_per_sample = 24;
 681                 break;
 682         case SNDRV_PCM_FORMAT_S32_BE:
 683                 format.data_are_bigendian = 1;
 684         case SNDRV_PCM_FORMAT_S32_LE:
 685                 format.bits_per_sample = 32;
 686                 break;
 687         default:
 688                 DE_HWP(("Prepare error: unsupported format %d\n",
 689                         runtime->format));
 690                 return -EINVAL;
 691         }
 692
 693         snd_assert(pipe_index < px_num(chip), return -EINVAL);
 694         snd_assert(is_pipe_allocated(chip, pipe_index), return -EINVAL);
 695         set_audio_format(chip, pipe_index, &format);
 696         return 0;
 697 }
 698
 699
 700
 701 static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 702 {
 703         struct echoaudio *chip = snd_pcm_substream_chip(substream);
 704         struct snd_pcm_runtime *runtime = substream->runtime;
 705         struct audiopipe *pipe = runtime->private_data;
 706         int i, err;
 707         u32 channelmask = 0;
 708         struct list_head *pos;
 709         struct snd_pcm_substream *s;
 710
 711         snd_pcm_group_for_each(pos, substream) {
 712                 s = snd_pcm_group_substream_entry(pos);
 713                 for (i = 0; i < DSP_MAXPIPES; i++) {
 714                         if (s == chip->substream[i]) {
 715                                 channelmask |= 1 << i;
 716                                 snd_pcm_trigger_done(s, substream);
 717                         }
 718                 }
 719         }
 720
 721         spin_lock(&chip->lock);
 722         switch (cmd) {
 723         case SNDRV_PCM_TRIGGER_START:
 724         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 725                 DE_ACT(("pcm_trigger start\n"));
 726                 for (i = 0; i < DSP_MAXPIPES; i++) {
 727                         if (channelmask & (1 << i)) {
 728                                 pipe = chip->substream[i]->runtime->private_data;
 729                                 switch (pipe->state) {
 730                                 case PIPE_STATE_STOPPED:
 731                                         chip->last_period[i] = 0;
 732                                         pipe->last_counter = 0;
 733                                         pipe->position = 0;
 734                                         *pipe->dma_counter = 0;
 735                                 case PIPE_STATE_PAUSED:
 736                                         pipe->state = PIPE_STATE_STARTED;
 737                                         break;
 738                                 case PIPE_STATE_STARTED:
 739                                         break;
 740                                 }
 741                         }
 742                 }
 743                 err = start_transport(chip, channelmask,
 744                                       chip->pipe_cyclic_mask);
 745                 break;
 746         case SNDRV_PCM_TRIGGER_STOP:
 747                 DE_ACT(("pcm_trigger stop\n"));
 748                 for (i = 0; i < DSP_MAXPIPES; i++) {
 749                         if (channelmask & (1 << i)) {
 750                                 pipe = chip->substream[i]->runtime->private_data;
 751                                 pipe->state = PIPE_STATE_STOPPED;
 752                         }
 753                 }
 754                 err = stop_transport(chip, channelmask);
 755                 break;
 756         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 757                 DE_ACT(("pcm_trigger pause\n"));
 758                 for (i = 0; i < DSP_MAXPIPES; i++) {
 759                         if (channelmask & (1 << i)) {
 760                                 pipe = chip->substream[i]->runtime->private_data;
 761                                 pipe->state = PIPE_STATE_PAUSED;
 762                         }
 763                 }
 764                 err = pause_transport(chip, channelmask);
 765                 break;
 766         default:
 767                 err = -EINVAL;
 768         }
 769         spin_unlock(&chip->lock);
 770         return err;
 771 }
 772
 773
 774
 775 static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
 776 {
 777         struct snd_pcm_runtime *runtime = substream->runtime;
 778         struct audiopipe *pipe = runtime->private_data;
 779         size_t cnt, bufsize, pos;
 780
 781         cnt = le32_to_cpu(*pipe->dma_counter);
 782         pipe->position += cnt - pipe->last_counter;
 783         pipe->last_counter = cnt;
 784         bufsize = substream->runtime->buffer_size;
 785         pos = bytes_to_frames(substream->runtime, pipe->position);
 786
 787         while (pos >= bufsize) {
 788                 pipe->position -= frames_to_bytes(substream->runtime, bufsize);
 789                 pos -= bufsize;
 790         }
 791         return pos;
 792 }
 793
 794
 795
 796 /* pcm *_ops structures */
 797 static struct snd_pcm_ops analog_playback_ops = {
 798         .open = pcm_analog_out_open,
 799         .close = pcm_close,
 800         .ioctl = snd_pcm_lib_ioctl,
 801         .hw_params = pcm_analog_out_hw_params,
 802         .hw_free = pcm_hw_free,
 803         .prepare = pcm_prepare,
 804         .trigger = pcm_trigger,
 805         .pointer = pcm_pointer,
 806         .page = snd_pcm_sgbuf_ops_page,
 807 };
 808 static struct snd_pcm_ops analog_capture_ops = {
 809         .open = pcm_analog_in_open,
 810         .close = pcm_close,
 811         .ioctl = snd_pcm_lib_ioctl,
 812         .hw_params = pcm_analog_in_hw_params,
 813         .hw_free = pcm_hw_free,
 814         .prepare = pcm_prepare,
 815         .trigger = pcm_trigger,
 816         .pointer = pcm_pointer,
 817         .page = snd_pcm_sgbuf_ops_page,
 818 };
 819 #ifdef ECHOCARD_HAS_DIGITAL_IO
 820 #ifndef ECHOCARD_HAS_VMIXER
 821 static struct snd_pcm_ops digital_playback_ops = {
 822         .open = pcm_digital_out_open,
 823         .close = pcm_close,
 824         .ioctl = snd_pcm_lib_ioctl,
 825         .hw_params = pcm_digital_out_hw_params,
 826         .hw_free = pcm_hw_free,
 827         .prepare = pcm_prepare,
 828         .trigger = pcm_trigger,
 829         .pointer = pcm_pointer,
 830         .page = snd_pcm_sgbuf_ops_page,
 831 };
 832 #endif /* !ECHOCARD_HAS_VMIXER */
 833 static struct snd_pcm_ops digital_capture_ops = {
 834         .open = pcm_digital_in_open,
 835         .close = pcm_close,
 836         .ioctl = snd_pcm_lib_ioctl,
 837         .hw_params = pcm_digital_in_hw_params,
 838         .hw_free = pcm_hw_free,
 839         .prepare = pcm_prepare,
 840         .trigger = pcm_trigger,
 841         .pointer = pcm_pointer,
 842         .page = snd_pcm_sgbuf_ops_page,
 843 };
 844 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 845
 846
 847
 848 /* Preallocate memory only for the first substream because it's the most
 849  * used one
 850  */
 851 static int snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
 852 {
 853         struct snd_pcm_substream *ss;
 854         int stream, err;
 855
 856         for (stream = 0; stream < 2; stream++)
 857                 for (ss = pcm->streams[stream].substream; ss; ss = ss->next) {
 858                         err = snd_pcm_lib_preallocate_pages(ss, SNDRV_DMA_TYPE_DEV_SG,
 859                                                             dev,
 860                                                             ss->number ? 0 : 128<<10,
 861                                                             256<<10);
 862                         if (err < 0)
 863                                 return err;
 864                 }
 865         return 0;
 866 }
 867
 868
 869
 870 /*<--snd_echo_probe() */
 871 static int __devinit snd_echo_new_pcm(struct echoaudio *chip)
 872 {
 873         struct snd_pcm *pcm;
 874         int err;
 875
 876 #ifdef ECHOCARD_HAS_VMIXER
 877         /* This card has a Vmixer, that is there is no direct mapping from PCM
 878         streams to physical outputs. The user can mix the streams as he wishes
 879         via control interface and it's possible to send any stream to any
 880         output, thus it makes no sense to keep analog and digital outputs
 881         separated */
 882
 883         /* PCM#0 Virtual outputs and analog inputs */
 884         if ((err = snd_pcm_new(chip->card, "PCM", 0, num_pipes_out(chip),
 885                                 num_analog_busses_in(chip), &pcm)) < 0)
 886                 return err;
 887         pcm->private_data = chip;
 888         chip->analog_pcm = pcm;
 889         strcpy(pcm->name, chip->card->shortname);
 890         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
 891         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
 892         if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
 893                 return err;
 894         DE_INIT(("Analog PCM ok\n"));
 895
 896 #ifdef ECHOCARD_HAS_DIGITAL_IO
 897         /* PCM#1 Digital inputs, no outputs */
 898         if ((err = snd_pcm_new(chip->card, "Digital PCM", 1, 0,
 899                                num_digital_busses_in(chip), &pcm)) < 0)
 900                 return err;
 901         pcm->private_data = chip;
 902         chip->digital_pcm = pcm;
 903         strcpy(pcm->name, chip->card->shortname);
 904         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
 905         if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
 906                 return err;
 907         DE_INIT(("Digital PCM ok\n"));
 908 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 909
 910 #else /* ECHOCARD_HAS_VMIXER */
 911
 912         /* The card can manage substreams formed by analog and digital channels
 913         at the same time, but I prefer to keep analog and digital channels
 914         separated, because that mixed thing is confusing and useless. So we
 915         register two PCM devices: */
 916
 917         /* PCM#0 Analog i/o */
 918         if ((err = snd_pcm_new(chip->card, "Analog PCM", 0,
 919                                num_analog_busses_out(chip),
 920                                num_analog_busses_in(chip), &pcm)) < 0)
 921                 return err;
 922         pcm->private_data = chip;
 923         chip->analog_pcm = pcm;
 924         strcpy(pcm->name, chip->card->shortname);
 925         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &analog_playback_ops);
 926         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops);
 927         if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
 928                 return err;
 929         DE_INIT(("Analog PCM ok\n"));
 930
 931 #ifdef ECHOCARD_HAS_DIGITAL_IO
 932         /* PCM#1 Digital i/o */
 933         if ((err = snd_pcm_new(chip->card, "Digital PCM", 1,
 934                                num_digital_busses_out(chip),
 935                                num_digital_busses_in(chip), &pcm)) < 0)
 936                 return err;
 937         pcm->private_data = chip;
 938         chip->digital_pcm = pcm;
 939         strcpy(pcm->name, chip->card->shortname);
 940         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &digital_playback_ops);
 941         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops);
 942         if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0)
 943                 return err;
 944         DE_INIT(("Digital PCM ok\n"));
 945 #endif /* ECHOCARD_HAS_DIGITAL_IO */
 946
 947 #endif /* ECHOCARD_HAS_VMIXER */
 948
 949         return 0;
 950 }
 951
 952
 953
 954
 955 /******************************************************************************
 956         Control interface
 957 ******************************************************************************/
 958
 959 /******************* PCM output volume *******************/
 960 static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
 961                                      struct snd_ctl_elem_info *uinfo)
 962 {
 963         struct echoaudio *chip;
 964
 965         chip = snd_kcontrol_chip(kcontrol);
 966         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 967         uinfo->count = num_busses_out(chip);
 968         uinfo->value.integer.min = ECHOGAIN_MINOUT;
 969         uinfo->value.integer.max = ECHOGAIN_MAXOUT;
 970         return 0;
 971 }
 972
 973 static int snd_echo_output_gain_get(struct snd_kcontrol *kcontrol,
 974                                     struct snd_ctl_elem_value *ucontrol)
 975 {
 976         struct echoaudio *chip;
 977         int c;
 978
 979         chip = snd_kcontrol_chip(kcontrol);
 980         for (c = 0; c < num_busses_out(chip); c++)
 981                 ucontrol->value.integer.value[c] = chip->output_gain[c];
 982         return 0;
 983 }
 984
 985 static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
 986                                     struct snd_ctl_elem_value *ucontrol)
 987 {
 988         struct echoaudio *chip;
 989         int c, changed, gain;
 990
 991         changed = 0;
 992         chip = snd_kcontrol_chip(kcontrol);
 993         spin_lock_irq(&chip->lock);
 994         for (c = 0; c < num_busses_out(chip); c++) {
 995                 gain = ucontrol->value.integer.value[c];
 996                 /* Ignore out of range values */
 997                 if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
 998                         continue;
 999                 if (chip->output_gain[c] != gain) {
1000                         set_output_gain(chip, c, gain);
1001                         changed = 1;
1002                 }
1003         }
1004         if (changed)
1005                 update_output_line_level(chip);
1006         spin_unlock_irq(&chip->lock);
1007         return changed;
1008 }
1009
1010 #ifdef ECHOCARD_HAS_VMIXER
1011 /* On Vmixer cards this one controls the line-out volume */
1012 static struct snd_kcontrol_new snd_echo_line_output_gain __devinitdata = {
1013         .name = "Line Playback Volume",
1014         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1015         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1016         .info = snd_echo_output_gain_info,
1017         .get = snd_echo_output_gain_get,
1018         .put = snd_echo_output_gain_put,
1019         .tlv = {.p = db_scale_output_gain},
1020 };
1021 #else
1022 static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
1023         .name = "PCM Playback Volume",
1024         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1025         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1026         .info = snd_echo_output_gain_info,
1027         .get = snd_echo_output_gain_get,
1028         .put = snd_echo_output_gain_put,
1029         .tlv = {.p = db_scale_output_gain},
1030 };
1031 #endif
1032
1033
1034
1035 #ifdef ECHOCARD_HAS_INPUT_GAIN
1036
1037 /******************* Analog input volume *******************/
1038 static int snd_echo_input_gain_info(struct snd_kcontrol *kcontrol,
1039                                     struct snd_ctl_elem_info *uinfo)
1040 {
1041         struct echoaudio *chip;
1042
1043         chip = snd_kcontrol_chip(kcontrol);
1044         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1045         uinfo->count = num_analog_busses_in(chip);
1046         uinfo->value.integer.min = ECHOGAIN_MININP;
1047         uinfo->value.integer.max = ECHOGAIN_MAXINP;
1048         return 0;
1049 }
1050
1051 static int snd_echo_input_gain_get(struct snd_kcontrol *kcontrol,
1052                                    struct snd_ctl_elem_value *ucontrol)
1053 {
1054         struct echoaudio *chip;
1055         int c;
1056
1057         chip = snd_kcontrol_chip(kcontrol);
1058         for (c = 0; c < num_analog_busses_in(chip); c++)
1059                 ucontrol->value.integer.value[c] = chip->input_gain[c];
1060         return 0;
1061 }
1062
1063 static int snd_echo_input_gain_put(struct snd_kcontrol *kcontrol,
1064                                    struct snd_ctl_elem_value *ucontrol)
1065 {
1066         struct echoaudio *chip;
1067         int c, gain, changed;
1068
1069         changed = 0;
1070         chip = snd_kcontrol_chip(kcontrol);
1071         spin_lock_irq(&chip->lock);
1072         for (c = 0; c < num_analog_busses_in(chip); c++) {
1073                 gain = ucontrol->value.integer.value[c];
1074                 /* Ignore out of range values */
1075                 if (gain < ECHOGAIN_MININP || gain > ECHOGAIN_MAXINP)
1076                         continue;
1077                 if (chip->input_gain[c] != gain) {
1078                         set_input_gain(chip, c, gain);
1079                         changed = 1;
1080                 }
1081         }
1082         if (changed)
1083                 update_input_line_level(chip);
1084         spin_unlock_irq(&chip->lock);
1085         return changed;
1086 }
1087
1088 static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
1089
1090 static struct snd_kcontrol_new snd_echo_line_input_gain __devinitdata = {
1091         .name = "Line Capture Volume",
1092         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1093         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1094         .info = snd_echo_input_gain_info,
1095         .get = snd_echo_input_gain_get,
1096         .put = snd_echo_input_gain_put,
1097         .tlv = {.p = db_scale_input_gain},
1098 };
1099
1100 #endif /* ECHOCARD_HAS_INPUT_GAIN */
1101
1102
1103
1104 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
1105
1106 /************ Analog output nominal level (+4dBu / -10dBV) ***************/
1107 static int snd_echo_output_nominal_info (struct snd_kcontrol *kcontrol,
1108                                          struct snd_ctl_elem_info *uinfo)
1109 {
1110         struct echoaudio *chip;
1111
1112         chip = snd_kcontrol_chip(kcontrol);
1113         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1114         uinfo->count = num_analog_busses_out(chip);
1115         uinfo->value.integer.min = 0;
1116         uinfo->value.integer.max = 1;
1117         return 0;
1118 }
1119
1120 static int snd_echo_output_nominal_get(struct snd_kcontrol *kcontrol,
1121                                        struct snd_ctl_elem_value *ucontrol)
1122 {
1123         struct echoaudio *chip;
1124         int c;
1125
1126         chip = snd_kcontrol_chip(kcontrol);
1127         for (c = 0; c < num_analog_busses_out(chip); c++)
1128                 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1129         return 0;
1130 }
1131
1132 static int snd_echo_output_nominal_put(struct snd_kcontrol *kcontrol,
1133                                        struct snd_ctl_elem_value *ucontrol)
1134 {
1135         struct echoaudio *chip;
1136         int c, changed;
1137
1138         changed = 0;
1139         chip = snd_kcontrol_chip(kcontrol);
1140         spin_lock_irq(&chip->lock);
1141         for (c = 0; c < num_analog_busses_out(chip); c++) {
1142                 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1143                         set_nominal_level(chip, c,
1144                                           ucontrol->value.integer.value[c]);
1145                         changed = 1;
1146                 }
1147         }
1148         if (changed)
1149                 update_output_line_level(chip);
1150         spin_unlock_irq(&chip->lock);
1151         return changed;
1152 }
1153
1154 static struct snd_kcontrol_new snd_echo_output_nominal_level __devinitdata = {
1155         .name = "Line Playback Switch (-10dBV)",
1156         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1157         .info = snd_echo_output_nominal_info,
1158         .get = snd_echo_output_nominal_get,
1159         .put = snd_echo_output_nominal_put,
1160 };
1161
1162 #endif /* ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL */
1163
1164
1165
1166 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
1167
1168 /*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1169 static int snd_echo_input_nominal_info(struct snd_kcontrol *kcontrol,
1170                                        struct snd_ctl_elem_info *uinfo)
1171 {
1172         struct echoaudio *chip;
1173
1174         chip = snd_kcontrol_chip(kcontrol);
1175         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1176         uinfo->count = num_analog_busses_in(chip);
1177         uinfo->value.integer.min = 0;
1178         uinfo->value.integer.max = 1;
1179         return 0;
1180 }
1181
1182 static int snd_echo_input_nominal_get(struct snd_kcontrol *kcontrol,
1183                                       struct snd_ctl_elem_value *ucontrol)
1184 {
1185         struct echoaudio *chip;
1186         int c;
1187
1188         chip = snd_kcontrol_chip(kcontrol);
1189         for (c = 0; c < num_analog_busses_in(chip); c++)
1190                 ucontrol->value.integer.value[c] =
1191                         chip->nominal_level[bx_analog_in(chip) + c];
1192         return 0;
1193 }
1194
1195 static int snd_echo_input_nominal_put(struct snd_kcontrol *kcontrol,
1196                                       struct snd_ctl_elem_value *ucontrol)
1197 {
1198         struct echoaudio *chip;
1199         int c, changed;
1200
1201         changed = 0;
1202         chip = snd_kcontrol_chip(kcontrol);
1203         spin_lock_irq(&chip->lock);
1204         for (c = 0; c < num_analog_busses_in(chip); c++) {
1205                 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1206                     ucontrol->value.integer.value[c]) {
1207                         set_nominal_level(chip, bx_analog_in(chip) + c,
1208                                           ucontrol->value.integer.value[c]);
1209                         changed = 1;
1210                 }
1211         }
1212         if (changed)
1213                 update_output_line_level(chip); /* "Output" is not a mistake
1214                                                  * here.
1215                                                  */
1216         spin_unlock_irq(&chip->lock);
1217         return changed;
1218 }
1219
1220 static struct snd_kcontrol_new snd_echo_intput_nominal_level __devinitdata = {
1221         .name = "Line Capture Switch (-10dBV)",
1222         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1223         .info = snd_echo_input_nominal_info,
1224         .get = snd_echo_input_nominal_get,
1225         .put = snd_echo_input_nominal_put,
1226 };
1227
1228 #endif /* ECHOCARD_HAS_INPUT_NOMINAL_LEVEL */
1229
1230
1231
1232 #ifdef ECHOCARD_HAS_MONITOR
1233
1234 /******************* Monitor mixer *******************/
1235 static int snd_echo_mixer_info(struct snd_kcontrol *kcontrol,
1236                                struct snd_ctl_elem_info *uinfo)
1237 {
1238         struct echoaudio *chip;
1239
1240         chip = snd_kcontrol_chip(kcontrol);
1241         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1242         uinfo->count = 1;
1243         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1244         uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1245         uinfo->dimen.d[0] = num_busses_out(chip);
1246         uinfo->dimen.d[1] = num_busses_in(chip);
1247         return 0;
1248 }
1249
1250 static int snd_echo_mixer_get(struct snd_kcontrol *kcontrol,
1251                               struct snd_ctl_elem_value *ucontrol)
1252 {
1253         struct echoaudio *chip;
1254
1255         chip = snd_kcontrol_chip(kcontrol);
1256         ucontrol->value.integer.value[0] =
1257                 chip->monitor_gain[ucontrol->id.index / num_busses_in(chip)]
1258                         [ucontrol->id.index % num_busses_in(chip)];
1259         return 0;
1260 }
1261
1262 static int snd_echo_mixer_put(struct snd_kcontrol *kcontrol,
1263                               struct snd_ctl_elem_value *ucontrol)
1264 {
1265         struct echoaudio *chip;
1266         int changed,  gain;
1267         short out, in;
1268
1269         changed = 0;
1270         chip = snd_kcontrol_chip(kcontrol);
1271         out = ucontrol->id.index / num_busses_in(chip);
1272         in = ucontrol->id.index % num_busses_in(chip);
1273         gain = ucontrol->value.integer.value[0];
1274         if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1275                 return -EINVAL;
1276         if (chip->monitor_gain[out][in] != gain) {
1277                 spin_lock_irq(&chip->lock);
1278                 set_monitor_gain(chip, out, in, gain);
1279                 update_output_line_level(chip);
1280                 spin_unlock_irq(&chip->lock);
1281                 changed = 1;
1282         }
1283         return changed;
1284 }
1285
1286 static struct snd_kcontrol_new snd_echo_monitor_mixer __devinitdata = {
1287         .name = "Monitor Mixer Volume",
1288         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1289         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1290         .info = snd_echo_mixer_info,
1291         .get = snd_echo_mixer_get,
1292         .put = snd_echo_mixer_put,
1293         .tlv = {.p = db_scale_output_gain},
1294 };
1295
1296 #endif /* ECHOCARD_HAS_MONITOR */
1297
1298
1299
1300 #ifdef ECHOCARD_HAS_VMIXER
1301
1302 /******************* Vmixer *******************/
1303 static int snd_echo_vmixer_info(struct snd_kcontrol *kcontrol,
1304                                 struct snd_ctl_elem_info *uinfo)
1305 {
1306         struct echoaudio *chip;
1307
1308         chip = snd_kcontrol_chip(kcontrol);
1309         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1310         uinfo->count = 1;
1311         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1312         uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1313         uinfo->dimen.d[0] = num_busses_out(chip);
1314         uinfo->dimen.d[1] = num_pipes_out(chip);
1315         return 0;
1316 }
1317
1318 static int snd_echo_vmixer_get(struct snd_kcontrol *kcontrol,
1319                                struct snd_ctl_elem_value *ucontrol)
1320 {
1321         struct echoaudio *chip;
1322
1323         chip = snd_kcontrol_chip(kcontrol);
1324         ucontrol->value.integer.value[0] =
1325                 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1326                         [ucontrol->id.index % num_pipes_out(chip)];
1327         return 0;
1328 }
1329
1330 static int snd_echo_vmixer_put(struct snd_kcontrol *kcontrol,
1331                                struct snd_ctl_elem_value *ucontrol)
1332 {
1333         struct echoaudio *chip;
1334         int gain, changed;
1335         short vch, out;
1336
1337         changed = 0;
1338         chip = snd_kcontrol_chip(kcontrol);
1339         out = ucontrol->id.index / num_pipes_out(chip);
1340         vch = ucontrol->id.index % num_pipes_out(chip);
1341         gain = ucontrol->value.integer.value[0];
1342         if (gain < ECHOGAIN_MINOUT || gain > ECHOGAIN_MAXOUT)
1343                 return -EINVAL;
1344         if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1345                 spin_lock_irq(&chip->lock);
1346                 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1347                 update_vmixer_level(chip);
1348                 spin_unlock_irq(&chip->lock);
1349                 changed = 1;
1350         }
1351         return changed;
1352 }
1353
1354 static struct snd_kcontrol_new snd_echo_vmixer __devinitdata = {
1355         .name = "VMixer Volume",
1356         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1357         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1358         .info = snd_echo_vmixer_info,
1359         .get = snd_echo_vmixer_get,
1360         .put = snd_echo_vmixer_put,
1361         .tlv = {.p = db_scale_output_gain},
1362 };
1363
1364 #endif /* ECHOCARD_HAS_VMIXER */
1365
1366
1367
1368 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
1369
1370 /******************* Digital mode switch *******************/
1371 static int snd_echo_digital_mode_info(struct snd_kcontrol *kcontrol,
1372                                       struct snd_ctl_elem_info *uinfo)
1373 {
1374         static char *names[4] = {
1375                 "S/PDIF Coaxial", "S/PDIF Optical", "ADAT Optical",
1376                 "S/PDIF Cdrom"
1377         };
1378         struct echoaudio *chip;
1379
1380         chip = snd_kcontrol_chip(kcontrol);
1381         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1382         uinfo->value.enumerated.items = chip->num_digital_modes;
1383         uinfo->count = 1;
1384         if (uinfo->value.enumerated.item >= chip->num_digital_modes)
1385                 uinfo->value.enumerated.item = chip->num_digital_modes - 1;
1386         strcpy(uinfo->value.enumerated.name, names[
1387                         chip->digital_mode_list[uinfo->value.enumerated.item]]);
1388         return 0;
1389 }
1390
1391 static int snd_echo_digital_mode_get(struct snd_kcontrol *kcontrol,
1392                                      struct snd_ctl_elem_value *ucontrol)
1393 {
1394         struct echoaudio *chip;
1395         int i, mode;
1396
1397         chip = snd_kcontrol_chip(kcontrol);
1398         mode = chip->digital_mode;
1399         for (i = chip->num_digital_modes - 1; i >= 0; i--)
1400                 if (mode == chip->digital_mode_list[i]) {
1401                         ucontrol->value.enumerated.item[0] = i;
1402                         break;
1403                 }
1404         return 0;
1405 }
1406
1407 static int snd_echo_digital_mode_put(struct snd_kcontrol *kcontrol,
1408                                      struct snd_ctl_elem_value *ucontrol)
1409 {
1410         struct echoaudio *chip;
1411         int changed;
1412         unsigned short emode, dmode;
1413
1414         changed = 0;
1415         chip = snd_kcontrol_chip(kcontrol);
1416
1417         emode = ucontrol->value.enumerated.item[0];
1418         if (emode >= chip->num_digital_modes)
1419                 return -EINVAL;
1420         dmode = chip->digital_mode_list[emode];
1421
1422         if (dmode != chip->digital_mode) {
1423                 /* mode_mutex is required to make this operation atomic wrt
1424                 pcm_digital_*_open() and set_input_clock() functions. */
1425                 down(&chip->mode_mutex);
1426
1427                 /* Do not allow the user to change the digital mode when a pcm
1428                 device is open because it also changes the number of channels
1429                 and the allowed sample rates */
1430                 if (atomic_read(&chip->opencount)) {
1431                         changed = -EAGAIN;
1432                 } else {
1433                         changed = set_digital_mode(chip, dmode);
1434                         /* If we had to change the clock source, report it */
1435                         if (changed > 0 && chip->clock_src_ctl) {
1436                                 snd_ctl_notify(chip->card,
1437                                                SNDRV_CTL_EVENT_MASK_VALUE,
1438                                                &chip->clock_src_ctl->id);
1439                                 DE_ACT(("SDM() =%d\n", changed));
1440                         }
1441                         if (changed >= 0)
1442                                 changed = 1;    /* No errors */
1443                 }
1444                 up(&chip->mode_mutex);
1445         }
1446         return changed;
1447 }
1448
1449 static struct snd_kcontrol_new snd_echo_digital_mode_switch __devinitdata = {
1450         .name = "Digital mode Switch",
1451         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1452         .info = snd_echo_digital_mode_info,
1453         .get = snd_echo_digital_mode_get,
1454         .put = snd_echo_digital_mode_put,
1455 };
1456
1457 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
1458
1459
1460
1461 #ifdef ECHOCARD_HAS_DIGITAL_IO
1462
1463 /******************* S/PDIF mode switch *******************/
1464 static int snd_echo_spdif_mode_info(struct snd_kcontrol *kcontrol,
1465                                     struct snd_ctl_elem_info *uinfo)
1466 {
1467         static char *names[2] = {"Consumer", "Professional"};
1468
1469         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1470         uinfo->value.enumerated.items = 2;
1471         uinfo->count = 1;
1472         if (uinfo->value.enumerated.item)
1473                 uinfo->value.enumerated.item = 1;
1474         strcpy(uinfo->value.enumerated.name,
1475                names[uinfo->value.enumerated.item]);
1476         return 0;
1477 }
1478
1479 static int snd_echo_spdif_mode_get(struct snd_kcontrol *kcontrol,
1480                                    struct snd_ctl_elem_value *ucontrol)
1481 {
1482         struct echoaudio *chip;
1483
1484         chip = snd_kcontrol_chip(kcontrol);
1485         ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1486         return 0;
1487 }
1488
1489 static int snd_echo_spdif_mode_put(struct snd_kcontrol *kcontrol,
1490                                    struct snd_ctl_elem_value *ucontrol)
1491 {
1492         struct echoaudio *chip;
1493         int mode;
1494
1495         chip = snd_kcontrol_chip(kcontrol);
1496         mode = !!ucontrol->value.enumerated.item[0];
1497         if (mode != chip->professional_spdif) {
1498                 spin_lock_irq(&chip->lock);
1499                 set_professional_spdif(chip, mode);
1500                 spin_unlock_irq(&chip->lock);
1501                 return 1;
1502         }
1503         return 0;
1504 }
1505
1506 static struct snd_kcontrol_new snd_echo_spdif_mode_switch __devinitdata = {
1507         .name = "S/PDIF mode Switch",
1508         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1509         .info = snd_echo_spdif_mode_info,
1510         .get = snd_echo_spdif_mode_get,
1511         .put = snd_echo_spdif_mode_put,
1512 };
1513
1514 #endif /* ECHOCARD_HAS_DIGITAL_IO */
1515
1516
1517
1518 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
1519
1520 /******************* Select input clock source *******************/
1521 static int snd_echo_clock_source_info(struct snd_kcontrol *kcontrol,
1522                                       struct snd_ctl_elem_info *uinfo)
1523 {
1524         static char *names[8] = {
1525                 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1526                 "ESync96", "MTC"
1527         };
1528         struct echoaudio *chip;
1529
1530         chip = snd_kcontrol_chip(kcontrol);
1531         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1532         uinfo->value.enumerated.items = chip->num_clock_sources;
1533         uinfo->count = 1;
1534         if (uinfo->value.enumerated.item >= chip->num_clock_sources)
1535                 uinfo->value.enumerated.item = chip->num_clock_sources - 1;
1536         strcpy(uinfo->value.enumerated.name, names[
1537                         chip->clock_source_list[uinfo->value.enumerated.item]]);
1538         return 0;
1539 }
1540
1541 static int snd_echo_clock_source_get(struct snd_kcontrol *kcontrol,
1542                                      struct snd_ctl_elem_value *ucontrol)
1543 {
1544         struct echoaudio *chip;
1545         int i, clock;
1546
1547         chip = snd_kcontrol_chip(kcontrol);
1548         clock = chip->input_clock;
1549
1550         for (i = 0; i < chip->num_clock_sources; i++)
1551                 if (clock == chip->clock_source_list[i])
1552                         ucontrol->value.enumerated.item[0] = i;
1553
1554         return 0;
1555 }
1556
1557 static int snd_echo_clock_source_put(struct snd_kcontrol *kcontrol,
1558                                      struct snd_ctl_elem_value *ucontrol)
1559 {
1560         struct echoaudio *chip;
1561         int changed;
1562         unsigned int eclock, dclock;
1563
1564         changed = 0;
1565         chip = snd_kcontrol_chip(kcontrol);
1566         eclock = ucontrol->value.enumerated.item[0];
1567         if (eclock >= chip->input_clock_types)
1568                 return -EINVAL;
1569         dclock = chip->clock_source_list[eclock];
1570         if (chip->input_clock != dclock) {
1571                 down(&chip->mode_mutex);
1572                 spin_lock_irq(&chip->lock);
1573                 if ((changed = set_input_clock(chip, dclock)) == 0)
1574                         changed = 1;    /* no errors */
1575                 spin_unlock_irq(&chip->lock);
1576                 up(&chip->mode_mutex);
1577         }
1578
1579         if (changed < 0)
1580                 DE_ACT(("seticlk val%d err 0x%x\n", dclock, changed));
1581
1582         return changed;
1583 }
1584
1585 static struct snd_kcontrol_new snd_echo_clock_source_switch __devinitdata = {
1586         .name = "Sample Clock Source",
1587         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1588         .info = snd_echo_clock_source_info,
1589         .get = snd_echo_clock_source_get,
1590         .put = snd_echo_clock_source_put,
1591 };
1592
1593 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
1594
1595
1596
1597 #ifdef ECHOCARD_HAS_PHANTOM_POWER
1598
1599 /******************* Phantom power switch *******************/
1600 static int snd_echo_phantom_power_info(struct snd_kcontrol *kcontrol,
1601                                        struct snd_ctl_elem_info *uinfo)
1602 {
1603         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1604         uinfo->count = 1;
1605         uinfo->value.integer.min = 0;
1606         uinfo->value.integer.max = 1;
1607         return 0;
1608 }
1609
1610 static int snd_echo_phantom_power_get(struct snd_kcontrol *kcontrol,
1611                                       struct snd_ctl_elem_value *ucontrol)
1612 {
1613         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1614
1615         ucontrol->value.integer.value[0] = chip->phantom_power;
1616         return 0;
1617 }
1618
1619 static int snd_echo_phantom_power_put(struct snd_kcontrol *kcontrol,
1620                                       struct snd_ctl_elem_value *ucontrol)
1621 {
1622         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1623         int power, changed = 0;
1624
1625         power = !!ucontrol->value.integer.value[0];
1626         if (chip->phantom_power != power) {
1627                 spin_lock_irq(&chip->lock);
1628                 changed = set_phantom_power(chip, power);
1629                 spin_unlock_irq(&chip->lock);
1630                 if (changed == 0)
1631                         changed = 1;    /* no errors */
1632         }
1633         return changed;
1634 }
1635
1636 static struct snd_kcontrol_new snd_echo_phantom_power_switch __devinitdata = {
1637         .name = "Phantom power Switch",
1638         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1639         .info = snd_echo_phantom_power_info,
1640         .get = snd_echo_phantom_power_get,
1641         .put = snd_echo_phantom_power_put,
1642 };
1643
1644 #endif /* ECHOCARD_HAS_PHANTOM_POWER */
1645
1646
1647
1648 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
1649
1650 /******************* Digital input automute switch *******************/
1651 static int snd_echo_automute_info(struct snd_kcontrol *kcontrol,
1652                                   struct snd_ctl_elem_info *uinfo)
1653 {
1654         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1655         uinfo->count = 1;
1656         uinfo->value.integer.min = 0;
1657         uinfo->value.integer.max = 1;
1658         return 0;
1659 }
1660
1661 static int snd_echo_automute_get(struct snd_kcontrol *kcontrol,
1662                                  struct snd_ctl_elem_value *ucontrol)
1663 {
1664         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1665
1666         ucontrol->value.integer.value[0] = chip->digital_in_automute;
1667         return 0;
1668 }
1669
1670 static int snd_echo_automute_put(struct snd_kcontrol *kcontrol,
1671                                  struct snd_ctl_elem_value *ucontrol)
1672 {
1673         struct echoaudio *chip = snd_kcontrol_chip(kcontrol);
1674         int automute, changed = 0;
1675
1676         automute = !!ucontrol->value.integer.value[0];
1677         if (chip->digital_in_automute != automute) {
1678                 spin_lock_irq(&chip->lock);
1679                 changed = set_input_auto_mute(chip, automute);
1680                 spin_unlock_irq(&chip->lock);
1681                 if (changed == 0)
1682                         changed = 1;    /* no errors */
1683         }
1684         return changed;
1685 }
1686
1687 static struct snd_kcontrol_new snd_echo_automute_switch __devinitdata = {
1688         .name = "Digital Capture Switch (automute)",
1689         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1690         .info = snd_echo_automute_info,
1691         .get = snd_echo_automute_get,
1692         .put = snd_echo_automute_put,
1693 };
1694
1695 #endif /* ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE */
1696
1697
1698
1699 /******************* VU-meters switch *******************/
1700 static int snd_echo_vumeters_switch_info(struct snd_kcontrol *kcontrol,
1701                                          struct snd_ctl_elem_info *uinfo)
1702 {
1703         struct echoaudio *chip;
1704
1705         chip = snd_kcontrol_chip(kcontrol);
1706         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1707         uinfo->count = 1;
1708         uinfo->value.integer.min = 0;
1709         uinfo->value.integer.max = 1;
1710         return 0;
1711 }
1712
1713 static int snd_echo_vumeters_switch_put(struct snd_kcontrol *kcontrol,
1714                                         struct snd_ctl_elem_value *ucontrol)
1715 {
1716         struct echoaudio *chip;
1717
1718         chip = snd_kcontrol_chip(kcontrol);
1719         spin_lock_irq(&chip->lock);
1720         set_meters_on(chip, ucontrol->value.integer.value[0]);
1721         spin_unlock_irq(&chip->lock);
1722         return 1;
1723 }
1724
1725 static struct snd_kcontrol_new snd_echo_vumeters_switch __devinitdata = {
1726         .name = "VU-meters Switch",
1727         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1728         .access = SNDRV_CTL_ELEM_ACCESS_WRITE,
1729         .info = snd_echo_vumeters_switch_info,
1730         .put = snd_echo_vumeters_switch_put,
1731 };
1732
1733
1734
1735 /***** Read VU-meters (input, output, analog and digital together) *****/
1736 static int snd_echo_vumeters_info(struct snd_kcontrol *kcontrol,
1737                                   struct snd_ctl_elem_info *uinfo)
1738 {
1739         struct echoaudio *chip;
1740
1741         chip = snd_kcontrol_chip(kcontrol);
1742         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1743         uinfo->count = 96;
1744         uinfo->value.integer.min = ECHOGAIN_MINOUT;
1745         uinfo->value.integer.max = 0;
1746 #ifdef ECHOCARD_HAS_VMIXER
1747         uinfo->dimen.d[0] = 3;  /* Out, In, Virt */
1748 #else
1749         uinfo->dimen.d[0] = 2;  /* Out, In */
1750 #endif
1751         uinfo->dimen.d[1] = 16; /* 16 channels */
1752         uinfo->dimen.d[2] = 2;  /* 0=level, 1=peak */
1753         return 0;
1754 }
1755
1756 static int snd_echo_vumeters_get(struct snd_kcontrol *kcontrol,
1757                                  struct snd_ctl_elem_value *ucontrol)
1758 {
1759         struct echoaudio *chip;
1760
1761         chip = snd_kcontrol_chip(kcontrol);
1762         get_audio_meters(chip, ucontrol->value.integer.value);
1763         return 0;
1764 }
1765
1766 static struct snd_kcontrol_new snd_echo_vumeters __devinitdata = {
1767         .name = "VU-meters",
1768         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1769         .access = SNDRV_CTL_ELEM_ACCESS_READ |
1770                   SNDRV_CTL_ELEM_ACCESS_VOLATILE |
1771                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1772         .info = snd_echo_vumeters_info,
1773         .get = snd_echo_vumeters_get,
1774         .tlv = {.p = db_scale_output_gain},
1775 };
1776
1777
1778
1779 /*** Channels info - it exports informations about the number of channels ***/
1780 static int snd_echo_channels_info_info(struct snd_kcontrol *kcontrol,
1781                                        struct snd_ctl_elem_info *uinfo)
1782 {
1783         struct echoaudio *chip;
1784
1785         chip = snd_kcontrol_chip(kcontrol);
1786         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1787         uinfo->count = 6;
1788         uinfo->value.integer.min = 0;
1789         uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1790         return 0;
1791 }
1792
1793 static int snd_echo_channels_info_get(struct snd_kcontrol *kcontrol,
1794                                       struct snd_ctl_elem_value *ucontrol)
1795 {
1796         struct echoaudio *chip;
1797         int detected, clocks, bit, src;
1798
1799         chip = snd_kcontrol_chip(kcontrol);
1800         ucontrol->value.integer.value[0] = num_busses_in(chip);
1801         ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1802         ucontrol->value.integer.value[2] = num_busses_out(chip);
1803         ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1804         ucontrol->value.integer.value[4] = num_pipes_out(chip);
1805
1806         /* Compute the bitmask of the currently valid input clocks */
1807         detected = detect_input_clocks(chip);
1808         clocks = 0;
1809         src = chip->num_clock_sources - 1;
1810         for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1811                 if (detected & (1 << bit))
1812                         for (; src >= 0; src--)
1813                                 if (bit == chip->clock_source_list[src]) {
1814                                         clocks |= 1 << src;
1815                                         break;
1816                                 }
1817         ucontrol->value.integer.value[5] = clocks;
1818
1819         return 0;
1820 }
1821
1822 static struct snd_kcontrol_new snd_echo_channels_info __devinitdata = {
1823         .name = "Channels info",
1824         .iface = SNDRV_CTL_ELEM_IFACE_HWDEP,
1825         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1826         .info = snd_echo_channels_info_info,
1827         .get = snd_echo_channels_info_get,
1828 };
1829
1830
1831
1832
1833 /******************************************************************************
1834         IRQ Handler
1835 ******************************************************************************/
1836
1837 static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
1838 {
1839         struct echoaudio *chip = dev_id;
1840         struct snd_pcm_substream *substream;
1841         int period, ss, st;
1842
1843         spin_lock(&chip->lock);
1844         st = service_irq(chip);
1845         if (st < 0) {
1846                 spin_unlock(&chip->lock);
1847                 return IRQ_NONE;
1848         }
1849         /* The hardware doesn't tell us which substream caused the irq,
1850         thus we have to check all running substreams. */
1851         for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1852                 if ((substream = chip->substream[ss])) {
1853                         period = pcm_pointer(substream) /
1854                                 substream->runtime->period_size;
1855                         if (period != chip->last_period[ss]) {
1856                                 chip->last_period[ss] = period;
1857                                 spin_unlock(&chip->lock);
1858                                 snd_pcm_period_elapsed(substream);
1859                                 spin_lock(&chip->lock);
1860                         }
1861                 }
1862         }
1863         spin_unlock(&chip->lock);
1864
1865 #ifdef ECHOCARD_HAS_MIDI
1866         if (st > 0 && chip->midi_in) {
1867                 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1868                 DE_MID(("rawmidi_iread=%d\n", st));
1869         }
1870 #endif
1871         return IRQ_HANDLED;
1872 }
1873
1874
1875
1876
1877 /******************************************************************************
1878         Module construction / destruction
1879 ******************************************************************************/
1880
1881 static int snd_echo_free(struct echoaudio *chip)
1882 {
1883         DE_INIT(("Stop DSP...\n"));
1884         if (chip->comm_page) {
1885                 rest_in_peace(chip);
1886                 snd_dma_free_pages(&chip->commpage_dma_buf);
1887         }
1888         DE_INIT(("Stopped.\n"));
1889
1890         if (chip->irq >= 0)
1891                 free_irq(chip->irq, chip);
1892
1893         if (chip->dsp_registers)
1894                 iounmap(chip->dsp_registers);
1895
1896         if (chip->iores)
1897                 release_and_free_resource(chip->iores);
1898
1899         DE_INIT(("MMIO freed.\n"));
1900
1901         pci_disable_device(chip->pci);
1902
1903         /* release chip data */
1904         kfree(chip);
1905         DE_INIT(("Chip freed.\n"));
1906         return 0;
1907 }
1908
1909
1910
1911 static int snd_echo_dev_free(struct snd_device *device)
1912 {
1913         struct echoaudio *chip = device->device_data;
1914
1915         DE_INIT(("snd_echo_dev_free()...\n"));
1916         return snd_echo_free(chip);
1917 }
1918
1919
1920
1921 /* <--snd_echo_probe() */
1922 static __devinit int snd_echo_create(struct snd_card *card,
1923                                      struct pci_dev *pci,
1924                                      struct echoaudio **rchip)
1925 {
1926         struct echoaudio *chip;
1927         int err;
1928         size_t sz;
1929         static struct snd_device_ops ops = {
1930                 .dev_free = snd_echo_dev_free,
1931         };
1932
1933         *rchip = NULL;
1934
1935         pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1936
1937         if ((err = pci_enable_device(pci)) < 0)
1938                 return err;
1939         pci_set_master(pci);
1940
1941         /* allocate a chip-specific data */
1942         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1943         if (!chip) {
1944                 pci_disable_device(pci);
1945                 return -ENOMEM;
1946         }
1947         DE_INIT(("chip=%p\n", chip));
1948
1949         spin_lock_init(&chip->lock);
1950         chip->card = card;
1951         chip->pci = pci;
1952         chip->irq = -1;
1953
1954         /* PCI resource allocation */
1955         chip->dsp_registers_phys = pci_resource_start(pci, 0);
1956         sz = pci_resource_len(pci, 0);
1957         if (sz > PAGE_SIZE)
1958                 sz = PAGE_SIZE;         /* We map only the required part */
1959
1960         if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1961                                               ECHOCARD_NAME)) == NULL) {
1962                 snd_echo_free(chip);
1963                 snd_printk(KERN_ERR "cannot get memory region\n");
1964                 return -EBUSY;
1965         }
1966         chip->dsp_registers = (volatile u32 __iomem *)
1967                 ioremap_nocache(chip->dsp_registers_phys, sz);
1968
1969         if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1970                         ECHOCARD_NAME, chip)) {
1971                 snd_echo_free(chip);
1972                 snd_printk(KERN_ERR "cannot grab irq\n");
1973                 return -EBUSY;
1974         }
1975         chip->irq = pci->irq;
1976         DE_INIT(("pci=%p irq=%d subdev=%04x Init hardware...\n",
1977                  chip->pci, chip->irq, chip->pci->subsystem_device));
1978
1979         /* Create the DSP comm page - this is the area of memory used for most
1980         of the communication with the DSP, which accesses it via bus mastering */
1981         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
1982                                 sizeof(struct comm_page),
1983                                 &chip->commpage_dma_buf) < 0) {
1984                 snd_echo_free(chip);
1985                 snd_printk(KERN_ERR "cannot allocate the comm page\n");
1986                 return -ENOMEM;
1987         }
1988         chip->comm_page_phys = chip->commpage_dma_buf.addr;
1989         chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1990
1991         err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1992         if (err) {
1993                 DE_INIT(("init_hw err=%d\n", err));
1994                 snd_echo_free(chip);
1995                 return err;
1996         }
1997         DE_INIT(("Card init OK\n"));
1998
1999         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2000                 snd_echo_free(chip);
2001                 return err;
2002         }
2003         atomic_set(&chip->opencount, 0);
2004         init_MUTEX(&chip->mode_mutex);
2005         chip->can_set_rate = 1;
2006         *rchip = chip;
2007         /* Init done ! */
2008         return 0;
2009 }
2010
2011
2012
2013 /* constructor */
2014 static int __devinit snd_echo_probe(struct pci_dev *pci,
2015                                     const struct pci_device_id *pci_id)
2016 {
2017         static int dev;
2018         struct snd_card *card;
2019         struct echoaudio *chip;
2020         char *dsp;
2021         int i, err;
2022
2023         if (dev >= SNDRV_CARDS)
2024                 return -ENODEV;
2025         if (!enable[dev]) {
2026                 dev++;
2027                 return -ENOENT;
2028         }
2029
2030         DE_INIT(("Echoaudio driver starting...\n"));
2031         i = 0;
2032         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
2033         if (card == NULL)
2034                 return -ENOMEM;
2035
2036         if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2037                 snd_card_free(card);
2038                 return err;
2039         }
2040
2041         strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2042         strcpy(card->shortname, chip->card_name);
2043
2044         dsp = "56301";
2045         if (pci_id->device == 0x3410)
2046                 dsp = "56361";
2047
2048         sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
2049                 card->shortname, pci_id->subdevice & 0x000f, dsp,
2050                 chip->dsp_registers_phys, chip->irq);
2051
2052         if ((err = snd_echo_new_pcm(chip)) < 0) {
2053                 snd_printk(KERN_ERR "new pcm error %d\n", err);
2054                 snd_card_free(card);
2055                 return err;
2056         }
2057
2058 #ifdef ECHOCARD_HAS_MIDI
2059         if (chip->has_midi) {   /* Some Mia's do not have midi */
2060                 if ((err = snd_echo_midi_create(card, chip)) < 0) {
2061                         snd_printk(KERN_ERR "new midi error %d\n", err);
2062                         snd_card_free(card);
2063                         return err;
2064                 }
2065         }
2066 #endif
2067
2068 #ifdef ECHOCARD_HAS_VMIXER
2069         snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
2070         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_output_gain, chip))) < 0)
2071                 goto ctl_error;
2072         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
2073                 goto ctl_error;
2074 #else
2075         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_pcm_output_gain, chip))) < 0)
2076                 goto ctl_error;
2077 #endif
2078
2079 #ifdef ECHOCARD_HAS_INPUT_GAIN
2080         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
2081                 goto ctl_error;
2082 #endif
2083
2084 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL
2085         if (!chip->hasnt_input_nominal_level)
2086                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip))) < 0)
2087                         goto ctl_error;
2088 #endif
2089
2090 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL
2091         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip))) < 0)
2092                 goto ctl_error;
2093 #endif
2094
2095         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip))) < 0)
2096                 goto ctl_error;
2097
2098         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip))) < 0)
2099                 goto ctl_error;
2100
2101 #ifdef ECHOCARD_HAS_MONITOR
2102         snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip);
2103         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip))) < 0)
2104                 goto ctl_error;
2105 #endif
2106
2107 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE
2108         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip))) < 0)
2109                 goto ctl_error;
2110 #endif
2111
2112         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip))) < 0)
2113                 goto ctl_error;
2114
2115 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
2116         /* Creates a list of available digital modes */
2117         chip->num_digital_modes = 0;
2118         for (i = 0; i < 6; i++)
2119                 if (chip->digital_modes & (1 << i))
2120                         chip->digital_mode_list[chip->num_digital_modes++] = i;
2121
2122         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip))) < 0)
2123                 goto ctl_error;
2124 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */
2125
2126 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
2127         /* Creates a list of available clock sources */
2128         chip->num_clock_sources = 0;
2129         for (i = 0; i < 10; i++)
2130                 if (chip->input_clock_types & (1 << i))
2131                         chip->clock_source_list[chip->num_clock_sources++] = i;
2132
2133         if (chip->num_clock_sources > 1) {
2134                 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2135                 if ((err = snd_ctl_add(chip->card, chip->clock_src_ctl)) < 0)
2136                         goto ctl_error;
2137         }
2138 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */
2139
2140 #ifdef ECHOCARD_HAS_DIGITAL_IO
2141         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip))) < 0)
2142                 goto ctl_error;
2143 #endif
2144
2145 #ifdef ECHOCARD_HAS_PHANTOM_POWER
2146         if (chip->has_phantom_power)
2147                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip))) < 0)
2148                         goto ctl_error;
2149 #endif
2150
2151         if ((err = snd_card_register(card)) < 0) {
2152                 snd_card_free(card);
2153                 goto ctl_error;
2154         }
2155         snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
2156
2157         pci_set_drvdata(pci, chip);
2158         dev++;
2159         return 0;
2160
2161 ctl_error:
2162         snd_printk(KERN_ERR "new control error %d\n", err);
2163         snd_card_free(card);
2164         return err;
2165 }
2166
2167
2168
2169 static void __devexit snd_echo_remove(struct pci_dev *pci)
2170 {
2171         struct echoaudio *chip;
2172
2173         chip = pci_get_drvdata(pci);
2174         if (chip)
2175                 snd_card_free(chip->card);
2176         pci_set_drvdata(pci, NULL);
2177 }
2178
2179
2180
2181 /******************************************************************************
2182         Everything starts and ends here
2183 ******************************************************************************/
2184
2185 /* pci_driver definition */
2186 static struct pci_driver driver = {
2187         .name = "Echoaudio " ECHOCARD_NAME,
2188         .id_table = snd_echo_ids,
2189         .probe = snd_echo_probe,
2190         .remove = __devexit_p(snd_echo_remove),
2191 };
2192
2193
2194
2195 /* initialization of the module */
2196 static int __init alsa_card_echo_init(void)
2197 {
2198         return pci_register_driver(&driver);
2199 }
2200
2201
2202
2203 /* clean up the module */
2204 static void __exit alsa_card_echo_exit(void)
2205 {
2206         pci_unregister_driver(&driver);
2207 }
2208
2209
2210 module_init(alsa_card_echo_init)
2211 module_exit(alsa_card_echo_exit)