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