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