drivers/regulator/lp872x.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2012 Texas Instruments
   4  *
   5  * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/slab.h>
  10 #include <linux/i2c.h>
  11 #include <linux/regmap.h>
  12 #include <linux/err.h>
  13 #include <linux/gpio/consumer.h>
  14 #include <linux/delay.h>
  15 #include <linux/regulator/lp872x.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/of.h>
  19 #include <linux/regulator/of_regulator.h>
  20
  21 /* Registers : LP8720/8725 shared */
  22 #define LP872X_GENERAL_CFG              0x00
  23 #define LP872X_LDO1_VOUT                0x01
  24 #define LP872X_LDO2_VOUT                0x02
  25 #define LP872X_LDO3_VOUT                0x03
  26 #define LP872X_LDO4_VOUT                0x04
  27 #define LP872X_LDO5_VOUT                0x05
  28
  29 /* Registers : LP8720 */
  30 #define LP8720_BUCK_VOUT1               0x06
  31 #define LP8720_BUCK_VOUT2               0x07
  32 #define LP8720_ENABLE                   0x08
  33
  34 /* Registers : LP8725 */
  35 #define LP8725_LILO1_VOUT               0x06
  36 #define LP8725_LILO2_VOUT               0x07
  37 #define LP8725_BUCK1_VOUT1              0x08
  38 #define LP8725_BUCK1_VOUT2              0x09
  39 #define LP8725_BUCK2_VOUT1              0x0A
  40 #define LP8725_BUCK2_VOUT2              0x0B
  41 #define LP8725_BUCK_CTRL                0x0C
  42 #define LP8725_LDO_CTRL                 0x0D
  43
  44 /* Mask/shift : LP8720/LP8725 shared */
  45 #define LP872X_VOUT_M                   0x1F
  46 #define LP872X_START_DELAY_M            0xE0
  47 #define LP872X_START_DELAY_S            5
  48 #define LP872X_EN_LDO1_M                BIT(0)
  49 #define LP872X_EN_LDO2_M                BIT(1)
  50 #define LP872X_EN_LDO3_M                BIT(2)
  51 #define LP872X_EN_LDO4_M                BIT(3)
  52 #define LP872X_EN_LDO5_M                BIT(4)
  53
  54 /* Mask/shift : LP8720 */
  55 #define LP8720_TIMESTEP_S               0               /* Addr 00h */
  56 #define LP8720_TIMESTEP_M               BIT(0)
  57 #define LP8720_EXT_DVS_M                BIT(2)
  58 #define LP8720_BUCK_FPWM_S              5               /* Addr 07h */
  59 #define LP8720_BUCK_FPWM_M              BIT(5)
  60 #define LP8720_EN_BUCK_M                BIT(5)          /* Addr 08h */
  61 #define LP8720_DVS_SEL_M                BIT(7)
  62
  63 /* Mask/shift : LP8725 */
  64 #define LP8725_TIMESTEP_M               0xC0            /* Addr 00h */
  65 #define LP8725_TIMESTEP_S               6
  66 #define LP8725_BUCK1_EN_M               BIT(0)
  67 #define LP8725_DVS1_M                   BIT(2)
  68 #define LP8725_DVS2_M                   BIT(3)
  69 #define LP8725_BUCK2_EN_M               BIT(4)
  70 #define LP8725_BUCK_CL_M                0xC0            /* Addr 09h, 0Bh */
  71 #define LP8725_BUCK_CL_S                6
  72 #define LP8725_BUCK1_FPWM_S             1               /* Addr 0Ch */
  73 #define LP8725_BUCK1_FPWM_M             BIT(1)
  74 #define LP8725_BUCK2_FPWM_S             5
  75 #define LP8725_BUCK2_FPWM_M             BIT(5)
  76 #define LP8725_EN_LILO1_M               BIT(5)          /* Addr 0Dh */
  77 #define LP8725_EN_LILO2_M               BIT(6)
  78
  79 /* PWM mode */
  80 #define LP872X_FORCE_PWM                1
  81 #define LP872X_AUTO_PWM                 0
  82
  83 #define LP8720_NUM_REGULATORS           6
  84 #define LP8725_NUM_REGULATORS           9
  85 #define EXTERN_DVS_USED                 0
  86 #define MAX_DELAY                       6
  87
  88 /* Default DVS Mode */
  89 #define LP8720_DEFAULT_DVS              0
  90 #define LP8725_DEFAULT_DVS              BIT(2)
  91
  92 /* dump registers in regmap-debugfs */
  93 #define MAX_REGISTERS                   0x0F
  94
  95 enum lp872x_id {
  96         LP8720,
  97         LP8725,
  98 };
  99
 100 struct lp872x {
 101         struct regmap *regmap;
 102         struct device *dev;
 103         enum lp872x_id chipid;
 104         struct lp872x_platform_data *pdata;
 105         int num_regulators;
 106         enum gpiod_flags dvs_pin;
 107 };
 108
 109 /* LP8720/LP8725 shared voltage table for LDOs */
 110 static const unsigned int lp872x_ldo_vtbl[] = {
 111         1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
 112         1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
 113         2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
 114         2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
 115 };
 116
 117 /* LP8720 LDO4 voltage table */
 118 static const unsigned int lp8720_ldo4_vtbl[] = {
 119          800000,  850000,  900000, 1000000, 1100000, 1200000, 1250000, 1300000,
 120         1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
 121         1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
 122         2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
 123 };
 124
 125 /* LP8725 LILO(Low Input Low Output) voltage table */
 126 static const unsigned int lp8725_lilo_vtbl[] = {
 127          800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
 128         1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
 129         1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
 130         2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
 131 };
 132
 133 /* LP8720 BUCK voltage table */
 134 #define EXT_R           0       /* external resistor divider */
 135 static const unsigned int lp8720_buck_vtbl[] = {
 136           EXT_R,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
 137         1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
 138         1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
 139         1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
 140 };
 141
 142 /* LP8725 BUCK voltage table */
 143 static const unsigned int lp8725_buck_vtbl[] = {
 144          800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
 145         1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
 146         1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
 147         2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
 148 };
 149
 150 /* LP8725 BUCK current limit */
 151 static const unsigned int lp8725_buck_uA[] = {
 152         460000, 780000, 1050000, 1370000,
 153 };
 154
 155 static int lp872x_read_byte(struct lp872x *lp, u8 addr, u8 *data)
 156 {
 157         int ret;
 158         unsigned int val;
 159
 160         ret = regmap_read(lp->regmap, addr, &val);
 161         if (ret < 0) {
 162                 dev_err(lp->dev, "failed to read 0x%.2x\n", addr);
 163                 return ret;
 164         }
 165
 166         *data = (u8)val;
 167         return 0;
 168 }
 169
 170 static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
 171 {
 172         return regmap_write(lp->regmap, addr, data);
 173 }
 174
 175 static inline int lp872x_update_bits(struct lp872x *lp, u8 addr,
 176                                 unsigned int mask, u8 data)
 177 {
 178         return regmap_update_bits(lp->regmap, addr, mask, data);
 179 }
 180
 181 static int lp872x_get_timestep_usec(struct lp872x *lp)
 182 {
 183         enum lp872x_id chip = lp->chipid;
 184         u8 val, mask, shift;
 185         int *time_usec, size, ret;
 186         int lp8720_time_usec[] = { 25, 50 };
 187         int lp8725_time_usec[] = { 32, 64, 128, 256 };
 188
 189         switch (chip) {
 190         case LP8720:
 191                 mask = LP8720_TIMESTEP_M;
 192                 shift = LP8720_TIMESTEP_S;
 193                 time_usec = &lp8720_time_usec[0];
 194                 size = ARRAY_SIZE(lp8720_time_usec);
 195                 break;
 196         case LP8725:
 197                 mask = LP8725_TIMESTEP_M;
 198                 shift = LP8725_TIMESTEP_S;
 199                 time_usec = &lp8725_time_usec[0];
 200                 size = ARRAY_SIZE(lp8725_time_usec);
 201                 break;
 202         default:
 203                 return -EINVAL;
 204         }
 205
 206         ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
 207         if (ret)
 208                 return ret;
 209
 210         val = (val & mask) >> shift;
 211         if (val >= size)
 212                 return -EINVAL;
 213
 214         return *(time_usec + val);
 215 }
 216
 217 static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
 218 {
 219         struct lp872x *lp = rdev_get_drvdata(rdev);
 220         enum lp872x_regulator_id rid = rdev_get_id(rdev);
 221         int time_step_us = lp872x_get_timestep_usec(lp);
 222         int ret;
 223         u8 addr, val;
 224
 225         if (time_step_us < 0)
 226                 return time_step_us;
 227
 228         switch (rid) {
 229         case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
 230                 addr = LP872X_LDO1_VOUT + rid;
 231                 break;
 232         case LP8725_ID_LDO1 ... LP8725_ID_BUCK1:
 233                 addr = LP872X_LDO1_VOUT + rid - LP8725_ID_BASE;
 234                 break;
 235         case LP8725_ID_BUCK2:
 236                 addr = LP8725_BUCK2_VOUT1;
 237                 break;
 238         default:
 239                 return -EINVAL;
 240         }
 241
 242         ret = lp872x_read_byte(lp, addr, &val);
 243         if (ret)
 244                 return ret;
 245
 246         val = (val & LP872X_START_DELAY_M) >> LP872X_START_DELAY_S;
 247
 248         return val > MAX_DELAY ? 0 : val * time_step_us;
 249 }
 250
 251 static void lp872x_set_dvs(struct lp872x *lp, enum lp872x_dvs_sel dvs_sel,
 252                         struct gpio_desc *gpio)
 253 {
 254         enum gpiod_flags state;
 255
 256         state = dvs_sel == SEL_V1 ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
 257         gpiod_set_value(gpio, state);
 258         lp->dvs_pin = state;
 259 }
 260
 261 static u8 lp872x_select_buck_vout_addr(struct lp872x *lp,
 262                                 enum lp872x_regulator_id buck)
 263 {
 264         u8 val, addr;
 265
 266         if (lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val))
 267                 return 0;
 268
 269         switch (buck) {
 270         case LP8720_ID_BUCK:
 271                 if (val & LP8720_EXT_DVS_M) {
 272                         addr = (lp->dvs_pin == GPIOD_OUT_HIGH) ?
 273                                 LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
 274                 } else {
 275                         if (lp872x_read_byte(lp, LP8720_ENABLE, &val))
 276                                 return 0;
 277
 278                         addr = val & LP8720_DVS_SEL_M ?
 279                                 LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
 280                 }
 281                 break;
 282         case LP8725_ID_BUCK1:
 283                 if (val & LP8725_DVS1_M)
 284                         addr = LP8725_BUCK1_VOUT1;
 285                 else
 286                         addr = (lp->dvs_pin == GPIOD_OUT_HIGH) ?
 287                                 LP8725_BUCK1_VOUT1 : LP8725_BUCK1_VOUT2;
 288                 break;
 289         case LP8725_ID_BUCK2:
 290                 addr =  val & LP8725_DVS2_M ?
 291                         LP8725_BUCK2_VOUT1 : LP8725_BUCK2_VOUT2;
 292                 break;
 293         default:
 294                 return 0;
 295         }
 296
 297         return addr;
 298 }
 299
 300 static bool lp872x_is_valid_buck_addr(u8 addr)
 301 {
 302         switch (addr) {
 303         case LP8720_BUCK_VOUT1:
 304         case LP8720_BUCK_VOUT2:
 305         case LP8725_BUCK1_VOUT1:
 306         case LP8725_BUCK1_VOUT2:
 307         case LP8725_BUCK2_VOUT1:
 308         case LP8725_BUCK2_VOUT2:
 309                 return true;
 310         default:
 311                 return false;
 312         }
 313 }
 314
 315 static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
 316                                         unsigned selector)
 317 {
 318         struct lp872x *lp = rdev_get_drvdata(rdev);
 319         enum lp872x_regulator_id buck = rdev_get_id(rdev);
 320         u8 addr, mask = LP872X_VOUT_M;
 321         struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
 322
 323         if (dvs && dvs->gpio)
 324                 lp872x_set_dvs(lp, dvs->vsel, dvs->gpio);
 325
 326         addr = lp872x_select_buck_vout_addr(lp, buck);
 327         if (!lp872x_is_valid_buck_addr(addr))
 328                 return -EINVAL;
 329
 330         return lp872x_update_bits(lp, addr, mask, selector);
 331 }
 332
 333 static int lp872x_buck_get_voltage_sel(struct regulator_dev *rdev)
 334 {
 335         struct lp872x *lp = rdev_get_drvdata(rdev);
 336         enum lp872x_regulator_id buck = rdev_get_id(rdev);
 337         u8 addr, val;
 338         int ret;
 339
 340         addr = lp872x_select_buck_vout_addr(lp, buck);
 341         if (!lp872x_is_valid_buck_addr(addr))
 342                 return -EINVAL;
 343
 344         ret = lp872x_read_byte(lp, addr, &val);
 345         if (ret)
 346                 return ret;
 347
 348         return val & LP872X_VOUT_M;
 349 }
 350
 351 static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
 352 {
 353         struct lp872x *lp = rdev_get_drvdata(rdev);
 354         enum lp872x_regulator_id buck = rdev_get_id(rdev);
 355         u8 addr, mask, shift, val;
 356
 357         switch (buck) {
 358         case LP8720_ID_BUCK:
 359                 addr = LP8720_BUCK_VOUT2;
 360                 mask = LP8720_BUCK_FPWM_M;
 361                 shift = LP8720_BUCK_FPWM_S;
 362                 break;
 363         case LP8725_ID_BUCK1:
 364                 addr = LP8725_BUCK_CTRL;
 365                 mask = LP8725_BUCK1_FPWM_M;
 366                 shift = LP8725_BUCK1_FPWM_S;
 367                 break;
 368         case LP8725_ID_BUCK2:
 369                 addr = LP8725_BUCK_CTRL;
 370                 mask = LP8725_BUCK2_FPWM_M;
 371                 shift = LP8725_BUCK2_FPWM_S;
 372                 break;
 373         default:
 374                 return -EINVAL;
 375         }
 376
 377         if (mode == REGULATOR_MODE_FAST)
 378                 val = LP872X_FORCE_PWM << shift;
 379         else if (mode == REGULATOR_MODE_NORMAL)
 380                 val = LP872X_AUTO_PWM << shift;
 381         else
 382                 return -EINVAL;
 383
 384         return lp872x_update_bits(lp, addr, mask, val);
 385 }
 386
 387 static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
 388 {
 389         struct lp872x *lp = rdev_get_drvdata(rdev);
 390         enum lp872x_regulator_id buck = rdev_get_id(rdev);
 391         u8 addr, mask, val;
 392         int ret;
 393
 394         switch (buck) {
 395         case LP8720_ID_BUCK:
 396                 addr = LP8720_BUCK_VOUT2;
 397                 mask = LP8720_BUCK_FPWM_M;
 398                 break;
 399         case LP8725_ID_BUCK1:
 400                 addr = LP8725_BUCK_CTRL;
 401                 mask = LP8725_BUCK1_FPWM_M;
 402                 break;
 403         case LP8725_ID_BUCK2:
 404                 addr = LP8725_BUCK_CTRL;
 405                 mask = LP8725_BUCK2_FPWM_M;
 406                 break;
 407         default:
 408                 return -EINVAL;
 409         }
 410
 411         ret = lp872x_read_byte(lp, addr, &val);
 412         if (ret)
 413                 return ret;
 414
 415         return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
 416 }
 417
 418 static const struct regulator_ops lp872x_ldo_ops = {
 419         .list_voltage = regulator_list_voltage_table,
 420         .map_voltage = regulator_map_voltage_ascend,
 421         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 422         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 423         .enable = regulator_enable_regmap,
 424         .disable = regulator_disable_regmap,
 425         .is_enabled = regulator_is_enabled_regmap,
 426         .enable_time = lp872x_regulator_enable_time,
 427 };
 428
 429 static const struct regulator_ops lp8720_buck_ops = {
 430         .list_voltage = regulator_list_voltage_table,
 431         .map_voltage = regulator_map_voltage_ascend,
 432         .set_voltage_sel = lp872x_buck_set_voltage_sel,
 433         .get_voltage_sel = lp872x_buck_get_voltage_sel,
 434         .enable = regulator_enable_regmap,
 435         .disable = regulator_disable_regmap,
 436         .is_enabled = regulator_is_enabled_regmap,
 437         .enable_time = lp872x_regulator_enable_time,
 438         .set_mode = lp872x_buck_set_mode,
 439         .get_mode = lp872x_buck_get_mode,
 440 };
 441
 442 static const struct regulator_ops lp8725_buck_ops = {
 443         .list_voltage = regulator_list_voltage_table,
 444         .map_voltage = regulator_map_voltage_ascend,
 445         .set_voltage_sel = lp872x_buck_set_voltage_sel,
 446         .get_voltage_sel = lp872x_buck_get_voltage_sel,
 447         .enable = regulator_enable_regmap,
 448         .disable = regulator_disable_regmap,
 449         .is_enabled = regulator_is_enabled_regmap,
 450         .enable_time = lp872x_regulator_enable_time,
 451         .set_mode = lp872x_buck_set_mode,
 452         .get_mode = lp872x_buck_get_mode,
 453         .set_current_limit = regulator_set_current_limit_regmap,
 454         .get_current_limit = regulator_get_current_limit_regmap,
 455 };
 456
 457 static const struct regulator_desc lp8720_regulator_desc[] = {
 458         {
 459                 .name = "ldo1",
 460                 .of_match = of_match_ptr("ldo1"),
 461                 .id = LP8720_ID_LDO1,
 462                 .ops = &lp872x_ldo_ops,
 463                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 464                 .volt_table = lp872x_ldo_vtbl,
 465                 .type = REGULATOR_VOLTAGE,
 466                 .owner = THIS_MODULE,
 467                 .vsel_reg = LP872X_LDO1_VOUT,
 468                 .vsel_mask = LP872X_VOUT_M,
 469                 .enable_reg = LP8720_ENABLE,
 470                 .enable_mask = LP872X_EN_LDO1_M,
 471         },
 472         {
 473                 .name = "ldo2",
 474                 .of_match = of_match_ptr("ldo2"),
 475                 .id = LP8720_ID_LDO2,
 476                 .ops = &lp872x_ldo_ops,
 477                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 478                 .volt_table = lp872x_ldo_vtbl,
 479                 .type = REGULATOR_VOLTAGE,
 480                 .owner = THIS_MODULE,
 481                 .vsel_reg = LP872X_LDO2_VOUT,
 482                 .vsel_mask = LP872X_VOUT_M,
 483                 .enable_reg = LP8720_ENABLE,
 484                 .enable_mask = LP872X_EN_LDO2_M,
 485         },
 486         {
 487                 .name = "ldo3",
 488                 .of_match = of_match_ptr("ldo3"),
 489                 .id = LP8720_ID_LDO3,
 490                 .ops = &lp872x_ldo_ops,
 491                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 492                 .volt_table = lp872x_ldo_vtbl,
 493                 .type = REGULATOR_VOLTAGE,
 494                 .owner = THIS_MODULE,
 495                 .vsel_reg = LP872X_LDO3_VOUT,
 496                 .vsel_mask = LP872X_VOUT_M,
 497                 .enable_reg = LP8720_ENABLE,
 498                 .enable_mask = LP872X_EN_LDO3_M,
 499         },
 500         {
 501                 .name = "ldo4",
 502                 .of_match = of_match_ptr("ldo4"),
 503                 .id = LP8720_ID_LDO4,
 504                 .ops = &lp872x_ldo_ops,
 505                 .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
 506                 .volt_table = lp8720_ldo4_vtbl,
 507                 .type = REGULATOR_VOLTAGE,
 508                 .owner = THIS_MODULE,
 509                 .vsel_reg = LP872X_LDO4_VOUT,
 510                 .vsel_mask = LP872X_VOUT_M,
 511                 .enable_reg = LP8720_ENABLE,
 512                 .enable_mask = LP872X_EN_LDO4_M,
 513         },
 514         {
 515                 .name = "ldo5",
 516                 .of_match = of_match_ptr("ldo5"),
 517                 .id = LP8720_ID_LDO5,
 518                 .ops = &lp872x_ldo_ops,
 519                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 520                 .volt_table = lp872x_ldo_vtbl,
 521                 .type = REGULATOR_VOLTAGE,
 522                 .owner = THIS_MODULE,
 523                 .vsel_reg = LP872X_LDO5_VOUT,
 524                 .vsel_mask = LP872X_VOUT_M,
 525                 .enable_reg = LP8720_ENABLE,
 526                 .enable_mask = LP872X_EN_LDO5_M,
 527         },
 528         {
 529                 .name = "buck",
 530                 .of_match = of_match_ptr("buck"),
 531                 .id = LP8720_ID_BUCK,
 532                 .ops = &lp8720_buck_ops,
 533                 .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
 534                 .volt_table = lp8720_buck_vtbl,
 535                 .type = REGULATOR_VOLTAGE,
 536                 .owner = THIS_MODULE,
 537                 .enable_reg = LP8720_ENABLE,
 538                 .enable_mask = LP8720_EN_BUCK_M,
 539         },
 540 };
 541
 542 static const struct regulator_desc lp8725_regulator_desc[] = {
 543         {
 544                 .name = "ldo1",
 545                 .of_match = of_match_ptr("ldo1"),
 546                 .id = LP8725_ID_LDO1,
 547                 .ops = &lp872x_ldo_ops,
 548                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 549                 .volt_table = lp872x_ldo_vtbl,
 550                 .type = REGULATOR_VOLTAGE,
 551                 .owner = THIS_MODULE,
 552                 .vsel_reg = LP872X_LDO1_VOUT,
 553                 .vsel_mask = LP872X_VOUT_M,
 554                 .enable_reg = LP8725_LDO_CTRL,
 555                 .enable_mask = LP872X_EN_LDO1_M,
 556         },
 557         {
 558                 .name = "ldo2",
 559                 .of_match = of_match_ptr("ldo2"),
 560                 .id = LP8725_ID_LDO2,
 561                 .ops = &lp872x_ldo_ops,
 562                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 563                 .volt_table = lp872x_ldo_vtbl,
 564                 .type = REGULATOR_VOLTAGE,
 565                 .owner = THIS_MODULE,
 566                 .vsel_reg = LP872X_LDO2_VOUT,
 567                 .vsel_mask = LP872X_VOUT_M,
 568                 .enable_reg = LP8725_LDO_CTRL,
 569                 .enable_mask = LP872X_EN_LDO2_M,
 570         },
 571         {
 572                 .name = "ldo3",
 573                 .of_match = of_match_ptr("ldo3"),
 574                 .id = LP8725_ID_LDO3,
 575                 .ops = &lp872x_ldo_ops,
 576                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 577                 .volt_table = lp872x_ldo_vtbl,
 578                 .type = REGULATOR_VOLTAGE,
 579                 .owner = THIS_MODULE,
 580                 .vsel_reg = LP872X_LDO3_VOUT,
 581                 .vsel_mask = LP872X_VOUT_M,
 582                 .enable_reg = LP8725_LDO_CTRL,
 583                 .enable_mask = LP872X_EN_LDO3_M,
 584         },
 585         {
 586                 .name = "ldo4",
 587                 .of_match = of_match_ptr("ldo4"),
 588                 .id = LP8725_ID_LDO4,
 589                 .ops = &lp872x_ldo_ops,
 590                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 591                 .volt_table = lp872x_ldo_vtbl,
 592                 .type = REGULATOR_VOLTAGE,
 593                 .owner = THIS_MODULE,
 594                 .vsel_reg = LP872X_LDO4_VOUT,
 595                 .vsel_mask = LP872X_VOUT_M,
 596                 .enable_reg = LP8725_LDO_CTRL,
 597                 .enable_mask = LP872X_EN_LDO4_M,
 598         },
 599         {
 600                 .name = "ldo5",
 601                 .of_match = of_match_ptr("ldo5"),
 602                 .id = LP8725_ID_LDO5,
 603                 .ops = &lp872x_ldo_ops,
 604                 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
 605                 .volt_table = lp872x_ldo_vtbl,
 606                 .type = REGULATOR_VOLTAGE,
 607                 .owner = THIS_MODULE,
 608                 .vsel_reg = LP872X_LDO5_VOUT,
 609                 .vsel_mask = LP872X_VOUT_M,
 610                 .enable_reg = LP8725_LDO_CTRL,
 611                 .enable_mask = LP872X_EN_LDO5_M,
 612         },
 613         {
 614                 .name = "lilo1",
 615                 .of_match = of_match_ptr("lilo1"),
 616                 .id = LP8725_ID_LILO1,
 617                 .ops = &lp872x_ldo_ops,
 618                 .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
 619                 .volt_table = lp8725_lilo_vtbl,
 620                 .type = REGULATOR_VOLTAGE,
 621                 .owner = THIS_MODULE,
 622                 .vsel_reg = LP8725_LILO1_VOUT,
 623                 .vsel_mask = LP872X_VOUT_M,
 624                 .enable_reg = LP8725_LDO_CTRL,
 625                 .enable_mask = LP8725_EN_LILO1_M,
 626         },
 627         {
 628                 .name = "lilo2",
 629                 .of_match = of_match_ptr("lilo2"),
 630                 .id = LP8725_ID_LILO2,
 631                 .ops = &lp872x_ldo_ops,
 632                 .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
 633                 .volt_table = lp8725_lilo_vtbl,
 634                 .type = REGULATOR_VOLTAGE,
 635                 .owner = THIS_MODULE,
 636                 .vsel_reg = LP8725_LILO2_VOUT,
 637                 .vsel_mask = LP872X_VOUT_M,
 638                 .enable_reg = LP8725_LDO_CTRL,
 639                 .enable_mask = LP8725_EN_LILO2_M,
 640         },
 641         {
 642                 .name = "buck1",
 643                 .of_match = of_match_ptr("buck1"),
 644                 .id = LP8725_ID_BUCK1,
 645                 .ops = &lp8725_buck_ops,
 646                 .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
 647                 .volt_table = lp8725_buck_vtbl,
 648                 .type = REGULATOR_VOLTAGE,
 649                 .owner = THIS_MODULE,
 650                 .enable_reg = LP872X_GENERAL_CFG,
 651                 .enable_mask = LP8725_BUCK1_EN_M,
 652                 .curr_table = lp8725_buck_uA,
 653                 .n_current_limits = ARRAY_SIZE(lp8725_buck_uA),
 654                 .csel_reg = LP8725_BUCK1_VOUT2,
 655                 .csel_mask = LP8725_BUCK_CL_M,
 656         },
 657         {
 658                 .name = "buck2",
 659                 .of_match = of_match_ptr("buck2"),
 660                 .id = LP8725_ID_BUCK2,
 661                 .ops = &lp8725_buck_ops,
 662                 .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
 663                 .volt_table = lp8725_buck_vtbl,
 664                 .type = REGULATOR_VOLTAGE,
 665                 .owner = THIS_MODULE,
 666                 .enable_reg = LP872X_GENERAL_CFG,
 667                 .enable_mask = LP8725_BUCK2_EN_M,
 668                 .curr_table = lp8725_buck_uA,
 669                 .n_current_limits = ARRAY_SIZE(lp8725_buck_uA),
 670                 .csel_reg = LP8725_BUCK2_VOUT2,
 671                 .csel_mask = LP8725_BUCK_CL_M,
 672         },
 673 };
 674
 675 static int lp872x_init_dvs(struct lp872x *lp)
 676 {
 677         struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
 678         enum gpiod_flags pinstate;
 679         u8 mask[] = { LP8720_EXT_DVS_M, LP8725_DVS1_M | LP8725_DVS2_M };
 680         u8 default_dvs_mode[] = { LP8720_DEFAULT_DVS, LP8725_DEFAULT_DVS };
 681
 682         if (!dvs)
 683                 goto set_default_dvs_mode;
 684
 685         if (!dvs->gpio)
 686                 goto set_default_dvs_mode;
 687
 688         pinstate = dvs->init_state;
 689         dvs->gpio = devm_gpiod_get_optional(lp->dev, "ti,dvs", pinstate);
 690
 691         if (IS_ERR(dvs->gpio)) {
 692                 dev_err(lp->dev, "gpio request err: %ld\n", PTR_ERR(dvs->gpio));
 693                 return PTR_ERR(dvs->gpio);
 694         }
 695
 696         lp->dvs_pin = pinstate;
 697
 698         return 0;
 699
 700 set_default_dvs_mode:
 701         return lp872x_update_bits(lp, LP872X_GENERAL_CFG, mask[lp->chipid],
 702                                 default_dvs_mode[lp->chipid]);
 703 }
 704
 705 static int lp872x_hw_enable(struct lp872x *lp)
 706 {
 707         if (!lp->pdata)
 708                 return -EINVAL;
 709
 710         if (!lp->pdata->enable_gpio)
 711                 return 0;
 712
 713         /* Always set enable GPIO high. */
 714         lp->pdata->enable_gpio = devm_gpiod_get_optional(lp->dev, "enable", GPIOD_OUT_HIGH);
 715         if (IS_ERR(lp->pdata->enable_gpio)) {
 716                 dev_err(lp->dev, "gpio request err: %ld\n", PTR_ERR(lp->pdata->enable_gpio));
 717                 return PTR_ERR(lp->pdata->enable_gpio);
 718         }
 719
 720         /* Each chip has a different enable delay. */
 721         if (lp->chipid == LP8720)
 722                 usleep_range(LP8720_ENABLE_DELAY, 1.5 * LP8720_ENABLE_DELAY);
 723         else
 724                 usleep_range(LP8725_ENABLE_DELAY, 1.5 * LP8725_ENABLE_DELAY);
 725
 726         return 0;
 727 }
 728
 729 static int lp872x_config(struct lp872x *lp)
 730 {
 731         struct lp872x_platform_data *pdata = lp->pdata;
 732         int ret;
 733
 734         if (!pdata || !pdata->update_config)
 735                 goto init_dvs;
 736
 737         ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
 738         if (ret)
 739                 return ret;
 740
 741 init_dvs:
 742         return lp872x_init_dvs(lp);
 743 }
 744
 745 static struct regulator_init_data
 746 *lp872x_find_regulator_init_data(int id, struct lp872x *lp)
 747 {
 748         struct lp872x_platform_data *pdata = lp->pdata;
 749         int i;
 750
 751         if (!pdata)
 752                 return NULL;
 753
 754         for (i = 0; i < lp->num_regulators; i++) {
 755                 if (pdata->regulator_data[i].id == id)
 756                         return pdata->regulator_data[i].init_data;
 757         }
 758
 759         return NULL;
 760 }
 761
 762 static int lp872x_regulator_register(struct lp872x *lp)
 763 {
 764         const struct regulator_desc *desc;
 765         struct regulator_config cfg = { };
 766         struct regulator_dev *rdev;
 767         int i;
 768
 769         for (i = 0; i < lp->num_regulators; i++) {
 770                 desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
 771                                                 &lp8725_regulator_desc[i];
 772
 773                 cfg.dev = lp->dev;
 774                 cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
 775                 cfg.driver_data = lp;
 776                 cfg.regmap = lp->regmap;
 777
 778                 rdev = devm_regulator_register(lp->dev, desc, &cfg);
 779                 if (IS_ERR(rdev)) {
 780                         dev_err(lp->dev, "regulator register err");
 781                         return PTR_ERR(rdev);
 782                 }
 783         }
 784
 785         return 0;
 786 }
 787
 788 static const struct regmap_config lp872x_regmap_config = {
 789         .reg_bits = 8,
 790         .val_bits = 8,
 791         .max_register = MAX_REGISTERS,
 792 };
 793
 794 #ifdef CONFIG_OF
 795
 796 #define LP872X_VALID_OPMODE     (REGULATOR_MODE_FAST | REGULATOR_MODE_NORMAL)
 797
 798 static struct of_regulator_match lp8720_matches[] = {
 799         { .name = "ldo1", .driver_data = (void *)LP8720_ID_LDO1, },
 800         { .name = "ldo2", .driver_data = (void *)LP8720_ID_LDO2, },
 801         { .name = "ldo3", .driver_data = (void *)LP8720_ID_LDO3, },
 802         { .name = "ldo4", .driver_data = (void *)LP8720_ID_LDO4, },
 803         { .name = "ldo5", .driver_data = (void *)LP8720_ID_LDO5, },
 804         { .name = "buck", .driver_data = (void *)LP8720_ID_BUCK, },
 805 };
 806
 807 static struct of_regulator_match lp8725_matches[] = {
 808         { .name = "ldo1", .driver_data = (void *)LP8725_ID_LDO1, },
 809         { .name = "ldo2", .driver_data = (void *)LP8725_ID_LDO2, },
 810         { .name = "ldo3", .driver_data = (void *)LP8725_ID_LDO3, },
 811         { .name = "ldo4", .driver_data = (void *)LP8725_ID_LDO4, },
 812         { .name = "ldo5", .driver_data = (void *)LP8725_ID_LDO5, },
 813         { .name = "lilo1", .driver_data = (void *)LP8725_ID_LILO1, },
 814         { .name = "lilo2", .driver_data = (void *)LP8725_ID_LILO2, },
 815         { .name = "buck1", .driver_data = (void *)LP8725_ID_BUCK1, },
 816         { .name = "buck2", .driver_data = (void *)LP8725_ID_BUCK2, },
 817 };
 818
 819 static struct lp872x_platform_data
 820 *lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
 821 {
 822         struct device_node *np = dev->of_node;
 823         struct lp872x_platform_data *pdata;
 824         struct of_regulator_match *match;
 825         int num_matches;
 826         int count;
 827         int i;
 828         u8 dvs_state;
 829
 830         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 831         if (!pdata)
 832                 return ERR_PTR(-ENOMEM);
 833
 834         of_property_read_u8(np, "ti,general-config", &pdata->general_config);
 835         pdata->update_config = of_property_read_bool(np, "ti,update-config");
 836
 837         pdata->dvs = devm_kzalloc(dev, sizeof(struct lp872x_dvs), GFP_KERNEL);
 838         if (!pdata->dvs)
 839                 return ERR_PTR(-ENOMEM);
 840
 841         of_property_read_u8(np, "ti,dvs-vsel", (u8 *)&pdata->dvs->vsel);
 842         of_property_read_u8(np, "ti,dvs-state", &dvs_state);
 843         pdata->dvs->init_state = dvs_state ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
 844
 845         if (of_get_child_count(np) == 0)
 846                 goto out;
 847
 848         switch (which) {
 849         case LP8720:
 850                 match = lp8720_matches;
 851                 num_matches = ARRAY_SIZE(lp8720_matches);
 852                 break;
 853         case LP8725:
 854                 match = lp8725_matches;
 855                 num_matches = ARRAY_SIZE(lp8725_matches);
 856                 break;
 857         default:
 858                 goto out;
 859         }
 860
 861         count = of_regulator_match(dev, np, match, num_matches);
 862         if (count <= 0)
 863                 goto out;
 864
 865         for (i = 0; i < num_matches; i++) {
 866                 pdata->regulator_data[i].id =
 867                                 (uintptr_t)match[i].driver_data;
 868                 pdata->regulator_data[i].init_data = match[i].init_data;
 869         }
 870 out:
 871         return pdata;
 872 }
 873 #else
 874 static struct lp872x_platform_data
 875 *lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
 876 {
 877         return NULL;
 878 }
 879 #endif
 880
 881 static int lp872x_probe(struct i2c_client *cl)
 882 {
 883         const struct i2c_device_id *id = i2c_client_get_device_id(cl);
 884         struct lp872x *lp;
 885         struct lp872x_platform_data *pdata;
 886         int ret;
 887         static const int lp872x_num_regulators[] = {
 888                 [LP8720] = LP8720_NUM_REGULATORS,
 889                 [LP8725] = LP8725_NUM_REGULATORS,
 890         };
 891
 892         if (cl->dev.of_node) {
 893                 pdata = lp872x_populate_pdata_from_dt(&cl->dev,
 894                                               (enum lp872x_id)id->driver_data);
 895                 if (IS_ERR(pdata))
 896                         return PTR_ERR(pdata);
 897         } else {
 898                 pdata = dev_get_platdata(&cl->dev);
 899         }
 900
 901         lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
 902         if (!lp)
 903                 return -ENOMEM;
 904
 905         lp->num_regulators = lp872x_num_regulators[id->driver_data];
 906
 907         lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
 908         if (IS_ERR(lp->regmap)) {
 909                 ret = PTR_ERR(lp->regmap);
 910                 dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
 911                 return ret;
 912         }
 913
 914         lp->dev = &cl->dev;
 915         lp->pdata = pdata;
 916         lp->chipid = id->driver_data;
 917         i2c_set_clientdata(cl, lp);
 918
 919         ret = lp872x_hw_enable(lp);
 920         if (ret)
 921                 return ret;
 922
 923         ret = lp872x_config(lp);
 924         if (ret)
 925                 return ret;
 926
 927         return lp872x_regulator_register(lp);
 928 }
 929
 930 static const struct of_device_id lp872x_dt_ids[] __maybe_unused = {
 931         { .compatible = "ti,lp8720", },
 932         { .compatible = "ti,lp8725", },
 933         { }
 934 };
 935 MODULE_DEVICE_TABLE(of, lp872x_dt_ids);
 936
 937 static const struct i2c_device_id lp872x_ids[] = {
 938         {"lp8720", LP8720},
 939         {"lp8725", LP8725},
 940         { }
 941 };
 942 MODULE_DEVICE_TABLE(i2c, lp872x_ids);
 943
 944 static struct i2c_driver lp872x_driver = {
 945         .driver = {
 946                 .name = "lp872x",
 947                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 948                 .of_match_table = of_match_ptr(lp872x_dt_ids),
 949         },
 950         .probe = lp872x_probe,
 951         .id_table = lp872x_ids,
 952 };
 953
 954 module_i2c_driver(lp872x_driver);
 955
 956 MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
 957 MODULE_AUTHOR("Milo Kim");
 958 MODULE_LICENSE("GPL");