1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Rockchip IO Voltage Domain driver 4 * 5 * Copyright 2014 MundoReader S.L. 6 * Copyright 2014 Google, Inc. 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/module.h> 11 #include <linux/err.h> 12 #include <linux/mfd/syscon.h> 13 #include <linux/of.h> 14 #include <linux/platform_device.h> 15 #include <linux/regmap.h> 16 #include <linux/regulator/consumer.h> 17 18 #define MAX_SUPPLIES 16 19 20 /* 21 * The max voltage for 1.8V and 3.3V come from the Rockchip datasheet under 22 * "Recommended Operating Conditions" for "Digital GPIO". When the typical 23 * is 3.3V the max is 3.6V. When the typical is 1.8V the max is 1.98V. 24 * 25 * They are used like this: 26 * - If the voltage on a rail is above the "1.8" voltage (1.98V) we'll tell the 27 * SoC we're at 3.3. 28 * - If the voltage on a rail is above the "3.3" voltage (3.6V) we'll consider 29 * that to be an error. 30 */ 31 #define MAX_VOLTAGE_1_8 1980000 32 #define MAX_VOLTAGE_3_3 3600000 33 34 #define PX30_IO_VSEL 0x180 35 #define PX30_IO_VSEL_VCCIO6_SRC BIT(0) 36 #define PX30_IO_VSEL_VCCIO6_SUPPLY_NUM 1 37 38 #define RK3288_SOC_CON2 0x24c 39 #define RK3288_SOC_CON2_FLASH0 BIT(7) 40 #define RK3288_SOC_FLASH_SUPPLY_NUM 2 41 42 #define RK3328_SOC_CON4 0x410 43 #define RK3328_SOC_CON4_VCCIO2 BIT(7) 44 #define RK3328_SOC_VCCIO2_SUPPLY_NUM 1 45 46 #define RK3368_SOC_CON15 0x43c 47 #define RK3368_SOC_CON15_FLASH0 BIT(14) 48 #define RK3368_SOC_FLASH_SUPPLY_NUM 2 49 50 #define RK3399_PMUGRF_CON0 0x180 51 #define RK3399_PMUGRF_CON0_VSEL BIT(8) 52 #define RK3399_PMUGRF_VSEL_SUPPLY_NUM 9 53 54 #define RK3568_PMU_GRF_IO_VSEL0 (0x0140) 55 #define RK3568_PMU_GRF_IO_VSEL1 (0x0144) 56 #define RK3568_PMU_GRF_IO_VSEL2 (0x0148) 57 58 struct rockchip_iodomain; 59 60 struct rockchip_iodomain_supply { 61 struct rockchip_iodomain *iod; 62 struct regulator *reg; 63 struct notifier_block nb; 64 int idx; 65 }; 66 67 struct rockchip_iodomain_soc_data { 68 int grf_offset; 69 const char *supply_names[MAX_SUPPLIES]; 70 void (*init)(struct rockchip_iodomain *iod); 71 int (*write)(struct rockchip_iodomain_supply *supply, int uV); 72 }; 73 74 struct rockchip_iodomain { 75 struct device *dev; 76 struct regmap *grf; 77 const struct rockchip_iodomain_soc_data *soc_data; 78 struct rockchip_iodomain_supply supplies[MAX_SUPPLIES]; 79 int (*write)(struct rockchip_iodomain_supply *supply, int uV); 80 }; 81 82 static int rk3568_iodomain_write(struct rockchip_iodomain_supply *supply, int uV) 83 { 84 struct rockchip_iodomain *iod = supply->iod; 85 u32 is_3v3 = uV > MAX_VOLTAGE_1_8; 86 u32 val0, val1; 87 int b; 88 89 switch (supply->idx) { 90 case 0: /* pmuio1 */ 91 break; 92 case 1: /* pmuio2 */ 93 b = supply->idx; 94 val0 = BIT(16 + b) | (is_3v3 ? 0 : BIT(b)); 95 b = supply->idx + 4; 96 val1 = BIT(16 + b) | (is_3v3 ? BIT(b) : 0); 97 98 regmap_write(iod->grf, RK3568_PMU_GRF_IO_VSEL2, val0); 99 regmap_write(iod->grf, RK3568_PMU_GRF_IO_VSEL2, val1); 100 break; 101 case 3: /* vccio2 */ 102 break; 103 case 2: /* vccio1 */ 104 case 4: /* vccio3 */ 105 case 5: /* vccio4 */ 106 case 6: /* vccio5 */ 107 case 7: /* vccio6 */ 108 case 8: /* vccio7 */ 109 b = supply->idx - 1; 110 val0 = BIT(16 + b) | (is_3v3 ? 0 : BIT(b)); 111 val1 = BIT(16 + b) | (is_3v3 ? BIT(b) : 0); 112 113 regmap_write(iod->grf, RK3568_PMU_GRF_IO_VSEL0, val0); 114 regmap_write(iod->grf, RK3568_PMU_GRF_IO_VSEL1, val1); 115 break; 116 default: 117 return -EINVAL; 118 } 119 120 return 0; 121 } 122 123 static int rockchip_iodomain_write(struct rockchip_iodomain_supply *supply, 124 int uV) 125 { 126 struct rockchip_iodomain *iod = supply->iod; 127 u32 val; 128 int ret; 129 130 /* set value bit */ 131 val = (uV > MAX_VOLTAGE_1_8) ? 0 : 1; 132 val <<= supply->idx; 133 134 /* apply hiword-mask */ 135 val |= (BIT(supply->idx) << 16); 136 137 ret = regmap_write(iod->grf, iod->soc_data->grf_offset, val); 138 if (ret) 139 dev_err(iod->dev, "Couldn't write to GRF\n"); 140 141 return ret; 142 } 143 144 static int rockchip_iodomain_notify(struct notifier_block *nb, 145 unsigned long event, 146 void *data) 147 { 148 struct rockchip_iodomain_supply *supply = 149 container_of(nb, struct rockchip_iodomain_supply, nb); 150 int uV; 151 int ret; 152 153 /* 154 * According to Rockchip it's important to keep the SoC IO domain 155 * higher than (or equal to) the external voltage. That means we need 156 * to change it before external voltage changes happen in the case 157 * of an increase. 158 * 159 * Note that in the "pre" change we pick the max possible voltage that 160 * the regulator might end up at (the client requests a range and we 161 * don't know for certain the exact voltage). Right now we rely on the 162 * slop in MAX_VOLTAGE_1_8 and MAX_VOLTAGE_3_3 to save us if clients 163 * request something like a max of 3.6V when they really want 3.3V. 164 * We could attempt to come up with better rules if this fails. 165 */ 166 if (event & REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) { 167 struct pre_voltage_change_data *pvc_data = data; 168 169 uV = max_t(unsigned long, pvc_data->old_uV, pvc_data->max_uV); 170 } else if (event & (REGULATOR_EVENT_VOLTAGE_CHANGE | 171 REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE)) { 172 uV = (unsigned long)data; 173 } else { 174 return NOTIFY_OK; 175 } 176 177 dev_dbg(supply->iod->dev, "Setting to %d\n", uV); 178 179 if (uV > MAX_VOLTAGE_3_3) { 180 dev_err(supply->iod->dev, "Voltage too high: %d\n", uV); 181 182 if (event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) 183 return NOTIFY_BAD; 184 } 185 186 ret = supply->iod->write(supply, uV); 187 if (ret && event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) 188 return NOTIFY_BAD; 189 190 dev_dbg(supply->iod->dev, "Setting to %d done\n", uV); 191 return NOTIFY_OK; 192 } 193 194 static void px30_iodomain_init(struct rockchip_iodomain *iod) 195 { 196 int ret; 197 u32 val; 198 199 /* if no VCCIO6 supply we should leave things alone */ 200 if (!iod->supplies[PX30_IO_VSEL_VCCIO6_SUPPLY_NUM].reg) 201 return; 202 203 /* 204 * set vccio6 iodomain to also use this framework 205 * instead of a special gpio. 206 */ 207 val = PX30_IO_VSEL_VCCIO6_SRC | (PX30_IO_VSEL_VCCIO6_SRC << 16); 208 ret = regmap_write(iod->grf, PX30_IO_VSEL, val); 209 if (ret < 0) 210 dev_warn(iod->dev, "couldn't update vccio6 ctrl\n"); 211 } 212 213 static void rk3288_iodomain_init(struct rockchip_iodomain *iod) 214 { 215 int ret; 216 u32 val; 217 218 /* if no flash supply we should leave things alone */ 219 if (!iod->supplies[RK3288_SOC_FLASH_SUPPLY_NUM].reg) 220 return; 221 222 /* 223 * set flash0 iodomain to also use this framework 224 * instead of a special gpio. 225 */ 226 val = RK3288_SOC_CON2_FLASH0 | (RK3288_SOC_CON2_FLASH0 << 16); 227 ret = regmap_write(iod->grf, RK3288_SOC_CON2, val); 228 if (ret < 0) 229 dev_warn(iod->dev, "couldn't update flash0 ctrl\n"); 230 } 231 232 static void rk3328_iodomain_init(struct rockchip_iodomain *iod) 233 { 234 int ret; 235 u32 val; 236 237 /* if no vccio2 supply we should leave things alone */ 238 if (!iod->supplies[RK3328_SOC_VCCIO2_SUPPLY_NUM].reg) 239 return; 240 241 /* 242 * set vccio2 iodomain to also use this framework 243 * instead of a special gpio. 244 */ 245 val = RK3328_SOC_CON4_VCCIO2 | (RK3328_SOC_CON4_VCCIO2 << 16); 246 ret = regmap_write(iod->grf, RK3328_SOC_CON4, val); 247 if (ret < 0) 248 dev_warn(iod->dev, "couldn't update vccio2 vsel ctrl\n"); 249 } 250 251 static void rk3368_iodomain_init(struct rockchip_iodomain *iod) 252 { 253 int ret; 254 u32 val; 255 256 /* if no flash supply we should leave things alone */ 257 if (!iod->supplies[RK3368_SOC_FLASH_SUPPLY_NUM].reg) 258 return; 259 260 /* 261 * set flash0 iodomain to also use this framework 262 * instead of a special gpio. 263 */ 264 val = RK3368_SOC_CON15_FLASH0 | (RK3368_SOC_CON15_FLASH0 << 16); 265 ret = regmap_write(iod->grf, RK3368_SOC_CON15, val); 266 if (ret < 0) 267 dev_warn(iod->dev, "couldn't update flash0 ctrl\n"); 268 } 269 270 static void rk3399_pmu_iodomain_init(struct rockchip_iodomain *iod) 271 { 272 int ret; 273 u32 val; 274 275 /* if no pmu io supply we should leave things alone */ 276 if (!iod->supplies[RK3399_PMUGRF_VSEL_SUPPLY_NUM].reg) 277 return; 278 279 /* 280 * set pmu io iodomain to also use this framework 281 * instead of a special gpio. 282 */ 283 val = RK3399_PMUGRF_CON0_VSEL | (RK3399_PMUGRF_CON0_VSEL << 16); 284 ret = regmap_write(iod->grf, RK3399_PMUGRF_CON0, val); 285 if (ret < 0) 286 dev_warn(iod->dev, "couldn't update pmu io iodomain ctrl\n"); 287 } 288 289 static const struct rockchip_iodomain_soc_data soc_data_px30 = { 290 .grf_offset = 0x180, 291 .supply_names = { 292 NULL, 293 "vccio6", 294 "vccio1", 295 "vccio2", 296 "vccio3", 297 "vccio4", 298 "vccio5", 299 "vccio-oscgpi", 300 }, 301 .init = px30_iodomain_init, 302 }; 303 304 static const struct rockchip_iodomain_soc_data soc_data_px30_pmu = { 305 .grf_offset = 0x100, 306 .supply_names = { 307 NULL, 308 NULL, 309 NULL, 310 NULL, 311 NULL, 312 NULL, 313 NULL, 314 NULL, 315 NULL, 316 NULL, 317 NULL, 318 NULL, 319 NULL, 320 NULL, 321 "pmuio1", 322 "pmuio2", 323 }, 324 }; 325 326 /* 327 * On the rk3188 the io-domains are handled by a shared register with the 328 * lower 8 bits being still being continuing drive-strength settings. 329 */ 330 static const struct rockchip_iodomain_soc_data soc_data_rk3188 = { 331 .grf_offset = 0x104, 332 .supply_names = { 333 NULL, 334 NULL, 335 NULL, 336 NULL, 337 NULL, 338 NULL, 339 NULL, 340 NULL, 341 "ap0", 342 "ap1", 343 "cif", 344 "flash", 345 "vccio0", 346 "vccio1", 347 "lcdc0", 348 "lcdc1", 349 }, 350 }; 351 352 static const struct rockchip_iodomain_soc_data soc_data_rk3228 = { 353 .grf_offset = 0x418, 354 .supply_names = { 355 "vccio1", 356 "vccio2", 357 "vccio3", 358 "vccio4", 359 }, 360 }; 361 362 static const struct rockchip_iodomain_soc_data soc_data_rk3288 = { 363 .grf_offset = 0x380, 364 .supply_names = { 365 "lcdc", /* LCDC_VDD */ 366 "dvp", /* DVPIO_VDD */ 367 "flash0", /* FLASH0_VDD (emmc) */ 368 "flash1", /* FLASH1_VDD (sdio1) */ 369 "wifi", /* APIO3_VDD (sdio0) */ 370 "bb", /* APIO5_VDD */ 371 "audio", /* APIO4_VDD */ 372 "sdcard", /* SDMMC0_VDD (sdmmc) */ 373 "gpio30", /* APIO1_VDD */ 374 "gpio1830", /* APIO2_VDD */ 375 }, 376 .init = rk3288_iodomain_init, 377 }; 378 379 static const struct rockchip_iodomain_soc_data soc_data_rk3328 = { 380 .grf_offset = 0x410, 381 .supply_names = { 382 "vccio1", 383 "vccio2", 384 "vccio3", 385 "vccio4", 386 "vccio5", 387 "vccio6", 388 "pmuio", 389 }, 390 .init = rk3328_iodomain_init, 391 }; 392 393 static const struct rockchip_iodomain_soc_data soc_data_rk3368 = { 394 .grf_offset = 0x900, 395 .supply_names = { 396 NULL, /* reserved */ 397 "dvp", /* DVPIO_VDD */ 398 "flash0", /* FLASH0_VDD (emmc) */ 399 "wifi", /* APIO2_VDD (sdio0) */ 400 NULL, 401 "audio", /* APIO3_VDD */ 402 "sdcard", /* SDMMC0_VDD (sdmmc) */ 403 "gpio30", /* APIO1_VDD */ 404 "gpio1830", /* APIO4_VDD (gpujtag) */ 405 }, 406 .init = rk3368_iodomain_init, 407 }; 408 409 static const struct rockchip_iodomain_soc_data soc_data_rk3368_pmu = { 410 .grf_offset = 0x100, 411 .supply_names = { 412 NULL, 413 NULL, 414 NULL, 415 NULL, 416 "pmu", /*PMU IO domain*/ 417 "vop", /*LCDC IO domain*/ 418 }, 419 }; 420 421 static const struct rockchip_iodomain_soc_data soc_data_rk3399 = { 422 .grf_offset = 0xe640, 423 .supply_names = { 424 "bt656", /* APIO2_VDD */ 425 "audio", /* APIO5_VDD */ 426 "sdmmc", /* SDMMC0_VDD */ 427 "gpio1830", /* APIO4_VDD */ 428 }, 429 }; 430 431 static const struct rockchip_iodomain_soc_data soc_data_rk3399_pmu = { 432 .grf_offset = 0x180, 433 .supply_names = { 434 NULL, 435 NULL, 436 NULL, 437 NULL, 438 NULL, 439 NULL, 440 NULL, 441 NULL, 442 NULL, 443 "pmu1830", /* PMUIO2_VDD */ 444 }, 445 .init = rk3399_pmu_iodomain_init, 446 }; 447 448 static const struct rockchip_iodomain_soc_data soc_data_rk3568_pmu = { 449 .grf_offset = 0x140, 450 .supply_names = { 451 "pmuio1", 452 "pmuio2", 453 "vccio1", 454 "vccio2", 455 "vccio3", 456 "vccio4", 457 "vccio5", 458 "vccio6", 459 "vccio7", 460 }, 461 .write = rk3568_iodomain_write, 462 }; 463 464 static const struct rockchip_iodomain_soc_data soc_data_rv1108 = { 465 .grf_offset = 0x404, 466 .supply_names = { 467 NULL, 468 NULL, 469 NULL, 470 NULL, 471 NULL, 472 NULL, 473 NULL, 474 NULL, 475 NULL, 476 NULL, 477 NULL, 478 "vccio1", 479 "vccio2", 480 "vccio3", 481 "vccio5", 482 "vccio6", 483 }, 484 485 }; 486 487 static const struct rockchip_iodomain_soc_data soc_data_rv1108_pmu = { 488 .grf_offset = 0x104, 489 .supply_names = { 490 "pmu", 491 }, 492 }; 493 494 static const struct of_device_id rockchip_iodomain_match[] = { 495 { 496 .compatible = "rockchip,px30-io-voltage-domain", 497 .data = (void *)&soc_data_px30 498 }, 499 { 500 .compatible = "rockchip,px30-pmu-io-voltage-domain", 501 .data = (void *)&soc_data_px30_pmu 502 }, 503 { 504 .compatible = "rockchip,rk3188-io-voltage-domain", 505 .data = &soc_data_rk3188 506 }, 507 { 508 .compatible = "rockchip,rk3228-io-voltage-domain", 509 .data = &soc_data_rk3228 510 }, 511 { 512 .compatible = "rockchip,rk3288-io-voltage-domain", 513 .data = &soc_data_rk3288 514 }, 515 { 516 .compatible = "rockchip,rk3328-io-voltage-domain", 517 .data = &soc_data_rk3328 518 }, 519 { 520 .compatible = "rockchip,rk3368-io-voltage-domain", 521 .data = &soc_data_rk3368 522 }, 523 { 524 .compatible = "rockchip,rk3368-pmu-io-voltage-domain", 525 .data = &soc_data_rk3368_pmu 526 }, 527 { 528 .compatible = "rockchip,rk3399-io-voltage-domain", 529 .data = &soc_data_rk3399 530 }, 531 { 532 .compatible = "rockchip,rk3399-pmu-io-voltage-domain", 533 .data = &soc_data_rk3399_pmu 534 }, 535 { 536 .compatible = "rockchip,rk3568-pmu-io-voltage-domain", 537 .data = &soc_data_rk3568_pmu 538 }, 539 { 540 .compatible = "rockchip,rv1108-io-voltage-domain", 541 .data = &soc_data_rv1108 542 }, 543 { 544 .compatible = "rockchip,rv1108-pmu-io-voltage-domain", 545 .data = &soc_data_rv1108_pmu 546 }, 547 { /* sentinel */ }, 548 }; 549 MODULE_DEVICE_TABLE(of, rockchip_iodomain_match); 550 551 static int rockchip_iodomain_probe(struct platform_device *pdev) 552 { 553 struct device_node *np = pdev->dev.of_node; 554 const struct of_device_id *match; 555 struct rockchip_iodomain *iod; 556 struct device *parent; 557 int i, ret = 0; 558 559 if (!np) 560 return -ENODEV; 561 562 iod = devm_kzalloc(&pdev->dev, sizeof(*iod), GFP_KERNEL); 563 if (!iod) 564 return -ENOMEM; 565 566 iod->dev = &pdev->dev; 567 platform_set_drvdata(pdev, iod); 568 569 match = of_match_node(rockchip_iodomain_match, np); 570 iod->soc_data = match->data; 571 572 if (iod->soc_data->write) 573 iod->write = iod->soc_data->write; 574 else 575 iod->write = rockchip_iodomain_write; 576 577 parent = pdev->dev.parent; 578 if (parent && parent->of_node) { 579 iod->grf = syscon_node_to_regmap(parent->of_node); 580 } else { 581 dev_dbg(&pdev->dev, "falling back to old binding\n"); 582 iod->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf"); 583 } 584 585 if (IS_ERR(iod->grf)) { 586 dev_err(&pdev->dev, "couldn't find grf regmap\n"); 587 return PTR_ERR(iod->grf); 588 } 589 590 for (i = 0; i < MAX_SUPPLIES; i++) { 591 const char *supply_name = iod->soc_data->supply_names[i]; 592 struct rockchip_iodomain_supply *supply = &iod->supplies[i]; 593 struct regulator *reg; 594 int uV; 595 596 if (!supply_name) 597 continue; 598 599 reg = devm_regulator_get_optional(iod->dev, supply_name); 600 if (IS_ERR(reg)) { 601 ret = PTR_ERR(reg); 602 603 /* If a supply wasn't specified, that's OK */ 604 if (ret == -ENODEV) 605 continue; 606 else if (ret != -EPROBE_DEFER) 607 dev_err(iod->dev, "couldn't get regulator %s\n", 608 supply_name); 609 goto unreg_notify; 610 } 611 612 /* set initial correct value */ 613 uV = regulator_get_voltage(reg); 614 615 /* must be a regulator we can get the voltage of */ 616 if (uV < 0) { 617 dev_err(iod->dev, "Can't determine voltage: %s\n", 618 supply_name); 619 ret = uV; 620 goto unreg_notify; 621 } 622 623 if (uV > MAX_VOLTAGE_3_3) { 624 dev_crit(iod->dev, 625 "%d uV is too high. May damage SoC!\n", 626 uV); 627 ret = -EINVAL; 628 goto unreg_notify; 629 } 630 631 /* setup our supply */ 632 supply->idx = i; 633 supply->iod = iod; 634 supply->reg = reg; 635 supply->nb.notifier_call = rockchip_iodomain_notify; 636 637 ret = iod->write(supply, uV); 638 if (ret) { 639 supply->reg = NULL; 640 goto unreg_notify; 641 } 642 643 /* register regulator notifier */ 644 ret = regulator_register_notifier(reg, &supply->nb); 645 if (ret) { 646 dev_err(&pdev->dev, 647 "regulator notifier request failed\n"); 648 supply->reg = NULL; 649 goto unreg_notify; 650 } 651 } 652 653 if (iod->soc_data->init) 654 iod->soc_data->init(iod); 655 656 return 0; 657 658 unreg_notify: 659 for (i = MAX_SUPPLIES - 1; i >= 0; i--) { 660 struct rockchip_iodomain_supply *io_supply = &iod->supplies[i]; 661 662 if (io_supply->reg) 663 regulator_unregister_notifier(io_supply->reg, 664 &io_supply->nb); 665 } 666 667 return ret; 668 } 669 670 static int rockchip_iodomain_remove(struct platform_device *pdev) 671 { 672 struct rockchip_iodomain *iod = platform_get_drvdata(pdev); 673 int i; 674 675 for (i = MAX_SUPPLIES - 1; i >= 0; i--) { 676 struct rockchip_iodomain_supply *io_supply = &iod->supplies[i]; 677 678 if (io_supply->reg) 679 regulator_unregister_notifier(io_supply->reg, 680 &io_supply->nb); 681 } 682 683 return 0; 684 } 685 686 static struct platform_driver rockchip_iodomain_driver = { 687 .probe = rockchip_iodomain_probe, 688 .remove = rockchip_iodomain_remove, 689 .driver = { 690 .name = "rockchip-iodomain", 691 .of_match_table = rockchip_iodomain_match, 692 }, 693 }; 694 695 module_platform_driver(rockchip_iodomain_driver); 696 697 MODULE_DESCRIPTION("Rockchip IO-domain driver"); 698 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); 699 MODULE_AUTHOR("Doug Anderson <dianders@chromium.org>"); 700 MODULE_LICENSE("GPL v2"); 701