sound/soc/soc-ops.c

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