1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // soc-ops.c  --  Generic ASoC operations
4 //
5 // Copyright 2005 Wolfson Microelectronics PLC.
6 // Copyright 2005 Openedhand Ltd.
7 // Copyright (C) 2010 Slimlogic Ltd.
8 // Copyright (C) 2010 Texas Instruments Inc.
9 //
10 // Author: Liam Girdwood <lrg@slimlogic.co.uk>
11 //         with code, comments and ideas from :-
12 //         Richard Purdie <richard@openedhand.com>
13 
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/init.h>
17 #include <linux/pm.h>
18 #include <linux/bitops.h>
19 #include <linux/ctype.h>
20 #include <linux/slab.h>
21 #include <sound/core.h>
22 #include <sound/jack.h>
23 #include <sound/pcm.h>
24 #include <sound/pcm_params.h>
25 #include <sound/soc.h>
26 #include <sound/soc-dpcm.h>
27 #include <sound/initval.h>
28 
29 /**
30  * snd_soc_info_enum_double - enumerated double mixer info callback
31  * @kcontrol: mixer control
32  * @uinfo: control element information
33  *
34  * Callback to provide information about a double enumerated
35  * mixer control.
36  *
37  * Returns 0 for success.
38  */
snd_soc_info_enum_double(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)39 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
40 	struct snd_ctl_elem_info *uinfo)
41 {
42 	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
43 
44 	return snd_ctl_enum_info(uinfo, e->shift_l == e->shift_r ? 1 : 2,
45 				 e->items, e->texts);
46 }
47 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
48 
49 /**
50  * snd_soc_get_enum_double - enumerated double mixer get callback
51  * @kcontrol: mixer control
52  * @ucontrol: control element information
53  *
54  * Callback to get the value of a double enumerated mixer.
55  *
56  * Returns 0 for success.
57  */
snd_soc_get_enum_double(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)58 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
59 	struct snd_ctl_elem_value *ucontrol)
60 {
61 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
62 	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
63 	unsigned int val, item;
64 	unsigned int reg_val;
65 
66 	reg_val = snd_soc_component_read(component, e->reg);
67 	val = (reg_val >> e->shift_l) & e->mask;
68 	item = snd_soc_enum_val_to_item(e, val);
69 	ucontrol->value.enumerated.item[0] = item;
70 	if (e->shift_l != e->shift_r) {
71 		val = (reg_val >> e->shift_r) & e->mask;
72 		item = snd_soc_enum_val_to_item(e, val);
73 		ucontrol->value.enumerated.item[1] = item;
74 	}
75 
76 	return 0;
77 }
78 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
79 
80 /**
81  * snd_soc_put_enum_double - enumerated double mixer put callback
82  * @kcontrol: mixer control
83  * @ucontrol: control element information
84  *
85  * Callback to set the value of a double enumerated mixer.
86  *
87  * Returns 0 for success.
88  */
snd_soc_put_enum_double(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)89 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
90 	struct snd_ctl_elem_value *ucontrol)
91 {
92 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
93 	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
94 	unsigned int *item = ucontrol->value.enumerated.item;
95 	unsigned int val;
96 	unsigned int mask;
97 
98 	if (item[0] >= e->items)
99 		return -EINVAL;
100 	val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
101 	mask = e->mask << e->shift_l;
102 	if (e->shift_l != e->shift_r) {
103 		if (item[1] >= e->items)
104 			return -EINVAL;
105 		val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
106 		mask |= e->mask << e->shift_r;
107 	}
108 
109 	return snd_soc_component_update_bits(component, e->reg, mask, val);
110 }
111 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
112 
113 /**
114  * snd_soc_read_signed - Read a codec register and interpret as signed value
115  * @component: component
116  * @reg: Register to read
117  * @mask: Mask to use after shifting the register value
118  * @shift: Right shift of register value
119  * @sign_bit: Bit that describes if a number is negative or not.
120  * @signed_val: Pointer to where the read value should be stored
121  *
122  * This functions reads a codec register. The register value is shifted right
123  * by 'shift' bits and masked with the given 'mask'. Afterwards it translates
124  * the given registervalue into a signed integer if sign_bit is non-zero.
125  *
126  * Returns 0 on sucess, otherwise an error value
127  */
snd_soc_read_signed(struct snd_soc_component * component,unsigned int reg,unsigned int mask,unsigned int shift,unsigned int sign_bit,int * signed_val)128 static int snd_soc_read_signed(struct snd_soc_component *component,
129 	unsigned int reg, unsigned int mask, unsigned int shift,
130 	unsigned int sign_bit, int *signed_val)
131 {
132 	int ret;
133 	unsigned int val;
134 
135 	val = snd_soc_component_read(component, reg);
136 	val = (val >> shift) & mask;
137 
138 	if (!sign_bit) {
139 		*signed_val = val;
140 		return 0;
141 	}
142 
143 	/* non-negative number */
144 	if (!(val & BIT(sign_bit))) {
145 		*signed_val = val;
146 		return 0;
147 	}
148 
149 	ret = val;
150 
151 	/*
152 	 * The register most probably does not contain a full-sized int.
153 	 * Instead we have an arbitrary number of bits in a signed
154 	 * representation which has to be translated into a full-sized int.
155 	 * This is done by filling up all bits above the sign-bit.
156 	 */
157 	ret |= ~((int)(BIT(sign_bit) - 1));
158 
159 	*signed_val = ret;
160 
161 	return 0;
162 }
163 
164 /**
165  * snd_soc_info_volsw - single mixer info callback
166  * @kcontrol: mixer control
167  * @uinfo: control element information
168  *
169  * Callback to provide information about a single mixer control, or a double
170  * mixer control that spans 2 registers.
171  *
172  * Returns 0 for success.
173  */
snd_soc_info_volsw(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)174 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
175 	struct snd_ctl_elem_info *uinfo)
176 {
177 	struct soc_mixer_control *mc =
178 		(struct soc_mixer_control *)kcontrol->private_value;
179 	const char *vol_string = NULL;
180 	int max;
181 
182 	max = uinfo->value.integer.max = mc->max - mc->min;
183 	if (mc->platform_max && mc->platform_max < max)
184 		max = mc->platform_max;
185 
186 	if (max == 1) {
187 		/* Even two value controls ending in Volume should always be integer */
188 		vol_string = strstr(kcontrol->id.name, " Volume");
189 		if (vol_string && !strcmp(vol_string, " Volume"))
190 			uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
191 		else
192 			uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
193 	} else {
194 		uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
195 	}
196 
197 	uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
198 	uinfo->value.integer.min = 0;
199 	uinfo->value.integer.max = max;
200 
201 	return 0;
202 }
203 EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
204 
205 /**
206  * snd_soc_info_volsw_sx - Mixer info callback for SX TLV controls
207  * @kcontrol: mixer control
208  * @uinfo: control element information
209  *
210  * Callback to provide information about a single mixer control, or a double
211  * mixer control that spans 2 registers of the SX TLV type. SX TLV controls
212  * have a range that represents both positive and negative values either side
213  * of zero but without a sign bit. min is the minimum register value, max is
214  * the number of steps.
215  *
216  * Returns 0 for success.
217  */
snd_soc_info_volsw_sx(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)218 int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,
219 			  struct snd_ctl_elem_info *uinfo)
220 {
221 	struct soc_mixer_control *mc =
222 		(struct soc_mixer_control *)kcontrol->private_value;
223 	int max;
224 
225 	if (mc->platform_max)
226 		max = mc->platform_max;
227 	else
228 		max = mc->max;
229 
230 	if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
231 		uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
232 	else
233 		uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
234 
235 	uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
236 	uinfo->value.integer.min = 0;
237 	uinfo->value.integer.max = max;
238 
239 	return 0;
240 }
241 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_sx);
242 
243 /**
244  * snd_soc_get_volsw - single mixer get callback
245  * @kcontrol: mixer control
246  * @ucontrol: control element information
247  *
248  * Callback to get the value of a single mixer control, or a double mixer
249  * control that spans 2 registers.
250  *
251  * Returns 0 for success.
252  */
snd_soc_get_volsw(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)253 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
254 	struct snd_ctl_elem_value *ucontrol)
255 {
256 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
257 	struct soc_mixer_control *mc =
258 		(struct soc_mixer_control *)kcontrol->private_value;
259 	unsigned int reg = mc->reg;
260 	unsigned int reg2 = mc->rreg;
261 	unsigned int shift = mc->shift;
262 	unsigned int rshift = mc->rshift;
263 	int max = mc->max;
264 	int min = mc->min;
265 	int sign_bit = mc->sign_bit;
266 	unsigned int mask = (1 << fls(max)) - 1;
267 	unsigned int invert = mc->invert;
268 	int val;
269 	int ret;
270 
271 	if (sign_bit)
272 		mask = BIT(sign_bit + 1) - 1;
273 
274 	ret = snd_soc_read_signed(component, reg, mask, shift, sign_bit, &val);
275 	if (ret)
276 		return ret;
277 
278 	ucontrol->value.integer.value[0] = val - min;
279 	if (invert)
280 		ucontrol->value.integer.value[0] =
281 			max - ucontrol->value.integer.value[0];
282 
283 	if (snd_soc_volsw_is_stereo(mc)) {
284 		if (reg == reg2)
285 			ret = snd_soc_read_signed(component, reg, mask, rshift,
286 				sign_bit, &val);
287 		else
288 			ret = snd_soc_read_signed(component, reg2, mask, shift,
289 				sign_bit, &val);
290 		if (ret)
291 			return ret;
292 
293 		ucontrol->value.integer.value[1] = val - min;
294 		if (invert)
295 			ucontrol->value.integer.value[1] =
296 				max - ucontrol->value.integer.value[1];
297 	}
298 
299 	return 0;
300 }
301 EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
302 
303 /**
304  * snd_soc_put_volsw - single mixer put callback
305  * @kcontrol: mixer control
306  * @ucontrol: control element information
307  *
308  * Callback to set the value of a single mixer control, or a double mixer
309  * control that spans 2 registers.
310  *
311  * Returns 0 for success.
312  */
snd_soc_put_volsw(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)313 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
314 	struct snd_ctl_elem_value *ucontrol)
315 {
316 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
317 	struct soc_mixer_control *mc =
318 		(struct soc_mixer_control *)kcontrol->private_value;
319 	unsigned int reg = mc->reg;
320 	unsigned int reg2 = mc->rreg;
321 	unsigned int shift = mc->shift;
322 	unsigned int rshift = mc->rshift;
323 	int max = mc->max;
324 	int min = mc->min;
325 	unsigned int sign_bit = mc->sign_bit;
326 	unsigned int mask = (1 << fls(max)) - 1;
327 	unsigned int invert = mc->invert;
328 	int err, ret;
329 	bool type_2r = false;
330 	unsigned int val2 = 0;
331 	unsigned int val, val_mask;
332 
333 	if (sign_bit)
334 		mask = BIT(sign_bit + 1) - 1;
335 
336 	if (ucontrol->value.integer.value[0] < 0)
337 		return -EINVAL;
338 	val = ucontrol->value.integer.value[0];
339 	if (mc->platform_max && ((int)val + min) > mc->platform_max)
340 		return -EINVAL;
341 	if (val > max - min)
342 		return -EINVAL;
343 	val = (val + min) & mask;
344 	if (invert)
345 		val = max - val;
346 	val_mask = mask << shift;
347 	val = val << shift;
348 	if (snd_soc_volsw_is_stereo(mc)) {
349 		if (ucontrol->value.integer.value[1] < 0)
350 			return -EINVAL;
351 		val2 = ucontrol->value.integer.value[1];
352 		if (mc->platform_max && ((int)val2 + min) > mc->platform_max)
353 			return -EINVAL;
354 		if (val2 > max - min)
355 			return -EINVAL;
356 		val2 = (val2 + min) & mask;
357 		if (invert)
358 			val2 = max - val2;
359 		if (reg == reg2) {
360 			val_mask |= mask << rshift;
361 			val |= val2 << rshift;
362 		} else {
363 			val2 = val2 << shift;
364 			type_2r = true;
365 		}
366 	}
367 	err = snd_soc_component_update_bits(component, reg, val_mask, val);
368 	if (err < 0)
369 		return err;
370 	ret = err;
371 
372 	if (type_2r) {
373 		err = snd_soc_component_update_bits(component, reg2, val_mask,
374 						    val2);
375 		/* Don't discard any error code or drop change flag */
376 		if (ret == 0 || err < 0) {
377 			ret = err;
378 		}
379 	}
380 
381 	return ret;
382 }
383 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
384 
385 /**
386  * snd_soc_get_volsw_sx - single mixer get callback
387  * @kcontrol: mixer control
388  * @ucontrol: control element information
389  *
390  * Callback to get the value of a single mixer control, or a double mixer
391  * control that spans 2 registers.
392  *
393  * Returns 0 for success.
394  */
snd_soc_get_volsw_sx(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)395 int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
396 		      struct snd_ctl_elem_value *ucontrol)
397 {
398 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
399 	struct soc_mixer_control *mc =
400 	    (struct soc_mixer_control *)kcontrol->private_value;
401 	unsigned int reg = mc->reg;
402 	unsigned int reg2 = mc->rreg;
403 	unsigned int shift = mc->shift;
404 	unsigned int rshift = mc->rshift;
405 	int max = mc->max;
406 	int min = mc->min;
407 	unsigned int mask = (1U << (fls(min + max) - 1)) - 1;
408 	unsigned int val;
409 
410 	val = snd_soc_component_read(component, reg);
411 	ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask;
412 
413 	if (snd_soc_volsw_is_stereo(mc)) {
414 		val = snd_soc_component_read(component, reg2);
415 		val = ((val >> rshift) - min) & mask;
416 		ucontrol->value.integer.value[1] = val;
417 	}
418 
419 	return 0;
420 }
421 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx);
422 
423 /**
424  * snd_soc_put_volsw_sx - double mixer set callback
425  * @kcontrol: mixer control
426  * @ucontrol: control element information
427  *
428  * Callback to set the value of a double mixer control that spans 2 registers.
429  *
430  * Returns 0 for success.
431  */
snd_soc_put_volsw_sx(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)432 int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
433 			 struct snd_ctl_elem_value *ucontrol)
434 {
435 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
436 	struct soc_mixer_control *mc =
437 	    (struct soc_mixer_control *)kcontrol->private_value;
438 
439 	unsigned int reg = mc->reg;
440 	unsigned int reg2 = mc->rreg;
441 	unsigned int shift = mc->shift;
442 	unsigned int rshift = mc->rshift;
443 	int max = mc->max;
444 	int min = mc->min;
445 	unsigned int mask = (1U << (fls(min + max) - 1)) - 1;
446 	int err = 0;
447 	int ret;
448 	unsigned int val, val_mask;
449 
450 	if (ucontrol->value.integer.value[0] < 0)
451 		return -EINVAL;
452 	val = ucontrol->value.integer.value[0];
453 	if (mc->platform_max && val > mc->platform_max)
454 		return -EINVAL;
455 	if (val > max)
456 		return -EINVAL;
457 	val_mask = mask << shift;
458 	val = (val + min) & mask;
459 	val = val << shift;
460 
461 	err = snd_soc_component_update_bits(component, reg, val_mask, val);
462 	if (err < 0)
463 		return err;
464 	ret = err;
465 
466 	if (snd_soc_volsw_is_stereo(mc)) {
467 		unsigned int val2 = ucontrol->value.integer.value[1];
468 
469 		if (mc->platform_max && val2 > mc->platform_max)
470 			return -EINVAL;
471 		if (val2 > max)
472 			return -EINVAL;
473 
474 		val_mask = mask << rshift;
475 		val2 = (val2 + min) & mask;
476 		val2 = val2 << rshift;
477 
478 		err = snd_soc_component_update_bits(component, reg2, val_mask,
479 			val2);
480 
481 		/* Don't discard any error code or drop change flag */
482 		if (ret == 0 || err < 0) {
483 			ret = err;
484 		}
485 	}
486 	return ret;
487 }
488 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx);
489 
490 /**
491  * snd_soc_info_volsw_range - single mixer info callback with range.
492  * @kcontrol: mixer control
493  * @uinfo: control element information
494  *
495  * Callback to provide information, within a range, about a single
496  * mixer control.
497  *
498  * returns 0 for success.
499  */
snd_soc_info_volsw_range(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)500 int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
501 	struct snd_ctl_elem_info *uinfo)
502 {
503 	struct soc_mixer_control *mc =
504 		(struct soc_mixer_control *)kcontrol->private_value;
505 	int platform_max;
506 	int min = mc->min;
507 
508 	if (!mc->platform_max)
509 		mc->platform_max = mc->max;
510 	platform_max = mc->platform_max;
511 
512 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
513 	uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
514 	uinfo->value.integer.min = 0;
515 	uinfo->value.integer.max = platform_max - min;
516 
517 	return 0;
518 }
519 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range);
520 
521 /**
522  * snd_soc_put_volsw_range - single mixer put value callback with range.
523  * @kcontrol: mixer control
524  * @ucontrol: control element information
525  *
526  * Callback to set the value, within a range, for a single mixer control.
527  *
528  * Returns 0 for success.
529  */
snd_soc_put_volsw_range(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)530 int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
531 	struct snd_ctl_elem_value *ucontrol)
532 {
533 	struct soc_mixer_control *mc =
534 		(struct soc_mixer_control *)kcontrol->private_value;
535 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
536 	unsigned int reg = mc->reg;
537 	unsigned int rreg = mc->rreg;
538 	unsigned int shift = mc->shift;
539 	int min = mc->min;
540 	int max = mc->max;
541 	unsigned int mask = (1 << fls(max)) - 1;
542 	unsigned int invert = mc->invert;
543 	unsigned int val, val_mask;
544 	int err, ret, tmp;
545 
546 	tmp = ucontrol->value.integer.value[0];
547 	if (tmp < 0)
548 		return -EINVAL;
549 	if (mc->platform_max && tmp > mc->platform_max)
550 		return -EINVAL;
551 	if (tmp > mc->max - mc->min)
552 		return -EINVAL;
553 
554 	if (invert)
555 		val = (max - ucontrol->value.integer.value[0]) & mask;
556 	else
557 		val = ((ucontrol->value.integer.value[0] + min) & mask);
558 	val_mask = mask << shift;
559 	val = val << shift;
560 
561 	err = snd_soc_component_update_bits(component, reg, val_mask, val);
562 	if (err < 0)
563 		return err;
564 	ret = err;
565 
566 	if (snd_soc_volsw_is_stereo(mc)) {
567 		tmp = ucontrol->value.integer.value[1];
568 		if (tmp < 0)
569 			return -EINVAL;
570 		if (mc->platform_max && tmp > mc->platform_max)
571 			return -EINVAL;
572 		if (tmp > mc->max - mc->min)
573 			return -EINVAL;
574 
575 		if (invert)
576 			val = (max - ucontrol->value.integer.value[1]) & mask;
577 		else
578 			val = ((ucontrol->value.integer.value[1] + min) & mask);
579 		val_mask = mask << shift;
580 		val = val << shift;
581 
582 		err = snd_soc_component_update_bits(component, rreg, val_mask,
583 			val);
584 		/* Don't discard any error code or drop change flag */
585 		if (ret == 0 || err < 0) {
586 			ret = err;
587 		}
588 	}
589 
590 	return ret;
591 }
592 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range);
593 
594 /**
595  * snd_soc_get_volsw_range - single mixer get callback with range
596  * @kcontrol: mixer control
597  * @ucontrol: control element information
598  *
599  * Callback to get the value, within a range, of a single mixer control.
600  *
601  * Returns 0 for success.
602  */
snd_soc_get_volsw_range(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)603 int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
604 	struct snd_ctl_elem_value *ucontrol)
605 {
606 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
607 	struct soc_mixer_control *mc =
608 		(struct soc_mixer_control *)kcontrol->private_value;
609 	unsigned int reg = mc->reg;
610 	unsigned int rreg = mc->rreg;
611 	unsigned int shift = mc->shift;
612 	int min = mc->min;
613 	int max = mc->max;
614 	unsigned int mask = (1 << fls(max)) - 1;
615 	unsigned int invert = mc->invert;
616 	unsigned int val;
617 
618 	val = snd_soc_component_read(component, reg);
619 	ucontrol->value.integer.value[0] = (val >> shift) & mask;
620 	if (invert)
621 		ucontrol->value.integer.value[0] =
622 			max - ucontrol->value.integer.value[0];
623 	else
624 		ucontrol->value.integer.value[0] =
625 			ucontrol->value.integer.value[0] - min;
626 
627 	if (snd_soc_volsw_is_stereo(mc)) {
628 		val = snd_soc_component_read(component, rreg);
629 		ucontrol->value.integer.value[1] = (val >> shift) & mask;
630 		if (invert)
631 			ucontrol->value.integer.value[1] =
632 				max - ucontrol->value.integer.value[1];
633 		else
634 			ucontrol->value.integer.value[1] =
635 				ucontrol->value.integer.value[1] - min;
636 	}
637 
638 	return 0;
639 }
640 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range);
641 
642 /**
643  * snd_soc_limit_volume - Set new limit to an existing volume control.
644  *
645  * @card: where to look for the control
646  * @name: Name of the control
647  * @max: new maximum limit
648  *
649  * Return 0 for success, else error.
650  */
snd_soc_limit_volume(struct snd_soc_card * card,const char * name,int max)651 int snd_soc_limit_volume(struct snd_soc_card *card,
652 	const char *name, int max)
653 {
654 	struct snd_kcontrol *kctl;
655 	int ret = -EINVAL;
656 
657 	/* Sanity check for name and max */
658 	if (unlikely(!name || max <= 0))
659 		return -EINVAL;
660 
661 	kctl = snd_soc_card_get_kcontrol(card, name);
662 	if (kctl) {
663 		struct soc_mixer_control *mc = (struct soc_mixer_control *)kctl->private_value;
664 		if (max <= mc->max - mc->min) {
665 			mc->platform_max = max;
666 			ret = 0;
667 		}
668 	}
669 	return ret;
670 }
671 EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
672 
snd_soc_bytes_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)673 int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
674 		       struct snd_ctl_elem_info *uinfo)
675 {
676 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
677 	struct soc_bytes *params = (void *)kcontrol->private_value;
678 
679 	uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
680 	uinfo->count = params->num_regs * component->val_bytes;
681 
682 	return 0;
683 }
684 EXPORT_SYMBOL_GPL(snd_soc_bytes_info);
685 
snd_soc_bytes_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)686 int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
687 		      struct snd_ctl_elem_value *ucontrol)
688 {
689 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
690 	struct soc_bytes *params = (void *)kcontrol->private_value;
691 	int ret;
692 
693 	if (component->regmap)
694 		ret = regmap_raw_read(component->regmap, params->base,
695 				      ucontrol->value.bytes.data,
696 				      params->num_regs * component->val_bytes);
697 	else
698 		ret = -EINVAL;
699 
700 	/* Hide any masked bytes to ensure consistent data reporting */
701 	if (ret == 0 && params->mask) {
702 		switch (component->val_bytes) {
703 		case 1:
704 			ucontrol->value.bytes.data[0] &= ~params->mask;
705 			break;
706 		case 2:
707 			((u16 *)(&ucontrol->value.bytes.data))[0]
708 				&= cpu_to_be16(~params->mask);
709 			break;
710 		case 4:
711 			((u32 *)(&ucontrol->value.bytes.data))[0]
712 				&= cpu_to_be32(~params->mask);
713 			break;
714 		default:
715 			return -EINVAL;
716 		}
717 	}
718 
719 	return ret;
720 }
721 EXPORT_SYMBOL_GPL(snd_soc_bytes_get);
722 
snd_soc_bytes_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)723 int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
724 		      struct snd_ctl_elem_value *ucontrol)
725 {
726 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
727 	struct soc_bytes *params = (void *)kcontrol->private_value;
728 	int ret, len;
729 	unsigned int val, mask;
730 	void *data;
731 
732 	if (!component->regmap || !params->num_regs)
733 		return -EINVAL;
734 
735 	len = params->num_regs * component->val_bytes;
736 
737 	data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA);
738 	if (!data)
739 		return -ENOMEM;
740 
741 	/*
742 	 * If we've got a mask then we need to preserve the register
743 	 * bits.  We shouldn't modify the incoming data so take a
744 	 * copy.
745 	 */
746 	if (params->mask) {
747 		ret = regmap_read(component->regmap, params->base, &val);
748 		if (ret != 0)
749 			goto out;
750 
751 		val &= params->mask;
752 
753 		switch (component->val_bytes) {
754 		case 1:
755 			((u8 *)data)[0] &= ~params->mask;
756 			((u8 *)data)[0] |= val;
757 			break;
758 		case 2:
759 			mask = ~params->mask;
760 			ret = regmap_parse_val(component->regmap,
761 							&mask, &mask);
762 			if (ret != 0)
763 				goto out;
764 
765 			((u16 *)data)[0] &= mask;
766 
767 			ret = regmap_parse_val(component->regmap,
768 							&val, &val);
769 			if (ret != 0)
770 				goto out;
771 
772 			((u16 *)data)[0] |= val;
773 			break;
774 		case 4:
775 			mask = ~params->mask;
776 			ret = regmap_parse_val(component->regmap,
777 							&mask, &mask);
778 			if (ret != 0)
779 				goto out;
780 
781 			((u32 *)data)[0] &= mask;
782 
783 			ret = regmap_parse_val(component->regmap,
784 							&val, &val);
785 			if (ret != 0)
786 				goto out;
787 
788 			((u32 *)data)[0] |= val;
789 			break;
790 		default:
791 			ret = -EINVAL;
792 			goto out;
793 		}
794 	}
795 
796 	ret = regmap_raw_write(component->regmap, params->base,
797 			       data, len);
798 
799 out:
800 	kfree(data);
801 
802 	return ret;
803 }
804 EXPORT_SYMBOL_GPL(snd_soc_bytes_put);
805 
snd_soc_bytes_info_ext(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * ucontrol)806 int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
807 			struct snd_ctl_elem_info *ucontrol)
808 {
809 	struct soc_bytes_ext *params = (void *)kcontrol->private_value;
810 
811 	ucontrol->type = SNDRV_CTL_ELEM_TYPE_BYTES;
812 	ucontrol->count = params->max;
813 
814 	return 0;
815 }
816 EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext);
817 
snd_soc_bytes_tlv_callback(struct snd_kcontrol * kcontrol,int op_flag,unsigned int size,unsigned int __user * tlv)818 int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
819 				unsigned int size, unsigned int __user *tlv)
820 {
821 	struct soc_bytes_ext *params = (void *)kcontrol->private_value;
822 	unsigned int count = size < params->max ? size : params->max;
823 	int ret = -ENXIO;
824 
825 	switch (op_flag) {
826 	case SNDRV_CTL_TLV_OP_READ:
827 		if (params->get)
828 			ret = params->get(kcontrol, tlv, count);
829 		break;
830 	case SNDRV_CTL_TLV_OP_WRITE:
831 		if (params->put)
832 			ret = params->put(kcontrol, tlv, count);
833 		break;
834 	}
835 	return ret;
836 }
837 EXPORT_SYMBOL_GPL(snd_soc_bytes_tlv_callback);
838 
839 /**
840  * snd_soc_info_xr_sx - signed multi register info callback
841  * @kcontrol: mreg control
842  * @uinfo: control element information
843  *
844  * Callback to provide information of a control that can
845  * span multiple codec registers which together
846  * forms a single signed value in a MSB/LSB manner.
847  *
848  * Returns 0 for success.
849  */
snd_soc_info_xr_sx(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)850 int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
851 	struct snd_ctl_elem_info *uinfo)
852 {
853 	struct soc_mreg_control *mc =
854 		(struct soc_mreg_control *)kcontrol->private_value;
855 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
856 	uinfo->count = 1;
857 	uinfo->value.integer.min = mc->min;
858 	uinfo->value.integer.max = mc->max;
859 
860 	return 0;
861 }
862 EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx);
863 
864 /**
865  * snd_soc_get_xr_sx - signed multi register get callback
866  * @kcontrol: mreg control
867  * @ucontrol: control element information
868  *
869  * Callback to get the value of a control that can span
870  * multiple codec registers which together forms a single
871  * signed value in a MSB/LSB manner. The control supports
872  * specifying total no of bits used to allow for bitfields
873  * across the multiple codec registers.
874  *
875  * Returns 0 for success.
876  */
snd_soc_get_xr_sx(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)877 int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
878 	struct snd_ctl_elem_value *ucontrol)
879 {
880 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
881 	struct soc_mreg_control *mc =
882 		(struct soc_mreg_control *)kcontrol->private_value;
883 	unsigned int regbase = mc->regbase;
884 	unsigned int regcount = mc->regcount;
885 	unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
886 	unsigned int regwmask = (1UL<<regwshift)-1;
887 	unsigned int invert = mc->invert;
888 	unsigned long mask = (1UL<<mc->nbits)-1;
889 	long min = mc->min;
890 	long max = mc->max;
891 	long val = 0;
892 	unsigned int i;
893 
894 	for (i = 0; i < regcount; i++) {
895 		unsigned int regval = snd_soc_component_read(component, regbase+i);
896 		val |= (regval & regwmask) << (regwshift*(regcount-i-1));
897 	}
898 	val &= mask;
899 	if (min < 0 && val > max)
900 		val |= ~mask;
901 	if (invert)
902 		val = max - val;
903 	ucontrol->value.integer.value[0] = val;
904 
905 	return 0;
906 }
907 EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx);
908 
909 /**
910  * snd_soc_put_xr_sx - signed multi register get callback
911  * @kcontrol: mreg control
912  * @ucontrol: control element information
913  *
914  * Callback to set the value of a control that can span
915  * multiple codec registers which together forms a single
916  * signed value in a MSB/LSB manner. The control supports
917  * specifying total no of bits used to allow for bitfields
918  * across the multiple codec registers.
919  *
920  * Returns 0 for success.
921  */
snd_soc_put_xr_sx(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)922 int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
923 	struct snd_ctl_elem_value *ucontrol)
924 {
925 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
926 	struct soc_mreg_control *mc =
927 		(struct soc_mreg_control *)kcontrol->private_value;
928 	unsigned int regbase = mc->regbase;
929 	unsigned int regcount = mc->regcount;
930 	unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
931 	unsigned int regwmask = (1UL<<regwshift)-1;
932 	unsigned int invert = mc->invert;
933 	unsigned long mask = (1UL<<mc->nbits)-1;
934 	long max = mc->max;
935 	long val = ucontrol->value.integer.value[0];
936 	int ret = 0;
937 	unsigned int i;
938 
939 	if (val < mc->min || val > mc->max)
940 		return -EINVAL;
941 	if (invert)
942 		val = max - val;
943 	val &= mask;
944 	for (i = 0; i < regcount; i++) {
945 		unsigned int regval = (val >> (regwshift*(regcount-i-1))) & regwmask;
946 		unsigned int regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask;
947 		int err = snd_soc_component_update_bits(component, regbase+i,
948 							regmask, regval);
949 		if (err < 0)
950 			return err;
951 		if (err > 0)
952 			ret = err;
953 	}
954 
955 	return ret;
956 }
957 EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);
958 
959 /**
960  * snd_soc_get_strobe - strobe get callback
961  * @kcontrol: mixer control
962  * @ucontrol: control element information
963  *
964  * Callback get the value of a strobe mixer control.
965  *
966  * Returns 0 for success.
967  */
snd_soc_get_strobe(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)968 int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
969 	struct snd_ctl_elem_value *ucontrol)
970 {
971 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
972 	struct soc_mixer_control *mc =
973 		(struct soc_mixer_control *)kcontrol->private_value;
974 	unsigned int reg = mc->reg;
975 	unsigned int shift = mc->shift;
976 	unsigned int mask = 1 << shift;
977 	unsigned int invert = mc->invert != 0;
978 	unsigned int val;
979 
980 	val = snd_soc_component_read(component, reg);
981 	val &= mask;
982 
983 	if (shift != 0 && val != 0)
984 		val = val >> shift;
985 	ucontrol->value.enumerated.item[0] = val ^ invert;
986 
987 	return 0;
988 }
989 EXPORT_SYMBOL_GPL(snd_soc_get_strobe);
990 
991 /**
992  * snd_soc_put_strobe - strobe put callback
993  * @kcontrol: mixer control
994  * @ucontrol: control element information
995  *
996  * Callback strobe a register bit to high then low (or the inverse)
997  * in one pass of a single mixer enum control.
998  *
999  * Returns 1 for success.
1000  */
snd_soc_put_strobe(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1001 int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
1002 	struct snd_ctl_elem_value *ucontrol)
1003 {
1004 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
1005 	struct soc_mixer_control *mc =
1006 		(struct soc_mixer_control *)kcontrol->private_value;
1007 	unsigned int reg = mc->reg;
1008 	unsigned int shift = mc->shift;
1009 	unsigned int mask = 1 << shift;
1010 	unsigned int invert = mc->invert != 0;
1011 	unsigned int strobe = ucontrol->value.enumerated.item[0] != 0;
1012 	unsigned int val1 = (strobe ^ invert) ? mask : 0;
1013 	unsigned int val2 = (strobe ^ invert) ? 0 : mask;
1014 	int err;
1015 
1016 	err = snd_soc_component_update_bits(component, reg, mask, val1);
1017 	if (err < 0)
1018 		return err;
1019 
1020 	return snd_soc_component_update_bits(component, reg, mask, val2);
1021 }
1022 EXPORT_SYMBOL_GPL(snd_soc_put_strobe);
1023