drivers/regulator/lp3971.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Regulator driver for National Semiconductors LP3971 PMIC chip
0004  *
0005  *  Copyright (C) 2009 Samsung Electronics
0006  *  Author: Marek Szyprowski <m.szyprowski@samsung.com>
0007  *
0008  * Based on wm8350.c
0009  */
0010
0011 #include <linux/bug.h>
0012 #include <linux/err.h>
0013 #include <linux/i2c.h>
0014 #include <linux/kernel.h>
0015 #include <linux/module.h>
0016 #include <linux/regulator/driver.h>
0017 #include <linux/regulator/lp3971.h>
0018 #include <linux/slab.h>
0019
0020 struct lp3971 {
0021     struct device *dev;
0022     struct mutex io_lock;
0023     struct i2c_client *i2c;
0024 };
0025
0026 static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg);
0027 static int lp3971_set_bits(struct lp3971 *lp3971, u8 reg, u16 mask, u16 val);
0028
0029 #define LP3971_SYS_CONTROL1_REG 0x07
0030
0031 /* System control register 1 initial value,
0032    bits 4 and 5 are EPROM programmable */
0033 #define SYS_CONTROL1_INIT_VAL 0x40
0034 #define SYS_CONTROL1_INIT_MASK 0xCF
0035
0036 #define LP3971_BUCK_VOL_ENABLE_REG 0x10
0037 #define LP3971_BUCK_VOL_CHANGE_REG 0x20
0038
0039 /*  Voltage control registers shift:
0040     LP3971_BUCK1 -> 0
0041     LP3971_BUCK2 -> 4
0042     LP3971_BUCK3 -> 6
0043 */
0044 #define BUCK_VOL_CHANGE_SHIFT(x) (((!!x) << 2) | (x & ~0x01))
0045 #define BUCK_VOL_CHANGE_FLAG_GO 0x01
0046 #define BUCK_VOL_CHANGE_FLAG_TARGET 0x02
0047 #define BUCK_VOL_CHANGE_FLAG_MASK 0x03
0048
0049 #define LP3971_BUCK1_BASE 0x23
0050 #define LP3971_BUCK2_BASE 0x29
0051 #define LP3971_BUCK3_BASE 0x32
0052
0053 static const int buck_base_addr[] = {
0054     LP3971_BUCK1_BASE,
0055     LP3971_BUCK2_BASE,
0056     LP3971_BUCK3_BASE,
0057 };
0058
0059 #define LP3971_BUCK_TARGET_VOL1_REG(x) (buck_base_addr[x])
0060 #define LP3971_BUCK_TARGET_VOL2_REG(x) (buck_base_addr[x]+1)
0061
0062 static const unsigned int buck_voltage_map[] = {
0063           0,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
0064     1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
0065     1550000, 1600000, 1650000, 1700000, 1800000, 1900000, 2500000, 2800000,
0066     3000000, 3300000,
0067 };
0068
0069 #define BUCK_TARGET_VOL_MASK 0x3f
0070
0071 #define LP3971_BUCK_RAMP_REG(x) (buck_base_addr[x]+2)
0072
0073 #define LP3971_LDO_ENABLE_REG 0x12
0074 #define LP3971_LDO_VOL_CONTR_BASE 0x39
0075
0076 /*  Voltage control registers:
0077     LP3971_LDO1 -> LP3971_LDO_VOL_CONTR_BASE + 0
0078     LP3971_LDO2 -> LP3971_LDO_VOL_CONTR_BASE + 0
0079     LP3971_LDO3 -> LP3971_LDO_VOL_CONTR_BASE + 1
0080     LP3971_LDO4 -> LP3971_LDO_VOL_CONTR_BASE + 1
0081     LP3971_LDO5 -> LP3971_LDO_VOL_CONTR_BASE + 2
0082 */
0083 #define LP3971_LDO_VOL_CONTR_REG(x) (LP3971_LDO_VOL_CONTR_BASE + (x >> 1))
0084
0085 /*  Voltage control registers shift:
0086     LP3971_LDO1 -> 0, LP3971_LDO2 -> 4
0087     LP3971_LDO3 -> 0, LP3971_LDO4 -> 4
0088     LP3971_LDO5 -> 0
0089 */
0090 #define LDO_VOL_CONTR_SHIFT(x) ((x & 1) << 2)
0091 #define LDO_VOL_CONTR_MASK 0x0f
0092
0093 static const unsigned int ldo45_voltage_map[] = {
0094     1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000, 1350000,
0095     1400000, 1500000, 1800000, 1900000, 2500000, 2800000, 3000000, 3300000,
0096 };
0097
0098 static const unsigned int ldo123_voltage_map[] = {
0099     1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
0100     2600000, 2700000, 2800000, 2900000, 3000000, 3100000, 3200000, 3300000,
0101 };
0102
0103 #define LDO_VOL_MIN_IDX 0x00
0104 #define LDO_VOL_MAX_IDX 0x0f
0105
0106 static int lp3971_ldo_is_enabled(struct regulator_dev *dev)
0107 {
0108     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0109     int ldo = rdev_get_id(dev) - LP3971_LDO1;
0110     u16 mask = 1 << (1 + ldo);
0111     u16 val;
0112
0113     val = lp3971_reg_read(lp3971, LP3971_LDO_ENABLE_REG);
0114     return (val & mask) != 0;
0115 }
0116
0117 static int lp3971_ldo_enable(struct regulator_dev *dev)
0118 {
0119     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0120     int ldo = rdev_get_id(dev) - LP3971_LDO1;
0121     u16 mask = 1 << (1 + ldo);
0122
0123     return lp3971_set_bits(lp3971, LP3971_LDO_ENABLE_REG, mask, mask);
0124 }
0125
0126 static int lp3971_ldo_disable(struct regulator_dev *dev)
0127 {
0128     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0129     int ldo = rdev_get_id(dev) - LP3971_LDO1;
0130     u16 mask = 1 << (1 + ldo);
0131
0132     return lp3971_set_bits(lp3971, LP3971_LDO_ENABLE_REG, mask, 0);
0133 }
0134
0135 static int lp3971_ldo_get_voltage_sel(struct regulator_dev *dev)
0136 {
0137     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0138     int ldo = rdev_get_id(dev) - LP3971_LDO1;
0139     u16 val, reg;
0140
0141     reg = lp3971_reg_read(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo));
0142     val = (reg >> LDO_VOL_CONTR_SHIFT(ldo)) & LDO_VOL_CONTR_MASK;
0143
0144     return val;
0145 }
0146
0147 static int lp3971_ldo_set_voltage_sel(struct regulator_dev *dev,
0148                       unsigned int selector)
0149 {
0150     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0151     int ldo = rdev_get_id(dev) - LP3971_LDO1;
0152
0153     return lp3971_set_bits(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo),
0154             LDO_VOL_CONTR_MASK << LDO_VOL_CONTR_SHIFT(ldo),
0155             selector << LDO_VOL_CONTR_SHIFT(ldo));
0156 }
0157
0158 static const struct regulator_ops lp3971_ldo_ops = {
0159     .list_voltage = regulator_list_voltage_table,
0160     .map_voltage = regulator_map_voltage_ascend,
0161     .is_enabled = lp3971_ldo_is_enabled,
0162     .enable = lp3971_ldo_enable,
0163     .disable = lp3971_ldo_disable,
0164     .get_voltage_sel = lp3971_ldo_get_voltage_sel,
0165     .set_voltage_sel = lp3971_ldo_set_voltage_sel,
0166 };
0167
0168 static int lp3971_dcdc_is_enabled(struct regulator_dev *dev)
0169 {
0170     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0171     int buck = rdev_get_id(dev) - LP3971_DCDC1;
0172     u16 mask = 1 << (buck * 2);
0173     u16 val;
0174
0175     val = lp3971_reg_read(lp3971, LP3971_BUCK_VOL_ENABLE_REG);
0176     return (val & mask) != 0;
0177 }
0178
0179 static int lp3971_dcdc_enable(struct regulator_dev *dev)
0180 {
0181     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0182     int buck = rdev_get_id(dev) - LP3971_DCDC1;
0183     u16 mask = 1 << (buck * 2);
0184
0185     return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_ENABLE_REG, mask, mask);
0186 }
0187
0188 static int lp3971_dcdc_disable(struct regulator_dev *dev)
0189 {
0190     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0191     int buck = rdev_get_id(dev) - LP3971_DCDC1;
0192     u16 mask = 1 << (buck * 2);
0193
0194     return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_ENABLE_REG, mask, 0);
0195 }
0196
0197 static int lp3971_dcdc_get_voltage_sel(struct regulator_dev *dev)
0198 {
0199     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0200     int buck = rdev_get_id(dev) - LP3971_DCDC1;
0201     u16 reg;
0202
0203     reg = lp3971_reg_read(lp3971, LP3971_BUCK_TARGET_VOL1_REG(buck));
0204     reg &= BUCK_TARGET_VOL_MASK;
0205
0206     return reg;
0207 }
0208
0209 static int lp3971_dcdc_set_voltage_sel(struct regulator_dev *dev,
0210                        unsigned int selector)
0211 {
0212     struct lp3971 *lp3971 = rdev_get_drvdata(dev);
0213     int buck = rdev_get_id(dev) - LP3971_DCDC1;
0214     int ret;
0215
0216     ret = lp3971_set_bits(lp3971, LP3971_BUCK_TARGET_VOL1_REG(buck),
0217            BUCK_TARGET_VOL_MASK, selector);
0218     if (ret)
0219         return ret;
0220
0221     ret = lp3971_set_bits(lp3971, LP3971_BUCK_VOL_CHANGE_REG,
0222            BUCK_VOL_CHANGE_FLAG_MASK << BUCK_VOL_CHANGE_SHIFT(buck),
0223            BUCK_VOL_CHANGE_FLAG_GO << BUCK_VOL_CHANGE_SHIFT(buck));
0224     if (ret)
0225         return ret;
0226
0227     return lp3971_set_bits(lp3971, LP3971_BUCK_VOL_CHANGE_REG,
0228            BUCK_VOL_CHANGE_FLAG_MASK << BUCK_VOL_CHANGE_SHIFT(buck),
0229            0 << BUCK_VOL_CHANGE_SHIFT(buck));
0230 }
0231
0232 static const struct regulator_ops lp3971_dcdc_ops = {
0233     .list_voltage = regulator_list_voltage_table,
0234     .map_voltage = regulator_map_voltage_ascend,
0235     .is_enabled = lp3971_dcdc_is_enabled,
0236     .enable = lp3971_dcdc_enable,
0237     .disable = lp3971_dcdc_disable,
0238     .get_voltage_sel = lp3971_dcdc_get_voltage_sel,
0239     .set_voltage_sel = lp3971_dcdc_set_voltage_sel,
0240 };
0241
0242 static const struct regulator_desc regulators[] = {
0243     {
0244         .name = "LDO1",
0245         .id = LP3971_LDO1,
0246         .ops = &lp3971_ldo_ops,
0247         .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
0248         .volt_table = ldo123_voltage_map,
0249         .type = REGULATOR_VOLTAGE,
0250         .owner = THIS_MODULE,
0251     },
0252     {
0253         .name = "LDO2",
0254         .id = LP3971_LDO2,
0255         .ops = &lp3971_ldo_ops,
0256         .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
0257         .volt_table = ldo123_voltage_map,
0258         .type = REGULATOR_VOLTAGE,
0259         .owner = THIS_MODULE,
0260     },
0261     {
0262         .name = "LDO3",
0263         .id = LP3971_LDO3,
0264         .ops = &lp3971_ldo_ops,
0265         .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
0266         .volt_table = ldo123_voltage_map,
0267         .type = REGULATOR_VOLTAGE,
0268         .owner = THIS_MODULE,
0269     },
0270     {
0271         .name = "LDO4",
0272         .id = LP3971_LDO4,
0273         .ops = &lp3971_ldo_ops,
0274         .n_voltages = ARRAY_SIZE(ldo45_voltage_map),
0275         .volt_table = ldo45_voltage_map,
0276         .type = REGULATOR_VOLTAGE,
0277         .owner = THIS_MODULE,
0278     },
0279     {
0280         .name = "LDO5",
0281         .id = LP3971_LDO5,
0282         .ops = &lp3971_ldo_ops,
0283         .n_voltages = ARRAY_SIZE(ldo45_voltage_map),
0284         .volt_table = ldo45_voltage_map,
0285         .type = REGULATOR_VOLTAGE,
0286         .owner = THIS_MODULE,
0287     },
0288     {
0289         .name = "DCDC1",
0290         .id = LP3971_DCDC1,
0291         .ops = &lp3971_dcdc_ops,
0292         .n_voltages = ARRAY_SIZE(buck_voltage_map),
0293         .volt_table = buck_voltage_map,
0294         .type = REGULATOR_VOLTAGE,
0295         .owner = THIS_MODULE,
0296     },
0297     {
0298         .name = "DCDC2",
0299         .id = LP3971_DCDC2,
0300         .ops = &lp3971_dcdc_ops,
0301         .n_voltages = ARRAY_SIZE(buck_voltage_map),
0302         .volt_table = buck_voltage_map,
0303         .type = REGULATOR_VOLTAGE,
0304         .owner = THIS_MODULE,
0305     },
0306     {
0307         .name = "DCDC3",
0308         .id = LP3971_DCDC3,
0309         .ops = &lp3971_dcdc_ops,
0310         .n_voltages = ARRAY_SIZE(buck_voltage_map),
0311         .volt_table = buck_voltage_map,
0312         .type = REGULATOR_VOLTAGE,
0313         .owner = THIS_MODULE,
0314     },
0315 };
0316
0317 static int lp3971_i2c_read(struct i2c_client *i2c, char reg, int count,
0318     u16 *dest)
0319 {
0320     int ret;
0321
0322     if (count != 1)
0323         return -EIO;
0324     ret = i2c_smbus_read_byte_data(i2c, reg);
0325     if (ret < 0)
0326         return ret;
0327
0328     *dest = ret;
0329     return 0;
0330 }
0331
0332 static int lp3971_i2c_write(struct i2c_client *i2c, char reg, int count,
0333     const u16 *src)
0334 {
0335     if (count != 1)
0336         return -EIO;
0337     return i2c_smbus_write_byte_data(i2c, reg, *src);
0338 }
0339
0340 static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg)
0341 {
0342     u16 val = 0;
0343
0344     mutex_lock(&lp3971->io_lock);
0345
0346     lp3971_i2c_read(lp3971->i2c, reg, 1, &val);
0347
0348     dev_dbg(lp3971->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg,
0349         (unsigned)val&0xff);
0350
0351     mutex_unlock(&lp3971->io_lock);
0352
0353     return val & 0xff;
0354 }
0355
0356 static int lp3971_set_bits(struct lp3971 *lp3971, u8 reg, u16 mask, u16 val)
0357 {
0358     u16 tmp;
0359     int ret;
0360
0361     mutex_lock(&lp3971->io_lock);
0362
0363     ret = lp3971_i2c_read(lp3971->i2c, reg, 1, &tmp);
0364     if (ret == 0) {
0365         tmp = (tmp & ~mask) | val;
0366         ret = lp3971_i2c_write(lp3971->i2c, reg, 1, &tmp);
0367         dev_dbg(lp3971->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg,
0368             (unsigned)val&0xff);
0369     }
0370     mutex_unlock(&lp3971->io_lock);
0371
0372     return ret;
0373 }
0374
0375 static int setup_regulators(struct lp3971 *lp3971,
0376                       struct lp3971_platform_data *pdata)
0377 {
0378     int i, err;
0379
0380     /* Instantiate the regulators */
0381     for (i = 0; i < pdata->num_regulators; i++) {
0382         struct regulator_config config = { };
0383         struct lp3971_regulator_subdev *reg = &pdata->regulators[i];
0384         struct regulator_dev *rdev;
0385
0386         config.dev = lp3971->dev;
0387         config.init_data = reg->initdata;
0388         config.driver_data = lp3971;
0389
0390         rdev = devm_regulator_register(lp3971->dev,
0391                            &regulators[reg->id], &config);
0392         if (IS_ERR(rdev)) {
0393             err = PTR_ERR(rdev);
0394             dev_err(lp3971->dev, "regulator init failed: %d\n",
0395                 err);
0396             return err;
0397         }
0398     }
0399
0400     return 0;
0401 }
0402
0403 static int lp3971_i2c_probe(struct i2c_client *i2c)
0404 {
0405     struct lp3971 *lp3971;
0406     struct lp3971_platform_data *pdata = dev_get_platdata(&i2c->dev);
0407     int ret;
0408     u16 val;
0409
0410     if (!pdata) {
0411         dev_dbg(&i2c->dev, "No platform init data supplied\n");
0412         return -ENODEV;
0413     }
0414
0415     lp3971 = devm_kzalloc(&i2c->dev, sizeof(struct lp3971), GFP_KERNEL);
0416     if (lp3971 == NULL)
0417         return -ENOMEM;
0418
0419     lp3971->i2c = i2c;
0420     lp3971->dev = &i2c->dev;
0421
0422     mutex_init(&lp3971->io_lock);
0423
0424     /* Detect LP3971 */
0425     ret = lp3971_i2c_read(i2c, LP3971_SYS_CONTROL1_REG, 1, &val);
0426     if (ret == 0 && (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL)
0427         ret = -ENODEV;
0428     if (ret < 0) {
0429         dev_err(&i2c->dev, "failed to detect device\n");
0430         return ret;
0431     }
0432
0433     ret = setup_regulators(lp3971, pdata);
0434     if (ret < 0)
0435         return ret;
0436
0437     i2c_set_clientdata(i2c, lp3971);
0438     return 0;
0439 }
0440
0441 static const struct i2c_device_id lp3971_i2c_id[] = {
0442     { "lp3971", 0 },
0443     { }
0444 };
0445 MODULE_DEVICE_TABLE(i2c, lp3971_i2c_id);
0446
0447 static struct i2c_driver lp3971_i2c_driver = {
0448     .driver = {
0449         .name = "LP3971",
0450     },
0451     .probe_new = lp3971_i2c_probe,
0452     .id_table = lp3971_i2c_id,
0453 };
0454
0455 module_i2c_driver(lp3971_i2c_driver);
0456
0457 MODULE_LICENSE("GPL");
0458 MODULE_AUTHOR("Marek Szyprowski <m.szyprowski@samsung.com>");
0459 MODULE_DESCRIPTION("LP3971 PMIC driver");