1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * LP8755 High Performance Power Management Unit : System Interface Driver 4 * (based on rev. 0.26) 5 * Copyright 2012 Texas Instruments 6 * 7 * Author: Daniel(Geon Si) Jeong <daniel.jeong@ti.com> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/slab.h> 12 #include <linux/i2c.h> 13 #include <linux/err.h> 14 #include <linux/irq.h> 15 #include <linux/interrupt.h> 16 #include <linux/gpio.h> 17 #include <linux/regmap.h> 18 #include <linux/uaccess.h> 19 #include <linux/regulator/driver.h> 20 #include <linux/regulator/machine.h> 21 #include <linux/platform_data/lp8755.h> 22 23 #define LP8755_REG_BUCK0 0x00 24 #define LP8755_REG_BUCK1 0x03 25 #define LP8755_REG_BUCK2 0x04 26 #define LP8755_REG_BUCK3 0x01 27 #define LP8755_REG_BUCK4 0x05 28 #define LP8755_REG_BUCK5 0x02 29 #define LP8755_REG_MAX 0xFF 30 31 #define LP8755_BUCK_EN_M BIT(7) 32 #define LP8755_BUCK_LINEAR_OUT_MAX 0x76 33 #define LP8755_BUCK_VOUT_M 0x7F 34 35 struct lp8755_mphase { 36 int nreg; 37 int buck_num[LP8755_BUCK_MAX]; 38 }; 39 40 struct lp8755_chip { 41 struct device *dev; 42 struct regmap *regmap; 43 struct lp8755_platform_data *pdata; 44 45 int irq; 46 unsigned int irqmask; 47 48 int mphase; 49 struct regulator_dev *rdev[LP8755_BUCK_MAX]; 50 }; 51 52 /** 53 *lp8755_read : read a single register value from lp8755. 54 *@pchip : device to read from 55 *@reg : register to read from 56 *@val : pointer to store read value 57 */ 58 static int lp8755_read(struct lp8755_chip *pchip, unsigned int reg, 59 unsigned int *val) 60 { 61 return regmap_read(pchip->regmap, reg, val); 62 } 63 64 /** 65 *lp8755_write : write a single register value to lp8755. 66 *@pchip : device to write to 67 *@reg : register to write to 68 *@val : value to be written 69 */ 70 static int lp8755_write(struct lp8755_chip *pchip, unsigned int reg, 71 unsigned int val) 72 { 73 return regmap_write(pchip->regmap, reg, val); 74 } 75 76 /** 77 *lp8755_update_bits : set the values of bit fields in lp8755 register. 78 *@pchip : device to read from 79 *@reg : register to update 80 *@mask : bitmask to be changed 81 *@val : value for bitmask 82 */ 83 static int lp8755_update_bits(struct lp8755_chip *pchip, unsigned int reg, 84 unsigned int mask, unsigned int val) 85 { 86 return regmap_update_bits(pchip->regmap, reg, mask, val); 87 } 88 89 static int lp8755_buck_enable_time(struct regulator_dev *rdev) 90 { 91 int ret; 92 unsigned int regval; 93 enum lp8755_bucks id = rdev_get_id(rdev); 94 struct lp8755_chip *pchip = rdev_get_drvdata(rdev); 95 96 ret = lp8755_read(pchip, 0x12 + id, ®val); 97 if (ret < 0) { 98 dev_err(pchip->dev, "i2c access error %s\n", __func__); 99 return ret; 100 } 101 return (regval & 0xff) * 100; 102 } 103 104 static int lp8755_buck_set_mode(struct regulator_dev *rdev, unsigned int mode) 105 { 106 int ret; 107 unsigned int regbval = 0x0; 108 enum lp8755_bucks id = rdev_get_id(rdev); 109 struct lp8755_chip *pchip = rdev_get_drvdata(rdev); 110 111 switch (mode) { 112 case REGULATOR_MODE_FAST: 113 /* forced pwm mode */ 114 regbval = (0x01 << id); 115 break; 116 case REGULATOR_MODE_NORMAL: 117 /* enable automatic pwm/pfm mode */ 118 ret = lp8755_update_bits(pchip, 0x08 + id, 0x20, 0x00); 119 if (ret < 0) 120 goto err_i2c; 121 break; 122 case REGULATOR_MODE_IDLE: 123 /* enable automatic pwm/pfm/lppfm mode */ 124 ret = lp8755_update_bits(pchip, 0x08 + id, 0x20, 0x20); 125 if (ret < 0) 126 goto err_i2c; 127 128 ret = lp8755_update_bits(pchip, 0x10, 0x01, 0x01); 129 if (ret < 0) 130 goto err_i2c; 131 break; 132 default: 133 dev_err(pchip->dev, "Not supported buck mode %s\n", __func__); 134 /* forced pwm mode */ 135 regbval = (0x01 << id); 136 } 137 138 ret = lp8755_update_bits(pchip, 0x06, 0x01 << id, regbval); 139 if (ret < 0) 140 goto err_i2c; 141 return ret; 142 err_i2c: 143 dev_err(pchip->dev, "i2c access error %s\n", __func__); 144 return ret; 145 } 146 147 static unsigned int lp8755_buck_get_mode(struct regulator_dev *rdev) 148 { 149 int ret; 150 unsigned int regval; 151 enum lp8755_bucks id = rdev_get_id(rdev); 152 struct lp8755_chip *pchip = rdev_get_drvdata(rdev); 153 154 ret = lp8755_read(pchip, 0x06, ®val); 155 if (ret < 0) 156 goto err_i2c; 157 158 /* mode fast means forced pwm mode */ 159 if (regval & (0x01 << id)) 160 return REGULATOR_MODE_FAST; 161 162 ret = lp8755_read(pchip, 0x08 + id, ®val); 163 if (ret < 0) 164 goto err_i2c; 165 166 /* mode idle means automatic pwm/pfm/lppfm mode */ 167 if (regval & 0x20) 168 return REGULATOR_MODE_IDLE; 169 170 /* mode normal means automatic pwm/pfm mode */ 171 return REGULATOR_MODE_NORMAL; 172 173 err_i2c: 174 dev_err(pchip->dev, "i2c access error %s\n", __func__); 175 return 0; 176 } 177 178 static int lp8755_buck_set_ramp(struct regulator_dev *rdev, int ramp) 179 { 180 int ret; 181 unsigned int regval = 0x00; 182 enum lp8755_bucks id = rdev_get_id(rdev); 183 struct lp8755_chip *pchip = rdev_get_drvdata(rdev); 184 185 /* uV/us */ 186 switch (ramp) { 187 case 0 ... 230: 188 regval = 0x07; 189 break; 190 case 231 ... 470: 191 regval = 0x06; 192 break; 193 case 471 ... 940: 194 regval = 0x05; 195 break; 196 case 941 ... 1900: 197 regval = 0x04; 198 break; 199 case 1901 ... 3800: 200 regval = 0x03; 201 break; 202 case 3801 ... 7500: 203 regval = 0x02; 204 break; 205 case 7501 ... 15000: 206 regval = 0x01; 207 break; 208 case 15001 ... 30000: 209 regval = 0x00; 210 break; 211 default: 212 dev_err(pchip->dev, 213 "Not supported ramp value %d %s\n", ramp, __func__); 214 return -EINVAL; 215 } 216 217 ret = lp8755_update_bits(pchip, 0x07 + id, 0x07, regval); 218 if (ret < 0) 219 goto err_i2c; 220 return ret; 221 err_i2c: 222 dev_err(pchip->dev, "i2c access error %s\n", __func__); 223 return ret; 224 } 225 226 static const struct regulator_ops lp8755_buck_ops = { 227 .map_voltage = regulator_map_voltage_linear, 228 .list_voltage = regulator_list_voltage_linear, 229 .set_voltage_sel = regulator_set_voltage_sel_regmap, 230 .get_voltage_sel = regulator_get_voltage_sel_regmap, 231 .enable = regulator_enable_regmap, 232 .disable = regulator_disable_regmap, 233 .is_enabled = regulator_is_enabled_regmap, 234 .enable_time = lp8755_buck_enable_time, 235 .set_mode = lp8755_buck_set_mode, 236 .get_mode = lp8755_buck_get_mode, 237 .set_ramp_delay = lp8755_buck_set_ramp, 238 }; 239 240 #define lp8755_rail(_id) "lp8755_buck"#_id 241 #define lp8755_buck_init(_id)\ 242 {\ 243 .constraints = {\ 244 .name = lp8755_rail(_id),\ 245 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,\ 246 .min_uV = 500000,\ 247 .max_uV = 1675000,\ 248 },\ 249 } 250 251 static struct regulator_init_data lp8755_reg_default[LP8755_BUCK_MAX] = { 252 [LP8755_BUCK0] = lp8755_buck_init(0), 253 [LP8755_BUCK1] = lp8755_buck_init(1), 254 [LP8755_BUCK2] = lp8755_buck_init(2), 255 [LP8755_BUCK3] = lp8755_buck_init(3), 256 [LP8755_BUCK4] = lp8755_buck_init(4), 257 [LP8755_BUCK5] = lp8755_buck_init(5), 258 }; 259 260 static const struct lp8755_mphase mphase_buck[MPHASE_CONF_MAX] = { 261 { 3, { LP8755_BUCK0, LP8755_BUCK3, LP8755_BUCK5 } }, 262 { 6, { LP8755_BUCK0, LP8755_BUCK1, LP8755_BUCK2, LP8755_BUCK3, 263 LP8755_BUCK4, LP8755_BUCK5 } }, 264 { 5, { LP8755_BUCK0, LP8755_BUCK2, LP8755_BUCK3, LP8755_BUCK4, 265 LP8755_BUCK5} }, 266 { 4, { LP8755_BUCK0, LP8755_BUCK3, LP8755_BUCK4, LP8755_BUCK5} }, 267 { 3, { LP8755_BUCK0, LP8755_BUCK4, LP8755_BUCK5} }, 268 { 2, { LP8755_BUCK0, LP8755_BUCK5} }, 269 { 1, { LP8755_BUCK0} }, 270 { 2, { LP8755_BUCK0, LP8755_BUCK3} }, 271 { 4, { LP8755_BUCK0, LP8755_BUCK2, LP8755_BUCK3, LP8755_BUCK5} }, 272 }; 273 274 static int lp8755_init_data(struct lp8755_chip *pchip) 275 { 276 unsigned int regval; 277 int ret, icnt, buck_num; 278 struct lp8755_platform_data *pdata = pchip->pdata; 279 280 /* read back muti-phase configuration */ 281 ret = lp8755_read(pchip, 0x3D, ®val); 282 if (ret < 0) 283 goto out_i2c_error; 284 pchip->mphase = regval & 0x0F; 285 286 /* set default data based on multi-phase config */ 287 for (icnt = 0; icnt < mphase_buck[pchip->mphase].nreg; icnt++) { 288 buck_num = mphase_buck[pchip->mphase].buck_num[icnt]; 289 pdata->buck_data[buck_num] = &lp8755_reg_default[buck_num]; 290 } 291 return ret; 292 293 out_i2c_error: 294 dev_err(pchip->dev, "i2c access error %s\n", __func__); 295 return ret; 296 } 297 298 #define lp8755_buck_desc(_id)\ 299 {\ 300 .name = lp8755_rail(_id),\ 301 .id = LP8755_BUCK##_id,\ 302 .ops = &lp8755_buck_ops,\ 303 .n_voltages = LP8755_BUCK_LINEAR_OUT_MAX+1,\ 304 .uV_step = 10000,\ 305 .min_uV = 500000,\ 306 .type = REGULATOR_VOLTAGE,\ 307 .owner = THIS_MODULE,\ 308 .enable_reg = LP8755_REG_BUCK##_id,\ 309 .enable_mask = LP8755_BUCK_EN_M,\ 310 .vsel_reg = LP8755_REG_BUCK##_id,\ 311 .vsel_mask = LP8755_BUCK_VOUT_M,\ 312 } 313 314 static const struct regulator_desc lp8755_regulators[] = { 315 lp8755_buck_desc(0), 316 lp8755_buck_desc(1), 317 lp8755_buck_desc(2), 318 lp8755_buck_desc(3), 319 lp8755_buck_desc(4), 320 lp8755_buck_desc(5), 321 }; 322 323 static int lp8755_regulator_init(struct lp8755_chip *pchip) 324 { 325 int ret, icnt, buck_num; 326 struct lp8755_platform_data *pdata = pchip->pdata; 327 struct regulator_config rconfig = { }; 328 329 rconfig.regmap = pchip->regmap; 330 rconfig.dev = pchip->dev; 331 rconfig.driver_data = pchip; 332 333 for (icnt = 0; icnt < mphase_buck[pchip->mphase].nreg; icnt++) { 334 buck_num = mphase_buck[pchip->mphase].buck_num[icnt]; 335 rconfig.init_data = pdata->buck_data[buck_num]; 336 rconfig.of_node = pchip->dev->of_node; 337 pchip->rdev[buck_num] = 338 devm_regulator_register(pchip->dev, 339 &lp8755_regulators[buck_num], &rconfig); 340 if (IS_ERR(pchip->rdev[buck_num])) { 341 ret = PTR_ERR(pchip->rdev[buck_num]); 342 pchip->rdev[buck_num] = NULL; 343 dev_err(pchip->dev, "regulator init failed: buck %d\n", 344 buck_num); 345 return ret; 346 } 347 } 348 349 return 0; 350 } 351 352 static irqreturn_t lp8755_irq_handler(int irq, void *data) 353 { 354 int ret, icnt; 355 unsigned int flag0, flag1; 356 struct lp8755_chip *pchip = data; 357 358 /* read flag0 register */ 359 ret = lp8755_read(pchip, 0x0D, &flag0); 360 if (ret < 0) 361 goto err_i2c; 362 /* clear flag register to pull up int. pin */ 363 ret = lp8755_write(pchip, 0x0D, 0x00); 364 if (ret < 0) 365 goto err_i2c; 366 367 /* sent power fault detection event to specific regulator */ 368 for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) 369 if ((flag0 & (0x4 << icnt)) 370 && (pchip->irqmask & (0x04 << icnt)) 371 && (pchip->rdev[icnt] != NULL)) { 372 regulator_lock(pchip->rdev[icnt]); 373 regulator_notifier_call_chain(pchip->rdev[icnt], 374 LP8755_EVENT_PWR_FAULT, 375 NULL); 376 regulator_unlock(pchip->rdev[icnt]); 377 } 378 379 /* read flag1 register */ 380 ret = lp8755_read(pchip, 0x0E, &flag1); 381 if (ret < 0) 382 goto err_i2c; 383 /* clear flag register to pull up int. pin */ 384 ret = lp8755_write(pchip, 0x0E, 0x00); 385 if (ret < 0) 386 goto err_i2c; 387 388 /* send OCP event to all regulator devices */ 389 if ((flag1 & 0x01) && (pchip->irqmask & 0x01)) 390 for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) 391 if (pchip->rdev[icnt] != NULL) { 392 regulator_lock(pchip->rdev[icnt]); 393 regulator_notifier_call_chain(pchip->rdev[icnt], 394 LP8755_EVENT_OCP, 395 NULL); 396 regulator_unlock(pchip->rdev[icnt]); 397 } 398 399 /* send OVP event to all regulator devices */ 400 if ((flag1 & 0x02) && (pchip->irqmask & 0x02)) 401 for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) 402 if (pchip->rdev[icnt] != NULL) { 403 regulator_lock(pchip->rdev[icnt]); 404 regulator_notifier_call_chain(pchip->rdev[icnt], 405 LP8755_EVENT_OVP, 406 NULL); 407 regulator_unlock(pchip->rdev[icnt]); 408 } 409 return IRQ_HANDLED; 410 411 err_i2c: 412 dev_err(pchip->dev, "i2c access error %s\n", __func__); 413 return IRQ_NONE; 414 } 415 416 static int lp8755_int_config(struct lp8755_chip *pchip) 417 { 418 int ret; 419 unsigned int regval; 420 421 if (pchip->irq == 0) { 422 dev_warn(pchip->dev, "not use interrupt : %s\n", __func__); 423 return 0; 424 } 425 426 ret = lp8755_read(pchip, 0x0F, ®val); 427 if (ret < 0) { 428 dev_err(pchip->dev, "i2c access error %s\n", __func__); 429 return ret; 430 } 431 432 pchip->irqmask = regval; 433 return devm_request_threaded_irq(pchip->dev, pchip->irq, NULL, 434 lp8755_irq_handler, 435 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 436 "lp8755-irq", pchip); 437 } 438 439 static const struct regmap_config lp8755_regmap = { 440 .reg_bits = 8, 441 .val_bits = 8, 442 .max_register = LP8755_REG_MAX, 443 }; 444 445 static int lp8755_probe(struct i2c_client *client, 446 const struct i2c_device_id *id) 447 { 448 int ret, icnt; 449 struct lp8755_chip *pchip; 450 struct lp8755_platform_data *pdata = dev_get_platdata(&client->dev); 451 452 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 453 dev_err(&client->dev, "i2c functionality check fail.\n"); 454 return -EOPNOTSUPP; 455 } 456 457 pchip = devm_kzalloc(&client->dev, 458 sizeof(struct lp8755_chip), GFP_KERNEL); 459 if (!pchip) 460 return -ENOMEM; 461 462 pchip->dev = &client->dev; 463 pchip->regmap = devm_regmap_init_i2c(client, &lp8755_regmap); 464 if (IS_ERR(pchip->regmap)) { 465 ret = PTR_ERR(pchip->regmap); 466 dev_err(&client->dev, "fail to allocate regmap %d\n", ret); 467 return ret; 468 } 469 i2c_set_clientdata(client, pchip); 470 471 if (pdata != NULL) { 472 pchip->pdata = pdata; 473 pchip->mphase = pdata->mphase; 474 } else { 475 pchip->pdata = devm_kzalloc(pchip->dev, 476 sizeof(struct lp8755_platform_data), 477 GFP_KERNEL); 478 if (!pchip->pdata) 479 return -ENOMEM; 480 ret = lp8755_init_data(pchip); 481 if (ret < 0) { 482 dev_err(&client->dev, "fail to initialize chip\n"); 483 return ret; 484 } 485 } 486 487 ret = lp8755_regulator_init(pchip); 488 if (ret < 0) { 489 dev_err(&client->dev, "fail to initialize regulators\n"); 490 goto err; 491 } 492 493 pchip->irq = client->irq; 494 ret = lp8755_int_config(pchip); 495 if (ret < 0) { 496 dev_err(&client->dev, "fail to irq config\n"); 497 goto err; 498 } 499 500 return ret; 501 502 err: 503 /* output disable */ 504 for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) 505 lp8755_write(pchip, icnt, 0x00); 506 507 return ret; 508 } 509 510 static int lp8755_remove(struct i2c_client *client) 511 { 512 int icnt; 513 struct lp8755_chip *pchip = i2c_get_clientdata(client); 514 515 for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) 516 lp8755_write(pchip, icnt, 0x00); 517 518 return 0; 519 } 520 521 static const struct i2c_device_id lp8755_id[] = { 522 {LP8755_NAME, 0}, 523 {} 524 }; 525 526 MODULE_DEVICE_TABLE(i2c, lp8755_id); 527 528 static struct i2c_driver lp8755_i2c_driver = { 529 .driver = { 530 .name = LP8755_NAME, 531 }, 532 .probe = lp8755_probe, 533 .remove = lp8755_remove, 534 .id_table = lp8755_id, 535 }; 536 537 static int __init lp8755_init(void) 538 { 539 return i2c_add_driver(&lp8755_i2c_driver); 540 } 541 542 subsys_initcall(lp8755_init); 543 544 static void __exit lp8755_exit(void) 545 { 546 i2c_del_driver(&lp8755_i2c_driver); 547 } 548 549 module_exit(lp8755_exit); 550 551 MODULE_DESCRIPTION("Texas Instruments lp8755 driver"); 552 MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>"); 553 MODULE_LICENSE("GPL v2"); 554