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