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