~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/soc-ops.c

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp