drivers/power/regulator/tps65941_regulator.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2019
   4  * Texas Instruments Incorporated, <www.ti.com>
   5  *
   6  * Keerthy <j-keerthy@ti.com>
   7  */
   8
   9 #include <common.h>
  10 #include <fdtdec.h>
  11 #include <errno.h>
  12 #include <dm.h>
  13 #include <i2c.h>
  14 #include <log.h>
  15 #include <linux/delay.h>
  16 #include <power/pmic.h>
  17 #include <power/regulator.h>
  18 #include <power/tps65941.h>
  19
  20 static const char tps65941_buck_ctrl[TPS65941_BUCK_NUM] = {0x4, 0x6, 0x8, 0xA,
  21                                                                 0xC};
  22 static const char tps65941_buck_vout[TPS65941_BUCK_NUM] = {0xE, 0x10, 0x12,
  23                                                                 0x14, 0x16};
  24 static const char tps65941_ldo_ctrl[TPS65941_BUCK_NUM] = {0x1D, 0x1E, 0x1F,
  25                                                                 0x20};
  26 static const char tps65941_ldo_vout[TPS65941_BUCK_NUM] = {0x23, 0x24, 0x25,
  27                                                                 0x26};
  28
  29 static int tps65941_buck_enable(struct udevice *dev, int op, bool *enable)
  30 {
  31         int ret;
  32         unsigned int adr;
  33         struct dm_regulator_uclass_plat *uc_pdata;
  34
  35         uc_pdata = dev_get_uclass_plat(dev);
  36         adr = uc_pdata->ctrl_reg;
  37
  38         ret = pmic_reg_read(dev->parent, adr);
  39         if (ret < 0)
  40                 return ret;
  41
  42         if (op == PMIC_OP_GET) {
  43                 ret &= TPS65941_BUCK_MODE_MASK;
  44
  45                 if (ret)
  46                         *enable = true;
  47                 else
  48                         *enable = false;
  49
  50                 return 0;
  51         } else if (op == PMIC_OP_SET) {
  52                 if (*enable)
  53                         ret |= TPS65941_BUCK_MODE_MASK;
  54                 else
  55                         ret &= ~TPS65941_BUCK_MODE_MASK;
  56                 ret = pmic_reg_write(dev->parent, adr, ret);
  57                 if (ret)
  58                         return ret;
  59         }
  60
  61         return 0;
  62 }
  63
  64 static int tps65941_buck_volt2val(int uV)
  65 {
  66         if (uV > TPS65941_BUCK_VOLT_MAX)
  67                 return -EINVAL;
  68         else if (uV > 1650000)
  69                 return (uV - 1660000) / 20000 + 0xAB;
  70         else if (uV > 1110000)
  71                 return (uV - 1110000) / 10000 + 0x73;
  72         else if (uV > 600000)
  73                 return (uV - 600000) / 5000 + 0x0F;
  74         else if (uV >= 300000)
  75                 return (uV - 300000) / 20000 + 0x00;
  76         else
  77                 return -EINVAL;
  78 }
  79
  80 static int tps65941_buck_val2volt(int val)
  81 {
  82         if (val > TPS65941_BUCK_VOLT_MAX_HEX)
  83                 return -EINVAL;
  84         else if (val > 0xAB)
  85                 return 1660000 + (val - 0xAB) * 20000;
  86         else if (val > 0x73)
  87                 return 1100000 + (val - 0x73) * 10000;
  88         else if (val > 0xF)
  89                 return 600000 + (val - 0xF) * 5000;
  90         else if (val >= 0x0)
  91                 return 300000 + val * 5000;
  92         else
  93                 return -EINVAL;
  94 }
  95
  96 int tps65941_lookup_slew(int id)
  97 {
  98         switch (id) {
  99         case 0:
 100                 return 33000;
 101         case 1:
 102                 return 20000;
 103         case 2:
 104                 return 10000;
 105         case 3:
 106                 return 5000;
 107         case 4:
 108                 return 2500;
 109         case 5:
 110                 return 1300;
 111         case 6:
 112                 return 630;
 113         case 7:
 114                 return 310;
 115         default:
 116                 return -1;
 117         }
 118 }
 119
 120 static int tps65941_buck_val(struct udevice *dev, int op, int *uV)
 121 {
 122         unsigned int hex, adr;
 123         int ret, delta, uwait, slew;
 124         struct dm_regulator_uclass_plat *uc_pdata;
 125
 126         uc_pdata = dev_get_uclass_plat(dev);
 127
 128         if (op == PMIC_OP_GET)
 129                 *uV = 0;
 130
 131         adr = uc_pdata->volt_reg;
 132
 133         ret = pmic_reg_read(dev->parent, adr);
 134         if (ret < 0)
 135                 return ret;
 136
 137         ret &= TPS65941_BUCK_VOLT_MASK;
 138         ret = tps65941_buck_val2volt(ret);
 139         if (ret < 0)
 140                 return ret;
 141
 142         if (op == PMIC_OP_GET) {
 143                 *uV = ret;
 144                 return 0;
 145         }
 146
 147         /*
 148          * Compute the delta voltage, find the slew rate and wait
 149          * for the appropriate amount of time after voltage switch
 150          */
 151         if (*uV > ret)
 152                 delta = *uV - ret;
 153         else
 154                 delta = ret - *uV;
 155
 156         slew = pmic_reg_read(dev->parent, uc_pdata->ctrl_reg + 1);
 157         if (slew < 0)
 158                 return ret;
 159
 160         slew &= TP65941_BUCK_CONF_SLEW_MASK;
 161         slew = tps65941_lookup_slew(slew);
 162         if (slew <= 0)
 163                 return ret;
 164
 165         uwait = delta / slew;
 166
 167         hex = tps65941_buck_volt2val(*uV);
 168         if (hex < 0)
 169                 return hex;
 170
 171         ret &= 0x0;
 172         ret = hex;
 173
 174         ret = pmic_reg_write(dev->parent, adr, ret);
 175
 176         udelay(uwait);
 177
 178         return ret;
 179 }
 180
 181 static int tps65941_ldo_enable(struct udevice *dev, int op, bool *enable)
 182 {
 183         int ret;
 184         unsigned int adr;
 185         struct dm_regulator_uclass_plat *uc_pdata;
 186
 187         uc_pdata = dev_get_uclass_plat(dev);
 188         adr = uc_pdata->ctrl_reg;
 189
 190         ret = pmic_reg_read(dev->parent, adr);
 191         if (ret < 0)
 192                 return ret;
 193
 194         if (op == PMIC_OP_GET) {
 195                 ret &= TPS65941_LDO_MODE_MASK;
 196
 197                 if (ret)
 198                         *enable = true;
 199                 else
 200                         *enable = false;
 201
 202                 return 0;
 203         } else if (op == PMIC_OP_SET) {
 204                 if (*enable)
 205                         ret |= TPS65941_LDO_MODE_MASK;
 206                 else
 207                         ret &= ~TPS65941_LDO_MODE_MASK;
 208                 ret = pmic_reg_write(dev->parent, adr, ret);
 209                 if (ret)
 210                         return ret;
 211         }
 212
 213         return 0;
 214 }
 215
 216 static int tps65941_ldo_val2volt(int val)
 217 {
 218         if (val > TPS65941_LDO_VOLT_MAX_HEX || val < TPS65941_LDO_VOLT_MIN_HEX)
 219                 return -EINVAL;
 220         else if (val >= TPS65941_LDO_VOLT_MIN_HEX)
 221                 return 600000 + (val - TPS65941_LDO_VOLT_MIN_HEX) * 50000;
 222         else
 223                 return -EINVAL;
 224 }
 225
 226 static int tps65941_ldo_val(struct udevice *dev, int op, int *uV)
 227 {
 228         unsigned int hex, adr;
 229         int ret;
 230         struct dm_regulator_uclass_plat *uc_pdata;
 231
 232         uc_pdata = dev_get_uclass_plat(dev);
 233
 234         if (op == PMIC_OP_GET)
 235                 *uV = 0;
 236
 237         adr = uc_pdata->volt_reg;
 238
 239         ret = pmic_reg_read(dev->parent, adr);
 240         if (ret < 0)
 241                 return ret;
 242
 243         ret &= TPS65941_LDO_VOLT_MASK;
 244         ret = tps65941_ldo_val2volt(ret);
 245         if (ret < 0)
 246                 return ret;
 247
 248         if (op == PMIC_OP_GET) {
 249                 *uV = ret;
 250                 return 0;
 251         }
 252
 253         hex = tps65941_buck_volt2val(*uV);
 254         if (hex < 0)
 255                 return hex;
 256
 257         ret &= 0x0;
 258         ret = hex;
 259
 260         ret = pmic_reg_write(dev->parent, adr, ret);
 261
 262         return ret;
 263 }
 264
 265 static int tps65941_ldo_probe(struct udevice *dev)
 266 {
 267         struct dm_regulator_uclass_plat *uc_pdata;
 268         int idx;
 269
 270         uc_pdata = dev_get_uclass_plat(dev);
 271         uc_pdata->type = REGULATOR_TYPE_LDO;
 272
 273         idx = dev->driver_data;
 274         if (idx == 1 || idx == 2 || idx == 3 || idx == 4) {
 275                 debug("Single phase regulator\n");
 276         } else {
 277                 printf("Wrong ID for regulator\n");
 278                 return -EINVAL;
 279         }
 280
 281         uc_pdata->ctrl_reg = tps65941_ldo_ctrl[idx - 1];
 282         uc_pdata->volt_reg = tps65941_ldo_vout[idx - 1];
 283
 284         return 0;
 285 }
 286
 287 static int tps65941_buck_probe(struct udevice *dev)
 288 {
 289         struct dm_regulator_uclass_plat *uc_pdata;
 290         int idx;
 291
 292         uc_pdata = dev_get_uclass_plat(dev);
 293         uc_pdata->type = REGULATOR_TYPE_BUCK;
 294
 295         idx = dev->driver_data;
 296         if (idx == 1 || idx == 2 || idx == 3 || idx == 4 || idx == 5) {
 297                 debug("Single phase regulator\n");
 298         } else if (idx == 12) {
 299                 idx = 1;
 300         } else if (idx == 34) {
 301                 idx = 3;
 302         } else if (idx == 123) {
 303                 idx = 1;
 304         } else if (idx == 1234) {
 305                 idx = 1;
 306         } else {
 307                 printf("Wrong ID for regulator\n");
 308                 return -EINVAL;
 309         }
 310
 311         uc_pdata->ctrl_reg = tps65941_buck_ctrl[idx - 1];
 312         uc_pdata->volt_reg = tps65941_buck_vout[idx - 1];
 313
 314         return 0;
 315 }
 316
 317 static int ldo_get_value(struct udevice *dev)
 318 {
 319         int uV;
 320         int ret;
 321
 322         ret = tps65941_ldo_val(dev, PMIC_OP_GET, &uV);
 323         if (ret)
 324                 return ret;
 325
 326         return uV;
 327 }
 328
 329 static int ldo_set_value(struct udevice *dev, int uV)
 330 {
 331         return tps65941_ldo_val(dev, PMIC_OP_SET, &uV);
 332 }
 333
 334 static int ldo_get_enable(struct udevice *dev)
 335 {
 336         bool enable = false;
 337         int ret;
 338
 339         ret = tps65941_ldo_enable(dev, PMIC_OP_GET, &enable);
 340         if (ret)
 341                 return ret;
 342
 343         return enable;
 344 }
 345
 346 static int ldo_set_enable(struct udevice *dev, bool enable)
 347 {
 348         return tps65941_ldo_enable(dev, PMIC_OP_SET, &enable);
 349 }
 350
 351 static int buck_get_value(struct udevice *dev)
 352 {
 353         int uV;
 354         int ret;
 355
 356         ret = tps65941_buck_val(dev, PMIC_OP_GET, &uV);
 357         if (ret)
 358                 return ret;
 359
 360         return uV;
 361 }
 362
 363 static int buck_set_value(struct udevice *dev, int uV)
 364 {
 365         return tps65941_buck_val(dev, PMIC_OP_SET, &uV);
 366 }
 367
 368 static int buck_get_enable(struct udevice *dev)
 369 {
 370         bool enable = false;
 371         int ret;
 372
 373         ret = tps65941_buck_enable(dev, PMIC_OP_GET, &enable);
 374         if (ret)
 375                 return ret;
 376
 377         return enable;
 378 }
 379
 380 static int buck_set_enable(struct udevice *dev, bool enable)
 381 {
 382         return tps65941_buck_enable(dev, PMIC_OP_SET, &enable);
 383 }
 384
 385 static const struct dm_regulator_ops tps65941_ldo_ops = {
 386         .get_value  = ldo_get_value,
 387         .set_value  = ldo_set_value,
 388         .get_enable = ldo_get_enable,
 389         .set_enable = ldo_set_enable,
 390 };
 391
 392 U_BOOT_DRIVER(tps65941_ldo) = {
 393         .name = TPS65941_LDO_DRIVER,
 394         .id = UCLASS_REGULATOR,
 395         .ops = &tps65941_ldo_ops,
 396         .probe = tps65941_ldo_probe,
 397 };
 398
 399 static const struct dm_regulator_ops tps65941_buck_ops = {
 400         .get_value  = buck_get_value,
 401         .set_value  = buck_set_value,
 402         .get_enable = buck_get_enable,
 403         .set_enable = buck_set_enable,
 404 };
 405
 406 U_BOOT_DRIVER(tps65941_buck) = {
 407         .name = TPS65941_BUCK_DRIVER,
 408         .id = UCLASS_REGULATOR,
 409         .ops = &tps65941_buck_ops,
 410         .probe = tps65941_buck_probe,
 411 };