drivers/spi/tsc2301-mixer.c

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