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