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