1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (c) 2020 Collabora Ltd. 4 */ 5#include <linux/clk.h> 6#include <linux/clk-provider.h> 7#include <linux/init.h> 8#include <linux/io.h> 9#include <linux/iopoll.h> 10#include <linux/mfd/syscon.h> 11#include <linux/of.h> 12#include <linux/of_clk.h> 13#include <linux/platform_device.h> 14#include <linux/pm_domain.h> 15#include <linux/regmap.h> 16#include <linux/regulator/consumer.h> 17#include <linux/soc/mediatek/infracfg.h> 18 19#include "mt6795-pm-domains.h" 20#include "mt8167-pm-domains.h" 21#include "mt8173-pm-domains.h" 22#include "mt8183-pm-domains.h" 23#include "mt8186-pm-domains.h" 24#include "mt8188-pm-domains.h" 25#include "mt8192-pm-domains.h" 26#include "mt8195-pm-domains.h" 27 28#define MTK_POLL_DELAY_US 10 29#define MTK_POLL_TIMEOUT USEC_PER_SEC 30 31#define PWR_RST_B_BIT BIT(0) 32#define PWR_ISO_BIT BIT(1) 33#define PWR_ON_BIT BIT(2) 34#define PWR_ON_2ND_BIT BIT(3) 35#define PWR_CLK_DIS_BIT BIT(4) 36#define PWR_SRAM_CLKISO_BIT BIT(5) 37#define PWR_SRAM_ISOINT_B_BIT BIT(6) 38 39struct scpsys_domain { 40 struct generic_pm_domain genpd; 41 const struct scpsys_domain_data *data; 42 struct scpsys *scpsys; 43 int num_clks; 44 struct clk_bulk_data *clks; 45 int num_subsys_clks; 46 struct clk_bulk_data *subsys_clks; 47 struct regmap *infracfg; 48 struct regmap *smi; 49 struct regulator *supply; 50}; 51 52struct scpsys { 53 struct device *dev; 54 struct regmap *base; 55 const struct scpsys_soc_data *soc_data; 56 struct genpd_onecell_data pd_data; 57 struct generic_pm_domain *domains[]; 58}; 59 60#define to_scpsys_domain(gpd) container_of(gpd, struct scpsys_domain, genpd) 61 62static bool scpsys_domain_is_on(struct scpsys_domain *pd) 63{ 64 struct scpsys *scpsys = pd->scpsys; 65 u32 status, status2; 66 67 regmap_read(scpsys->base, pd->data->pwr_sta_offs, &status); 68 status &= pd->data->sta_mask; 69 70 regmap_read(scpsys->base, pd->data->pwr_sta2nd_offs, &status2); 71 status2 &= pd->data->sta_mask; 72 73 /* A domain is on when both status bits are set. */ 74 return status && status2; 75} 76 77static int scpsys_sram_enable(struct scpsys_domain *pd) 78{ 79 u32 pdn_ack = pd->data->sram_pdn_ack_bits; 80 struct scpsys *scpsys = pd->scpsys; 81 unsigned int tmp; 82 int ret; 83 84 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, pd->data->sram_pdn_bits); 85 86 /* Either wait until SRAM_PDN_ACK all 1 or 0 */ 87 ret = regmap_read_poll_timeout(scpsys->base, pd->data->ctl_offs, tmp, 88 (tmp & pdn_ack) == 0, MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT); 89 if (ret < 0) 90 return ret; 91 92 if (MTK_SCPD_CAPS(pd, MTK_SCPD_SRAM_ISO)) { 93 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_ISOINT_B_BIT); 94 udelay(1); 95 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_CLKISO_BIT); 96 } 97 98 return 0; 99} 100 101static int scpsys_sram_disable(struct scpsys_domain *pd) 102{ 103 u32 pdn_ack = pd->data->sram_pdn_ack_bits; 104 struct scpsys *scpsys = pd->scpsys; 105 unsigned int tmp; 106 107 if (MTK_SCPD_CAPS(pd, MTK_SCPD_SRAM_ISO)) { 108 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_CLKISO_BIT); 109 udelay(1); 110 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_ISOINT_B_BIT); 111 } 112 113 regmap_set_bits(scpsys->base, pd->data->ctl_offs, pd->data->sram_pdn_bits); 114 115 /* Either wait until SRAM_PDN_ACK all 1 or 0 */ 116 return regmap_read_poll_timeout(scpsys->base, pd->data->ctl_offs, tmp, 117 (tmp & pdn_ack) == pdn_ack, MTK_POLL_DELAY_US, 118 MTK_POLL_TIMEOUT); 119} 120 121static int _scpsys_bus_protect_enable(const struct scpsys_bus_prot_data *bpd, struct regmap *regmap) 122{ 123 int i, ret; 124 125 for (i = 0; i < SPM_MAX_BUS_PROT_DATA; i++) { 126 u32 val, mask = bpd[i].bus_prot_mask; 127 128 if (!mask) 129 break; 130 131 if (bpd[i].bus_prot_reg_update) 132 regmap_set_bits(regmap, bpd[i].bus_prot_set, mask); 133 else 134 regmap_write(regmap, bpd[i].bus_prot_set, mask); 135 136 ret = regmap_read_poll_timeout(regmap, bpd[i].bus_prot_sta, 137 val, (val & mask) == mask, 138 MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT); 139 if (ret) 140 return ret; 141 } 142 143 return 0; 144} 145 146static int scpsys_bus_protect_enable(struct scpsys_domain *pd) 147{ 148 int ret; 149 150 ret = _scpsys_bus_protect_enable(pd->data->bp_infracfg, pd->infracfg); 151 if (ret) 152 return ret; 153 154 return _scpsys_bus_protect_enable(pd->data->bp_smi, pd->smi); 155} 156 157static int _scpsys_bus_protect_disable(const struct scpsys_bus_prot_data *bpd, 158 struct regmap *regmap) 159{ 160 int i, ret; 161 162 for (i = SPM_MAX_BUS_PROT_DATA - 1; i >= 0; i--) { 163 u32 val, mask = bpd[i].bus_prot_mask; 164 165 if (!mask) 166 continue; 167 168 if (bpd[i].bus_prot_reg_update) 169 regmap_clear_bits(regmap, bpd[i].bus_prot_clr, mask); 170 else 171 regmap_write(regmap, bpd[i].bus_prot_clr, mask); 172 173 if (bpd[i].ignore_clr_ack) 174 continue; 175 176 ret = regmap_read_poll_timeout(regmap, bpd[i].bus_prot_sta, 177 val, !(val & mask), 178 MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT); 179 if (ret) 180 return ret; 181 } 182 183 return 0; 184} 185 186static int scpsys_bus_protect_disable(struct scpsys_domain *pd) 187{ 188 int ret; 189 190 ret = _scpsys_bus_protect_disable(pd->data->bp_smi, pd->smi); 191 if (ret) 192 return ret; 193 194 return _scpsys_bus_protect_disable(pd->data->bp_infracfg, pd->infracfg); 195} 196 197static int scpsys_regulator_enable(struct regulator *supply) 198{ 199 return supply ? regulator_enable(supply) : 0; 200} 201 202static int scpsys_regulator_disable(struct regulator *supply) 203{ 204 return supply ? regulator_disable(supply) : 0; 205} 206 207static int scpsys_power_on(struct generic_pm_domain *genpd) 208{ 209 struct scpsys_domain *pd = container_of(genpd, struct scpsys_domain, genpd); 210 struct scpsys *scpsys = pd->scpsys; 211 bool tmp; 212 int ret; 213 214 ret = scpsys_regulator_enable(pd->supply); 215 if (ret) 216 return ret; 217 218 ret = clk_bulk_prepare_enable(pd->num_clks, pd->clks); 219 if (ret) 220 goto err_reg; 221 222 if (pd->data->ext_buck_iso_offs && MTK_SCPD_CAPS(pd, MTK_SCPD_EXT_BUCK_ISO)) 223 regmap_clear_bits(scpsys->base, pd->data->ext_buck_iso_offs, 224 pd->data->ext_buck_iso_mask); 225 226 /* subsys power on */ 227 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_BIT); 228 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_2ND_BIT); 229 230 /* wait until PWR_ACK = 1 */ 231 ret = readx_poll_timeout(scpsys_domain_is_on, pd, tmp, tmp, MTK_POLL_DELAY_US, 232 MTK_POLL_TIMEOUT); 233 if (ret < 0) 234 goto err_pwr_ack; 235 236 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_CLK_DIS_BIT); 237 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ISO_BIT); 238 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_RST_B_BIT); 239 240 ret = clk_bulk_prepare_enable(pd->num_subsys_clks, pd->subsys_clks); 241 if (ret) 242 goto err_pwr_ack; 243 244 ret = scpsys_sram_enable(pd); 245 if (ret < 0) 246 goto err_disable_subsys_clks; 247 248 ret = scpsys_bus_protect_disable(pd); 249 if (ret < 0) 250 goto err_disable_sram; 251 252 return 0; 253 254err_disable_sram: 255 scpsys_sram_disable(pd); 256err_disable_subsys_clks: 257 clk_bulk_disable_unprepare(pd->num_subsys_clks, pd->subsys_clks); 258err_pwr_ack: 259 clk_bulk_disable_unprepare(pd->num_clks, pd->clks); 260err_reg: 261 scpsys_regulator_disable(pd->supply); 262 return ret; 263} 264 265static int scpsys_power_off(struct generic_pm_domain *genpd) 266{ 267 struct scpsys_domain *pd = container_of(genpd, struct scpsys_domain, genpd); 268 struct scpsys *scpsys = pd->scpsys; 269 bool tmp; 270 int ret; 271 272 ret = scpsys_bus_protect_enable(pd); 273 if (ret < 0) 274 return ret; 275 276 ret = scpsys_sram_disable(pd); 277 if (ret < 0) 278 return ret; 279 280 if (pd->data->ext_buck_iso_offs && MTK_SCPD_CAPS(pd, MTK_SCPD_EXT_BUCK_ISO)) 281 regmap_set_bits(scpsys->base, pd->data->ext_buck_iso_offs, 282 pd->data->ext_buck_iso_mask); 283 284 clk_bulk_disable_unprepare(pd->num_subsys_clks, pd->subsys_clks); 285 286 /* subsys power off */ 287 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ISO_BIT); 288 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_CLK_DIS_BIT); 289 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_RST_B_BIT); 290 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_2ND_BIT); 291 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_BIT); 292 293 /* wait until PWR_ACK = 0 */ 294 ret = readx_poll_timeout(scpsys_domain_is_on, pd, tmp, !tmp, MTK_POLL_DELAY_US, 295 MTK_POLL_TIMEOUT); 296 if (ret < 0) 297 return ret; 298 299 clk_bulk_disable_unprepare(pd->num_clks, pd->clks); 300 301 scpsys_regulator_disable(pd->supply); 302 303 return 0; 304} 305 306static struct 307generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_node *node) 308{ 309 const struct scpsys_domain_data *domain_data; 310 struct scpsys_domain *pd; 311 struct device_node *root_node = scpsys->dev->of_node; 312 struct device_node *smi_node; 313 struct property *prop; 314 const char *clk_name; 315 int i, ret, num_clks; 316 struct clk *clk; 317 int clk_ind = 0; 318 u32 id; 319 320 ret = of_property_read_u32(node, "reg", &id); 321 if (ret) { 322 dev_err(scpsys->dev, "%pOF: failed to retrieve domain id from reg: %d\n", 323 node, ret); 324 return ERR_PTR(-EINVAL); 325 } 326 327 if (id >= scpsys->soc_data->num_domains) { 328 dev_err(scpsys->dev, "%pOF: invalid domain id %d\n", node, id); 329 return ERR_PTR(-EINVAL); 330 } 331 332 domain_data = &scpsys->soc_data->domains_data[id]; 333 if (domain_data->sta_mask == 0) { 334 dev_err(scpsys->dev, "%pOF: undefined domain id %d\n", node, id); 335 return ERR_PTR(-EINVAL); 336 } 337 338 pd = devm_kzalloc(scpsys->dev, sizeof(*pd), GFP_KERNEL); 339 if (!pd) 340 return ERR_PTR(-ENOMEM); 341 342 pd->data = domain_data; 343 pd->scpsys = scpsys; 344 345 if (MTK_SCPD_CAPS(pd, MTK_SCPD_DOMAIN_SUPPLY)) { 346 /* 347 * Find regulator in current power domain node. 348 * devm_regulator_get() finds regulator in a node and its child 349 * node, so set of_node to current power domain node then change 350 * back to original node after regulator is found for current 351 * power domain node. 352 */ 353 scpsys->dev->of_node = node; 354 pd->supply = devm_regulator_get(scpsys->dev, "domain"); 355 scpsys->dev->of_node = root_node; 356 if (IS_ERR(pd->supply)) { 357 dev_err_probe(scpsys->dev, PTR_ERR(pd->supply), 358 "%pOF: failed to get power supply.\n", 359 node); 360 return ERR_CAST(pd->supply); 361 } 362 } 363 364 pd->infracfg = syscon_regmap_lookup_by_phandle_optional(node, "mediatek,infracfg"); 365 if (IS_ERR(pd->infracfg)) 366 return ERR_CAST(pd->infracfg); 367 368 smi_node = of_parse_phandle(node, "mediatek,smi", 0); 369 if (smi_node) { 370 pd->smi = device_node_to_regmap(smi_node); 371 of_node_put(smi_node); 372 if (IS_ERR(pd->smi)) 373 return ERR_CAST(pd->smi); 374 } 375 376 num_clks = of_clk_get_parent_count(node); 377 if (num_clks > 0) { 378 /* Calculate number of subsys_clks */ 379 of_property_for_each_string(node, "clock-names", prop, clk_name) { 380 char *subsys; 381 382 subsys = strchr(clk_name, '-'); 383 if (subsys) 384 pd->num_subsys_clks++; 385 else 386 pd->num_clks++; 387 } 388 389 pd->clks = devm_kcalloc(scpsys->dev, pd->num_clks, sizeof(*pd->clks), GFP_KERNEL); 390 if (!pd->clks) 391 return ERR_PTR(-ENOMEM); 392 393 pd->subsys_clks = devm_kcalloc(scpsys->dev, pd->num_subsys_clks, 394 sizeof(*pd->subsys_clks), GFP_KERNEL); 395 if (!pd->subsys_clks) 396 return ERR_PTR(-ENOMEM); 397 398 } 399 400 for (i = 0; i < pd->num_clks; i++) { 401 clk = of_clk_get(node, i); 402 if (IS_ERR(clk)) { 403 ret = PTR_ERR(clk); 404 dev_err_probe(scpsys->dev, ret, 405 "%pOF: failed to get clk at index %d\n", node, i); 406 goto err_put_clocks; 407 } 408 409 pd->clks[clk_ind++].clk = clk; 410 } 411 412 for (i = 0; i < pd->num_subsys_clks; i++) { 413 clk = of_clk_get(node, i + clk_ind); 414 if (IS_ERR(clk)) { 415 ret = PTR_ERR(clk); 416 dev_err_probe(scpsys->dev, ret, 417 "%pOF: failed to get clk at index %d\n", node, 418 i + clk_ind); 419 goto err_put_subsys_clocks; 420 } 421 422 pd->subsys_clks[i].clk = clk; 423 } 424 425 /* 426 * Initially turn on all domains to make the domains usable 427 * with !CONFIG_PM and to get the hardware in sync with the 428 * software. The unused domains will be switched off during 429 * late_init time. 430 */ 431 if (MTK_SCPD_CAPS(pd, MTK_SCPD_KEEP_DEFAULT_OFF)) { 432 if (scpsys_domain_is_on(pd)) 433 dev_warn(scpsys->dev, 434 "%pOF: A default off power domain has been ON\n", node); 435 } else { 436 ret = scpsys_power_on(&pd->genpd); 437 if (ret < 0) { 438 dev_err(scpsys->dev, "%pOF: failed to power on domain: %d\n", node, ret); 439 goto err_put_subsys_clocks; 440 } 441 442 if (MTK_SCPD_CAPS(pd, MTK_SCPD_ALWAYS_ON)) 443 pd->genpd.flags |= GENPD_FLAG_ALWAYS_ON; 444 } 445 446 if (scpsys->domains[id]) { 447 ret = -EINVAL; 448 dev_err(scpsys->dev, 449 "power domain with id %d already exists, check your device-tree\n", id); 450 goto err_put_subsys_clocks; 451 } 452 453 if (!pd->data->name) 454 pd->genpd.name = node->name; 455 else 456 pd->genpd.name = pd->data->name; 457 458 pd->genpd.power_off = scpsys_power_off; 459 pd->genpd.power_on = scpsys_power_on; 460 461 if (MTK_SCPD_CAPS(pd, MTK_SCPD_ACTIVE_WAKEUP)) 462 pd->genpd.flags |= GENPD_FLAG_ACTIVE_WAKEUP; 463 464 if (MTK_SCPD_CAPS(pd, MTK_SCPD_KEEP_DEFAULT_OFF)) 465 pm_genpd_init(&pd->genpd, NULL, true); 466 else 467 pm_genpd_init(&pd->genpd, NULL, false); 468 469 scpsys->domains[id] = &pd->genpd; 470 471 return scpsys->pd_data.domains[id]; 472 473err_put_subsys_clocks: 474 clk_bulk_put(pd->num_subsys_clks, pd->subsys_clks); 475err_put_clocks: 476 clk_bulk_put(pd->num_clks, pd->clks); 477 return ERR_PTR(ret); 478} 479 480static int scpsys_add_subdomain(struct scpsys *scpsys, struct device_node *parent) 481{ 482 struct generic_pm_domain *child_pd, *parent_pd; 483 struct device_node *child; 484 int ret; 485 486 for_each_child_of_node(parent, child) { 487 u32 id; 488 489 ret = of_property_read_u32(parent, "reg", &id); 490 if (ret) { 491 dev_err(scpsys->dev, "%pOF: failed to get parent domain id\n", child); 492 goto err_put_node; 493 } 494 495 if (!scpsys->pd_data.domains[id]) { 496 ret = -EINVAL; 497 dev_err(scpsys->dev, "power domain with id %d does not exist\n", id); 498 goto err_put_node; 499 } 500 501 parent_pd = scpsys->pd_data.domains[id]; 502 503 child_pd = scpsys_add_one_domain(scpsys, child); 504 if (IS_ERR(child_pd)) { 505 ret = PTR_ERR(child_pd); 506 dev_err_probe(scpsys->dev, ret, "%pOF: failed to get child domain id\n", 507 child); 508 goto err_put_node; 509 } 510 511 /* recursive call to add all subdomains */ 512 ret = scpsys_add_subdomain(scpsys, child); 513 if (ret) 514 goto err_put_node; 515 516 ret = pm_genpd_add_subdomain(parent_pd, child_pd); 517 if (ret) { 518 dev_err(scpsys->dev, "failed to add %s subdomain to parent %s\n", 519 child_pd->name, parent_pd->name); 520 goto err_put_node; 521 } else { 522 dev_dbg(scpsys->dev, "%s add subdomain: %s\n", parent_pd->name, 523 child_pd->name); 524 } 525 } 526 527 return 0; 528 529err_put_node: 530 of_node_put(child); 531 return ret; 532} 533 534static void scpsys_remove_one_domain(struct scpsys_domain *pd) 535{ 536 int ret; 537 538 /* 539 * We're in the error cleanup already, so we only complain, 540 * but won't emit another error on top of the original one. 541 */ 542 ret = pm_genpd_remove(&pd->genpd); 543 if (ret < 0) 544 dev_err(pd->scpsys->dev, 545 "failed to remove domain '%s' : %d - state may be inconsistent\n", 546 pd->genpd.name, ret); 547 if (scpsys_domain_is_on(pd)) 548 scpsys_power_off(&pd->genpd); 549 550 clk_bulk_put(pd->num_clks, pd->clks); 551 clk_bulk_put(pd->num_subsys_clks, pd->subsys_clks); 552} 553 554static void scpsys_domain_cleanup(struct scpsys *scpsys) 555{ 556 struct generic_pm_domain *genpd; 557 struct scpsys_domain *pd; 558 int i; 559 560 for (i = scpsys->pd_data.num_domains - 1; i >= 0; i--) { 561 genpd = scpsys->pd_data.domains[i]; 562 if (genpd) { 563 pd = to_scpsys_domain(genpd); 564 scpsys_remove_one_domain(pd); 565 } 566 } 567} 568 569static const struct of_device_id scpsys_of_match[] = { 570 { 571 .compatible = "mediatek,mt6795-power-controller", 572 .data = &mt6795_scpsys_data, 573 }, 574 { 575 .compatible = "mediatek,mt8167-power-controller", 576 .data = &mt8167_scpsys_data, 577 }, 578 { 579 .compatible = "mediatek,mt8173-power-controller", 580 .data = &mt8173_scpsys_data, 581 }, 582 { 583 .compatible = "mediatek,mt8183-power-controller", 584 .data = &mt8183_scpsys_data, 585 }, 586 { 587 .compatible = "mediatek,mt8186-power-controller", 588 .data = &mt8186_scpsys_data, 589 }, 590 { 591 .compatible = "mediatek,mt8188-power-controller", 592 .data = &mt8188_scpsys_data, 593 }, 594 { 595 .compatible = "mediatek,mt8192-power-controller", 596 .data = &mt8192_scpsys_data, 597 }, 598 { 599 .compatible = "mediatek,mt8195-power-controller", 600 .data = &mt8195_scpsys_data, 601 }, 602 { } 603}; 604 605static int scpsys_probe(struct platform_device *pdev) 606{ 607 struct device *dev = &pdev->dev; 608 struct device_node *np = dev->of_node; 609 const struct scpsys_soc_data *soc; 610 struct device_node *node; 611 struct device *parent; 612 struct scpsys *scpsys; 613 int ret; 614 615 soc = of_device_get_match_data(&pdev->dev); 616 if (!soc) { 617 dev_err(&pdev->dev, "no power controller data\n"); 618 return -EINVAL; 619 } 620 621 scpsys = devm_kzalloc(dev, struct_size(scpsys, domains, soc->num_domains), GFP_KERNEL); 622 if (!scpsys) 623 return -ENOMEM; 624 625 scpsys->dev = dev; 626 scpsys->soc_data = soc; 627 628 scpsys->pd_data.domains = scpsys->domains; 629 scpsys->pd_data.num_domains = soc->num_domains; 630 631 parent = dev->parent; 632 if (!parent) { 633 dev_err(dev, "no parent for syscon devices\n"); 634 return -ENODEV; 635 } 636 637 scpsys->base = syscon_node_to_regmap(parent->of_node); 638 if (IS_ERR(scpsys->base)) { 639 dev_err(dev, "no regmap available\n"); 640 return PTR_ERR(scpsys->base); 641 } 642 643 ret = -ENODEV; 644 for_each_available_child_of_node(np, node) { 645 struct generic_pm_domain *domain; 646 647 domain = scpsys_add_one_domain(scpsys, node); 648 if (IS_ERR(domain)) { 649 ret = PTR_ERR(domain); 650 of_node_put(node); 651 goto err_cleanup_domains; 652 } 653 654 ret = scpsys_add_subdomain(scpsys, node); 655 if (ret) { 656 of_node_put(node); 657 goto err_cleanup_domains; 658 } 659 } 660 661 if (ret) { 662 dev_dbg(dev, "no power domains present\n"); 663 return ret; 664 } 665 666 ret = of_genpd_add_provider_onecell(np, &scpsys->pd_data); 667 if (ret) { 668 dev_err(dev, "failed to add provider: %d\n", ret); 669 goto err_cleanup_domains; 670 } 671 672 return 0; 673 674err_cleanup_domains: 675 scpsys_domain_cleanup(scpsys); 676 return ret; 677} 678 679static struct platform_driver scpsys_pm_domain_driver = { 680 .probe = scpsys_probe, 681 .driver = { 682 .name = "mtk-power-controller", 683 .suppress_bind_attrs = true, 684 .of_match_table = scpsys_of_match, 685 }, 686}; 687builtin_platform_driver(scpsys_pm_domain_driver); 688