linux/sound/soc/soc-ops.c
<<
>>
Prefs
   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 */
  45int 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}
  53EXPORT_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 */
  64int 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_l) & 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}
  87EXPORT_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 */
  98int 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}
 120EXPORT_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 */
 137static 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 */
 186int 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}
 207EXPORT_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 */
 221int 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}
 235EXPORT_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 */
 247int 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}
 295EXPORT_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 */
 307int 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}
 357EXPORT_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 */
 369int 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}
 402EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx);
 403
 404/**
 405 * snd_soc_put_volsw_sx - double mixer set callback
 406 * @kcontrol: mixer control
 407 * @uinfo: 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 */
 413int 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}
 448EXPORT_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 */
 460int 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}
 479EXPORT_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 */
 490int 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}
 531EXPORT_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 */
 542int 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}
 586EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range);
 587
 588/**
 589 * snd_soc_limit_volume - Set new limit to an existing volume control.
 590 *
 591 * @codec: 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 */
 597int snd_soc_limit_volume(struct snd_soc_codec *codec,
 598        const char *name, int max)
 599{
 600        struct snd_card *card = codec->component.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, &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}
 625EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
 626
 627int 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}
 638EXPORT_SYMBOL_GPL(snd_soc_bytes_info);
 639
 640int 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}
 675EXPORT_SYMBOL_GPL(snd_soc_bytes_get);
 676
 677int 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
 753out:
 754        kfree(data);
 755
 756        return ret;
 757}
 758EXPORT_SYMBOL_GPL(snd_soc_bytes_put);
 759
 760int 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}
 770EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext);
 771
 772int 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(tlv, count);
 783                break;
 784        case SNDRV_CTL_TLV_OP_WRITE:
 785                if (params->put)
 786                        ret = params->put(tlv, count);
 787                break;
 788        }
 789        return ret;
 790}
 791EXPORT_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 */
 804int 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}
 816EXPORT_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 */
 831int 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}
 865EXPORT_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 */
 880int 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}
 911EXPORT_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 */
 922int 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}
 947EXPORT_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 */
 959int 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}
 980EXPORT_SYMBOL_GPL(snd_soc_put_strobe);
 981