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, data: 0, extdata: 0, val: &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, pin: &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(addr: 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(size: 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(addr: &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(addr: &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(val: gain, addr: &chip->mixer.array->src_gain[id]); |
231 | writel(val, addr: &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, nid: chip->mixer.nid, |
235 | LOLA_VERB_SET_SOURCE_GAIN, data: id, extdata: 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(val: gain, addr: &chip->mixer.array->dest_mix_gain[dest][src]); |
281 | val = readl(addr: &chip->mixer.array->dest_mix_gain_enable[dest]); |
282 | if (on) |
283 | val |= (1 << src); |
284 | else |
285 | val &= ~(1 << src); |
286 | writel(val, addr: &chip->mixer.array->dest_mix_gain_enable[dest]); |
287 | lola_codec_flush(chip); |
288 | return lola_codec_write(chip, nid: chip->mixer.nid, LOLA_VERB_SET_MIX_GAIN, |
289 | data: src, extdata: 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, external_call: 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, mute: 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, nid: chip->mixer.nid, |
364 | LOLA_VERB_SET_SOURCE_GAIN, |
365 | data: i, extdata: 0); |
366 | for (i = 0; i < chip->mixer.src_stream_outs; i++) |
367 | lola_codec_write(chip, nid: chip->mixer.nid, |
368 | LOLA_VERB_SET_SOURCE_GAIN, |
369 | data: chip->mixer.src_stream_out_ofs + i, extdata: 0); |
370 | for (i = 0; i < chip->mixer.dest_stream_ins; i++) |
371 | lola_codec_write(chip, nid: chip->mixer.nid, |
372 | LOLA_VERB_SET_DESTINATION_GAIN, |
373 | data: i, extdata: 0); |
374 | for (i = 0; i < chip->mixer.dest_phys_outs; i++) |
375 | lola_codec_write(chip, nid: chip->mixer.nid, |
376 | LOLA_VERB_SET_DESTINATION_GAIN, |
377 | data: chip->mixer.dest_phys_out_ofs + i, extdata: 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, nid: pin->nid, |
405 | LOLA_VERB_SET_AMP_GAIN_MUTE, data: val, extdata: 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, nid: chip->pcm[CAPT].streams[n].nid, |
436 | LOLA_VERB_SET_SRC, data: new_src, extdata: 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, src_mask: (1 << chip->pin[CAPT].num_pins) - 1, update: 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, nid: chip->mixer.nid, |
463 | LOLA_VERB_SET_DESTINATION_GAIN, |
464 | data: i, extdata: 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, nid: chip->mixer.nid, |
468 | LOLA_VERB_SET_DESTINATION_GAIN, |
469 | data: chip->mixer.dest_phys_out_ofs + i, extdata: 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, id: i, gain: 336, on: 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 | id: i + chip->mixer.src_stream_out_ofs, |
479 | gain: 336, on: 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, dest: i, gain: 336, on: 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, dest: dst, gain: 336, on: 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, idx: i, |
536 | val: ucontrol->value.integer.value[i], |
537 | external_call: 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(card: chip->card, |
593 | kcontrol: snd_ctl_new1(kcontrolnew: &lola_analog_mixer, private_data: 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, src_mask: mask, update: 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(card: chip->card, |
655 | kcontrol: snd_ctl_new1(kcontrolnew: &lola_input_src_mixer, private_data: 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(addr: &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(addr: &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, id: idx, gain: val, on: !!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(card: chip->card, |
735 | kcontrol: snd_ctl_new1(kcontrolnew: &lola_src_gain_mixer, private_data: 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, name: "Analog Playback Volume" ); |
836 | if (err < 0) |
837 | return err; |
838 | err = create_analog_mixer(chip, CAPT, name: "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, num: chip->mixer.src_phys_ins, ofs: 0, |
845 | name: "Digital Capture Volume" ); |
846 | if (err < 0) |
847 | return err; |
848 | err = create_src_gain_mixer(chip, num: chip->mixer.src_stream_outs, |
849 | ofs: chip->mixer.src_stream_out_ofs, |
850 | name: "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 | |