0001
0002
0003 #include <dt-bindings/regulator/richtek,rt5190a-regulator.h>
0004 #include <linux/bits.h>
0005 #include <linux/i2c.h>
0006 #include <linux/interrupt.h>
0007 #include <linux/kernel.h>
0008 #include <linux/module.h>
0009 #include <linux/of.h>
0010 #include <linux/property.h>
0011 #include <linux/regmap.h>
0012 #include <linux/regulator/driver.h>
0013 #include <linux/regulator/machine.h>
0014 #include <linux/regulator/of_regulator.h>
0015
0016 #define RT5190A_REG_MANUFACTURE 0x00
0017 #define RT5190A_REG_BUCK2VSEL 0x04
0018 #define RT5190A_REG_BUCK3VSEL 0x05
0019 #define RT5190A_REG_DCDCCNTL 0x06
0020 #define RT5190A_REG_ENABLE 0x07
0021 #define RT5190A_REG_DISCHARGE 0x09
0022 #define RT5190A_REG_PROTMODE 0x0A
0023 #define RT5190A_REG_MUTECNTL 0x0B
0024 #define RT5190A_REG_PGSTAT 0x0F
0025 #define RT5190A_REG_OVINT 0x10
0026 #define RT5190A_REG_HOTDIEMASK 0x17
0027
0028 #define RT5190A_VSEL_MASK GENMASK(6, 0)
0029 #define RT5190A_RID_BITMASK(rid) BIT(rid + 1)
0030 #define RT5190A_BUCK1_DISCHG_MASK GENMASK(1, 0)
0031 #define RT5190A_BUCK1_DISCHG_ONVAL 0x01
0032 #define RT5190A_OVERVOLT_MASK GENMASK(7, 0)
0033 #define RT5190A_UNDERVOLT_MASK GENMASK(15, 8)
0034 #define RT5190A_CH234OT_MASK BIT(29)
0035 #define RT5190A_CHIPOT_MASK BIT(28)
0036
0037 #define RT5190A_BUCK23_MINUV 600000
0038 #define RT5190A_BUCK23_MAXUV 1400000
0039 #define RT5190A_BUCK23_STEPUV 10000
0040 #define RT5190A_BUCK23_STEPNUM ((1400000 - 600000) / 10000 + 1)
0041
0042 enum {
0043 RT5190A_IDX_BUCK1 = 0,
0044 RT5190A_IDX_BUCK2,
0045 RT5190A_IDX_BUCK3,
0046 RT5190A_IDX_BUCK4,
0047 RT5190A_IDX_LDO,
0048 RT5190A_MAX_IDX
0049 };
0050
0051 struct rt5190a_priv {
0052 struct device *dev;
0053 struct regmap *regmap;
0054 struct regulator_desc rdesc[RT5190A_MAX_IDX];
0055 struct regulator_dev *rdev[RT5190A_MAX_IDX];
0056 };
0057
0058 static int rt5190a_get_error_flags(struct regulator_dev *rdev,
0059 unsigned int *flags)
0060 {
0061 struct regmap *regmap = rdev_get_regmap(rdev);
0062 int rid = rdev_get_id(rdev);
0063 unsigned int pgood_stat;
0064 int ret;
0065
0066 ret = regmap_read(regmap, RT5190A_REG_PGSTAT, &pgood_stat);
0067 if (ret)
0068 return ret;
0069
0070 if (!(pgood_stat & RT5190A_RID_BITMASK(rid)))
0071 *flags = REGULATOR_ERROR_FAIL;
0072 else
0073 *flags = 0;
0074
0075 return 0;
0076 }
0077
0078 static int rt5190a_fixed_buck_set_mode(struct regulator_dev *rdev,
0079 unsigned int mode)
0080 {
0081 struct regmap *regmap = rdev_get_regmap(rdev);
0082 int rid = rdev_get_id(rdev);
0083 unsigned int mask = RT5190A_RID_BITMASK(rid), val;
0084
0085 switch (mode) {
0086 case REGULATOR_MODE_FAST:
0087 val = mask;
0088 break;
0089 case REGULATOR_MODE_NORMAL:
0090 val = 0;
0091 break;
0092 default:
0093 return -EINVAL;
0094 }
0095
0096 return regmap_update_bits(regmap, RT5190A_REG_DCDCCNTL, mask, val);
0097 }
0098
0099 static unsigned int rt5190a_fixed_buck_get_mode(struct regulator_dev *rdev)
0100 {
0101 struct regmap *regmap = rdev_get_regmap(rdev);
0102 int rid = rdev_get_id(rdev);
0103 unsigned int val;
0104 int ret;
0105
0106 ret = regmap_read(regmap, RT5190A_REG_DCDCCNTL, &val);
0107 if (ret) {
0108 dev_err(&rdev->dev, "Failed to get mode [%d]\n", ret);
0109 return ret;
0110 }
0111
0112 if (val & RT5190A_RID_BITMASK(rid))
0113 return REGULATOR_MODE_FAST;
0114
0115 return REGULATOR_MODE_NORMAL;
0116 }
0117
0118 static const struct regulator_ops rt5190a_ranged_buck_ops = {
0119 .enable = regulator_enable_regmap,
0120 .disable = regulator_disable_regmap,
0121 .is_enabled = regulator_is_enabled_regmap,
0122 .set_voltage_sel = regulator_set_voltage_sel_regmap,
0123 .get_voltage_sel = regulator_get_voltage_sel_regmap,
0124 .list_voltage = regulator_list_voltage_linear,
0125 .set_active_discharge = regulator_set_active_discharge_regmap,
0126 .get_error_flags = rt5190a_get_error_flags,
0127 };
0128
0129 static const struct regulator_ops rt5190a_fixed_buck_ops = {
0130 .enable = regulator_enable_regmap,
0131 .disable = regulator_disable_regmap,
0132 .is_enabled = regulator_is_enabled_regmap,
0133 .set_active_discharge = regulator_set_active_discharge_regmap,
0134 .set_mode = rt5190a_fixed_buck_set_mode,
0135 .get_mode = rt5190a_fixed_buck_get_mode,
0136 .get_error_flags = rt5190a_get_error_flags,
0137 };
0138
0139 static const struct regulator_ops rt5190a_fixed_ldo_ops = {
0140 .enable = regulator_enable_regmap,
0141 .disable = regulator_disable_regmap,
0142 .is_enabled = regulator_is_enabled_regmap,
0143 .set_active_discharge = regulator_set_active_discharge_regmap,
0144 .get_error_flags = rt5190a_get_error_flags,
0145 };
0146
0147 static irqreturn_t rt5190a_irq_handler(int irq, void *data)
0148 {
0149 struct rt5190a_priv *priv = data;
0150 __le32 raws;
0151 unsigned int events, fields;
0152 static const struct {
0153 unsigned int bitmask;
0154 unsigned int report;
0155 } event_tbl[] = {
0156 { RT5190A_OVERVOLT_MASK, REGULATOR_ERROR_REGULATION_OUT },
0157 { RT5190A_UNDERVOLT_MASK, REGULATOR_ERROR_UNDER_VOLTAGE }
0158 };
0159 int i, j, ret;
0160
0161 ret = regmap_raw_read(priv->regmap, RT5190A_REG_OVINT, &raws,
0162 sizeof(raws));
0163 if (ret) {
0164 dev_err(priv->dev, "Failed to read events\n");
0165 return IRQ_NONE;
0166 }
0167
0168 events = le32_to_cpu(raws);
0169
0170 ret = regmap_raw_write(priv->regmap, RT5190A_REG_OVINT, &raws,
0171 sizeof(raws));
0172 if (ret)
0173 dev_err(priv->dev, "Failed to write-clear events\n");
0174
0175
0176 for (i = 0; i < ARRAY_SIZE(event_tbl); i++) {
0177 fields = events & event_tbl[i].bitmask;
0178 fields >>= ffs(event_tbl[i].bitmask) - 1;
0179
0180 for (j = 0; j < RT5190A_MAX_IDX; j++) {
0181 if (!(fields & RT5190A_RID_BITMASK(j)))
0182 continue;
0183
0184 regulator_notifier_call_chain(priv->rdev[j],
0185 event_tbl[i].report,
0186 NULL);
0187 }
0188 }
0189
0190
0191 if (events & RT5190A_CH234OT_MASK) {
0192 for (j = RT5190A_IDX_BUCK2; j < RT5190A_IDX_LDO; j++) {
0193 regulator_notifier_call_chain(priv->rdev[j],
0194 REGULATOR_ERROR_OVER_TEMP,
0195 NULL);
0196 }
0197 }
0198
0199
0200 if (events & RT5190A_CHIPOT_MASK)
0201 dev_warn(priv->dev, "CHIP overheat\n");
0202
0203 return IRQ_HANDLED;
0204 }
0205
0206 static unsigned int rt5190a_of_map_mode(unsigned int mode)
0207 {
0208 switch (mode) {
0209 case RT5190A_OPMODE_AUTO:
0210 return REGULATOR_MODE_NORMAL;
0211 case RT5190A_OPMODE_FPWM:
0212 return REGULATOR_MODE_FAST;
0213 default:
0214 return REGULATOR_MODE_INVALID;
0215 }
0216 }
0217
0218 static int rt5190a_of_parse_cb(struct rt5190a_priv *priv, int rid,
0219 struct of_regulator_match *match)
0220 {
0221 struct regulator_desc *desc = priv->rdesc + rid;
0222 struct regulator_init_data *init_data = match->init_data;
0223 struct device_node *np = match->of_node;
0224 bool latchup_enable;
0225 unsigned int mask = RT5190A_RID_BITMASK(rid), val;
0226
0227 if (!init_data)
0228 return 0;
0229
0230 switch (rid) {
0231 case RT5190A_IDX_BUCK1:
0232 case RT5190A_IDX_BUCK4:
0233 case RT5190A_IDX_LDO:
0234 init_data->constraints.apply_uV = 0;
0235
0236 if (init_data->constraints.min_uV ==
0237 init_data->constraints.max_uV)
0238 desc->fixed_uV = init_data->constraints.min_uV;
0239 else {
0240 dev_err(priv->dev,
0241 "Variable voltage for fixed regulator\n");
0242 return -EINVAL;
0243 }
0244 break;
0245 default:
0246 break;
0247 }
0248
0249 latchup_enable = of_property_read_bool(np, "richtek,latchup-enable");
0250
0251
0252 val = !latchup_enable ? mask : 0;
0253
0254 return regmap_update_bits(priv->regmap, RT5190A_REG_PROTMODE, mask, val);
0255 }
0256
0257 static void rt5190a_fillin_regulator_desc(struct regulator_desc *desc, int rid)
0258 {
0259 static const char * const regu_name[] = { "buck1", "buck2",
0260 "buck3", "buck4",
0261 "ldo" };
0262 static const char * const supply[] = { NULL, "vin2", "vin3", "vin4",
0263 "vinldo" };
0264
0265 desc->name = regu_name[rid];
0266 desc->supply_name = supply[rid];
0267 desc->owner = THIS_MODULE;
0268 desc->type = REGULATOR_VOLTAGE;
0269 desc->id = rid;
0270 desc->enable_reg = RT5190A_REG_ENABLE;
0271 desc->enable_mask = RT5190A_RID_BITMASK(rid);
0272 desc->active_discharge_reg = RT5190A_REG_DISCHARGE;
0273 desc->active_discharge_mask = RT5190A_RID_BITMASK(rid);
0274 desc->active_discharge_on = RT5190A_RID_BITMASK(rid);
0275
0276 switch (rid) {
0277 case RT5190A_IDX_BUCK1:
0278 desc->active_discharge_mask = RT5190A_BUCK1_DISCHG_MASK;
0279 desc->active_discharge_on = RT5190A_BUCK1_DISCHG_ONVAL;
0280 desc->n_voltages = 1;
0281 desc->ops = &rt5190a_fixed_buck_ops;
0282 desc->of_map_mode = rt5190a_of_map_mode;
0283 break;
0284 case RT5190A_IDX_BUCK2:
0285 desc->vsel_reg = RT5190A_REG_BUCK2VSEL;
0286 desc->vsel_mask = RT5190A_VSEL_MASK;
0287 desc->min_uV = RT5190A_BUCK23_MINUV;
0288 desc->uV_step = RT5190A_BUCK23_STEPUV;
0289 desc->n_voltages = RT5190A_BUCK23_STEPNUM;
0290 desc->ops = &rt5190a_ranged_buck_ops;
0291 break;
0292 case RT5190A_IDX_BUCK3:
0293 desc->vsel_reg = RT5190A_REG_BUCK3VSEL;
0294 desc->vsel_mask = RT5190A_VSEL_MASK;
0295 desc->min_uV = RT5190A_BUCK23_MINUV;
0296 desc->uV_step = RT5190A_BUCK23_STEPUV;
0297 desc->n_voltages = RT5190A_BUCK23_STEPNUM;
0298 desc->ops = &rt5190a_ranged_buck_ops;
0299 break;
0300 case RT5190A_IDX_BUCK4:
0301 desc->n_voltages = 1;
0302 desc->ops = &rt5190a_fixed_buck_ops;
0303 desc->of_map_mode = rt5190a_of_map_mode;
0304 break;
0305 case RT5190A_IDX_LDO:
0306 desc->n_voltages = 1;
0307 desc->ops = &rt5190a_fixed_ldo_ops;
0308 break;
0309 }
0310 }
0311
0312 static struct of_regulator_match rt5190a_regulator_match[] = {
0313 { .name = "buck1", },
0314 { .name = "buck2", },
0315 { .name = "buck3", },
0316 { .name = "buck4", },
0317 { .name = "ldo", }
0318 };
0319
0320 static int rt5190a_parse_regulator_dt_data(struct rt5190a_priv *priv)
0321 {
0322 struct device_node *regulator_np;
0323 struct regulator_desc *reg_desc;
0324 struct of_regulator_match *match;
0325 int i, ret;
0326
0327 for (i = 0; i < RT5190A_MAX_IDX; i++) {
0328 reg_desc = priv->rdesc + i;
0329 match = rt5190a_regulator_match + i;
0330
0331 rt5190a_fillin_regulator_desc(reg_desc, i);
0332
0333 match->desc = reg_desc;
0334 }
0335
0336 regulator_np = of_get_child_by_name(priv->dev->of_node, "regulators");
0337 if (!regulator_np) {
0338 dev_err(priv->dev, "Could not find 'regulators' node\n");
0339 return -ENODEV;
0340 }
0341
0342 ret = of_regulator_match(priv->dev, regulator_np,
0343 rt5190a_regulator_match,
0344 ARRAY_SIZE(rt5190a_regulator_match));
0345
0346 of_node_put(regulator_np);
0347
0348 if (ret < 0) {
0349 dev_err(priv->dev,
0350 "Error parsing regulator init data: %d\n", ret);
0351 return ret;
0352 }
0353
0354 for (i = 0; i < RT5190A_MAX_IDX; i++) {
0355 match = rt5190a_regulator_match + i;
0356
0357 ret = rt5190a_of_parse_cb(priv, i, match);
0358 if (ret) {
0359 dev_err(priv->dev, "Failed in [%d] of_parse_cb\n", i);
0360 return ret;
0361 }
0362 }
0363
0364 return 0;
0365 }
0366
0367 static const struct reg_sequence rt5190a_init_patch[] = {
0368 { 0x09, 0x3d, },
0369 { 0x0a, 0x3e, },
0370 { 0x0b, 0x01, },
0371 { 0x10, 0xff, },
0372 { 0x11, 0xff, },
0373 { 0x12, 0xff, },
0374 { 0x13, 0xff, },
0375 { 0x14, 0, },
0376 { 0x15, 0, },
0377 { 0x16, 0x3e, },
0378 { 0x17, 0, }
0379 };
0380
0381 static int rt5190a_device_initialize(struct rt5190a_priv *priv)
0382 {
0383 bool mute_enable;
0384 int ret;
0385
0386 ret = regmap_register_patch(priv->regmap, rt5190a_init_patch,
0387 ARRAY_SIZE(rt5190a_init_patch));
0388 if (ret) {
0389 dev_err(priv->dev, "Failed to do register patch\n");
0390 return ret;
0391 }
0392
0393 mute_enable = device_property_read_bool(priv->dev,
0394 "richtek,mute-enable");
0395
0396 if (mute_enable) {
0397 ret = regmap_write(priv->regmap, RT5190A_REG_MUTECNTL, 0x00);
0398 if (ret) {
0399 dev_err(priv->dev, "Failed to enable mute function\n");
0400 return ret;
0401 }
0402 }
0403
0404 return 0;
0405 }
0406
0407 static int rt5190a_device_check(struct rt5190a_priv *priv)
0408 {
0409 u16 devid;
0410 int ret;
0411
0412 ret = regmap_raw_read(priv->regmap, RT5190A_REG_MANUFACTURE, &devid,
0413 sizeof(devid));
0414 if (ret)
0415 return ret;
0416
0417 if (devid) {
0418 dev_err(priv->dev, "Incorrect device id 0x%04x\n", devid);
0419 return -ENODEV;
0420 }
0421
0422 return 0;
0423 }
0424
0425 static const struct regmap_config rt5190a_regmap_config = {
0426 .reg_bits = 8,
0427 .val_bits = 8,
0428 .max_register = RT5190A_REG_HOTDIEMASK,
0429 };
0430
0431 static int rt5190a_probe(struct i2c_client *i2c)
0432 {
0433 struct rt5190a_priv *priv;
0434 struct regulator_config cfg = {};
0435 int i, ret;
0436
0437 priv = devm_kzalloc(&i2c->dev, sizeof(*priv), GFP_KERNEL);
0438 if (!priv)
0439 return -ENOMEM;
0440
0441 priv->dev = &i2c->dev;
0442
0443 priv->regmap = devm_regmap_init_i2c(i2c, &rt5190a_regmap_config);
0444 if (IS_ERR(priv->regmap)) {
0445 dev_err(&i2c->dev, "Failed to allocate regmap\n");
0446 return PTR_ERR(priv->regmap);
0447 }
0448
0449 ret = rt5190a_device_check(priv);
0450 if (ret) {
0451 dev_err(&i2c->dev, "Failed to check device %d\n", ret);
0452 return ret;
0453 }
0454
0455 ret = rt5190a_device_initialize(priv);
0456 if (ret) {
0457 dev_err(&i2c->dev, "Failed to initialize the device\n");
0458 return ret;
0459 }
0460
0461 ret = rt5190a_parse_regulator_dt_data(priv);
0462 if (ret) {
0463 dev_err(&i2c->dev, "Failed to parse regulator dt\n");
0464 return ret;
0465 }
0466
0467 cfg.dev = &i2c->dev;
0468 cfg.regmap = priv->regmap;
0469
0470 for (i = 0; i < RT5190A_MAX_IDX; i++) {
0471 struct regulator_desc *desc = priv->rdesc + i;
0472 struct of_regulator_match *match = rt5190a_regulator_match + i;
0473
0474 cfg.init_data = match->init_data;
0475 cfg.of_node = match->of_node;
0476
0477 priv->rdev[i] = devm_regulator_register(&i2c->dev, desc, &cfg);
0478 if (IS_ERR(priv->rdev[i])) {
0479 dev_err(&i2c->dev, "Failed to register regulator %s\n",
0480 desc->name);
0481 return PTR_ERR(priv->rdev[i]);
0482 }
0483 }
0484
0485 if (i2c->irq) {
0486 ret = devm_request_threaded_irq(&i2c->dev, i2c->irq, NULL,
0487 rt5190a_irq_handler,
0488 IRQF_ONESHOT,
0489 dev_name(&i2c->dev), priv);
0490 if (ret) {
0491 dev_err(&i2c->dev, "Failed to register interrupt\n");
0492 return ret;
0493 }
0494 }
0495
0496 return 0;
0497 }
0498
0499 static const struct of_device_id __maybe_unused rt5190a_device_table[] = {
0500 { .compatible = "richtek,rt5190a", },
0501 {}
0502 };
0503 MODULE_DEVICE_TABLE(of, rt5190a_device_table);
0504
0505 static struct i2c_driver rt5190a_driver = {
0506 .driver = {
0507 .name = "rt5190a",
0508 .of_match_table = rt5190a_device_table,
0509 },
0510 .probe_new = rt5190a_probe,
0511 };
0512 module_i2c_driver(rt5190a_driver);
0513
0514 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
0515 MODULE_DESCRIPTION("Richtek RT5190A Regulator Driver");
0516 MODULE_LICENSE("GPL v2");
