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