drivers/spi/tsc2301-mixer.c

   1 /*
   2  * ALSA Mixer implementation for TSC2301
   3  *
   4  * Copyright (C) 2006 Nokia Corporation.
   5  *
   6  * Contact: Jarkko Nikula <jarkko.nikula@nokia.com>
   7  *          Juha Yrjola
   8  *
   9  * Some notes about TSC2301:
  10  * - PLL will stop when DAC and ADC's are powered down.
  11  * - Touchscreen will stop working when audio part is powered up and if audio
  12  *   MCLK is stopped. Problem is avoided if audio is powered down before
  13  *   stopping MCLK.
  14  * - Audio DAC or audio outputs will activate only after 100 msec from the
  15  *   chip power-up. Reason seems to be VCM since there is no this delay if the
  16  *   chip and VCM (bit AVPD on PD/MISC) were not powered down. The chip will
  17  *   consume about 1 mA if all other audio blocks are powered down except the
  18  *   chip itself and VCM. Full power down consumes only about few uA.
  19  * - Power-down transition could happen earliest about 100 msec after the chip
  20  *   power-up. Otherwise power-down will fail if there is no that 100 msec
  21  *   on time before it. It's not obvious why is that since chip reports
  22  *   power-up to be completed and also PLL output on GPIO_0 is active in few
  23  *   milliseconds.
  24  *
  25  * This program is free software; you can redistribute it and/or
  26  * modify it under the terms of the GNU General Public License
  27  * version 2 as published by the Free Software Foundation.
  28  *
  29  * This program is distributed in the hope that it will be useful, but
  30  * WITHOUT ANY WARRANTY; without even the implied warranty of
  31  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  32  * General Public License for more details.
  33  *
  34  * You should have received a copy of the GNU General Public License
  35  * along with this program; if not, write to the Free Software
  36  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  37  * 02110-1301 USA
  38  *
  39  */
  40
  41 #include <linux/module.h>
  42 #include <linux/device.h>
  43 #include <linux/errno.h>
  44 #include <linux/delay.h>
  45 #include <linux/slab.h>
  46 #include <linux/spi/spi.h>
  47 #include <linux/spi/tsc2301.h>
  48
  49 #include <sound/driver.h>
  50 #include <sound/core.h>
  51 #include <sound/control.h>
  52
  53 /* shadow register indexes */
  54 enum {
  55         /* audio control and volume registers */
  56         AUDCNTL_INDEX,
  57         ADCVOL_INDEX,
  58         DACVOL_INDEX,
  59         BPVOL_INDEX,
  60         /* keyclick control register (not needed here) */
  61         /* audio power control register */
  62         PD_MISC_INDEX,
  63         /* TSC2301 GPIO control register */
  64         GPIO_INDEX,
  65
  66         SHADOW_REG_COUNT,
  67 };
  68
  69 /* structure for driver private data */
  70 struct tsc2301_mixer {
  71         struct tsc2301 *tsc;
  72         struct mutex mutex;
  73
  74         /* shadow registers holding TSC2301 audio registers. Used to hold
  75          * their states during the sleep and also to reduce communication with
  76          * the chip since get callback functions could get register values
  77          * directly from these shadow registers without needing to read them
  78          * from the chip */
  79         u16 shadow_regs[SHADOW_REG_COUNT];
  80
  81         /* audio controller driver usage of the ADC and DAC */
  82         unsigned adc_enabled:1, dac_enabled:1;
  83         unsigned pll_output:1;
  84         unsigned mclk_enabled;
  85
  86         /* latest audio power-up timestamp */
  87         unsigned long pu_jiffies;
  88
  89         /* these are used when upper layer(s) are going to power-down TSC2301
  90          * before 100 msec is passed from power-up */
  91         struct delayed_work delayed_power_down;
  92         unsigned delayed_pd_active:1;
  93
  94         int (* platform_init)(struct device *);
  95         void (* platform_cleanup)(struct device *);
  96
  97         struct tsc2301_mixer_gpio *mixer_gpios;
  98         int n_mixer_gpios;
  99 };
 100
 101 #define TSC2301_DAC_DELAY               msecs_to_jiffies(100)
 102 #define TSC2301_MIN_PU_PERIOD           msecs_to_jiffies(100)
 103
 104 #define TSC2301_REG_TO_PVAL(reg)        \
 105         (TSC2301_REG_TO_PAGE(reg) << 6 | TSC2301_REG_TO_ADDR(reg))
 106 #define  TSC2301_PVAL_TO_REG(v)         \
 107         (TSC2301_REG((((v) >> 6) & 3),((v) & 0x1f)))
 108
 109 #define TSC2301_VOLUME_MASK             0x7f
 110 #define TSC2301_MIN_ADCVOL              6
 111 #define TSC2301_MIN_DACVOL              0
 112 #define TSC2301_MIN_BPVOL               31
 113 #define TSC2301_MUTE_LEFT_SHIFT         15
 114 #define TSC2301_VOL_LEFT_SHIFT          8
 115 #define TSC2301_MUTE_RIGHT_SHIFT        7
 116 #define TSC2301_VOL_RIGHT_SHIFT         0
 117
 118 #define TSC2301_INM_MASK                3
 119 #define TSC2301_INML_SHIFT              12
 120 #define TSC2301_INMR_SHIFT              10
 121
 122 #define TSC2301_MICG_MASK               3
 123 #define TSC2301_MICG_MIN                1 /* values 0 & 1 both mean 0 dB */
 124 #define TSC2301_MICG_SHIFT              8
 125
 126 #define TSC2301_REG_AUDCNTL_MCLK(v)     (((v) & 3) << 6)
 127 #define TSC2301_REG_AUDCNTL_I2SFS(v)    (((v) & 0xf) << 2)
 128 #define TSC2301_REG_AUDCNTL_I2SFM(v)    (((v) & 3) << 0)
 129
 130 #define TSC2301_SINGLE(xname, xindex, reg, shadow_index, shift, mask, min) \
 131 {\
 132         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 133         .name = xname, \
 134         .index = xindex, \
 135         .info = snd_tsc2301_info_single, \
 136         .get = snd_tsc2301_get_single, \
 137         .put = snd_tsc2301_put_single, \
 138         .private_value = TSC2301_REG_TO_PVAL(reg) | \
 139                 (shadow_index << 8) | (shift << 16) | (mask << 24) | \
 140                 (min << 28) \
 141 }
 142 #define TSC2301_SINGLE_MINVAL(v)        (((v) >> 28) & 15)
 143 #define TSC2301_SINGLE_SHIFT(v)         (((v) >> 16) & 15)
 144 #define TSC2301_SINGLE_MASK(v)          (((v) >> 24) & 15)
 145
 146 #define TSC2301_DOUBLE(xname, xindex, reg, shadow_index, ls, rs, mask, min) \
 147 {\
 148         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 149         .name = xname, \
 150         .index = xindex, \
 151         .info = snd_tsc2301_info_double, \
 152         .get = snd_tsc2301_get_double, \
 153         .put = snd_tsc2301_put_double, \
 154         .private_value = TSC2301_REG_TO_PVAL(reg) | \
 155                 (shadow_index << 8) | (min << 11) | \
 156                 (ls << 16) | (rs << 20) | (mask << 24) \
 157 }
 158 #define TSC2301_DOUBLE_MINVAL(v)        (((v) >> 11) & 0x1f)
 159 #define TSC2301_DOUBLE_LEFT_SHIFT(v)    (((v) >> 16) & 15)
 160 #define TSC2301_DOUBLE_RIGHT_SHIFT(v)   (((v) >> 20) & 15)
 161 #define TSC2301_DOUBLE_MASK(v)          (((v) >> 24) & TSC2301_VOLUME_MASK)
 162
 163 #define TSC2301_MUX(xname, xindex, reg, shadow_index, ls, rs, mask) \
 164 {\
 165         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 166         .name = xname, \
 167         .index = xindex, \
 168         .info = snd_tsc2301_info_mux, \
 169         .get = snd_tsc2301_get_mux, \
 170         .put = snd_tsc2301_put_mux, \
 171         .private_value = TSC2301_REG_TO_PVAL(reg) | \
 172                 (shadow_index << 8) | (ls << 16) | (rs << 20) | (mask << 24) \
 173 }
 174 #define TSC2301_MUX_LEFT_SHIFT(v)       (((v) >> 16) & 15)
 175 #define TSC2301_MUX_RIGHT_SHIFT(v)      (((v) >> 20) & 15)
 176 #define TSC2301_MUX_MASK(v)             (((v) >> 24) & TSC2301_VOLUME_MASK)
 177
 178 #define TSC2301_BOOL(xname, xindex, reg, shadow_index, shift, invert, state) \
 179 { \
 180         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 181         .name = xname, \
 182         .index = xindex, \
 183         .info = snd_tsc2301_info_bool, \
 184         .get = snd_tsc2301_get_bool, \
 185         .put = snd_tsc2301_put_bool, \
 186         .private_value = TSC2301_REG_TO_PVAL(reg) | \
 187                 (shadow_index << 8) | (shift << 16) | \
 188                 (invert << 24) | (state << 25) \
 189 }
 190 #define TSC2301_BOOL_SHIFT(v)           (((v) >> 16) & 7)
 191 #define TSC2301_BOOL_INVERT(v)          (((v) >> 24) & 1)
 192 #define TSC2301_BOOL_STATE(v)           (((v) >> 25) & 1)
 193
 194 #define TSC2301_SHADOW_INDEX(v)         (((v) >> 8) & 7)
 195
 196 /*
 197  * Power-down handler for additional GPIO mixer controls. GPIO state of GPIO
 198  * controls whose power-down flag is enabled are set to their false/deactivate
 199  * state
 200  *
 201  * Must be called tsc->mixer->mutex locked
 202  */
 203 static void tsc2301_gpio_power_down(struct tsc2301 *tsc)
 204 {
 205         struct tsc2301_mixer *mix = tsc->mixer;
 206         u16 temp;
 207         int i;
 208
 209         temp = mix->shadow_regs[GPIO_INDEX];
 210         for (i = 0; i < mix->n_mixer_gpios; i++) {
 211                 const struct tsc2301_mixer_gpio *mg;
 212
 213                 mg = mix->mixer_gpios + i;
 214                 if (mg->deactivate_on_pd) {
 215                         int gpio = mg->gpio;
 216
 217                         temp &= ~(1 << gpio);
 218                         temp |= mg->inverted << gpio;
 219                 }
 220         }
 221         tsc2301_write_reg(tsc, TSC2301_REG_GPIO, temp);
 222 }
 223
 224 /*
 225  * Powers down/up audio blocks which are muted or become unused.
 226  * shadow_index >= 0, changes power state of single audio block
 227  * shadow_index < 0, changes power state of all blocks
 228  *
 229  * Must be called tsc->mixer->mutex locked
 230  */
 231 #define TSC2301_MUTE_MASK \
 232         ((1 << TSC2301_MUTE_LEFT_SHIFT) | (1 << TSC2301_MUTE_RIGHT_SHIFT))
 233 static void tsc2301_power_ctrl(struct tsc2301 *tsc, int shadow_index,
 234                                int poll_pdsts)
 235 {
 236         struct tsc2301_mixer *mix = tsc->mixer;
 237         u16 pd_ctrl, pd_ctrl_old, w;
 238         unsigned long timeout;
 239         int power_up = 0;
 240
 241         if (mix->delayed_pd_active) {
 242                 mix->delayed_pd_active = 0;
 243                 mix->mclk_enabled--;
 244                 cancel_delayed_work(&mix->delayed_power_down);
 245         }
 246
 247         pd_ctrl = pd_ctrl_old = mix->shadow_regs[PD_MISC_INDEX];
 248         /* power control helper based on used space mixer selections. See
 249          * actual power control decisions below */
 250         if (shadow_index < 0 || shadow_index == ADCVOL_INDEX) {
 251                 /* ADC left and right power down control */
 252                 if (mix->shadow_regs[ADCVOL_INDEX] &
 253                     (1 << TSC2301_MUTE_LEFT_SHIFT))
 254                         /* left ADC muted. Power down the left ADC */
 255                         pd_ctrl |= TSC2301_REG_PD_MISC_ADPDL;
 256                 else
 257                         pd_ctrl &= ~TSC2301_REG_PD_MISC_ADPDL;
 258                 if (mix->shadow_regs[ADCVOL_INDEX] &
 259                     (1 << TSC2301_MUTE_LEFT_SHIFT))
 260                         /* right ADC muted. Power down the right ADC */
 261                         pd_ctrl |= TSC2301_REG_PD_MISC_ADPDR;
 262                 else
 263                         pd_ctrl &= ~TSC2301_REG_PD_MISC_ADPDR;
 264         }
 265         if (shadow_index < 0 || shadow_index == DACVOL_INDEX) {
 266                 /* DAC power down control */
 267                 if ((mix->shadow_regs[DACVOL_INDEX] &
 268                      TSC2301_MUTE_MASK) == TSC2301_MUTE_MASK)
 269                         /* both DACs muted. Power down the DAC */
 270                         pd_ctrl |= TSC2301_REG_PD_MISC_DAPD;
 271                 else
 272                         pd_ctrl &= ~TSC2301_REG_PD_MISC_DAPD;
 273         }
 274         if (shadow_index < 0 || shadow_index == BPVOL_INDEX) {
 275                 /* line bypass power down control */
 276                 if ((mix->shadow_regs[BPVOL_INDEX] &
 277                      TSC2301_MUTE_MASK) == TSC2301_MUTE_MASK)
 278                         /* both line bypasses muted. Power down the bypass
 279                          * path */
 280                         pd_ctrl |= TSC2301_REG_PD_MISC_ABPD;
 281                 else
 282                         pd_ctrl &= ~TSC2301_REG_PD_MISC_ABPD;
 283         }
 284         if (shadow_index < 0 || shadow_index == AUDCNTL_INDEX) {
 285                 /* mic bias power down control */
 286                 if ((mix->shadow_regs[AUDCNTL_INDEX] &
 287                      (3 << TSC2301_INML_SHIFT)) &&
 288                     (mix->shadow_regs[AUDCNTL_INDEX] &
 289                      (3 << TSC2301_INMR_SHIFT)))
 290                         /* both ADC channels use other than mic input. Power
 291                          * down the mic bias output */
 292                         pd_ctrl |= TSC2301_REG_PD_MISC_MIBPD;
 293                 else
 294                         pd_ctrl &= ~TSC2301_REG_PD_MISC_MIBPD;
 295         }
 296
 297         /* power control decisions based on codec usage and user space mixer
 298          * selections detected above */
 299         pd_ctrl &= ~TSC2301_REG_PD_MISC_APD; /* audio not powered down */
 300         if (mix->mclk_enabled) {
 301                 if (!mix->adc_enabled) {
 302                         /* ADC not used, power down both ADC's and mic bias
 303                          * output independently of user space mixer
 304                          * selections */
 305                         pd_ctrl |= TSC2301_REG_PD_MISC_ADPDL;
 306                         pd_ctrl |= TSC2301_REG_PD_MISC_ADPDR;
 307                         pd_ctrl |= TSC2301_REG_PD_MISC_MIBPD;
 308                 }
 309                 if (!mix->dac_enabled) {
 310                         /* DAC not used, power down DAC independently of user
 311                          * space mixer selections */
 312                         pd_ctrl |= TSC2301_REG_PD_MISC_DAPD;
 313                 }
 314
 315                 if (mix->pll_output) {
 316                         /* GPIO_0 is configured as PLL output so audio
 317                          * controller is expecting clock from TSC2301. Either
 318                          * ADC or DAC must be active in order to keep PLL on */
 319                         if ((pd_ctrl & TSC2301_REG_PD_MISC_ADPDL) &&
 320                             (pd_ctrl & TSC2301_REG_PD_MISC_ADPDR) &&
 321                             (pd_ctrl & TSC2301_REG_PD_MISC_DAPD)) {
 322                                 /* neither ADC or DAC used. Force ADC on in
 323                                  * order to keep PLL active */
 324                                 pd_ctrl &= ~(TSC2301_REG_PD_MISC_ADPDL |
 325                                              TSC2301_REG_PD_MISC_ADPDR);
 326                         }
 327                 }
 328         } else {
 329                 /* audio input clock is not enabled so power down DAC and ADC
 330                  * in order to shutdown PLL and to keep touchscreen and keypad
 331                  * parts working. Touchscreen and keypad use audio clock when
 332                  * PLL is on and internal clock otherwise */
 333                 pd_ctrl |= TSC2301_REG_PD_MISC_DAPD |
 334                            TSC2301_REG_PD_MISC_ADPDL |
 335                            TSC2301_REG_PD_MISC_ADPDR;
 336         }
 337
 338         if ((pd_ctrl & TSC2301_REG_PD_MISC_ADPDL) &&
 339             (pd_ctrl & TSC2301_REG_PD_MISC_ADPDR) &&
 340             (pd_ctrl & TSC2301_REG_PD_MISC_DAPD) &&
 341             (pd_ctrl & TSC2301_REG_PD_MISC_ABPD)) {
 342                 /* all ADC, DAC and line bypass path unused. Power down the
 343                  * whole audio part of the TSC2301 */
 344                 pd_ctrl |= TSC2301_REG_PD_MISC_APD;
 345         }
 346
 347         if (pd_ctrl == pd_ctrl_old)
 348                 return;
 349
 350         /* power down control changed. Update into TSC2301 */
 351         if ((pd_ctrl ^ pd_ctrl_old) & TSC2301_REG_PD_MISC_APD) {
 352                 /* whole audio power state changed. Update GPIO states */
 353                 if (pd_ctrl & TSC2301_REG_PD_MISC_APD) {
 354                         /* power down GPIO controls before powering down
 355                          * the codec */
 356                         tsc2301_gpio_power_down(tsc);
 357                         /* we must really ensure that codec has been on no less
 358                          * than 100 msec before doing power-down */
 359                         timeout = mix->pu_jiffies + TSC2301_MIN_PU_PERIOD -
 360                                   jiffies;
 361                         if (timeout <= TSC2301_MIN_PU_PERIOD) {
 362                                 mix->delayed_pd_active = 1;
 363                                 mix->mclk_enabled++;
 364                                 schedule_delayed_work(&mix->delayed_power_down,
 365                                                       timeout + 1);
 366                                 return;
 367                         }
 368                 } else
 369                         /* restore GPIOs after codec is powered up */
 370                         power_up = 1;
 371         }
 372         mix->shadow_regs[PD_MISC_INDEX] = pd_ctrl;
 373         tsc2301_write_reg(tsc, TSC2301_REG_PD_MISC, pd_ctrl);
 374         if (power_up)
 375                 mix->pu_jiffies = jiffies;
 376         if (!poll_pdsts) {
 377                 if (power_up)
 378                         tsc2301_write_reg(tsc, TSC2301_REG_GPIO,
 379                                           mix->shadow_regs[GPIO_INDEX]);
 380                 return;
 381         }
 382
 383         /* wait until power-up/-down is completed */
 384         timeout = jiffies + msecs_to_jiffies(100);
 385         w = 0;
 386         do {
 387                 if (time_after(jiffies, timeout)) {
 388                         /* Print a warning only if the I2S clock is not
 389                          * present / out of sync. This can happen during
 390                          * init time, when that clock will be turned on
 391                          * by another driver like in the OMAP EAC with
 392                          * external clock case.
 393                          */
 394                         if (w & TSC2301_REG_PD_MISC_OTSYN) {
 395                                 dev_warn(&tsc->spi->dev,
 396                                    "I2S clock not in sync or off.\n");
 397                         } else {
 398                                 dev_err(&tsc->spi->dev,
 399                                    "power-up/-down timed out "
 400                                    "(0x%04x, 0x%04x -> 0x%04x)\n",
 401                                    w, pd_ctrl_old, pd_ctrl);
 402                         }
 403                         goto out;
 404                 }
 405                 w = tsc2301_read_reg(tsc, TSC2301_REG_PD_MISC);
 406         } while (!(w & TSC2301_REG_PD_MISC_PDSTS));
 407
 408 out:
 409         if (((pd_ctrl ^ pd_ctrl_old) & TSC2301_REG_PD_MISC_DAPD) &&
 410             !(pd_ctrl & TSC2301_REG_PD_MISC_DAPD)) {
 411                 /* DAC powered up now. Ensure that DAC and audio outputs are
 412                  * activated. They are up 100 msec after the chip power-up
 413                  * command */
 414                 timeout = mix->pu_jiffies + TSC2301_DAC_DELAY - jiffies;
 415                 if (timeout <= TSC2301_DAC_DELAY)
 416                         schedule_timeout_interruptible(timeout);
 417                 /* FIXME: This is lazy. We restore GPIOs only after activating
 418                  * the DAC. It would be better to do some kind of delayed GPIO
 419                  * restore. That ensures that we restore them also if only ADC
 420                  * path is activated. But this is required only if there is
 421                  * some input amplifier, bias control, etc. and their power
 422                  * state is under TSC GPIO control */
 423                 tsc2301_write_reg(tsc, TSC2301_REG_GPIO,
 424                                   mix->shadow_regs[GPIO_INDEX]);
 425         }
 426 }
 427
 428 static int snd_tsc2301_info_single(struct snd_kcontrol *kcontrol,
 429                                    struct snd_ctl_elem_info *uinfo)
 430 {
 431         int mask = TSC2301_SINGLE_MASK(kcontrol->private_value);
 432         int minval = TSC2301_SINGLE_MINVAL(kcontrol->private_value);
 433
 434         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 435         uinfo->count = 1;
 436         uinfo->value.integer.min = minval;
 437         uinfo->value.integer.max = mask;
 438
 439         return 0;
 440 }
 441
 442 static int snd_tsc2301_get_single(struct snd_kcontrol *kcontrol,
 443                                   struct snd_ctl_elem_value *ucontrol)
 444 {
 445         struct tsc2301 *tsc = kcontrol->private_data;
 446         unsigned long priv = kcontrol->private_value;
 447         int mask = TSC2301_SINGLE_MASK(priv);
 448         int shift = TSC2301_SINGLE_SHIFT(priv);
 449         int shadow_index = TSC2301_SHADOW_INDEX(priv);
 450         u16 shadow_reg;
 451
 452         shadow_reg = tsc->mixer->shadow_regs[shadow_index];
 453
 454         ucontrol->value.integer.value[0] = (shadow_reg >> shift) & mask;
 455
 456         return 0;
 457 }
 458
 459 static int snd_tsc2301_put_single(struct snd_kcontrol *kcontrol,
 460                                   struct snd_ctl_elem_value *ucontrol)
 461 {
 462         struct tsc2301 *tsc = kcontrol->private_data;
 463         unsigned long priv = kcontrol->private_value;
 464         int mask = TSC2301_SINGLE_MASK(priv);
 465         int shadow_index = TSC2301_SHADOW_INDEX(priv);
 466         u16 shadow_reg, shadow_reg_old;
 467         int shift = TSC2301_SINGLE_SHIFT(priv);
 468         int reg = TSC2301_PVAL_TO_REG(priv);
 469         int changed;
 470
 471         mutex_lock(&tsc->mixer->mutex);
 472         shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
 473
 474         /* zero bits to be modified */
 475         shadow_reg &= ~(mask << shift);
 476         /* modify with new value */
 477         shadow_reg |= ((ucontrol->value.integer.value[0] & mask) << shift);
 478
 479         changed = (shadow_reg != shadow_reg_old);
 480         tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
 481
 482         /* update into TSC2301 if necessary */
 483         if (changed)
 484                 tsc2301_write_reg(tsc, reg, shadow_reg);
 485         mutex_unlock(&tsc->mixer->mutex);
 486
 487         return changed;
 488 }
 489
 490 static int snd_tsc2301_info_double(struct snd_kcontrol *kcontrol,
 491                                    struct snd_ctl_elem_info *uinfo)
 492 {
 493         /* mask == 1 : Switch
 494          * mask > 1 : Max volume */
 495         int mask = TSC2301_DOUBLE_MASK(kcontrol->private_value);
 496         int minval = TSC2301_DOUBLE_MINVAL(kcontrol->private_value);
 497
 498         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN :
 499                 SNDRV_CTL_ELEM_TYPE_INTEGER;
 500         uinfo->count = 2;
 501         uinfo->value.integer.min = minval;
 502         uinfo->value.integer.max = mask;
 503
 504         return 0;
 505 }
 506
 507 static int snd_tsc2301_get_double(struct snd_kcontrol *kcontrol,
 508                                   struct snd_ctl_elem_value *ucontrol)
 509 {
 510         struct tsc2301 *tsc = kcontrol->private_data;
 511         unsigned long priv = kcontrol->private_value;
 512         /* mask == 1 : Switch
 513          * mask > 1 : Volume */
 514         int mask = TSC2301_DOUBLE_MASK(priv);
 515         int ls = TSC2301_DOUBLE_LEFT_SHIFT(priv);
 516         int rs = TSC2301_DOUBLE_RIGHT_SHIFT(priv);
 517         int shadow_index = TSC2301_SHADOW_INDEX(priv);
 518         u16 shadow_reg;
 519
 520         shadow_reg = tsc->mixer->shadow_regs[shadow_index];
 521
 522         /* invert mute bits for the switches */
 523         if (mask == 1)
 524                 shadow_reg = ~shadow_reg;
 525
 526         ucontrol->value.integer.value[0] = (shadow_reg >> ls) & mask;
 527         ucontrol->value.integer.value[1] = (shadow_reg >> rs) & mask;
 528
 529         return 0;
 530 }
 531
 532 static int snd_tsc2301_put_double(struct snd_kcontrol *kcontrol,
 533                                   struct snd_ctl_elem_value *ucontrol)
 534 {
 535         struct tsc2301 *tsc = kcontrol->private_data;
 536         unsigned long priv = kcontrol->private_value;
 537         /* mask == 1 : Switch
 538          * mask > 1 : Volume */
 539         int mask = TSC2301_DOUBLE_MASK(priv);
 540         int shadow_index = TSC2301_SHADOW_INDEX(priv);
 541         u16 shadow_reg, shadow_reg_old;
 542         int ls = TSC2301_DOUBLE_LEFT_SHIFT(priv);
 543         int rs = TSC2301_DOUBLE_RIGHT_SHIFT(priv);
 544         int reg = TSC2301_PVAL_TO_REG(priv);
 545         int changed;
 546
 547         mutex_lock(&tsc->mixer->mutex);
 548         shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
 549
 550         /* zero bits to be modified */
 551         shadow_reg &= ~((mask << ls) | (mask << rs));
 552         /* modify with new value */
 553         if (mask == 1) {
 554                 /* switch. Invert switch values for the mute bits */
 555                 shadow_reg |=
 556                         ((~ucontrol->value.integer.value[0] & mask) << ls) |
 557                         ((~ucontrol->value.integer.value[1] & mask) << rs);
 558         } else {
 559                 /* volume */
 560                 shadow_reg |=
 561                         (ucontrol->value.integer.value[0] << ls) |
 562                         (ucontrol->value.integer.value[1] << rs);
 563         }
 564
 565         changed = (shadow_reg != shadow_reg_old);
 566         tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
 567
 568         /* update into TSC2301 if necessary */
 569         if (changed)
 570                 tsc2301_write_reg(tsc, reg, shadow_reg);
 571
 572         if (mask == 1)
 573                 /* check is need to power down/up audio blocks in case of
 574                  * muted state change */
 575                 tsc2301_power_ctrl(tsc, shadow_index, 0);
 576         mutex_unlock(&tsc->mixer->mutex);
 577
 578         return changed;
 579 }
 580
 581 static int snd_tsc2301_info_mux(struct snd_kcontrol *kcontrol,
 582                                 struct snd_ctl_elem_info *uinfo)
 583 {
 584         static char *texts[4] = {"Mic", "Line", "Line swapped", "Line mono"};
 585
 586         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 587         uinfo->count = 2;
 588         uinfo->value.enumerated.items = 4;
 589         if (uinfo->value.enumerated.item > 3)
 590                 uinfo->value.enumerated.item = 3;
 591         strcpy(uinfo->value.enumerated.name,
 592                texts[uinfo->value.enumerated.item]);
 593
 594         return 0;
 595 }
 596
 597 static int snd_tsc2301_get_mux(struct snd_kcontrol *kcontrol,
 598                                struct snd_ctl_elem_value *ucontrol)
 599 {
 600         struct tsc2301 *tsc = kcontrol->private_data;
 601         unsigned long priv = kcontrol->private_value;
 602         int mask = TSC2301_MUX_MASK(priv);
 603         int ls = TSC2301_MUX_LEFT_SHIFT(priv);
 604         int rs = TSC2301_MUX_RIGHT_SHIFT(priv);
 605         int shadow_index = TSC2301_SHADOW_INDEX(priv);
 606         u16 shadow_reg;
 607
 608         shadow_reg = tsc->mixer->shadow_regs[shadow_index];
 609         ucontrol->value.enumerated.item[0] = (shadow_reg >> ls) & mask;
 610         ucontrol->value.enumerated.item[1] = (shadow_reg >> rs) & mask;
 611
 612         return 0;
 613 }
 614
 615 static int snd_tsc2301_put_mux(struct snd_kcontrol *kcontrol,
 616                                struct snd_ctl_elem_value *ucontrol)
 617 {
 618         struct tsc2301 *tsc = kcontrol->private_data;
 619         unsigned long priv = kcontrol->private_value;
 620         int mask = TSC2301_MUX_MASK(priv);
 621         int shadow_index = TSC2301_SHADOW_INDEX(priv);
 622         u16 shadow_reg, shadow_reg_old;
 623         int ls = TSC2301_MUX_LEFT_SHIFT(priv);
 624         int rs = TSC2301_MUX_RIGHT_SHIFT(priv);
 625         int reg = TSC2301_PVAL_TO_REG(priv);
 626         int changed;
 627
 628         mutex_lock(&tsc->mixer->mutex);
 629         shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
 630
 631         /* zero bits to be modified */
 632         shadow_reg &= ~((mask << ls) | (mask << rs));
 633         /* modify with new value */
 634         shadow_reg |= (ucontrol->value.enumerated.item[0] << ls);
 635         shadow_reg |= (ucontrol->value.enumerated.item[1] << rs);
 636
 637         changed = (shadow_reg != shadow_reg_old);
 638
 639         /* update into TSC2301 if necessary */
 640         if (changed) {
 641                 tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
 642                 tsc2301_write_reg(tsc, reg, shadow_reg);
 643         }
 644
 645         /* check is need to power up/down audio blocks in case of ADC input
 646          * change */
 647         tsc2301_power_ctrl(tsc, shadow_index, 0);
 648         mutex_unlock(&tsc->mixer->mutex);
 649
 650         return changed;
 651 }
 652
 653 static int snd_tsc2301_info_bool(struct snd_kcontrol *kcontrol,
 654                                  struct snd_ctl_elem_info *uinfo)
 655 {
 656         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 657         uinfo->count = 1;
 658         uinfo->value.integer.min = 0;
 659         uinfo->value.integer.max = 1;
 660
 661         return 0;
 662 }
 663
 664 static int snd_tsc2301_get_bool(struct snd_kcontrol *kcontrol,
 665                                 struct snd_ctl_elem_value *ucontrol)
 666 {
 667         struct tsc2301 *tsc = kcontrol->private_data;
 668         unsigned long priv = kcontrol->private_value;
 669         int shadow_index = TSC2301_SHADOW_INDEX(priv);
 670         int shift = TSC2301_BOOL_SHIFT(priv);
 671         int invert = TSC2301_BOOL_INVERT(priv);
 672         u16 shadow_reg;
 673
 674         shadow_reg = tsc->mixer->shadow_regs[shadow_index];
 675         ucontrol->value.integer.value[0] =
 676                 invert ^ ((shadow_reg >> shift) & 1);
 677
 678         return 0;
 679 }
 680
 681 static int snd_tsc2301_put_bool(struct snd_kcontrol *kcontrol,
 682                                 struct snd_ctl_elem_value *ucontrol)
 683 {
 684         struct tsc2301 *tsc = kcontrol->private_data;
 685         unsigned long priv = kcontrol->private_value;
 686         int shadow_index = TSC2301_SHADOW_INDEX(priv);
 687         int shift = TSC2301_BOOL_SHIFT(priv);
 688         int invert = TSC2301_BOOL_INVERT(priv);
 689         int reg = TSC2301_PVAL_TO_REG(priv);
 690         u16 shadow_reg, shadow_reg_old;
 691         int changed;
 692
 693         mutex_lock(&tsc->mixer->mutex);
 694         shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
 695
 696         /* zero bit to be modified */
 697         shadow_reg &= ~(1 << shift);
 698         /* modify with new value */
 699         shadow_reg |=
 700                 (invert ^ (ucontrol->value.integer.value[0] & 1)) << shift;
 701
 702         changed = (shadow_reg != shadow_reg_old);
 703
 704         /* update into TSC2301 if necessary */
 705         if (changed) {
 706                 tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
 707                 if ((shadow_index == GPIO_INDEX) &&
 708                     (tsc->mixer->shadow_regs[PD_MISC_INDEX] &
 709                      TSC2301_REG_PD_MISC_APD)) {
 710                         /* changing GPIO control and audio is powered down.
 711                          * Update GPIO states according to their power-down
 712                          * flag */
 713                         tsc2301_gpio_power_down(tsc);
 714                 } else
 715                         tsc2301_write_reg(tsc, reg, shadow_reg);
 716         }
 717         mutex_unlock(&tsc->mixer->mutex);
 718
 719         return changed;
 720 }
 721
 722 /* TSC2301 internal mixer controls */
 723 static struct snd_kcontrol_new snd_tsc2301_controls[] = {
 724         /* stereo ADC input switches and volumes */
 725         TSC2301_DOUBLE("Capture Switch", 0,
 726                 TSC2301_REG_ADCVOL, ADCVOL_INDEX,
 727                 TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
 728                 1, 0),
 729         TSC2301_DOUBLE("Capture Volume", 0,
 730                 TSC2301_REG_ADCVOL, ADCVOL_INDEX,
 731                 TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
 732                 TSC2301_VOLUME_MASK, TSC2301_MIN_ADCVOL),
 733
 734         /* stereo DAC output switches and volumes */
 735         TSC2301_DOUBLE("PCM Playback Switch", 0,
 736                 TSC2301_REG_DACVOL, DACVOL_INDEX,
 737                 TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
 738                 1, 0),
 739         TSC2301_DOUBLE("PCM Playback Volume", 0,
 740                 TSC2301_REG_DACVOL, DACVOL_INDEX,
 741                 TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
 742                 TSC2301_VOLUME_MASK, TSC2301_MIN_DACVOL),
 743
 744         /* stereo line input bypass switches and volumes */
 745         TSC2301_DOUBLE("Line Playback Switch", 0,
 746                 TSC2301_REG_BPVOL, BPVOL_INDEX,
 747                 TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
 748                 1, 0),
 749         TSC2301_DOUBLE("Line Playback Volume", 0,
 750                 TSC2301_REG_BPVOL, BPVOL_INDEX,
 751                 TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
 752                 TSC2301_VOLUME_MASK, TSC2301_MIN_BPVOL),
 753
 754         /* mono microphone input gain */
 755         TSC2301_SINGLE("Mic Boost", 0,
 756                 TSC2301_REG_AUDCNTL, AUDCNTL_INDEX,
 757                 TSC2301_MICG_SHIFT,
 758                 TSC2301_MICG_MASK, TSC2301_MICG_MIN),
 759
 760         /* ADC input sources. Both channels could be selected separately */
 761         TSC2301_MUX("Capture Source", 0,
 762                 TSC2301_REG_AUDCNTL, AUDCNTL_INDEX,
 763                 TSC2301_INML_SHIFT, TSC2301_INMR_SHIFT,
 764                 TSC2301_INM_MASK),
 765 };
 766
 767 /* must be called tsc->mixer->mutex locked */
 768 static void tsc2301_flush_shadow_regs(struct tsc2301 *tsc)
 769 {
 770         int i, page, addr;
 771         u16 temp;
 772
 773         page = TSC2301_REG_TO_PAGE(TSC2301_REG_AUDCNTL);
 774         addr = TSC2301_REG_TO_ADDR(TSC2301_REG_AUDCNTL);
 775
 776         for (i = 0; i < 4; i++) {
 777                 temp = tsc->mixer->shadow_regs[i];
 778                 tsc2301_write_reg(tsc, TSC2301_REG(page, addr + i), temp);
 779         }
 780         temp = tsc->mixer->shadow_regs[GPIO_INDEX];
 781         tsc2301_write_reg(tsc, TSC2301_REG_GPIO, temp);
 782
 783         /* Update power state of all audio blocks depending are they
 784          * muted or unused. */
 785         tsc2301_power_ctrl(tsc, -1, 0);
 786 }
 787
 788 #ifdef CONFIG_PM
 789 int tsc2301_mixer_suspend(struct tsc2301 *tsc)
 790 {
 791         /* power down entire audio section inside TSC2301 in case the
 792          * chip is still powered during the system sleep. However this driver
 793          * doesn't require that chip is powered because registers are restored
 794          * in function tsc2301_mixer_resume */
 795         mutex_lock(&tsc->mixer->mutex);
 796         tsc2301_gpio_power_down(tsc);
 797         tsc->mixer->shadow_regs[PD_MISC_INDEX] |= TSC2301_REG_PD_MISC_APD;
 798         tsc2301_write_reg(tsc, TSC2301_REG_PD_MISC,
 799                           tsc->mixer->shadow_regs[PD_MISC_INDEX]);
 800         mutex_unlock(&tsc->mixer->mutex);
 801         return 0;
 802 }
 803
 804 void tsc2301_mixer_resume(struct tsc2301 *tsc)
 805 {
 806         /* power up the TSC2301 audio section and restore registers */
 807         mutex_lock(&tsc->mixer->mutex);
 808         tsc->mixer->shadow_regs[PD_MISC_INDEX] &= ~TSC2301_REG_PD_MISC_APD;
 809         tsc2301_flush_shadow_regs(tsc);
 810         mutex_unlock(&tsc->mixer->mutex);
 811 }
 812 #endif
 813
 814 void tsc2301_mixer_enable_mclk(struct device *dev)
 815 {
 816         struct tsc2301 *tsc = dev_get_drvdata(dev);
 817         struct tsc2301_mixer *mix = tsc->mixer;
 818
 819         mutex_lock(&mix->mutex);
 820         if (!mix->mclk_enabled++ && tsc->enable_clock != NULL) {
 821                 tsc->enable_clock(dev);
 822         }
 823         tsc2301_power_ctrl(tsc, -1, 1);
 824         mutex_unlock(&mix->mutex);
 825 }
 826
 827 void tsc2301_mixer_disable_mclk(struct device *dev)
 828 {
 829         struct tsc2301 *tsc = dev_get_drvdata(dev);
 830         struct tsc2301_mixer *mix = tsc->mixer;
 831
 832         mutex_lock(&mix->mutex);
 833         mix->mclk_enabled--;
 834         tsc2301_power_ctrl(tsc, -1, 1);
 835         if (!mix->mclk_enabled && tsc->disable_clock != NULL) {
 836                 tsc->disable_clock(dev);
 837         }
 838         mutex_unlock(&mix->mutex);
 839 }
 840
 841 static void tsc2301_mixer_delayed_power_down(struct work_struct *work)
 842 {
 843         struct tsc2301_mixer *mix = container_of(work, struct tsc2301_mixer,
 844                                                  delayed_power_down.work);
 845         struct tsc2301 *tsc = mix->tsc;
 846
 847         mutex_lock(&mix->mutex);
 848         if (!mix->delayed_pd_active) {
 849                 mutex_unlock(&mix->mutex);
 850                 return;
 851         }
 852         mix->delayed_pd_active = 0;
 853         mutex_unlock(&mix->mutex);
 854         tsc2301_mixer_disable_mclk(&tsc->spi->dev);
 855 }
 856
 857 /*
 858  * Allows audio controller driver to notify its usage of ADC and DAC
 859  */
 860 void tsc2301_mixer_set_power(struct device *dev, int dac, int adc)
 861 {
 862         struct tsc2301 *tsc = dev_get_drvdata(dev);
 863
 864         mutex_lock(&tsc->mixer->mutex);
 865         tsc->mixer->adc_enabled = adc;
 866         tsc->mixer->dac_enabled = dac;
 867
 868         /* update power state of all audio blocks */
 869         tsc2301_power_ctrl(tsc, -1, 1);
 870         mutex_unlock(&tsc->mixer->mutex);
 871 }
 872
 873 /*
 874  * Registers TSC2301 ALSA Mixer controls for the given sound card
 875  */
 876 int tsc2301_mixer_register_controls(struct device *dev, struct snd_card *card)
 877 {
 878         struct tsc2301 *tsc = dev_get_drvdata(dev);
 879         struct tsc2301_mixer *mix = tsc->mixer;
 880         int i, err;
 881
 882         /* Register ALSA mixer controls */
 883         for (i = 0; i < ARRAY_SIZE(snd_tsc2301_controls); i++) {
 884                 err = snd_ctl_add(card,
 885                                   snd_ctl_new1(&snd_tsc2301_controls[i], tsc));
 886                 if (err < 0)
 887                         return err;
 888         }
 889
 890         if (!mix->n_mixer_gpios)
 891                 return 0;
 892
 893         /* Register additional GPIO controls if defined */
 894         for (i = 0; i < mix->n_mixer_gpios; i++) {
 895                 const struct tsc2301_mixer_gpio *mg = mix->mixer_gpios + i;
 896                 struct snd_kcontrol *ctrlp;
 897                 struct snd_kcontrol_new ctrl =
 898                         TSC2301_BOOL((char *)mg->name, 0,
 899                                      TSC2301_REG_GPIO, GPIO_INDEX,
 900                                      mg->gpio, mg->inverted, mg->def_enable);
 901
 902                 ctrlp = snd_ctl_new1(&ctrl, tsc);
 903                 err = snd_ctl_add(card, ctrlp);
 904                 if (err < 0)
 905                         return err;
 906         }
 907
 908         return 0;
 909 }
 910
 911 int tsc2301_mixer_init(struct tsc2301 *tsc,
 912                        struct tsc2301_platform_data *pdata)
 913 {
 914         struct tsc2301_mixer *mix;
 915         int err = 0;
 916         u16 w;
 917
 918         mix = kzalloc(sizeof(*mix), GFP_KERNEL);
 919         if (mix == NULL)
 920                 return -ENOMEM;
 921         tsc->mixer = mix;
 922
 923         mix->tsc = tsc;
 924         mutex_init(&mix->mutex);
 925         mix->platform_init = pdata->codec_init;
 926         mix->platform_cleanup = pdata->codec_cleanup;
 927         mix->pll_output = pdata->pll_output;
 928
 929         INIT_DELAYED_WORK(&mix->delayed_power_down,
 930                           tsc2301_mixer_delayed_power_down);
 931
 932         /* initialize shadow register default values */
 933         w = 0xc000;
 934         w |= (pdata->mclk_ratio << 6) | (pdata->i2s_sample_rate << 2);
 935         w |= pdata->i2s_format;
 936         mix->shadow_regs[AUDCNTL_INDEX] = w;
 937         mix->shadow_regs[ADCVOL_INDEX] = 0xd7d7;
 938         mix->shadow_regs[DACVOL_INDEX] = 0xffff;
 939         mix->shadow_regs[BPVOL_INDEX] = 0xe7e7;
 940         mix->shadow_regs[PD_MISC_INDEX] = pdata->power_down_blocks;
 941
 942         /* if extra mixer controls configured, then configure associated
 943          * GPIOs as output and drive their default state */
 944         if (pdata->n_mixer_gpios) {
 945                 int i;
 946
 947                 w = 0;
 948                 for (i = 0; i < pdata->n_mixer_gpios; i++) {
 949                         const struct tsc2301_mixer_gpio *mg;
 950                         int gpio;
 951
 952                         mg = pdata->mixer_gpios + i;
 953                         gpio = mg->gpio;
 954                         w |= (1 << gpio) << 8;
 955                         w |= (mg->inverted ^ mg->def_enable) << gpio;
 956                 }
 957                 mix->shadow_regs[GPIO_INDEX] = w;
 958
 959                 mix->mixer_gpios = kmalloc(sizeof(*pdata->mixer_gpios) *
 960                                            pdata->n_mixer_gpios,
 961                                            GFP_KERNEL);
 962                 if (mix->mixer_gpios == NULL) {
 963                         err = -ENOMEM;
 964                         goto err1;
 965                 }
 966                 memcpy(mix->mixer_gpios, pdata->mixer_gpios,
 967                        sizeof(*pdata->mixer_gpios) * pdata->n_mixer_gpios);
 968                 mix->n_mixer_gpios = pdata->n_mixer_gpios;
 969         }
 970
 971         /* PLL control */
 972         tsc2301_write_pll(tsc, pdata->pll_n, pdata->pll_a, pdata->pll_pdc,
 973                           0, mix->pll_output ? 0 : 1);
 974
 975         tsc2301_flush_shadow_regs(tsc);
 976
 977         if (mix->platform_init != NULL) {
 978                 err = mix->platform_init(&tsc->spi->dev);
 979                 if (err < 0)
 980                         goto err2;
 981         }
 982
 983         return 0;
 984 err2:
 985         if (mix->mixer_gpios != NULL)
 986                 kfree(mix->mixer_gpios);
 987 err1:
 988         kfree(mix);
 989         return err;
 990 }
 991
 992 void tsc2301_mixer_exit(struct tsc2301 *tsc)
 993 {
 994         struct tsc2301_mixer *mixer = tsc->mixer;
 995
 996         if (mixer->platform_cleanup != NULL)
 997                 mixer->platform_cleanup(&tsc->spi->dev);
 998
 999         if (mixer->mixer_gpios != NULL)
1000                 kfree(mixer->mixer_gpios);
1001 }
1002
1003 MODULE_AUTHOR("Jarkko Nikula <jarkko.nikula@nokia.com>");
1004 MODULE_LICENSE("GPL");