1 /* 2 * Support for Digigram Lola PCI-e boards 3 * 4 * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the Free 8 * Software Foundation; either version 2 of the License, or (at your option) 9 * any later version. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * You should have received a copy of the GNU General Public License along with 17 * this program; if not, write to the Free Software Foundation, Inc., 59 18 * Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 */ 20 21 #include <linux/kernel.h> 22 #include <linux/init.h> 23 #include <linux/vmalloc.h> 24 #include <linux/io.h> 25 #include <sound/core.h> 26 #include <sound/control.h> 27 #include <sound/pcm.h> 28 #include <sound/tlv.h> 29 #include "lola.h" 30 31 static int __devinit lola_init_pin(struct lola *chip, struct lola_pin *pin, 32 int dir, int nid) 33 { 34 unsigned int val; 35 int err; 36 37 pin->nid = nid; 38 err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val); 39 if (err < 0) { 40 printk(KERN_ERR SFX "Can't read wcaps for 0x%x\n", nid); 41 return err; 42 } 43 val &= 0x00f00fff; /* test TYPE and bits 0..11 */ 44 if (val == 0x00400200) /* Type = 4, Digital = 1 */ 45 pin->is_analog = false; 46 else if (val == 0x0040000a && dir == CAPT) /* Dig=0, InAmp/ovrd */ 47 pin->is_analog = true; 48 else if (val == 0x0040000c && dir == PLAY) /* Dig=0, OutAmp/ovrd */ 49 pin->is_analog = true; 50 else { 51 printk(KERN_ERR SFX "Invalid wcaps 0x%x for 0x%x\n", val, nid); 52 return -EINVAL; 53 } 54 55 /* analog parameters only following, so continue in case of Digital pin 56 */ 57 if (!pin->is_analog) 58 return 0; 59 60 if (dir == PLAY) 61 err = lola_read_param(chip, nid, LOLA_PAR_AMP_OUT_CAP, &val); 62 else 63 err = lola_read_param(chip, nid, LOLA_PAR_AMP_IN_CAP, &val); 64 if (err < 0) { 65 printk(KERN_ERR SFX "Can't read AMP-caps for 0x%x\n", nid); 66 return err; 67 } 68 69 pin->amp_mute = LOLA_AMP_MUTE_CAPABLE(val); 70 pin->amp_step_size = LOLA_AMP_STEP_SIZE(val); 71 pin->amp_num_steps = LOLA_AMP_NUM_STEPS(val); 72 if (pin->amp_num_steps) { 73 /* zero as mute state */ 74 pin->amp_num_steps++; 75 pin->amp_step_size++; 76 } 77 pin->amp_offset = LOLA_AMP_OFFSET(val); 78 79 err = lola_codec_read(chip, nid, LOLA_VERB_GET_MAX_LEVEL, 0, 0, &val, 80 NULL); 81 if (err < 0) { 82 printk(KERN_ERR SFX "Can't get MAX_LEVEL 0x%x\n", nid); 83 return err; 84 } 85 pin->max_level = val & 0x3ff; /* 10 bits */ 86 87 pin->config_default_reg = 0; 88 pin->fixed_gain_list_len = 0; 89 pin->cur_gain_step = 0; 90 91 return 0; 92 } 93 94 int __devinit lola_init_pins(struct lola *chip, int dir, int *nidp) 95 { 96 int i, err, nid; 97 nid = *nidp; 98 for (i = 0; i < chip->pin[dir].num_pins; i++, nid++) { 99 err = lola_init_pin(chip, &chip->pin[dir].pins[i], dir, nid); 100 if (err < 0) 101 return err; 102 if (chip->pin[dir].pins[i].is_analog) 103 chip->pin[dir].num_analog_pins++; 104 } 105 *nidp = nid; 106 return 0; 107 } 108 109 void lola_free_mixer(struct lola *chip) 110 { 111 if (chip->mixer.array_saved) 112 vfree(chip->mixer.array_saved); 113 } 114 115 int __devinit lola_init_mixer_widget(struct lola *chip, int nid) 116 { 117 unsigned int val; 118 int err; 119 120 err = lola_read_param(chip, nid, LOLA_PAR_AUDIO_WIDGET_CAP, &val); 121 if (err < 0) { 122 printk(KERN_ERR SFX "Can't read wcaps for 0x%x\n", nid); 123 return err; 124 } 125 126 if ((val & 0xfff00000) != 0x02f00000) { /* test SubType and Type */ 127 snd_printdd("No valid mixer widget\n"); 128 return 0; 129 } 130 131 chip->mixer.nid = nid; 132 chip->mixer.caps = val; 133 chip->mixer.array = (struct lola_mixer_array __iomem *) 134 (chip->bar[BAR1].remap_addr + LOLA_BAR1_SOURCE_GAIN_ENABLE); 135 136 /* reserve memory to copy mixer data for sleep mode transitions */ 137 chip->mixer.array_saved = vmalloc(sizeof(struct lola_mixer_array)); 138 139 /* mixer matrix sources are physical input data and play streams */ 140 chip->mixer.src_stream_outs = chip->pcm[PLAY].num_streams; 141 chip->mixer.src_phys_ins = chip->pin[CAPT].num_pins; 142 143 /* mixer matrix destinations are record streams and physical output */ 144 chip->mixer.dest_stream_ins = chip->pcm[CAPT].num_streams; 145 chip->mixer.dest_phys_outs = chip->pin[PLAY].num_pins; 146 147 /* mixer matrix can have unused areas between PhysIn and 148 * Play or Record and PhysOut zones 149 */ 150 chip->mixer.src_stream_out_ofs = chip->mixer.src_phys_ins + 151 LOLA_MIXER_SRC_INPUT_PLAY_SEPARATION(val); 152 chip->mixer.dest_phys_out_ofs = chip->mixer.dest_stream_ins + 153 LOLA_MIXER_DEST_REC_OUTPUT_SEPATATION(val); 154 155 /* example : MixerMatrix of LoLa881 156 * 0-------8------16-------8------16 157 * | | | | | 158 * | INPUT | | INPUT | | 159 * | -> |unused | -> |unused | 160 * | RECORD| | OUTPUT| | 161 * | | | | | 162 * 8-------------------------------- 163 * | | | | | 164 * | | | | | 165 * |unused |unused |unused |unused | 166 * | | | | | 167 * | | | | | 168 * 16------------------------------- 169 * | | | | | 170 * | PLAY | | PLAY | | 171 * | -> |unused | -> |unused | 172 * | RECORD| | OUTPUT| | 173 * | | | | | 174 * 8-------------------------------- 175 * | | | | | 176 * | | | | | 177 * |unused |unused |unused |unused | 178 * | | | | | 179 * | | | | | 180 * 16------------------------------- 181 */ 182 if (chip->mixer.src_stream_out_ofs > MAX_AUDIO_INOUT_COUNT || 183 chip->mixer.dest_phys_out_ofs > MAX_STREAM_IN_COUNT) { 184 printk(KERN_ERR SFX "Invalid mixer widget size\n"); 185 return -EINVAL; 186 } 187 188 chip->mixer.src_mask = ((1U << chip->mixer.src_phys_ins) - 1) | 189 (((1U << chip->mixer.src_stream_outs) - 1) 190 << chip->mixer.src_stream_out_ofs); 191 chip->mixer.dest_mask = ((1U << chip->mixer.dest_stream_ins) - 1) | 192 (((1U << chip->mixer.dest_phys_outs) - 1) 193 << chip->mixer.dest_phys_out_ofs); 194 195 return 0; 196 } 197 198 static int lola_mixer_set_src_gain(struct lola *chip, unsigned int id, 199 unsigned short gain, bool on) 200 { 201 unsigned int oldval, val; 202 203 if (!(chip->mixer.src_mask & (1 << id))) 204 return -EINVAL; 205 writew(gain, &chip->mixer.array->src_gain[id]); 206 oldval = val = readl(&chip->mixer.array->src_gain_enable); 207 if (on) 208 val |= (1 << id); 209 else 210 val &= ~(1 << id); 211 writel(val, &chip->mixer.array->src_gain_enable); 212 lola_codec_flush(chip); 213 /* inform micro-controller about the new source gain */ 214 return lola_codec_write(chip, chip->mixer.nid, 215 LOLA_VERB_SET_SOURCE_GAIN, id, 0); 216 } 217 218 #if 0 /* not used */ 219 static int lola_mixer_set_src_gains(struct lola *chip, unsigned int mask, 220 unsigned short *gains) 221 { 222 int i; 223 224 if ((chip->mixer.src_mask & mask) != mask) 225 return -EINVAL; 226 for (i = 0; i < LOLA_MIXER_DIM; i++) { 227 if (mask & (1 << i)) { 228 writew(*gains, &chip->mixer.array->src_gain[i]); 229 gains++; 230 } 231 } 232 writel(mask, &chip->mixer.array->src_gain_enable); 233 lola_codec_flush(chip); 234 if (chip->mixer.caps & LOLA_PEAK_METER_CAN_AGC_MASK) { 235 /* update for all srcs at once */ 236 return lola_codec_write(chip, chip->mixer.nid, 237 LOLA_VERB_SET_SOURCE_GAIN, 0x80, 0); 238 } 239 /* update manually */ 240 for (i = 0; i < LOLA_MIXER_DIM; i++) { 241 if (mask & (1 << i)) { 242 lola_codec_write(chip, chip->mixer.nid, 243 LOLA_VERB_SET_SOURCE_GAIN, i, 0); 244 } 245 } 246 return 0; 247 } 248 #endif /* not used */ 249 250 static int lola_mixer_set_mapping_gain(struct lola *chip, 251 unsigned int src, unsigned int dest, 252 unsigned short gain, bool on) 253 { 254 unsigned int val; 255 256 if (!(chip->mixer.src_mask & (1 << src)) || 257 !(chip->mixer.dest_mask & (1 << dest))) 258 return -EINVAL; 259 if (on) 260 writew(gain, &chip->mixer.array->dest_mix_gain[dest][src]); 261 val = readl(&chip->mixer.array->dest_mix_gain_enable[dest]); 262 if (on) 263 val |= (1 << src); 264 else 265 val &= ~(1 << src); 266 writel(val, &chip->mixer.array->dest_mix_gain_enable[dest]); 267 lola_codec_flush(chip); 268 return lola_codec_write(chip, chip->mixer.nid, LOLA_VERB_SET_MIX_GAIN, 269 src, dest); 270 } 271 272 static int lola_mixer_set_dest_gains(struct lola *chip, unsigned int id, 273 unsigned int mask, unsigned short *gains) 274 { 275 int i; 276 277 if (!(chip->mixer.dest_mask & (1 << id)) || 278 (chip->mixer.src_mask & mask) != mask) 279 return -EINVAL; 280 for (i = 0; i < LOLA_MIXER_DIM; i++) { 281 if (mask & (1 << i)) { 282 writew(*gains, &chip->mixer.array->dest_mix_gain[id][i]); 283 gains++; 284 } 285 } 286 writel(mask, &chip->mixer.array->dest_mix_gain_enable[id]); 287 lola_codec_flush(chip); 288 /* update for all dests at once */ 289 return lola_codec_write(chip, chip->mixer.nid, 290 LOLA_VERB_SET_DESTINATION_GAIN, id, 0); 291 } 292 293 /* 294 */ 295 296 static int set_analog_volume(struct lola *chip, int dir, 297 unsigned int idx, unsigned int val, 298 bool external_call); 299 300 int lola_setup_all_analog_gains(struct lola *chip, int dir, bool mute) 301 { 302 struct lola_pin *pin; 303 int idx, max_idx; 304 305 pin = chip->pin[dir].pins; 306 max_idx = chip->pin[dir].num_pins; 307 for (idx = 0; idx < max_idx; idx++) { 308 if (pin[idx].is_analog) { 309 unsigned int val = mute ? 0 : pin[idx].cur_gain_step; 310 /* set volume and do not save the value */ 311 set_analog_volume(chip, dir, idx, val, false); 312 } 313 } 314 return lola_codec_flush(chip); 315 } 316 317 void lola_save_mixer(struct lola *chip) 318 { 319 /* mute analog output */ 320 if (chip->mixer.array_saved) { 321 /* store contents of mixer array */ 322 memcpy_fromio(chip->mixer.array_saved, chip->mixer.array, 323 sizeof(*chip->mixer.array)); 324 } 325 lola_setup_all_analog_gains(chip, PLAY, true); /* output mute */ 326 } 327 328 void lola_restore_mixer(struct lola *chip) 329 { 330 int i; 331 332 /*lola_reset_setups(chip);*/ 333 if (chip->mixer.array_saved) { 334 /* restore contents of mixer array */ 335 memcpy_toio(chip->mixer.array, chip->mixer.array_saved, 336 sizeof(*chip->mixer.array)); 337 /* inform micro-controller about all restored values 338 * and ignore return values 339 */ 340 for (i = 0; i < chip->mixer.src_phys_ins; i++) 341 lola_codec_write(chip, chip->mixer.nid, 342 LOLA_VERB_SET_SOURCE_GAIN, 343 i, 0); 344 for (i = 0; i < chip->mixer.src_stream_outs; i++) 345 lola_codec_write(chip, chip->mixer.nid, 346 LOLA_VERB_SET_SOURCE_GAIN, 347 chip->mixer.src_stream_out_ofs + i, 0); 348 for (i = 0; i < chip->mixer.dest_stream_ins; i++) 349 lola_codec_write(chip, chip->mixer.nid, 350 LOLA_VERB_SET_DESTINATION_GAIN, 351 i, 0); 352 for (i = 0; i < chip->mixer.dest_phys_outs; i++) 353 lola_codec_write(chip, chip->mixer.nid, 354 LOLA_VERB_SET_DESTINATION_GAIN, 355 chip->mixer.dest_phys_out_ofs + i, 0); 356 lola_codec_flush(chip); 357 } 358 } 359 360 /* 361 */ 362 363 static int set_analog_volume(struct lola *chip, int dir, 364 unsigned int idx, unsigned int val, 365 bool external_call) 366 { 367 struct lola_pin *pin; 368 int err; 369 370 if (idx >= chip->pin[dir].num_pins) 371 return -EINVAL; 372 pin = &chip->pin[dir].pins[idx]; 373 if (!pin->is_analog || pin->amp_num_steps <= val) 374 return -EINVAL; 375 if (external_call && pin->cur_gain_step == val) 376 return 0; 377 if (external_call) 378 lola_codec_flush(chip); 379 err = lola_codec_write(chip, pin->nid, 380 LOLA_VERB_SET_AMP_GAIN_MUTE, val, 0); 381 if (err < 0) 382 return err; 383 if (external_call) 384 pin->cur_gain_step = val; 385 return 0; 386 } 387 388 int lola_set_src_config(struct lola *chip, unsigned int src_mask, bool update) 389 { 390 int ret = 0; 391 int success = 0; 392 int n, err; 393 394 /* SRC can be activated and the dwInputSRCMask is valid? */ 395 if ((chip->input_src_caps_mask & src_mask) != src_mask) 396 return -EINVAL; 397 /* handle all even Inputs - SRC is a stereo setting !!! */ 398 for (n = 0; n < chip->pin[CAPT].num_pins; n += 2) { 399 unsigned int mask = 3U << n; /* handle the stereo case */ 400 unsigned int new_src, src_state; 401 if (!(chip->input_src_caps_mask & mask)) 402 continue; 403 /* if one IO needs SRC, both stereo IO will get SRC */ 404 new_src = (src_mask & mask) != 0; 405 if (update) { 406 src_state = (chip->input_src_mask & mask) != 0; 407 if (src_state == new_src) 408 continue; /* nothing to change for this IO */ 409 } 410 err = lola_codec_write(chip, chip->pcm[CAPT].streams[n].nid, 411 LOLA_VERB_SET_SRC, new_src, 0); 412 if (!err) 413 success++; 414 else 415 ret = err; 416 } 417 if (success) 418 ret = lola_codec_flush(chip); 419 if (!ret) 420 chip->input_src_mask = src_mask; 421 return ret; 422 } 423 424 /* 425 */ 426 static int init_mixer_values(struct lola *chip) 427 { 428 int i; 429 430 /* all src on */ 431 lola_set_src_config(chip, (1 << chip->pin[CAPT].num_pins) - 1, false); 432 433 /* clear all matrix */ 434 memset_io(chip->mixer.array, 0, sizeof(*chip->mixer.array)); 435 /* set src gain to 0dB */ 436 for (i = 0; i < chip->mixer.src_phys_ins; i++) 437 lola_mixer_set_src_gain(chip, i, 336, true); /* 0dB */ 438 for (i = 0; i < chip->mixer.src_stream_outs; i++) 439 lola_mixer_set_src_gain(chip, 440 i + chip->mixer.src_stream_out_ofs, 441 336, true); /* 0dB */ 442 /* set 1:1 dest gain */ 443 for (i = 0; i < chip->mixer.dest_stream_ins; i++) { 444 int src = i % chip->mixer.src_phys_ins; 445 lola_mixer_set_mapping_gain(chip, src, i, 336, true); 446 } 447 for (i = 0; i < chip->mixer.src_stream_outs; i++) { 448 int src = chip->mixer.src_stream_out_ofs + i; 449 int dst = chip->mixer.dest_phys_out_ofs + 450 i % chip->mixer.dest_phys_outs; 451 lola_mixer_set_mapping_gain(chip, src, dst, 336, true); 452 } 453 return 0; 454 } 455 456 /* 457 * analog mixer control element 458 */ 459 static int lola_analog_vol_info(struct snd_kcontrol *kcontrol, 460 struct snd_ctl_elem_info *uinfo) 461 { 462 struct lola *chip = snd_kcontrol_chip(kcontrol); 463 int dir = kcontrol->private_value; 464 465 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 466 uinfo->count = chip->pin[dir].num_pins; 467 uinfo->value.integer.min = 0; 468 uinfo->value.integer.max = chip->pin[dir].pins[0].amp_num_steps; 469 return 0; 470 } 471 472 static int lola_analog_vol_get(struct snd_kcontrol *kcontrol, 473 struct snd_ctl_elem_value *ucontrol) 474 { 475 struct lola *chip = snd_kcontrol_chip(kcontrol); 476 int dir = kcontrol->private_value; 477 int i; 478 479 for (i = 0; i < chip->pin[dir].num_pins; i++) 480 ucontrol->value.integer.value[i] = 481 chip->pin[dir].pins[i].cur_gain_step; 482 return 0; 483 } 484 485 static int lola_analog_vol_put(struct snd_kcontrol *kcontrol, 486 struct snd_ctl_elem_value *ucontrol) 487 { 488 struct lola *chip = snd_kcontrol_chip(kcontrol); 489 int dir = kcontrol->private_value; 490 int i, err; 491 492 for (i = 0; i < chip->pin[dir].num_pins; i++) { 493 err = set_analog_volume(chip, dir, i, 494 ucontrol->value.integer.value[i], 495 true); 496 if (err < 0) 497 return err; 498 } 499 return 0; 500 } 501 502 static int lola_analog_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag, 503 unsigned int size, unsigned int __user *tlv) 504 { 505 struct lola *chip = snd_kcontrol_chip(kcontrol); 506 int dir = kcontrol->private_value; 507 unsigned int val1, val2; 508 struct lola_pin *pin; 509 510 if (size < 4 * sizeof(unsigned int)) 511 return -ENOMEM; 512 pin = &chip->pin[dir].pins[0]; 513 514 val2 = pin->amp_step_size * 25; 515 val1 = -1 * (int)pin->amp_offset * (int)val2; 516 #ifdef TLV_DB_SCALE_MUTE 517 val2 |= TLV_DB_SCALE_MUTE; 518 #endif 519 if (put_user(SNDRV_CTL_TLVT_DB_SCALE, tlv)) 520 return -EFAULT; 521 if (put_user(2 * sizeof(unsigned int), tlv + 1)) 522 return -EFAULT; 523 if (put_user(val1, tlv + 2)) 524 return -EFAULT; 525 if (put_user(val2, tlv + 3)) 526 return -EFAULT; 527 return 0; 528 } 529 530 static struct snd_kcontrol_new lola_analog_mixer __devinitdata = { 531 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 532 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 533 SNDRV_CTL_ELEM_ACCESS_TLV_READ | 534 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), 535 .info = lola_analog_vol_info, 536 .get = lola_analog_vol_get, 537 .put = lola_analog_vol_put, 538 .tlv.c = lola_analog_vol_tlv, 539 }; 540 541 static int __devinit create_analog_mixer(struct lola *chip, int dir, char *name) 542 { 543 if (!chip->pin[dir].num_pins) 544 return 0; 545 /* no analog volumes on digital only adapters */ 546 if (chip->pin[dir].num_pins != chip->pin[dir].num_analog_pins) 547 return 0; 548 lola_analog_mixer.name = name; 549 lola_analog_mixer.private_value = dir; 550 return snd_ctl_add(chip->card, 551 snd_ctl_new1(&lola_analog_mixer, chip)); 552 } 553 554 /* 555 * Hardware sample rate converter on digital input 556 */ 557 static int lola_input_src_info(struct snd_kcontrol *kcontrol, 558 struct snd_ctl_elem_info *uinfo) 559 { 560 struct lola *chip = snd_kcontrol_chip(kcontrol); 561 562 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 563 uinfo->count = chip->pin[CAPT].num_pins; 564 uinfo->value.integer.min = 0; 565 uinfo->value.integer.max = 1; 566 return 0; 567 } 568 569 static int lola_input_src_get(struct snd_kcontrol *kcontrol, 570 struct snd_ctl_elem_value *ucontrol) 571 { 572 struct lola *chip = snd_kcontrol_chip(kcontrol); 573 int i; 574 575 for (i = 0; i < chip->pin[CAPT].num_pins; i++) 576 ucontrol->value.integer.value[i] = 577 !!(chip->input_src_mask & (1 << i)); 578 return 0; 579 } 580 581 static int lola_input_src_put(struct snd_kcontrol *kcontrol, 582 struct snd_ctl_elem_value *ucontrol) 583 { 584 struct lola *chip = snd_kcontrol_chip(kcontrol); 585 int i; 586 unsigned int mask; 587 588 mask = 0; 589 for (i = 0; i < chip->pin[CAPT].num_pins; i++) 590 if (ucontrol->value.integer.value[i]) 591 mask |= 1 << i; 592 return lola_set_src_config(chip, mask, true); 593 } 594 595 static struct snd_kcontrol_new lola_input_src_mixer __devinitdata = { 596 .name = "Digital SRC Capture Switch", 597 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 598 .info = lola_input_src_info, 599 .get = lola_input_src_get, 600 .put = lola_input_src_put, 601 }; 602 603 /* 604 * Lola16161 or Lola881 can have Hardware sample rate converters 605 * on its digital input pins 606 */ 607 static int __devinit create_input_src_mixer(struct lola *chip) 608 { 609 if (!chip->input_src_caps_mask) 610 return 0; 611 612 return snd_ctl_add(chip->card, 613 snd_ctl_new1(&lola_input_src_mixer, chip)); 614 } 615 616 /* 617 * src gain mixer 618 */ 619 static int lola_src_gain_info(struct snd_kcontrol *kcontrol, 620 struct snd_ctl_elem_info *uinfo) 621 { 622 unsigned int count = (kcontrol->private_value >> 8) & 0xff; 623 624 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 625 uinfo->count = count; 626 uinfo->value.integer.min = 0; 627 uinfo->value.integer.max = 409; 628 return 0; 629 } 630 631 static int lola_src_gain_get(struct snd_kcontrol *kcontrol, 632 struct snd_ctl_elem_value *ucontrol) 633 { 634 struct lola *chip = snd_kcontrol_chip(kcontrol); 635 unsigned int ofs = kcontrol->private_value & 0xff; 636 unsigned int count = (kcontrol->private_value >> 8) & 0xff; 637 unsigned int mask, i; 638 639 mask = readl(&chip->mixer.array->src_gain_enable); 640 for (i = 0; i < count; i++) { 641 unsigned int idx = ofs + i; 642 unsigned short val; 643 if (!(chip->mixer.src_mask & (1 << idx))) 644 return -EINVAL; 645 if (mask & (1 << idx)) 646 val = readw(&chip->mixer.array->src_gain[idx]) + 1; 647 else 648 val = 0; 649 ucontrol->value.integer.value[i] = val; 650 } 651 return 0; 652 } 653 654 static int lola_src_gain_put(struct snd_kcontrol *kcontrol, 655 struct snd_ctl_elem_value *ucontrol) 656 { 657 struct lola *chip = snd_kcontrol_chip(kcontrol); 658 unsigned int ofs = kcontrol->private_value & 0xff; 659 unsigned int count = (kcontrol->private_value >> 8) & 0xff; 660 int i, err; 661 662 for (i = 0; i < count; i++) { 663 unsigned int idx = ofs + i; 664 unsigned short val = ucontrol->value.integer.value[i]; 665 if (val) 666 val--; 667 err = lola_mixer_set_src_gain(chip, idx, val, !!val); 668 if (err < 0) 669 return err; 670 } 671 return 0; 672 } 673 674 /* raw value: 0 = -84dB, 336 = 0dB, 408=18dB, incremented 1 for mute */ 675 static const DECLARE_TLV_DB_SCALE(lola_src_gain_tlv, -8425, 25, 1); 676 677 static struct snd_kcontrol_new lola_src_gain_mixer __devinitdata = { 678 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 679 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 680 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 681 .info = lola_src_gain_info, 682 .get = lola_src_gain_get, 683 .put = lola_src_gain_put, 684 .tlv.p = lola_src_gain_tlv, 685 }; 686 687 static int __devinit create_src_gain_mixer(struct lola *chip, 688 int num, int ofs, char *name) 689 { 690 lola_src_gain_mixer.name = name; 691 lola_src_gain_mixer.private_value = ofs + (num << 8); 692 return snd_ctl_add(chip->card, 693 snd_ctl_new1(&lola_src_gain_mixer, chip)); 694 } 695 696 /* 697 * destination gain (matrix-like) mixer 698 */ 699 static int lola_dest_gain_info(struct snd_kcontrol *kcontrol, 700 struct snd_ctl_elem_info *uinfo) 701 { 702 unsigned int src_num = (kcontrol->private_value >> 8) & 0xff; 703 704 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 705 uinfo->count = src_num; 706 uinfo->value.integer.min = 0; 707 uinfo->value.integer.max = 433; 708 return 0; 709 } 710 711 static int lola_dest_gain_get(struct snd_kcontrol *kcontrol, 712 struct snd_ctl_elem_value *ucontrol) 713 { 714 struct lola *chip = snd_kcontrol_chip(kcontrol); 715 unsigned int src_ofs = kcontrol->private_value & 0xff; 716 unsigned int src_num = (kcontrol->private_value >> 8) & 0xff; 717 unsigned int dst_ofs = (kcontrol->private_value >> 16) & 0xff; 718 unsigned int dst, mask, i; 719 720 dst = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + dst_ofs; 721 mask = readl(&chip->mixer.array->dest_mix_gain_enable[dst]); 722 for (i = 0; i < src_num; i++) { 723 unsigned int src = src_ofs + i; 724 unsigned short val; 725 if (!(chip->mixer.src_mask & (1 << src))) 726 return -EINVAL; 727 if (mask & (1 << dst)) 728 val = readw(&chip->mixer.array->dest_mix_gain[dst][src]) + 1; 729 else 730 val = 0; 731 ucontrol->value.integer.value[i] = val; 732 } 733 return 0; 734 } 735 736 static int lola_dest_gain_put(struct snd_kcontrol *kcontrol, 737 struct snd_ctl_elem_value *ucontrol) 738 { 739 struct lola *chip = snd_kcontrol_chip(kcontrol); 740 unsigned int src_ofs = kcontrol->private_value & 0xff; 741 unsigned int src_num = (kcontrol->private_value >> 8) & 0xff; 742 unsigned int dst_ofs = (kcontrol->private_value >> 16) & 0xff; 743 unsigned int dst, mask; 744 unsigned short gains[MAX_STREAM_COUNT]; 745 int i, num; 746 747 mask = 0; 748 num = 0; 749 for (i = 0; i < src_num; i++) { 750 unsigned short val = ucontrol->value.integer.value[i]; 751 if (val) { 752 gains[num++] = val - 1; 753 mask |= 1 << i; 754 } 755 } 756 mask <<= src_ofs; 757 dst = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + dst_ofs; 758 return lola_mixer_set_dest_gains(chip, dst, mask, gains); 759 } 760 761 static const DECLARE_TLV_DB_SCALE(lola_dest_gain_tlv, -8425, 25, 1); 762 763 static struct snd_kcontrol_new lola_dest_gain_mixer __devinitdata = { 764 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 765 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 766 SNDRV_CTL_ELEM_ACCESS_TLV_READ), 767 .info = lola_dest_gain_info, 768 .get = lola_dest_gain_get, 769 .put = lola_dest_gain_put, 770 .tlv.p = lola_dest_gain_tlv, 771 }; 772 773 static int __devinit create_dest_gain_mixer(struct lola *chip, 774 int src_num, int src_ofs, 775 int num, int ofs, char *name) 776 { 777 lola_dest_gain_mixer.count = num; 778 lola_dest_gain_mixer.name = name; 779 lola_dest_gain_mixer.private_value = 780 src_ofs + (src_num << 8) + (ofs << 16) + (num << 24); 781 return snd_ctl_add(chip->card, 782 snd_ctl_new1(&lola_dest_gain_mixer, chip)); 783 } 784 785 /* 786 */ 787 int __devinit lola_create_mixer(struct lola *chip) 788 { 789 int err; 790 791 err = create_analog_mixer(chip, PLAY, "Analog Playback Volume"); 792 if (err < 0) 793 return err; 794 err = create_analog_mixer(chip, CAPT, "Analog Capture Volume"); 795 if (err < 0) 796 return err; 797 err = create_input_src_mixer(chip); 798 if (err < 0) 799 return err; 800 err = create_src_gain_mixer(chip, chip->mixer.src_phys_ins, 0, 801 "Line Source Gain Volume"); 802 if (err < 0) 803 return err; 804 err = create_src_gain_mixer(chip, chip->mixer.src_stream_outs, 805 chip->mixer.src_stream_out_ofs, 806 "Stream Source Gain Volume"); 807 if (err < 0) 808 return err; 809 err = create_dest_gain_mixer(chip, 810 chip->mixer.src_phys_ins, 0, 811 chip->mixer.dest_stream_ins, 0, 812 "Line Capture Volume"); 813 if (err < 0) 814 return err; 815 err = create_dest_gain_mixer(chip, 816 chip->mixer.src_stream_outs, 817 chip->mixer.src_stream_out_ofs, 818 chip->mixer.dest_stream_ins, 0, 819 "Stream-Loopback Capture Volume"); 820 if (err < 0) 821 return err; 822 err = create_dest_gain_mixer(chip, 823 chip->mixer.src_phys_ins, 0, 824 chip->mixer.dest_phys_outs, 825 chip->mixer.dest_phys_out_ofs, 826 "Line-Loopback Playback Volume"); 827 if (err < 0) 828 return err; 829 err = create_dest_gain_mixer(chip, 830 chip->mixer.src_stream_outs, 831 chip->mixer.src_stream_out_ofs, 832 chip->mixer.dest_phys_outs, 833 chip->mixer.dest_phys_out_ofs, 834 "Stream Playback Volume"); 835 if (err < 0) 836 return err; 837 838 return init_mixer_values(chip); 839 } 840