Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright 2012 Texas Instruments
0004  *
0005  * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
0006  */
0007 
0008 #include <linux/module.h>
0009 #include <linux/slab.h>
0010 #include <linux/i2c.h>
0011 #include <linux/regmap.h>
0012 #include <linux/err.h>
0013 #include <linux/gpio/consumer.h>
0014 #include <linux/delay.h>
0015 #include <linux/regulator/lp872x.h>
0016 #include <linux/regulator/driver.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/of.h>
0019 #include <linux/regulator/of_regulator.h>
0020 
0021 /* Registers : LP8720/8725 shared */
0022 #define LP872X_GENERAL_CFG      0x00
0023 #define LP872X_LDO1_VOUT        0x01
0024 #define LP872X_LDO2_VOUT        0x02
0025 #define LP872X_LDO3_VOUT        0x03
0026 #define LP872X_LDO4_VOUT        0x04
0027 #define LP872X_LDO5_VOUT        0x05
0028 
0029 /* Registers : LP8720 */
0030 #define LP8720_BUCK_VOUT1       0x06
0031 #define LP8720_BUCK_VOUT2       0x07
0032 #define LP8720_ENABLE           0x08
0033 
0034 /* Registers : LP8725 */
0035 #define LP8725_LILO1_VOUT       0x06
0036 #define LP8725_LILO2_VOUT       0x07
0037 #define LP8725_BUCK1_VOUT1      0x08
0038 #define LP8725_BUCK1_VOUT2      0x09
0039 #define LP8725_BUCK2_VOUT1      0x0A
0040 #define LP8725_BUCK2_VOUT2      0x0B
0041 #define LP8725_BUCK_CTRL        0x0C
0042 #define LP8725_LDO_CTRL         0x0D
0043 
0044 /* Mask/shift : LP8720/LP8725 shared */
0045 #define LP872X_VOUT_M           0x1F
0046 #define LP872X_START_DELAY_M        0xE0
0047 #define LP872X_START_DELAY_S        5
0048 #define LP872X_EN_LDO1_M        BIT(0)
0049 #define LP872X_EN_LDO2_M        BIT(1)
0050 #define LP872X_EN_LDO3_M        BIT(2)
0051 #define LP872X_EN_LDO4_M        BIT(3)
0052 #define LP872X_EN_LDO5_M        BIT(4)
0053 
0054 /* Mask/shift : LP8720 */
0055 #define LP8720_TIMESTEP_S       0       /* Addr 00h */
0056 #define LP8720_TIMESTEP_M       BIT(0)
0057 #define LP8720_EXT_DVS_M        BIT(2)
0058 #define LP8720_BUCK_FPWM_S      5       /* Addr 07h */
0059 #define LP8720_BUCK_FPWM_M      BIT(5)
0060 #define LP8720_EN_BUCK_M        BIT(5)      /* Addr 08h */
0061 #define LP8720_DVS_SEL_M        BIT(7)
0062 
0063 /* Mask/shift : LP8725 */
0064 #define LP8725_TIMESTEP_M       0xC0        /* Addr 00h */
0065 #define LP8725_TIMESTEP_S       6
0066 #define LP8725_BUCK1_EN_M       BIT(0)
0067 #define LP8725_DVS1_M           BIT(2)
0068 #define LP8725_DVS2_M           BIT(3)
0069 #define LP8725_BUCK2_EN_M       BIT(4)
0070 #define LP8725_BUCK_CL_M        0xC0        /* Addr 09h, 0Bh */
0071 #define LP8725_BUCK_CL_S        6
0072 #define LP8725_BUCK1_FPWM_S     1       /* Addr 0Ch */
0073 #define LP8725_BUCK1_FPWM_M     BIT(1)
0074 #define LP8725_BUCK2_FPWM_S     5
0075 #define LP8725_BUCK2_FPWM_M     BIT(5)
0076 #define LP8725_EN_LILO1_M       BIT(5)      /* Addr 0Dh */
0077 #define LP8725_EN_LILO2_M       BIT(6)
0078 
0079 /* PWM mode */
0080 #define LP872X_FORCE_PWM        1
0081 #define LP872X_AUTO_PWM         0
0082 
0083 #define LP8720_NUM_REGULATORS       6
0084 #define LP8725_NUM_REGULATORS       9
0085 #define EXTERN_DVS_USED         0
0086 #define MAX_DELAY           6
0087 
0088 /* Default DVS Mode */
0089 #define LP8720_DEFAULT_DVS      0
0090 #define LP8725_DEFAULT_DVS      BIT(2)
0091 
0092 /* dump registers in regmap-debugfs */
0093 #define MAX_REGISTERS           0x0F
0094 
0095 enum lp872x_id {
0096     LP8720,
0097     LP8725,
0098 };
0099 
0100 struct lp872x {
0101     struct regmap *regmap;
0102     struct device *dev;
0103     enum lp872x_id chipid;
0104     struct lp872x_platform_data *pdata;
0105     int num_regulators;
0106     enum gpiod_flags dvs_pin;
0107 };
0108 
0109 /* LP8720/LP8725 shared voltage table for LDOs */
0110 static const unsigned int lp872x_ldo_vtbl[] = {
0111     1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
0112     1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
0113     2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
0114     2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
0115 };
0116 
0117 /* LP8720 LDO4 voltage table */
0118 static const unsigned int lp8720_ldo4_vtbl[] = {
0119      800000,  850000,  900000, 1000000, 1100000, 1200000, 1250000, 1300000,
0120     1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
0121     1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
0122     2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
0123 };
0124 
0125 /* LP8725 LILO(Low Input Low Output) voltage table */
0126 static const unsigned int lp8725_lilo_vtbl[] = {
0127      800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
0128     1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
0129     1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
0130     2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
0131 };
0132 
0133 /* LP8720 BUCK voltage table */
0134 #define EXT_R       0   /* external resistor divider */
0135 static const unsigned int lp8720_buck_vtbl[] = {
0136       EXT_R,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
0137     1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
0138     1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
0139     1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
0140 };
0141 
0142 /* LP8725 BUCK voltage table */
0143 static const unsigned int lp8725_buck_vtbl[] = {
0144      800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
0145     1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
0146     1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
0147     2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
0148 };
0149 
0150 /* LP8725 BUCK current limit */
0151 static const unsigned int lp8725_buck_uA[] = {
0152     460000, 780000, 1050000, 1370000,
0153 };
0154 
0155 static int lp872x_read_byte(struct lp872x *lp, u8 addr, u8 *data)
0156 {
0157     int ret;
0158     unsigned int val;
0159 
0160     ret = regmap_read(lp->regmap, addr, &val);
0161     if (ret < 0) {
0162         dev_err(lp->dev, "failed to read 0x%.2x\n", addr);
0163         return ret;
0164     }
0165 
0166     *data = (u8)val;
0167     return 0;
0168 }
0169 
0170 static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
0171 {
0172     return regmap_write(lp->regmap, addr, data);
0173 }
0174 
0175 static inline int lp872x_update_bits(struct lp872x *lp, u8 addr,
0176                 unsigned int mask, u8 data)
0177 {
0178     return regmap_update_bits(lp->regmap, addr, mask, data);
0179 }
0180 
0181 static int lp872x_get_timestep_usec(struct lp872x *lp)
0182 {
0183     enum lp872x_id chip = lp->chipid;
0184     u8 val, mask, shift;
0185     int *time_usec, size, ret;
0186     int lp8720_time_usec[] = { 25, 50 };
0187     int lp8725_time_usec[] = { 32, 64, 128, 256 };
0188 
0189     switch (chip) {
0190     case LP8720:
0191         mask = LP8720_TIMESTEP_M;
0192         shift = LP8720_TIMESTEP_S;
0193         time_usec = &lp8720_time_usec[0];
0194         size = ARRAY_SIZE(lp8720_time_usec);
0195         break;
0196     case LP8725:
0197         mask = LP8725_TIMESTEP_M;
0198         shift = LP8725_TIMESTEP_S;
0199         time_usec = &lp8725_time_usec[0];
0200         size = ARRAY_SIZE(lp8725_time_usec);
0201         break;
0202     default:
0203         return -EINVAL;
0204     }
0205 
0206     ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
0207     if (ret)
0208         return ret;
0209 
0210     val = (val & mask) >> shift;
0211     if (val >= size)
0212         return -EINVAL;
0213 
0214     return *(time_usec + val);
0215 }
0216 
0217 static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
0218 {
0219     struct lp872x *lp = rdev_get_drvdata(rdev);
0220     enum lp872x_regulator_id rid = rdev_get_id(rdev);
0221     int time_step_us = lp872x_get_timestep_usec(lp);
0222     int ret;
0223     u8 addr, val;
0224 
0225     if (time_step_us < 0)
0226         return time_step_us;
0227 
0228     switch (rid) {
0229     case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
0230         addr = LP872X_LDO1_VOUT + rid;
0231         break;
0232     case LP8725_ID_LDO1 ... LP8725_ID_BUCK1:
0233         addr = LP872X_LDO1_VOUT + rid - LP8725_ID_BASE;
0234         break;
0235     case LP8725_ID_BUCK2:
0236         addr = LP8725_BUCK2_VOUT1;
0237         break;
0238     default:
0239         return -EINVAL;
0240     }
0241 
0242     ret = lp872x_read_byte(lp, addr, &val);
0243     if (ret)
0244         return ret;
0245 
0246     val = (val & LP872X_START_DELAY_M) >> LP872X_START_DELAY_S;
0247 
0248     return val > MAX_DELAY ? 0 : val * time_step_us;
0249 }
0250 
0251 static void lp872x_set_dvs(struct lp872x *lp, enum lp872x_dvs_sel dvs_sel,
0252             struct gpio_desc *gpio)
0253 {
0254     enum gpiod_flags state;
0255 
0256     state = dvs_sel == SEL_V1 ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
0257     gpiod_set_value(gpio, state);
0258     lp->dvs_pin = state;
0259 }
0260 
0261 static u8 lp872x_select_buck_vout_addr(struct lp872x *lp,
0262                 enum lp872x_regulator_id buck)
0263 {
0264     u8 val, addr;
0265 
0266     if (lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val))
0267         return 0;
0268 
0269     switch (buck) {
0270     case LP8720_ID_BUCK:
0271         if (val & LP8720_EXT_DVS_M) {
0272             addr = (lp->dvs_pin == GPIOD_OUT_HIGH) ?
0273                 LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
0274         } else {
0275             if (lp872x_read_byte(lp, LP8720_ENABLE, &val))
0276                 return 0;
0277 
0278             addr = val & LP8720_DVS_SEL_M ?
0279                 LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
0280         }
0281         break;
0282     case LP8725_ID_BUCK1:
0283         if (val & LP8725_DVS1_M)
0284             addr = LP8725_BUCK1_VOUT1;
0285         else
0286             addr = (lp->dvs_pin == GPIOD_OUT_HIGH) ?
0287                 LP8725_BUCK1_VOUT1 : LP8725_BUCK1_VOUT2;
0288         break;
0289     case LP8725_ID_BUCK2:
0290         addr =  val & LP8725_DVS2_M ?
0291             LP8725_BUCK2_VOUT1 : LP8725_BUCK2_VOUT2;
0292         break;
0293     default:
0294         return 0;
0295     }
0296 
0297     return addr;
0298 }
0299 
0300 static bool lp872x_is_valid_buck_addr(u8 addr)
0301 {
0302     switch (addr) {
0303     case LP8720_BUCK_VOUT1:
0304     case LP8720_BUCK_VOUT2:
0305     case LP8725_BUCK1_VOUT1:
0306     case LP8725_BUCK1_VOUT2:
0307     case LP8725_BUCK2_VOUT1:
0308     case LP8725_BUCK2_VOUT2:
0309         return true;
0310     default:
0311         return false;
0312     }
0313 }
0314 
0315 static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
0316                     unsigned selector)
0317 {
0318     struct lp872x *lp = rdev_get_drvdata(rdev);
0319     enum lp872x_regulator_id buck = rdev_get_id(rdev);
0320     u8 addr, mask = LP872X_VOUT_M;
0321     struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
0322 
0323     if (dvs && dvs->gpio)
0324         lp872x_set_dvs(lp, dvs->vsel, dvs->gpio);
0325 
0326     addr = lp872x_select_buck_vout_addr(lp, buck);
0327     if (!lp872x_is_valid_buck_addr(addr))
0328         return -EINVAL;
0329 
0330     return lp872x_update_bits(lp, addr, mask, selector);
0331 }
0332 
0333 static int lp872x_buck_get_voltage_sel(struct regulator_dev *rdev)
0334 {
0335     struct lp872x *lp = rdev_get_drvdata(rdev);
0336     enum lp872x_regulator_id buck = rdev_get_id(rdev);
0337     u8 addr, val;
0338     int ret;
0339 
0340     addr = lp872x_select_buck_vout_addr(lp, buck);
0341     if (!lp872x_is_valid_buck_addr(addr))
0342         return -EINVAL;
0343 
0344     ret = lp872x_read_byte(lp, addr, &val);
0345     if (ret)
0346         return ret;
0347 
0348     return val & LP872X_VOUT_M;
0349 }
0350 
0351 static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
0352 {
0353     struct lp872x *lp = rdev_get_drvdata(rdev);
0354     enum lp872x_regulator_id buck = rdev_get_id(rdev);
0355     u8 addr, mask, shift, val;
0356 
0357     switch (buck) {
0358     case LP8720_ID_BUCK:
0359         addr = LP8720_BUCK_VOUT2;
0360         mask = LP8720_BUCK_FPWM_M;
0361         shift = LP8720_BUCK_FPWM_S;
0362         break;
0363     case LP8725_ID_BUCK1:
0364         addr = LP8725_BUCK_CTRL;
0365         mask = LP8725_BUCK1_FPWM_M;
0366         shift = LP8725_BUCK1_FPWM_S;
0367         break;
0368     case LP8725_ID_BUCK2:
0369         addr = LP8725_BUCK_CTRL;
0370         mask = LP8725_BUCK2_FPWM_M;
0371         shift = LP8725_BUCK2_FPWM_S;
0372         break;
0373     default:
0374         return -EINVAL;
0375     }
0376 
0377     if (mode == REGULATOR_MODE_FAST)
0378         val = LP872X_FORCE_PWM << shift;
0379     else if (mode == REGULATOR_MODE_NORMAL)
0380         val = LP872X_AUTO_PWM << shift;
0381     else
0382         return -EINVAL;
0383 
0384     return lp872x_update_bits(lp, addr, mask, val);
0385 }
0386 
0387 static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
0388 {
0389     struct lp872x *lp = rdev_get_drvdata(rdev);
0390     enum lp872x_regulator_id buck = rdev_get_id(rdev);
0391     u8 addr, mask, val;
0392     int ret;
0393 
0394     switch (buck) {
0395     case LP8720_ID_BUCK:
0396         addr = LP8720_BUCK_VOUT2;
0397         mask = LP8720_BUCK_FPWM_M;
0398         break;
0399     case LP8725_ID_BUCK1:
0400         addr = LP8725_BUCK_CTRL;
0401         mask = LP8725_BUCK1_FPWM_M;
0402         break;
0403     case LP8725_ID_BUCK2:
0404         addr = LP8725_BUCK_CTRL;
0405         mask = LP8725_BUCK2_FPWM_M;
0406         break;
0407     default:
0408         return -EINVAL;
0409     }
0410 
0411     ret = lp872x_read_byte(lp, addr, &val);
0412     if (ret)
0413         return ret;
0414 
0415     return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
0416 }
0417 
0418 static const struct regulator_ops lp872x_ldo_ops = {
0419     .list_voltage = regulator_list_voltage_table,
0420     .map_voltage = regulator_map_voltage_ascend,
0421     .set_voltage_sel = regulator_set_voltage_sel_regmap,
0422     .get_voltage_sel = regulator_get_voltage_sel_regmap,
0423     .enable = regulator_enable_regmap,
0424     .disable = regulator_disable_regmap,
0425     .is_enabled = regulator_is_enabled_regmap,
0426     .enable_time = lp872x_regulator_enable_time,
0427 };
0428 
0429 static const struct regulator_ops lp8720_buck_ops = {
0430     .list_voltage = regulator_list_voltage_table,
0431     .map_voltage = regulator_map_voltage_ascend,
0432     .set_voltage_sel = lp872x_buck_set_voltage_sel,
0433     .get_voltage_sel = lp872x_buck_get_voltage_sel,
0434     .enable = regulator_enable_regmap,
0435     .disable = regulator_disable_regmap,
0436     .is_enabled = regulator_is_enabled_regmap,
0437     .enable_time = lp872x_regulator_enable_time,
0438     .set_mode = lp872x_buck_set_mode,
0439     .get_mode = lp872x_buck_get_mode,
0440 };
0441 
0442 static const struct regulator_ops lp8725_buck_ops = {
0443     .list_voltage = regulator_list_voltage_table,
0444     .map_voltage = regulator_map_voltage_ascend,
0445     .set_voltage_sel = lp872x_buck_set_voltage_sel,
0446     .get_voltage_sel = lp872x_buck_get_voltage_sel,
0447     .enable = regulator_enable_regmap,
0448     .disable = regulator_disable_regmap,
0449     .is_enabled = regulator_is_enabled_regmap,
0450     .enable_time = lp872x_regulator_enable_time,
0451     .set_mode = lp872x_buck_set_mode,
0452     .get_mode = lp872x_buck_get_mode,
0453     .set_current_limit = regulator_set_current_limit_regmap,
0454     .get_current_limit = regulator_get_current_limit_regmap,
0455 };
0456 
0457 static const struct regulator_desc lp8720_regulator_desc[] = {
0458     {
0459         .name = "ldo1",
0460         .of_match = of_match_ptr("ldo1"),
0461         .id = LP8720_ID_LDO1,
0462         .ops = &lp872x_ldo_ops,
0463         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0464         .volt_table = lp872x_ldo_vtbl,
0465         .type = REGULATOR_VOLTAGE,
0466         .owner = THIS_MODULE,
0467         .vsel_reg = LP872X_LDO1_VOUT,
0468         .vsel_mask = LP872X_VOUT_M,
0469         .enable_reg = LP8720_ENABLE,
0470         .enable_mask = LP872X_EN_LDO1_M,
0471     },
0472     {
0473         .name = "ldo2",
0474         .of_match = of_match_ptr("ldo2"),
0475         .id = LP8720_ID_LDO2,
0476         .ops = &lp872x_ldo_ops,
0477         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0478         .volt_table = lp872x_ldo_vtbl,
0479         .type = REGULATOR_VOLTAGE,
0480         .owner = THIS_MODULE,
0481         .vsel_reg = LP872X_LDO2_VOUT,
0482         .vsel_mask = LP872X_VOUT_M,
0483         .enable_reg = LP8720_ENABLE,
0484         .enable_mask = LP872X_EN_LDO2_M,
0485     },
0486     {
0487         .name = "ldo3",
0488         .of_match = of_match_ptr("ldo3"),
0489         .id = LP8720_ID_LDO3,
0490         .ops = &lp872x_ldo_ops,
0491         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0492         .volt_table = lp872x_ldo_vtbl,
0493         .type = REGULATOR_VOLTAGE,
0494         .owner = THIS_MODULE,
0495         .vsel_reg = LP872X_LDO3_VOUT,
0496         .vsel_mask = LP872X_VOUT_M,
0497         .enable_reg = LP8720_ENABLE,
0498         .enable_mask = LP872X_EN_LDO3_M,
0499     },
0500     {
0501         .name = "ldo4",
0502         .of_match = of_match_ptr("ldo4"),
0503         .id = LP8720_ID_LDO4,
0504         .ops = &lp872x_ldo_ops,
0505         .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
0506         .volt_table = lp8720_ldo4_vtbl,
0507         .type = REGULATOR_VOLTAGE,
0508         .owner = THIS_MODULE,
0509         .vsel_reg = LP872X_LDO4_VOUT,
0510         .vsel_mask = LP872X_VOUT_M,
0511         .enable_reg = LP8720_ENABLE,
0512         .enable_mask = LP872X_EN_LDO4_M,
0513     },
0514     {
0515         .name = "ldo5",
0516         .of_match = of_match_ptr("ldo5"),
0517         .id = LP8720_ID_LDO5,
0518         .ops = &lp872x_ldo_ops,
0519         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0520         .volt_table = lp872x_ldo_vtbl,
0521         .type = REGULATOR_VOLTAGE,
0522         .owner = THIS_MODULE,
0523         .vsel_reg = LP872X_LDO5_VOUT,
0524         .vsel_mask = LP872X_VOUT_M,
0525         .enable_reg = LP8720_ENABLE,
0526         .enable_mask = LP872X_EN_LDO5_M,
0527     },
0528     {
0529         .name = "buck",
0530         .of_match = of_match_ptr("buck"),
0531         .id = LP8720_ID_BUCK,
0532         .ops = &lp8720_buck_ops,
0533         .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
0534         .volt_table = lp8720_buck_vtbl,
0535         .type = REGULATOR_VOLTAGE,
0536         .owner = THIS_MODULE,
0537         .enable_reg = LP8720_ENABLE,
0538         .enable_mask = LP8720_EN_BUCK_M,
0539     },
0540 };
0541 
0542 static const struct regulator_desc lp8725_regulator_desc[] = {
0543     {
0544         .name = "ldo1",
0545         .of_match = of_match_ptr("ldo1"),
0546         .id = LP8725_ID_LDO1,
0547         .ops = &lp872x_ldo_ops,
0548         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0549         .volt_table = lp872x_ldo_vtbl,
0550         .type = REGULATOR_VOLTAGE,
0551         .owner = THIS_MODULE,
0552         .vsel_reg = LP872X_LDO1_VOUT,
0553         .vsel_mask = LP872X_VOUT_M,
0554         .enable_reg = LP8725_LDO_CTRL,
0555         .enable_mask = LP872X_EN_LDO1_M,
0556     },
0557     {
0558         .name = "ldo2",
0559         .of_match = of_match_ptr("ldo2"),
0560         .id = LP8725_ID_LDO2,
0561         .ops = &lp872x_ldo_ops,
0562         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0563         .volt_table = lp872x_ldo_vtbl,
0564         .type = REGULATOR_VOLTAGE,
0565         .owner = THIS_MODULE,
0566         .vsel_reg = LP872X_LDO2_VOUT,
0567         .vsel_mask = LP872X_VOUT_M,
0568         .enable_reg = LP8725_LDO_CTRL,
0569         .enable_mask = LP872X_EN_LDO2_M,
0570     },
0571     {
0572         .name = "ldo3",
0573         .of_match = of_match_ptr("ldo3"),
0574         .id = LP8725_ID_LDO3,
0575         .ops = &lp872x_ldo_ops,
0576         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0577         .volt_table = lp872x_ldo_vtbl,
0578         .type = REGULATOR_VOLTAGE,
0579         .owner = THIS_MODULE,
0580         .vsel_reg = LP872X_LDO3_VOUT,
0581         .vsel_mask = LP872X_VOUT_M,
0582         .enable_reg = LP8725_LDO_CTRL,
0583         .enable_mask = LP872X_EN_LDO3_M,
0584     },
0585     {
0586         .name = "ldo4",
0587         .of_match = of_match_ptr("ldo4"),
0588         .id = LP8725_ID_LDO4,
0589         .ops = &lp872x_ldo_ops,
0590         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0591         .volt_table = lp872x_ldo_vtbl,
0592         .type = REGULATOR_VOLTAGE,
0593         .owner = THIS_MODULE,
0594         .vsel_reg = LP872X_LDO4_VOUT,
0595         .vsel_mask = LP872X_VOUT_M,
0596         .enable_reg = LP8725_LDO_CTRL,
0597         .enable_mask = LP872X_EN_LDO4_M,
0598     },
0599     {
0600         .name = "ldo5",
0601         .of_match = of_match_ptr("ldo5"),
0602         .id = LP8725_ID_LDO5,
0603         .ops = &lp872x_ldo_ops,
0604         .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
0605         .volt_table = lp872x_ldo_vtbl,
0606         .type = REGULATOR_VOLTAGE,
0607         .owner = THIS_MODULE,
0608         .vsel_reg = LP872X_LDO5_VOUT,
0609         .vsel_mask = LP872X_VOUT_M,
0610         .enable_reg = LP8725_LDO_CTRL,
0611         .enable_mask = LP872X_EN_LDO5_M,
0612     },
0613     {
0614         .name = "lilo1",
0615         .of_match = of_match_ptr("lilo1"),
0616         .id = LP8725_ID_LILO1,
0617         .ops = &lp872x_ldo_ops,
0618         .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
0619         .volt_table = lp8725_lilo_vtbl,
0620         .type = REGULATOR_VOLTAGE,
0621         .owner = THIS_MODULE,
0622         .vsel_reg = LP8725_LILO1_VOUT,
0623         .vsel_mask = LP872X_VOUT_M,
0624         .enable_reg = LP8725_LDO_CTRL,
0625         .enable_mask = LP8725_EN_LILO1_M,
0626     },
0627     {
0628         .name = "lilo2",
0629         .of_match = of_match_ptr("lilo2"),
0630         .id = LP8725_ID_LILO2,
0631         .ops = &lp872x_ldo_ops,
0632         .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
0633         .volt_table = lp8725_lilo_vtbl,
0634         .type = REGULATOR_VOLTAGE,
0635         .owner = THIS_MODULE,
0636         .vsel_reg = LP8725_LILO2_VOUT,
0637         .vsel_mask = LP872X_VOUT_M,
0638         .enable_reg = LP8725_LDO_CTRL,
0639         .enable_mask = LP8725_EN_LILO2_M,
0640     },
0641     {
0642         .name = "buck1",
0643         .of_match = of_match_ptr("buck1"),
0644         .id = LP8725_ID_BUCK1,
0645         .ops = &lp8725_buck_ops,
0646         .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
0647         .volt_table = lp8725_buck_vtbl,
0648         .type = REGULATOR_VOLTAGE,
0649         .owner = THIS_MODULE,
0650         .enable_reg = LP872X_GENERAL_CFG,
0651         .enable_mask = LP8725_BUCK1_EN_M,
0652         .curr_table = lp8725_buck_uA,
0653         .n_current_limits = ARRAY_SIZE(lp8725_buck_uA),
0654         .csel_reg = LP8725_BUCK1_VOUT2,
0655         .csel_mask = LP8725_BUCK_CL_M,
0656     },
0657     {
0658         .name = "buck2",
0659         .of_match = of_match_ptr("buck2"),
0660         .id = LP8725_ID_BUCK2,
0661         .ops = &lp8725_buck_ops,
0662         .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
0663         .volt_table = lp8725_buck_vtbl,
0664         .type = REGULATOR_VOLTAGE,
0665         .owner = THIS_MODULE,
0666         .enable_reg = LP872X_GENERAL_CFG,
0667         .enable_mask = LP8725_BUCK2_EN_M,
0668         .curr_table = lp8725_buck_uA,
0669         .n_current_limits = ARRAY_SIZE(lp8725_buck_uA),
0670         .csel_reg = LP8725_BUCK2_VOUT2,
0671         .csel_mask = LP8725_BUCK_CL_M,
0672     },
0673 };
0674 
0675 static int lp872x_init_dvs(struct lp872x *lp)
0676 {
0677     struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
0678     enum gpiod_flags pinstate;
0679     u8 mask[] = { LP8720_EXT_DVS_M, LP8725_DVS1_M | LP8725_DVS2_M };
0680     u8 default_dvs_mode[] = { LP8720_DEFAULT_DVS, LP8725_DEFAULT_DVS };
0681 
0682     if (!dvs)
0683         goto set_default_dvs_mode;
0684 
0685     if (!dvs->gpio)
0686         goto set_default_dvs_mode;
0687 
0688     pinstate = dvs->init_state;
0689     dvs->gpio = devm_gpiod_get_optional(lp->dev, "ti,dvs", pinstate);
0690 
0691     if (IS_ERR(dvs->gpio)) {
0692         dev_err(lp->dev, "gpio request err: %ld\n", PTR_ERR(dvs->gpio));
0693         return PTR_ERR(dvs->gpio);
0694     }
0695 
0696     lp->dvs_pin = pinstate;
0697 
0698     return 0;
0699 
0700 set_default_dvs_mode:
0701     return lp872x_update_bits(lp, LP872X_GENERAL_CFG, mask[lp->chipid],
0702                 default_dvs_mode[lp->chipid]);
0703 }
0704 
0705 static int lp872x_hw_enable(struct lp872x *lp)
0706 {
0707     if (!lp->pdata)
0708         return -EINVAL;
0709 
0710     if (!lp->pdata->enable_gpio)
0711         return 0;
0712 
0713     /* Always set enable GPIO high. */
0714     lp->pdata->enable_gpio = devm_gpiod_get_optional(lp->dev, "enable", GPIOD_OUT_HIGH);
0715     if (IS_ERR(lp->pdata->enable_gpio)) {
0716         dev_err(lp->dev, "gpio request err: %ld\n", PTR_ERR(lp->pdata->enable_gpio));
0717         return PTR_ERR(lp->pdata->enable_gpio);
0718     }
0719 
0720     /* Each chip has a different enable delay. */
0721     if (lp->chipid == LP8720)
0722         usleep_range(LP8720_ENABLE_DELAY, 1.5 * LP8720_ENABLE_DELAY);
0723     else
0724         usleep_range(LP8725_ENABLE_DELAY, 1.5 * LP8725_ENABLE_DELAY);
0725 
0726     return 0;
0727 }
0728 
0729 static int lp872x_config(struct lp872x *lp)
0730 {
0731     struct lp872x_platform_data *pdata = lp->pdata;
0732     int ret;
0733 
0734     if (!pdata || !pdata->update_config)
0735         goto init_dvs;
0736 
0737     ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
0738     if (ret)
0739         return ret;
0740 
0741 init_dvs:
0742     return lp872x_init_dvs(lp);
0743 }
0744 
0745 static struct regulator_init_data
0746 *lp872x_find_regulator_init_data(int id, struct lp872x *lp)
0747 {
0748     struct lp872x_platform_data *pdata = lp->pdata;
0749     int i;
0750 
0751     if (!pdata)
0752         return NULL;
0753 
0754     for (i = 0; i < lp->num_regulators; i++) {
0755         if (pdata->regulator_data[i].id == id)
0756             return pdata->regulator_data[i].init_data;
0757     }
0758 
0759     return NULL;
0760 }
0761 
0762 static int lp872x_regulator_register(struct lp872x *lp)
0763 {
0764     const struct regulator_desc *desc;
0765     struct regulator_config cfg = { };
0766     struct regulator_dev *rdev;
0767     int i;
0768 
0769     for (i = 0; i < lp->num_regulators; i++) {
0770         desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
0771                         &lp8725_regulator_desc[i];
0772 
0773         cfg.dev = lp->dev;
0774         cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
0775         cfg.driver_data = lp;
0776         cfg.regmap = lp->regmap;
0777 
0778         rdev = devm_regulator_register(lp->dev, desc, &cfg);
0779         if (IS_ERR(rdev)) {
0780             dev_err(lp->dev, "regulator register err");
0781             return PTR_ERR(rdev);
0782         }
0783     }
0784 
0785     return 0;
0786 }
0787 
0788 static const struct regmap_config lp872x_regmap_config = {
0789     .reg_bits = 8,
0790     .val_bits = 8,
0791     .max_register = MAX_REGISTERS,
0792 };
0793 
0794 #ifdef CONFIG_OF
0795 
0796 #define LP872X_VALID_OPMODE (REGULATOR_MODE_FAST | REGULATOR_MODE_NORMAL)
0797 
0798 static struct of_regulator_match lp8720_matches[] = {
0799     { .name = "ldo1", .driver_data = (void *)LP8720_ID_LDO1, },
0800     { .name = "ldo2", .driver_data = (void *)LP8720_ID_LDO2, },
0801     { .name = "ldo3", .driver_data = (void *)LP8720_ID_LDO3, },
0802     { .name = "ldo4", .driver_data = (void *)LP8720_ID_LDO4, },
0803     { .name = "ldo5", .driver_data = (void *)LP8720_ID_LDO5, },
0804     { .name = "buck", .driver_data = (void *)LP8720_ID_BUCK, },
0805 };
0806 
0807 static struct of_regulator_match lp8725_matches[] = {
0808     { .name = "ldo1", .driver_data = (void *)LP8725_ID_LDO1, },
0809     { .name = "ldo2", .driver_data = (void *)LP8725_ID_LDO2, },
0810     { .name = "ldo3", .driver_data = (void *)LP8725_ID_LDO3, },
0811     { .name = "ldo4", .driver_data = (void *)LP8725_ID_LDO4, },
0812     { .name = "ldo5", .driver_data = (void *)LP8725_ID_LDO5, },
0813     { .name = "lilo1", .driver_data = (void *)LP8725_ID_LILO1, },
0814     { .name = "lilo2", .driver_data = (void *)LP8725_ID_LILO2, },
0815     { .name = "buck1", .driver_data = (void *)LP8725_ID_BUCK1, },
0816     { .name = "buck2", .driver_data = (void *)LP8725_ID_BUCK2, },
0817 };
0818 
0819 static struct lp872x_platform_data
0820 *lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
0821 {
0822     struct device_node *np = dev->of_node;
0823     struct lp872x_platform_data *pdata;
0824     struct of_regulator_match *match;
0825     int num_matches;
0826     int count;
0827     int i;
0828     u8 dvs_state;
0829 
0830     pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
0831     if (!pdata)
0832         return ERR_PTR(-ENOMEM);
0833 
0834     of_property_read_u8(np, "ti,general-config", &pdata->general_config);
0835     if (of_find_property(np, "ti,update-config", NULL))
0836         pdata->update_config = true;
0837 
0838     pdata->dvs = devm_kzalloc(dev, sizeof(struct lp872x_dvs), GFP_KERNEL);
0839     if (!pdata->dvs)
0840         return ERR_PTR(-ENOMEM);
0841 
0842     of_property_read_u8(np, "ti,dvs-vsel", (u8 *)&pdata->dvs->vsel);
0843     of_property_read_u8(np, "ti,dvs-state", &dvs_state);
0844     pdata->dvs->init_state = dvs_state ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
0845 
0846     if (of_get_child_count(np) == 0)
0847         goto out;
0848 
0849     switch (which) {
0850     case LP8720:
0851         match = lp8720_matches;
0852         num_matches = ARRAY_SIZE(lp8720_matches);
0853         break;
0854     case LP8725:
0855         match = lp8725_matches;
0856         num_matches = ARRAY_SIZE(lp8725_matches);
0857         break;
0858     default:
0859         goto out;
0860     }
0861 
0862     count = of_regulator_match(dev, np, match, num_matches);
0863     if (count <= 0)
0864         goto out;
0865 
0866     for (i = 0; i < num_matches; i++) {
0867         pdata->regulator_data[i].id =
0868                 (enum lp872x_regulator_id)match[i].driver_data;
0869         pdata->regulator_data[i].init_data = match[i].init_data;
0870     }
0871 out:
0872     return pdata;
0873 }
0874 #else
0875 static struct lp872x_platform_data
0876 *lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
0877 {
0878     return NULL;
0879 }
0880 #endif
0881 
0882 static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
0883 {
0884     struct lp872x *lp;
0885     struct lp872x_platform_data *pdata;
0886     int ret;
0887     static const int lp872x_num_regulators[] = {
0888         [LP8720] = LP8720_NUM_REGULATORS,
0889         [LP8725] = LP8725_NUM_REGULATORS,
0890     };
0891 
0892     if (cl->dev.of_node) {
0893         pdata = lp872x_populate_pdata_from_dt(&cl->dev,
0894                           (enum lp872x_id)id->driver_data);
0895         if (IS_ERR(pdata))
0896             return PTR_ERR(pdata);
0897     } else {
0898         pdata = dev_get_platdata(&cl->dev);
0899     }
0900 
0901     lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
0902     if (!lp)
0903         return -ENOMEM;
0904 
0905     lp->num_regulators = lp872x_num_regulators[id->driver_data];
0906 
0907     lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
0908     if (IS_ERR(lp->regmap)) {
0909         ret = PTR_ERR(lp->regmap);
0910         dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
0911         return ret;
0912     }
0913 
0914     lp->dev = &cl->dev;
0915     lp->pdata = pdata;
0916     lp->chipid = id->driver_data;
0917     i2c_set_clientdata(cl, lp);
0918 
0919     ret = lp872x_hw_enable(lp);
0920     if (ret)
0921         return ret;
0922 
0923     ret = lp872x_config(lp);
0924     if (ret)
0925         return ret;
0926 
0927     return lp872x_regulator_register(lp);
0928 }
0929 
0930 static const struct of_device_id lp872x_dt_ids[] = {
0931     { .compatible = "ti,lp8720", },
0932     { .compatible = "ti,lp8725", },
0933     { }
0934 };
0935 MODULE_DEVICE_TABLE(of, lp872x_dt_ids);
0936 
0937 static const struct i2c_device_id lp872x_ids[] = {
0938     {"lp8720", LP8720},
0939     {"lp8725", LP8725},
0940     { }
0941 };
0942 MODULE_DEVICE_TABLE(i2c, lp872x_ids);
0943 
0944 static struct i2c_driver lp872x_driver = {
0945     .driver = {
0946         .name = "lp872x",
0947         .of_match_table = of_match_ptr(lp872x_dt_ids),
0948     },
0949     .probe = lp872x_probe,
0950     .id_table = lp872x_ids,
0951 };
0952 
0953 module_i2c_driver(lp872x_driver);
0954 
0955 MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
0956 MODULE_AUTHOR("Milo Kim");
0957 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!