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