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