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