sound/soc/soc-ops.c

   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);