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