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