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;
 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] + min) & mask);
 331         if (invert)
 332                 val = max - val;
 333         val_mask = mask << shift;
 334         val = val << shift;
 335         if (snd_soc_volsw_is_stereo(mc)) {
 336                 val2 = ((ucontrol->value.integer.value[1] + min) & mask);
 337                 if (invert)
 338                         val2 = max - val2;
 339                 if (reg == reg2) {
 340                         val_mask |= mask << rshift;
 341                         val |= val2 << rshift;
 342                 } else {
 343                         val2 = val2 << shift;
 344                         type_2r = true;
 345                 }
 346         }
 347         err = snd_soc_component_update_bits(component, reg, val_mask, val);
 348         if (err < 0)
 349                 return err;
 350
 351         if (type_2r)
 352                 err = snd_soc_component_update_bits(component, reg2, val_mask,
 353                         val2);
 354
 355         return err;
 356 }
 357 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
 358
 359 /**
 360  * snd_soc_get_volsw_sx - single mixer get callback
 361  * @kcontrol: mixer control
 362  * @ucontrol: control element information
 363  *
 364  * Callback to get the value of a single mixer control, or a double mixer
 365  * control that spans 2 registers.
 366  *
 367  * Returns 0 for success.
 368  */
 369 int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
 370                       struct snd_ctl_elem_value *ucontrol)
 371 {
 372         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 373         struct soc_mixer_control *mc =
 374             (struct soc_mixer_control *)kcontrol->private_value;
 375         unsigned int reg = mc->reg;
 376         unsigned int reg2 = mc->rreg;
 377         unsigned int shift = mc->shift;
 378         unsigned int rshift = mc->rshift;
 379         int max = mc->max;
 380         int min = mc->min;
 381         int mask = (1 << (fls(min + max) - 1)) - 1;
 382         unsigned int val;
 383         int ret;
 384
 385         ret = snd_soc_component_read(component, reg, &val);
 386         if (ret < 0)
 387                 return ret;
 388
 389         ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask;
 390
 391         if (snd_soc_volsw_is_stereo(mc)) {
 392                 ret = snd_soc_component_read(component, reg2, &val);
 393                 if (ret < 0)
 394                         return ret;
 395
 396                 val = ((val >> rshift) - min) & mask;
 397                 ucontrol->value.integer.value[1] = val;
 398         }
 399
 400         return 0;
 401 }
 402 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx);
 403
 404 /**
 405  * snd_soc_put_volsw_sx - double mixer set callback
 406  * @kcontrol: mixer control
 407  * @ucontrol: control element information
 408  *
 409  * Callback to set the value of a double mixer control that spans 2 registers.
 410  *
 411  * Returns 0 for success.
 412  */
 413 int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
 414                          struct snd_ctl_elem_value *ucontrol)
 415 {
 416         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 417         struct soc_mixer_control *mc =
 418             (struct soc_mixer_control *)kcontrol->private_value;
 419
 420         unsigned int reg = mc->reg;
 421         unsigned int reg2 = mc->rreg;
 422         unsigned int shift = mc->shift;
 423         unsigned int rshift = mc->rshift;
 424         int max = mc->max;
 425         int min = mc->min;
 426         int mask = (1 << (fls(min + max) - 1)) - 1;
 427         int err = 0;
 428         unsigned int val, val_mask, val2 = 0;
 429
 430         val_mask = mask << shift;
 431         val = (ucontrol->value.integer.value[0] + min) & mask;
 432         val = val << shift;
 433
 434         err = snd_soc_component_update_bits(component, reg, val_mask, val);
 435         if (err < 0)
 436                 return err;
 437
 438         if (snd_soc_volsw_is_stereo(mc)) {
 439                 val_mask = mask << rshift;
 440                 val2 = (ucontrol->value.integer.value[1] + min) & mask;
 441                 val2 = val2 << rshift;
 442
 443                 err = snd_soc_component_update_bits(component, reg2, val_mask,
 444                         val2);
 445         }
 446         return err;
 447 }
 448 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx);
 449
 450 /**
 451  * snd_soc_info_volsw_range - single mixer info callback with range.
 452  * @kcontrol: mixer control
 453  * @uinfo: control element information
 454  *
 455  * Callback to provide information, within a range, about a single
 456  * mixer control.
 457  *
 458  * returns 0 for success.
 459  */
 460 int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
 461         struct snd_ctl_elem_info *uinfo)
 462 {
 463         struct soc_mixer_control *mc =
 464                 (struct soc_mixer_control *)kcontrol->private_value;
 465         int platform_max;
 466         int min = mc->min;
 467
 468         if (!mc->platform_max)
 469                 mc->platform_max = mc->max;
 470         platform_max = mc->platform_max;
 471
 472         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 473         uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
 474         uinfo->value.integer.min = 0;
 475         uinfo->value.integer.max = platform_max - min;
 476
 477         return 0;
 478 }
 479 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range);
 480
 481 /**
 482  * snd_soc_put_volsw_range - single mixer put value callback with range.
 483  * @kcontrol: mixer control
 484  * @ucontrol: control element information
 485  *
 486  * Callback to set the value, within a range, for a single mixer control.
 487  *
 488  * Returns 0 for success.
 489  */
 490 int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
 491         struct snd_ctl_elem_value *ucontrol)
 492 {
 493         struct soc_mixer_control *mc =
 494                 (struct soc_mixer_control *)kcontrol->private_value;
 495         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 496         unsigned int reg = mc->reg;
 497         unsigned int rreg = mc->rreg;
 498         unsigned int shift = mc->shift;
 499         int min = mc->min;
 500         int max = mc->max;
 501         unsigned int mask = (1 << fls(max)) - 1;
 502         unsigned int invert = mc->invert;
 503         unsigned int val, val_mask;
 504         int ret;
 505
 506         if (invert)
 507                 val = (max - ucontrol->value.integer.value[0]) & mask;
 508         else
 509                 val = ((ucontrol->value.integer.value[0] + min) & mask);
 510         val_mask = mask << shift;
 511         val = val << shift;
 512
 513         ret = snd_soc_component_update_bits(component, reg, val_mask, val);
 514         if (ret < 0)
 515                 return ret;
 516
 517         if (snd_soc_volsw_is_stereo(mc)) {
 518                 if (invert)
 519                         val = (max - ucontrol->value.integer.value[1]) & mask;
 520                 else
 521                         val = ((ucontrol->value.integer.value[1] + min) & mask);
 522                 val_mask = mask << shift;
 523                 val = val << shift;
 524
 525                 ret = snd_soc_component_update_bits(component, rreg, val_mask,
 526                         val);
 527         }
 528
 529         return ret;
 530 }
 531 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range);
 532
 533 /**
 534  * snd_soc_get_volsw_range - single mixer get callback with range
 535  * @kcontrol: mixer control
 536  * @ucontrol: control element information
 537  *
 538  * Callback to get the value, within a range, of a single mixer control.
 539  *
 540  * Returns 0 for success.
 541  */
 542 int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
 543         struct snd_ctl_elem_value *ucontrol)
 544 {
 545         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 546         struct soc_mixer_control *mc =
 547                 (struct soc_mixer_control *)kcontrol->private_value;
 548         unsigned int reg = mc->reg;
 549         unsigned int rreg = mc->rreg;
 550         unsigned int shift = mc->shift;
 551         int min = mc->min;
 552         int max = mc->max;
 553         unsigned int mask = (1 << fls(max)) - 1;
 554         unsigned int invert = mc->invert;
 555         unsigned int val;
 556         int ret;
 557
 558         ret = snd_soc_component_read(component, reg, &val);
 559         if (ret)
 560                 return ret;
 561
 562         ucontrol->value.integer.value[0] = (val >> shift) & mask;
 563         if (invert)
 564                 ucontrol->value.integer.value[0] =
 565                         max - ucontrol->value.integer.value[0];
 566         else
 567                 ucontrol->value.integer.value[0] =
 568                         ucontrol->value.integer.value[0] - min;
 569
 570         if (snd_soc_volsw_is_stereo(mc)) {
 571                 ret = snd_soc_component_read(component, rreg, &val);
 572                 if (ret)
 573                         return ret;
 574
 575                 ucontrol->value.integer.value[1] = (val >> shift) & mask;
 576                 if (invert)
 577                         ucontrol->value.integer.value[1] =
 578                                 max - ucontrol->value.integer.value[1];
 579                 else
 580                         ucontrol->value.integer.value[1] =
 581                                 ucontrol->value.integer.value[1] - min;
 582         }
 583
 584         return 0;
 585 }
 586 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range);
 587
 588 /**
 589  * snd_soc_limit_volume - Set new limit to an existing volume control.
 590  *
 591  * @card: where to look for the control
 592  * @name: Name of the control
 593  * @max: new maximum limit
 594  *
 595  * Return 0 for success, else error.
 596  */
 597 int snd_soc_limit_volume(struct snd_soc_card *card,
 598         const char *name, int max)
 599 {
 600         struct snd_card *snd_card = card->snd_card;
 601         struct snd_kcontrol *kctl;
 602         struct soc_mixer_control *mc;
 603         int found = 0;
 604         int ret = -EINVAL;
 605
 606         /* Sanity check for name and max */
 607         if (unlikely(!name || max <= 0))
 608                 return -EINVAL;
 609
 610         list_for_each_entry(kctl, &snd_card->controls, list) {
 611                 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
 612                         found = 1;
 613                         break;
 614                 }
 615         }
 616         if (found) {
 617                 mc = (struct soc_mixer_control *)kctl->private_value;
 618                 if (max <= mc->max) {
 619                         mc->platform_max = max;
 620                         ret = 0;
 621                 }
 622         }
 623         return ret;
 624 }
 625 EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
 626
 627 int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
 628                        struct snd_ctl_elem_info *uinfo)
 629 {
 630         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 631         struct soc_bytes *params = (void *)kcontrol->private_value;
 632
 633         uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
 634         uinfo->count = params->num_regs * component->val_bytes;
 635
 636         return 0;
 637 }
 638 EXPORT_SYMBOL_GPL(snd_soc_bytes_info);
 639
 640 int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
 641                       struct snd_ctl_elem_value *ucontrol)
 642 {
 643         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 644         struct soc_bytes *params = (void *)kcontrol->private_value;
 645         int ret;
 646
 647         if (component->regmap)
 648                 ret = regmap_raw_read(component->regmap, params->base,
 649                                       ucontrol->value.bytes.data,
 650                                       params->num_regs * component->val_bytes);
 651         else
 652                 ret = -EINVAL;
 653
 654         /* Hide any masked bytes to ensure consistent data reporting */
 655         if (ret == 0 && params->mask) {
 656                 switch (component->val_bytes) {
 657                 case 1:
 658                         ucontrol->value.bytes.data[0] &= ~params->mask;
 659                         break;
 660                 case 2:
 661                         ((u16 *)(&ucontrol->value.bytes.data))[0]
 662                                 &= cpu_to_be16(~params->mask);
 663                         break;
 664                 case 4:
 665                         ((u32 *)(&ucontrol->value.bytes.data))[0]
 666                                 &= cpu_to_be32(~params->mask);
 667                         break;
 668                 default:
 669                         return -EINVAL;
 670                 }
 671         }
 672
 673         return ret;
 674 }
 675 EXPORT_SYMBOL_GPL(snd_soc_bytes_get);
 676
 677 int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
 678                       struct snd_ctl_elem_value *ucontrol)
 679 {
 680         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 681         struct soc_bytes *params = (void *)kcontrol->private_value;
 682         int ret, len;
 683         unsigned int val, mask;
 684         void *data;
 685
 686         if (!component->regmap || !params->num_regs)
 687                 return -EINVAL;
 688
 689         len = params->num_regs * component->val_bytes;
 690
 691         data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA);
 692         if (!data)
 693                 return -ENOMEM;
 694
 695         /*
 696          * If we've got a mask then we need to preserve the register
 697          * bits.  We shouldn't modify the incoming data so take a
 698          * copy.
 699          */
 700         if (params->mask) {
 701                 ret = regmap_read(component->regmap, params->base, &val);
 702                 if (ret != 0)
 703                         goto out;
 704
 705                 val &= params->mask;
 706
 707                 switch (component->val_bytes) {
 708                 case 1:
 709                         ((u8 *)data)[0] &= ~params->mask;
 710                         ((u8 *)data)[0] |= val;
 711                         break;
 712                 case 2:
 713                         mask = ~params->mask;
 714                         ret = regmap_parse_val(component->regmap,
 715                                                         &mask, &mask);
 716                         if (ret != 0)
 717                                 goto out;
 718
 719                         ((u16 *)data)[0] &= mask;
 720
 721                         ret = regmap_parse_val(component->regmap,
 722                                                         &val, &val);
 723                         if (ret != 0)
 724                                 goto out;
 725
 726                         ((u16 *)data)[0] |= val;
 727                         break;
 728                 case 4:
 729                         mask = ~params->mask;
 730                         ret = regmap_parse_val(component->regmap,
 731                                                         &mask, &mask);
 732                         if (ret != 0)
 733                                 goto out;
 734
 735                         ((u32 *)data)[0] &= mask;
 736
 737                         ret = regmap_parse_val(component->regmap,
 738                                                         &val, &val);
 739                         if (ret != 0)
 740                                 goto out;
 741
 742                         ((u32 *)data)[0] |= val;
 743                         break;
 744                 default:
 745                         ret = -EINVAL;
 746                         goto out;
 747                 }
 748         }
 749
 750         ret = regmap_raw_write(component->regmap, params->base,
 751                                data, len);
 752
 753 out:
 754         kfree(data);
 755
 756         return ret;
 757 }
 758 EXPORT_SYMBOL_GPL(snd_soc_bytes_put);
 759
 760 int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
 761                         struct snd_ctl_elem_info *ucontrol)
 762 {
 763         struct soc_bytes_ext *params = (void *)kcontrol->private_value;
 764
 765         ucontrol->type = SNDRV_CTL_ELEM_TYPE_BYTES;
 766         ucontrol->count = params->max;
 767
 768         return 0;
 769 }
 770 EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext);
 771
 772 int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
 773                                 unsigned int size, unsigned int __user *tlv)
 774 {
 775         struct soc_bytes_ext *params = (void *)kcontrol->private_value;
 776         unsigned int count = size < params->max ? size : params->max;
 777         int ret = -ENXIO;
 778
 779         switch (op_flag) {
 780         case SNDRV_CTL_TLV_OP_READ:
 781                 if (params->get)
 782                         ret = params->get(kcontrol, tlv, count);
 783                 break;
 784         case SNDRV_CTL_TLV_OP_WRITE:
 785                 if (params->put)
 786                         ret = params->put(kcontrol, tlv, count);
 787                 break;
 788         }
 789         return ret;
 790 }
 791 EXPORT_SYMBOL_GPL(snd_soc_bytes_tlv_callback);
 792
 793 /**
 794  * snd_soc_info_xr_sx - signed multi register info callback
 795  * @kcontrol: mreg control
 796  * @uinfo: control element information
 797  *
 798  * Callback to provide information of a control that can
 799  * span multiple codec registers which together
 800  * forms a single signed value in a MSB/LSB manner.
 801  *
 802  * Returns 0 for success.
 803  */
 804 int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
 805         struct snd_ctl_elem_info *uinfo)
 806 {
 807         struct soc_mreg_control *mc =
 808                 (struct soc_mreg_control *)kcontrol->private_value;
 809         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 810         uinfo->count = 1;
 811         uinfo->value.integer.min = mc->min;
 812         uinfo->value.integer.max = mc->max;
 813
 814         return 0;
 815 }
 816 EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx);
 817
 818 /**
 819  * snd_soc_get_xr_sx - signed multi register get callback
 820  * @kcontrol: mreg control
 821  * @ucontrol: control element information
 822  *
 823  * Callback to get the value of a control that can span
 824  * multiple codec registers which together forms a single
 825  * signed value in a MSB/LSB manner. The control supports
 826  * specifying total no of bits used to allow for bitfields
 827  * across the multiple codec registers.
 828  *
 829  * Returns 0 for success.
 830  */
 831 int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
 832         struct snd_ctl_elem_value *ucontrol)
 833 {
 834         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 835         struct soc_mreg_control *mc =
 836                 (struct soc_mreg_control *)kcontrol->private_value;
 837         unsigned int regbase = mc->regbase;
 838         unsigned int regcount = mc->regcount;
 839         unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
 840         unsigned int regwmask = (1<<regwshift)-1;
 841         unsigned int invert = mc->invert;
 842         unsigned long mask = (1UL<<mc->nbits)-1;
 843         long min = mc->min;
 844         long max = mc->max;
 845         long val = 0;
 846         unsigned int regval;
 847         unsigned int i;
 848         int ret;
 849
 850         for (i = 0; i < regcount; i++) {
 851                 ret = snd_soc_component_read(component, regbase+i, &regval);
 852                 if (ret)
 853                         return ret;
 854                 val |= (regval & regwmask) << (regwshift*(regcount-i-1));
 855         }
 856         val &= mask;
 857         if (min < 0 && val > max)
 858                 val |= ~mask;
 859         if (invert)
 860                 val = max - val;
 861         ucontrol->value.integer.value[0] = val;
 862
 863         return 0;
 864 }
 865 EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx);
 866
 867 /**
 868  * snd_soc_put_xr_sx - signed multi register get callback
 869  * @kcontrol: mreg control
 870  * @ucontrol: control element information
 871  *
 872  * Callback to set the value of a control that can span
 873  * multiple codec registers which together forms a single
 874  * signed value in a MSB/LSB manner. The control supports
 875  * specifying total no of bits used to allow for bitfields
 876  * across the multiple codec registers.
 877  *
 878  * Returns 0 for success.
 879  */
 880 int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
 881         struct snd_ctl_elem_value *ucontrol)
 882 {
 883         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 884         struct soc_mreg_control *mc =
 885                 (struct soc_mreg_control *)kcontrol->private_value;
 886         unsigned int regbase = mc->regbase;
 887         unsigned int regcount = mc->regcount;
 888         unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
 889         unsigned int regwmask = (1<<regwshift)-1;
 890         unsigned int invert = mc->invert;
 891         unsigned long mask = (1UL<<mc->nbits)-1;
 892         long max = mc->max;
 893         long val = ucontrol->value.integer.value[0];
 894         unsigned int i, regval, regmask;
 895         int err;
 896
 897         if (invert)
 898                 val = max - val;
 899         val &= mask;
 900         for (i = 0; i < regcount; i++) {
 901                 regval = (val >> (regwshift*(regcount-i-1))) & regwmask;
 902                 regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask;
 903                 err = snd_soc_component_update_bits(component, regbase+i,
 904                                 regmask, regval);
 905                 if (err < 0)
 906                         return err;
 907         }
 908
 909         return 0;
 910 }
 911 EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);
 912
 913 /**
 914  * snd_soc_get_strobe - strobe get callback
 915  * @kcontrol: mixer control
 916  * @ucontrol: control element information
 917  *
 918  * Callback get the value of a strobe mixer control.
 919  *
 920  * Returns 0 for success.
 921  */
 922 int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
 923         struct snd_ctl_elem_value *ucontrol)
 924 {
 925         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 926         struct soc_mixer_control *mc =
 927                 (struct soc_mixer_control *)kcontrol->private_value;
 928         unsigned int reg = mc->reg;
 929         unsigned int shift = mc->shift;
 930         unsigned int mask = 1 << shift;
 931         unsigned int invert = mc->invert != 0;
 932         unsigned int val;
 933         int ret;
 934
 935         ret = snd_soc_component_read(component, reg, &val);
 936         if (ret)
 937                 return ret;
 938
 939         val &= mask;
 940
 941         if (shift != 0 && val != 0)
 942                 val = val >> shift;
 943         ucontrol->value.enumerated.item[0] = val ^ invert;
 944
 945         return 0;
 946 }
 947 EXPORT_SYMBOL_GPL(snd_soc_get_strobe);
 948
 949 /**
 950  * snd_soc_put_strobe - strobe put callback
 951  * @kcontrol: mixer control
 952  * @ucontrol: control element information
 953  *
 954  * Callback strobe a register bit to high then low (or the inverse)
 955  * in one pass of a single mixer enum control.
 956  *
 957  * Returns 1 for success.
 958  */
 959 int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
 960         struct snd_ctl_elem_value *ucontrol)
 961 {
 962         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 963         struct soc_mixer_control *mc =
 964                 (struct soc_mixer_control *)kcontrol->private_value;
 965         unsigned int reg = mc->reg;
 966         unsigned int shift = mc->shift;
 967         unsigned int mask = 1 << shift;
 968         unsigned int invert = mc->invert != 0;
 969         unsigned int strobe = ucontrol->value.enumerated.item[0] != 0;
 970         unsigned int val1 = (strobe ^ invert) ? mask : 0;
 971         unsigned int val2 = (strobe ^ invert) ? 0 : mask;
 972         int err;
 973
 974         err = snd_soc_component_update_bits(component, reg, mask, val1);
 975         if (err < 0)
 976                 return err;
 977
 978         return snd_soc_component_update_bits(component, reg, mask, val2);
 979 }
 980 EXPORT_SYMBOL_GPL(snd_soc_put_strobe);