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 */ 40 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol, 41 struct snd_ctl_elem_info *uinfo) 42 { 43 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 44 45 return snd_ctl_enum_info(uinfo, e->shift_l == e->shift_r ? 1 : 2, 46 e->items, e->texts); 47 } 48 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double); 49 50 /** 51 * snd_soc_get_enum_double - enumerated double mixer get callback 52 * @kcontrol: mixer control 53 * @ucontrol: control element information 54 * 55 * Callback to get the value of a double enumerated mixer. 56 * 57 * Returns 0 for success. 58 */ 59 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol, 60 struct snd_ctl_elem_value *ucontrol) 61 { 62 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 63 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 64 unsigned int val, item; 65 unsigned int reg_val; 66 67 reg_val = snd_soc_component_read(component, e->reg); 68 val = (reg_val >> e->shift_l) & e->mask; 69 item = snd_soc_enum_val_to_item(e, val); 70 ucontrol->value.enumerated.item[0] = item; 71 if (e->shift_l != e->shift_r) { 72 val = (reg_val >> e->shift_r) & e->mask; 73 item = snd_soc_enum_val_to_item(e, val); 74 ucontrol->value.enumerated.item[1] = item; 75 } 76 77 return 0; 78 } 79 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double); 80 81 /** 82 * snd_soc_put_enum_double - enumerated double mixer put callback 83 * @kcontrol: mixer control 84 * @ucontrol: control element information 85 * 86 * Callback to set the value of a double enumerated mixer. 87 * 88 * Returns 0 for success. 89 */ 90 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol, 91 struct snd_ctl_elem_value *ucontrol) 92 { 93 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 94 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 95 unsigned int *item = ucontrol->value.enumerated.item; 96 unsigned int val; 97 unsigned int mask; 98 99 if (item[0] >= e->items) 100 return -EINVAL; 101 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l; 102 mask = e->mask << e->shift_l; 103 if (e->shift_l != e->shift_r) { 104 if (item[1] >= e->items) 105 return -EINVAL; 106 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r; 107 mask |= e->mask << e->shift_r; 108 } 109 110 return snd_soc_component_update_bits(component, e->reg, mask, val); 111 } 112 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double); 113 114 /** 115 * snd_soc_read_signed - Read a codec register and interpret as signed value 116 * @component: component 117 * @reg: Register to read 118 * @mask: Mask to use after shifting the register value 119 * @shift: Right shift of register value 120 * @sign_bit: Bit that describes if a number is negative or not. 121 * @signed_val: Pointer to where the read value should be stored 122 * 123 * This functions reads a codec register. The register value is shifted right 124 * by 'shift' bits and masked with the given 'mask'. Afterwards it translates 125 * the given registervalue into a signed integer if sign_bit is non-zero. 126 * 127 * Returns 0 on sucess, otherwise an error value 128 */ 129 static int snd_soc_read_signed(struct snd_soc_component *component, 130 unsigned int reg, unsigned int mask, unsigned int shift, 131 unsigned int sign_bit, int *signed_val) 132 { 133 int ret; 134 unsigned int val; 135 136 val = snd_soc_component_read(component, reg); 137 val = (val >> shift) & mask; 138 139 if (!sign_bit) { 140 *signed_val = val; 141 return 0; 142 } 143 144 /* non-negative number */ 145 if (!(val & BIT(sign_bit))) { 146 *signed_val = val; 147 return 0; 148 } 149 150 ret = val; 151 152 /* 153 * The register most probably does not contain a full-sized int. 154 * Instead we have an arbitrary number of bits in a signed 155 * representation which has to be translated into a full-sized int. 156 * This is done by filling up all bits above the sign-bit. 157 */ 158 ret |= ~((int)(BIT(sign_bit) - 1)); 159 160 *signed_val = ret; 161 162 return 0; 163 } 164 165 /** 166 * snd_soc_info_volsw - single mixer info callback 167 * @kcontrol: mixer control 168 * @uinfo: control element information 169 * 170 * Callback to provide information about a single mixer control, or a double 171 * mixer control that spans 2 registers. 172 * 173 * Returns 0 for success. 174 */ 175 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol, 176 struct snd_ctl_elem_info *uinfo) 177 { 178 struct soc_mixer_control *mc = 179 (struct soc_mixer_control *)kcontrol->private_value; 180 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 } 204 EXPORT_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 */ 219 int 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 } 242 EXPORT_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 */ 254 int 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 } 302 EXPORT_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 */ 314 int 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 } 384 EXPORT_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 */ 396 int 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 } 422 EXPORT_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 */ 433 int 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 } 489 EXPORT_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 */ 501 int 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 } 520 EXPORT_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 */ 531 int 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 } 593 EXPORT_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 */ 604 int 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 } 641 EXPORT_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 */ 652 int 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 } 672 EXPORT_SYMBOL_GPL(snd_soc_limit_volume); 673 674 int 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 } 685 EXPORT_SYMBOL_GPL(snd_soc_bytes_info); 686 687 int 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 } 722 EXPORT_SYMBOL_GPL(snd_soc_bytes_get); 723 724 int 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 } 798 EXPORT_SYMBOL_GPL(snd_soc_bytes_put); 799 800 int 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 } 810 EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext); 811 812 int 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 } 831 EXPORT_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 */ 844 int 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 } 856 EXPORT_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 */ 871 int 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 } 901 EXPORT_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 */ 916 int 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 } 951 EXPORT_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 */ 962 int 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 } 983 EXPORT_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 */ 995 int 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 } 1016 EXPORT_SYMBOL_GPL(snd_soc_put_strobe); 1017