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