soc/codecs/tfa989x.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2021 Stephan Gerhold
0004  *
0005  * Register definitions/sequences taken from various tfa98xx kernel drivers:
0006  * Copyright (C) 2014-2020 NXP Semiconductors, All Rights Reserved.
0007  * Copyright (C) 2013 Sony Mobile Communications Inc.
0008  */
0009
0010 #include <linux/gpio/consumer.h>
0011 #include <linux/i2c.h>
0012 #include <linux/module.h>
0013 #include <linux/regmap.h>
0014 #include <linux/regulator/consumer.h>
0015 #include <sound/soc.h>
0016
0017 #define TFA989X_STATUSREG       0x00
0018 #define TFA989X_BATTERYVOLTAGE      0x01
0019 #define TFA989X_TEMPERATURE     0x02
0020 #define TFA989X_REVISIONNUMBER      0x03
0021 #define TFA989X_REVISIONNUMBER_REV_MSK  GENMASK(7, 0)   /* device revision */
0022 #define TFA989X_I2SREG          0x04
0023 #define TFA989X_I2SREG_RCV      2   /* receiver mode */
0024 #define TFA989X_I2SREG_CHSA     6   /* amplifier input select */
0025 #define TFA989X_I2SREG_CHSA_MSK     GENMASK(7, 6)
0026 #define TFA989X_I2SREG_I2SSR        12  /* sample rate */
0027 #define TFA989X_I2SREG_I2SSR_MSK    GENMASK(15, 12)
0028 #define TFA989X_BAT_PROT        0x05
0029 #define TFA989X_AUDIO_CTR       0x06
0030 #define TFA989X_DCDCBOOST       0x07
0031 #define TFA989X_SPKR_CALIBRATION    0x08
0032 #define TFA989X_SYS_CTRL        0x09
0033 #define TFA989X_SYS_CTRL_PWDN       0   /* power down */
0034 #define TFA989X_SYS_CTRL_I2CR       1   /* I2C reset */
0035 #define TFA989X_SYS_CTRL_CFE        2   /* enable CoolFlux DSP */
0036 #define TFA989X_SYS_CTRL_AMPE       3   /* enable amplifier */
0037 #define TFA989X_SYS_CTRL_DCA        4   /* enable boost */
0038 #define TFA989X_SYS_CTRL_SBSL       5   /* DSP configured */
0039 #define TFA989X_SYS_CTRL_AMPC       6   /* amplifier enabled by DSP */
0040 #define TFA989X_I2S_SEL_REG     0x0a
0041 #define TFA989X_I2S_SEL_REG_SPKR_MSK    GENMASK(10, 9)  /* speaker impedance */
0042 #define TFA989X_I2S_SEL_REG_DCFG_MSK    GENMASK(14, 11) /* DCDC compensation */
0043 #define TFA989X_HIDE_UNHIDE_KEY 0x40
0044 #define TFA989X_PWM_CONTROL     0x41
0045 #define TFA989X_CURRENTSENSE1       0x46
0046 #define TFA989X_CURRENTSENSE2       0x47
0047 #define TFA989X_CURRENTSENSE3       0x48
0048 #define TFA989X_CURRENTSENSE4       0x49
0049
0050 #define TFA9890_REVISION        0x80
0051 #define TFA9895_REVISION        0x12
0052 #define TFA9897_REVISION        0x97
0053
0054 struct tfa989x_rev {
0055     unsigned int rev;
0056     int (*init)(struct regmap *regmap);
0057 };
0058
0059 struct tfa989x {
0060     const struct tfa989x_rev *rev;
0061     struct regulator *vddd_supply;
0062     struct gpio_desc *rcv_gpiod;
0063 };
0064
0065 static bool tfa989x_writeable_reg(struct device *dev, unsigned int reg)
0066 {
0067     return reg > TFA989X_REVISIONNUMBER;
0068 }
0069
0070 static bool tfa989x_volatile_reg(struct device *dev, unsigned int reg)
0071 {
0072     return reg < TFA989X_REVISIONNUMBER;
0073 }
0074
0075 static const struct regmap_config tfa989x_regmap = {
0076     .reg_bits = 8,
0077     .val_bits = 16,
0078
0079     .writeable_reg  = tfa989x_writeable_reg,
0080     .volatile_reg   = tfa989x_volatile_reg,
0081     .cache_type = REGCACHE_RBTREE,
0082 };
0083
0084 static const char * const chsa_text[] = { "Left", "Right", /* "DSP" */ };
0085 static SOC_ENUM_SINGLE_DECL(chsa_enum, TFA989X_I2SREG, TFA989X_I2SREG_CHSA, chsa_text);
0086 static const struct snd_kcontrol_new chsa_mux = SOC_DAPM_ENUM("Amp Input", chsa_enum);
0087
0088 static const struct snd_soc_dapm_widget tfa989x_dapm_widgets[] = {
0089     SND_SOC_DAPM_OUTPUT("OUT"),
0090     SND_SOC_DAPM_SUPPLY("POWER", TFA989X_SYS_CTRL, TFA989X_SYS_CTRL_PWDN, 1, NULL, 0),
0091     SND_SOC_DAPM_OUT_DRV("AMPE", TFA989X_SYS_CTRL, TFA989X_SYS_CTRL_AMPE, 0, NULL, 0),
0092
0093     SND_SOC_DAPM_MUX("Amp Input", SND_SOC_NOPM, 0, 0, &chsa_mux),
0094     SND_SOC_DAPM_AIF_IN("AIFINL", "HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
0095     SND_SOC_DAPM_AIF_IN("AIFINR", "HiFi Playback", 1, SND_SOC_NOPM, 0, 0),
0096 };
0097
0098 static const struct snd_soc_dapm_route tfa989x_dapm_routes[] = {
0099     {"OUT", NULL, "AMPE"},
0100     {"AMPE", NULL, "POWER"},
0101     {"AMPE", NULL, "Amp Input"},
0102     {"Amp Input", "Left", "AIFINL"},
0103     {"Amp Input", "Right", "AIFINR"},
0104 };
0105
0106 static int tfa989x_put_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
0107 {
0108     struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
0109     struct tfa989x *tfa989x = snd_soc_component_get_drvdata(component);
0110
0111     gpiod_set_value_cansleep(tfa989x->rcv_gpiod, ucontrol->value.enumerated.item[0]);
0112
0113     return snd_soc_put_enum_double(kcontrol, ucontrol);
0114 }
0115
0116 static const char * const mode_text[] = { "Speaker", "Receiver" };
0117 static SOC_ENUM_SINGLE_DECL(mode_enum, TFA989X_I2SREG, TFA989X_I2SREG_RCV, mode_text);
0118 static const struct snd_kcontrol_new tfa989x_mode_controls[] = {
0119     SOC_ENUM_EXT("Mode", mode_enum, snd_soc_get_enum_double, tfa989x_put_mode),
0120 };
0121
0122 static int tfa989x_probe(struct snd_soc_component *component)
0123 {
0124     struct tfa989x *tfa989x = snd_soc_component_get_drvdata(component);
0125
0126     if (tfa989x->rev->rev == TFA9897_REVISION)
0127         return snd_soc_add_component_controls(component, tfa989x_mode_controls,
0128                               ARRAY_SIZE(tfa989x_mode_controls));
0129
0130     return 0;
0131 }
0132
0133 static const struct snd_soc_component_driver tfa989x_component = {
0134     .probe          = tfa989x_probe,
0135     .dapm_widgets       = tfa989x_dapm_widgets,
0136     .num_dapm_widgets   = ARRAY_SIZE(tfa989x_dapm_widgets),
0137     .dapm_routes        = tfa989x_dapm_routes,
0138     .num_dapm_routes    = ARRAY_SIZE(tfa989x_dapm_routes),
0139     .use_pmdown_time    = 1,
0140     .endianness     = 1,
0141 };
0142
0143 static const unsigned int tfa989x_rates[] = {
0144     8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000
0145 };
0146
0147 static int tfa989x_find_sample_rate(unsigned int rate)
0148 {
0149     int i;
0150
0151     for (i = 0; i < ARRAY_SIZE(tfa989x_rates); ++i)
0152         if (tfa989x_rates[i] == rate)
0153             return i;
0154
0155     return -EINVAL;
0156 }
0157
0158 static int tfa989x_hw_params(struct snd_pcm_substream *substream,
0159                  struct snd_pcm_hw_params *params,
0160                  struct snd_soc_dai *dai)
0161 {
0162     struct snd_soc_component *component = dai->component;
0163     int sr;
0164
0165     sr = tfa989x_find_sample_rate(params_rate(params));
0166     if (sr < 0)
0167         return sr;
0168
0169     return snd_soc_component_update_bits(component, TFA989X_I2SREG,
0170                          TFA989X_I2SREG_I2SSR_MSK,
0171                          sr << TFA989X_I2SREG_I2SSR);
0172 }
0173
0174 static const struct snd_soc_dai_ops tfa989x_dai_ops = {
0175     .hw_params = tfa989x_hw_params,
0176 };
0177
0178 static struct snd_soc_dai_driver tfa989x_dai = {
0179     .name = "tfa989x-hifi",
0180     .playback = {
0181         .stream_name    = "HiFi Playback",
0182         .formats    = SNDRV_PCM_FMTBIT_S16_LE,
0183         .rates      = SNDRV_PCM_RATE_8000_48000,
0184         .rate_min   = 8000,
0185         .rate_max   = 48000,
0186         .channels_min   = 1,
0187         .channels_max   = 2,
0188     },
0189     .ops = &tfa989x_dai_ops,
0190 };
0191
0192 static int tfa9890_init(struct regmap *regmap)
0193 {
0194     int ret;
0195
0196     /* unhide keys to allow updating them */
0197     ret = regmap_write(regmap, TFA989X_HIDE_UNHIDE_KEY, 0x5a6b);
0198     if (ret)
0199         return ret;
0200
0201     /* update PLL registers */
0202     ret = regmap_set_bits(regmap, 0x59, 0x3);
0203     if (ret)
0204         return ret;
0205
0206     /* hide keys again */
0207     ret = regmap_write(regmap, TFA989X_HIDE_UNHIDE_KEY, 0x0000);
0208     if (ret)
0209         return ret;
0210
0211     return regmap_write(regmap, TFA989X_CURRENTSENSE2, 0x7BE1);
0212 }
0213
0214 static const struct tfa989x_rev tfa9890_rev = {
0215     .rev    = TFA9890_REVISION,
0216     .init   = tfa9890_init,
0217 };
0218
0219 static const struct reg_sequence tfa9895_reg_init[] = {
0220     /* some other registers must be set for optimal amplifier behaviour */
0221     { TFA989X_BAT_PROT, 0x13ab },
0222     { TFA989X_AUDIO_CTR, 0x001f },
0223
0224     /* peak voltage protection is always on, but may be written */
0225     { TFA989X_SPKR_CALIBRATION, 0x3c4e },
0226
0227     /* TFA989X_SYSCTRL_DCA = 0 */
0228     { TFA989X_SYS_CTRL, 0x024d },
0229     { TFA989X_PWM_CONTROL, 0x0308 },
0230     { TFA989X_CURRENTSENSE4, 0x0e82 },
0231 };
0232
0233 static int tfa9895_init(struct regmap *regmap)
0234 {
0235     return regmap_multi_reg_write(regmap, tfa9895_reg_init,
0236                       ARRAY_SIZE(tfa9895_reg_init));
0237 }
0238
0239 static const struct tfa989x_rev tfa9895_rev = {
0240     .rev    = TFA9895_REVISION,
0241     .init   = tfa9895_init,
0242 };
0243
0244 static int tfa9897_init(struct regmap *regmap)
0245 {
0246     int ret;
0247
0248     /* Reduce slewrate by clearing iddqtestbst to avoid booster damage */
0249     ret = regmap_write(regmap, TFA989X_CURRENTSENSE3, 0x0300);
0250     if (ret)
0251         return ret;
0252
0253     /* Enable clipping */
0254     ret = regmap_clear_bits(regmap, TFA989X_CURRENTSENSE4, 0x1);
0255     if (ret)
0256         return ret;
0257
0258     /* Set required TDM configuration */
0259     return regmap_write(regmap, 0x14, 0x0);
0260 }
0261
0262 static const struct tfa989x_rev tfa9897_rev = {
0263     .rev    = TFA9897_REVISION,
0264     .init   = tfa9897_init,
0265 };
0266
0267 /*
0268  * Note: At the moment this driver bypasses the "CoolFlux DSP" built into the
0269  * TFA989X amplifiers. Unfortunately, there seems to be absolutely
0270  * no documentation for it - the public "short datasheets" do not provide
0271  * any information about the DSP or available registers.
0272  *
0273  * Usually the TFA989X amplifiers are configured through proprietary userspace
0274  * libraries. There are also some (rather complex) kernel drivers but even those
0275  * rely on obscure firmware blobs for configuration (so-called "containers").
0276  * They seem to contain different "profiles" with tuned speaker settings, sample
0277  * rates and volume steps (which would be better exposed as separate ALSA mixers).
0278  *
0279  * Bypassing the DSP disables volume control (and perhaps some speaker
0280  * optimization?), but at least allows using the speaker without obscure
0281  * kernel drivers and firmware.
0282  *
0283  * Ideally NXP (or now Goodix) should release proper documentation for these
0284  * amplifiers so that support for the "CoolFlux DSP" can be implemented properly.
0285  */
0286 static int tfa989x_dsp_bypass(struct regmap *regmap)
0287 {
0288     int ret;
0289
0290     /* Clear CHSA to bypass DSP and take input from I2S 1 left channel */
0291     ret = regmap_clear_bits(regmap, TFA989X_I2SREG, TFA989X_I2SREG_CHSA_MSK);
0292     if (ret)
0293         return ret;
0294
0295     /* Set DCDC compensation to off and speaker impedance to 8 ohm */
0296     ret = regmap_update_bits(regmap, TFA989X_I2S_SEL_REG,
0297                  TFA989X_I2S_SEL_REG_DCFG_MSK |
0298                  TFA989X_I2S_SEL_REG_SPKR_MSK,
0299                  TFA989X_I2S_SEL_REG_SPKR_MSK);
0300     if (ret)
0301         return ret;
0302
0303     /* Set DCDC to follower mode and disable CoolFlux DSP */
0304     return regmap_clear_bits(regmap, TFA989X_SYS_CTRL,
0305                  BIT(TFA989X_SYS_CTRL_DCA) |
0306                  BIT(TFA989X_SYS_CTRL_CFE) |
0307                  BIT(TFA989X_SYS_CTRL_AMPC));
0308 }
0309
0310 static void tfa989x_regulator_disable(void *data)
0311 {
0312     struct tfa989x *tfa989x = data;
0313
0314     regulator_disable(tfa989x->vddd_supply);
0315 }
0316
0317 static int tfa989x_i2c_probe(struct i2c_client *i2c)
0318 {
0319     struct device *dev = &i2c->dev;
0320     const struct tfa989x_rev *rev;
0321     struct tfa989x *tfa989x;
0322     struct regmap *regmap;
0323     unsigned int val;
0324     int ret;
0325
0326     rev = device_get_match_data(dev);
0327     if (!rev) {
0328         dev_err(dev, "unknown device revision\n");
0329         return -ENODEV;
0330     }
0331
0332     tfa989x = devm_kzalloc(dev, sizeof(*tfa989x), GFP_KERNEL);
0333     if (!tfa989x)
0334         return -ENOMEM;
0335
0336     tfa989x->rev = rev;
0337     i2c_set_clientdata(i2c, tfa989x);
0338
0339     tfa989x->vddd_supply = devm_regulator_get(dev, "vddd");
0340     if (IS_ERR(tfa989x->vddd_supply))
0341         return dev_err_probe(dev, PTR_ERR(tfa989x->vddd_supply),
0342                      "Failed to get vddd regulator\n");
0343
0344     if (tfa989x->rev->rev == TFA9897_REVISION) {
0345         tfa989x->rcv_gpiod = devm_gpiod_get_optional(dev, "rcv", GPIOD_OUT_LOW);
0346         if (IS_ERR(tfa989x->rcv_gpiod))
0347             return PTR_ERR(tfa989x->rcv_gpiod);
0348     }
0349
0350     regmap = devm_regmap_init_i2c(i2c, &tfa989x_regmap);
0351     if (IS_ERR(regmap))
0352         return PTR_ERR(regmap);
0353
0354     ret = regulator_enable(tfa989x->vddd_supply);
0355     if (ret) {
0356         dev_err(dev, "Failed to enable vddd regulator: %d\n", ret);
0357         return ret;
0358     }
0359
0360     ret = devm_add_action_or_reset(dev, tfa989x_regulator_disable, tfa989x);
0361     if (ret)
0362         return ret;
0363
0364     /* Bypass regcache for reset and init sequence */
0365     regcache_cache_bypass(regmap, true);
0366
0367     /* Dummy read to generate i2c clocks, required on some devices */
0368     regmap_read(regmap, TFA989X_REVISIONNUMBER, &val);
0369
0370     ret = regmap_read(regmap, TFA989X_REVISIONNUMBER, &val);
0371     if (ret) {
0372         dev_err(dev, "failed to read revision number: %d\n", ret);
0373         return ret;
0374     }
0375
0376     val &= TFA989X_REVISIONNUMBER_REV_MSK;
0377     if (val != rev->rev) {
0378         dev_err(dev, "invalid revision number, expected %#x, got %#x\n",
0379             rev->rev, val);
0380         return -ENODEV;
0381     }
0382
0383     ret = regmap_write(regmap, TFA989X_SYS_CTRL, BIT(TFA989X_SYS_CTRL_I2CR));
0384     if (ret) {
0385         dev_err(dev, "failed to reset I2C registers: %d\n", ret);
0386         return ret;
0387     }
0388
0389     ret = rev->init(regmap);
0390     if (ret) {
0391         dev_err(dev, "failed to initialize registers: %d\n", ret);
0392         return ret;
0393     }
0394
0395     ret = tfa989x_dsp_bypass(regmap);
0396     if (ret) {
0397         dev_err(dev, "failed to enable DSP bypass: %d\n", ret);
0398         return ret;
0399     }
0400     regcache_cache_bypass(regmap, false);
0401
0402     return devm_snd_soc_register_component(dev, &tfa989x_component,
0403                            &tfa989x_dai, 1);
0404 }
0405
0406 static const struct of_device_id tfa989x_of_match[] = {
0407     { .compatible = "nxp,tfa9890", .data = &tfa9890_rev },
0408     { .compatible = "nxp,tfa9895", .data = &tfa9895_rev },
0409     { .compatible = "nxp,tfa9897", .data = &tfa9897_rev },
0410     { }
0411 };
0412 MODULE_DEVICE_TABLE(of, tfa989x_of_match);
0413
0414 static struct i2c_driver tfa989x_i2c_driver = {
0415     .driver = {
0416         .name = "tfa989x",
0417         .of_match_table = tfa989x_of_match,
0418     },
0419     .probe_new = tfa989x_i2c_probe,
0420 };
0421 module_i2c_driver(tfa989x_i2c_driver);
0422
0423 MODULE_DESCRIPTION("ASoC NXP/Goodix TFA989X (TFA1) driver");
0424 MODULE_AUTHOR("Stephan Gerhold <stephan@gerhold.net>");
0425 MODULE_LICENSE("GPL");