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