sound/soc/codecs/sta32x.c

   1 /*
   2  * Codec driver for ST STA32x 2.1-channel high-efficiency digital audio system
   3  *
   4  * Copyright: 2011 Raumfeld GmbH
   5  * Author: Johannes Stezenbach <js@sig21.net>
   6  *
   7  * based on code from:
   8  *      Wolfson Microelectronics PLC.
   9  *        Mark Brown <broonie@opensource.wolfsonmicro.com>
  10  *      Freescale Semiconductor, Inc.
  11  *        Timur Tabi <timur@freescale.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 #define pr_fmt(fmt) KBUILD_MODNAME ":%s:%d: " fmt, __func__, __LINE__
  20
  21 #include <linux/module.h>
  22 #include <linux/moduleparam.h>
  23 #include <linux/init.h>
  24 #include <linux/delay.h>
  25 #include <linux/pm.h>
  26 #include <linux/i2c.h>
  27 #include <linux/regulator/consumer.h>
  28 #include <linux/slab.h>
  29 #include <linux/workqueue.h>
  30 #include <sound/core.h>
  31 #include <sound/pcm.h>
  32 #include <sound/pcm_params.h>
  33 #include <sound/soc.h>
  34 #include <sound/soc-dapm.h>
  35 #include <sound/initval.h>
  36 #include <sound/tlv.h>
  37
  38 #include <sound/sta32x.h>
  39 #include "sta32x.h"
  40
  41 #define STA32X_RATES (SNDRV_PCM_RATE_32000 | \
  42                       SNDRV_PCM_RATE_44100 | \
  43                       SNDRV_PCM_RATE_48000 | \
  44                       SNDRV_PCM_RATE_88200 | \
  45                       SNDRV_PCM_RATE_96000 | \
  46                       SNDRV_PCM_RATE_176400 | \
  47                       SNDRV_PCM_RATE_192000)
  48
  49 #define STA32X_FORMATS \
  50         (SNDRV_PCM_FMTBIT_S16_LE  | SNDRV_PCM_FMTBIT_S16_BE  | \
  51          SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE | \
  52          SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE | \
  53          SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE | \
  54          SNDRV_PCM_FMTBIT_S24_LE  | SNDRV_PCM_FMTBIT_S24_BE  | \
  55          SNDRV_PCM_FMTBIT_S32_LE  | SNDRV_PCM_FMTBIT_S32_BE)
  56
  57 /* Power-up register defaults */
  58 static const u8 sta32x_regs[STA32X_REGISTER_COUNT] = {
  59         0x63, 0x80, 0xc2, 0x40, 0xc2, 0x5c, 0x10, 0xff, 0x60, 0x60,
  60         0x60, 0x80, 0x00, 0x00, 0x00, 0x40, 0x80, 0x77, 0x6a, 0x69,
  61         0x6a, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  62         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d,
  63         0xc0, 0xf3, 0x33, 0x00, 0x0c,
  64 };
  65
  66 /* regulator power supply names */
  67 static const char *sta32x_supply_names[] = {
  68         "Vdda", /* analog supply, 3.3VV */
  69         "Vdd3", /* digital supply, 3.3V */
  70         "Vcc"   /* power amp spply, 10V - 36V */
  71 };
  72
  73 /* codec private data */
  74 struct sta32x_priv {
  75         struct regulator_bulk_data supplies[ARRAY_SIZE(sta32x_supply_names)];
  76         struct snd_soc_codec *codec;
  77         struct sta32x_platform_data *pdata;
  78
  79         unsigned int mclk;
  80         unsigned int format;
  81
  82         u32 coef_shadow[STA32X_COEF_COUNT];
  83         struct delayed_work watchdog_work;
  84         int shutdown;
  85 };
  86
  87 static const DECLARE_TLV_DB_SCALE(mvol_tlv, -12700, 50, 1);
  88 static const DECLARE_TLV_DB_SCALE(chvol_tlv, -7950, 50, 1);
  89 static const DECLARE_TLV_DB_SCALE(tone_tlv, -120, 200, 0);
  90
  91 static const char *sta32x_drc_ac[] = {
  92         "Anti-Clipping", "Dynamic Range Compression" };
  93 static const char *sta32x_auto_eq_mode[] = {
  94         "User", "Preset", "Loudness" };
  95 static const char *sta32x_auto_gc_mode[] = {
  96         "User", "AC no clipping", "AC limited clipping (10%)",
  97         "DRC nighttime listening mode" };
  98 static const char *sta32x_auto_xo_mode[] = {
  99         "User", "80Hz", "100Hz", "120Hz", "140Hz", "160Hz", "180Hz", "200Hz",
 100         "220Hz", "240Hz", "260Hz", "280Hz", "300Hz", "320Hz", "340Hz", "360Hz" };
 101 static const char *sta32x_preset_eq_mode[] = {
 102         "Flat", "Rock", "Soft Rock", "Jazz", "Classical", "Dance", "Pop", "Soft",
 103         "Hard", "Party", "Vocal", "Hip-Hop", "Dialog", "Bass-boost #1",
 104         "Bass-boost #2", "Bass-boost #3", "Loudness 1", "Loudness 2",
 105         "Loudness 3", "Loudness 4", "Loudness 5", "Loudness 6", "Loudness 7",
 106         "Loudness 8", "Loudness 9", "Loudness 10", "Loudness 11", "Loudness 12",
 107         "Loudness 13", "Loudness 14", "Loudness 15", "Loudness 16" };
 108 static const char *sta32x_limiter_select[] = {
 109         "Limiter Disabled", "Limiter #1", "Limiter #2" };
 110 static const char *sta32x_limiter_attack_rate[] = {
 111         "3.1584", "2.7072", "2.2560", "1.8048", "1.3536", "0.9024",
 112         "0.4512", "0.2256", "0.1504", "0.1123", "0.0902", "0.0752",
 113         "0.0645", "0.0564", "0.0501", "0.0451" };
 114 static const char *sta32x_limiter_release_rate[] = {
 115         "0.5116", "0.1370", "0.0744", "0.0499", "0.0360", "0.0299",
 116         "0.0264", "0.0208", "0.0198", "0.0172", "0.0147", "0.0137",
 117         "0.0134", "0.0117", "0.0110", "0.0104" };
 118
 119 static const unsigned int sta32x_limiter_ac_attack_tlv[] = {
 120         TLV_DB_RANGE_HEAD(2),
 121         0, 7, TLV_DB_SCALE_ITEM(-1200, 200, 0),
 122         8, 16, TLV_DB_SCALE_ITEM(300, 100, 0),
 123 };
 124
 125 static const unsigned int sta32x_limiter_ac_release_tlv[] = {
 126         TLV_DB_RANGE_HEAD(5),
 127         0, 0, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 0),
 128         1, 1, TLV_DB_SCALE_ITEM(-2900, 0, 0),
 129         2, 2, TLV_DB_SCALE_ITEM(-2000, 0, 0),
 130         3, 8, TLV_DB_SCALE_ITEM(-1400, 200, 0),
 131         8, 16, TLV_DB_SCALE_ITEM(-700, 100, 0),
 132 };
 133
 134 static const unsigned int sta32x_limiter_drc_attack_tlv[] = {
 135         TLV_DB_RANGE_HEAD(3),
 136         0, 7, TLV_DB_SCALE_ITEM(-3100, 200, 0),
 137         8, 13, TLV_DB_SCALE_ITEM(-1600, 100, 0),
 138         14, 16, TLV_DB_SCALE_ITEM(-1000, 300, 0),
 139 };
 140
 141 static const unsigned int sta32x_limiter_drc_release_tlv[] = {
 142         TLV_DB_RANGE_HEAD(5),
 143         0, 0, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 0),
 144         1, 2, TLV_DB_SCALE_ITEM(-3800, 200, 0),
 145         3, 4, TLV_DB_SCALE_ITEM(-3300, 200, 0),
 146         5, 12, TLV_DB_SCALE_ITEM(-3000, 200, 0),
 147         13, 16, TLV_DB_SCALE_ITEM(-1500, 300, 0),
 148 };
 149
 150 static const struct soc_enum sta32x_drc_ac_enum =
 151         SOC_ENUM_SINGLE(STA32X_CONFD, STA32X_CONFD_DRC_SHIFT,
 152                         2, sta32x_drc_ac);
 153 static const struct soc_enum sta32x_auto_eq_enum =
 154         SOC_ENUM_SINGLE(STA32X_AUTO1, STA32X_AUTO1_AMEQ_SHIFT,
 155                         3, sta32x_auto_eq_mode);
 156 static const struct soc_enum sta32x_auto_gc_enum =
 157         SOC_ENUM_SINGLE(STA32X_AUTO1, STA32X_AUTO1_AMGC_SHIFT,
 158                         4, sta32x_auto_gc_mode);
 159 static const struct soc_enum sta32x_auto_xo_enum =
 160         SOC_ENUM_SINGLE(STA32X_AUTO2, STA32X_AUTO2_XO_SHIFT,
 161                         16, sta32x_auto_xo_mode);
 162 static const struct soc_enum sta32x_preset_eq_enum =
 163         SOC_ENUM_SINGLE(STA32X_AUTO3, STA32X_AUTO3_PEQ_SHIFT,
 164                         32, sta32x_preset_eq_mode);
 165 static const struct soc_enum sta32x_limiter_ch1_enum =
 166         SOC_ENUM_SINGLE(STA32X_C1CFG, STA32X_CxCFG_LS_SHIFT,
 167                         3, sta32x_limiter_select);
 168 static const struct soc_enum sta32x_limiter_ch2_enum =
 169         SOC_ENUM_SINGLE(STA32X_C2CFG, STA32X_CxCFG_LS_SHIFT,
 170                         3, sta32x_limiter_select);
 171 static const struct soc_enum sta32x_limiter_ch3_enum =
 172         SOC_ENUM_SINGLE(STA32X_C3CFG, STA32X_CxCFG_LS_SHIFT,
 173                         3, sta32x_limiter_select);
 174 static const struct soc_enum sta32x_limiter1_attack_rate_enum =
 175         SOC_ENUM_SINGLE(STA32X_L1AR, STA32X_LxA_SHIFT,
 176                         16, sta32x_limiter_attack_rate);
 177 static const struct soc_enum sta32x_limiter2_attack_rate_enum =
 178         SOC_ENUM_SINGLE(STA32X_L2AR, STA32X_LxA_SHIFT,
 179                         16, sta32x_limiter_attack_rate);
 180 static const struct soc_enum sta32x_limiter1_release_rate_enum =
 181         SOC_ENUM_SINGLE(STA32X_L1AR, STA32X_LxR_SHIFT,
 182                         16, sta32x_limiter_release_rate);
 183 static const struct soc_enum sta32x_limiter2_release_rate_enum =
 184         SOC_ENUM_SINGLE(STA32X_L2AR, STA32X_LxR_SHIFT,
 185                         16, sta32x_limiter_release_rate);
 186
 187 /* byte array controls for setting biquad, mixer, scaling coefficients;
 188  * for biquads all five coefficients need to be set in one go,
 189  * mixer and pre/postscale coefs can be set individually;
 190  * each coef is 24bit, the bytes are ordered in the same way
 191  * as given in the STA32x data sheet (big endian; b1, b2, a1, a2, b0)
 192  */
 193
 194 static int sta32x_coefficient_info(struct snd_kcontrol *kcontrol,
 195                                    struct snd_ctl_elem_info *uinfo)
 196 {
 197         int numcoef = kcontrol->private_value >> 16;
 198         uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
 199         uinfo->count = 3 * numcoef;
 200         return 0;
 201 }
 202
 203 static int sta32x_coefficient_get(struct snd_kcontrol *kcontrol,
 204                                   struct snd_ctl_elem_value *ucontrol)
 205 {
 206         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 207         int numcoef = kcontrol->private_value >> 16;
 208         int index = kcontrol->private_value & 0xffff;
 209         unsigned int cfud;
 210         int i;
 211
 212         /* preserve reserved bits in STA32X_CFUD */
 213         cfud = snd_soc_read(codec, STA32X_CFUD) & 0xf0;
 214         /* chip documentation does not say if the bits are self clearing,
 215          * so do it explicitly */
 216         snd_soc_write(codec, STA32X_CFUD, cfud);
 217
 218         snd_soc_write(codec, STA32X_CFADDR2, index);
 219         if (numcoef == 1)
 220                 snd_soc_write(codec, STA32X_CFUD, cfud | 0x04);
 221         else if (numcoef == 5)
 222                 snd_soc_write(codec, STA32X_CFUD, cfud | 0x08);
 223         else
 224                 return -EINVAL;
 225         for (i = 0; i < 3 * numcoef; i++)
 226                 ucontrol->value.bytes.data[i] =
 227                         snd_soc_read(codec, STA32X_B1CF1 + i);
 228
 229         return 0;
 230 }
 231
 232 static int sta32x_coefficient_put(struct snd_kcontrol *kcontrol,
 233                                   struct snd_ctl_elem_value *ucontrol)
 234 {
 235         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 236         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 237         int numcoef = kcontrol->private_value >> 16;
 238         int index = kcontrol->private_value & 0xffff;
 239         unsigned int cfud;
 240         int i;
 241
 242         /* preserve reserved bits in STA32X_CFUD */
 243         cfud = snd_soc_read(codec, STA32X_CFUD) & 0xf0;
 244         /* chip documentation does not say if the bits are self clearing,
 245          * so do it explicitly */
 246         snd_soc_write(codec, STA32X_CFUD, cfud);
 247
 248         snd_soc_write(codec, STA32X_CFADDR2, index);
 249         for (i = 0; i < numcoef && (index + i < STA32X_COEF_COUNT); i++)
 250                 sta32x->coef_shadow[index + i] =
 251                           (ucontrol->value.bytes.data[3 * i] << 16)
 252                         | (ucontrol->value.bytes.data[3 * i + 1] << 8)
 253                         | (ucontrol->value.bytes.data[3 * i + 2]);
 254         for (i = 0; i < 3 * numcoef; i++)
 255                 snd_soc_write(codec, STA32X_B1CF1 + i,
 256                               ucontrol->value.bytes.data[i]);
 257         if (numcoef == 1)
 258                 snd_soc_write(codec, STA32X_CFUD, cfud | 0x01);
 259         else if (numcoef == 5)
 260                 snd_soc_write(codec, STA32X_CFUD, cfud | 0x02);
 261         else
 262                 return -EINVAL;
 263
 264         return 0;
 265 }
 266
 267 static int sta32x_sync_coef_shadow(struct snd_soc_codec *codec)
 268 {
 269         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 270         unsigned int cfud;
 271         int i;
 272
 273         /* preserve reserved bits in STA32X_CFUD */
 274         cfud = snd_soc_read(codec, STA32X_CFUD) & 0xf0;
 275
 276         for (i = 0; i < STA32X_COEF_COUNT; i++) {
 277                 snd_soc_write(codec, STA32X_CFADDR2, i);
 278                 snd_soc_write(codec, STA32X_B1CF1,
 279                               (sta32x->coef_shadow[i] >> 16) & 0xff);
 280                 snd_soc_write(codec, STA32X_B1CF2,
 281                               (sta32x->coef_shadow[i] >> 8) & 0xff);
 282                 snd_soc_write(codec, STA32X_B1CF3,
 283                               (sta32x->coef_shadow[i]) & 0xff);
 284                 /* chip documentation does not say if the bits are
 285                  * self-clearing, so do it explicitly */
 286                 snd_soc_write(codec, STA32X_CFUD, cfud);
 287                 snd_soc_write(codec, STA32X_CFUD, cfud | 0x01);
 288         }
 289         return 0;
 290 }
 291
 292 static int sta32x_cache_sync(struct snd_soc_codec *codec)
 293 {
 294         unsigned int mute;
 295         int rc;
 296
 297         if (!codec->cache_sync)
 298                 return 0;
 299
 300         /* mute during register sync */
 301         mute = snd_soc_read(codec, STA32X_MMUTE);
 302         snd_soc_write(codec, STA32X_MMUTE, mute | STA32X_MMUTE_MMUTE);
 303         sta32x_sync_coef_shadow(codec);
 304         rc = snd_soc_cache_sync(codec);
 305         snd_soc_write(codec, STA32X_MMUTE, mute);
 306         return rc;
 307 }
 308
 309 /* work around ESD issue where sta32x resets and loses all configuration */
 310 static void sta32x_watchdog(struct work_struct *work)
 311 {
 312         struct sta32x_priv *sta32x = container_of(work, struct sta32x_priv,
 313                                                   watchdog_work.work);
 314         struct snd_soc_codec *codec = sta32x->codec;
 315         unsigned int confa, confa_cached;
 316
 317         /* check if sta32x has reset itself */
 318         confa_cached = snd_soc_read(codec, STA32X_CONFA);
 319         codec->cache_bypass = 1;
 320         confa = snd_soc_read(codec, STA32X_CONFA);
 321         codec->cache_bypass = 0;
 322         if (confa != confa_cached) {
 323                 codec->cache_sync = 1;
 324                 sta32x_cache_sync(codec);
 325         }
 326
 327         if (!sta32x->shutdown)
 328                 schedule_delayed_work(&sta32x->watchdog_work,
 329                                       round_jiffies_relative(HZ));
 330 }
 331
 332 static void sta32x_watchdog_start(struct sta32x_priv *sta32x)
 333 {
 334         if (sta32x->pdata->needs_esd_watchdog) {
 335                 sta32x->shutdown = 0;
 336                 schedule_delayed_work(&sta32x->watchdog_work,
 337                                       round_jiffies_relative(HZ));
 338         }
 339 }
 340
 341 static void sta32x_watchdog_stop(struct sta32x_priv *sta32x)
 342 {
 343         if (sta32x->pdata->needs_esd_watchdog) {
 344                 sta32x->shutdown = 1;
 345                 cancel_delayed_work_sync(&sta32x->watchdog_work);
 346         }
 347 }
 348
 349 #define SINGLE_COEF(xname, index) \
 350 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 351         .info = sta32x_coefficient_info, \
 352         .get = sta32x_coefficient_get,\
 353         .put = sta32x_coefficient_put, \
 354         .private_value = index | (1 << 16) }
 355
 356 #define BIQUAD_COEFS(xname, index) \
 357 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 358         .info = sta32x_coefficient_info, \
 359         .get = sta32x_coefficient_get,\
 360         .put = sta32x_coefficient_put, \
 361         .private_value = index | (5 << 16) }
 362
 363 static const struct snd_kcontrol_new sta32x_snd_controls[] = {
 364 SOC_SINGLE_TLV("Master Volume", STA32X_MVOL, 0, 0xff, 1, mvol_tlv),
 365 SOC_SINGLE("Master Switch", STA32X_MMUTE, 0, 1, 1),
 366 SOC_SINGLE("Ch1 Switch", STA32X_MMUTE, 1, 1, 1),
 367 SOC_SINGLE("Ch2 Switch", STA32X_MMUTE, 2, 1, 1),
 368 SOC_SINGLE("Ch3 Switch", STA32X_MMUTE, 3, 1, 1),
 369 SOC_SINGLE_TLV("Ch1 Volume", STA32X_C1VOL, 0, 0xff, 1, chvol_tlv),
 370 SOC_SINGLE_TLV("Ch2 Volume", STA32X_C2VOL, 0, 0xff, 1, chvol_tlv),
 371 SOC_SINGLE_TLV("Ch3 Volume", STA32X_C3VOL, 0, 0xff, 1, chvol_tlv),
 372 SOC_SINGLE("De-emphasis Filter Switch", STA32X_CONFD, STA32X_CONFD_DEMP_SHIFT, 1, 0),
 373 SOC_ENUM("Compressor/Limiter Switch", sta32x_drc_ac_enum),
 374 SOC_SINGLE("Miami Mode Switch", STA32X_CONFD, STA32X_CONFD_MME_SHIFT, 1, 0),
 375 SOC_SINGLE("Zero Cross Switch", STA32X_CONFE, STA32X_CONFE_ZCE_SHIFT, 1, 0),
 376 SOC_SINGLE("Soft Ramp Switch", STA32X_CONFE, STA32X_CONFE_SVE_SHIFT, 1, 0),
 377 SOC_SINGLE("Auto-Mute Switch", STA32X_CONFF, STA32X_CONFF_IDE_SHIFT, 1, 0),
 378 SOC_ENUM("Automode EQ", sta32x_auto_eq_enum),
 379 SOC_ENUM("Automode GC", sta32x_auto_gc_enum),
 380 SOC_ENUM("Automode XO", sta32x_auto_xo_enum),
 381 SOC_ENUM("Preset EQ", sta32x_preset_eq_enum),
 382 SOC_SINGLE("Ch1 Tone Control Bypass Switch", STA32X_C1CFG, STA32X_CxCFG_TCB_SHIFT, 1, 0),
 383 SOC_SINGLE("Ch2 Tone Control Bypass Switch", STA32X_C2CFG, STA32X_CxCFG_TCB_SHIFT, 1, 0),
 384 SOC_SINGLE("Ch1 EQ Bypass Switch", STA32X_C1CFG, STA32X_CxCFG_EQBP_SHIFT, 1, 0),
 385 SOC_SINGLE("Ch2 EQ Bypass Switch", STA32X_C2CFG, STA32X_CxCFG_EQBP_SHIFT, 1, 0),
 386 SOC_SINGLE("Ch1 Master Volume Bypass Switch", STA32X_C1CFG, STA32X_CxCFG_VBP_SHIFT, 1, 0),
 387 SOC_SINGLE("Ch2 Master Volume Bypass Switch", STA32X_C1CFG, STA32X_CxCFG_VBP_SHIFT, 1, 0),
 388 SOC_SINGLE("Ch3 Master Volume Bypass Switch", STA32X_C1CFG, STA32X_CxCFG_VBP_SHIFT, 1, 0),
 389 SOC_ENUM("Ch1 Limiter Select", sta32x_limiter_ch1_enum),
 390 SOC_ENUM("Ch2 Limiter Select", sta32x_limiter_ch2_enum),
 391 SOC_ENUM("Ch3 Limiter Select", sta32x_limiter_ch3_enum),
 392 SOC_SINGLE_TLV("Bass Tone Control", STA32X_TONE, STA32X_TONE_BTC_SHIFT, 15, 0, tone_tlv),
 393 SOC_SINGLE_TLV("Treble Tone Control", STA32X_TONE, STA32X_TONE_TTC_SHIFT, 15, 0, tone_tlv),
 394 SOC_ENUM("Limiter1 Attack Rate (dB/ms)", sta32x_limiter1_attack_rate_enum),
 395 SOC_ENUM("Limiter2 Attack Rate (dB/ms)", sta32x_limiter2_attack_rate_enum),
 396 SOC_ENUM("Limiter1 Release Rate (dB/ms)", sta32x_limiter1_release_rate_enum),
 397 SOC_ENUM("Limiter2 Release Rate (dB/ms)", sta32x_limiter1_release_rate_enum),
 398
 399 /* depending on mode, the attack/release thresholds have
 400  * two different enum definitions; provide both
 401  */
 402 SOC_SINGLE_TLV("Limiter1 Attack Threshold (AC Mode)", STA32X_L1ATRT, STA32X_LxA_SHIFT,
 403                16, 0, sta32x_limiter_ac_attack_tlv),
 404 SOC_SINGLE_TLV("Limiter2 Attack Threshold (AC Mode)", STA32X_L2ATRT, STA32X_LxA_SHIFT,
 405                16, 0, sta32x_limiter_ac_attack_tlv),
 406 SOC_SINGLE_TLV("Limiter1 Release Threshold (AC Mode)", STA32X_L1ATRT, STA32X_LxR_SHIFT,
 407                16, 0, sta32x_limiter_ac_release_tlv),
 408 SOC_SINGLE_TLV("Limiter2 Release Threshold (AC Mode)", STA32X_L2ATRT, STA32X_LxR_SHIFT,
 409                16, 0, sta32x_limiter_ac_release_tlv),
 410 SOC_SINGLE_TLV("Limiter1 Attack Threshold (DRC Mode)", STA32X_L1ATRT, STA32X_LxA_SHIFT,
 411                16, 0, sta32x_limiter_drc_attack_tlv),
 412 SOC_SINGLE_TLV("Limiter2 Attack Threshold (DRC Mode)", STA32X_L2ATRT, STA32X_LxA_SHIFT,
 413                16, 0, sta32x_limiter_drc_attack_tlv),
 414 SOC_SINGLE_TLV("Limiter1 Release Threshold (DRC Mode)", STA32X_L1ATRT, STA32X_LxR_SHIFT,
 415                16, 0, sta32x_limiter_drc_release_tlv),
 416 SOC_SINGLE_TLV("Limiter2 Release Threshold (DRC Mode)", STA32X_L2ATRT, STA32X_LxR_SHIFT,
 417                16, 0, sta32x_limiter_drc_release_tlv),
 418
 419 BIQUAD_COEFS("Ch1 - Biquad 1", 0),
 420 BIQUAD_COEFS("Ch1 - Biquad 2", 5),
 421 BIQUAD_COEFS("Ch1 - Biquad 3", 10),
 422 BIQUAD_COEFS("Ch1 - Biquad 4", 15),
 423 BIQUAD_COEFS("Ch2 - Biquad 1", 20),
 424 BIQUAD_COEFS("Ch2 - Biquad 2", 25),
 425 BIQUAD_COEFS("Ch2 - Biquad 3", 30),
 426 BIQUAD_COEFS("Ch2 - Biquad 4", 35),
 427 BIQUAD_COEFS("High-pass", 40),
 428 BIQUAD_COEFS("Low-pass", 45),
 429 SINGLE_COEF("Ch1 - Prescale", 50),
 430 SINGLE_COEF("Ch2 - Prescale", 51),
 431 SINGLE_COEF("Ch1 - Postscale", 52),
 432 SINGLE_COEF("Ch2 - Postscale", 53),
 433 SINGLE_COEF("Ch3 - Postscale", 54),
 434 SINGLE_COEF("Thermal warning - Postscale", 55),
 435 SINGLE_COEF("Ch1 - Mix 1", 56),
 436 SINGLE_COEF("Ch1 - Mix 2", 57),
 437 SINGLE_COEF("Ch2 - Mix 1", 58),
 438 SINGLE_COEF("Ch2 - Mix 2", 59),
 439 SINGLE_COEF("Ch3 - Mix 1", 60),
 440 SINGLE_COEF("Ch3 - Mix 2", 61),
 441 };
 442
 443 static const struct snd_soc_dapm_widget sta32x_dapm_widgets[] = {
 444 SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM, 0, 0),
 445 SND_SOC_DAPM_OUTPUT("LEFT"),
 446 SND_SOC_DAPM_OUTPUT("RIGHT"),
 447 SND_SOC_DAPM_OUTPUT("SUB"),
 448 };
 449
 450 static const struct snd_soc_dapm_route sta32x_dapm_routes[] = {
 451         { "LEFT", NULL, "DAC" },
 452         { "RIGHT", NULL, "DAC" },
 453         { "SUB", NULL, "DAC" },
 454 };
 455
 456 /* MCLK interpolation ratio per fs */
 457 static struct {
 458         int fs;
 459         int ir;
 460 } interpolation_ratios[] = {
 461         { 32000, 0 },
 462         { 44100, 0 },
 463         { 48000, 0 },
 464         { 88200, 1 },
 465         { 96000, 1 },
 466         { 176400, 2 },
 467         { 192000, 2 },
 468 };
 469
 470 /* MCLK to fs clock ratios */
 471 static struct {
 472         int ratio;
 473         int mcs;
 474 } mclk_ratios[3][7] = {
 475         { { 768, 0 }, { 512, 1 }, { 384, 2 }, { 256, 3 },
 476           { 128, 4 }, { 576, 5 }, { 0, 0 } },
 477         { { 384, 2 }, { 256, 3 }, { 192, 4 }, { 128, 5 }, {64, 0 }, { 0, 0 } },
 478         { { 384, 2 }, { 256, 3 }, { 192, 4 }, { 128, 5 }, {64, 0 }, { 0, 0 } },
 479 };
 480
 481
 482 /**
 483  * sta32x_set_dai_sysclk - configure MCLK
 484  * @codec_dai: the codec DAI
 485  * @clk_id: the clock ID (ignored)
 486  * @freq: the MCLK input frequency
 487  * @dir: the clock direction (ignored)
 488  *
 489  * The value of MCLK is used to determine which sample rates are supported
 490  * by the STA32X, based on the mclk_ratios table.
 491  *
 492  * This function must be called by the machine driver's 'startup' function,
 493  * otherwise the list of supported sample rates will not be available in
 494  * time for ALSA.
 495  *
 496  * For setups with variable MCLKs, pass 0 as 'freq' argument. This will cause
 497  * theoretically possible sample rates to be enabled. Call it again with a
 498  * proper value set one the external clock is set (most probably you would do
 499  * that from a machine's driver 'hw_param' hook.
 500  */
 501 static int sta32x_set_dai_sysclk(struct snd_soc_dai *codec_dai,
 502                 int clk_id, unsigned int freq, int dir)
 503 {
 504         struct snd_soc_codec *codec = codec_dai->codec;
 505         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 506         int i, j, ir, fs;
 507         unsigned int rates = 0;
 508         unsigned int rate_min = -1;
 509         unsigned int rate_max = 0;
 510
 511         pr_debug("mclk=%u\n", freq);
 512         sta32x->mclk = freq;
 513
 514         if (sta32x->mclk) {
 515                 for (i = 0; i < ARRAY_SIZE(interpolation_ratios); i++) {
 516                         ir = interpolation_ratios[i].ir;
 517                         fs = interpolation_ratios[i].fs;
 518                         for (j = 0; mclk_ratios[ir][j].ratio; j++) {
 519                                 if (mclk_ratios[ir][j].ratio * fs == freq) {
 520                                         rates |= snd_pcm_rate_to_rate_bit(fs);
 521                                         if (fs < rate_min)
 522                                                 rate_min = fs;
 523                                         if (fs > rate_max)
 524                                                 rate_max = fs;
 525                                         break;
 526                                 }
 527                         }
 528                 }
 529                 /* FIXME: soc should support a rate list */
 530                 rates &= ~SNDRV_PCM_RATE_KNOT;
 531
 532                 if (!rates) {
 533                         dev_err(codec->dev, "could not find a valid sample rate\n");
 534                         return -EINVAL;
 535                 }
 536         } else {
 537                 /* enable all possible rates */
 538                 rates = STA32X_RATES;
 539                 rate_min = 32000;
 540                 rate_max = 192000;
 541         }
 542
 543         codec_dai->driver->playback.rates = rates;
 544         codec_dai->driver->playback.rate_min = rate_min;
 545         codec_dai->driver->playback.rate_max = rate_max;
 546         return 0;
 547 }
 548
 549 /**
 550  * sta32x_set_dai_fmt - configure the codec for the selected audio format
 551  * @codec_dai: the codec DAI
 552  * @fmt: a SND_SOC_DAIFMT_x value indicating the data format
 553  *
 554  * This function takes a bitmask of SND_SOC_DAIFMT_x bits and programs the
 555  * codec accordingly.
 556  */
 557 static int sta32x_set_dai_fmt(struct snd_soc_dai *codec_dai,
 558                               unsigned int fmt)
 559 {
 560         struct snd_soc_codec *codec = codec_dai->codec;
 561         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 562         u8 confb = snd_soc_read(codec, STA32X_CONFB);
 563
 564         pr_debug("\n");
 565         confb &= ~(STA32X_CONFB_C1IM | STA32X_CONFB_C2IM);
 566
 567         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 568         case SND_SOC_DAIFMT_CBS_CFS:
 569                 break;
 570         default:
 571                 return -EINVAL;
 572         }
 573
 574         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 575         case SND_SOC_DAIFMT_I2S:
 576         case SND_SOC_DAIFMT_RIGHT_J:
 577         case SND_SOC_DAIFMT_LEFT_J:
 578                 sta32x->format = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
 579                 break;
 580         default:
 581                 return -EINVAL;
 582         }
 583
 584         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 585         case SND_SOC_DAIFMT_NB_NF:
 586                 confb |= STA32X_CONFB_C2IM;
 587                 break;
 588         case SND_SOC_DAIFMT_NB_IF:
 589                 confb |= STA32X_CONFB_C1IM;
 590                 break;
 591         default:
 592                 return -EINVAL;
 593         }
 594
 595         snd_soc_write(codec, STA32X_CONFB, confb);
 596         return 0;
 597 }
 598
 599 /**
 600  * sta32x_hw_params - program the STA32X with the given hardware parameters.
 601  * @substream: the audio stream
 602  * @params: the hardware parameters to set
 603  * @dai: the SOC DAI (ignored)
 604  *
 605  * This function programs the hardware with the values provided.
 606  * Specifically, the sample rate and the data format.
 607  */
 608 static int sta32x_hw_params(struct snd_pcm_substream *substream,
 609                             struct snd_pcm_hw_params *params,
 610                             struct snd_soc_dai *dai)
 611 {
 612         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 613         struct snd_soc_codec *codec = rtd->codec;
 614         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 615         unsigned int rate;
 616         int i, mcs = -1, ir = -1;
 617         u8 confa, confb;
 618
 619         rate = params_rate(params);
 620         pr_debug("rate: %u\n", rate);
 621         for (i = 0; i < ARRAY_SIZE(interpolation_ratios); i++)
 622                 if (interpolation_ratios[i].fs == rate) {
 623                         ir = interpolation_ratios[i].ir;
 624                         break;
 625                 }
 626         if (ir < 0)
 627                 return -EINVAL;
 628         for (i = 0; mclk_ratios[ir][i].ratio; i++)
 629                 if (mclk_ratios[ir][i].ratio * rate == sta32x->mclk) {
 630                         mcs = mclk_ratios[ir][i].mcs;
 631                         break;
 632                 }
 633         if (mcs < 0)
 634                 return -EINVAL;
 635
 636         confa = snd_soc_read(codec, STA32X_CONFA);
 637         confa &= ~(STA32X_CONFA_MCS_MASK | STA32X_CONFA_IR_MASK);
 638         confa |= (ir << STA32X_CONFA_IR_SHIFT) | (mcs << STA32X_CONFA_MCS_SHIFT);
 639
 640         confb = snd_soc_read(codec, STA32X_CONFB);
 641         confb &= ~(STA32X_CONFB_SAI_MASK | STA32X_CONFB_SAIFB);
 642         switch (params_format(params)) {
 643         case SNDRV_PCM_FORMAT_S24_LE:
 644         case SNDRV_PCM_FORMAT_S24_BE:
 645         case SNDRV_PCM_FORMAT_S24_3LE:
 646         case SNDRV_PCM_FORMAT_S24_3BE:
 647                 pr_debug("24bit\n");
 648                 /* fall through */
 649         case SNDRV_PCM_FORMAT_S32_LE:
 650         case SNDRV_PCM_FORMAT_S32_BE:
 651                 pr_debug("24bit or 32bit\n");
 652                 switch (sta32x->format) {
 653                 case SND_SOC_DAIFMT_I2S:
 654                         confb |= 0x0;
 655                         break;
 656                 case SND_SOC_DAIFMT_LEFT_J:
 657                         confb |= 0x1;
 658                         break;
 659                 case SND_SOC_DAIFMT_RIGHT_J:
 660                         confb |= 0x2;
 661                         break;
 662                 }
 663
 664                 break;
 665         case SNDRV_PCM_FORMAT_S20_3LE:
 666         case SNDRV_PCM_FORMAT_S20_3BE:
 667                 pr_debug("20bit\n");
 668                 switch (sta32x->format) {
 669                 case SND_SOC_DAIFMT_I2S:
 670                         confb |= 0x4;
 671                         break;
 672                 case SND_SOC_DAIFMT_LEFT_J:
 673                         confb |= 0x5;
 674                         break;
 675                 case SND_SOC_DAIFMT_RIGHT_J:
 676                         confb |= 0x6;
 677                         break;
 678                 }
 679
 680                 break;
 681         case SNDRV_PCM_FORMAT_S18_3LE:
 682         case SNDRV_PCM_FORMAT_S18_3BE:
 683                 pr_debug("18bit\n");
 684                 switch (sta32x->format) {
 685                 case SND_SOC_DAIFMT_I2S:
 686                         confb |= 0x8;
 687                         break;
 688                 case SND_SOC_DAIFMT_LEFT_J:
 689                         confb |= 0x9;
 690                         break;
 691                 case SND_SOC_DAIFMT_RIGHT_J:
 692                         confb |= 0xa;
 693                         break;
 694                 }
 695
 696                 break;
 697         case SNDRV_PCM_FORMAT_S16_LE:
 698         case SNDRV_PCM_FORMAT_S16_BE:
 699                 pr_debug("16bit\n");
 700                 switch (sta32x->format) {
 701                 case SND_SOC_DAIFMT_I2S:
 702                         confb |= 0x0;
 703                         break;
 704                 case SND_SOC_DAIFMT_LEFT_J:
 705                         confb |= 0xd;
 706                         break;
 707                 case SND_SOC_DAIFMT_RIGHT_J:
 708                         confb |= 0xe;
 709                         break;
 710                 }
 711
 712                 break;
 713         default:
 714                 return -EINVAL;
 715         }
 716
 717         snd_soc_write(codec, STA32X_CONFA, confa);
 718         snd_soc_write(codec, STA32X_CONFB, confb);
 719         return 0;
 720 }
 721
 722 /**
 723  * sta32x_set_bias_level - DAPM callback
 724  * @codec: the codec device
 725  * @level: DAPM power level
 726  *
 727  * This is called by ALSA to put the codec into low power mode
 728  * or to wake it up.  If the codec is powered off completely
 729  * all registers must be restored after power on.
 730  */
 731 static int sta32x_set_bias_level(struct snd_soc_codec *codec,
 732                                  enum snd_soc_bias_level level)
 733 {
 734         int ret;
 735         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 736
 737         pr_debug("level = %d\n", level);
 738         switch (level) {
 739         case SND_SOC_BIAS_ON:
 740                 break;
 741
 742         case SND_SOC_BIAS_PREPARE:
 743                 /* Full power on */
 744                 snd_soc_update_bits(codec, STA32X_CONFF,
 745                                     STA32X_CONFF_PWDN | STA32X_CONFF_EAPD,
 746                                     STA32X_CONFF_PWDN | STA32X_CONFF_EAPD);
 747                 break;
 748
 749         case SND_SOC_BIAS_STANDBY:
 750                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
 751                         ret = regulator_bulk_enable(ARRAY_SIZE(sta32x->supplies),
 752                                                     sta32x->supplies);
 753                         if (ret != 0) {
 754                                 dev_err(codec->dev,
 755                                         "Failed to enable supplies: %d\n", ret);
 756                                 return ret;
 757                         }
 758
 759                         sta32x_cache_sync(codec);
 760                         sta32x_watchdog_start(sta32x);
 761                 }
 762
 763                 /* Power up to mute */
 764                 /* FIXME */
 765                 snd_soc_update_bits(codec, STA32X_CONFF,
 766                                     STA32X_CONFF_PWDN | STA32X_CONFF_EAPD,
 767                                     STA32X_CONFF_PWDN | STA32X_CONFF_EAPD);
 768
 769                 break;
 770
 771         case SND_SOC_BIAS_OFF:
 772                 /* The chip runs through the power down sequence for us. */
 773                 snd_soc_update_bits(codec, STA32X_CONFF,
 774                                     STA32X_CONFF_PWDN | STA32X_CONFF_EAPD,
 775                                     STA32X_CONFF_PWDN);
 776                 msleep(300);
 777                 sta32x_watchdog_stop(sta32x);
 778                 regulator_bulk_disable(ARRAY_SIZE(sta32x->supplies),
 779                                        sta32x->supplies);
 780                 break;
 781         }
 782         codec->dapm.bias_level = level;
 783         return 0;
 784 }
 785
 786 static const struct snd_soc_dai_ops sta32x_dai_ops = {
 787         .hw_params      = sta32x_hw_params,
 788         .set_sysclk     = sta32x_set_dai_sysclk,
 789         .set_fmt        = sta32x_set_dai_fmt,
 790 };
 791
 792 static struct snd_soc_dai_driver sta32x_dai = {
 793         .name = "STA32X",
 794         .playback = {
 795                 .stream_name = "Playback",
 796                 .channels_min = 2,
 797                 .channels_max = 2,
 798                 .rates = STA32X_RATES,
 799                 .formats = STA32X_FORMATS,
 800         },
 801         .ops = &sta32x_dai_ops,
 802 };
 803
 804 #ifdef CONFIG_PM
 805 static int sta32x_suspend(struct snd_soc_codec *codec)
 806 {
 807         sta32x_set_bias_level(codec, SND_SOC_BIAS_OFF);
 808         return 0;
 809 }
 810
 811 static int sta32x_resume(struct snd_soc_codec *codec)
 812 {
 813         sta32x_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 814         return 0;
 815 }
 816 #else
 817 #define sta32x_suspend NULL
 818 #define sta32x_resume NULL
 819 #endif
 820
 821 static int sta32x_probe(struct snd_soc_codec *codec)
 822 {
 823         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 824         int i, ret = 0, thermal = 0;
 825
 826         sta32x->codec = codec;
 827         sta32x->pdata = dev_get_platdata(codec->dev);
 828
 829         /* regulators */
 830         for (i = 0; i < ARRAY_SIZE(sta32x->supplies); i++)
 831                 sta32x->supplies[i].supply = sta32x_supply_names[i];
 832
 833         ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(sta32x->supplies),
 834                                  sta32x->supplies);
 835         if (ret != 0) {
 836                 dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
 837                 goto err;
 838         }
 839
 840         ret = regulator_bulk_enable(ARRAY_SIZE(sta32x->supplies),
 841                                     sta32x->supplies);
 842         if (ret != 0) {
 843                 dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
 844                 goto err_get;
 845         }
 846
 847         /* Tell ASoC what kind of I/O to use to read the registers.  ASoC will
 848          * then do the I2C transactions itself.
 849          */
 850         ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C);
 851         if (ret < 0) {
 852                 dev_err(codec->dev, "failed to set cache I/O (ret=%i)\n", ret);
 853                 return ret;
 854         }
 855
 856         /* Chip documentation explicitly requires that the reset values
 857          * of reserved register bits are left untouched.
 858          * Write the register default value to cache for reserved registers,
 859          * so the write to the these registers are suppressed by the cache
 860          * restore code when it skips writes of default registers.
 861          */
 862         snd_soc_cache_write(codec, STA32X_CONFC, 0xc2);
 863         snd_soc_cache_write(codec, STA32X_CONFE, 0xc2);
 864         snd_soc_cache_write(codec, STA32X_CONFF, 0x5c);
 865         snd_soc_cache_write(codec, STA32X_MMUTE, 0x10);
 866         snd_soc_cache_write(codec, STA32X_AUTO1, 0x60);
 867         snd_soc_cache_write(codec, STA32X_AUTO3, 0x00);
 868         snd_soc_cache_write(codec, STA32X_C3CFG, 0x40);
 869
 870         /* set thermal warning adjustment and recovery */
 871         if (!(sta32x->pdata->thermal_conf & STA32X_THERMAL_ADJUSTMENT_ENABLE))
 872                 thermal |= STA32X_CONFA_TWAB;
 873         if (!(sta32x->pdata->thermal_conf & STA32X_THERMAL_RECOVERY_ENABLE))
 874                 thermal |= STA32X_CONFA_TWRB;
 875         snd_soc_update_bits(codec, STA32X_CONFA,
 876                             STA32X_CONFA_TWAB | STA32X_CONFA_TWRB,
 877                             thermal);
 878
 879         /* select output configuration  */
 880         snd_soc_update_bits(codec, STA32X_CONFF,
 881                             STA32X_CONFF_OCFG_MASK,
 882                             sta32x->pdata->output_conf
 883                             << STA32X_CONFF_OCFG_SHIFT);
 884
 885         /* channel to output mapping */
 886         snd_soc_update_bits(codec, STA32X_C1CFG,
 887                             STA32X_CxCFG_OM_MASK,
 888                             sta32x->pdata->ch1_output_mapping
 889                             << STA32X_CxCFG_OM_SHIFT);
 890         snd_soc_update_bits(codec, STA32X_C2CFG,
 891                             STA32X_CxCFG_OM_MASK,
 892                             sta32x->pdata->ch2_output_mapping
 893                             << STA32X_CxCFG_OM_SHIFT);
 894         snd_soc_update_bits(codec, STA32X_C3CFG,
 895                             STA32X_CxCFG_OM_MASK,
 896                             sta32x->pdata->ch3_output_mapping
 897                             << STA32X_CxCFG_OM_SHIFT);
 898
 899         /* initialize coefficient shadow RAM with reset values */
 900         for (i = 4; i <= 49; i += 5)
 901                 sta32x->coef_shadow[i] = 0x400000;
 902         for (i = 50; i <= 54; i++)
 903                 sta32x->coef_shadow[i] = 0x7fffff;
 904         sta32x->coef_shadow[55] = 0x5a9df7;
 905         sta32x->coef_shadow[56] = 0x7fffff;
 906         sta32x->coef_shadow[59] = 0x7fffff;
 907         sta32x->coef_shadow[60] = 0x400000;
 908         sta32x->coef_shadow[61] = 0x400000;
 909
 910         if (sta32x->pdata->needs_esd_watchdog)
 911                 INIT_DELAYED_WORK(&sta32x->watchdog_work, sta32x_watchdog);
 912
 913         sta32x_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 914         /* Bias level configuration will have done an extra enable */
 915         regulator_bulk_disable(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
 916
 917         return 0;
 918
 919 err_get:
 920         regulator_bulk_free(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
 921 err:
 922         return ret;
 923 }
 924
 925 static int sta32x_remove(struct snd_soc_codec *codec)
 926 {
 927         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 928
 929         sta32x_watchdog_stop(sta32x);
 930         sta32x_set_bias_level(codec, SND_SOC_BIAS_OFF);
 931         regulator_bulk_disable(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
 932         regulator_bulk_free(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
 933
 934         return 0;
 935 }
 936
 937 static int sta32x_reg_is_volatile(struct snd_soc_codec *codec,
 938                                   unsigned int reg)
 939 {
 940         switch (reg) {
 941         case STA32X_CONFA ... STA32X_L2ATRT:
 942         case STA32X_MPCC1 ... STA32X_FDRC2:
 943                 return 0;
 944         }
 945         return 1;
 946 }
 947
 948 static const struct snd_soc_codec_driver sta32x_codec = {
 949         .probe =                sta32x_probe,
 950         .remove =               sta32x_remove,
 951         .suspend =              sta32x_suspend,
 952         .resume =               sta32x_resume,
 953         .reg_cache_size =       STA32X_REGISTER_COUNT,
 954         .reg_word_size =        sizeof(u8),
 955         .reg_cache_default =    sta32x_regs,
 956         .volatile_register =    sta32x_reg_is_volatile,
 957         .set_bias_level =       sta32x_set_bias_level,
 958         .controls =             sta32x_snd_controls,
 959         .num_controls =         ARRAY_SIZE(sta32x_snd_controls),
 960         .dapm_widgets =         sta32x_dapm_widgets,
 961         .num_dapm_widgets =     ARRAY_SIZE(sta32x_dapm_widgets),
 962         .dapm_routes =          sta32x_dapm_routes,
 963         .num_dapm_routes =      ARRAY_SIZE(sta32x_dapm_routes),
 964 };
 965
 966 static __devinit int sta32x_i2c_probe(struct i2c_client *i2c,
 967                                       const struct i2c_device_id *id)
 968 {
 969         struct sta32x_priv *sta32x;
 970         int ret;
 971
 972         sta32x = devm_kzalloc(&i2c->dev, sizeof(struct sta32x_priv),
 973                               GFP_KERNEL);
 974         if (!sta32x)
 975                 return -ENOMEM;
 976
 977         i2c_set_clientdata(i2c, sta32x);
 978
 979         ret = snd_soc_register_codec(&i2c->dev, &sta32x_codec, &sta32x_dai, 1);
 980         if (ret != 0)
 981                 dev_err(&i2c->dev, "Failed to register codec (%d)\n", ret);
 982
 983         return ret;
 984 }
 985
 986 static __devexit int sta32x_i2c_remove(struct i2c_client *client)
 987 {
 988         snd_soc_unregister_codec(&client->dev);
 989         return 0;
 990 }
 991
 992 static const struct i2c_device_id sta32x_i2c_id[] = {
 993         { "sta326", 0 },
 994         { "sta328", 0 },
 995         { "sta329", 0 },
 996         { }
 997 };
 998 MODULE_DEVICE_TABLE(i2c, sta32x_i2c_id);
 999
1000 static struct i2c_driver sta32x_i2c_driver = {
1001         .driver = {
1002                 .name = "sta32x",
1003                 .owner = THIS_MODULE,
1004         },
1005         .probe =    sta32x_i2c_probe,
1006         .remove =   __devexit_p(sta32x_i2c_remove),
1007         .id_table = sta32x_i2c_id,
1008 };
1009
1010 static int __init sta32x_init(void)
1011 {
1012         return i2c_add_driver(&sta32x_i2c_driver);
1013 }
1014 module_init(sta32x_init);
1015
1016 static void __exit sta32x_exit(void)
1017 {
1018         i2c_del_driver(&sta32x_i2c_driver);
1019 }
1020 module_exit(sta32x_exit);
1021
1022 MODULE_DESCRIPTION("ASoC STA32X driver");
1023 MODULE_AUTHOR("Johannes Stezenbach <js@sig21.net>");
1024 MODULE_LICENSE("GPL");