drivers/regulator/rt5120-regulator.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002
0003 #include <linux/bits.h>
0004 #include <linux/kernel.h>
0005 #include <linux/module.h>
0006 #include <linux/of.h>
0007 #include <linux/platform_device.h>
0008 #include <linux/regmap.h>
0009 #include <linux/regulator/driver.h>
0010 #include <linux/regulator/machine.h>
0011 #include <linux/regulator/of_regulator.h>
0012
0013 #define RT5120_REG_PGSTAT   0x03
0014 #define RT5120_REG_CH1VID   0x06
0015 #define RT5120_REG_CH1SLPVID    0x07
0016 #define RT5120_REG_ENABLE   0x08
0017 #define RT5120_REG_MODECTL  0x09
0018 #define RT5120_REG_UVOVPROT 0x0A
0019 #define RT5120_REG_SLPCTL   0x0C
0020 #define RT5120_REG_INTSTAT  0x1E
0021 #define RT5120_REG_DISCHG   0x1F
0022
0023 #define RT5120_OUTPG_MASK(rid)  BIT(rid + 1)
0024 #define RT5120_OUTUV_MASK(rid)  BIT(rid + 9)
0025 #define RT5120_OUTOV_MASK(rid)  BIT(rid + 16)
0026 #define RT5120_CH1VID_MASK  GENMASK(6, 0)
0027 #define RT5120_RIDEN_MASK(rid)  BIT(rid + 1)
0028 #define RT5120_RADEN_MASK(rid)  BIT(rid)
0029 #define RT5120_FPWM_MASK(rid)   BIT(rid + 1)
0030 #define RT5120_UVHICCUP_MASK    BIT(1)
0031 #define RT5120_OVHICCUP_MASK    BIT(0)
0032 #define RT5120_HOTDIE_MASK  BIT(1)
0033
0034 #define RT5120_BUCK1_MINUV  600000
0035 #define RT5120_BUCK1_MAXUV  1393750
0036 #define RT5120_BUCK1_STEPUV 6250
0037 #define RT5120_BUCK1_NUM_VOLT   0x80
0038
0039 #define RT5120_AUTO_MODE    0
0040 #define RT5120_FPWM_MODE    1
0041
0042 enum {
0043     RT5120_REGULATOR_BUCK1 = 0,
0044     RT5120_REGULATOR_BUCK2,
0045     RT5120_REGULATOR_BUCK3,
0046     RT5120_REGULATOR_BUCK4,
0047     RT5120_REGULATOR_LDO,
0048     RT5120_REGULATOR_EXTEN,
0049     RT5120_MAX_REGULATOR
0050 };
0051
0052 struct rt5120_priv {
0053     struct device *dev;
0054     struct regmap *regmap;
0055     struct regulator_desc rdesc[RT5120_MAX_REGULATOR];
0056 };
0057
0058 static int rt5120_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
0059 {
0060     struct regmap *regmap = rdev_get_regmap(rdev);
0061     int rid = rdev_get_id(rdev);
0062     unsigned int mask = RT5120_FPWM_MASK(rid), val;
0063
0064     switch (mode) {
0065     case REGULATOR_MODE_NORMAL:
0066         val = 0;
0067         break;
0068     case REGULATOR_MODE_FAST:
0069         val = RT5120_FPWM_MASK(rid);
0070         break;
0071     default:
0072         return -EINVAL;
0073     }
0074
0075     return regmap_update_bits(regmap, RT5120_REG_MODECTL, mask, val);
0076 }
0077
0078 static unsigned int rt5120_buck_get_mode(struct regulator_dev *rdev)
0079 {
0080     struct regmap *regmap = rdev_get_regmap(rdev);
0081     int ret, rid = rdev_get_id(rdev);
0082     unsigned int val;
0083
0084     ret = regmap_read(regmap, RT5120_REG_MODECTL, &val);
0085     if (ret)
0086         return REGULATOR_MODE_INVALID;
0087
0088     if (val & RT5120_FPWM_MASK(rid))
0089         return REGULATOR_MODE_FAST;
0090
0091     return REGULATOR_MODE_NORMAL;
0092 }
0093
0094 static int rt5120_regulator_get_error_flags(struct regulator_dev *rdev,
0095                         unsigned int *flags)
0096 {
0097     struct regmap *regmap = rdev_get_regmap(rdev);
0098     unsigned int stat, hd_stat, cur_flags = 0;
0099     int rid = rdev_get_id(rdev), ret;
0100
0101     /*
0102      * reg 0x03/0x04/0x05 to indicate PG/UV/OV
0103      * use block read to descrease I/O xfer time
0104      */
0105     ret = regmap_raw_read(regmap, RT5120_REG_PGSTAT, &stat, 3);
0106     if (ret)
0107         return ret;
0108
0109     ret = regmap_read(regmap, RT5120_REG_INTSTAT, &hd_stat);
0110     if (ret)
0111         return ret;
0112
0113     if (!(stat & RT5120_OUTPG_MASK(rid))) {
0114         if (stat & RT5120_OUTUV_MASK(rid))
0115             cur_flags |= REGULATOR_ERROR_UNDER_VOLTAGE;
0116
0117         if (stat & RT5120_OUTOV_MASK(rid))
0118             cur_flags |= REGULATOR_ERROR_REGULATION_OUT;
0119     }
0120
0121     if (hd_stat & RT5120_HOTDIE_MASK)
0122         cur_flags |= REGULATOR_ERROR_OVER_TEMP;
0123
0124     *flags = cur_flags;
0125     return 0;
0126 }
0127
0128 static int rt5120_buck1_set_suspend_voltage(struct regulator_dev *rdev, int uV)
0129 {
0130     struct regmap *regmap = rdev_get_regmap(rdev);
0131     int sel;
0132
0133     if (uV < RT5120_BUCK1_MINUV || uV > RT5120_BUCK1_MAXUV)
0134         return -EINVAL;
0135
0136     sel = (uV - RT5120_BUCK1_MINUV) / RT5120_BUCK1_STEPUV;
0137     return regmap_write(regmap, RT5120_REG_CH1SLPVID, sel);
0138 }
0139
0140 static int rt5120_regulator_set_suspend_enable(struct regulator_dev *rdev)
0141 {
0142     struct regmap *regmap = rdev_get_regmap(rdev);
0143     int rid = rdev_get_id(rdev);
0144     unsigned int mask = RT5120_RIDEN_MASK(rid);
0145
0146     return regmap_update_bits(regmap, RT5120_REG_SLPCTL, mask, mask);
0147 }
0148
0149 static int rt5120_regulator_set_suspend_disable(struct regulator_dev *rdev)
0150 {
0151     struct regmap *regmap = rdev_get_regmap(rdev);
0152     int rid = rdev_get_id(rdev);
0153     unsigned int mask = RT5120_RIDEN_MASK(rid);
0154
0155     return regmap_update_bits(regmap, RT5120_REG_SLPCTL, mask, 0);
0156 }
0157
0158 static const struct regulator_ops rt5120_buck1_ops = {
0159     .enable = regulator_enable_regmap,
0160     .disable = regulator_disable_regmap,
0161     .is_enabled = regulator_is_enabled_regmap,
0162     .list_voltage = regulator_list_voltage_linear,
0163     .set_voltage_sel = regulator_set_voltage_sel_regmap,
0164     .get_voltage_sel = regulator_get_voltage_sel_regmap,
0165     .set_active_discharge = regulator_set_active_discharge_regmap,
0166     .set_mode = rt5120_buck_set_mode,
0167     .get_mode = rt5120_buck_get_mode,
0168     .get_error_flags = rt5120_regulator_get_error_flags,
0169     .set_suspend_voltage = rt5120_buck1_set_suspend_voltage,
0170     .set_suspend_enable = rt5120_regulator_set_suspend_enable,
0171     .set_suspend_disable = rt5120_regulator_set_suspend_disable,
0172 };
0173
0174 static const struct regulator_ops rt5120_buck234_ops = {
0175     .enable = regulator_enable_regmap,
0176     .disable = regulator_disable_regmap,
0177     .is_enabled = regulator_is_enabled_regmap,
0178     .set_active_discharge = regulator_set_active_discharge_regmap,
0179     .set_mode = rt5120_buck_set_mode,
0180     .get_mode = rt5120_buck_get_mode,
0181     .get_error_flags = rt5120_regulator_get_error_flags,
0182     .set_suspend_enable = rt5120_regulator_set_suspend_enable,
0183     .set_suspend_disable = rt5120_regulator_set_suspend_disable,
0184 };
0185
0186 static const struct regulator_ops rt5120_ldo_ops = {
0187     .enable = regulator_enable_regmap,
0188     .disable = regulator_disable_regmap,
0189     .is_enabled = regulator_is_enabled_regmap,
0190     .set_active_discharge = regulator_set_active_discharge_regmap,
0191     .get_error_flags = rt5120_regulator_get_error_flags,
0192     .set_suspend_enable = rt5120_regulator_set_suspend_enable,
0193     .set_suspend_disable = rt5120_regulator_set_suspend_disable,
0194 };
0195
0196 static const struct regulator_ops rt5120_exten_ops = {
0197     .enable = regulator_enable_regmap,
0198     .disable = regulator_disable_regmap,
0199     .is_enabled = regulator_is_enabled_regmap,
0200     .set_suspend_enable = rt5120_regulator_set_suspend_enable,
0201     .set_suspend_disable = rt5120_regulator_set_suspend_disable,
0202 };
0203
0204 static unsigned int rt5120_buck_of_map_mode(unsigned int mode)
0205 {
0206     switch (mode) {
0207     case RT5120_AUTO_MODE:
0208         return REGULATOR_MODE_NORMAL;
0209     case RT5120_FPWM_MODE:
0210         return REGULATOR_MODE_FAST;
0211     default:
0212         return REGULATOR_MODE_INVALID;
0213     }
0214 }
0215
0216 static void rt5120_fillin_regulator_desc(struct regulator_desc *desc, int rid)
0217 {
0218     static const char * const name[] = {
0219         "buck1", "buck2", "buck3", "buck4", "ldo", "exten" };
0220     static const char * const sname[] = {
0221         "vin1", "vin2", "vin3", "vin4", "vinldo", NULL };
0222
0223     /* Common regulator property */
0224     desc->name = name[rid];
0225     desc->supply_name = sname[rid];
0226     desc->owner = THIS_MODULE;
0227     desc->type = REGULATOR_VOLTAGE;
0228     desc->id = rid;
0229     desc->enable_reg = RT5120_REG_ENABLE;
0230     desc->enable_mask = RT5120_RIDEN_MASK(rid);
0231     desc->active_discharge_reg = RT5120_REG_DISCHG;
0232     desc->active_discharge_mask = RT5120_RADEN_MASK(rid);
0233     desc->active_discharge_on = RT5120_RADEN_MASK(rid);
0234     /* Config n_voltages to 1 for all*/
0235     desc->n_voltages = 1;
0236
0237     /* Only buck support mode change */
0238     if (rid >= RT5120_REGULATOR_BUCK1 && rid <= RT5120_REGULATOR_BUCK4)
0239         desc->of_map_mode = rt5120_buck_of_map_mode;
0240
0241     /* RID specific property init */
0242     switch (rid) {
0243     case RT5120_REGULATOR_BUCK1:
0244         /* Only buck1 support voltage change by I2C */
0245         desc->n_voltages = RT5120_BUCK1_NUM_VOLT;
0246         desc->min_uV = RT5120_BUCK1_MINUV;
0247         desc->uV_step = RT5120_BUCK1_STEPUV;
0248         desc->vsel_reg = RT5120_REG_CH1VID,
0249         desc->vsel_mask = RT5120_CH1VID_MASK,
0250         desc->ops = &rt5120_buck1_ops;
0251         break;
0252     case RT5120_REGULATOR_BUCK2 ... RT5120_REGULATOR_BUCK4:
0253         desc->ops = &rt5120_buck234_ops;
0254         break;
0255     case RT5120_REGULATOR_LDO:
0256         desc->ops = &rt5120_ldo_ops;
0257         break;
0258     default:
0259         desc->ops = &rt5120_exten_ops;
0260     }
0261 }
0262
0263 static int rt5120_of_parse_cb(struct rt5120_priv *priv, int rid,
0264                   struct of_regulator_match *match)
0265 {
0266     struct regulator_desc *desc = priv->rdesc + rid;
0267     struct regulator_init_data *init_data = match->init_data;
0268
0269     if (!init_data || rid == RT5120_REGULATOR_BUCK1)
0270         return 0;
0271
0272     if (init_data->constraints.min_uV != init_data->constraints.max_uV) {
0273         dev_err(priv->dev, "Variable voltage for fixed regulator\n");
0274         return -EINVAL;
0275     }
0276
0277     desc->fixed_uV = init_data->constraints.min_uV;
0278     return 0;
0279 }
0280
0281 static struct of_regulator_match rt5120_regu_match[RT5120_MAX_REGULATOR] = {
0282     [RT5120_REGULATOR_BUCK1] = { .name = "buck1", },
0283     [RT5120_REGULATOR_BUCK2] = { .name = "buck2", },
0284     [RT5120_REGULATOR_BUCK3] = { .name = "buck3", },
0285     [RT5120_REGULATOR_BUCK4] = { .name = "buck4", },
0286     [RT5120_REGULATOR_LDO] = { .name = "ldo", },
0287     [RT5120_REGULATOR_EXTEN] = { .name = "exten", }
0288 };
0289
0290 static int rt5120_parse_regulator_dt_data(struct rt5120_priv *priv)
0291 {
0292     struct device *dev = priv->dev->parent;
0293     struct device_node *reg_node;
0294     int i, ret;
0295
0296     for (i = 0; i < RT5120_MAX_REGULATOR; i++) {
0297         rt5120_fillin_regulator_desc(priv->rdesc + i, i);
0298
0299         rt5120_regu_match[i].desc = priv->rdesc + i;
0300     }
0301
0302     reg_node = of_get_child_by_name(dev->of_node, "regulators");
0303     if (!reg_node) {
0304         dev_err(priv->dev, "Couldn't find 'regulators' node\n");
0305         return -ENODEV;
0306     }
0307
0308     ret = of_regulator_match(priv->dev, reg_node, rt5120_regu_match,
0309                  ARRAY_SIZE(rt5120_regu_match));
0310
0311     of_node_put(reg_node);
0312
0313     if (ret < 0) {
0314         dev_err(priv->dev,
0315             "Error parsing regulator init data (%d)\n", ret);
0316         return ret;
0317     }
0318
0319     for (i = 0; i < RT5120_MAX_REGULATOR; i++) {
0320         ret = rt5120_of_parse_cb(priv, i, rt5120_regu_match + i);
0321         if (ret) {
0322             dev_err(priv->dev, "Failed in [%d] of_passe_cb\n", i);
0323             return ret;
0324         }
0325     }
0326
0327     return 0;
0328 }
0329
0330 static int rt5120_device_property_init(struct rt5120_priv *priv)
0331 {
0332     struct device *dev = priv->dev->parent;
0333     struct device_node *np = dev->of_node;
0334     bool prot_enable;
0335     unsigned int prot_enable_val = 0;
0336
0337     /* Assign UV/OV HW protection behavior */
0338     prot_enable = of_property_read_bool(np,
0339                         "richtek,enable-undervolt-hiccup");
0340     if (prot_enable)
0341         prot_enable_val |= RT5120_UVHICCUP_MASK;
0342
0343     prot_enable = of_property_read_bool(np,
0344                         "richtek,enable-overvolt-hiccup");
0345     if (prot_enable)
0346         prot_enable_val |= RT5120_OVHICCUP_MASK;
0347
0348     return regmap_update_bits(priv->regmap, RT5120_REG_UVOVPROT,
0349                   RT5120_UVHICCUP_MASK | RT5120_OVHICCUP_MASK,
0350                   prot_enable_val);
0351 }
0352
0353 static int rt5120_regulator_probe(struct platform_device *pdev)
0354 {
0355     struct rt5120_priv *priv;
0356     struct regulator_dev *rdev;
0357     struct regulator_config config = {};
0358     int i, ret;
0359
0360     priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
0361     if (!priv)
0362         return -ENOMEM;
0363
0364     priv->dev = &pdev->dev;
0365
0366     priv->regmap = dev_get_regmap(pdev->dev.parent, NULL);
0367     if (!priv->regmap) {
0368         dev_err(&pdev->dev, "Failed to init regmap\n");
0369         return -ENODEV;
0370     }
0371
0372     ret = rt5120_device_property_init(priv);
0373     if (ret) {
0374         dev_err(&pdev->dev, "Failed to do property init\n");
0375         return ret;
0376     }
0377
0378     ret = rt5120_parse_regulator_dt_data(priv);
0379     if (ret) {
0380         dev_err(&pdev->dev, "Failed to parse dt data\n");
0381         return ret;
0382     }
0383
0384     config.dev = &pdev->dev;
0385     config.regmap = priv->regmap;
0386
0387     for (i = 0; i < RT5120_MAX_REGULATOR; i++) {
0388         config.of_node = rt5120_regu_match[i].of_node;
0389         config.init_data = rt5120_regu_match[i].init_data;
0390
0391         rdev = devm_regulator_register(&pdev->dev, priv->rdesc + i,
0392                            &config);
0393         if (IS_ERR(rdev)) {
0394             dev_err(&pdev->dev,
0395                 "Failed to register regulator [%d]\n", i);
0396             return PTR_ERR(rdev);
0397         }
0398     }
0399
0400     return 0;
0401 }
0402
0403 static const struct platform_device_id rt5120_regulator_dev_table[] = {
0404     { "rt5120-regulator", 0 },
0405     {}
0406 };
0407 MODULE_DEVICE_TABLE(platform, rt5120_regulator_dev_table);
0408
0409 static struct platform_driver rt5120_regulator_driver = {
0410     .driver = {
0411         .name = "rt5120-regulator",
0412     },
0413     .id_table = rt5120_regulator_dev_table,
0414     .probe = rt5120_regulator_probe,
0415 };
0416 module_platform_driver(rt5120_regulator_driver);
0417
0418 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
0419 MODULE_DESCRIPTION("Richtek RT5120 regulator driver");
0420 MODULE_LICENSE("GPL v2");