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