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