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 int snd_echo_free(struct echoaudio *chip) 1886 { 1887 if (chip->comm_page) 1888 rest_in_peace(chip); 1889 1890 if (chip->irq >= 0) 1891 free_irq(chip->irq, chip); 1892 1893 if (chip->comm_page) 1894 snd_dma_free_pages(&chip->commpage_dma_buf); 1895 1896 iounmap(chip->dsp_registers); 1897 release_and_free_resource(chip->iores); 1898 pci_disable_device(chip->pci); 1899 1900 /* release chip data */ 1901 free_firmware_cache(chip); 1902 kfree(chip); 1903 return 0; 1904 } 1905 1906 1907 1908 static int snd_echo_dev_free(struct snd_device *device) 1909 { 1910 struct echoaudio *chip = device->device_data; 1911 1912 return snd_echo_free(chip); 1913 } 1914 1915 1916 1917 /* <--snd_echo_probe() */ 1918 static int snd_echo_create(struct snd_card *card, 1919 struct pci_dev *pci, 1920 struct echoaudio **rchip) 1921 { 1922 struct echoaudio *chip; 1923 int err; 1924 size_t sz; 1925 static const struct snd_device_ops ops = { 1926 .dev_free = snd_echo_dev_free, 1927 }; 1928 1929 *rchip = NULL; 1930 1931 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0); 1932 1933 err = pci_enable_device(pci); 1934 if (err < 0) 1935 return err; 1936 pci_set_master(pci); 1937 1938 /* Allocate chip if needed */ 1939 if (!*rchip) { 1940 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 1941 if (!chip) { 1942 pci_disable_device(pci); 1943 return -ENOMEM; 1944 } 1945 dev_dbg(card->dev, "chip=%p\n", chip); 1946 spin_lock_init(&chip->lock); 1947 chip->card = card; 1948 chip->pci = pci; 1949 chip->irq = -1; 1950 chip->opencount = 0; 1951 mutex_init(&chip->mode_mutex); 1952 chip->can_set_rate = 1; 1953 } else { 1954 /* If this was called from the resume function, chip is 1955 * already allocated and it contains current card settings. 1956 */ 1957 chip = *rchip; 1958 } 1959 1960 /* PCI resource allocation */ 1961 chip->dsp_registers_phys = pci_resource_start(pci, 0); 1962 sz = pci_resource_len(pci, 0); 1963 if (sz > PAGE_SIZE) 1964 sz = PAGE_SIZE; /* We map only the required part */ 1965 1966 chip->iores = request_mem_region(chip->dsp_registers_phys, sz, 1967 ECHOCARD_NAME); 1968 if (!chip->iores) { 1969 dev_err(chip->card->dev, "cannot get memory region\n"); 1970 snd_echo_free(chip); 1971 return -EBUSY; 1972 } 1973 chip->dsp_registers = ioremap(chip->dsp_registers_phys, sz); 1974 if (!chip->dsp_registers) { 1975 dev_err(chip->card->dev, "ioremap failed\n"); 1976 snd_echo_free(chip); 1977 return -ENOMEM; 1978 } 1979 1980 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED, 1981 KBUILD_MODNAME, chip)) { 1982 dev_err(chip->card->dev, "cannot grab irq\n"); 1983 snd_echo_free(chip); 1984 return -EBUSY; 1985 } 1986 chip->irq = pci->irq; 1987 card->sync_irq = chip->irq; 1988 dev_dbg(card->dev, "pci=%p irq=%d subdev=%04x Init hardware...\n", 1989 chip->pci, chip->irq, chip->pci->subsystem_device); 1990 1991 /* Create the DSP comm page - this is the area of memory used for most 1992 of the communication with the DSP, which accesses it via bus mastering */ 1993 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev, 1994 sizeof(struct comm_page), 1995 &chip->commpage_dma_buf) < 0) { 1996 dev_err(chip->card->dev, "cannot allocate the comm page\n"); 1997 snd_echo_free(chip); 1998 return -ENOMEM; 1999 } 2000 chip->comm_page_phys = chip->commpage_dma_buf.addr; 2001 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area; 2002 2003 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device); 2004 if (err >= 0) 2005 err = set_mixer_defaults(chip); 2006 if (err < 0) { 2007 dev_err(card->dev, "init_hw err=%d\n", err); 2008 snd_echo_free(chip); 2009 return err; 2010 } 2011 2012 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); 2013 if (err < 0) { 2014 snd_echo_free(chip); 2015 return err; 2016 } 2017 *rchip = chip; 2018 /* Init done ! */ 2019 return 0; 2020 } 2021 2022 2023 2024 /* constructor */ 2025 static int snd_echo_probe(struct pci_dev *pci, 2026 const struct pci_device_id *pci_id) 2027 { 2028 static int dev; 2029 struct snd_card *card; 2030 struct echoaudio *chip; 2031 char *dsp; 2032 __maybe_unused int i; 2033 int err; 2034 2035 if (dev >= SNDRV_CARDS) 2036 return -ENODEV; 2037 if (!enable[dev]) { 2038 dev++; 2039 return -ENOENT; 2040 } 2041 2042 i = 0; 2043 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, 2044 0, &card); 2045 if (err < 0) 2046 return err; 2047 2048 chip = NULL; /* Tells snd_echo_create to allocate chip */ 2049 err = snd_echo_create(card, pci, &chip); 2050 if (err < 0) { 2051 snd_card_free(card); 2052 return err; 2053 } 2054 2055 strcpy(card->driver, "Echo_" ECHOCARD_NAME); 2056 strcpy(card->shortname, chip->card_name); 2057 2058 dsp = "56301"; 2059 if (pci_id->device == 0x3410) 2060 dsp = "56361"; 2061 2062 sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i", 2063 card->shortname, pci_id->subdevice & 0x000f, dsp, 2064 chip->dsp_registers_phys, chip->irq); 2065 2066 err = snd_echo_new_pcm(chip); 2067 if (err < 0) { 2068 dev_err(chip->card->dev, "new pcm error %d\n", err); 2069 snd_card_free(card); 2070 return err; 2071 } 2072 2073 #ifdef ECHOCARD_HAS_MIDI 2074 if (chip->has_midi) { /* Some Mia's do not have midi */ 2075 err = snd_echo_midi_create(card, chip); 2076 if (err < 0) { 2077 dev_err(chip->card->dev, "new midi error %d\n", err); 2078 snd_card_free(card); 2079 return err; 2080 } 2081 } 2082 #endif 2083 2084 #ifdef ECHOCARD_HAS_VMIXER 2085 snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip); 2086 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip)); 2087 if (err < 0) 2088 goto ctl_error; 2089 #ifdef ECHOCARD_HAS_LINE_OUT_GAIN 2090 err = snd_ctl_add(chip->card, 2091 snd_ctl_new1(&snd_echo_line_output_gain, chip)); 2092 if (err < 0) 2093 goto ctl_error; 2094 #endif 2095 #else /* ECHOCARD_HAS_VMIXER */ 2096 err = snd_ctl_add(chip->card, 2097 snd_ctl_new1(&snd_echo_pcm_output_gain, chip)); 2098 if (err < 0) 2099 goto ctl_error; 2100 #endif /* ECHOCARD_HAS_VMIXER */ 2101 2102 #ifdef ECHOCARD_HAS_INPUT_GAIN 2103 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip)); 2104 if (err < 0) 2105 goto ctl_error; 2106 #endif 2107 2108 #ifdef ECHOCARD_HAS_INPUT_NOMINAL_LEVEL 2109 if (!chip->hasnt_input_nominal_level) { 2110 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip)); 2111 if (err < 0) 2112 goto ctl_error; 2113 } 2114 #endif 2115 2116 #ifdef ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL 2117 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip)); 2118 if (err < 0) 2119 goto ctl_error; 2120 #endif 2121 2122 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip)); 2123 if (err < 0) 2124 goto ctl_error; 2125 2126 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip)); 2127 if (err < 0) 2128 goto ctl_error; 2129 2130 #ifdef ECHOCARD_HAS_MONITOR 2131 snd_echo_monitor_mixer.count = num_busses_in(chip) * num_busses_out(chip); 2132 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip)); 2133 if (err < 0) 2134 goto ctl_error; 2135 #endif 2136 2137 #ifdef ECHOCARD_HAS_DIGITAL_IN_AUTOMUTE 2138 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip)); 2139 if (err < 0) 2140 goto ctl_error; 2141 #endif 2142 2143 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip)); 2144 if (err < 0) 2145 goto ctl_error; 2146 2147 #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH 2148 /* Creates a list of available digital modes */ 2149 chip->num_digital_modes = 0; 2150 for (i = 0; i < 6; i++) 2151 if (chip->digital_modes & (1 << i)) 2152 chip->digital_mode_list[chip->num_digital_modes++] = i; 2153 2154 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip)); 2155 if (err < 0) 2156 goto ctl_error; 2157 #endif /* ECHOCARD_HAS_DIGITAL_MODE_SWITCH */ 2158 2159 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK 2160 /* Creates a list of available clock sources */ 2161 chip->num_clock_sources = 0; 2162 for (i = 0; i < 10; i++) 2163 if (chip->input_clock_types & (1 << i)) 2164 chip->clock_source_list[chip->num_clock_sources++] = i; 2165 2166 if (chip->num_clock_sources > 1) { 2167 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip); 2168 err = snd_ctl_add(chip->card, chip->clock_src_ctl); 2169 if (err < 0) 2170 goto ctl_error; 2171 } 2172 #endif /* ECHOCARD_HAS_EXTERNAL_CLOCK */ 2173 2174 #ifdef ECHOCARD_HAS_DIGITAL_IO 2175 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip)); 2176 if (err < 0) 2177 goto ctl_error; 2178 #endif 2179 2180 #ifdef ECHOCARD_HAS_PHANTOM_POWER 2181 if (chip->has_phantom_power) { 2182 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip)); 2183 if (err < 0) 2184 goto ctl_error; 2185 } 2186 #endif 2187 2188 err = snd_card_register(card); 2189 if (err < 0) 2190 goto ctl_error; 2191 dev_info(card->dev, "Card registered: %s\n", card->longname); 2192 2193 pci_set_drvdata(pci, chip); 2194 dev++; 2195 return 0; 2196 2197 ctl_error: 2198 dev_err(card->dev, "new control error %d\n", err); 2199 snd_card_free(card); 2200 return err; 2201 } 2202 2203 2204 2205 #if defined(CONFIG_PM_SLEEP) 2206 2207 static int snd_echo_suspend(struct device *dev) 2208 { 2209 struct echoaudio *chip = dev_get_drvdata(dev); 2210 2211 #ifdef ECHOCARD_HAS_MIDI 2212 /* This call can sleep */ 2213 if (chip->midi_out) 2214 snd_echo_midi_output_trigger(chip->midi_out, 0); 2215 #endif 2216 spin_lock_irq(&chip->lock); 2217 if (wait_handshake(chip)) { 2218 spin_unlock_irq(&chip->lock); 2219 return -EIO; 2220 } 2221 clear_handshake(chip); 2222 if (send_vector(chip, DSP_VC_GO_COMATOSE) < 0) { 2223 spin_unlock_irq(&chip->lock); 2224 return -EIO; 2225 } 2226 spin_unlock_irq(&chip->lock); 2227 2228 chip->dsp_code = NULL; 2229 free_irq(chip->irq, chip); 2230 chip->irq = -1; 2231 chip->card->sync_irq = -1; 2232 return 0; 2233 } 2234 2235 2236 2237 static int snd_echo_resume(struct device *dev) 2238 { 2239 struct pci_dev *pci = to_pci_dev(dev); 2240 struct echoaudio *chip = dev_get_drvdata(dev); 2241 struct comm_page *commpage, *commpage_bak; 2242 u32 pipe_alloc_mask; 2243 int err; 2244 2245 commpage = chip->comm_page; 2246 commpage_bak = kmemdup(commpage, sizeof(*commpage), GFP_KERNEL); 2247 if (commpage_bak == NULL) 2248 return -ENOMEM; 2249 2250 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device); 2251 if (err < 0) { 2252 kfree(commpage_bak); 2253 dev_err(dev, "resume init_hw err=%d\n", err); 2254 return err; 2255 } 2256 2257 /* Temporarily set chip->pipe_alloc_mask=0 otherwise 2258 * restore_dsp_settings() fails. 2259 */ 2260 pipe_alloc_mask = chip->pipe_alloc_mask; 2261 chip->pipe_alloc_mask = 0; 2262 err = restore_dsp_rettings(chip); 2263 chip->pipe_alloc_mask = pipe_alloc_mask; 2264 if (err < 0) { 2265 kfree(commpage_bak); 2266 return err; 2267 } 2268 2269 memcpy(&commpage->audio_format, &commpage_bak->audio_format, 2270 sizeof(commpage->audio_format)); 2271 memcpy(&commpage->sglist_addr, &commpage_bak->sglist_addr, 2272 sizeof(commpage->sglist_addr)); 2273 memcpy(&commpage->midi_output, &commpage_bak->midi_output, 2274 sizeof(commpage->midi_output)); 2275 kfree(commpage_bak); 2276 2277 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED, 2278 KBUILD_MODNAME, chip)) { 2279 dev_err(chip->card->dev, "cannot grab irq\n"); 2280 return -EBUSY; 2281 } 2282 chip->irq = pci->irq; 2283 chip->card->sync_irq = chip->irq; 2284 dev_dbg(dev, "resume irq=%d\n", chip->irq); 2285 2286 #ifdef ECHOCARD_HAS_MIDI 2287 if (chip->midi_input_enabled) 2288 enable_midi_input(chip, true); 2289 if (chip->midi_out) 2290 snd_echo_midi_output_trigger(chip->midi_out, 1); 2291 #endif 2292 2293 return 0; 2294 } 2295 2296 static SIMPLE_DEV_PM_OPS(snd_echo_pm, snd_echo_suspend, snd_echo_resume); 2297 #define SND_ECHO_PM_OPS &snd_echo_pm 2298 #else 2299 #define SND_ECHO_PM_OPS NULL 2300 #endif /* CONFIG_PM_SLEEP */ 2301 2302 2303 static void snd_echo_remove(struct pci_dev *pci) 2304 { 2305 struct echoaudio *chip; 2306 2307 chip = pci_get_drvdata(pci); 2308 if (chip) 2309 snd_card_free(chip->card); 2310 } 2311 2312 2313 2314 /****************************************************************************** 2315 Everything starts and ends here 2316 ******************************************************************************/ 2317 2318 /* pci_driver definition */ 2319 static struct pci_driver echo_driver = { 2320 .name = KBUILD_MODNAME, 2321 .id_table = snd_echo_ids, 2322 .probe = snd_echo_probe, 2323 .remove = snd_echo_remove, 2324 .driver = { 2325 .pm = SND_ECHO_PM_OPS, 2326 }, 2327 }; 2328 2329 module_pci_driver(echo_driver); 2330