drivers/regulator/lp8755.c

   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, &regval);
  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, &regval);
 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, &regval);
 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, &regval);
 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_notifier_call_chain(pchip->rdev[icnt],
 333                                                       LP8755_EVENT_PWR_FAULT,
 334                                                       NULL);
 335                 }
 336
 337         /* read flag1 register */
 338         ret = regmap_read(pchip->regmap, 0x0E, &flag1);
 339         if (ret < 0)
 340                 goto err_i2c;
 341         /* clear flag register to pull up int. pin */
 342         ret = regmap_write(pchip->regmap, 0x0E, 0x00);
 343         if (ret < 0)
 344                 goto err_i2c;
 345
 346         /* send OCP event to all regulator devices */
 347         if ((flag1 & 0x01) && (pchip->irqmask & 0x01))
 348                 for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
 349                         if (pchip->rdev[icnt] != NULL) {
 350                                 regulator_notifier_call_chain(pchip->rdev[icnt],
 351                                                               LP8755_EVENT_OCP,
 352                                                               NULL);
 353                         }
 354
 355         /* send OVP event to all regulator devices */
 356         if ((flag1 & 0x02) && (pchip->irqmask & 0x02))
 357                 for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
 358                         if (pchip->rdev[icnt] != NULL) {
 359                                 regulator_notifier_call_chain(pchip->rdev[icnt],
 360                                                               LP8755_EVENT_OVP,
 361                                                               NULL);
 362                         }
 363         return IRQ_HANDLED;
 364
 365 err_i2c:
 366         dev_err(pchip->dev, "i2c access error %s\n", __func__);
 367         return IRQ_NONE;
 368 }
 369
 370 static int lp8755_int_config(struct lp8755_chip *pchip)
 371 {
 372         int ret;
 373         unsigned int regval;
 374
 375         if (pchip->irq == 0) {
 376                 dev_warn(pchip->dev, "not use interrupt : %s\n", __func__);
 377                 return 0;
 378         }
 379
 380         ret = regmap_read(pchip->regmap, 0x0F, &regval);
 381         if (ret < 0) {
 382                 dev_err(pchip->dev, "i2c access error %s\n", __func__);
 383                 return ret;
 384         }
 385
 386         pchip->irqmask = regval;
 387         return devm_request_threaded_irq(pchip->dev, pchip->irq, NULL,
 388                                          lp8755_irq_handler,
 389                                          IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 390                                          "lp8755-irq", pchip);
 391 }
 392
 393 static const struct regmap_config lp8755_regmap = {
 394         .reg_bits = 8,
 395         .val_bits = 8,
 396         .max_register = LP8755_REG_MAX,
 397 };
 398
 399 static int lp8755_probe(struct i2c_client *client,
 400                         const struct i2c_device_id *id)
 401 {
 402         int ret, icnt;
 403         struct lp8755_chip *pchip;
 404         struct lp8755_platform_data *pdata = dev_get_platdata(&client->dev);
 405
 406         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 407                 dev_err(&client->dev, "i2c functionality check fail.\n");
 408                 return -EOPNOTSUPP;
 409         }
 410
 411         pchip = devm_kzalloc(&client->dev,
 412                              sizeof(struct lp8755_chip), GFP_KERNEL);
 413         if (!pchip)
 414                 return -ENOMEM;
 415
 416         pchip->dev = &client->dev;
 417         pchip->regmap = devm_regmap_init_i2c(client, &lp8755_regmap);
 418         if (IS_ERR(pchip->regmap)) {
 419                 ret = PTR_ERR(pchip->regmap);
 420                 dev_err(&client->dev, "fail to allocate regmap %d\n", ret);
 421                 return ret;
 422         }
 423         i2c_set_clientdata(client, pchip);
 424
 425         if (pdata != NULL) {
 426                 pchip->pdata = pdata;
 427                 pchip->mphase = pdata->mphase;
 428         } else {
 429                 pchip->pdata = devm_kzalloc(pchip->dev,
 430                                             sizeof(struct lp8755_platform_data),
 431                                             GFP_KERNEL);
 432                 if (!pchip->pdata)
 433                         return -ENOMEM;
 434                 ret = lp8755_init_data(pchip);
 435                 if (ret < 0) {
 436                         dev_err(&client->dev, "fail to initialize chip\n");
 437                         return ret;
 438                 }
 439         }
 440
 441         ret = lp8755_regulator_init(pchip);
 442         if (ret < 0) {
 443                 dev_err(&client->dev, "fail to initialize regulators\n");
 444                 goto err;
 445         }
 446
 447         pchip->irq = client->irq;
 448         ret = lp8755_int_config(pchip);
 449         if (ret < 0) {
 450                 dev_err(&client->dev, "fail to irq config\n");
 451                 goto err;
 452         }
 453
 454         return ret;
 455
 456 err:
 457         /* output disable */
 458         for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
 459                 regmap_write(pchip->regmap, icnt, 0x00);
 460
 461         return ret;
 462 }
 463
 464 static int lp8755_remove(struct i2c_client *client)
 465 {
 466         int icnt;
 467         struct lp8755_chip *pchip = i2c_get_clientdata(client);
 468
 469         for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
 470                 regmap_write(pchip->regmap, icnt, 0x00);
 471
 472         return 0;
 473 }
 474
 475 static const struct i2c_device_id lp8755_id[] = {
 476         {LP8755_NAME, 0},
 477         {}
 478 };
 479
 480 MODULE_DEVICE_TABLE(i2c, lp8755_id);
 481
 482 static struct i2c_driver lp8755_i2c_driver = {
 483         .driver = {
 484                    .name = LP8755_NAME,
 485                    },
 486         .probe = lp8755_probe,
 487         .remove = lp8755_remove,
 488         .id_table = lp8755_id,
 489 };
 490
 491 static int __init lp8755_init(void)
 492 {
 493         return i2c_add_driver(&lp8755_i2c_driver);
 494 }
 495
 496 subsys_initcall(lp8755_init);
 497
 498 static void __exit lp8755_exit(void)
 499 {
 500         i2c_del_driver(&lp8755_i2c_driver);
 501 }
 502
 503 module_exit(lp8755_exit);
 504
 505 MODULE_DESCRIPTION("Texas Instruments lp8755 driver");
 506 MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
 507 MODULE_LICENSE("GPL v2");