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