1017 lines · c
1// SPDX-License-Identifier: GPL-2.0+2//3// soc-ops.c -- Generic ASoC operations4//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/cleanup.h>15#include <linux/module.h>16#include <linux/moduleparam.h>17#include <linux/init.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 callback32 * @kcontrol: mixer control33 * @uinfo: control element information34 *35 * Callback to provide information about a double enumerated36 * mixer control.37 *38 * Returns 0 for success.39 */40int 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}48EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);49 50/**51 * snd_soc_get_enum_double - enumerated double mixer get callback52 * @kcontrol: mixer control53 * @ucontrol: control element information54 *55 * Callback to get the value of a double enumerated mixer.56 *57 * Returns 0 for success.58 */59int 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}79EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);80 81/**82 * snd_soc_put_enum_double - enumerated double mixer put callback83 * @kcontrol: mixer control84 * @ucontrol: control element information85 *86 * Callback to set the value of a double enumerated mixer.87 *88 * Returns 0 for success.89 */90int 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}112EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);113 114/**115 * snd_soc_read_signed - Read a codec register and interpret as signed value116 * @component: component117 * @reg: Register to read118 * @mask: Mask to use after shifting the register value119 * @shift: Right shift of register value120 * @sign_bit: Bit that describes if a number is negative or not.121 * @signed_val: Pointer to where the read value should be stored122 *123 * This functions reads a codec register. The register value is shifted right124 * by 'shift' bits and masked with the given 'mask'. Afterwards it translates125 * the given registervalue into a signed integer if sign_bit is non-zero.126 *127 * Returns 0 on sucess, otherwise an error value128 */129static 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 signed155 * 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 callback167 * @kcontrol: mixer control168 * @uinfo: control element information169 *170 * Callback to provide information about a single mixer control, or a double171 * mixer control that spans 2 registers.172 *173 * Returns 0 for success.174 */175int 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 const char *vol_string = NULL;181 int max;182 183 max = uinfo->value.integer.max = mc->max - mc->min;184 if (mc->platform_max && mc->platform_max < max)185 max = mc->platform_max;186 187 if (max == 1) {188 /* Even two value controls ending in Volume should always be integer */189 vol_string = strstr(kcontrol->id.name, " Volume");190 if (vol_string && !strcmp(vol_string, " Volume"))191 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;192 else193 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;194 } else {195 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;196 }197 198 uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;199 uinfo->value.integer.min = 0;200 uinfo->value.integer.max = max;201 202 return 0;203}204EXPORT_SYMBOL_GPL(snd_soc_info_volsw);205 206/**207 * snd_soc_info_volsw_sx - Mixer info callback for SX TLV controls208 * @kcontrol: mixer control209 * @uinfo: control element information210 *211 * Callback to provide information about a single mixer control, or a double212 * mixer control that spans 2 registers of the SX TLV type. SX TLV controls213 * have a range that represents both positive and negative values either side214 * of zero but without a sign bit. min is the minimum register value, max is215 * the number of steps.216 *217 * Returns 0 for success.218 */219int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol,220 struct snd_ctl_elem_info *uinfo)221{222 struct soc_mixer_control *mc =223 (struct soc_mixer_control *)kcontrol->private_value;224 int max;225 226 if (mc->platform_max)227 max = mc->platform_max;228 else229 max = mc->max;230 231 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))232 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;233 else234 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;235 236 uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;237 uinfo->value.integer.min = 0;238 uinfo->value.integer.max = max;239 240 return 0;241}242EXPORT_SYMBOL_GPL(snd_soc_info_volsw_sx);243 244/**245 * snd_soc_get_volsw - single mixer get callback246 * @kcontrol: mixer control247 * @ucontrol: control element information248 *249 * Callback to get the value of a single mixer control, or a double mixer250 * control that spans 2 registers.251 *252 * Returns 0 for success.253 */254int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,255 struct snd_ctl_elem_value *ucontrol)256{257 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);258 struct soc_mixer_control *mc =259 (struct soc_mixer_control *)kcontrol->private_value;260 unsigned int reg = mc->reg;261 unsigned int reg2 = mc->rreg;262 unsigned int shift = mc->shift;263 unsigned int rshift = mc->rshift;264 int max = mc->max;265 int min = mc->min;266 int sign_bit = mc->sign_bit;267 unsigned int mask = (1ULL << fls(max)) - 1;268 unsigned int invert = mc->invert;269 int val;270 int ret;271 272 if (sign_bit)273 mask = BIT(sign_bit + 1) - 1;274 275 ret = snd_soc_read_signed(component, reg, mask, shift, sign_bit, &val);276 if (ret)277 return ret;278 279 ucontrol->value.integer.value[0] = val - min;280 if (invert)281 ucontrol->value.integer.value[0] =282 max - ucontrol->value.integer.value[0];283 284 if (snd_soc_volsw_is_stereo(mc)) {285 if (reg == reg2)286 ret = snd_soc_read_signed(component, reg, mask, rshift,287 sign_bit, &val);288 else289 ret = snd_soc_read_signed(component, reg2, mask, shift,290 sign_bit, &val);291 if (ret)292 return ret;293 294 ucontrol->value.integer.value[1] = val - min;295 if (invert)296 ucontrol->value.integer.value[1] =297 max - ucontrol->value.integer.value[1];298 }299 300 return 0;301}302EXPORT_SYMBOL_GPL(snd_soc_get_volsw);303 304/**305 * snd_soc_put_volsw - single mixer put callback306 * @kcontrol: mixer control307 * @ucontrol: control element information308 *309 * Callback to set the value of a single mixer control, or a double mixer310 * control that spans 2 registers.311 *312 * Returns 0 for success.313 */314int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,315 struct snd_ctl_elem_value *ucontrol)316{317 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);318 struct soc_mixer_control *mc =319 (struct soc_mixer_control *)kcontrol->private_value;320 unsigned int reg = mc->reg;321 unsigned int reg2 = mc->rreg;322 unsigned int shift = mc->shift;323 unsigned int rshift = mc->rshift;324 int max = mc->max;325 int min = mc->min;326 unsigned int sign_bit = mc->sign_bit;327 unsigned int mask = (1 << fls(max)) - 1;328 unsigned int invert = mc->invert;329 int err, ret;330 bool type_2r = false;331 unsigned int val2 = 0;332 unsigned int val, val_mask;333 334 if (sign_bit)335 mask = BIT(sign_bit + 1) - 1;336 337 if (ucontrol->value.integer.value[0] < 0)338 return -EINVAL;339 val = ucontrol->value.integer.value[0];340 if (mc->platform_max && ((int)val + min) > mc->platform_max)341 return -EINVAL;342 if (val > max - min)343 return -EINVAL;344 val = (val + min) & mask;345 if (invert)346 val = max - val;347 val_mask = mask << shift;348 val = val << shift;349 if (snd_soc_volsw_is_stereo(mc)) {350 if (ucontrol->value.integer.value[1] < 0)351 return -EINVAL;352 val2 = ucontrol->value.integer.value[1];353 if (mc->platform_max && ((int)val2 + min) > mc->platform_max)354 return -EINVAL;355 if (val2 > max - min)356 return -EINVAL;357 val2 = (val2 + min) & mask;358 if (invert)359 val2 = max - val2;360 if (reg == reg2) {361 val_mask |= mask << rshift;362 val |= val2 << rshift;363 } else {364 val2 = val2 << shift;365 type_2r = true;366 }367 }368 err = snd_soc_component_update_bits(component, reg, val_mask, val);369 if (err < 0)370 return err;371 ret = err;372 373 if (type_2r) {374 err = snd_soc_component_update_bits(component, reg2, val_mask,375 val2);376 /* Don't discard any error code or drop change flag */377 if (ret == 0 || err < 0) {378 ret = err;379 }380 }381 382 return ret;383}384EXPORT_SYMBOL_GPL(snd_soc_put_volsw);385 386/**387 * snd_soc_get_volsw_sx - single mixer get callback388 * @kcontrol: mixer control389 * @ucontrol: control element information390 *391 * Callback to get the value of a single mixer control, or a double mixer392 * control that spans 2 registers.393 *394 * Returns 0 for success.395 */396int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,397 struct snd_ctl_elem_value *ucontrol)398{399 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);400 struct soc_mixer_control *mc =401 (struct soc_mixer_control *)kcontrol->private_value;402 unsigned int reg = mc->reg;403 unsigned int reg2 = mc->rreg;404 unsigned int shift = mc->shift;405 unsigned int rshift = mc->rshift;406 int max = mc->max;407 int min = mc->min;408 unsigned int mask = (1U << (fls(min + max) - 1)) - 1;409 unsigned int val;410 411 val = snd_soc_component_read(component, reg);412 ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask;413 414 if (snd_soc_volsw_is_stereo(mc)) {415 val = snd_soc_component_read(component, reg2);416 val = ((val >> rshift) - min) & mask;417 ucontrol->value.integer.value[1] = val;418 }419 420 return 0;421}422EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx);423 424/**425 * snd_soc_put_volsw_sx - double mixer set callback426 * @kcontrol: mixer control427 * @ucontrol: control element information428 *429 * Callback to set the value of a double mixer control that spans 2 registers.430 *431 * Returns 0 for success.432 */433int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,434 struct snd_ctl_elem_value *ucontrol)435{436 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);437 struct soc_mixer_control *mc =438 (struct soc_mixer_control *)kcontrol->private_value;439 440 unsigned int reg = mc->reg;441 unsigned int reg2 = mc->rreg;442 unsigned int shift = mc->shift;443 unsigned int rshift = mc->rshift;444 int max = mc->max;445 int min = mc->min;446 unsigned int mask = (1U << (fls(min + max) - 1)) - 1;447 int err = 0;448 int ret;449 unsigned int val, val_mask;450 451 if (ucontrol->value.integer.value[0] < 0)452 return -EINVAL;453 val = ucontrol->value.integer.value[0];454 if (mc->platform_max && val > mc->platform_max)455 return -EINVAL;456 if (val > max)457 return -EINVAL;458 val_mask = mask << shift;459 val = (val + min) & mask;460 val = val << shift;461 462 err = snd_soc_component_update_bits(component, reg, val_mask, val);463 if (err < 0)464 return err;465 ret = err;466 467 if (snd_soc_volsw_is_stereo(mc)) {468 unsigned int val2 = ucontrol->value.integer.value[1];469 470 if (mc->platform_max && val2 > mc->platform_max)471 return -EINVAL;472 if (val2 > max)473 return -EINVAL;474 475 val_mask = mask << rshift;476 val2 = (val2 + min) & mask;477 val2 = val2 << rshift;478 479 err = snd_soc_component_update_bits(component, reg2, val_mask,480 val2);481 482 /* Don't discard any error code or drop change flag */483 if (ret == 0 || err < 0) {484 ret = err;485 }486 }487 return ret;488}489EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx);490 491/**492 * snd_soc_info_volsw_range - single mixer info callback with range.493 * @kcontrol: mixer control494 * @uinfo: control element information495 *496 * Callback to provide information, within a range, about a single497 * mixer control.498 *499 * returns 0 for success.500 */501int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,502 struct snd_ctl_elem_info *uinfo)503{504 struct soc_mixer_control *mc =505 (struct soc_mixer_control *)kcontrol->private_value;506 int platform_max;507 int min = mc->min;508 509 if (!mc->platform_max)510 mc->platform_max = mc->max;511 platform_max = mc->platform_max;512 513 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;514 uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;515 uinfo->value.integer.min = 0;516 uinfo->value.integer.max = platform_max - min;517 518 return 0;519}520EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range);521 522/**523 * snd_soc_put_volsw_range - single mixer put value callback with range.524 * @kcontrol: mixer control525 * @ucontrol: control element information526 *527 * Callback to set the value, within a range, for a single mixer control.528 *529 * Returns 0 for success.530 */531int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,532 struct snd_ctl_elem_value *ucontrol)533{534 struct soc_mixer_control *mc =535 (struct soc_mixer_control *)kcontrol->private_value;536 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);537 unsigned int reg = mc->reg;538 unsigned int rreg = mc->rreg;539 unsigned int shift = mc->shift;540 int min = mc->min;541 int max = mc->max;542 unsigned int mask = (1 << fls(max)) - 1;543 unsigned int invert = mc->invert;544 unsigned int val, val_mask;545 int err, ret, tmp;546 547 tmp = ucontrol->value.integer.value[0];548 if (tmp < 0)549 return -EINVAL;550 if (mc->platform_max && tmp > mc->platform_max)551 return -EINVAL;552 if (tmp > mc->max - mc->min)553 return -EINVAL;554 555 if (invert)556 val = (max - ucontrol->value.integer.value[0]) & mask;557 else558 val = ((ucontrol->value.integer.value[0] + min) & mask);559 val_mask = mask << shift;560 val = val << shift;561 562 err = snd_soc_component_update_bits(component, reg, val_mask, val);563 if (err < 0)564 return err;565 ret = err;566 567 if (snd_soc_volsw_is_stereo(mc)) {568 tmp = ucontrol->value.integer.value[1];569 if (tmp < 0)570 return -EINVAL;571 if (mc->platform_max && tmp > mc->platform_max)572 return -EINVAL;573 if (tmp > mc->max - mc->min)574 return -EINVAL;575 576 if (invert)577 val = (max - ucontrol->value.integer.value[1]) & mask;578 else579 val = ((ucontrol->value.integer.value[1] + min) & mask);580 val_mask = mask << shift;581 val = val << shift;582 583 err = snd_soc_component_update_bits(component, rreg, val_mask,584 val);585 /* Don't discard any error code or drop change flag */586 if (ret == 0 || err < 0) {587 ret = err;588 }589 }590 591 return ret;592}593EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range);594 595/**596 * snd_soc_get_volsw_range - single mixer get callback with range597 * @kcontrol: mixer control598 * @ucontrol: control element information599 *600 * Callback to get the value, within a range, of a single mixer control.601 *602 * Returns 0 for success.603 */604int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,605 struct snd_ctl_elem_value *ucontrol)606{607 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);608 struct soc_mixer_control *mc =609 (struct soc_mixer_control *)kcontrol->private_value;610 unsigned int reg = mc->reg;611 unsigned int rreg = mc->rreg;612 unsigned int shift = mc->shift;613 int min = mc->min;614 int max = mc->max;615 unsigned int mask = (1 << fls(max)) - 1;616 unsigned int invert = mc->invert;617 unsigned int val;618 619 val = snd_soc_component_read(component, reg);620 ucontrol->value.integer.value[0] = (val >> shift) & mask;621 if (invert)622 ucontrol->value.integer.value[0] =623 max - ucontrol->value.integer.value[0];624 else625 ucontrol->value.integer.value[0] =626 ucontrol->value.integer.value[0] - min;627 628 if (snd_soc_volsw_is_stereo(mc)) {629 val = snd_soc_component_read(component, rreg);630 ucontrol->value.integer.value[1] = (val >> shift) & mask;631 if (invert)632 ucontrol->value.integer.value[1] =633 max - ucontrol->value.integer.value[1];634 else635 ucontrol->value.integer.value[1] =636 ucontrol->value.integer.value[1] - min;637 }638 639 return 0;640}641EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range);642 643/**644 * snd_soc_limit_volume - Set new limit to an existing volume control.645 *646 * @card: where to look for the control647 * @name: Name of the control648 * @max: new maximum limit649 *650 * Return 0 for success, else error.651 */652int snd_soc_limit_volume(struct snd_soc_card *card,653 const char *name, int max)654{655 struct snd_kcontrol *kctl;656 int ret = -EINVAL;657 658 /* Sanity check for name and max */659 if (unlikely(!name || max <= 0))660 return -EINVAL;661 662 kctl = snd_soc_card_get_kcontrol(card, name);663 if (kctl) {664 struct soc_mixer_control *mc = (struct soc_mixer_control *)kctl->private_value;665 if (max <= mc->max - mc->min) {666 mc->platform_max = max;667 ret = 0;668 }669 }670 return ret;671}672EXPORT_SYMBOL_GPL(snd_soc_limit_volume);673 674int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,675 struct snd_ctl_elem_info *uinfo)676{677 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);678 struct soc_bytes *params = (void *)kcontrol->private_value;679 680 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;681 uinfo->count = params->num_regs * component->val_bytes;682 683 return 0;684}685EXPORT_SYMBOL_GPL(snd_soc_bytes_info);686 687int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,688 struct snd_ctl_elem_value *ucontrol)689{690 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);691 struct soc_bytes *params = (void *)kcontrol->private_value;692 int ret;693 694 if (component->regmap)695 ret = regmap_raw_read(component->regmap, params->base,696 ucontrol->value.bytes.data,697 params->num_regs * component->val_bytes);698 else699 ret = -EINVAL;700 701 /* Hide any masked bytes to ensure consistent data reporting */702 if (ret == 0 && params->mask) {703 switch (component->val_bytes) {704 case 1:705 ucontrol->value.bytes.data[0] &= ~params->mask;706 break;707 case 2:708 ((u16 *)(&ucontrol->value.bytes.data))[0]709 &= cpu_to_be16(~params->mask);710 break;711 case 4:712 ((u32 *)(&ucontrol->value.bytes.data))[0]713 &= cpu_to_be32(~params->mask);714 break;715 default:716 return -EINVAL;717 }718 }719 720 return ret;721}722EXPORT_SYMBOL_GPL(snd_soc_bytes_get);723 724int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,725 struct snd_ctl_elem_value *ucontrol)726{727 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);728 struct soc_bytes *params = (void *)kcontrol->private_value;729 int ret, len;730 unsigned int val, mask;731 732 if (!component->regmap || !params->num_regs)733 return -EINVAL;734 735 len = params->num_regs * component->val_bytes;736 737 void *data __free(kfree) = kmemdup(ucontrol->value.bytes.data, len,738 GFP_KERNEL | GFP_DMA);739 if (!data)740 return -ENOMEM;741 742 /*743 * If we've got a mask then we need to preserve the register744 * bits. We shouldn't modify the incoming data so take a745 * copy.746 */747 if (params->mask) {748 ret = regmap_read(component->regmap, params->base, &val);749 if (ret != 0)750 return ret;751 752 val &= params->mask;753 754 switch (component->val_bytes) {755 case 1:756 ((u8 *)data)[0] &= ~params->mask;757 ((u8 *)data)[0] |= val;758 break;759 case 2:760 mask = ~params->mask;761 ret = regmap_parse_val(component->regmap,762 &mask, &mask);763 if (ret != 0)764 return ret;765 766 ((u16 *)data)[0] &= mask;767 768 ret = regmap_parse_val(component->regmap,769 &val, &val);770 if (ret != 0)771 return ret;772 773 ((u16 *)data)[0] |= val;774 break;775 case 4:776 mask = ~params->mask;777 ret = regmap_parse_val(component->regmap,778 &mask, &mask);779 if (ret != 0)780 return ret;781 782 ((u32 *)data)[0] &= mask;783 784 ret = regmap_parse_val(component->regmap,785 &val, &val);786 if (ret != 0)787 return ret;788 789 ((u32 *)data)[0] |= val;790 break;791 default:792 return -EINVAL;793 }794 }795 796 return regmap_raw_write(component->regmap, params->base, data, len);797}798EXPORT_SYMBOL_GPL(snd_soc_bytes_put);799 800int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,801 struct snd_ctl_elem_info *ucontrol)802{803 struct soc_bytes_ext *params = (void *)kcontrol->private_value;804 805 ucontrol->type = SNDRV_CTL_ELEM_TYPE_BYTES;806 ucontrol->count = params->max;807 808 return 0;809}810EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext);811 812int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,813 unsigned int size, unsigned int __user *tlv)814{815 struct soc_bytes_ext *params = (void *)kcontrol->private_value;816 unsigned int count = size < params->max ? size : params->max;817 int ret = -ENXIO;818 819 switch (op_flag) {820 case SNDRV_CTL_TLV_OP_READ:821 if (params->get)822 ret = params->get(kcontrol, tlv, count);823 break;824 case SNDRV_CTL_TLV_OP_WRITE:825 if (params->put)826 ret = params->put(kcontrol, tlv, count);827 break;828 }829 return ret;830}831EXPORT_SYMBOL_GPL(snd_soc_bytes_tlv_callback);832 833/**834 * snd_soc_info_xr_sx - signed multi register info callback835 * @kcontrol: mreg control836 * @uinfo: control element information837 *838 * Callback to provide information of a control that can839 * span multiple codec registers which together840 * forms a single signed value in a MSB/LSB manner.841 *842 * Returns 0 for success.843 */844int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,845 struct snd_ctl_elem_info *uinfo)846{847 struct soc_mreg_control *mc =848 (struct soc_mreg_control *)kcontrol->private_value;849 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;850 uinfo->count = 1;851 uinfo->value.integer.min = mc->min;852 uinfo->value.integer.max = mc->max;853 854 return 0;855}856EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx);857 858/**859 * snd_soc_get_xr_sx - signed multi register get callback860 * @kcontrol: mreg control861 * @ucontrol: control element information862 *863 * Callback to get the value of a control that can span864 * multiple codec registers which together forms a single865 * signed value in a MSB/LSB manner. The control supports866 * specifying total no of bits used to allow for bitfields867 * across the multiple codec registers.868 *869 * Returns 0 for success.870 */871int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,872 struct snd_ctl_elem_value *ucontrol)873{874 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);875 struct soc_mreg_control *mc =876 (struct soc_mreg_control *)kcontrol->private_value;877 unsigned int regbase = mc->regbase;878 unsigned int regcount = mc->regcount;879 unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;880 unsigned int regwmask = (1UL<<regwshift)-1;881 unsigned int invert = mc->invert;882 unsigned long mask = (1UL<<mc->nbits)-1;883 long min = mc->min;884 long max = mc->max;885 long val = 0;886 unsigned int i;887 888 for (i = 0; i < regcount; i++) {889 unsigned int regval = snd_soc_component_read(component, regbase+i);890 val |= (regval & regwmask) << (regwshift*(regcount-i-1));891 }892 val &= mask;893 if (min < 0 && val > max)894 val |= ~mask;895 if (invert)896 val = max - val;897 ucontrol->value.integer.value[0] = val;898 899 return 0;900}901EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx);902 903/**904 * snd_soc_put_xr_sx - signed multi register get callback905 * @kcontrol: mreg control906 * @ucontrol: control element information907 *908 * Callback to set the value of a control that can span909 * multiple codec registers which together forms a single910 * signed value in a MSB/LSB manner. The control supports911 * specifying total no of bits used to allow for bitfields912 * across the multiple codec registers.913 *914 * Returns 0 for success.915 */916int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,917 struct snd_ctl_elem_value *ucontrol)918{919 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);920 struct soc_mreg_control *mc =921 (struct soc_mreg_control *)kcontrol->private_value;922 unsigned int regbase = mc->regbase;923 unsigned int regcount = mc->regcount;924 unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;925 unsigned int regwmask = (1UL<<regwshift)-1;926 unsigned int invert = mc->invert;927 unsigned long mask = (1UL<<mc->nbits)-1;928 long max = mc->max;929 long val = ucontrol->value.integer.value[0];930 int ret = 0;931 unsigned int i;932 933 if (val < mc->min || val > mc->max)934 return -EINVAL;935 if (invert)936 val = max - val;937 val &= mask;938 for (i = 0; i < regcount; i++) {939 unsigned int regval = (val >> (regwshift*(regcount-i-1))) & regwmask;940 unsigned int regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask;941 int err = snd_soc_component_update_bits(component, regbase+i,942 regmask, regval);943 if (err < 0)944 return err;945 if (err > 0)946 ret = err;947 }948 949 return ret;950}951EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);952 953/**954 * snd_soc_get_strobe - strobe get callback955 * @kcontrol: mixer control956 * @ucontrol: control element information957 *958 * Callback get the value of a strobe mixer control.959 *960 * Returns 0 for success.961 */962int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,963 struct snd_ctl_elem_value *ucontrol)964{965 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);966 struct soc_mixer_control *mc =967 (struct soc_mixer_control *)kcontrol->private_value;968 unsigned int reg = mc->reg;969 unsigned int shift = mc->shift;970 unsigned int mask = 1 << shift;971 unsigned int invert = mc->invert != 0;972 unsigned int val;973 974 val = snd_soc_component_read(component, reg);975 val &= mask;976 977 if (shift != 0 && val != 0)978 val = val >> shift;979 ucontrol->value.enumerated.item[0] = val ^ invert;980 981 return 0;982}983EXPORT_SYMBOL_GPL(snd_soc_get_strobe);984 985/**986 * snd_soc_put_strobe - strobe put callback987 * @kcontrol: mixer control988 * @ucontrol: control element information989 *990 * Callback strobe a register bit to high then low (or the inverse)991 * in one pass of a single mixer enum control.992 *993 * Returns 1 for success.994 */995int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,996 struct snd_ctl_elem_value *ucontrol)997{998 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);999 struct soc_mixer_control *mc =1000 (struct soc_mixer_control *)kcontrol->private_value;1001 unsigned int reg = mc->reg;1002 unsigned int shift = mc->shift;1003 unsigned int mask = 1 << shift;1004 unsigned int invert = mc->invert != 0;1005 unsigned int strobe = ucontrol->value.enumerated.item[0] != 0;1006 unsigned int val1 = (strobe ^ invert) ? mask : 0;1007 unsigned int val2 = (strobe ^ invert) ? 0 : mask;1008 int err;1009 1010 err = snd_soc_component_update_bits(component, reg, mask, val1);1011 if (err < 0)1012 return err;1013 1014 return snd_soc_component_update_bits(component, reg, mask, val2);1015}1016EXPORT_SYMBOL_GPL(snd_soc_put_strobe);1017