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