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