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