sound/soc/soc-ops.c

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