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