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