sound/soc/soc-ops.c

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