mediatek/mtk-scpsys.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2015 Pengutronix, Sascha Hauer <kernel@pengutronix.de>
   4  */
   5 #include <linux/clk.h>
   6 #include <linux/init.h>
   7 #include <linux/io.h>
   8 #include <linux/iopoll.h>
   9 #include <linux/mfd/syscon.h>
  10 #include <linux/of_device.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/pm_domain.h>
  13 #include <linux/regulator/consumer.h>
  14 #include <linux/soc/mediatek/infracfg.h>
  15
  16 #include <dt-bindings/power/mt2701-power.h>
  17 #include <dt-bindings/power/mt2712-power.h>
  18 #include <dt-bindings/power/mt6797-power.h>
  19 #include <dt-bindings/power/mt7622-power.h>
  20 #include <dt-bindings/power/mt7623a-power.h>
  21 #include <dt-bindings/power/mt8173-power.h>
  22
  23 #define MTK_POLL_DELAY_US   10
  24 #define MTK_POLL_TIMEOUT    USEC_PER_SEC
  25
  26 #define MTK_SCPD_ACTIVE_WAKEUP          BIT(0)
  27 #define MTK_SCPD_FWAIT_SRAM             BIT(1)
  28 #define MTK_SCPD_CAPS(_scpd, _x)        ((_scpd)->data->caps & (_x))
  29
  30 #define SPM_VDE_PWR_CON                 0x0210
  31 #define SPM_MFG_PWR_CON                 0x0214
  32 #define SPM_VEN_PWR_CON                 0x0230
  33 #define SPM_ISP_PWR_CON                 0x0238
  34 #define SPM_DIS_PWR_CON                 0x023c
  35 #define SPM_CONN_PWR_CON                0x0280
  36 #define SPM_VEN2_PWR_CON                0x0298
  37 #define SPM_AUDIO_PWR_CON               0x029c  /* MT8173, MT2712 */
  38 #define SPM_BDP_PWR_CON                 0x029c  /* MT2701 */
  39 #define SPM_ETH_PWR_CON                 0x02a0
  40 #define SPM_HIF_PWR_CON                 0x02a4
  41 #define SPM_IFR_MSC_PWR_CON             0x02a8
  42 #define SPM_MFG_2D_PWR_CON              0x02c0
  43 #define SPM_MFG_ASYNC_PWR_CON           0x02c4
  44 #define SPM_USB_PWR_CON                 0x02cc
  45 #define SPM_USB2_PWR_CON                0x02d4  /* MT2712 */
  46 #define SPM_ETHSYS_PWR_CON              0x02e0  /* MT7622 */
  47 #define SPM_HIF0_PWR_CON                0x02e4  /* MT7622 */
  48 #define SPM_HIF1_PWR_CON                0x02e8  /* MT7622 */
  49 #define SPM_WB_PWR_CON                  0x02ec  /* MT7622 */
  50
  51 #define SPM_PWR_STATUS                  0x060c
  52 #define SPM_PWR_STATUS_2ND              0x0610
  53
  54 #define PWR_RST_B_BIT                   BIT(0)
  55 #define PWR_ISO_BIT                     BIT(1)
  56 #define PWR_ON_BIT                      BIT(2)
  57 #define PWR_ON_2ND_BIT                  BIT(3)
  58 #define PWR_CLK_DIS_BIT                 BIT(4)
  59
  60 #define PWR_STATUS_CONN                 BIT(1)
  61 #define PWR_STATUS_DISP                 BIT(3)
  62 #define PWR_STATUS_MFG                  BIT(4)
  63 #define PWR_STATUS_ISP                  BIT(5)
  64 #define PWR_STATUS_VDEC                 BIT(7)
  65 #define PWR_STATUS_BDP                  BIT(14)
  66 #define PWR_STATUS_ETH                  BIT(15)
  67 #define PWR_STATUS_HIF                  BIT(16)
  68 #define PWR_STATUS_IFR_MSC              BIT(17)
  69 #define PWR_STATUS_USB2                 BIT(19) /* MT2712 */
  70 #define PWR_STATUS_VENC_LT              BIT(20)
  71 #define PWR_STATUS_VENC                 BIT(21)
  72 #define PWR_STATUS_MFG_2D               BIT(22) /* MT8173 */
  73 #define PWR_STATUS_MFG_ASYNC            BIT(23) /* MT8173 */
  74 #define PWR_STATUS_AUDIO                BIT(24) /* MT8173, MT2712 */
  75 #define PWR_STATUS_USB                  BIT(25) /* MT8173, MT2712 */
  76 #define PWR_STATUS_ETHSYS               BIT(24) /* MT7622 */
  77 #define PWR_STATUS_HIF0                 BIT(25) /* MT7622 */
  78 #define PWR_STATUS_HIF1                 BIT(26) /* MT7622 */
  79 #define PWR_STATUS_WB                   BIT(27) /* MT7622 */
  80
  81 enum clk_id {
  82         CLK_NONE,
  83         CLK_MM,
  84         CLK_MFG,
  85         CLK_VENC,
  86         CLK_VENC_LT,
  87         CLK_ETHIF,
  88         CLK_VDEC,
  89         CLK_HIFSEL,
  90         CLK_JPGDEC,
  91         CLK_AUDIO,
  92         CLK_MAX,
  93 };
  94
  95 static const char * const clk_names[] = {
  96         NULL,
  97         "mm",
  98         "mfg",
  99         "venc",
 100         "venc_lt",
 101         "ethif",
 102         "vdec",
 103         "hif_sel",
 104         "jpgdec",
 105         "audio",
 106         NULL,
 107 };
 108
 109 #define MAX_CLKS        3
 110
 111 /**
 112  * struct scp_domain_data - scp domain data for power on/off flow
 113  * @name: The domain name.
 114  * @sta_mask: The mask for power on/off status bit.
 115  * @ctl_offs: The offset for main power control register.
 116  * @sram_pdn_bits: The mask for sram power control bits.
 117  * @sram_pdn_ack_bits: The mask for sram power control acked bits.
 118  * @bus_prot_mask: The mask for single step bus protection.
 119  * @clk_id: The basic clocks required by this power domain.
 120  * @caps: The flag for active wake-up action.
 121  */
 122 struct scp_domain_data {
 123         const char *name;
 124         u32 sta_mask;
 125         int ctl_offs;
 126         u32 sram_pdn_bits;
 127         u32 sram_pdn_ack_bits;
 128         u32 bus_prot_mask;
 129         enum clk_id clk_id[MAX_CLKS];
 130         u8 caps;
 131 };
 132
 133 struct scp;
 134
 135 struct scp_domain {
 136         struct generic_pm_domain genpd;
 137         struct scp *scp;
 138         struct clk *clk[MAX_CLKS];
 139         const struct scp_domain_data *data;
 140         struct regulator *supply;
 141 };
 142
 143 struct scp_ctrl_reg {
 144         int pwr_sta_offs;
 145         int pwr_sta2nd_offs;
 146 };
 147
 148 struct scp {
 149         struct scp_domain *domains;
 150         struct genpd_onecell_data pd_data;
 151         struct device *dev;
 152         void __iomem *base;
 153         struct regmap *infracfg;
 154         struct scp_ctrl_reg ctrl_reg;
 155         bool bus_prot_reg_update;
 156 };
 157
 158 struct scp_subdomain {
 159         int origin;
 160         int subdomain;
 161 };
 162
 163 struct scp_soc_data {
 164         const struct scp_domain_data *domains;
 165         int num_domains;
 166         const struct scp_subdomain *subdomains;
 167         int num_subdomains;
 168         const struct scp_ctrl_reg regs;
 169         bool bus_prot_reg_update;
 170 };
 171
 172 static int scpsys_domain_is_on(struct scp_domain *scpd)
 173 {
 174         struct scp *scp = scpd->scp;
 175
 176         u32 status = readl(scp->base + scp->ctrl_reg.pwr_sta_offs) &
 177                                                 scpd->data->sta_mask;
 178         u32 status2 = readl(scp->base + scp->ctrl_reg.pwr_sta2nd_offs) &
 179                                                 scpd->data->sta_mask;
 180
 181         /*
 182          * A domain is on when both status bits are set. If only one is set
 183          * return an error. This happens while powering up a domain
 184          */
 185
 186         if (status && status2)
 187                 return true;
 188         if (!status && !status2)
 189                 return false;
 190
 191         return -EINVAL;
 192 }
 193
 194 static int scpsys_regulator_enable(struct scp_domain *scpd)
 195 {
 196         if (!scpd->supply)
 197                 return 0;
 198
 199         return regulator_enable(scpd->supply);
 200 }
 201
 202 static int scpsys_regulator_disable(struct scp_domain *scpd)
 203 {
 204         if (!scpd->supply)
 205                 return 0;
 206
 207         return regulator_disable(scpd->supply);
 208 }
 209
 210 static void scpsys_clk_disable(struct clk *clk[], int max_num)
 211 {
 212         int i;
 213
 214         for (i = max_num - 1; i >= 0; i--)
 215                 clk_disable_unprepare(clk[i]);
 216 }
 217
 218 static int scpsys_clk_enable(struct clk *clk[], int max_num)
 219 {
 220         int i, ret = 0;
 221
 222         for (i = 0; i < max_num && clk[i]; i++) {
 223                 ret = clk_prepare_enable(clk[i]);
 224                 if (ret) {
 225                         scpsys_clk_disable(clk, i);
 226                         break;
 227                 }
 228         }
 229
 230         return ret;
 231 }
 232
 233 static int scpsys_sram_enable(struct scp_domain *scpd, void __iomem *ctl_addr)
 234 {
 235         u32 val;
 236         u32 pdn_ack = scpd->data->sram_pdn_ack_bits;
 237         int tmp;
 238
 239         val = readl(ctl_addr);
 240         val &= ~scpd->data->sram_pdn_bits;
 241         writel(val, ctl_addr);
 242
 243         /* Either wait until SRAM_PDN_ACK all 0 or have a force wait */
 244         if (MTK_SCPD_CAPS(scpd, MTK_SCPD_FWAIT_SRAM)) {
 245                 /*
 246                  * Currently, MTK_SCPD_FWAIT_SRAM is necessary only for
 247                  * MT7622_POWER_DOMAIN_WB and thus just a trivial setup
 248                  * is applied here.
 249                  */
 250                 usleep_range(12000, 12100);
 251         } else {
 252                 /* Either wait until SRAM_PDN_ACK all 1 or 0 */
 253                 int ret = readl_poll_timeout(ctl_addr, tmp,
 254                                 (tmp & pdn_ack) == 0,
 255                                 MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
 256                 if (ret < 0)
 257                         return ret;
 258         }
 259
 260         return 0;
 261 }
 262
 263 static int scpsys_sram_disable(struct scp_domain *scpd, void __iomem *ctl_addr)
 264 {
 265         u32 val;
 266         u32 pdn_ack = scpd->data->sram_pdn_ack_bits;
 267         int tmp;
 268
 269         val = readl(ctl_addr);
 270         val |= scpd->data->sram_pdn_bits;
 271         writel(val, ctl_addr);
 272
 273         /* Either wait until SRAM_PDN_ACK all 1 or 0 */
 274         return readl_poll_timeout(ctl_addr, tmp,
 275                         (tmp & pdn_ack) == pdn_ack,
 276                         MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
 277 }
 278
 279 static int scpsys_bus_protect_enable(struct scp_domain *scpd)
 280 {
 281         struct scp *scp = scpd->scp;
 282
 283         if (!scpd->data->bus_prot_mask)
 284                 return 0;
 285
 286         return mtk_infracfg_set_bus_protection(scp->infracfg,
 287                         scpd->data->bus_prot_mask,
 288                         scp->bus_prot_reg_update);
 289 }
 290
 291 static int scpsys_bus_protect_disable(struct scp_domain *scpd)
 292 {
 293         struct scp *scp = scpd->scp;
 294
 295         if (!scpd->data->bus_prot_mask)
 296                 return 0;
 297
 298         return mtk_infracfg_clear_bus_protection(scp->infracfg,
 299                         scpd->data->bus_prot_mask,
 300                         scp->bus_prot_reg_update);
 301 }
 302
 303 static int scpsys_power_on(struct generic_pm_domain *genpd)
 304 {
 305         struct scp_domain *scpd = container_of(genpd, struct scp_domain, genpd);
 306         struct scp *scp = scpd->scp;
 307         void __iomem *ctl_addr = scp->base + scpd->data->ctl_offs;
 308         u32 val;
 309         int ret, tmp;
 310
 311         ret = scpsys_regulator_enable(scpd);
 312         if (ret < 0)
 313                 return ret;
 314
 315         ret = scpsys_clk_enable(scpd->clk, MAX_CLKS);
 316         if (ret)
 317                 goto err_clk;
 318
 319         /* subsys power on */
 320         val = readl(ctl_addr);
 321         val |= PWR_ON_BIT;
 322         writel(val, ctl_addr);
 323         val |= PWR_ON_2ND_BIT;
 324         writel(val, ctl_addr);
 325
 326         /* wait until PWR_ACK = 1 */
 327         ret = readx_poll_timeout(scpsys_domain_is_on, scpd, tmp, tmp > 0,
 328                                  MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
 329         if (ret < 0)
 330                 goto err_pwr_ack;
 331
 332         val &= ~PWR_CLK_DIS_BIT;
 333         writel(val, ctl_addr);
 334
 335         val &= ~PWR_ISO_BIT;
 336         writel(val, ctl_addr);
 337
 338         val |= PWR_RST_B_BIT;
 339         writel(val, ctl_addr);
 340
 341         ret = scpsys_sram_enable(scpd, ctl_addr);
 342         if (ret < 0)
 343                 goto err_pwr_ack;
 344
 345         ret = scpsys_bus_protect_disable(scpd);
 346         if (ret < 0)
 347                 goto err_pwr_ack;
 348
 349         return 0;
 350
 351 err_pwr_ack:
 352         scpsys_clk_disable(scpd->clk, MAX_CLKS);
 353 err_clk:
 354         scpsys_regulator_disable(scpd);
 355
 356         dev_err(scp->dev, "Failed to power on domain %s\n", genpd->name);
 357
 358         return ret;
 359 }
 360
 361 static int scpsys_power_off(struct generic_pm_domain *genpd)
 362 {
 363         struct scp_domain *scpd = container_of(genpd, struct scp_domain, genpd);
 364         struct scp *scp = scpd->scp;
 365         void __iomem *ctl_addr = scp->base + scpd->data->ctl_offs;
 366         u32 val;
 367         int ret, tmp;
 368
 369         ret = scpsys_bus_protect_enable(scpd);
 370         if (ret < 0)
 371                 goto out;
 372
 373         ret = scpsys_sram_disable(scpd, ctl_addr);
 374         if (ret < 0)
 375                 goto out;
 376
 377         /* subsys power off */
 378         val = readl(ctl_addr);
 379         val |= PWR_ISO_BIT;
 380         writel(val, ctl_addr);
 381
 382         val &= ~PWR_RST_B_BIT;
 383         writel(val, ctl_addr);
 384
 385         val |= PWR_CLK_DIS_BIT;
 386         writel(val, ctl_addr);
 387
 388         val &= ~PWR_ON_BIT;
 389         writel(val, ctl_addr);
 390
 391         val &= ~PWR_ON_2ND_BIT;
 392         writel(val, ctl_addr);
 393
 394         /* wait until PWR_ACK = 0 */
 395         ret = readx_poll_timeout(scpsys_domain_is_on, scpd, tmp, tmp == 0,
 396                                  MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
 397         if (ret < 0)
 398                 goto out;
 399
 400         scpsys_clk_disable(scpd->clk, MAX_CLKS);
 401
 402         ret = scpsys_regulator_disable(scpd);
 403         if (ret < 0)
 404                 goto out;
 405
 406         return 0;
 407
 408 out:
 409         dev_err(scp->dev, "Failed to power off domain %s\n", genpd->name);
 410
 411         return ret;
 412 }
 413
 414 static void init_clks(struct platform_device *pdev, struct clk **clk)
 415 {
 416         int i;
 417
 418         for (i = CLK_NONE + 1; i < CLK_MAX; i++)
 419                 clk[i] = devm_clk_get(&pdev->dev, clk_names[i]);
 420 }
 421
 422 static struct scp *init_scp(struct platform_device *pdev,
 423                         const struct scp_domain_data *scp_domain_data, int num,
 424                         const struct scp_ctrl_reg *scp_ctrl_reg,
 425                         bool bus_prot_reg_update)
 426 {
 427         struct genpd_onecell_data *pd_data;
 428         struct resource *res;
 429         int i, j;
 430         struct scp *scp;
 431         struct clk *clk[CLK_MAX];
 432
 433         scp = devm_kzalloc(&pdev->dev, sizeof(*scp), GFP_KERNEL);
 434         if (!scp)
 435                 return ERR_PTR(-ENOMEM);
 436
 437         scp->ctrl_reg.pwr_sta_offs = scp_ctrl_reg->pwr_sta_offs;
 438         scp->ctrl_reg.pwr_sta2nd_offs = scp_ctrl_reg->pwr_sta2nd_offs;
 439
 440         scp->bus_prot_reg_update = bus_prot_reg_update;
 441
 442         scp->dev = &pdev->dev;
 443
 444         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 445         scp->base = devm_ioremap_resource(&pdev->dev, res);
 446         if (IS_ERR(scp->base))
 447                 return ERR_CAST(scp->base);
 448
 449         scp->domains = devm_kcalloc(&pdev->dev,
 450                                 num, sizeof(*scp->domains), GFP_KERNEL);
 451         if (!scp->domains)
 452                 return ERR_PTR(-ENOMEM);
 453
 454         pd_data = &scp->pd_data;
 455
 456         pd_data->domains = devm_kcalloc(&pdev->dev,
 457                         num, sizeof(*pd_data->domains), GFP_KERNEL);
 458         if (!pd_data->domains)
 459                 return ERR_PTR(-ENOMEM);
 460
 461         scp->infracfg = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
 462                         "infracfg");
 463         if (IS_ERR(scp->infracfg)) {
 464                 dev_err(&pdev->dev, "Cannot find infracfg controller: %ld\n",
 465                                 PTR_ERR(scp->infracfg));
 466                 return ERR_CAST(scp->infracfg);
 467         }
 468
 469         for (i = 0; i < num; i++) {
 470                 struct scp_domain *scpd = &scp->domains[i];
 471                 const struct scp_domain_data *data = &scp_domain_data[i];
 472
 473                 scpd->supply = devm_regulator_get_optional(&pdev->dev, data->name);
 474                 if (IS_ERR(scpd->supply)) {
 475                         if (PTR_ERR(scpd->supply) == -ENODEV)
 476                                 scpd->supply = NULL;
 477                         else
 478                                 return ERR_CAST(scpd->supply);
 479                 }
 480         }
 481
 482         pd_data->num_domains = num;
 483
 484         init_clks(pdev, clk);
 485
 486         for (i = 0; i < num; i++) {
 487                 struct scp_domain *scpd = &scp->domains[i];
 488                 struct generic_pm_domain *genpd = &scpd->genpd;
 489                 const struct scp_domain_data *data = &scp_domain_data[i];
 490
 491                 pd_data->domains[i] = genpd;
 492                 scpd->scp = scp;
 493
 494                 scpd->data = data;
 495
 496                 for (j = 0; j < MAX_CLKS && data->clk_id[j]; j++) {
 497                         struct clk *c = clk[data->clk_id[j]];
 498
 499                         if (IS_ERR(c)) {
 500                                 dev_err(&pdev->dev, "%s: clk unavailable\n",
 501                                         data->name);
 502                                 return ERR_CAST(c);
 503                         }
 504
 505                         scpd->clk[j] = c;
 506                 }
 507
 508                 genpd->name = data->name;
 509                 genpd->power_off = scpsys_power_off;
 510                 genpd->power_on = scpsys_power_on;
 511                 if (MTK_SCPD_CAPS(scpd, MTK_SCPD_ACTIVE_WAKEUP))
 512                         genpd->flags |= GENPD_FLAG_ACTIVE_WAKEUP;
 513         }
 514
 515         return scp;
 516 }
 517
 518 static void mtk_register_power_domains(struct platform_device *pdev,
 519                                 struct scp *scp, int num)
 520 {
 521         struct genpd_onecell_data *pd_data;
 522         int i, ret;
 523
 524         for (i = 0; i < num; i++) {
 525                 struct scp_domain *scpd = &scp->domains[i];
 526                 struct generic_pm_domain *genpd = &scpd->genpd;
 527                 bool on;
 528
 529                 /*
 530                  * Initially turn on all domains to make the domains usable
 531                  * with !CONFIG_PM and to get the hardware in sync with the
 532                  * software.  The unused domains will be switched off during
 533                  * late_init time.
 534                  */
 535                 on = !WARN_ON(genpd->power_on(genpd) < 0);
 536
 537                 pm_genpd_init(genpd, NULL, !on);
 538         }
 539
 540         /*
 541          * We are not allowed to fail here since there is no way to unregister
 542          * a power domain. Once registered above we have to keep the domains
 543          * valid.
 544          */
 545
 546         pd_data = &scp->pd_data;
 547
 548         ret = of_genpd_add_provider_onecell(pdev->dev.of_node, pd_data);
 549         if (ret)
 550                 dev_err(&pdev->dev, "Failed to add OF provider: %d\n", ret);
 551 }
 552
 553 /*
 554  * MT2701 power domain support
 555  */
 556
 557 static const struct scp_domain_data scp_domain_data_mt2701[] = {
 558         [MT2701_POWER_DOMAIN_CONN] = {
 559                 .name = "conn",
 560                 .sta_mask = PWR_STATUS_CONN,
 561                 .ctl_offs = SPM_CONN_PWR_CON,
 562                 .bus_prot_mask = MT2701_TOP_AXI_PROT_EN_CONN_M |
 563                                  MT2701_TOP_AXI_PROT_EN_CONN_S,
 564                 .clk_id = {CLK_NONE},
 565                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 566         },
 567         [MT2701_POWER_DOMAIN_DISP] = {
 568                 .name = "disp",
 569                 .sta_mask = PWR_STATUS_DISP,
 570                 .ctl_offs = SPM_DIS_PWR_CON,
 571                 .sram_pdn_bits = GENMASK(11, 8),
 572                 .clk_id = {CLK_MM},
 573                 .bus_prot_mask = MT2701_TOP_AXI_PROT_EN_MM_M0,
 574                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 575         },
 576         [MT2701_POWER_DOMAIN_MFG] = {
 577                 .name = "mfg",
 578                 .sta_mask = PWR_STATUS_MFG,
 579                 .ctl_offs = SPM_MFG_PWR_CON,
 580                 .sram_pdn_bits = GENMASK(11, 8),
 581                 .sram_pdn_ack_bits = GENMASK(12, 12),
 582                 .clk_id = {CLK_MFG},
 583                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 584         },
 585         [MT2701_POWER_DOMAIN_VDEC] = {
 586                 .name = "vdec",
 587                 .sta_mask = PWR_STATUS_VDEC,
 588                 .ctl_offs = SPM_VDE_PWR_CON,
 589                 .sram_pdn_bits = GENMASK(11, 8),
 590                 .sram_pdn_ack_bits = GENMASK(12, 12),
 591                 .clk_id = {CLK_MM},
 592                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 593         },
 594         [MT2701_POWER_DOMAIN_ISP] = {
 595                 .name = "isp",
 596                 .sta_mask = PWR_STATUS_ISP,
 597                 .ctl_offs = SPM_ISP_PWR_CON,
 598                 .sram_pdn_bits = GENMASK(11, 8),
 599                 .sram_pdn_ack_bits = GENMASK(13, 12),
 600                 .clk_id = {CLK_MM},
 601                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 602         },
 603         [MT2701_POWER_DOMAIN_BDP] = {
 604                 .name = "bdp",
 605                 .sta_mask = PWR_STATUS_BDP,
 606                 .ctl_offs = SPM_BDP_PWR_CON,
 607                 .sram_pdn_bits = GENMASK(11, 8),
 608                 .clk_id = {CLK_NONE},
 609                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 610         },
 611         [MT2701_POWER_DOMAIN_ETH] = {
 612                 .name = "eth",
 613                 .sta_mask = PWR_STATUS_ETH,
 614                 .ctl_offs = SPM_ETH_PWR_CON,
 615                 .sram_pdn_bits = GENMASK(11, 8),
 616                 .sram_pdn_ack_bits = GENMASK(15, 12),
 617                 .clk_id = {CLK_ETHIF},
 618                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 619         },
 620         [MT2701_POWER_DOMAIN_HIF] = {
 621                 .name = "hif",
 622                 .sta_mask = PWR_STATUS_HIF,
 623                 .ctl_offs = SPM_HIF_PWR_CON,
 624                 .sram_pdn_bits = GENMASK(11, 8),
 625                 .sram_pdn_ack_bits = GENMASK(15, 12),
 626                 .clk_id = {CLK_ETHIF},
 627                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 628         },
 629         [MT2701_POWER_DOMAIN_IFR_MSC] = {
 630                 .name = "ifr_msc",
 631                 .sta_mask = PWR_STATUS_IFR_MSC,
 632                 .ctl_offs = SPM_IFR_MSC_PWR_CON,
 633                 .clk_id = {CLK_NONE},
 634                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 635         },
 636 };
 637
 638 /*
 639  * MT2712 power domain support
 640  */
 641 static const struct scp_domain_data scp_domain_data_mt2712[] = {
 642         [MT2712_POWER_DOMAIN_MM] = {
 643                 .name = "mm",
 644                 .sta_mask = PWR_STATUS_DISP,
 645                 .ctl_offs = SPM_DIS_PWR_CON,
 646                 .sram_pdn_bits = GENMASK(8, 8),
 647                 .sram_pdn_ack_bits = GENMASK(12, 12),
 648                 .clk_id = {CLK_MM},
 649                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 650         },
 651         [MT2712_POWER_DOMAIN_VDEC] = {
 652                 .name = "vdec",
 653                 .sta_mask = PWR_STATUS_VDEC,
 654                 .ctl_offs = SPM_VDE_PWR_CON,
 655                 .sram_pdn_bits = GENMASK(8, 8),
 656                 .sram_pdn_ack_bits = GENMASK(12, 12),
 657                 .clk_id = {CLK_MM, CLK_VDEC},
 658                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 659         },
 660         [MT2712_POWER_DOMAIN_VENC] = {
 661                 .name = "venc",
 662                 .sta_mask = PWR_STATUS_VENC,
 663                 .ctl_offs = SPM_VEN_PWR_CON,
 664                 .sram_pdn_bits = GENMASK(11, 8),
 665                 .sram_pdn_ack_bits = GENMASK(15, 12),
 666                 .clk_id = {CLK_MM, CLK_VENC, CLK_JPGDEC},
 667                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 668         },
 669         [MT2712_POWER_DOMAIN_ISP] = {
 670                 .name = "isp",
 671                 .sta_mask = PWR_STATUS_ISP,
 672                 .ctl_offs = SPM_ISP_PWR_CON,
 673                 .sram_pdn_bits = GENMASK(11, 8),
 674                 .sram_pdn_ack_bits = GENMASK(13, 12),
 675                 .clk_id = {CLK_MM},
 676                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 677         },
 678         [MT2712_POWER_DOMAIN_AUDIO] = {
 679                 .name = "audio",
 680                 .sta_mask = PWR_STATUS_AUDIO,
 681                 .ctl_offs = SPM_AUDIO_PWR_CON,
 682                 .sram_pdn_bits = GENMASK(11, 8),
 683                 .sram_pdn_ack_bits = GENMASK(15, 12),
 684                 .clk_id = {CLK_AUDIO},
 685                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 686         },
 687         [MT2712_POWER_DOMAIN_USB] = {
 688                 .name = "usb",
 689                 .sta_mask = PWR_STATUS_USB,
 690                 .ctl_offs = SPM_USB_PWR_CON,
 691                 .sram_pdn_bits = GENMASK(10, 8),
 692                 .sram_pdn_ack_bits = GENMASK(14, 12),
 693                 .clk_id = {CLK_NONE},
 694                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 695         },
 696         [MT2712_POWER_DOMAIN_USB2] = {
 697                 .name = "usb2",
 698                 .sta_mask = PWR_STATUS_USB2,
 699                 .ctl_offs = SPM_USB2_PWR_CON,
 700                 .sram_pdn_bits = GENMASK(10, 8),
 701                 .sram_pdn_ack_bits = GENMASK(14, 12),
 702                 .clk_id = {CLK_NONE},
 703                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 704         },
 705         [MT2712_POWER_DOMAIN_MFG] = {
 706                 .name = "mfg",
 707                 .sta_mask = PWR_STATUS_MFG,
 708                 .ctl_offs = SPM_MFG_PWR_CON,
 709                 .sram_pdn_bits = GENMASK(8, 8),
 710                 .sram_pdn_ack_bits = GENMASK(16, 16),
 711                 .clk_id = {CLK_MFG},
 712                 .bus_prot_mask = BIT(14) | BIT(21) | BIT(23),
 713                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 714         },
 715         [MT2712_POWER_DOMAIN_MFG_SC1] = {
 716                 .name = "mfg_sc1",
 717                 .sta_mask = BIT(22),
 718                 .ctl_offs = 0x02c0,
 719                 .sram_pdn_bits = GENMASK(8, 8),
 720                 .sram_pdn_ack_bits = GENMASK(16, 16),
 721                 .clk_id = {CLK_NONE},
 722                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 723         },
 724         [MT2712_POWER_DOMAIN_MFG_SC2] = {
 725                 .name = "mfg_sc2",
 726                 .sta_mask = BIT(23),
 727                 .ctl_offs = 0x02c4,
 728                 .sram_pdn_bits = GENMASK(8, 8),
 729                 .sram_pdn_ack_bits = GENMASK(16, 16),
 730                 .clk_id = {CLK_NONE},
 731                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 732         },
 733         [MT2712_POWER_DOMAIN_MFG_SC3] = {
 734                 .name = "mfg_sc3",
 735                 .sta_mask = BIT(30),
 736                 .ctl_offs = 0x01f8,
 737                 .sram_pdn_bits = GENMASK(8, 8),
 738                 .sram_pdn_ack_bits = GENMASK(16, 16),
 739                 .clk_id = {CLK_NONE},
 740                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 741         },
 742 };
 743
 744 static const struct scp_subdomain scp_subdomain_mt2712[] = {
 745         {MT2712_POWER_DOMAIN_MM, MT2712_POWER_DOMAIN_VDEC},
 746         {MT2712_POWER_DOMAIN_MM, MT2712_POWER_DOMAIN_VENC},
 747         {MT2712_POWER_DOMAIN_MM, MT2712_POWER_DOMAIN_ISP},
 748         {MT2712_POWER_DOMAIN_MFG, MT2712_POWER_DOMAIN_MFG_SC1},
 749         {MT2712_POWER_DOMAIN_MFG_SC1, MT2712_POWER_DOMAIN_MFG_SC2},
 750         {MT2712_POWER_DOMAIN_MFG_SC2, MT2712_POWER_DOMAIN_MFG_SC3},
 751 };
 752
 753 /*
 754  * MT6797 power domain support
 755  */
 756
 757 static const struct scp_domain_data scp_domain_data_mt6797[] = {
 758         [MT6797_POWER_DOMAIN_VDEC] = {
 759                 .name = "vdec",
 760                 .sta_mask = BIT(7),
 761                 .ctl_offs = 0x300,
 762                 .sram_pdn_bits = GENMASK(8, 8),
 763                 .sram_pdn_ack_bits = GENMASK(12, 12),
 764                 .clk_id = {CLK_VDEC},
 765         },
 766         [MT6797_POWER_DOMAIN_VENC] = {
 767                 .name = "venc",
 768                 .sta_mask = BIT(21),
 769                 .ctl_offs = 0x304,
 770                 .sram_pdn_bits = GENMASK(11, 8),
 771                 .sram_pdn_ack_bits = GENMASK(15, 12),
 772                 .clk_id = {CLK_NONE},
 773         },
 774         [MT6797_POWER_DOMAIN_ISP] = {
 775                 .name = "isp",
 776                 .sta_mask = BIT(5),
 777                 .ctl_offs = 0x308,
 778                 .sram_pdn_bits = GENMASK(9, 8),
 779                 .sram_pdn_ack_bits = GENMASK(13, 12),
 780                 .clk_id = {CLK_NONE},
 781         },
 782         [MT6797_POWER_DOMAIN_MM] = {
 783                 .name = "mm",
 784                 .sta_mask = BIT(3),
 785                 .ctl_offs = 0x30C,
 786                 .sram_pdn_bits = GENMASK(8, 8),
 787                 .sram_pdn_ack_bits = GENMASK(12, 12),
 788                 .clk_id = {CLK_MM},
 789                 .bus_prot_mask = (BIT(1) | BIT(2)),
 790         },
 791         [MT6797_POWER_DOMAIN_AUDIO] = {
 792                 .name = "audio",
 793                 .sta_mask = BIT(24),
 794                 .ctl_offs = 0x314,
 795                 .sram_pdn_bits = GENMASK(11, 8),
 796                 .sram_pdn_ack_bits = GENMASK(15, 12),
 797                 .clk_id = {CLK_NONE},
 798         },
 799         [MT6797_POWER_DOMAIN_MFG_ASYNC] = {
 800                 .name = "mfg_async",
 801                 .sta_mask = BIT(13),
 802                 .ctl_offs = 0x334,
 803                 .sram_pdn_bits = 0,
 804                 .sram_pdn_ack_bits = 0,
 805                 .clk_id = {CLK_MFG},
 806         },
 807         [MT6797_POWER_DOMAIN_MJC] = {
 808                 .name = "mjc",
 809                 .sta_mask = BIT(20),
 810                 .ctl_offs = 0x310,
 811                 .sram_pdn_bits = GENMASK(8, 8),
 812                 .sram_pdn_ack_bits = GENMASK(12, 12),
 813                 .clk_id = {CLK_NONE},
 814         },
 815 };
 816
 817 #define SPM_PWR_STATUS_MT6797           0x0180
 818 #define SPM_PWR_STATUS_2ND_MT6797       0x0184
 819
 820 static const struct scp_subdomain scp_subdomain_mt6797[] = {
 821         {MT6797_POWER_DOMAIN_MM, MT6797_POWER_DOMAIN_VDEC},
 822         {MT6797_POWER_DOMAIN_MM, MT6797_POWER_DOMAIN_ISP},
 823         {MT6797_POWER_DOMAIN_MM, MT6797_POWER_DOMAIN_VENC},
 824         {MT6797_POWER_DOMAIN_MM, MT6797_POWER_DOMAIN_MJC},
 825 };
 826
 827 /*
 828  * MT7622 power domain support
 829  */
 830
 831 static const struct scp_domain_data scp_domain_data_mt7622[] = {
 832         [MT7622_POWER_DOMAIN_ETHSYS] = {
 833                 .name = "ethsys",
 834                 .sta_mask = PWR_STATUS_ETHSYS,
 835                 .ctl_offs = SPM_ETHSYS_PWR_CON,
 836                 .sram_pdn_bits = GENMASK(11, 8),
 837                 .sram_pdn_ack_bits = GENMASK(15, 12),
 838                 .clk_id = {CLK_NONE},
 839                 .bus_prot_mask = MT7622_TOP_AXI_PROT_EN_ETHSYS,
 840                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 841         },
 842         [MT7622_POWER_DOMAIN_HIF0] = {
 843                 .name = "hif0",
 844                 .sta_mask = PWR_STATUS_HIF0,
 845                 .ctl_offs = SPM_HIF0_PWR_CON,
 846                 .sram_pdn_bits = GENMASK(11, 8),
 847                 .sram_pdn_ack_bits = GENMASK(15, 12),
 848                 .clk_id = {CLK_HIFSEL},
 849                 .bus_prot_mask = MT7622_TOP_AXI_PROT_EN_HIF0,
 850                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 851         },
 852         [MT7622_POWER_DOMAIN_HIF1] = {
 853                 .name = "hif1",
 854                 .sta_mask = PWR_STATUS_HIF1,
 855                 .ctl_offs = SPM_HIF1_PWR_CON,
 856                 .sram_pdn_bits = GENMASK(11, 8),
 857                 .sram_pdn_ack_bits = GENMASK(15, 12),
 858                 .clk_id = {CLK_HIFSEL},
 859                 .bus_prot_mask = MT7622_TOP_AXI_PROT_EN_HIF1,
 860                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 861         },
 862         [MT7622_POWER_DOMAIN_WB] = {
 863                 .name = "wb",
 864                 .sta_mask = PWR_STATUS_WB,
 865                 .ctl_offs = SPM_WB_PWR_CON,
 866                 .sram_pdn_bits = 0,
 867                 .sram_pdn_ack_bits = 0,
 868                 .clk_id = {CLK_NONE},
 869                 .bus_prot_mask = MT7622_TOP_AXI_PROT_EN_WB,
 870                 .caps = MTK_SCPD_ACTIVE_WAKEUP | MTK_SCPD_FWAIT_SRAM,
 871         },
 872 };
 873
 874 /*
 875  * MT7623A power domain support
 876  */
 877
 878 static const struct scp_domain_data scp_domain_data_mt7623a[] = {
 879         [MT7623A_POWER_DOMAIN_CONN] = {
 880                 .name = "conn",
 881                 .sta_mask = PWR_STATUS_CONN,
 882                 .ctl_offs = SPM_CONN_PWR_CON,
 883                 .bus_prot_mask = MT2701_TOP_AXI_PROT_EN_CONN_M |
 884                                  MT2701_TOP_AXI_PROT_EN_CONN_S,
 885                 .clk_id = {CLK_NONE},
 886                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 887         },
 888         [MT7623A_POWER_DOMAIN_ETH] = {
 889                 .name = "eth",
 890                 .sta_mask = PWR_STATUS_ETH,
 891                 .ctl_offs = SPM_ETH_PWR_CON,
 892                 .sram_pdn_bits = GENMASK(11, 8),
 893                 .sram_pdn_ack_bits = GENMASK(15, 12),
 894                 .clk_id = {CLK_ETHIF},
 895                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 896         },
 897         [MT7623A_POWER_DOMAIN_HIF] = {
 898                 .name = "hif",
 899                 .sta_mask = PWR_STATUS_HIF,
 900                 .ctl_offs = SPM_HIF_PWR_CON,
 901                 .sram_pdn_bits = GENMASK(11, 8),
 902                 .sram_pdn_ack_bits = GENMASK(15, 12),
 903                 .clk_id = {CLK_ETHIF},
 904                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 905         },
 906         [MT7623A_POWER_DOMAIN_IFR_MSC] = {
 907                 .name = "ifr_msc",
 908                 .sta_mask = PWR_STATUS_IFR_MSC,
 909                 .ctl_offs = SPM_IFR_MSC_PWR_CON,
 910                 .clk_id = {CLK_NONE},
 911                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 912         },
 913 };
 914
 915 /*
 916  * MT8173 power domain support
 917  */
 918
 919 static const struct scp_domain_data scp_domain_data_mt8173[] = {
 920         [MT8173_POWER_DOMAIN_VDEC] = {
 921                 .name = "vdec",
 922                 .sta_mask = PWR_STATUS_VDEC,
 923                 .ctl_offs = SPM_VDE_PWR_CON,
 924                 .sram_pdn_bits = GENMASK(11, 8),
 925                 .sram_pdn_ack_bits = GENMASK(12, 12),
 926                 .clk_id = {CLK_MM},
 927         },
 928         [MT8173_POWER_DOMAIN_VENC] = {
 929                 .name = "venc",
 930                 .sta_mask = PWR_STATUS_VENC,
 931                 .ctl_offs = SPM_VEN_PWR_CON,
 932                 .sram_pdn_bits = GENMASK(11, 8),
 933                 .sram_pdn_ack_bits = GENMASK(15, 12),
 934                 .clk_id = {CLK_MM, CLK_VENC},
 935         },
 936         [MT8173_POWER_DOMAIN_ISP] = {
 937                 .name = "isp",
 938                 .sta_mask = PWR_STATUS_ISP,
 939                 .ctl_offs = SPM_ISP_PWR_CON,
 940                 .sram_pdn_bits = GENMASK(11, 8),
 941                 .sram_pdn_ack_bits = GENMASK(13, 12),
 942                 .clk_id = {CLK_MM},
 943         },
 944         [MT8173_POWER_DOMAIN_MM] = {
 945                 .name = "mm",
 946                 .sta_mask = PWR_STATUS_DISP,
 947                 .ctl_offs = SPM_DIS_PWR_CON,
 948                 .sram_pdn_bits = GENMASK(11, 8),
 949                 .sram_pdn_ack_bits = GENMASK(12, 12),
 950                 .clk_id = {CLK_MM},
 951                 .bus_prot_mask = MT8173_TOP_AXI_PROT_EN_MM_M0 |
 952                         MT8173_TOP_AXI_PROT_EN_MM_M1,
 953         },
 954         [MT8173_POWER_DOMAIN_VENC_LT] = {
 955                 .name = "venc_lt",
 956                 .sta_mask = PWR_STATUS_VENC_LT,
 957                 .ctl_offs = SPM_VEN2_PWR_CON,
 958                 .sram_pdn_bits = GENMASK(11, 8),
 959                 .sram_pdn_ack_bits = GENMASK(15, 12),
 960                 .clk_id = {CLK_MM, CLK_VENC_LT},
 961         },
 962         [MT8173_POWER_DOMAIN_AUDIO] = {
 963                 .name = "audio",
 964                 .sta_mask = PWR_STATUS_AUDIO,
 965                 .ctl_offs = SPM_AUDIO_PWR_CON,
 966                 .sram_pdn_bits = GENMASK(11, 8),
 967                 .sram_pdn_ack_bits = GENMASK(15, 12),
 968                 .clk_id = {CLK_NONE},
 969         },
 970         [MT8173_POWER_DOMAIN_USB] = {
 971                 .name = "usb",
 972                 .sta_mask = PWR_STATUS_USB,
 973                 .ctl_offs = SPM_USB_PWR_CON,
 974                 .sram_pdn_bits = GENMASK(11, 8),
 975                 .sram_pdn_ack_bits = GENMASK(15, 12),
 976                 .clk_id = {CLK_NONE},
 977                 .caps = MTK_SCPD_ACTIVE_WAKEUP,
 978         },
 979         [MT8173_POWER_DOMAIN_MFG_ASYNC] = {
 980                 .name = "mfg_async",
 981                 .sta_mask = PWR_STATUS_MFG_ASYNC,
 982                 .ctl_offs = SPM_MFG_ASYNC_PWR_CON,
 983                 .sram_pdn_bits = GENMASK(11, 8),
 984                 .sram_pdn_ack_bits = 0,
 985                 .clk_id = {CLK_MFG},
 986         },
 987         [MT8173_POWER_DOMAIN_MFG_2D] = {
 988                 .name = "mfg_2d",
 989                 .sta_mask = PWR_STATUS_MFG_2D,
 990                 .ctl_offs = SPM_MFG_2D_PWR_CON,
 991                 .sram_pdn_bits = GENMASK(11, 8),
 992                 .sram_pdn_ack_bits = GENMASK(13, 12),
 993                 .clk_id = {CLK_NONE},
 994         },
 995         [MT8173_POWER_DOMAIN_MFG] = {
 996                 .name = "mfg",
 997                 .sta_mask = PWR_STATUS_MFG,
 998                 .ctl_offs = SPM_MFG_PWR_CON,
 999                 .sram_pdn_bits = GENMASK(13, 8),
1000                 .sram_pdn_ack_bits = GENMASK(21, 16),
1001                 .clk_id = {CLK_NONE},
1002                 .bus_prot_mask = MT8173_TOP_AXI_PROT_EN_MFG_S |
1003                         MT8173_TOP_AXI_PROT_EN_MFG_M0 |
1004                         MT8173_TOP_AXI_PROT_EN_MFG_M1 |
1005                         MT8173_TOP_AXI_PROT_EN_MFG_SNOOP_OUT,
1006         },
1007 };
1008
1009 static const struct scp_subdomain scp_subdomain_mt8173[] = {
1010         {MT8173_POWER_DOMAIN_MFG_ASYNC, MT8173_POWER_DOMAIN_MFG_2D},
1011         {MT8173_POWER_DOMAIN_MFG_2D, MT8173_POWER_DOMAIN_MFG},
1012 };
1013
1014 static const struct scp_soc_data mt2701_data = {
1015         .domains = scp_domain_data_mt2701,
1016         .num_domains = ARRAY_SIZE(scp_domain_data_mt2701),
1017         .regs = {
1018                 .pwr_sta_offs = SPM_PWR_STATUS,
1019                 .pwr_sta2nd_offs = SPM_PWR_STATUS_2ND
1020         },
1021         .bus_prot_reg_update = true,
1022 };
1023
1024 static const struct scp_soc_data mt2712_data = {
1025         .domains = scp_domain_data_mt2712,
1026         .num_domains = ARRAY_SIZE(scp_domain_data_mt2712),
1027         .subdomains = scp_subdomain_mt2712,
1028         .num_subdomains = ARRAY_SIZE(scp_subdomain_mt2712),
1029         .regs = {
1030                 .pwr_sta_offs = SPM_PWR_STATUS,
1031                 .pwr_sta2nd_offs = SPM_PWR_STATUS_2ND
1032         },
1033         .bus_prot_reg_update = false,
1034 };
1035
1036 static const struct scp_soc_data mt6797_data = {
1037         .domains = scp_domain_data_mt6797,
1038         .num_domains = ARRAY_SIZE(scp_domain_data_mt6797),
1039         .subdomains = scp_subdomain_mt6797,
1040         .num_subdomains = ARRAY_SIZE(scp_subdomain_mt6797),
1041         .regs = {
1042                 .pwr_sta_offs = SPM_PWR_STATUS_MT6797,
1043                 .pwr_sta2nd_offs = SPM_PWR_STATUS_2ND_MT6797
1044         },
1045         .bus_prot_reg_update = true,
1046 };
1047
1048 static const struct scp_soc_data mt7622_data = {
1049         .domains = scp_domain_data_mt7622,
1050         .num_domains = ARRAY_SIZE(scp_domain_data_mt7622),
1051         .regs = {
1052                 .pwr_sta_offs = SPM_PWR_STATUS,
1053                 .pwr_sta2nd_offs = SPM_PWR_STATUS_2ND
1054         },
1055         .bus_prot_reg_update = true,
1056 };
1057
1058 static const struct scp_soc_data mt7623a_data = {
1059         .domains = scp_domain_data_mt7623a,
1060         .num_domains = ARRAY_SIZE(scp_domain_data_mt7623a),
1061         .regs = {
1062                 .pwr_sta_offs = SPM_PWR_STATUS,
1063                 .pwr_sta2nd_offs = SPM_PWR_STATUS_2ND
1064         },
1065         .bus_prot_reg_update = true,
1066 };
1067
1068 static const struct scp_soc_data mt8173_data = {
1069         .domains = scp_domain_data_mt8173,
1070         .num_domains = ARRAY_SIZE(scp_domain_data_mt8173),
1071         .subdomains = scp_subdomain_mt8173,
1072         .num_subdomains = ARRAY_SIZE(scp_subdomain_mt8173),
1073         .regs = {
1074                 .pwr_sta_offs = SPM_PWR_STATUS,
1075                 .pwr_sta2nd_offs = SPM_PWR_STATUS_2ND
1076         },
1077         .bus_prot_reg_update = true,
1078 };
1079
1080 /*
1081  * scpsys driver init
1082  */
1083
1084 static const struct of_device_id of_scpsys_match_tbl[] = {
1085         {
1086                 .compatible = "mediatek,mt2701-scpsys",
1087                 .data = &mt2701_data,
1088         }, {
1089                 .compatible = "mediatek,mt2712-scpsys",
1090                 .data = &mt2712_data,
1091         }, {
1092                 .compatible = "mediatek,mt6797-scpsys",
1093                 .data = &mt6797_data,
1094         }, {
1095                 .compatible = "mediatek,mt7622-scpsys",
1096                 .data = &mt7622_data,
1097         }, {
1098                 .compatible = "mediatek,mt7623a-scpsys",
1099                 .data = &mt7623a_data,
1100         }, {
1101                 .compatible = "mediatek,mt8173-scpsys",
1102                 .data = &mt8173_data,
1103         }, {
1104                 /* sentinel */
1105         }
1106 };
1107
1108 static int scpsys_probe(struct platform_device *pdev)
1109 {
1110         const struct scp_subdomain *sd;
1111         const struct scp_soc_data *soc;
1112         struct scp *scp;
1113         struct genpd_onecell_data *pd_data;
1114         int i, ret;
1115
1116         soc = of_device_get_match_data(&pdev->dev);
1117
1118         scp = init_scp(pdev, soc->domains, soc->num_domains, &soc->regs,
1119                         soc->bus_prot_reg_update);
1120         if (IS_ERR(scp))
1121                 return PTR_ERR(scp);
1122
1123         mtk_register_power_domains(pdev, scp, soc->num_domains);
1124
1125         pd_data = &scp->pd_data;
1126
1127         for (i = 0, sd = soc->subdomains; i < soc->num_subdomains; i++, sd++) {
1128                 ret = pm_genpd_add_subdomain(pd_data->domains[sd->origin],
1129                                              pd_data->domains[sd->subdomain]);
1130                 if (ret && IS_ENABLED(CONFIG_PM))
1131                         dev_err(&pdev->dev, "Failed to add subdomain: %d\n",
1132                                 ret);
1133         }
1134
1135         return 0;
1136 }
1137
1138 static struct platform_driver scpsys_drv = {
1139         .probe = scpsys_probe,
1140         .driver = {
1141                 .name = "mtk-scpsys",
1142                 .suppress_bind_attrs = true,
1143                 .owner = THIS_MODULE,
1144                 .of_match_table = of_match_ptr(of_scpsys_match_tbl),
1145         },
1146 };
1147 builtin_platform_driver(scpsys_drv);