drivers/regulator/lp8755.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * LP8755 High Performance Power Management Unit : System Interface Driver
0004  * (based on rev. 0.26)
0005  * Copyright 2012 Texas Instruments
0006  *
0007  * Author: Daniel(Geon Si) Jeong <daniel.jeong@ti.com>
0008  */
0009
0010 #include <linux/module.h>
0011 #include <linux/slab.h>
0012 #include <linux/i2c.h>
0013 #include <linux/err.h>
0014 #include <linux/irq.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/gpio.h>
0017 #include <linux/regmap.h>
0018 #include <linux/uaccess.h>
0019 #include <linux/regulator/driver.h>
0020 #include <linux/regulator/machine.h>
0021 #include <linux/platform_data/lp8755.h>
0022
0023 #define LP8755_REG_BUCK0    0x00
0024 #define LP8755_REG_BUCK1    0x03
0025 #define LP8755_REG_BUCK2    0x04
0026 #define LP8755_REG_BUCK3    0x01
0027 #define LP8755_REG_BUCK4    0x05
0028 #define LP8755_REG_BUCK5    0x02
0029 #define LP8755_REG_MAX      0xFF
0030
0031 #define LP8755_BUCK_EN_M    BIT(7)
0032 #define LP8755_BUCK_LINEAR_OUT_MAX  0x76
0033 #define LP8755_BUCK_VOUT_M  0x7F
0034
0035 struct lp8755_mphase {
0036     int nreg;
0037     int buck_num[LP8755_BUCK_MAX];
0038 };
0039
0040 struct lp8755_chip {
0041     struct device *dev;
0042     struct regmap *regmap;
0043     struct lp8755_platform_data *pdata;
0044
0045     int irq;
0046     unsigned int irqmask;
0047
0048     int mphase;
0049     struct regulator_dev *rdev[LP8755_BUCK_MAX];
0050 };
0051
0052 static int lp8755_buck_enable_time(struct regulator_dev *rdev)
0053 {
0054     int ret;
0055     unsigned int regval;
0056     enum lp8755_bucks id = rdev_get_id(rdev);
0057
0058     ret = regmap_read(rdev->regmap, 0x12 + id, &regval);
0059     if (ret < 0) {
0060         dev_err(&rdev->dev, "i2c access error %s\n", __func__);
0061         return ret;
0062     }
0063     return (regval & 0xff) * 100;
0064 }
0065
0066 static int lp8755_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
0067 {
0068     int ret;
0069     unsigned int regbval = 0x0;
0070     enum lp8755_bucks id = rdev_get_id(rdev);
0071     struct lp8755_chip *pchip = rdev_get_drvdata(rdev);
0072
0073     switch (mode) {
0074     case REGULATOR_MODE_FAST:
0075         /* forced pwm mode */
0076         regbval = (0x01 << id);
0077         break;
0078     case REGULATOR_MODE_NORMAL:
0079         /* enable automatic pwm/pfm mode */
0080         ret = regmap_update_bits(rdev->regmap, 0x08 + id, 0x20, 0x00);
0081         if (ret < 0)
0082             goto err_i2c;
0083         break;
0084     case REGULATOR_MODE_IDLE:
0085         /* enable automatic pwm/pfm/lppfm mode */
0086         ret = regmap_update_bits(rdev->regmap, 0x08 + id, 0x20, 0x20);
0087         if (ret < 0)
0088             goto err_i2c;
0089
0090         ret = regmap_update_bits(rdev->regmap, 0x10, 0x01, 0x01);
0091         if (ret < 0)
0092             goto err_i2c;
0093         break;
0094     default:
0095         dev_err(pchip->dev, "Not supported buck mode %s\n", __func__);
0096         /* forced pwm mode */
0097         regbval = (0x01 << id);
0098     }
0099
0100     ret = regmap_update_bits(rdev->regmap, 0x06, 0x01 << id, regbval);
0101     if (ret < 0)
0102         goto err_i2c;
0103     return ret;
0104 err_i2c:
0105     dev_err(&rdev->dev, "i2c access error %s\n", __func__);
0106     return ret;
0107 }
0108
0109 static unsigned int lp8755_buck_get_mode(struct regulator_dev *rdev)
0110 {
0111     int ret;
0112     unsigned int regval;
0113     enum lp8755_bucks id = rdev_get_id(rdev);
0114
0115     ret = regmap_read(rdev->regmap, 0x06, &regval);
0116     if (ret < 0)
0117         goto err_i2c;
0118
0119     /* mode fast means forced pwm mode */
0120     if (regval & (0x01 << id))
0121         return REGULATOR_MODE_FAST;
0122
0123     ret = regmap_read(rdev->regmap, 0x08 + id, &regval);
0124     if (ret < 0)
0125         goto err_i2c;
0126
0127     /* mode idle means automatic pwm/pfm/lppfm mode */
0128     if (regval & 0x20)
0129         return REGULATOR_MODE_IDLE;
0130
0131     /* mode normal means automatic pwm/pfm mode */
0132     return REGULATOR_MODE_NORMAL;
0133
0134 err_i2c:
0135     dev_err(&rdev->dev, "i2c access error %s\n", __func__);
0136     return 0;
0137 }
0138
0139 static const unsigned int lp8755_buck_ramp_table[] = {
0140     30000, 15000, 7500, 3800, 1900, 940, 470, 230
0141 };
0142
0143 static const struct regulator_ops lp8755_buck_ops = {
0144     .map_voltage = regulator_map_voltage_linear,
0145     .list_voltage = regulator_list_voltage_linear,
0146     .set_voltage_sel = regulator_set_voltage_sel_regmap,
0147     .get_voltage_sel = regulator_get_voltage_sel_regmap,
0148     .enable = regulator_enable_regmap,
0149     .disable = regulator_disable_regmap,
0150     .is_enabled = regulator_is_enabled_regmap,
0151     .enable_time = lp8755_buck_enable_time,
0152     .set_mode = lp8755_buck_set_mode,
0153     .get_mode = lp8755_buck_get_mode,
0154     .set_ramp_delay = regulator_set_ramp_delay_regmap,
0155 };
0156
0157 #define lp8755_rail(_id) "lp8755_buck"#_id
0158 #define lp8755_buck_init(_id)\
0159 {\
0160     .constraints = {\
0161         .name = lp8755_rail(_id),\
0162         .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,\
0163         .min_uV = 500000,\
0164         .max_uV = 1675000,\
0165     },\
0166 }
0167
0168 static struct regulator_init_data lp8755_reg_default[LP8755_BUCK_MAX] = {
0169     [LP8755_BUCK0] = lp8755_buck_init(0),
0170     [LP8755_BUCK1] = lp8755_buck_init(1),
0171     [LP8755_BUCK2] = lp8755_buck_init(2),
0172     [LP8755_BUCK3] = lp8755_buck_init(3),
0173     [LP8755_BUCK4] = lp8755_buck_init(4),
0174     [LP8755_BUCK5] = lp8755_buck_init(5),
0175 };
0176
0177 static const struct lp8755_mphase mphase_buck[MPHASE_CONF_MAX] = {
0178     { 3, { LP8755_BUCK0, LP8755_BUCK3, LP8755_BUCK5 } },
0179     { 6, { LP8755_BUCK0, LP8755_BUCK1, LP8755_BUCK2, LP8755_BUCK3,
0180            LP8755_BUCK4, LP8755_BUCK5 } },
0181     { 5, { LP8755_BUCK0, LP8755_BUCK2, LP8755_BUCK3, LP8755_BUCK4,
0182            LP8755_BUCK5} },
0183     { 4, { LP8755_BUCK0, LP8755_BUCK3, LP8755_BUCK4, LP8755_BUCK5} },
0184     { 3, { LP8755_BUCK0, LP8755_BUCK4, LP8755_BUCK5} },
0185     { 2, { LP8755_BUCK0, LP8755_BUCK5} },
0186     { 1, { LP8755_BUCK0} },
0187     { 2, { LP8755_BUCK0, LP8755_BUCK3} },
0188     { 4, { LP8755_BUCK0, LP8755_BUCK2, LP8755_BUCK3, LP8755_BUCK5} },
0189 };
0190
0191 static int lp8755_init_data(struct lp8755_chip *pchip)
0192 {
0193     unsigned int regval;
0194     int ret, icnt, buck_num;
0195     struct lp8755_platform_data *pdata = pchip->pdata;
0196
0197     /* read back  muti-phase configuration */
0198     ret = regmap_read(pchip->regmap, 0x3D, &regval);
0199     if (ret < 0)
0200         goto out_i2c_error;
0201     pchip->mphase = regval & 0x0F;
0202
0203     /* set default data based on multi-phase config */
0204     for (icnt = 0; icnt < mphase_buck[pchip->mphase].nreg; icnt++) {
0205         buck_num = mphase_buck[pchip->mphase].buck_num[icnt];
0206         pdata->buck_data[buck_num] = &lp8755_reg_default[buck_num];
0207     }
0208     return ret;
0209
0210 out_i2c_error:
0211     dev_err(pchip->dev, "i2c access error %s\n", __func__);
0212     return ret;
0213 }
0214
0215 #define lp8755_buck_desc(_id)\
0216 {\
0217     .name = lp8755_rail(_id),\
0218     .id   = LP8755_BUCK##_id,\
0219     .ops  = &lp8755_buck_ops,\
0220     .n_voltages = LP8755_BUCK_LINEAR_OUT_MAX+1,\
0221     .uV_step = 10000,\
0222     .min_uV = 500000,\
0223     .type = REGULATOR_VOLTAGE,\
0224     .owner = THIS_MODULE,\
0225     .enable_reg = LP8755_REG_BUCK##_id,\
0226     .enable_mask = LP8755_BUCK_EN_M,\
0227     .vsel_reg = LP8755_REG_BUCK##_id,\
0228     .vsel_mask = LP8755_BUCK_VOUT_M,\
0229     .ramp_reg = (LP8755_BUCK##_id) + 0x7,\
0230     .ramp_mask = 0x7,\
0231     .ramp_delay_table = lp8755_buck_ramp_table,\
0232     .n_ramp_values = ARRAY_SIZE(lp8755_buck_ramp_table),\
0233 }
0234
0235 static const struct regulator_desc lp8755_regulators[] = {
0236     lp8755_buck_desc(0),
0237     lp8755_buck_desc(1),
0238     lp8755_buck_desc(2),
0239     lp8755_buck_desc(3),
0240     lp8755_buck_desc(4),
0241     lp8755_buck_desc(5),
0242 };
0243
0244 static int lp8755_regulator_init(struct lp8755_chip *pchip)
0245 {
0246     int ret, icnt, buck_num;
0247     struct lp8755_platform_data *pdata = pchip->pdata;
0248     struct regulator_config rconfig = { };
0249
0250     rconfig.regmap = pchip->regmap;
0251     rconfig.dev = pchip->dev;
0252     rconfig.driver_data = pchip;
0253
0254     for (icnt = 0; icnt < mphase_buck[pchip->mphase].nreg; icnt++) {
0255         buck_num = mphase_buck[pchip->mphase].buck_num[icnt];
0256         rconfig.init_data = pdata->buck_data[buck_num];
0257         rconfig.of_node = pchip->dev->of_node;
0258         pchip->rdev[buck_num] =
0259             devm_regulator_register(pchip->dev,
0260                     &lp8755_regulators[buck_num], &rconfig);
0261         if (IS_ERR(pchip->rdev[buck_num])) {
0262             ret = PTR_ERR(pchip->rdev[buck_num]);
0263             pchip->rdev[buck_num] = NULL;
0264             dev_err(pchip->dev, "regulator init failed: buck %d\n",
0265                 buck_num);
0266             return ret;
0267         }
0268     }
0269
0270     return 0;
0271 }
0272
0273 static irqreturn_t lp8755_irq_handler(int irq, void *data)
0274 {
0275     int ret, icnt;
0276     unsigned int flag0, flag1;
0277     struct lp8755_chip *pchip = data;
0278
0279     /* read flag0 register */
0280     ret = regmap_read(pchip->regmap, 0x0D, &flag0);
0281     if (ret < 0)
0282         goto err_i2c;
0283     /* clear flag register to pull up int. pin */
0284     ret = regmap_write(pchip->regmap, 0x0D, 0x00);
0285     if (ret < 0)
0286         goto err_i2c;
0287
0288     /* sent power fault detection event to specific regulator */
0289     for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
0290         if ((flag0 & (0x4 << icnt))
0291             && (pchip->irqmask & (0x04 << icnt))
0292             && (pchip->rdev[icnt] != NULL)) {
0293             regulator_notifier_call_chain(pchip->rdev[icnt],
0294                               LP8755_EVENT_PWR_FAULT,
0295                               NULL);
0296         }
0297
0298     /* read flag1 register */
0299     ret = regmap_read(pchip->regmap, 0x0E, &flag1);
0300     if (ret < 0)
0301         goto err_i2c;
0302     /* clear flag register to pull up int. pin */
0303     ret = regmap_write(pchip->regmap, 0x0E, 0x00);
0304     if (ret < 0)
0305         goto err_i2c;
0306
0307     /* send OCP event to all regulator devices */
0308     if ((flag1 & 0x01) && (pchip->irqmask & 0x01))
0309         for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
0310             if (pchip->rdev[icnt] != NULL) {
0311                 regulator_notifier_call_chain(pchip->rdev[icnt],
0312                                   LP8755_EVENT_OCP,
0313                                   NULL);
0314             }
0315
0316     /* send OVP event to all regulator devices */
0317     if ((flag1 & 0x02) && (pchip->irqmask & 0x02))
0318         for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
0319             if (pchip->rdev[icnt] != NULL) {
0320                 regulator_notifier_call_chain(pchip->rdev[icnt],
0321                                   LP8755_EVENT_OVP,
0322                                   NULL);
0323             }
0324     return IRQ_HANDLED;
0325
0326 err_i2c:
0327     dev_err(pchip->dev, "i2c access error %s\n", __func__);
0328     return IRQ_NONE;
0329 }
0330
0331 static int lp8755_int_config(struct lp8755_chip *pchip)
0332 {
0333     int ret;
0334     unsigned int regval;
0335
0336     if (pchip->irq == 0) {
0337         dev_warn(pchip->dev, "not use interrupt : %s\n", __func__);
0338         return 0;
0339     }
0340
0341     ret = regmap_read(pchip->regmap, 0x0F, &regval);
0342     if (ret < 0) {
0343         dev_err(pchip->dev, "i2c access error %s\n", __func__);
0344         return ret;
0345     }
0346
0347     pchip->irqmask = regval;
0348     return devm_request_threaded_irq(pchip->dev, pchip->irq, NULL,
0349                      lp8755_irq_handler,
0350                      IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
0351                      "lp8755-irq", pchip);
0352 }
0353
0354 static const struct regmap_config lp8755_regmap = {
0355     .reg_bits = 8,
0356     .val_bits = 8,
0357     .max_register = LP8755_REG_MAX,
0358 };
0359
0360 static int lp8755_probe(struct i2c_client *client,
0361             const struct i2c_device_id *id)
0362 {
0363     int ret, icnt;
0364     struct lp8755_chip *pchip;
0365     struct lp8755_platform_data *pdata = dev_get_platdata(&client->dev);
0366
0367     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
0368         dev_err(&client->dev, "i2c functionality check fail.\n");
0369         return -EOPNOTSUPP;
0370     }
0371
0372     pchip = devm_kzalloc(&client->dev,
0373                  sizeof(struct lp8755_chip), GFP_KERNEL);
0374     if (!pchip)
0375         return -ENOMEM;
0376
0377     pchip->dev = &client->dev;
0378     pchip->regmap = devm_regmap_init_i2c(client, &lp8755_regmap);
0379     if (IS_ERR(pchip->regmap)) {
0380         ret = PTR_ERR(pchip->regmap);
0381         dev_err(&client->dev, "fail to allocate regmap %d\n", ret);
0382         return ret;
0383     }
0384     i2c_set_clientdata(client, pchip);
0385
0386     if (pdata != NULL) {
0387         pchip->pdata = pdata;
0388         pchip->mphase = pdata->mphase;
0389     } else {
0390         pchip->pdata = devm_kzalloc(pchip->dev,
0391                         sizeof(struct lp8755_platform_data),
0392                         GFP_KERNEL);
0393         if (!pchip->pdata)
0394             return -ENOMEM;
0395         ret = lp8755_init_data(pchip);
0396         if (ret < 0) {
0397             dev_err(&client->dev, "fail to initialize chip\n");
0398             return ret;
0399         }
0400     }
0401
0402     ret = lp8755_regulator_init(pchip);
0403     if (ret < 0) {
0404         dev_err(&client->dev, "fail to initialize regulators\n");
0405         goto err;
0406     }
0407
0408     pchip->irq = client->irq;
0409     ret = lp8755_int_config(pchip);
0410     if (ret < 0) {
0411         dev_err(&client->dev, "fail to irq config\n");
0412         goto err;
0413     }
0414
0415     return ret;
0416
0417 err:
0418     /* output disable */
0419     for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
0420         regmap_write(pchip->regmap, icnt, 0x00);
0421
0422     return ret;
0423 }
0424
0425 static int lp8755_remove(struct i2c_client *client)
0426 {
0427     int icnt;
0428     struct lp8755_chip *pchip = i2c_get_clientdata(client);
0429
0430     for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
0431         regmap_write(pchip->regmap, icnt, 0x00);
0432
0433     return 0;
0434 }
0435
0436 static const struct i2c_device_id lp8755_id[] = {
0437     {LP8755_NAME, 0},
0438     {}
0439 };
0440
0441 MODULE_DEVICE_TABLE(i2c, lp8755_id);
0442
0443 static struct i2c_driver lp8755_i2c_driver = {
0444     .driver = {
0445            .name = LP8755_NAME,
0446            },
0447     .probe = lp8755_probe,
0448     .remove = lp8755_remove,
0449     .id_table = lp8755_id,
0450 };
0451
0452 static int __init lp8755_init(void)
0453 {
0454     return i2c_add_driver(&lp8755_i2c_driver);
0455 }
0456
0457 subsys_initcall(lp8755_init);
0458
0459 static void __exit lp8755_exit(void)
0460 {
0461     i2c_del_driver(&lp8755_i2c_driver);
0462 }
0463
0464 module_exit(lp8755_exit);
0465
0466 MODULE_DESCRIPTION("Texas Instruments lp8755 driver");
0467 MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
0468 MODULE_LICENSE("GPL v2");