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 */ 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 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 } 196 EXPORT_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 */ 210 int 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 } 224 EXPORT_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 */ 236 int 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 } 284 EXPORT_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 */ 296 int 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; 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 && val > 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 && val2 > 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 354 if (type_2r) 355 err = snd_soc_component_update_bits(component, reg2, val_mask, 356 val2); 357 358 return err; 359 } 360 EXPORT_SYMBOL_GPL(snd_soc_put_volsw); 361 362 /** 363 * snd_soc_get_volsw_sx - single mixer get callback 364 * @kcontrol: mixer control 365 * @ucontrol: control element information 366 * 367 * Callback to get the value of a single mixer control, or a double mixer 368 * control that spans 2 registers. 369 * 370 * Returns 0 for success. 371 */ 372 int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol, 373 struct snd_ctl_elem_value *ucontrol) 374 { 375 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 376 struct soc_mixer_control *mc = 377 (struct soc_mixer_control *)kcontrol->private_value; 378 unsigned int reg = mc->reg; 379 unsigned int reg2 = mc->rreg; 380 unsigned int shift = mc->shift; 381 unsigned int rshift = mc->rshift; 382 int max = mc->max; 383 int min = mc->min; 384 unsigned int mask = (1U << (fls(min + max) - 1)) - 1; 385 unsigned int val; 386 387 val = snd_soc_component_read(component, reg); 388 ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask; 389 390 if (snd_soc_volsw_is_stereo(mc)) { 391 val = snd_soc_component_read(component, reg2); 392 val = ((val >> rshift) - min) & mask; 393 ucontrol->value.integer.value[1] = val; 394 } 395 396 return 0; 397 } 398 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx); 399 400 /** 401 * snd_soc_put_volsw_sx - double mixer set callback 402 * @kcontrol: mixer control 403 * @ucontrol: control element information 404 * 405 * Callback to set the value of a double mixer control that spans 2 registers. 406 * 407 * Returns 0 for success. 408 */ 409 int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol, 410 struct snd_ctl_elem_value *ucontrol) 411 { 412 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 413 struct soc_mixer_control *mc = 414 (struct soc_mixer_control *)kcontrol->private_value; 415 416 unsigned int reg = mc->reg; 417 unsigned int reg2 = mc->rreg; 418 unsigned int shift = mc->shift; 419 unsigned int rshift = mc->rshift; 420 int max = mc->max; 421 int min = mc->min; 422 unsigned int mask = (1U << (fls(min + max) - 1)) - 1; 423 int err = 0; 424 unsigned int val, val_mask; 425 426 val_mask = mask << shift; 427 val = (ucontrol->value.integer.value[0] + min) & mask; 428 val = val << shift; 429 430 err = snd_soc_component_update_bits(component, reg, val_mask, val); 431 if (err < 0) 432 return err; 433 434 if (snd_soc_volsw_is_stereo(mc)) { 435 unsigned int val2; 436 437 val_mask = mask << rshift; 438 val2 = (ucontrol->value.integer.value[1] + min) & mask; 439 val2 = val2 << rshift; 440 441 err = snd_soc_component_update_bits(component, reg2, val_mask, 442 val2); 443 } 444 return err; 445 } 446 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx); 447 448 /** 449 * snd_soc_info_volsw_range - single mixer info callback with range. 450 * @kcontrol: mixer control 451 * @uinfo: control element information 452 * 453 * Callback to provide information, within a range, about a single 454 * mixer control. 455 * 456 * returns 0 for success. 457 */ 458 int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol, 459 struct snd_ctl_elem_info *uinfo) 460 { 461 struct soc_mixer_control *mc = 462 (struct soc_mixer_control *)kcontrol->private_value; 463 int platform_max; 464 int min = mc->min; 465 466 if (!mc->platform_max) 467 mc->platform_max = mc->max; 468 platform_max = mc->platform_max; 469 470 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 471 uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1; 472 uinfo->value.integer.min = 0; 473 uinfo->value.integer.max = platform_max - min; 474 475 return 0; 476 } 477 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range); 478 479 /** 480 * snd_soc_put_volsw_range - single mixer put value callback with range. 481 * @kcontrol: mixer control 482 * @ucontrol: control element information 483 * 484 * Callback to set the value, within a range, for a single mixer control. 485 * 486 * Returns 0 for success. 487 */ 488 int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol, 489 struct snd_ctl_elem_value *ucontrol) 490 { 491 struct soc_mixer_control *mc = 492 (struct soc_mixer_control *)kcontrol->private_value; 493 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 494 unsigned int reg = mc->reg; 495 unsigned int rreg = mc->rreg; 496 unsigned int shift = mc->shift; 497 int min = mc->min; 498 int max = mc->max; 499 unsigned int mask = (1 << fls(max)) - 1; 500 unsigned int invert = mc->invert; 501 unsigned int val, val_mask; 502 int ret; 503 504 if (invert) 505 val = (max - ucontrol->value.integer.value[0]) & mask; 506 else 507 val = ((ucontrol->value.integer.value[0] + min) & mask); 508 val_mask = mask << shift; 509 val = val << shift; 510 511 ret = snd_soc_component_update_bits(component, reg, val_mask, val); 512 if (ret < 0) 513 return ret; 514 515 if (snd_soc_volsw_is_stereo(mc)) { 516 if (invert) 517 val = (max - ucontrol->value.integer.value[1]) & mask; 518 else 519 val = ((ucontrol->value.integer.value[1] + min) & mask); 520 val_mask = mask << shift; 521 val = val << shift; 522 523 ret = snd_soc_component_update_bits(component, rreg, val_mask, 524 val); 525 } 526 527 return ret; 528 } 529 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range); 530 531 /** 532 * snd_soc_get_volsw_range - single mixer get callback with range 533 * @kcontrol: mixer control 534 * @ucontrol: control element information 535 * 536 * Callback to get the value, within a range, of a single mixer control. 537 * 538 * Returns 0 for success. 539 */ 540 int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol, 541 struct snd_ctl_elem_value *ucontrol) 542 { 543 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 544 struct soc_mixer_control *mc = 545 (struct soc_mixer_control *)kcontrol->private_value; 546 unsigned int reg = mc->reg; 547 unsigned int rreg = mc->rreg; 548 unsigned int shift = mc->shift; 549 int min = mc->min; 550 int max = mc->max; 551 unsigned int mask = (1 << fls(max)) - 1; 552 unsigned int invert = mc->invert; 553 unsigned int val; 554 555 val = snd_soc_component_read(component, reg); 556 ucontrol->value.integer.value[0] = (val >> shift) & mask; 557 if (invert) 558 ucontrol->value.integer.value[0] = 559 max - ucontrol->value.integer.value[0]; 560 else 561 ucontrol->value.integer.value[0] = 562 ucontrol->value.integer.value[0] - min; 563 564 if (snd_soc_volsw_is_stereo(mc)) { 565 val = snd_soc_component_read(component, rreg); 566 ucontrol->value.integer.value[1] = (val >> shift) & mask; 567 if (invert) 568 ucontrol->value.integer.value[1] = 569 max - ucontrol->value.integer.value[1]; 570 else 571 ucontrol->value.integer.value[1] = 572 ucontrol->value.integer.value[1] - min; 573 } 574 575 return 0; 576 } 577 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range); 578 579 /** 580 * snd_soc_limit_volume - Set new limit to an existing volume control. 581 * 582 * @card: where to look for the control 583 * @name: Name of the control 584 * @max: new maximum limit 585 * 586 * Return 0 for success, else error. 587 */ 588 int snd_soc_limit_volume(struct snd_soc_card *card, 589 const char *name, int max) 590 { 591 struct snd_kcontrol *kctl; 592 int ret = -EINVAL; 593 594 /* Sanity check for name and max */ 595 if (unlikely(!name || max <= 0)) 596 return -EINVAL; 597 598 kctl = snd_soc_card_get_kcontrol(card, name); 599 if (kctl) { 600 struct soc_mixer_control *mc = (struct soc_mixer_control *)kctl->private_value; 601 if (max <= mc->max) { 602 mc->platform_max = max; 603 ret = 0; 604 } 605 } 606 return ret; 607 } 608 EXPORT_SYMBOL_GPL(snd_soc_limit_volume); 609 610 int snd_soc_bytes_info(struct snd_kcontrol *kcontrol, 611 struct snd_ctl_elem_info *uinfo) 612 { 613 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 614 struct soc_bytes *params = (void *)kcontrol->private_value; 615 616 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; 617 uinfo->count = params->num_regs * component->val_bytes; 618 619 return 0; 620 } 621 EXPORT_SYMBOL_GPL(snd_soc_bytes_info); 622 623 int snd_soc_bytes_get(struct snd_kcontrol *kcontrol, 624 struct snd_ctl_elem_value *ucontrol) 625 { 626 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 627 struct soc_bytes *params = (void *)kcontrol->private_value; 628 int ret; 629 630 if (component->regmap) 631 ret = regmap_raw_read(component->regmap, params->base, 632 ucontrol->value.bytes.data, 633 params->num_regs * component->val_bytes); 634 else 635 ret = -EINVAL; 636 637 /* Hide any masked bytes to ensure consistent data reporting */ 638 if (ret == 0 && params->mask) { 639 switch (component->val_bytes) { 640 case 1: 641 ucontrol->value.bytes.data[0] &= ~params->mask; 642 break; 643 case 2: 644 ((u16 *)(&ucontrol->value.bytes.data))[0] 645 &= cpu_to_be16(~params->mask); 646 break; 647 case 4: 648 ((u32 *)(&ucontrol->value.bytes.data))[0] 649 &= cpu_to_be32(~params->mask); 650 break; 651 default: 652 return -EINVAL; 653 } 654 } 655 656 return ret; 657 } 658 EXPORT_SYMBOL_GPL(snd_soc_bytes_get); 659 660 int snd_soc_bytes_put(struct snd_kcontrol *kcontrol, 661 struct snd_ctl_elem_value *ucontrol) 662 { 663 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 664 struct soc_bytes *params = (void *)kcontrol->private_value; 665 int ret, len; 666 unsigned int val, mask; 667 void *data; 668 669 if (!component->regmap || !params->num_regs) 670 return -EINVAL; 671 672 len = params->num_regs * component->val_bytes; 673 674 data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA); 675 if (!data) 676 return -ENOMEM; 677 678 /* 679 * If we've got a mask then we need to preserve the register 680 * bits. We shouldn't modify the incoming data so take a 681 * copy. 682 */ 683 if (params->mask) { 684 ret = regmap_read(component->regmap, params->base, &val); 685 if (ret != 0) 686 goto out; 687 688 val &= params->mask; 689 690 switch (component->val_bytes) { 691 case 1: 692 ((u8 *)data)[0] &= ~params->mask; 693 ((u8 *)data)[0] |= val; 694 break; 695 case 2: 696 mask = ~params->mask; 697 ret = regmap_parse_val(component->regmap, 698 &mask, &mask); 699 if (ret != 0) 700 goto out; 701 702 ((u16 *)data)[0] &= mask; 703 704 ret = regmap_parse_val(component->regmap, 705 &val, &val); 706 if (ret != 0) 707 goto out; 708 709 ((u16 *)data)[0] |= val; 710 break; 711 case 4: 712 mask = ~params->mask; 713 ret = regmap_parse_val(component->regmap, 714 &mask, &mask); 715 if (ret != 0) 716 goto out; 717 718 ((u32 *)data)[0] &= mask; 719 720 ret = regmap_parse_val(component->regmap, 721 &val, &val); 722 if (ret != 0) 723 goto out; 724 725 ((u32 *)data)[0] |= val; 726 break; 727 default: 728 ret = -EINVAL; 729 goto out; 730 } 731 } 732 733 ret = regmap_raw_write(component->regmap, params->base, 734 data, len); 735 736 out: 737 kfree(data); 738 739 return ret; 740 } 741 EXPORT_SYMBOL_GPL(snd_soc_bytes_put); 742 743 int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol, 744 struct snd_ctl_elem_info *ucontrol) 745 { 746 struct soc_bytes_ext *params = (void *)kcontrol->private_value; 747 748 ucontrol->type = SNDRV_CTL_ELEM_TYPE_BYTES; 749 ucontrol->count = params->max; 750 751 return 0; 752 } 753 EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext); 754 755 int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag, 756 unsigned int size, unsigned int __user *tlv) 757 { 758 struct soc_bytes_ext *params = (void *)kcontrol->private_value; 759 unsigned int count = size < params->max ? size : params->max; 760 int ret = -ENXIO; 761 762 switch (op_flag) { 763 case SNDRV_CTL_TLV_OP_READ: 764 if (params->get) 765 ret = params->get(kcontrol, tlv, count); 766 break; 767 case SNDRV_CTL_TLV_OP_WRITE: 768 if (params->put) 769 ret = params->put(kcontrol, tlv, count); 770 break; 771 } 772 return ret; 773 } 774 EXPORT_SYMBOL_GPL(snd_soc_bytes_tlv_callback); 775 776 /** 777 * snd_soc_info_xr_sx - signed multi register info callback 778 * @kcontrol: mreg control 779 * @uinfo: control element information 780 * 781 * Callback to provide information of a control that can 782 * span multiple codec registers which together 783 * forms a single signed value in a MSB/LSB manner. 784 * 785 * Returns 0 for success. 786 */ 787 int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol, 788 struct snd_ctl_elem_info *uinfo) 789 { 790 struct soc_mreg_control *mc = 791 (struct soc_mreg_control *)kcontrol->private_value; 792 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 793 uinfo->count = 1; 794 uinfo->value.integer.min = mc->min; 795 uinfo->value.integer.max = mc->max; 796 797 return 0; 798 } 799 EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx); 800 801 /** 802 * snd_soc_get_xr_sx - signed multi register get callback 803 * @kcontrol: mreg control 804 * @ucontrol: control element information 805 * 806 * Callback to get the value of a control that can span 807 * multiple codec registers which together forms a single 808 * signed value in a MSB/LSB manner. The control supports 809 * specifying total no of bits used to allow for bitfields 810 * across the multiple codec registers. 811 * 812 * Returns 0 for success. 813 */ 814 int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol, 815 struct snd_ctl_elem_value *ucontrol) 816 { 817 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 818 struct soc_mreg_control *mc = 819 (struct soc_mreg_control *)kcontrol->private_value; 820 unsigned int regbase = mc->regbase; 821 unsigned int regcount = mc->regcount; 822 unsigned int regwshift = component->val_bytes * BITS_PER_BYTE; 823 unsigned int regwmask = (1UL<<regwshift)-1; 824 unsigned int invert = mc->invert; 825 unsigned long mask = (1UL<<mc->nbits)-1; 826 long min = mc->min; 827 long max = mc->max; 828 long val = 0; 829 unsigned int i; 830 831 for (i = 0; i < regcount; i++) { 832 unsigned int regval = snd_soc_component_read(component, regbase+i); 833 val |= (regval & regwmask) << (regwshift*(regcount-i-1)); 834 } 835 val &= mask; 836 if (min < 0 && val > max) 837 val |= ~mask; 838 if (invert) 839 val = max - val; 840 ucontrol->value.integer.value[0] = val; 841 842 return 0; 843 } 844 EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx); 845 846 /** 847 * snd_soc_put_xr_sx - signed multi register get callback 848 * @kcontrol: mreg control 849 * @ucontrol: control element information 850 * 851 * Callback to set the value of a control that can span 852 * multiple codec registers which together forms a single 853 * signed value in a MSB/LSB manner. The control supports 854 * specifying total no of bits used to allow for bitfields 855 * across the multiple codec registers. 856 * 857 * Returns 0 for success. 858 */ 859 int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol, 860 struct snd_ctl_elem_value *ucontrol) 861 { 862 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 863 struct soc_mreg_control *mc = 864 (struct soc_mreg_control *)kcontrol->private_value; 865 unsigned int regbase = mc->regbase; 866 unsigned int regcount = mc->regcount; 867 unsigned int regwshift = component->val_bytes * BITS_PER_BYTE; 868 unsigned int regwmask = (1UL<<regwshift)-1; 869 unsigned int invert = mc->invert; 870 unsigned long mask = (1UL<<mc->nbits)-1; 871 long max = mc->max; 872 long val = ucontrol->value.integer.value[0]; 873 unsigned int i; 874 875 if (invert) 876 val = max - val; 877 val &= mask; 878 for (i = 0; i < regcount; i++) { 879 unsigned int regval = (val >> (regwshift*(regcount-i-1))) & regwmask; 880 unsigned int regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask; 881 int err = snd_soc_component_update_bits(component, regbase+i, 882 regmask, regval); 883 if (err < 0) 884 return err; 885 } 886 887 return 0; 888 } 889 EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx); 890 891 /** 892 * snd_soc_get_strobe - strobe get callback 893 * @kcontrol: mixer control 894 * @ucontrol: control element information 895 * 896 * Callback get the value of a strobe mixer control. 897 * 898 * Returns 0 for success. 899 */ 900 int snd_soc_get_strobe(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_mixer_control *mc = 905 (struct soc_mixer_control *)kcontrol->private_value; 906 unsigned int reg = mc->reg; 907 unsigned int shift = mc->shift; 908 unsigned int mask = 1 << shift; 909 unsigned int invert = mc->invert != 0; 910 unsigned int val; 911 912 val = snd_soc_component_read(component, reg); 913 val &= mask; 914 915 if (shift != 0 && val != 0) 916 val = val >> shift; 917 ucontrol->value.enumerated.item[0] = val ^ invert; 918 919 return 0; 920 } 921 EXPORT_SYMBOL_GPL(snd_soc_get_strobe); 922 923 /** 924 * snd_soc_put_strobe - strobe put callback 925 * @kcontrol: mixer control 926 * @ucontrol: control element information 927 * 928 * Callback strobe a register bit to high then low (or the inverse) 929 * in one pass of a single mixer enum control. 930 * 931 * Returns 1 for success. 932 */ 933 int snd_soc_put_strobe(struct snd_kcontrol *kcontrol, 934 struct snd_ctl_elem_value *ucontrol) 935 { 936 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 937 struct soc_mixer_control *mc = 938 (struct soc_mixer_control *)kcontrol->private_value; 939 unsigned int reg = mc->reg; 940 unsigned int shift = mc->shift; 941 unsigned int mask = 1 << shift; 942 unsigned int invert = mc->invert != 0; 943 unsigned int strobe = ucontrol->value.enumerated.item[0] != 0; 944 unsigned int val1 = (strobe ^ invert) ? mask : 0; 945 unsigned int val2 = (strobe ^ invert) ? 0 : mask; 946 int err; 947 948 err = snd_soc_component_update_bits(component, reg, mask, val1); 949 if (err < 0) 950 return err; 951 952 return snd_soc_component_update_bits(component, reg, mask, val2); 953 } 954 EXPORT_SYMBOL_GPL(snd_soc_put_strobe); 955