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