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 = (1 << 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 - min) 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; 468 469 val_mask = mask << rshift; 470 val2 = (ucontrol->value.integer.value[1] + min) & mask; 471 val2 = val2 << rshift; 472 473 err = snd_soc_component_update_bits(component, reg2, val_mask, 474 val2); 475 476 /* Don't discard any error code or drop change flag */ 477 if (ret == 0 || err < 0) { 478 ret = err; 479 } 480 } 481 return ret; 482 } 483 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx); 484 485 /** 486 * snd_soc_info_volsw_range - single mixer info callback with range. 487 * @kcontrol: mixer control 488 * @uinfo: control element information 489 * 490 * Callback to provide information, within a range, about a single 491 * mixer control. 492 * 493 * returns 0 for success. 494 */ 495 int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol, 496 struct snd_ctl_elem_info *uinfo) 497 { 498 struct soc_mixer_control *mc = 499 (struct soc_mixer_control *)kcontrol->private_value; 500 int platform_max; 501 int min = mc->min; 502 503 if (!mc->platform_max) 504 mc->platform_max = mc->max; 505 platform_max = mc->platform_max; 506 507 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 508 uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1; 509 uinfo->value.integer.min = 0; 510 uinfo->value.integer.max = platform_max - min; 511 512 return 0; 513 } 514 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range); 515 516 /** 517 * snd_soc_put_volsw_range - single mixer put value callback with range. 518 * @kcontrol: mixer control 519 * @ucontrol: control element information 520 * 521 * Callback to set the value, within a range, for a single mixer control. 522 * 523 * Returns 0 for success. 524 */ 525 int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol, 526 struct snd_ctl_elem_value *ucontrol) 527 { 528 struct soc_mixer_control *mc = 529 (struct soc_mixer_control *)kcontrol->private_value; 530 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 531 unsigned int reg = mc->reg; 532 unsigned int rreg = mc->rreg; 533 unsigned int shift = mc->shift; 534 int min = mc->min; 535 int max = mc->max; 536 unsigned int mask = (1 << fls(max)) - 1; 537 unsigned int invert = mc->invert; 538 unsigned int val, val_mask; 539 int err, ret, tmp; 540 541 tmp = ucontrol->value.integer.value[0]; 542 if (tmp < 0) 543 return -EINVAL; 544 if (mc->platform_max && tmp > mc->platform_max) 545 return -EINVAL; 546 if (tmp > mc->max - mc->min) 547 return -EINVAL; 548 549 if (invert) 550 val = (max - ucontrol->value.integer.value[0]) & mask; 551 else 552 val = ((ucontrol->value.integer.value[0] + min) & mask); 553 val_mask = mask << shift; 554 val = val << shift; 555 556 err = snd_soc_component_update_bits(component, reg, val_mask, val); 557 if (err < 0) 558 return err; 559 ret = err; 560 561 if (snd_soc_volsw_is_stereo(mc)) { 562 tmp = ucontrol->value.integer.value[1]; 563 if (tmp < 0) 564 return -EINVAL; 565 if (mc->platform_max && tmp > mc->platform_max) 566 return -EINVAL; 567 if (tmp > mc->max - mc->min) 568 return -EINVAL; 569 570 if (invert) 571 val = (max - ucontrol->value.integer.value[1]) & mask; 572 else 573 val = ((ucontrol->value.integer.value[1] + min) & mask); 574 val_mask = mask << shift; 575 val = val << shift; 576 577 err = snd_soc_component_update_bits(component, rreg, val_mask, 578 val); 579 /* Don't discard any error code or drop change flag */ 580 if (ret == 0 || err < 0) { 581 ret = err; 582 } 583 } 584 585 return ret; 586 } 587 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range); 588 589 /** 590 * snd_soc_get_volsw_range - single mixer get callback with range 591 * @kcontrol: mixer control 592 * @ucontrol: control element information 593 * 594 * Callback to get the value, within a range, of a single mixer control. 595 * 596 * Returns 0 for success. 597 */ 598 int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol, 599 struct snd_ctl_elem_value *ucontrol) 600 { 601 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 602 struct soc_mixer_control *mc = 603 (struct soc_mixer_control *)kcontrol->private_value; 604 unsigned int reg = mc->reg; 605 unsigned int rreg = mc->rreg; 606 unsigned int shift = mc->shift; 607 int min = mc->min; 608 int max = mc->max; 609 unsigned int mask = (1 << fls(max)) - 1; 610 unsigned int invert = mc->invert; 611 unsigned int val; 612 613 val = snd_soc_component_read(component, reg); 614 ucontrol->value.integer.value[0] = (val >> shift) & mask; 615 if (invert) 616 ucontrol->value.integer.value[0] = 617 max - ucontrol->value.integer.value[0]; 618 else 619 ucontrol->value.integer.value[0] = 620 ucontrol->value.integer.value[0] - min; 621 622 if (snd_soc_volsw_is_stereo(mc)) { 623 val = snd_soc_component_read(component, rreg); 624 ucontrol->value.integer.value[1] = (val >> shift) & mask; 625 if (invert) 626 ucontrol->value.integer.value[1] = 627 max - ucontrol->value.integer.value[1]; 628 else 629 ucontrol->value.integer.value[1] = 630 ucontrol->value.integer.value[1] - min; 631 } 632 633 return 0; 634 } 635 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range); 636 637 /** 638 * snd_soc_limit_volume - Set new limit to an existing volume control. 639 * 640 * @card: where to look for the control 641 * @name: Name of the control 642 * @max: new maximum limit 643 * 644 * Return 0 for success, else error. 645 */ 646 int snd_soc_limit_volume(struct snd_soc_card *card, 647 const char *name, int max) 648 { 649 struct snd_kcontrol *kctl; 650 int ret = -EINVAL; 651 652 /* Sanity check for name and max */ 653 if (unlikely(!name || max <= 0)) 654 return -EINVAL; 655 656 kctl = snd_soc_card_get_kcontrol(card, name); 657 if (kctl) { 658 struct soc_mixer_control *mc = (struct soc_mixer_control *)kctl->private_value; 659 if (max <= mc->max) { 660 mc->platform_max = max; 661 ret = 0; 662 } 663 } 664 return ret; 665 } 666 EXPORT_SYMBOL_GPL(snd_soc_limit_volume); 667 668 int snd_soc_bytes_info(struct snd_kcontrol *kcontrol, 669 struct snd_ctl_elem_info *uinfo) 670 { 671 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 672 struct soc_bytes *params = (void *)kcontrol->private_value; 673 674 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; 675 uinfo->count = params->num_regs * component->val_bytes; 676 677 return 0; 678 } 679 EXPORT_SYMBOL_GPL(snd_soc_bytes_info); 680 681 int snd_soc_bytes_get(struct snd_kcontrol *kcontrol, 682 struct snd_ctl_elem_value *ucontrol) 683 { 684 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 685 struct soc_bytes *params = (void *)kcontrol->private_value; 686 int ret; 687 688 if (component->regmap) 689 ret = regmap_raw_read(component->regmap, params->base, 690 ucontrol->value.bytes.data, 691 params->num_regs * component->val_bytes); 692 else 693 ret = -EINVAL; 694 695 /* Hide any masked bytes to ensure consistent data reporting */ 696 if (ret == 0 && params->mask) { 697 switch (component->val_bytes) { 698 case 1: 699 ucontrol->value.bytes.data[0] &= ~params->mask; 700 break; 701 case 2: 702 ((u16 *)(&ucontrol->value.bytes.data))[0] 703 &= cpu_to_be16(~params->mask); 704 break; 705 case 4: 706 ((u32 *)(&ucontrol->value.bytes.data))[0] 707 &= cpu_to_be32(~params->mask); 708 break; 709 default: 710 return -EINVAL; 711 } 712 } 713 714 return ret; 715 } 716 EXPORT_SYMBOL_GPL(snd_soc_bytes_get); 717 718 int snd_soc_bytes_put(struct snd_kcontrol *kcontrol, 719 struct snd_ctl_elem_value *ucontrol) 720 { 721 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 722 struct soc_bytes *params = (void *)kcontrol->private_value; 723 int ret, len; 724 unsigned int val, mask; 725 void *data; 726 727 if (!component->regmap || !params->num_regs) 728 return -EINVAL; 729 730 len = params->num_regs * component->val_bytes; 731 732 data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA); 733 if (!data) 734 return -ENOMEM; 735 736 /* 737 * If we've got a mask then we need to preserve the register 738 * bits. We shouldn't modify the incoming data so take a 739 * copy. 740 */ 741 if (params->mask) { 742 ret = regmap_read(component->regmap, params->base, &val); 743 if (ret != 0) 744 goto out; 745 746 val &= params->mask; 747 748 switch (component->val_bytes) { 749 case 1: 750 ((u8 *)data)[0] &= ~params->mask; 751 ((u8 *)data)[0] |= val; 752 break; 753 case 2: 754 mask = ~params->mask; 755 ret = regmap_parse_val(component->regmap, 756 &mask, &mask); 757 if (ret != 0) 758 goto out; 759 760 ((u16 *)data)[0] &= mask; 761 762 ret = regmap_parse_val(component->regmap, 763 &val, &val); 764 if (ret != 0) 765 goto out; 766 767 ((u16 *)data)[0] |= val; 768 break; 769 case 4: 770 mask = ~params->mask; 771 ret = regmap_parse_val(component->regmap, 772 &mask, &mask); 773 if (ret != 0) 774 goto out; 775 776 ((u32 *)data)[0] &= mask; 777 778 ret = regmap_parse_val(component->regmap, 779 &val, &val); 780 if (ret != 0) 781 goto out; 782 783 ((u32 *)data)[0] |= val; 784 break; 785 default: 786 ret = -EINVAL; 787 goto out; 788 } 789 } 790 791 ret = regmap_raw_write(component->regmap, params->base, 792 data, len); 793 794 out: 795 kfree(data); 796 797 return ret; 798 } 799 EXPORT_SYMBOL_GPL(snd_soc_bytes_put); 800 801 int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol, 802 struct snd_ctl_elem_info *ucontrol) 803 { 804 struct soc_bytes_ext *params = (void *)kcontrol->private_value; 805 806 ucontrol->type = SNDRV_CTL_ELEM_TYPE_BYTES; 807 ucontrol->count = params->max; 808 809 return 0; 810 } 811 EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext); 812 813 int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag, 814 unsigned int size, unsigned int __user *tlv) 815 { 816 struct soc_bytes_ext *params = (void *)kcontrol->private_value; 817 unsigned int count = size < params->max ? size : params->max; 818 int ret = -ENXIO; 819 820 switch (op_flag) { 821 case SNDRV_CTL_TLV_OP_READ: 822 if (params->get) 823 ret = params->get(kcontrol, tlv, count); 824 break; 825 case SNDRV_CTL_TLV_OP_WRITE: 826 if (params->put) 827 ret = params->put(kcontrol, tlv, count); 828 break; 829 } 830 return ret; 831 } 832 EXPORT_SYMBOL_GPL(snd_soc_bytes_tlv_callback); 833 834 /** 835 * snd_soc_info_xr_sx - signed multi register info callback 836 * @kcontrol: mreg control 837 * @uinfo: control element information 838 * 839 * Callback to provide information of a control that can 840 * span multiple codec registers which together 841 * forms a single signed value in a MSB/LSB manner. 842 * 843 * Returns 0 for success. 844 */ 845 int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol, 846 struct snd_ctl_elem_info *uinfo) 847 { 848 struct soc_mreg_control *mc = 849 (struct soc_mreg_control *)kcontrol->private_value; 850 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 851 uinfo->count = 1; 852 uinfo->value.integer.min = mc->min; 853 uinfo->value.integer.max = mc->max; 854 855 return 0; 856 } 857 EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx); 858 859 /** 860 * snd_soc_get_xr_sx - signed multi register get callback 861 * @kcontrol: mreg control 862 * @ucontrol: control element information 863 * 864 * Callback to get the value of a control that can span 865 * multiple codec registers which together forms a single 866 * signed value in a MSB/LSB manner. The control supports 867 * specifying total no of bits used to allow for bitfields 868 * across the multiple codec registers. 869 * 870 * Returns 0 for success. 871 */ 872 int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol, 873 struct snd_ctl_elem_value *ucontrol) 874 { 875 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 876 struct soc_mreg_control *mc = 877 (struct soc_mreg_control *)kcontrol->private_value; 878 unsigned int regbase = mc->regbase; 879 unsigned int regcount = mc->regcount; 880 unsigned int regwshift = component->val_bytes * BITS_PER_BYTE; 881 unsigned int regwmask = (1UL<<regwshift)-1; 882 unsigned int invert = mc->invert; 883 unsigned long mask = (1UL<<mc->nbits)-1; 884 long min = mc->min; 885 long max = mc->max; 886 long val = 0; 887 unsigned int i; 888 889 for (i = 0; i < regcount; i++) { 890 unsigned int regval = snd_soc_component_read(component, regbase+i); 891 val |= (regval & regwmask) << (regwshift*(regcount-i-1)); 892 } 893 val &= mask; 894 if (min < 0 && val > max) 895 val |= ~mask; 896 if (invert) 897 val = max - val; 898 ucontrol->value.integer.value[0] = val; 899 900 return 0; 901 } 902 EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx); 903 904 /** 905 * snd_soc_put_xr_sx - signed multi register get callback 906 * @kcontrol: mreg control 907 * @ucontrol: control element information 908 * 909 * Callback to set the value of a control that can span 910 * multiple codec registers which together forms a single 911 * signed value in a MSB/LSB manner. The control supports 912 * specifying total no of bits used to allow for bitfields 913 * across the multiple codec registers. 914 * 915 * Returns 0 for success. 916 */ 917 int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol, 918 struct snd_ctl_elem_value *ucontrol) 919 { 920 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 921 struct soc_mreg_control *mc = 922 (struct soc_mreg_control *)kcontrol->private_value; 923 unsigned int regbase = mc->regbase; 924 unsigned int regcount = mc->regcount; 925 unsigned int regwshift = component->val_bytes * BITS_PER_BYTE; 926 unsigned int regwmask = (1UL<<regwshift)-1; 927 unsigned int invert = mc->invert; 928 unsigned long mask = (1UL<<mc->nbits)-1; 929 long max = mc->max; 930 long val = ucontrol->value.integer.value[0]; 931 int ret = 0; 932 unsigned int i; 933 934 if (val < mc->min || val > mc->max) 935 return -EINVAL; 936 if (invert) 937 val = max - val; 938 val &= mask; 939 for (i = 0; i < regcount; i++) { 940 unsigned int regval = (val >> (regwshift*(regcount-i-1))) & regwmask; 941 unsigned int regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask; 942 int err = snd_soc_component_update_bits(component, regbase+i, 943 regmask, regval); 944 if (err < 0) 945 return err; 946 if (err > 0) 947 ret = err; 948 } 949 950 return ret; 951 } 952 EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx); 953 954 /** 955 * snd_soc_get_strobe - strobe get callback 956 * @kcontrol: mixer control 957 * @ucontrol: control element information 958 * 959 * Callback get the value of a strobe mixer control. 960 * 961 * Returns 0 for success. 962 */ 963 int snd_soc_get_strobe(struct snd_kcontrol *kcontrol, 964 struct snd_ctl_elem_value *ucontrol) 965 { 966 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 967 struct soc_mixer_control *mc = 968 (struct soc_mixer_control *)kcontrol->private_value; 969 unsigned int reg = mc->reg; 970 unsigned int shift = mc->shift; 971 unsigned int mask = 1 << shift; 972 unsigned int invert = mc->invert != 0; 973 unsigned int val; 974 975 val = snd_soc_component_read(component, reg); 976 val &= mask; 977 978 if (shift != 0 && val != 0) 979 val = val >> shift; 980 ucontrol->value.enumerated.item[0] = val ^ invert; 981 982 return 0; 983 } 984 EXPORT_SYMBOL_GPL(snd_soc_get_strobe); 985 986 /** 987 * snd_soc_put_strobe - strobe put callback 988 * @kcontrol: mixer control 989 * @ucontrol: control element information 990 * 991 * Callback strobe a register bit to high then low (or the inverse) 992 * in one pass of a single mixer enum control. 993 * 994 * Returns 1 for success. 995 */ 996 int snd_soc_put_strobe(struct snd_kcontrol *kcontrol, 997 struct snd_ctl_elem_value *ucontrol) 998 { 999 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1000 struct soc_mixer_control *mc = 1001 (struct soc_mixer_control *)kcontrol->private_value; 1002 unsigned int reg = mc->reg; 1003 unsigned int shift = mc->shift; 1004 unsigned int mask = 1 << shift; 1005 unsigned int invert = mc->invert != 0; 1006 unsigned int strobe = ucontrol->value.enumerated.item[0] != 0; 1007 unsigned int val1 = (strobe ^ invert) ? mask : 0; 1008 unsigned int val2 = (strobe ^ invert) ? 0 : mask; 1009 int err; 1010 1011 err = snd_soc_component_update_bits(component, reg, mask, val1); 1012 if (err < 0) 1013 return err; 1014 1015 return snd_soc_component_update_bits(component, reg, mask, val2); 1016 } 1017 EXPORT_SYMBOL_GPL(snd_soc_put_strobe); 1018