soc/codecs/cs4341.c

0001 /* SPDX-License-Identifier: GPL-2.0+ */
0002 /*
0003  *  Cirrus Logic CS4341A ALSA SoC Codec Driver
0004  *  Author: Alexander Shiyan <shc_work@mail.ru>
0005  */
0006
0007 #include <linux/i2c.h>
0008 #include <linux/module.h>
0009 #include <linux/of.h>
0010 #include <linux/regmap.h>
0011 #include <linux/spi/spi.h>
0012
0013 #include <sound/pcm.h>
0014 #include <sound/pcm_params.h>
0015 #include <sound/soc.h>
0016 #include <sound/tlv.h>
0017
0018 #define CS4341_REG_MODE1    0x00
0019 #define CS4341_REG_MODE2    0x01
0020 #define CS4341_REG_MIX      0x02
0021 #define CS4341_REG_VOLA     0x03
0022 #define CS4341_REG_VOLB     0x04
0023
0024 #define CS4341_MODE2_DIF    (7 << 4)
0025 #define CS4341_MODE2_DIF_I2S_24 (0 << 4)
0026 #define CS4341_MODE2_DIF_I2S_16 (1 << 4)
0027 #define CS4341_MODE2_DIF_LJ_24  (2 << 4)
0028 #define CS4341_MODE2_DIF_RJ_24  (3 << 4)
0029 #define CS4341_MODE2_DIF_RJ_16  (5 << 4)
0030 #define CS4341_VOLX_MUTE    (1 << 7)
0031
0032 struct cs4341_priv {
0033     unsigned int        fmt;
0034     struct regmap       *regmap;
0035     struct regmap_config    regcfg;
0036 };
0037
0038 static const struct reg_default cs4341_reg_defaults[] = {
0039     { CS4341_REG_MODE1, 0x00 },
0040     { CS4341_REG_MODE2, 0x82 },
0041     { CS4341_REG_MIX,   0x49 },
0042     { CS4341_REG_VOLA,  0x80 },
0043     { CS4341_REG_VOLB,  0x80 },
0044 };
0045
0046 static int cs4341_set_fmt(struct snd_soc_dai *dai, unsigned int format)
0047 {
0048     struct snd_soc_component *component = dai->component;
0049     struct cs4341_priv *cs4341 = snd_soc_component_get_drvdata(component);
0050
0051     switch (format & SND_SOC_DAIFMT_MASTER_MASK) {
0052     case SND_SOC_DAIFMT_CBS_CFS:
0053         break;
0054     default:
0055         return -EINVAL;
0056     }
0057
0058     switch (format & SND_SOC_DAIFMT_INV_MASK) {
0059     case SND_SOC_DAIFMT_NB_NF:
0060         break;
0061     default:
0062         return -EINVAL;
0063     }
0064
0065     switch (format & SND_SOC_DAIFMT_FORMAT_MASK) {
0066     case SND_SOC_DAIFMT_I2S:
0067     case SND_SOC_DAIFMT_LEFT_J:
0068     case SND_SOC_DAIFMT_RIGHT_J:
0069         cs4341->fmt = format & SND_SOC_DAIFMT_FORMAT_MASK;
0070         break;
0071     default:
0072         return -EINVAL;
0073     }
0074
0075     return 0;
0076 }
0077
0078 static int cs4341_hw_params(struct snd_pcm_substream *substream,
0079                 struct snd_pcm_hw_params *params,
0080                 struct snd_soc_dai *dai)
0081 {
0082     struct snd_soc_component *component = dai->component;
0083     struct cs4341_priv *cs4341 = snd_soc_component_get_drvdata(component);
0084     unsigned int mode = 0;
0085     int b24 = 0;
0086
0087     switch (params_format(params)) {
0088     case SNDRV_PCM_FORMAT_S24_LE:
0089         b24 = 1;
0090         break;
0091     case SNDRV_PCM_FORMAT_S16_LE:
0092         break;
0093     default:
0094         dev_err(component->dev, "Unsupported PCM format 0x%08x.\n",
0095             params_format(params));
0096         return -EINVAL;
0097     }
0098
0099     switch (cs4341->fmt) {
0100     case SND_SOC_DAIFMT_I2S:
0101         mode = b24 ? CS4341_MODE2_DIF_I2S_24 : CS4341_MODE2_DIF_I2S_16;
0102         break;
0103     case SND_SOC_DAIFMT_LEFT_J:
0104         mode = CS4341_MODE2_DIF_LJ_24;
0105         break;
0106     case SND_SOC_DAIFMT_RIGHT_J:
0107         mode = b24 ? CS4341_MODE2_DIF_RJ_24 : CS4341_MODE2_DIF_RJ_16;
0108         break;
0109     default:
0110         dev_err(component->dev, "Unsupported DAI format 0x%08x.\n",
0111             cs4341->fmt);
0112         return -EINVAL;
0113     }
0114
0115     return snd_soc_component_update_bits(component, CS4341_REG_MODE2,
0116                          CS4341_MODE2_DIF, mode);
0117 }
0118
0119 static int cs4341_mute(struct snd_soc_dai *dai, int mute, int direction)
0120 {
0121     struct snd_soc_component *component = dai->component;
0122     int ret;
0123
0124     ret = snd_soc_component_update_bits(component, CS4341_REG_VOLA,
0125                         CS4341_VOLX_MUTE,
0126                         mute ? CS4341_VOLX_MUTE : 0);
0127     if (ret < 0)
0128         return ret;
0129
0130     return snd_soc_component_update_bits(component, CS4341_REG_VOLB,
0131                          CS4341_VOLX_MUTE,
0132                          mute ? CS4341_VOLX_MUTE : 0);
0133 }
0134
0135 static DECLARE_TLV_DB_SCALE(out_tlv, -9000, 100, 0);
0136
0137 static const char * const deemph[] = {
0138     "None", "44.1k", "48k", "32k",
0139 };
0140
0141 static const struct soc_enum deemph_enum =
0142     SOC_ENUM_SINGLE(CS4341_REG_MODE2, 2, 4, deemph);
0143
0144 static const char * const srzc[] = {
0145     "Immediate", "Zero Cross", "Soft Ramp", "SR on ZC",
0146 };
0147
0148 static const struct soc_enum srzc_enum =
0149     SOC_ENUM_SINGLE(CS4341_REG_MIX, 5, 4, srzc);
0150
0151
0152 static const struct snd_soc_dapm_widget cs4341_dapm_widgets[] = {
0153     SND_SOC_DAPM_DAC("HiFi DAC", NULL, SND_SOC_NOPM, 0, 0),
0154     SND_SOC_DAPM_OUTPUT("OutA"),
0155     SND_SOC_DAPM_OUTPUT("OutB"),
0156 };
0157
0158 static const struct snd_soc_dapm_route cs4341_routes[] = {
0159     { "OutA", NULL, "HiFi DAC" },
0160     { "OutB", NULL, "HiFi DAC" },
0161     { "DAC Playback", NULL, "OutA" },
0162     { "DAC Playback", NULL, "OutB" },
0163 };
0164
0165 static const struct snd_kcontrol_new cs4341_controls[] = {
0166     SOC_DOUBLE_R_TLV("Master Playback Volume",
0167              CS4341_REG_VOLA, CS4341_REG_VOLB, 0, 90, 1, out_tlv),
0168     SOC_ENUM("De-Emphasis Control", deemph_enum),
0169     SOC_ENUM("Soft Ramp Zero Cross Control", srzc_enum),
0170     SOC_SINGLE("Auto-Mute Switch", CS4341_REG_MODE2, 7, 1, 0),
0171     SOC_SINGLE("Popguard Transient Switch", CS4341_REG_MODE2, 1, 1, 0),
0172 };
0173
0174 static const struct snd_soc_dai_ops cs4341_dai_ops = {
0175     .set_fmt    = cs4341_set_fmt,
0176     .hw_params  = cs4341_hw_params,
0177     .mute_stream    = cs4341_mute,
0178     .no_capture_mute = 1,
0179 };
0180
0181 static struct snd_soc_dai_driver cs4341_dai = {
0182     .name           = "cs4341a-hifi",
0183     .playback       = {
0184         .stream_name    = "DAC Playback",
0185         .channels_min   = 1,
0186         .channels_max   = 2,
0187         .rates      = SNDRV_PCM_RATE_8000_96000,
0188         .formats    = SNDRV_PCM_FMTBIT_S16_LE |
0189                   SNDRV_PCM_FMTBIT_S24_LE,
0190     },
0191     .ops            = &cs4341_dai_ops,
0192     .symmetric_rate     = 1,
0193 };
0194
0195 static const struct snd_soc_component_driver soc_component_cs4341 = {
0196     .controls       = cs4341_controls,
0197     .num_controls       = ARRAY_SIZE(cs4341_controls),
0198     .dapm_widgets       = cs4341_dapm_widgets,
0199     .num_dapm_widgets   = ARRAY_SIZE(cs4341_dapm_widgets),
0200     .dapm_routes        = cs4341_routes,
0201     .num_dapm_routes    = ARRAY_SIZE(cs4341_routes),
0202     .idle_bias_on       = 1,
0203     .use_pmdown_time    = 1,
0204     .endianness     = 1,
0205 };
0206
0207 static const struct of_device_id __maybe_unused cs4341_dt_ids[] = {
0208     { .compatible = "cirrus,cs4341a", },
0209     { }
0210 };
0211 MODULE_DEVICE_TABLE(of, cs4341_dt_ids);
0212
0213 static int cs4341_probe(struct device *dev)
0214 {
0215     struct cs4341_priv *cs4341 = dev_get_drvdata(dev);
0216     int i;
0217
0218     for (i = 0; i < ARRAY_SIZE(cs4341_reg_defaults); i++)
0219         regmap_write(cs4341->regmap, cs4341_reg_defaults[i].reg,
0220                  cs4341_reg_defaults[i].def);
0221
0222     return devm_snd_soc_register_component(dev, &soc_component_cs4341,
0223                            &cs4341_dai, 1);
0224 }
0225
0226 #if IS_ENABLED(CONFIG_I2C)
0227 static int cs4341_i2c_probe(struct i2c_client *i2c)
0228 {
0229     struct cs4341_priv *cs4341;
0230
0231     cs4341 = devm_kzalloc(&i2c->dev, sizeof(*cs4341), GFP_KERNEL);
0232     if (!cs4341)
0233         return -ENOMEM;
0234
0235     i2c_set_clientdata(i2c, cs4341);
0236
0237     cs4341->regcfg.reg_bits     = 8;
0238     cs4341->regcfg.val_bits     = 8;
0239     cs4341->regcfg.max_register = CS4341_REG_VOLB;
0240     cs4341->regcfg.cache_type   = REGCACHE_FLAT;
0241     cs4341->regcfg.reg_defaults = cs4341_reg_defaults;
0242     cs4341->regcfg.num_reg_defaults = ARRAY_SIZE(cs4341_reg_defaults);
0243     cs4341->regmap = devm_regmap_init_i2c(i2c, &cs4341->regcfg);
0244     if (IS_ERR(cs4341->regmap))
0245         return PTR_ERR(cs4341->regmap);
0246
0247     return cs4341_probe(&i2c->dev);
0248 }
0249
0250 static const struct i2c_device_id cs4341_i2c_id[] = {
0251     { "cs4341", 0 },
0252     { }
0253 };
0254 MODULE_DEVICE_TABLE(i2c, cs4341_i2c_id);
0255
0256 static struct i2c_driver cs4341_i2c_driver = {
0257     .driver = {
0258         .name = "cs4341-i2c",
0259         .of_match_table = of_match_ptr(cs4341_dt_ids),
0260     },
0261     .probe_new = cs4341_i2c_probe,
0262     .id_table = cs4341_i2c_id,
0263 };
0264 #endif
0265
0266 #if defined(CONFIG_SPI_MASTER)
0267 static bool cs4341_reg_readable(struct device *dev, unsigned int reg)
0268 {
0269     return false;
0270 }
0271
0272 static int cs4341_spi_probe(struct spi_device *spi)
0273 {
0274     struct cs4341_priv *cs4341;
0275     int ret;
0276
0277     cs4341 = devm_kzalloc(&spi->dev, sizeof(*cs4341), GFP_KERNEL);
0278     if (!cs4341)
0279         return -ENOMEM;
0280
0281     if (!spi->bits_per_word)
0282         spi->bits_per_word = 8;
0283     if (!spi->max_speed_hz)
0284         spi->max_speed_hz = 6000000;
0285     ret = spi_setup(spi);
0286     if (ret)
0287         return ret;
0288
0289     spi_set_drvdata(spi, cs4341);
0290
0291     cs4341->regcfg.reg_bits     = 16;
0292     cs4341->regcfg.val_bits     = 8;
0293     cs4341->regcfg.write_flag_mask  = 0x20;
0294     cs4341->regcfg.max_register = CS4341_REG_VOLB;
0295     cs4341->regcfg.cache_type   = REGCACHE_FLAT;
0296     cs4341->regcfg.readable_reg = cs4341_reg_readable;
0297     cs4341->regcfg.reg_defaults = cs4341_reg_defaults;
0298     cs4341->regcfg.num_reg_defaults = ARRAY_SIZE(cs4341_reg_defaults);
0299     cs4341->regmap = devm_regmap_init_spi(spi, &cs4341->regcfg);
0300     if (IS_ERR(cs4341->regmap))
0301         return PTR_ERR(cs4341->regmap);
0302
0303     return cs4341_probe(&spi->dev);
0304 }
0305
0306 static const struct spi_device_id cs4341_spi_ids[] = {
0307     { "cs4341a" },
0308     { }
0309 };
0310 MODULE_DEVICE_TABLE(spi, cs4341_spi_ids);
0311
0312 static struct spi_driver cs4341_spi_driver = {
0313     .driver = {
0314         .name = "cs4341-spi",
0315         .of_match_table = of_match_ptr(cs4341_dt_ids),
0316     },
0317     .probe = cs4341_spi_probe,
0318     .id_table = cs4341_spi_ids,
0319 };
0320 #endif
0321
0322 static int __init cs4341_init(void)
0323 {
0324     int ret = 0;
0325
0326 #if IS_ENABLED(CONFIG_I2C)
0327     ret = i2c_add_driver(&cs4341_i2c_driver);
0328     if (ret)
0329         return ret;
0330 #endif
0331 #if defined(CONFIG_SPI_MASTER)
0332     ret = spi_register_driver(&cs4341_spi_driver);
0333 #endif
0334
0335     return ret;
0336 }
0337 module_init(cs4341_init);
0338
0339 static void __exit cs4341_exit(void)
0340 {
0341 #if IS_ENABLED(CONFIG_I2C)
0342     i2c_del_driver(&cs4341_i2c_driver);
0343 #endif
0344 #if defined(CONFIG_SPI_MASTER)
0345     spi_unregister_driver(&cs4341_spi_driver);
0346 #endif
0347 }
0348 module_exit(cs4341_exit);
0349
0350 MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
0351 MODULE_DESCRIPTION("Cirrus Logic CS4341 ALSA SoC Codec Driver");
0352 MODULE_LICENSE("GPL");