sound/pci/lola/lola_mixer.c

   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 }