1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2018 Samsung Electronics 4 * Jaehoon Chung <jh80.chung@samsung.com> 5 */ 6 7 #include <common.h> 8 #include <fdtdec.h> 9 #include <errno.h> 10 #include <dm.h> 11 #include <i2c.h> 12 #include <power/pmic.h> 13 #include <power/regulator.h> 14 #include <power/s2mps11.h> 15 16 #define MODE(_id, _val, _name) { \ 17 .id = _id, \ 18 .register_value = _val, \ 19 .name = _name, \ 20 } 21 22 /* BUCK : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 */ 23 static struct dm_regulator_mode s2mps11_buck_modes[] = { 24 MODE(OP_OFF, S2MPS11_BUCK_MODE_OFF, "OFF"), 25 MODE(OP_STANDBY, S2MPS11_BUCK_MODE_STANDBY, "ON/OFF"), 26 MODE(OP_ON, S2MPS11_BUCK_MODE_STANDBY, "ON"), 27 }; 28 29 static struct dm_regulator_mode s2mps11_ldo_modes[] = { 30 MODE(OP_OFF, S2MPS11_LDO_MODE_OFF, "OFF"), 31 MODE(OP_STANDBY, S2MPS11_LDO_MODE_STANDBY, "ON/OFF"), 32 MODE(OP_STANDBY_LPM, S2MPS11_LDO_MODE_STANDBY_LPM, "ON/LPM"), 33 MODE(OP_ON, S2MPS11_LDO_MODE_ON, "ON"), 34 }; 35 36 static const char s2mps11_buck_ctrl[] = { 37 0xff, 0x25, 0x27, 0x29, 0x2b, 0x2d, 0x33, 0x35, 0x37, 0x39, 0x3b 38 }; 39 40 static const char s2mps11_buck_out[] = { 41 0xff, 0x26, 0x28, 0x2a, 0x2c, 0x2f, 0x34, 0x36, 0x38, 0x3a, 0x3c 42 }; 43 44 static int s2mps11_buck_hex2volt(int buck, int hex) 45 { 46 unsigned int uV = 0; 47 48 if (hex < 0) 49 goto bad; 50 51 switch (buck) { 52 case 7: 53 case 8: 54 case 10: 55 if (hex > S2MPS11_BUCK7_8_10_VOLT_MAX_HEX) 56 goto bad; 57 58 uV = hex * S2MPS11_BUCK_HSTEP + S2MPS11_BUCK_UV_HMIN; 59 break; 60 case 9: 61 if (hex > S2MPS11_BUCK9_VOLT_MAX_HEX) 62 goto bad; 63 uV = hex * S2MPS11_BUCK9_STEP * 2 + S2MPS11_BUCK9_UV_MIN; 64 break; 65 default: 66 if (buck == 5 && hex > S2MPS11_BUCK5_VOLT_MAX_HEX) 67 goto bad; 68 else if (buck != 5 && hex > S2MPS11_BUCK_VOLT_MAX_HEX) 69 goto bad; 70 71 uV = hex * S2MPS11_BUCK_LSTEP + S2MPS11_BUCK_UV_MIN; 72 break; 73 } 74 75 return uV; 76 bad: 77 pr_err("Value: %#x is wrong for BUCK%d", hex, buck); 78 return -EINVAL; 79 } 80 81 static int s2mps11_buck_volt2hex(int buck, int uV) 82 { 83 int hex; 84 85 switch (buck) { 86 case 7: 87 case 8: 88 case 10: 89 hex = (uV - S2MPS11_BUCK_UV_HMIN) / S2MPS11_BUCK_HSTEP; 90 if (hex > S2MPS11_BUCK7_8_10_VOLT_MAX_HEX) 91 goto bad; 92 93 break; 94 case 9: 95 hex = (uV - S2MPS11_BUCK9_UV_MIN) / S2MPS11_BUCK9_STEP; 96 if (hex > S2MPS11_BUCK9_VOLT_MAX_HEX) 97 goto bad; 98 break; 99 default: 100 hex = (uV - S2MPS11_BUCK_UV_MIN) / S2MPS11_BUCK_LSTEP; 101 if (buck == 5 && hex > S2MPS11_BUCK5_VOLT_MAX_HEX) 102 goto bad; 103 else if (buck != 5 && hex > S2MPS11_BUCK_VOLT_MAX_HEX) 104 goto bad; 105 break; 106 }; 107 108 if (hex >= 0) 109 return hex; 110 111 bad: 112 pr_err("Value: %d uV is wrong for BUCK%d", uV, buck); 113 return -EINVAL; 114 } 115 116 static int s2mps11_buck_val(struct udevice *dev, int op, int *uV) 117 { 118 int hex, buck, ret; 119 u32 mask, addr; 120 u8 val; 121 122 buck = dev->driver_data; 123 if (buck < 1 || buck > S2MPS11_BUCK_NUM) { 124 pr_err("Wrong buck number: %d\n", buck); 125 return -EINVAL; 126 } 127 128 if (op == PMIC_OP_GET) 129 *uV = 0; 130 131 addr = s2mps11_buck_out[buck]; 132 133 switch (buck) { 134 case 9: 135 mask = S2MPS11_BUCK9_VOLT_MASK; 136 break; 137 default: 138 mask = S2MPS11_BUCK_VOLT_MASK; 139 break; 140 } 141 142 ret = pmic_read(dev->parent, addr, &val, 1); 143 if (ret) 144 return ret; 145 146 if (op == PMIC_OP_GET) { 147 val &= mask; 148 ret = s2mps11_buck_hex2volt(buck, val); 149 if (ret < 0) 150 return ret; 151 *uV = ret; 152 return 0; 153 } 154 155 hex = s2mps11_buck_volt2hex(buck, *uV); 156 if (hex < 0) 157 return hex; 158 159 val &= ~mask; 160 val |= hex; 161 ret = pmic_write(dev->parent, addr, &val, 1); 162 163 return ret; 164 } 165 166 static int s2mps11_buck_mode(struct udevice *dev, int op, int *opmode) 167 { 168 unsigned int addr, mode; 169 unsigned char val; 170 int buck, ret; 171 172 buck = dev->driver_data; 173 if (buck < 1 || buck > S2MPS11_BUCK_NUM) { 174 pr_err("Wrong buck number: %d\n", buck); 175 return -EINVAL; 176 } 177 178 addr = s2mps11_buck_ctrl[buck]; 179 180 ret = pmic_read(dev->parent, addr, &val, 1); 181 if (ret) 182 return ret; 183 184 if (op == PMIC_OP_GET) { 185 val &= (S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT); 186 switch (val) { 187 case S2MPS11_BUCK_MODE_OFF: 188 *opmode = OP_OFF; 189 break; 190 case S2MPS11_BUCK_MODE_STANDBY: 191 *opmode = OP_STANDBY; 192 break; 193 case S2MPS11_BUCK_MODE_ON: 194 *opmode = OP_ON; 195 break; 196 default: 197 return -EINVAL; 198 } 199 return 0; 200 } 201 202 switch (*opmode) { 203 case OP_OFF: 204 mode = S2MPS11_BUCK_MODE_OFF; 205 break; 206 case OP_STANDBY: 207 mode = S2MPS11_BUCK_MODE_STANDBY; 208 break; 209 case OP_ON: 210 mode = S2MPS11_BUCK_MODE_ON; 211 break; 212 default: 213 pr_err("Wrong mode: %d for buck: %d\n", *opmode, buck); 214 return -EINVAL; 215 } 216 217 val &= ~(S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT); 218 val |= mode; 219 ret = pmic_write(dev->parent, addr, &val, 1); 220 221 return ret; 222 } 223 224 static int s2mps11_buck_enable(struct udevice *dev, int op, bool *enable) 225 { 226 int ret, on_off; 227 228 if (op == PMIC_OP_GET) { 229 ret = s2mps11_buck_mode(dev, op, &on_off); 230 if (ret) 231 return ret; 232 switch (on_off) { 233 case OP_OFF: 234 *enable = false; 235 break; 236 case OP_ON: 237 *enable = true; 238 break; 239 default: 240 return -EINVAL; 241 } 242 } else if (op == PMIC_OP_SET) { 243 if (*enable) 244 on_off = OP_ON; 245 else 246 on_off = OP_OFF; 247 248 ret = s2mps11_buck_mode(dev, op, &on_off); 249 if (ret) 250 return ret; 251 } 252 253 return 0; 254 } 255 256 static int buck_get_value(struct udevice *dev) 257 { 258 int uV; 259 int ret; 260 261 ret = s2mps11_buck_val(dev, PMIC_OP_GET, &uV); 262 if (ret) 263 return ret; 264 return uV; 265 } 266 267 static int buck_set_value(struct udevice *dev, int uV) 268 { 269 return s2mps11_buck_val(dev, PMIC_OP_SET, &uV); 270 } 271 272 static int buck_get_enable(struct udevice *dev) 273 { 274 bool enable = false; 275 int ret; 276 277 ret = s2mps11_buck_enable(dev, PMIC_OP_GET, &enable); 278 if (ret) 279 return ret; 280 return enable; 281 } 282 283 static int buck_set_enable(struct udevice *dev, bool enable) 284 { 285 return s2mps11_buck_enable(dev, PMIC_OP_SET, &enable); 286 } 287 288 static int buck_get_mode(struct udevice *dev) 289 { 290 int mode; 291 int ret; 292 293 ret = s2mps11_buck_mode(dev, PMIC_OP_GET, &mode); 294 if (ret) 295 return ret; 296 297 return mode; 298 } 299 300 static int buck_set_mode(struct udevice *dev, int mode) 301 { 302 return s2mps11_buck_mode(dev, PMIC_OP_SET, &mode); 303 } 304 305 static int s2mps11_buck_probe(struct udevice *dev) 306 { 307 struct dm_regulator_uclass_platdata *uc_pdata; 308 309 uc_pdata = dev_get_uclass_platdata(dev); 310 311 uc_pdata->type = REGULATOR_TYPE_BUCK; 312 uc_pdata->mode = s2mps11_buck_modes; 313 uc_pdata->mode_count = ARRAY_SIZE(s2mps11_buck_modes); 314 315 return 0; 316 } 317 318 static const struct dm_regulator_ops s2mps11_buck_ops = { 319 .get_value = buck_get_value, 320 .set_value = buck_set_value, 321 .get_enable = buck_get_enable, 322 .set_enable = buck_set_enable, 323 .get_mode = buck_get_mode, 324 .set_mode = buck_set_mode, 325 }; 326 327 U_BOOT_DRIVER(s2mps11_buck) = { 328 .name = S2MPS11_BUCK_DRIVER, 329 .id = UCLASS_REGULATOR, 330 .ops = &s2mps11_buck_ops, 331 .probe = s2mps11_buck_probe, 332 }; 333 334 static int s2mps11_ldo_hex2volt(int ldo, int hex) 335 { 336 unsigned int uV = 0; 337 338 if (hex > S2MPS11_LDO_VOLT_MAX_HEX) { 339 pr_err("Value: %#x is wrong for LDO%d", hex, ldo); 340 return -EINVAL; 341 } 342 343 switch (ldo) { 344 case 1: 345 case 6: 346 case 11: 347 case 22: 348 case 23: 349 case 27: 350 case 35: 351 uV = hex * S2MPS11_LDO_STEP + S2MPS11_LDO_UV_MIN; 352 break; 353 default: 354 uV = hex * S2MPS11_LDO_STEP * 2 + S2MPS11_LDO_UV_MIN; 355 break; 356 } 357 358 return uV; 359 } 360 361 static int s2mps11_ldo_volt2hex(int ldo, int uV) 362 { 363 int hex = 0; 364 365 switch (ldo) { 366 case 1: 367 case 6: 368 case 11: 369 case 22: 370 case 23: 371 case 27: 372 case 35: 373 hex = (uV - S2MPS11_LDO_UV_MIN) / S2MPS11_LDO_STEP; 374 break; 375 default: 376 hex = (uV - S2MPS11_LDO_UV_MIN) / (S2MPS11_LDO_STEP * 2); 377 break; 378 } 379 380 if (hex >= 0 && hex <= S2MPS11_LDO_VOLT_MAX_HEX) 381 return hex; 382 383 pr_err("Value: %d uV is wrong for LDO%d", uV, ldo); 384 return -EINVAL; 385 386 return 0; 387 } 388 389 static int s2mps11_ldo_val(struct udevice *dev, int op, int *uV) 390 { 391 unsigned int addr; 392 unsigned char val; 393 int hex, ldo, ret; 394 395 ldo = dev->driver_data; 396 if (ldo < 1 || ldo > S2MPS11_LDO_NUM) { 397 pr_err("Wrong ldo number: %d\n", ldo); 398 return -EINVAL; 399 } 400 401 addr = S2MPS11_REG_L1CTRL + ldo - 1; 402 403 ret = pmic_read(dev->parent, addr, &val, 1); 404 if (ret) 405 return ret; 406 407 if (op == PMIC_OP_GET) { 408 *uV = 0; 409 val &= S2MPS11_LDO_VOLT_MASK; 410 ret = s2mps11_ldo_hex2volt(ldo, val); 411 if (ret < 0) 412 return ret; 413 414 *uV = ret; 415 return 0; 416 } 417 418 hex = s2mps11_ldo_volt2hex(ldo, *uV); 419 if (hex < 0) 420 return hex; 421 422 val &= ~S2MPS11_LDO_VOLT_MASK; 423 val |= hex; 424 ret = pmic_write(dev->parent, addr, &val, 1); 425 426 return ret; 427 } 428 429 static int s2mps11_ldo_mode(struct udevice *dev, int op, int *opmode) 430 { 431 unsigned int addr, mode; 432 unsigned char val; 433 int ldo, ret; 434 435 ldo = dev->driver_data; 436 if (ldo < 1 || ldo > S2MPS11_LDO_NUM) { 437 pr_err("Wrong ldo number: %d\n", ldo); 438 return -EINVAL; 439 } 440 addr = S2MPS11_REG_L1CTRL + ldo - 1; 441 442 ret = pmic_read(dev->parent, addr, &val, 1); 443 if (ret) 444 return ret; 445 446 if (op == PMIC_OP_GET) { 447 val &= (S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT); 448 switch (val) { 449 case S2MPS11_LDO_MODE_OFF: 450 *opmode = OP_OFF; 451 break; 452 case S2MPS11_LDO_MODE_STANDBY: 453 *opmode = OP_STANDBY; 454 break; 455 case S2MPS11_LDO_MODE_STANDBY_LPM: 456 *opmode = OP_STANDBY_LPM; 457 break; 458 case S2MPS11_LDO_MODE_ON: 459 *opmode = OP_ON; 460 break; 461 default: 462 return -EINVAL; 463 } 464 return 0; 465 } 466 467 switch (*opmode) { 468 case OP_OFF: 469 mode = S2MPS11_LDO_MODE_OFF; 470 break; 471 case OP_STANDBY: 472 mode = S2MPS11_LDO_MODE_STANDBY; 473 break; 474 case OP_STANDBY_LPM: 475 mode = S2MPS11_LDO_MODE_STANDBY_LPM; 476 break; 477 case OP_ON: 478 mode = S2MPS11_LDO_MODE_ON; 479 break; 480 default: 481 pr_err("Wrong mode: %d for ldo: %d\n", *opmode, ldo); 482 return -EINVAL; 483 } 484 485 val &= ~(S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT); 486 val |= mode; 487 ret = pmic_write(dev->parent, addr, &val, 1); 488 489 return ret; 490 } 491 492 static int s2mps11_ldo_enable(struct udevice *dev, int op, bool *enable) 493 { 494 int ret, on_off; 495 496 if (op == PMIC_OP_GET) { 497 ret = s2mps11_ldo_mode(dev, op, &on_off); 498 if (ret) 499 return ret; 500 switch (on_off) { 501 case OP_OFF: 502 *enable = false; 503 break; 504 case OP_ON: 505 *enable = true; 506 break; 507 default: 508 return -EINVAL; 509 } 510 } else if (op == PMIC_OP_SET) { 511 if (*enable) 512 on_off = OP_ON; 513 else 514 on_off = OP_OFF; 515 516 ret = s2mps11_ldo_mode(dev, op, &on_off); 517 if (ret) 518 return ret; 519 } 520 521 return 0; 522 } 523 524 static int ldo_get_value(struct udevice *dev) 525 { 526 int uV; 527 int ret; 528 529 ret = s2mps11_ldo_val(dev, PMIC_OP_GET, &uV); 530 if (ret) 531 return ret; 532 533 return uV; 534 } 535 536 static int ldo_set_value(struct udevice *dev, int uV) 537 { 538 return s2mps11_ldo_val(dev, PMIC_OP_SET, &uV); 539 } 540 541 static int ldo_get_enable(struct udevice *dev) 542 { 543 bool enable = false; 544 int ret; 545 546 ret = s2mps11_ldo_enable(dev, PMIC_OP_GET, &enable); 547 if (ret) 548 return ret; 549 return enable; 550 } 551 552 static int ldo_set_enable(struct udevice *dev, bool enable) 553 { 554 int ret; 555 556 ret = s2mps11_ldo_enable(dev, PMIC_OP_SET, &enable); 557 if (ret) 558 return ret; 559 560 /* Wait the "enable delay" for voltage to start to rise */ 561 udelay(15); 562 563 return 0; 564 } 565 566 static int ldo_get_mode(struct udevice *dev) 567 { 568 int mode, ret; 569 570 ret = s2mps11_ldo_mode(dev, PMIC_OP_GET, &mode); 571 if (ret) 572 return ret; 573 return mode; 574 } 575 576 static int ldo_set_mode(struct udevice *dev, int mode) 577 { 578 return s2mps11_ldo_mode(dev, PMIC_OP_SET, &mode); 579 } 580 581 static int s2mps11_ldo_probe(struct udevice *dev) 582 { 583 struct dm_regulator_uclass_platdata *uc_pdata; 584 585 uc_pdata = dev_get_uclass_platdata(dev); 586 uc_pdata->type = REGULATOR_TYPE_LDO; 587 uc_pdata->mode = s2mps11_ldo_modes; 588 uc_pdata->mode_count = ARRAY_SIZE(s2mps11_ldo_modes); 589 590 return 0; 591 } 592 593 static const struct dm_regulator_ops s2mps11_ldo_ops = { 594 .get_value = ldo_get_value, 595 .set_value = ldo_set_value, 596 .get_enable = ldo_get_enable, 597 .set_enable = ldo_set_enable, 598 .get_mode = ldo_get_mode, 599 .set_mode = ldo_set_mode, 600 }; 601 602 U_BOOT_DRIVER(s2mps11_ldo) = { 603 .name = S2MPS11_LDO_DRIVER, 604 .id = UCLASS_REGULATOR, 605 .ops = &s2mps11_ldo_ops, 606 .probe = s2mps11_ldo_probe, 607 }; 608