soc/mediatek/mtk-pm-domains.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2020 Collabora Ltd.
0004  */
0005 #include <linux/clk.h>
0006 #include <linux/clk-provider.h>
0007 #include <linux/init.h>
0008 #include <linux/io.h>
0009 #include <linux/iopoll.h>
0010 #include <linux/mfd/syscon.h>
0011 #include <linux/of_clk.h>
0012 #include <linux/of_device.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/pm_domain.h>
0015 #include <linux/regmap.h>
0016 #include <linux/regulator/consumer.h>
0017 #include <linux/soc/mediatek/infracfg.h>
0018
0019 #include "mt6795-pm-domains.h"
0020 #include "mt8167-pm-domains.h"
0021 #include "mt8173-pm-domains.h"
0022 #include "mt8183-pm-domains.h"
0023 #include "mt8186-pm-domains.h"
0024 #include "mt8192-pm-domains.h"
0025 #include "mt8195-pm-domains.h"
0026
0027 #define MTK_POLL_DELAY_US       10
0028 #define MTK_POLL_TIMEOUT        USEC_PER_SEC
0029
0030 #define PWR_RST_B_BIT           BIT(0)
0031 #define PWR_ISO_BIT         BIT(1)
0032 #define PWR_ON_BIT          BIT(2)
0033 #define PWR_ON_2ND_BIT          BIT(3)
0034 #define PWR_CLK_DIS_BIT         BIT(4)
0035 #define PWR_SRAM_CLKISO_BIT     BIT(5)
0036 #define PWR_SRAM_ISOINT_B_BIT       BIT(6)
0037
0038 struct scpsys_domain {
0039     struct generic_pm_domain genpd;
0040     const struct scpsys_domain_data *data;
0041     struct scpsys *scpsys;
0042     int num_clks;
0043     struct clk_bulk_data *clks;
0044     int num_subsys_clks;
0045     struct clk_bulk_data *subsys_clks;
0046     struct regmap *infracfg;
0047     struct regmap *smi;
0048     struct regulator *supply;
0049 };
0050
0051 struct scpsys {
0052     struct device *dev;
0053     struct regmap *base;
0054     const struct scpsys_soc_data *soc_data;
0055     struct genpd_onecell_data pd_data;
0056     struct generic_pm_domain *domains[];
0057 };
0058
0059 #define to_scpsys_domain(gpd) container_of(gpd, struct scpsys_domain, genpd)
0060
0061 static bool scpsys_domain_is_on(struct scpsys_domain *pd)
0062 {
0063     struct scpsys *scpsys = pd->scpsys;
0064     u32 status, status2;
0065
0066     regmap_read(scpsys->base, pd->data->pwr_sta_offs, &status);
0067     status &= pd->data->sta_mask;
0068
0069     regmap_read(scpsys->base, pd->data->pwr_sta2nd_offs, &status2);
0070     status2 &= pd->data->sta_mask;
0071
0072     /* A domain is on when both status bits are set. */
0073     return status && status2;
0074 }
0075
0076 static int scpsys_sram_enable(struct scpsys_domain *pd)
0077 {
0078     u32 pdn_ack = pd->data->sram_pdn_ack_bits;
0079     struct scpsys *scpsys = pd->scpsys;
0080     unsigned int tmp;
0081     int ret;
0082
0083     regmap_clear_bits(scpsys->base, pd->data->ctl_offs, pd->data->sram_pdn_bits);
0084
0085     /* Either wait until SRAM_PDN_ACK all 1 or 0 */
0086     ret = regmap_read_poll_timeout(scpsys->base, pd->data->ctl_offs, tmp,
0087                        (tmp & pdn_ack) == 0, MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
0088     if (ret < 0)
0089         return ret;
0090
0091     if (MTK_SCPD_CAPS(pd, MTK_SCPD_SRAM_ISO)) {
0092         regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_ISOINT_B_BIT);
0093         udelay(1);
0094         regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_CLKISO_BIT);
0095     }
0096
0097     return 0;
0098 }
0099
0100 static int scpsys_sram_disable(struct scpsys_domain *pd)
0101 {
0102     u32 pdn_ack = pd->data->sram_pdn_ack_bits;
0103     struct scpsys *scpsys = pd->scpsys;
0104     unsigned int tmp;
0105
0106     if (MTK_SCPD_CAPS(pd, MTK_SCPD_SRAM_ISO)) {
0107         regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_CLKISO_BIT);
0108         udelay(1);
0109         regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_ISOINT_B_BIT);
0110     }
0111
0112     regmap_set_bits(scpsys->base, pd->data->ctl_offs, pd->data->sram_pdn_bits);
0113
0114     /* Either wait until SRAM_PDN_ACK all 1 or 0 */
0115     return regmap_read_poll_timeout(scpsys->base, pd->data->ctl_offs, tmp,
0116                     (tmp & pdn_ack) == pdn_ack, MTK_POLL_DELAY_US,
0117                     MTK_POLL_TIMEOUT);
0118 }
0119
0120 static int _scpsys_bus_protect_enable(const struct scpsys_bus_prot_data *bpd, struct regmap *regmap)
0121 {
0122     int i, ret;
0123
0124     for (i = 0; i < SPM_MAX_BUS_PROT_DATA; i++) {
0125         u32 val, mask = bpd[i].bus_prot_mask;
0126
0127         if (!mask)
0128             break;
0129
0130         if (bpd[i].bus_prot_reg_update)
0131             regmap_set_bits(regmap, bpd[i].bus_prot_set, mask);
0132         else
0133             regmap_write(regmap, bpd[i].bus_prot_set, mask);
0134
0135         ret = regmap_read_poll_timeout(regmap, bpd[i].bus_prot_sta,
0136                            val, (val & mask) == mask,
0137                            MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
0138         if (ret)
0139             return ret;
0140     }
0141
0142     return 0;
0143 }
0144
0145 static int scpsys_bus_protect_enable(struct scpsys_domain *pd)
0146 {
0147     int ret;
0148
0149     ret = _scpsys_bus_protect_enable(pd->data->bp_infracfg, pd->infracfg);
0150     if (ret)
0151         return ret;
0152
0153     return _scpsys_bus_protect_enable(pd->data->bp_smi, pd->smi);
0154 }
0155
0156 static int _scpsys_bus_protect_disable(const struct scpsys_bus_prot_data *bpd,
0157                        struct regmap *regmap)
0158 {
0159     int i, ret;
0160
0161     for (i = SPM_MAX_BUS_PROT_DATA - 1; i >= 0; i--) {
0162         u32 val, mask = bpd[i].bus_prot_mask;
0163
0164         if (!mask)
0165             continue;
0166
0167         if (bpd[i].bus_prot_reg_update)
0168             regmap_clear_bits(regmap, bpd[i].bus_prot_clr, mask);
0169         else
0170             regmap_write(regmap, bpd[i].bus_prot_clr, mask);
0171
0172         if (bpd[i].ignore_clr_ack)
0173             continue;
0174
0175         ret = regmap_read_poll_timeout(regmap, bpd[i].bus_prot_sta,
0176                            val, !(val & mask),
0177                            MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
0178         if (ret)
0179             return ret;
0180     }
0181
0182     return 0;
0183 }
0184
0185 static int scpsys_bus_protect_disable(struct scpsys_domain *pd)
0186 {
0187     int ret;
0188
0189     ret = _scpsys_bus_protect_disable(pd->data->bp_smi, pd->smi);
0190     if (ret)
0191         return ret;
0192
0193     return _scpsys_bus_protect_disable(pd->data->bp_infracfg, pd->infracfg);
0194 }
0195
0196 static int scpsys_regulator_enable(struct regulator *supply)
0197 {
0198     return supply ? regulator_enable(supply) : 0;
0199 }
0200
0201 static int scpsys_regulator_disable(struct regulator *supply)
0202 {
0203     return supply ? regulator_disable(supply) : 0;
0204 }
0205
0206 static int scpsys_power_on(struct generic_pm_domain *genpd)
0207 {
0208     struct scpsys_domain *pd = container_of(genpd, struct scpsys_domain, genpd);
0209     struct scpsys *scpsys = pd->scpsys;
0210     bool tmp;
0211     int ret;
0212
0213     ret = scpsys_regulator_enable(pd->supply);
0214     if (ret)
0215         return ret;
0216
0217     ret = clk_bulk_prepare_enable(pd->num_clks, pd->clks);
0218     if (ret)
0219         goto err_reg;
0220
0221     /* subsys power on */
0222     regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_BIT);
0223     regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_2ND_BIT);
0224
0225     /* wait until PWR_ACK = 1 */
0226     ret = readx_poll_timeout(scpsys_domain_is_on, pd, tmp, tmp, MTK_POLL_DELAY_US,
0227                  MTK_POLL_TIMEOUT);
0228     if (ret < 0)
0229         goto err_pwr_ack;
0230
0231     regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_CLK_DIS_BIT);
0232     regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ISO_BIT);
0233     regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_RST_B_BIT);
0234
0235     ret = clk_bulk_prepare_enable(pd->num_subsys_clks, pd->subsys_clks);
0236     if (ret)
0237         goto err_pwr_ack;
0238
0239     ret = scpsys_sram_enable(pd);
0240     if (ret < 0)
0241         goto err_disable_subsys_clks;
0242
0243     ret = scpsys_bus_protect_disable(pd);
0244     if (ret < 0)
0245         goto err_disable_sram;
0246
0247     return 0;
0248
0249 err_disable_sram:
0250     scpsys_sram_disable(pd);
0251 err_disable_subsys_clks:
0252     clk_bulk_disable_unprepare(pd->num_subsys_clks, pd->subsys_clks);
0253 err_pwr_ack:
0254     clk_bulk_disable_unprepare(pd->num_clks, pd->clks);
0255 err_reg:
0256     scpsys_regulator_disable(pd->supply);
0257     return ret;
0258 }
0259
0260 static int scpsys_power_off(struct generic_pm_domain *genpd)
0261 {
0262     struct scpsys_domain *pd = container_of(genpd, struct scpsys_domain, genpd);
0263     struct scpsys *scpsys = pd->scpsys;
0264     bool tmp;
0265     int ret;
0266
0267     ret = scpsys_bus_protect_enable(pd);
0268     if (ret < 0)
0269         return ret;
0270
0271     ret = scpsys_sram_disable(pd);
0272     if (ret < 0)
0273         return ret;
0274
0275     clk_bulk_disable_unprepare(pd->num_subsys_clks, pd->subsys_clks);
0276
0277     /* subsys power off */
0278     regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_RST_B_BIT);
0279     regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ISO_BIT);
0280     regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_CLK_DIS_BIT);
0281     regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_2ND_BIT);
0282     regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_BIT);
0283
0284     /* wait until PWR_ACK = 0 */
0285     ret = readx_poll_timeout(scpsys_domain_is_on, pd, tmp, !tmp, MTK_POLL_DELAY_US,
0286                  MTK_POLL_TIMEOUT);
0287     if (ret < 0)
0288         return ret;
0289
0290     clk_bulk_disable_unprepare(pd->num_clks, pd->clks);
0291
0292     scpsys_regulator_disable(pd->supply);
0293
0294     return 0;
0295 }
0296
0297 static struct
0298 generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_node *node)
0299 {
0300     const struct scpsys_domain_data *domain_data;
0301     struct scpsys_domain *pd;
0302     struct device_node *root_node = scpsys->dev->of_node;
0303     struct device_node *smi_node;
0304     struct property *prop;
0305     const char *clk_name;
0306     int i, ret, num_clks;
0307     struct clk *clk;
0308     int clk_ind = 0;
0309     u32 id;
0310
0311     ret = of_property_read_u32(node, "reg", &id);
0312     if (ret) {
0313         dev_err(scpsys->dev, "%pOF: failed to retrieve domain id from reg: %d\n",
0314             node, ret);
0315         return ERR_PTR(-EINVAL);
0316     }
0317
0318     if (id >= scpsys->soc_data->num_domains) {
0319         dev_err(scpsys->dev, "%pOF: invalid domain id %d\n", node, id);
0320         return ERR_PTR(-EINVAL);
0321     }
0322
0323     domain_data = &scpsys->soc_data->domains_data[id];
0324     if (domain_data->sta_mask == 0) {
0325         dev_err(scpsys->dev, "%pOF: undefined domain id %d\n", node, id);
0326         return ERR_PTR(-EINVAL);
0327     }
0328
0329     pd = devm_kzalloc(scpsys->dev, sizeof(*pd), GFP_KERNEL);
0330     if (!pd)
0331         return ERR_PTR(-ENOMEM);
0332
0333     pd->data = domain_data;
0334     pd->scpsys = scpsys;
0335
0336     if (MTK_SCPD_CAPS(pd, MTK_SCPD_DOMAIN_SUPPLY)) {
0337         /*
0338          * Find regulator in current power domain node.
0339          * devm_regulator_get() finds regulator in a node and its child
0340          * node, so set of_node to current power domain node then change
0341          * back to original node after regulator is found for current
0342          * power domain node.
0343          */
0344         scpsys->dev->of_node = node;
0345         pd->supply = devm_regulator_get(scpsys->dev, "domain");
0346         scpsys->dev->of_node = root_node;
0347         if (IS_ERR(pd->supply)) {
0348             dev_err_probe(scpsys->dev, PTR_ERR(pd->supply),
0349                       "%pOF: failed to get power supply.\n",
0350                       node);
0351             return ERR_CAST(pd->supply);
0352         }
0353     }
0354
0355     pd->infracfg = syscon_regmap_lookup_by_phandle_optional(node, "mediatek,infracfg");
0356     if (IS_ERR(pd->infracfg))
0357         return ERR_CAST(pd->infracfg);
0358
0359     smi_node = of_parse_phandle(node, "mediatek,smi", 0);
0360     if (smi_node) {
0361         pd->smi = device_node_to_regmap(smi_node);
0362         of_node_put(smi_node);
0363         if (IS_ERR(pd->smi))
0364             return ERR_CAST(pd->smi);
0365     }
0366
0367     num_clks = of_clk_get_parent_count(node);
0368     if (num_clks > 0) {
0369         /* Calculate number of subsys_clks */
0370         of_property_for_each_string(node, "clock-names", prop, clk_name) {
0371             char *subsys;
0372
0373             subsys = strchr(clk_name, '-');
0374             if (subsys)
0375                 pd->num_subsys_clks++;
0376             else
0377                 pd->num_clks++;
0378         }
0379
0380         pd->clks = devm_kcalloc(scpsys->dev, pd->num_clks, sizeof(*pd->clks), GFP_KERNEL);
0381         if (!pd->clks)
0382             return ERR_PTR(-ENOMEM);
0383
0384         pd->subsys_clks = devm_kcalloc(scpsys->dev, pd->num_subsys_clks,
0385                            sizeof(*pd->subsys_clks), GFP_KERNEL);
0386         if (!pd->subsys_clks)
0387             return ERR_PTR(-ENOMEM);
0388
0389     }
0390
0391     for (i = 0; i < pd->num_clks; i++) {
0392         clk = of_clk_get(node, i);
0393         if (IS_ERR(clk)) {
0394             ret = PTR_ERR(clk);
0395             dev_err_probe(scpsys->dev, ret,
0396                       "%pOF: failed to get clk at index %d: %d\n", node, i, ret);
0397             goto err_put_clocks;
0398         }
0399
0400         pd->clks[clk_ind++].clk = clk;
0401     }
0402
0403     for (i = 0; i < pd->num_subsys_clks; i++) {
0404         clk = of_clk_get(node, i + clk_ind);
0405         if (IS_ERR(clk)) {
0406             ret = PTR_ERR(clk);
0407             dev_err_probe(scpsys->dev, ret,
0408                       "%pOF: failed to get clk at index %d: %d\n", node,
0409                       i + clk_ind, ret);
0410             goto err_put_subsys_clocks;
0411         }
0412
0413         pd->subsys_clks[i].clk = clk;
0414     }
0415
0416     /*
0417      * Initially turn on all domains to make the domains usable
0418      * with !CONFIG_PM and to get the hardware in sync with the
0419      * software.  The unused domains will be switched off during
0420      * late_init time.
0421      */
0422     if (MTK_SCPD_CAPS(pd, MTK_SCPD_KEEP_DEFAULT_OFF)) {
0423         if (scpsys_domain_is_on(pd))
0424             dev_warn(scpsys->dev,
0425                  "%pOF: A default off power domain has been ON\n", node);
0426     } else {
0427         ret = scpsys_power_on(&pd->genpd);
0428         if (ret < 0) {
0429             dev_err(scpsys->dev, "%pOF: failed to power on domain: %d\n", node, ret);
0430             goto err_put_subsys_clocks;
0431         }
0432
0433         if (MTK_SCPD_CAPS(pd, MTK_SCPD_ALWAYS_ON))
0434             pd->genpd.flags |= GENPD_FLAG_ALWAYS_ON;
0435     }
0436
0437     if (scpsys->domains[id]) {
0438         ret = -EINVAL;
0439         dev_err(scpsys->dev,
0440             "power domain with id %d already exists, check your device-tree\n", id);
0441         goto err_put_subsys_clocks;
0442     }
0443
0444     if (!pd->data->name)
0445         pd->genpd.name = node->name;
0446     else
0447         pd->genpd.name = pd->data->name;
0448
0449     pd->genpd.power_off = scpsys_power_off;
0450     pd->genpd.power_on = scpsys_power_on;
0451
0452     if (MTK_SCPD_CAPS(pd, MTK_SCPD_ACTIVE_WAKEUP))
0453         pd->genpd.flags |= GENPD_FLAG_ACTIVE_WAKEUP;
0454
0455     if (MTK_SCPD_CAPS(pd, MTK_SCPD_KEEP_DEFAULT_OFF))
0456         pm_genpd_init(&pd->genpd, NULL, true);
0457     else
0458         pm_genpd_init(&pd->genpd, NULL, false);
0459
0460     scpsys->domains[id] = &pd->genpd;
0461
0462     return scpsys->pd_data.domains[id];
0463
0464 err_put_subsys_clocks:
0465     clk_bulk_put(pd->num_subsys_clks, pd->subsys_clks);
0466 err_put_clocks:
0467     clk_bulk_put(pd->num_clks, pd->clks);
0468     return ERR_PTR(ret);
0469 }
0470
0471 static int scpsys_add_subdomain(struct scpsys *scpsys, struct device_node *parent)
0472 {
0473     struct generic_pm_domain *child_pd, *parent_pd;
0474     struct device_node *child;
0475     int ret;
0476
0477     for_each_child_of_node(parent, child) {
0478         u32 id;
0479
0480         ret = of_property_read_u32(parent, "reg", &id);
0481         if (ret) {
0482             dev_err(scpsys->dev, "%pOF: failed to get parent domain id\n", child);
0483             goto err_put_node;
0484         }
0485
0486         if (!scpsys->pd_data.domains[id]) {
0487             ret = -EINVAL;
0488             dev_err(scpsys->dev, "power domain with id %d does not exist\n", id);
0489             goto err_put_node;
0490         }
0491
0492         parent_pd = scpsys->pd_data.domains[id];
0493
0494         child_pd = scpsys_add_one_domain(scpsys, child);
0495         if (IS_ERR(child_pd)) {
0496             ret = PTR_ERR(child_pd);
0497             dev_err_probe(scpsys->dev, ret, "%pOF: failed to get child domain id\n",
0498                       child);
0499             goto err_put_node;
0500         }
0501
0502         ret = pm_genpd_add_subdomain(parent_pd, child_pd);
0503         if (ret) {
0504             dev_err(scpsys->dev, "failed to add %s subdomain to parent %s\n",
0505                 child_pd->name, parent_pd->name);
0506             goto err_put_node;
0507         } else {
0508             dev_dbg(scpsys->dev, "%s add subdomain: %s\n", parent_pd->name,
0509                 child_pd->name);
0510         }
0511
0512         /* recursive call to add all subdomains */
0513         ret = scpsys_add_subdomain(scpsys, child);
0514         if (ret)
0515             goto err_put_node;
0516     }
0517
0518     return 0;
0519
0520 err_put_node:
0521     of_node_put(child);
0522     return ret;
0523 }
0524
0525 static void scpsys_remove_one_domain(struct scpsys_domain *pd)
0526 {
0527     int ret;
0528
0529     if (scpsys_domain_is_on(pd))
0530         scpsys_power_off(&pd->genpd);
0531
0532     /*
0533      * We're in the error cleanup already, so we only complain,
0534      * but won't emit another error on top of the original one.
0535      */
0536     ret = pm_genpd_remove(&pd->genpd);
0537     if (ret < 0)
0538         dev_err(pd->scpsys->dev,
0539             "failed to remove domain '%s' : %d - state may be inconsistent\n",
0540             pd->genpd.name, ret);
0541
0542     clk_bulk_put(pd->num_clks, pd->clks);
0543     clk_bulk_put(pd->num_subsys_clks, pd->subsys_clks);
0544 }
0545
0546 static void scpsys_domain_cleanup(struct scpsys *scpsys)
0547 {
0548     struct generic_pm_domain *genpd;
0549     struct scpsys_domain *pd;
0550     int i;
0551
0552     for (i = scpsys->pd_data.num_domains - 1; i >= 0; i--) {
0553         genpd = scpsys->pd_data.domains[i];
0554         if (genpd) {
0555             pd = to_scpsys_domain(genpd);
0556             scpsys_remove_one_domain(pd);
0557         }
0558     }
0559 }
0560
0561 static const struct of_device_id scpsys_of_match[] = {
0562     {
0563         .compatible = "mediatek,mt6795-power-controller",
0564         .data = &mt6795_scpsys_data,
0565     },
0566     {
0567         .compatible = "mediatek,mt8167-power-controller",
0568         .data = &mt8167_scpsys_data,
0569     },
0570     {
0571         .compatible = "mediatek,mt8173-power-controller",
0572         .data = &mt8173_scpsys_data,
0573     },
0574     {
0575         .compatible = "mediatek,mt8183-power-controller",
0576         .data = &mt8183_scpsys_data,
0577     },
0578     {
0579         .compatible = "mediatek,mt8186-power-controller",
0580         .data = &mt8186_scpsys_data,
0581     },
0582     {
0583         .compatible = "mediatek,mt8192-power-controller",
0584         .data = &mt8192_scpsys_data,
0585     },
0586     {
0587         .compatible = "mediatek,mt8195-power-controller",
0588         .data = &mt8195_scpsys_data,
0589     },
0590     { }
0591 };
0592
0593 static int scpsys_probe(struct platform_device *pdev)
0594 {
0595     struct device *dev = &pdev->dev;
0596     struct device_node *np = dev->of_node;
0597     const struct scpsys_soc_data *soc;
0598     struct device_node *node;
0599     struct device *parent;
0600     struct scpsys *scpsys;
0601     int ret;
0602
0603     soc = of_device_get_match_data(&pdev->dev);
0604     if (!soc) {
0605         dev_err(&pdev->dev, "no power controller data\n");
0606         return -EINVAL;
0607     }
0608
0609     scpsys = devm_kzalloc(dev, struct_size(scpsys, domains, soc->num_domains), GFP_KERNEL);
0610     if (!scpsys)
0611         return -ENOMEM;
0612
0613     scpsys->dev = dev;
0614     scpsys->soc_data = soc;
0615
0616     scpsys->pd_data.domains = scpsys->domains;
0617     scpsys->pd_data.num_domains = soc->num_domains;
0618
0619     parent = dev->parent;
0620     if (!parent) {
0621         dev_err(dev, "no parent for syscon devices\n");
0622         return -ENODEV;
0623     }
0624
0625     scpsys->base = syscon_node_to_regmap(parent->of_node);
0626     if (IS_ERR(scpsys->base)) {
0627         dev_err(dev, "no regmap available\n");
0628         return PTR_ERR(scpsys->base);
0629     }
0630
0631     ret = -ENODEV;
0632     for_each_available_child_of_node(np, node) {
0633         struct generic_pm_domain *domain;
0634
0635         domain = scpsys_add_one_domain(scpsys, node);
0636         if (IS_ERR(domain)) {
0637             ret = PTR_ERR(domain);
0638             of_node_put(node);
0639             goto err_cleanup_domains;
0640         }
0641
0642         ret = scpsys_add_subdomain(scpsys, node);
0643         if (ret) {
0644             of_node_put(node);
0645             goto err_cleanup_domains;
0646         }
0647     }
0648
0649     if (ret) {
0650         dev_dbg(dev, "no power domains present\n");
0651         return ret;
0652     }
0653
0654     ret = of_genpd_add_provider_onecell(np, &scpsys->pd_data);
0655     if (ret) {
0656         dev_err(dev, "failed to add provider: %d\n", ret);
0657         goto err_cleanup_domains;
0658     }
0659
0660     return 0;
0661
0662 err_cleanup_domains:
0663     scpsys_domain_cleanup(scpsys);
0664     return ret;
0665 }
0666
0667 static struct platform_driver scpsys_pm_domain_driver = {
0668     .probe = scpsys_probe,
0669     .driver = {
0670         .name = "mtk-power-controller",
0671         .suppress_bind_attrs = true,
0672         .of_match_table = scpsys_of_match,
0673     },
0674 };
0675 builtin_platform_driver(scpsys_pm_domain_driver);