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