drivers/regulator/rt4801-regulator.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002
0003 #include <linux/gpio/consumer.h>
0004 #include <linux/i2c.h>
0005 #include <linux/kernel.h>
0006 #include <linux/module.h>
0007 #include <linux/of.h>
0008 #include <linux/regmap.h>
0009 #include <linux/regulator/driver.h>
0010
0011 #define RT4801_REG_VOP  0x00
0012 #define RT4801_REG_VON  0x01
0013 #define RT4801_REG_APPS 0x03
0014
0015 #define VOUT_MASK   0x1F
0016
0017 #define MIN_UV      4000000
0018 #define STEP_UV     100000
0019 #define MAX_UV      6000000
0020 #define N_VOLTAGES  ((MAX_UV - MIN_UV) / STEP_UV + 1)
0021
0022 #define DSV_OUT_POS 0
0023 #define DSV_OUT_NEG 1
0024 #define DSV_OUT_MAX 2
0025
0026 #define DSVP_ENABLE BIT(0)
0027 #define DSVN_ENABLE BIT(1)
0028 #define DSVALL_ENABLE   (DSVP_ENABLE | DSVN_ENABLE)
0029
0030 struct rt4801_priv {
0031     struct device *dev;
0032     struct gpio_desc *enable_gpios[DSV_OUT_MAX];
0033     unsigned int enable_flag;
0034     unsigned int volt_sel[DSV_OUT_MAX];
0035 };
0036
0037 static int rt4801_of_parse_cb(struct device_node *np,
0038                   const struct regulator_desc *desc,
0039                   struct regulator_config *config)
0040 {
0041     struct rt4801_priv *priv = config->driver_data;
0042     int id = desc->id;
0043
0044     if (priv->enable_gpios[id]) {
0045         dev_warn(priv->dev, "duplicated enable-gpios property\n");
0046         return 0;
0047     }
0048     priv->enable_gpios[id] = devm_fwnode_gpiod_get_index(priv->dev,
0049                                  of_fwnode_handle(np),
0050                                  "enable", 0,
0051                                  GPIOD_OUT_HIGH,
0052                                  "rt4801");
0053     if (IS_ERR(priv->enable_gpios[id]))
0054         priv->enable_gpios[id] = NULL;
0055
0056     return 0;
0057 }
0058
0059 static int rt4801_set_voltage_sel(struct regulator_dev *rdev, unsigned int selector)
0060 {
0061     struct rt4801_priv *priv = rdev_get_drvdata(rdev);
0062     int id = rdev_get_id(rdev), ret;
0063
0064     if (priv->enable_flag & BIT(id)) {
0065         ret = regulator_set_voltage_sel_regmap(rdev, selector);
0066         if (ret)
0067             return ret;
0068     }
0069
0070     priv->volt_sel[id] = selector;
0071     return 0;
0072 }
0073
0074 static int rt4801_get_voltage_sel(struct regulator_dev *rdev)
0075 {
0076     struct rt4801_priv *priv = rdev_get_drvdata(rdev);
0077     int id = rdev_get_id(rdev);
0078
0079     if (priv->enable_flag & BIT(id))
0080         return regulator_get_voltage_sel_regmap(rdev);
0081
0082     return priv->volt_sel[id];
0083 }
0084
0085 static int rt4801_enable(struct regulator_dev *rdev)
0086 {
0087     struct rt4801_priv *priv = rdev_get_drvdata(rdev);
0088     int id = rdev_get_id(rdev), ret;
0089
0090     if (!priv->enable_gpios[id]) {
0091         dev_warn(&rdev->dev, "no dedicated gpio can control\n");
0092         goto bypass_gpio;
0093     }
0094
0095     gpiod_set_value(priv->enable_gpios[id], 1);
0096
0097 bypass_gpio:
0098     ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, priv->volt_sel[id]);
0099     if (ret)
0100         return ret;
0101
0102     priv->enable_flag |= BIT(id);
0103     return 0;
0104 }
0105
0106 static int rt4801_disable(struct regulator_dev *rdev)
0107 {
0108     struct rt4801_priv *priv = rdev_get_drvdata(rdev);
0109     int id = rdev_get_id(rdev);
0110
0111     if (!priv->enable_gpios[id]) {
0112         dev_warn(&rdev->dev, "no dedicated gpio can control\n");
0113         goto bypass_gpio;
0114     }
0115
0116     gpiod_set_value(priv->enable_gpios[id], 0);
0117
0118 bypass_gpio:
0119     priv->enable_flag &= ~BIT(id);
0120     return 0;
0121 }
0122
0123 static int rt4801_is_enabled(struct regulator_dev *rdev)
0124 {
0125     struct rt4801_priv *priv = rdev_get_drvdata(rdev);
0126     int id = rdev_get_id(rdev);
0127
0128     return !!(priv->enable_flag & BIT(id));
0129 }
0130
0131 static const struct regulator_ops rt4801_regulator_ops = {
0132     .list_voltage = regulator_list_voltage_linear,
0133     .set_voltage_sel = rt4801_set_voltage_sel,
0134     .get_voltage_sel = rt4801_get_voltage_sel,
0135     .enable = rt4801_enable,
0136     .disable = rt4801_disable,
0137     .is_enabled = rt4801_is_enabled,
0138 };
0139
0140 static const struct regulator_desc rt4801_regulator_descs[] = {
0141     {
0142         .name = "DSVP",
0143         .ops = &rt4801_regulator_ops,
0144         .of_match = of_match_ptr("DSVP"),
0145         .of_parse_cb = rt4801_of_parse_cb,
0146         .type = REGULATOR_VOLTAGE,
0147         .id = DSV_OUT_POS,
0148         .min_uV = MIN_UV,
0149         .uV_step = STEP_UV,
0150         .n_voltages = N_VOLTAGES,
0151         .owner = THIS_MODULE,
0152         .vsel_reg = RT4801_REG_VOP,
0153         .vsel_mask = VOUT_MASK,
0154     },
0155     {
0156         .name = "DSVN",
0157         .ops = &rt4801_regulator_ops,
0158         .of_match = of_match_ptr("DSVN"),
0159         .of_parse_cb = rt4801_of_parse_cb,
0160         .type = REGULATOR_VOLTAGE,
0161         .id = DSV_OUT_NEG,
0162         .min_uV = MIN_UV,
0163         .uV_step = STEP_UV,
0164         .n_voltages = N_VOLTAGES,
0165         .owner = THIS_MODULE,
0166         .vsel_reg = RT4801_REG_VON,
0167         .vsel_mask = VOUT_MASK,
0168     },
0169 };
0170
0171 static const struct regmap_config rt4801_regmap_config = {
0172     .reg_bits = 8,
0173     .val_bits = 8,
0174     .max_register = RT4801_REG_APPS,
0175 };
0176
0177 static int rt4801_probe(struct i2c_client *i2c)
0178 {
0179     struct rt4801_priv *priv;
0180     struct regmap *regmap;
0181     int i;
0182
0183     priv = devm_kzalloc(&i2c->dev, sizeof(*priv), GFP_KERNEL);
0184     if (!priv)
0185         return -ENOMEM;
0186
0187     priv->dev = &i2c->dev;
0188     /* bootloader will on, driver only reconfigure enable to all output high */
0189     priv->enable_flag = DSVALL_ENABLE;
0190
0191     regmap = devm_regmap_init_i2c(i2c, &rt4801_regmap_config);
0192     if (IS_ERR(regmap)) {
0193         dev_err(&i2c->dev, "Failed to init regmap\n");
0194         return PTR_ERR(regmap);
0195     }
0196
0197     for (i = 0; i < DSV_OUT_MAX; i++) {
0198         priv->enable_gpios[i] = devm_gpiod_get_index_optional(&i2c->dev,
0199                                       "enable",
0200                                       i,
0201                                       GPIOD_OUT_HIGH);
0202         if (IS_ERR(priv->enable_gpios[i])) {
0203             dev_err(&i2c->dev, "Failed to get gpios\n");
0204             return PTR_ERR(priv->enable_gpios[i]);
0205         }
0206     }
0207
0208     for (i = 0; i < DSV_OUT_MAX; i++) {
0209         const struct regulator_desc *desc = rt4801_regulator_descs + i;
0210         struct regulator_config config = { .dev = &i2c->dev, .driver_data = priv,
0211                            .regmap = regmap, };
0212         struct regulator_dev *rdev;
0213         unsigned int val;
0214         int ret;
0215
0216         /* initialize volt_sel variable */
0217         ret = regmap_read(regmap, desc->vsel_reg, &val);
0218         if (ret)
0219             return ret;
0220
0221         priv->volt_sel[i] = val & desc->vsel_mask;
0222
0223         rdev = devm_regulator_register(&i2c->dev, desc, &config);
0224         if (IS_ERR(rdev)) {
0225             dev_err(&i2c->dev, "Failed to register [%d] regulator\n", i);
0226             return PTR_ERR(rdev);
0227         }
0228     }
0229
0230     return 0;
0231 }
0232
0233 static const struct of_device_id __maybe_unused rt4801_of_id[] = {
0234     { .compatible = "richtek,rt4801", },
0235     { },
0236 };
0237 MODULE_DEVICE_TABLE(of, rt4801_of_id);
0238
0239 static struct i2c_driver rt4801_driver = {
0240     .driver = {
0241         .name = "rt4801",
0242         .of_match_table = of_match_ptr(rt4801_of_id),
0243     },
0244     .probe_new = rt4801_probe,
0245 };
0246 module_i2c_driver(rt4801_driver);
0247
0248 MODULE_AUTHOR("ChiYuan Hwang <cy_huang@richtek.com>");
0249 MODULE_DESCRIPTION("Richtek RT4801 Display Bias Driver");
0250 MODULE_LICENSE("GPL v2");