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/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 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 */
  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 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 */
  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 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 */
  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 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 */
 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 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 */
 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		else
 193			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 controls
 208 * @kcontrol: mixer control
 209 * @uinfo: control element information
 210 *
 211 * Callback to provide information about a single mixer control, or a double
 212 * mixer control that spans 2 registers of the SX TLV type. SX TLV controls
 213 * have a range that represents both positive and negative values either side
 214 * of zero but without a sign bit. min is the minimum register value, max is
 215 * 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	else
 229		max = mc->max;
 230
 231	if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
 232		uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 233	else
 234		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 callback
 246 * @kcontrol: mixer control
 247 * @ucontrol: control element information
 248 *
 249 * Callback to get the value of a single mixer control, or a double mixer
 250 * 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		else
 289			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 callback
 306 * @kcontrol: mixer control
 307 * @ucontrol: control element information
 308 *
 309 * Callback to set the value of a single mixer control, or a double mixer
 310 * 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 callback
 388 * @kcontrol: mixer control
 389 * @ucontrol: control element information
 390 *
 391 * Callback to get the value of a single mixer control, or a double mixer
 392 * 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 callback
 426 * @kcontrol: mixer control
 427 * @ucontrol: control element information
 428 *
 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 control
 494 * @uinfo: control element information
 495 *
 496 * Callback to provide information, within a range, about a single
 497 * 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 control
 525 * @ucontrol: control element information
 526 *
 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	else
 558		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		else
 579			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 range
 597 * @kcontrol: mixer control
 598 * @ucontrol: control element information
 599 *
 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	else
 625		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		else
 635			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 control
 647 * @name: Name of the control
 648 * @max: new maximum limit
 649 *
 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	else
 699		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 register
 744	 * bits.  We shouldn't modify the incoming data so take a
 745	 * 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 callback
 835 * @kcontrol: mreg control
 836 * @uinfo: control element information
 837 *
 838 * Callback to provide information of a control that can
 839 * span multiple codec registers which together
 840 * 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 callback
 860 * @kcontrol: mreg control
 861 * @ucontrol: control element information
 862 *
 863 * Callback to get the value of a control that can span
 864 * multiple codec registers which together forms a single
 865 * signed value in a MSB/LSB manner. The control supports
 866 * specifying total no of bits used to allow for bitfields
 867 * 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 callback
 905 * @kcontrol: mreg control
 906 * @ucontrol: control element information
 907 *
 908 * Callback to set the value of a control that can span
 909 * multiple codec registers which together forms a single
 910 * signed value in a MSB/LSB manner. The control supports
 911 * specifying total no of bits used to allow for bitfields
 912 * 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 callback
 955 * @kcontrol: mixer control
 956 * @ucontrol: control element information
 957 *
 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 callback
 987 * @kcontrol: mixer control
 988 * @ucontrol: control element information
 989 *
 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);