drivers/regulator/lp872x.c

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