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