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