sound/soc/soc-ops.c

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