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