1 /* 2 * (C) Copyright 2016 3 * Texas Instruments Incorporated, <www.ti.com> 4 * 5 * Keerthy <j-keerthy@ti.com> 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #include <common.h> 11 #include <fdtdec.h> 12 #include <errno.h> 13 #include <dm.h> 14 #include <i2c.h> 15 #include <power/pmic.h> 16 #include <power/regulator.h> 17 #include <power/palmas.h> 18 19 DECLARE_GLOBAL_DATA_PTR; 20 21 #define REGULATOR_ON 0x1 22 #define REGULATOR_OFF 0x0 23 24 #define SMPS_MODE_MASK 0x3 25 #define SMPS_MODE_SHIFT 0x0 26 #define LDO_MODE_MASK 0x1 27 #define LDO_MODE_SHIFT 0x0 28 29 static const char palmas_smps_ctrl[][PALMAS_SMPS_NUM] = { 30 {0x20, 0x24, 0x28, 0x2c, 0x30, 0x34, 0x38, 0x3c}, 31 {0x20, 0x24, 0x28, 0x2c, 0x30, 0x34, 0x38}, 32 {0x20, 0x24, 0x2c, 0x30, 0x38}, 33 }; 34 35 static const char palmas_smps_volt[][PALMAS_SMPS_NUM] = { 36 {0x23, 0x27, 0x2b, 0x2f, 0x33, 0x37, 0x3b, 0x3c}, 37 {0x23, 0x27, 0x2b, 0x2f, 0x33, 0x37, 0x3b}, 38 {0x23, 0x27, 0x2f, 0x33, 0x3B} 39 }; 40 41 static const char palmas_ldo_ctrl[][PALMAS_LDO_NUM] = { 42 {0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, 0x64}, 43 {0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, 0x64}, 44 {0x50, 0x52, 0x54, 0x5e, 0x62} 45 }; 46 47 static const char palmas_ldo_volt[][PALMAS_LDO_NUM] = { 48 {0x51, 0x53, 0x55, 0x57, 0x59, 0x5b, 0x5d, 0x5f, 0x61, 0x63, 0x65}, 49 {0x51, 0x53, 0x55, 0x57, 0x59, 0x5b, 0x5d, 0x5f, 0x61, 0x63, 0x65}, 50 {0x51, 0x53, 0x55, 0x5f, 0x63} 51 }; 52 53 static int palmas_smps_enable(struct udevice *dev, int op, bool *enable) 54 { 55 int ret; 56 unsigned int adr; 57 struct dm_regulator_uclass_platdata *uc_pdata; 58 59 uc_pdata = dev_get_uclass_platdata(dev); 60 adr = uc_pdata->ctrl_reg; 61 62 ret = pmic_reg_read(dev->parent, adr); 63 if (ret < 0) 64 return ret; 65 66 if (op == PMIC_OP_GET) { 67 ret &= PALMAS_SMPS_STATUS_MASK; 68 69 if (ret) 70 *enable = true; 71 else 72 *enable = false; 73 74 return 0; 75 } else if (op == PMIC_OP_SET) { 76 if (*enable) 77 ret |= PALMAS_SMPS_MODE_MASK; 78 else 79 ret &= ~(PALMAS_SMPS_MODE_MASK); 80 81 ret = pmic_reg_write(dev->parent, adr, ret); 82 if (ret) 83 return ret; 84 } 85 86 return 0; 87 } 88 89 static int palmas_smps_volt2hex(int uV) 90 { 91 if (uV > PALMAS_LDO_VOLT_MAX) 92 return -EINVAL; 93 94 if (uV > 1650000) 95 return (uV - 1000000) / 20000 + 0x6; 96 97 if (uV == 500000) 98 return 0x6; 99 else 100 return 0x6 + ((uV - 500000) / 10000); 101 } 102 103 static int palmas_smps_hex2volt(int hex, bool range) 104 { 105 unsigned int uV = 0; 106 107 if (hex > PALMAS_SMPS_VOLT_MAX_HEX) 108 return -EINVAL; 109 110 if (hex < 0x7) 111 uV = 500000; 112 else 113 uV = 500000 + (hex - 0x6) * 10000; 114 115 if (range) 116 uV *= 2; 117 118 return uV; 119 } 120 121 static int palmas_smps_val(struct udevice *dev, int op, int *uV) 122 { 123 unsigned int hex, adr; 124 int ret; 125 bool range; 126 struct dm_regulator_uclass_platdata *uc_pdata; 127 128 uc_pdata = dev_get_uclass_platdata(dev); 129 130 if (op == PMIC_OP_GET) 131 *uV = 0; 132 133 adr = uc_pdata->volt_reg; 134 135 ret = pmic_reg_read(dev->parent, adr); 136 if (ret < 0) 137 return ret; 138 139 if (op == PMIC_OP_GET) { 140 if (ret & PALMAS_SMPS_RANGE_MASK) 141 range = true; 142 else 143 range = false; 144 145 ret &= PALMAS_SMPS_VOLT_MASK; 146 ret = palmas_smps_hex2volt(ret, range); 147 if (ret < 0) 148 return ret; 149 *uV = ret; 150 151 return 0; 152 } 153 154 hex = palmas_smps_volt2hex(*uV); 155 if (hex < 0) 156 return hex; 157 158 ret &= ~PALMAS_SMPS_VOLT_MASK; 159 ret |= hex; 160 if (*uV > 1650000) 161 ret |= PALMAS_SMPS_RANGE_MASK; 162 163 return pmic_reg_write(dev->parent, adr, ret); 164 } 165 166 static int palmas_ldo_bypass_enable(struct udevice *dev, bool enabled) 167 { 168 int type = dev_get_driver_data(dev_get_parent(dev)); 169 struct dm_regulator_uclass_platdata *p; 170 unsigned int adr; 171 int reg; 172 173 if (type == TPS65917) { 174 /* bypass available only on LDO1 and LDO2 */ 175 if (dev->driver_data > 2) 176 return -ENOTSUPP; 177 } else if (type == TPS659038) { 178 /* bypass available only on LDO9 */ 179 if (dev->driver_data != 9) 180 return -ENOTSUPP; 181 } 182 183 p = dev_get_uclass_platdata(dev); 184 adr = p->ctrl_reg; 185 186 reg = pmic_reg_read(dev->parent, adr); 187 if (reg < 0) 188 return reg; 189 190 if (enabled) 191 reg |= PALMAS_LDO_BYPASS_EN; 192 else 193 reg &= ~PALMAS_LDO_BYPASS_EN; 194 195 return pmic_reg_write(dev->parent, adr, reg); 196 } 197 198 static int palmas_ldo_enable(struct udevice *dev, int op, bool *enable) 199 { 200 int ret; 201 unsigned int adr; 202 struct dm_regulator_uclass_platdata *uc_pdata; 203 204 uc_pdata = dev_get_uclass_platdata(dev); 205 adr = uc_pdata->ctrl_reg; 206 207 ret = pmic_reg_read(dev->parent, adr); 208 if (ret < 0) 209 return ret; 210 211 if (op == PMIC_OP_GET) { 212 ret &= PALMAS_LDO_STATUS_MASK; 213 214 if (ret) 215 *enable = true; 216 else 217 *enable = false; 218 219 return 0; 220 } else if (op == PMIC_OP_SET) { 221 if (*enable) 222 ret |= PALMAS_LDO_MODE_MASK; 223 else 224 ret &= ~(PALMAS_LDO_MODE_MASK); 225 226 ret = pmic_reg_write(dev->parent, adr, ret); 227 if (ret) 228 return ret; 229 230 ret = palmas_ldo_bypass_enable(dev, false); 231 if (ret && (ret != -ENOTSUPP)) 232 return ret; 233 } 234 235 return 0; 236 } 237 238 static int palmas_ldo_volt2hex(int uV) 239 { 240 if (uV > PALMAS_LDO_VOLT_MAX) 241 return -EINVAL; 242 243 return (uV - 850000) / 50000; 244 } 245 246 static int palmas_ldo_hex2volt(int hex) 247 { 248 if (hex > PALMAS_LDO_VOLT_MAX_HEX) 249 return -EINVAL; 250 251 if (!hex) 252 return 0; 253 254 return (hex * 50000) + 850000; 255 } 256 257 static int palmas_ldo_val(struct udevice *dev, int op, int *uV) 258 { 259 unsigned int hex, adr; 260 int ret; 261 262 struct dm_regulator_uclass_platdata *uc_pdata; 263 264 if (op == PMIC_OP_GET) 265 *uV = 0; 266 267 uc_pdata = dev_get_uclass_platdata(dev); 268 269 adr = uc_pdata->volt_reg; 270 271 ret = pmic_reg_read(dev->parent, adr); 272 if (ret < 0) 273 return ret; 274 275 if (op == PMIC_OP_GET) { 276 ret &= PALMAS_LDO_VOLT_MASK; 277 ret = palmas_ldo_hex2volt(ret); 278 if (ret < 0) 279 return ret; 280 *uV = ret; 281 return 0; 282 } 283 284 hex = palmas_ldo_volt2hex(*uV); 285 if (hex < 0) 286 return hex; 287 288 ret &= ~PALMAS_LDO_VOLT_MASK; 289 ret |= hex; 290 if (*uV > 1650000) 291 ret |= 0x80; 292 293 return pmic_reg_write(dev->parent, adr, ret); 294 } 295 296 static int palmas_ldo_probe(struct udevice *dev) 297 { 298 struct dm_regulator_uclass_platdata *uc_pdata; 299 struct udevice *parent; 300 301 uc_pdata = dev_get_uclass_platdata(dev); 302 303 parent = dev_get_parent(dev); 304 int type = dev_get_driver_data(parent); 305 306 uc_pdata->type = REGULATOR_TYPE_LDO; 307 308 if (dev->driver_data) { 309 u8 idx = dev->driver_data - 1; 310 uc_pdata->ctrl_reg = palmas_ldo_ctrl[type][idx]; 311 uc_pdata->volt_reg = palmas_ldo_volt[type][idx]; 312 } else { 313 /* check for ldoln and ldousb cases */ 314 if (!strcmp("ldoln", dev->name)) { 315 uc_pdata->ctrl_reg = palmas_ldo_ctrl[type][9]; 316 uc_pdata->volt_reg = palmas_ldo_volt[type][9]; 317 } else if (!strcmp("ldousb", dev->name)) { 318 uc_pdata->ctrl_reg = palmas_ldo_ctrl[type][10]; 319 uc_pdata->volt_reg = palmas_ldo_volt[type][10]; 320 } 321 } 322 323 return 0; 324 } 325 326 static int ldo_get_value(struct udevice *dev) 327 { 328 int uV; 329 int ret; 330 331 ret = palmas_ldo_val(dev, PMIC_OP_GET, &uV); 332 if (ret) 333 return ret; 334 335 return uV; 336 } 337 338 static int ldo_set_value(struct udevice *dev, int uV) 339 { 340 return palmas_ldo_val(dev, PMIC_OP_SET, &uV); 341 } 342 343 static int ldo_get_enable(struct udevice *dev) 344 { 345 bool enable = false; 346 int ret; 347 348 ret = palmas_ldo_enable(dev, PMIC_OP_GET, &enable); 349 if (ret) 350 return ret; 351 352 return enable; 353 } 354 355 static int ldo_set_enable(struct udevice *dev, bool enable) 356 { 357 return palmas_ldo_enable(dev, PMIC_OP_SET, &enable); 358 } 359 360 static int palmas_smps_probe(struct udevice *dev) 361 { 362 struct dm_regulator_uclass_platdata *uc_pdata; 363 struct udevice *parent; 364 int idx; 365 366 uc_pdata = dev_get_uclass_platdata(dev); 367 368 parent = dev_get_parent(dev); 369 int type = dev_get_driver_data(parent); 370 371 uc_pdata->type = REGULATOR_TYPE_BUCK; 372 373 switch (type) { 374 case PALMAS: 375 case TPS659038: 376 switch (dev->driver_data) { 377 case 123: 378 case 12: 379 uc_pdata->ctrl_reg = palmas_smps_ctrl[type][0]; 380 uc_pdata->volt_reg = palmas_smps_volt[type][0]; 381 break; 382 case 3: 383 uc_pdata->ctrl_reg = palmas_smps_ctrl[type][1]; 384 uc_pdata->volt_reg = palmas_smps_volt[type][1]; 385 break; 386 case 45: 387 uc_pdata->ctrl_reg = palmas_smps_ctrl[type][2]; 388 uc_pdata->volt_reg = palmas_smps_volt[type][2]; 389 break; 390 case 6: 391 case 7: 392 case 8: 393 case 9: 394 case 10: 395 idx = dev->driver_data - 3; 396 uc_pdata->ctrl_reg = palmas_smps_ctrl[type][idx]; 397 uc_pdata->volt_reg = palmas_smps_volt[type][idx]; 398 break; 399 400 default: 401 printf("Wrong ID for regulator\n"); 402 } 403 break; 404 405 case TPS65917: 406 switch (dev->driver_data) { 407 case 1: 408 case 2: 409 case 3: 410 case 4: 411 case 5: 412 idx = dev->driver_data - 1; 413 uc_pdata->ctrl_reg = palmas_smps_ctrl[type][idx]; 414 uc_pdata->volt_reg = palmas_smps_volt[type][idx]; 415 break; 416 case 12: 417 idx = 0; 418 uc_pdata->ctrl_reg = palmas_smps_ctrl[type][idx]; 419 uc_pdata->volt_reg = palmas_smps_volt[type][idx]; 420 break; 421 default: 422 printf("Wrong ID for regulator\n"); 423 } 424 break; 425 426 default: 427 printf("Invalid PMIC ID\n"); 428 } 429 430 return 0; 431 } 432 433 static int smps_get_value(struct udevice *dev) 434 { 435 int uV; 436 int ret; 437 438 ret = palmas_smps_val(dev, PMIC_OP_GET, &uV); 439 if (ret) 440 return ret; 441 442 return uV; 443 } 444 445 static int smps_set_value(struct udevice *dev, int uV) 446 { 447 return palmas_smps_val(dev, PMIC_OP_SET, &uV); 448 } 449 450 static int smps_get_enable(struct udevice *dev) 451 { 452 bool enable = false; 453 int ret; 454 455 ret = palmas_smps_enable(dev, PMIC_OP_GET, &enable); 456 if (ret) 457 return ret; 458 459 return enable; 460 } 461 462 static int smps_set_enable(struct udevice *dev, bool enable) 463 { 464 return palmas_smps_enable(dev, PMIC_OP_SET, &enable); 465 } 466 467 static const struct dm_regulator_ops palmas_ldo_ops = { 468 .get_value = ldo_get_value, 469 .set_value = ldo_set_value, 470 .get_enable = ldo_get_enable, 471 .set_enable = ldo_set_enable, 472 }; 473 474 U_BOOT_DRIVER(palmas_ldo) = { 475 .name = PALMAS_LDO_DRIVER, 476 .id = UCLASS_REGULATOR, 477 .ops = &palmas_ldo_ops, 478 .probe = palmas_ldo_probe, 479 }; 480 481 static const struct dm_regulator_ops palmas_smps_ops = { 482 .get_value = smps_get_value, 483 .set_value = smps_set_value, 484 .get_enable = smps_get_enable, 485 .set_enable = smps_set_enable, 486 }; 487 488 U_BOOT_DRIVER(palmas_smps) = { 489 .name = PALMAS_SMPS_DRIVER, 490 .id = UCLASS_REGULATOR, 491 .ops = &palmas_smps_ops, 492 .probe = palmas_smps_probe, 493 }; 494