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