target/linux/mediatek/patches/0008-soc-Mediatek-Add-SCPSYS-power-domain-driver.patch

   1 From 04e2e2a895a95dc9e75403c2e8ea190dce9dc387 Mon Sep 17 00:00:00 2001
   2 From: Sascha Hauer <s.hauer@pengutronix.de>
   3 Date: Tue, 9 Jun 2015 10:47:01 +0200
   4 Subject: [PATCH 08/76] soc: Mediatek: Add SCPSYS power domain driver
   5
   6 This adds a power domain driver for the Mediatek SCPSYS unit.
   7
   8 The System Control Processor System (SCPSYS) has several power
   9 management related tasks in the system. The tasks include thermal
  10 measurement, dynamic voltage frequency scaling (DVFS), interrupt
  11 filter and lowlevel sleep control. The System Power Manager (SPM)
  12 inside the SCPSYS is for the MTCMOS power domain control.
  13
  14 For now this driver only adds power domain support, the more
  15 advanced features are not yet supported. The driver implements
  16 the generic PM domain device tree bindings, the first user will
  17 most likely be the Mediatek AFE audio driver.
  18
  19 Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
  20 ---
  21  drivers/soc/mediatek/Kconfig             |    9 +
  22  drivers/soc/mediatek/Makefile            |    1 +
  23  drivers/soc/mediatek/mtk-scpsys.c        |  490 ++++++++++++++++++++++++++++++
  24  include/dt-bindings/power/mt8173-power.h |   15 +
  25  4 files changed, 515 insertions(+)
  26  create mode 100644 drivers/soc/mediatek/mtk-scpsys.c
  27  create mode 100644 include/dt-bindings/power/mt8173-power.h
  28
  29 diff --git a/drivers/soc/mediatek/Kconfig b/drivers/soc/mediatek/Kconfig
  30 index 09da41e..2dc5d90 100644
  31 --- a/drivers/soc/mediatek/Kconfig
  32 +++ b/drivers/soc/mediatek/Kconfig
  33 @@ -19,3 +19,12 @@ config MTK_PMIC_WRAP
  34           Say yes here to add support for MediaTek PMIC Wrapper found
  35           on different MediaTek SoCs. The PMIC wrapper is a proprietary
  36           hardware to connect the PMIC.
  37 +
  38 +config MTK_SCPSYS
  39 +       bool "MediaTek SCPSYS Support"
  40 +       depends on ARCH_MEDIATEK || COMPILE_TEST
  41 +       select REGMAP
  42 +       select MTK_INFRACFG
  43 +       help
  44 +         Say yes here to add support for the MediaTek SCPSYS power domain
  45 +         driver.
  46 diff --git a/drivers/soc/mediatek/Makefile b/drivers/soc/mediatek/Makefile
  47 index 3fa940f..12998b0 100644
  48 --- a/drivers/soc/mediatek/Makefile
  49 +++ b/drivers/soc/mediatek/Makefile
  50 @@ -1,2 +1,3 @@
  51  obj-$(CONFIG_MTK_INFRACFG) += mtk-infracfg.o
  52  obj-$(CONFIG_MTK_PMIC_WRAP) += mtk-pmic-wrap.o
  53 +obj-$(CONFIG_MTK_SCPSYS) += mtk-scpsys.o
  54 diff --git a/drivers/soc/mediatek/mtk-scpsys.c b/drivers/soc/mediatek/mtk-scpsys.c
  55 new file mode 100644
  56 index 0000000..b9eed37
  57 --- /dev/null
  58 +++ b/drivers/soc/mediatek/mtk-scpsys.c
  59 @@ -0,0 +1,490 @@
  60 +/*
  61 + * Copyright (c) 2015 Pengutronix, Sascha Hauer <kernel@pengutronix.de>
  62 + *
  63 + * This program is free software; you can redistribute it and/or modify
  64 + * it under the terms of the GNU General Public License version 2 as
  65 + * published by the Free Software Foundation.
  66 + *
  67 + * This program is distributed in the hope that it will be useful,
  68 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  69 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  70 + * GNU General Public License for more details.
  71 + */
  72 +#include <linux/clk.h>
  73 +#include <linux/delay.h>
  74 +#include <linux/io.h>
  75 +#include <linux/kernel.h>
  76 +#include <linux/mfd/syscon.h>
  77 +#include <linux/of_device.h>
  78 +#include <linux/platform_device.h>
  79 +#include <linux/pm_domain.h>
  80 +#include <linux/regmap.h>
  81 +#include <linux/soc/mediatek/infracfg.h>
  82 +#include <dt-bindings/power/mt8173-power.h>
  83 +
  84 +#define SPM_VDE_PWR_CON                        0x0210
  85 +#define SPM_MFG_PWR_CON                        0x0214
  86 +#define SPM_VEN_PWR_CON                        0x0230
  87 +#define SPM_ISP_PWR_CON                        0x0238
  88 +#define SPM_DIS_PWR_CON                        0x023c
  89 +#define SPM_VEN2_PWR_CON               0x0298
  90 +#define SPM_AUDIO_PWR_CON              0x029c
  91 +#define SPM_MFG_2D_PWR_CON             0x02c0
  92 +#define SPM_MFG_ASYNC_PWR_CON          0x02c4
  93 +#define SPM_USB_PWR_CON                        0x02cc
  94 +#define SPM_PWR_STATUS                 0x060c
  95 +#define SPM_PWR_STATUS_2ND             0x0610
  96 +
  97 +#define PWR_RST_B_BIT                  BIT(0)
  98 +#define PWR_ISO_BIT                    BIT(1)
  99 +#define PWR_ON_BIT                     BIT(2)
 100 +#define PWR_ON_2ND_BIT                 BIT(3)
 101 +#define PWR_CLK_DIS_BIT                        BIT(4)
 102 +
 103 +#define PWR_STATUS_DISP                        BIT(3)
 104 +#define PWR_STATUS_MFG                 BIT(4)
 105 +#define PWR_STATUS_ISP                 BIT(5)
 106 +#define PWR_STATUS_VDEC                        BIT(7)
 107 +#define PWR_STATUS_VENC_LT             BIT(20)
 108 +#define PWR_STATUS_VENC                        BIT(21)
 109 +#define PWR_STATUS_MFG_2D              BIT(22)
 110 +#define PWR_STATUS_MFG_ASYNC           BIT(23)
 111 +#define PWR_STATUS_AUDIO               BIT(24)
 112 +#define PWR_STATUS_USB                 BIT(25)
 113 +
 114 +enum clk_id {
 115 +       MT8173_CLK_NONE,
 116 +       MT8173_CLK_MM,
 117 +       MT8173_CLK_MFG,
 118 +       MT8173_CLK_MAX = MT8173_CLK_MFG,
 119 +};
 120 +
 121 +struct scp_domain_data {
 122 +       const char *name;
 123 +       u32 sta_mask;
 124 +       int ctl_offs;
 125 +       u32 sram_pdn_bits;
 126 +       u32 sram_pdn_ack_bits;
 127 +       u32 bus_prot_mask;
 128 +       enum clk_id clk_id;
 129 +};
 130 +
 131 +static const struct scp_domain_data scp_domain_data[] __initconst = {
 132 +       [MT8173_POWER_DOMAIN_VDEC] = {
 133 +               .name = "vdec",
 134 +               .sta_mask = PWR_STATUS_VDEC,
 135 +               .ctl_offs = SPM_VDE_PWR_CON,
 136 +               .sram_pdn_bits = GENMASK(11, 8),
 137 +               .sram_pdn_ack_bits = GENMASK(12, 12),
 138 +               .clk_id = MT8173_CLK_MM,
 139 +       },
 140 +       [MT8173_POWER_DOMAIN_VENC] = {
 141 +               .name = "venc",
 142 +               .sta_mask = PWR_STATUS_VENC,
 143 +               .ctl_offs = SPM_VEN_PWR_CON,
 144 +               .sram_pdn_bits = GENMASK(11, 8),
 145 +               .sram_pdn_ack_bits = GENMASK(15, 12),
 146 +               .clk_id = MT8173_CLK_MM,
 147 +       },
 148 +       [MT8173_POWER_DOMAIN_ISP] = {
 149 +               .name = "isp",
 150 +               .sta_mask = PWR_STATUS_ISP,
 151 +               .ctl_offs = SPM_ISP_PWR_CON,
 152 +               .sram_pdn_bits = GENMASK(11, 8),
 153 +               .sram_pdn_ack_bits = GENMASK(13, 12),
 154 +               .clk_id = MT8173_CLK_MM,
 155 +       },
 156 +       [MT8173_POWER_DOMAIN_MM] = {
 157 +               .name = "mm",
 158 +               .sta_mask = PWR_STATUS_DISP,
 159 +               .ctl_offs = SPM_DIS_PWR_CON,
 160 +               .sram_pdn_bits = GENMASK(11, 8),
 161 +               .sram_pdn_ack_bits = GENMASK(12, 12),
 162 +               .clk_id = MT8173_CLK_MM,
 163 +               .bus_prot_mask = MT8173_TOP_AXI_PROT_EN_MM_M0 |
 164 +                       MT8173_TOP_AXI_PROT_EN_MM_M1,
 165 +       },
 166 +       [MT8173_POWER_DOMAIN_VENC_LT] = {
 167 +               .name = "venc_lt",
 168 +               .sta_mask = PWR_STATUS_VENC_LT,
 169 +               .ctl_offs = SPM_VEN2_PWR_CON,
 170 +               .sram_pdn_bits = GENMASK(11, 8),
 171 +               .sram_pdn_ack_bits = GENMASK(15, 12),
 172 +               .clk_id = MT8173_CLK_MM,
 173 +       },
 174 +       [MT8173_POWER_DOMAIN_AUDIO] = {
 175 +               .name = "audio",
 176 +               .sta_mask = PWR_STATUS_AUDIO,
 177 +               .ctl_offs = SPM_AUDIO_PWR_CON,
 178 +               .sram_pdn_bits = GENMASK(11, 8),
 179 +               .sram_pdn_ack_bits = GENMASK(15, 12),
 180 +               .clk_id = MT8173_CLK_NONE,
 181 +       },
 182 +       [MT8173_POWER_DOMAIN_USB] = {
 183 +               .name = "usb",
 184 +               .sta_mask = PWR_STATUS_USB,
 185 +               .ctl_offs = SPM_USB_PWR_CON,
 186 +               .sram_pdn_bits = GENMASK(11, 8),
 187 +               .sram_pdn_ack_bits = GENMASK(15, 12),
 188 +               .clk_id = MT8173_CLK_NONE,
 189 +       },
 190 +       [MT8173_POWER_DOMAIN_MFG_ASYNC] = {
 191 +               .name = "mfg_async",
 192 +               .sta_mask = PWR_STATUS_MFG_ASYNC,
 193 +               .ctl_offs = SPM_MFG_ASYNC_PWR_CON,
 194 +               .sram_pdn_bits = GENMASK(11, 8),
 195 +               .sram_pdn_ack_bits = 0,
 196 +               .clk_id = MT8173_CLK_MFG,
 197 +       },
 198 +       [MT8173_POWER_DOMAIN_MFG_2D] = {
 199 +               .name = "mfg_2d",
 200 +               .sta_mask = PWR_STATUS_MFG_2D,
 201 +               .ctl_offs = SPM_MFG_2D_PWR_CON,
 202 +               .sram_pdn_bits = GENMASK(11, 8),
 203 +               .sram_pdn_ack_bits = GENMASK(13, 12),
 204 +               .clk_id = MT8173_CLK_NONE,
 205 +       },
 206 +       [MT8173_POWER_DOMAIN_MFG] = {
 207 +               .name = "mfg",
 208 +               .sta_mask = PWR_STATUS_MFG,
 209 +               .ctl_offs = SPM_MFG_PWR_CON,
 210 +               .sram_pdn_bits = GENMASK(13, 8),
 211 +               .sram_pdn_ack_bits = GENMASK(21, 16),
 212 +               .clk_id = MT8173_CLK_NONE,
 213 +               .bus_prot_mask = MT8173_TOP_AXI_PROT_EN_MFG_S |
 214 +                       MT8173_TOP_AXI_PROT_EN_MFG_M0 |
 215 +                       MT8173_TOP_AXI_PROT_EN_MFG_M1 |
 216 +                       MT8173_TOP_AXI_PROT_EN_MFG_SNOOP_OUT,
 217 +       },
 218 +};
 219 +
 220 +#define NUM_DOMAINS    ARRAY_SIZE(scp_domain_data)
 221 +
 222 +struct scp;
 223 +
 224 +struct scp_domain {
 225 +       struct generic_pm_domain genpd;
 226 +       struct scp *scp;
 227 +       struct clk *clk;
 228 +       u32 sta_mask;
 229 +       void __iomem *ctl_addr;
 230 +       u32 sram_pdn_bits;
 231 +       u32 sram_pdn_ack_bits;
 232 +       u32 bus_prot_mask;
 233 +};
 234 +
 235 +struct scp {
 236 +       struct scp_domain domains[NUM_DOMAINS];
 237 +       struct genpd_onecell_data pd_data;
 238 +       struct device *dev;
 239 +       void __iomem *base;
 240 +       struct regmap *infracfg;
 241 +       struct clk *clk[MT8173_CLK_MAX];
 242 +};
 243 +
 244 +static int scpsys_domain_is_on(struct scp_domain *scpd)
 245 +{
 246 +       struct scp *scp = scpd->scp;
 247 +
 248 +       u32 status = readl(scp->base + SPM_PWR_STATUS) & scpd->sta_mask;
 249 +       u32 status2 = readl(scp->base + SPM_PWR_STATUS_2ND) & scpd->sta_mask;
 250 +
 251 +       /*
 252 +        * A domain is on when both status bits are set. If only one is set
 253 +        * return an error. This happens while powering up a domain
 254 +        */
 255 +
 256 +       if (status && status2)
 257 +               return true;
 258 +       if (!status && !status2)
 259 +               return false;
 260 +
 261 +       return -EINVAL;
 262 +}
 263 +
 264 +static int scpsys_power_on(struct generic_pm_domain *genpd)
 265 +{
 266 +       struct scp_domain *scpd = container_of(genpd, struct scp_domain, genpd);
 267 +       struct scp *scp = scpd->scp;
 268 +       unsigned long timeout;
 269 +       bool expired;
 270 +       void __iomem *ctl_addr = scpd->ctl_addr;
 271 +       u32 sram_pdn_ack = scpd->sram_pdn_ack_bits;
 272 +       u32 val;
 273 +       int ret;
 274 +
 275 +       if (scpd->clk) {
 276 +               ret = clk_prepare_enable(scpd->clk);
 277 +               if (ret)
 278 +                       return ret;
 279 +       }
 280 +
 281 +       val = readl(ctl_addr);
 282 +       val |= PWR_ON_BIT;
 283 +       writel(val, ctl_addr);
 284 +       val |= PWR_ON_2ND_BIT;
 285 +       writel(val, ctl_addr);
 286 +
 287 +       /* wait until PWR_ACK = 1 */
 288 +       timeout = jiffies + HZ;
 289 +       expired = false;
 290 +       while (1) {
 291 +               ret = scpsys_domain_is_on(scpd);
 292 +               if (ret > 0)
 293 +                       break;
 294 +
 295 +               if (expired) {
 296 +                       ret = -ETIMEDOUT;
 297 +                       goto out;
 298 +               }
 299 +
 300 +               cpu_relax();
 301 +
 302 +               if (time_after(jiffies, timeout))
 303 +                       expired = true;
 304 +       }
 305 +
 306 +       val &= ~PWR_CLK_DIS_BIT;
 307 +       writel(val, ctl_addr);
 308 +
 309 +       val &= ~PWR_ISO_BIT;
 310 +       writel(val, ctl_addr);
 311 +
 312 +       val |= PWR_RST_B_BIT;
 313 +       writel(val, ctl_addr);
 314 +
 315 +       val &= ~scpd->sram_pdn_bits;
 316 +       writel(val, ctl_addr);
 317 +
 318 +       /* wait until SRAM_PDN_ACK all 0 */
 319 +       timeout = jiffies + HZ;
 320 +       expired = false;
 321 +       while (sram_pdn_ack && (readl(ctl_addr) & sram_pdn_ack)) {
 322 +
 323 +               if (expired) {
 324 +                       ret = -ETIMEDOUT;
 325 +                       goto out;
 326 +               }
 327 +
 328 +               cpu_relax();
 329 +
 330 +               if (time_after(jiffies, timeout))
 331 +                       expired = true;
 332 +       }
 333 +
 334 +       if (scpd->bus_prot_mask) {
 335 +               ret = mtk_infracfg_clear_bus_protection(scp->infracfg,
 336 +                               scpd->bus_prot_mask);
 337 +               if (ret)
 338 +                       return ret;
 339 +       }
 340 +
 341 +       return 0;
 342 +out:
 343 +       dev_err(scp->dev, "Failed to power on domain %s\n", genpd->name);
 344 +
 345 +       return ret;
 346 +}
 347 +
 348 +static int scpsys_power_off(struct generic_pm_domain *genpd)
 349 +{
 350 +       struct scp_domain *scpd = container_of(genpd, struct scp_domain, genpd);
 351 +       struct scp *scp = scpd->scp;
 352 +       unsigned long timeout;
 353 +       bool expired;
 354 +       void __iomem *ctl_addr = scpd->ctl_addr;
 355 +       u32 pdn_ack = scpd->sram_pdn_ack_bits;
 356 +       u32 val;
 357 +       int ret;
 358 +
 359 +       if (scpd->bus_prot_mask) {
 360 +               ret = mtk_infracfg_set_bus_protection(scp->infracfg,
 361 +                               scpd->bus_prot_mask);
 362 +               if (ret)
 363 +                       return ret;
 364 +       }
 365 +
 366 +       val = readl(ctl_addr);
 367 +       val |= scpd->sram_pdn_bits;
 368 +       writel(val, ctl_addr);
 369 +
 370 +       /* wait until SRAM_PDN_ACK all 1 */
 371 +       timeout = jiffies + HZ;
 372 +       expired = false;
 373 +       while (pdn_ack && (readl(ctl_addr) & pdn_ack) != pdn_ack) {
 374 +               if (expired) {
 375 +                       ret = -ETIMEDOUT;
 376 +                       goto out;
 377 +               }
 378 +
 379 +               cpu_relax();
 380 +
 381 +               if (time_after(jiffies, timeout))
 382 +                       expired = true;
 383 +       }
 384 +
 385 +       val |= PWR_ISO_BIT;
 386 +       writel(val, ctl_addr);
 387 +
 388 +       val &= ~PWR_RST_B_BIT;
 389 +       writel(val, ctl_addr);
 390 +
 391 +       val |= PWR_CLK_DIS_BIT;
 392 +       writel(val, ctl_addr);
 393 +
 394 +       val &= ~PWR_ON_BIT;
 395 +       writel(val, ctl_addr);
 396 +
 397 +       val &= ~PWR_ON_2ND_BIT;
 398 +       writel(val, ctl_addr);
 399 +
 400 +       /* wait until PWR_ACK = 0 */
 401 +       timeout = jiffies + HZ;
 402 +       expired = false;
 403 +       while (1) {
 404 +               ret = scpsys_domain_is_on(scpd);
 405 +               if (ret == 0)
 406 +                       break;
 407 +
 408 +               if (expired) {
 409 +                       ret = -ETIMEDOUT;
 410 +                       goto out;
 411 +               }
 412 +
 413 +               cpu_relax();
 414 +
 415 +               if (time_after(jiffies, timeout))
 416 +                       expired = true;
 417 +       }
 418 +
 419 +       if (scpd->clk)
 420 +               clk_disable_unprepare(scpd->clk);
 421 +
 422 +       return 0;
 423 +
 424 +out:
 425 +       dev_err(scp->dev, "Failed to power off domain %s\n", genpd->name);
 426 +
 427 +       return ret;
 428 +}
 429 +
 430 +static int __init scpsys_probe(struct platform_device *pdev)
 431 +{
 432 +       struct genpd_onecell_data *pd_data;
 433 +       struct resource *res;
 434 +       int i, ret;
 435 +       struct scp *scp;
 436 +
 437 +       scp = devm_kzalloc(&pdev->dev, sizeof(*scp), GFP_KERNEL);
 438 +       if (!scp)
 439 +               return -ENOMEM;
 440 +
 441 +       scp->dev = &pdev->dev;
 442 +
 443 +       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 444 +       scp->base = devm_ioremap_resource(&pdev->dev, res);
 445 +       if (IS_ERR(scp->base))
 446 +               return PTR_ERR(scp->base);
 447 +
 448 +       pd_data = &scp->pd_data;
 449 +
 450 +       pd_data->domains = devm_kzalloc(&pdev->dev,
 451 +                       sizeof(*pd_data->domains) * NUM_DOMAINS, GFP_KERNEL);
 452 +       if (!pd_data->domains)
 453 +               return -ENOMEM;
 454 +
 455 +       scp->clk[MT8173_CLK_MM] = devm_clk_get(&pdev->dev, "mm");
 456 +       if (IS_ERR(scp->clk[MT8173_CLK_MM])) {
 457 +               dev_err(&pdev->dev, "Failed to get mm clk: %ld\n",
 458 +                               PTR_ERR(scp->clk[MT8173_CLK_MM]));
 459 +               return PTR_ERR(scp->clk[MT8173_CLK_MM]);
 460 +       }
 461 +
 462 +       scp->clk[MT8173_CLK_MFG] = devm_clk_get(&pdev->dev, "mfg");
 463 +       if (IS_ERR(scp->clk[MT8173_CLK_MFG])) {
 464 +               dev_err(&pdev->dev, "Failed to get mfg clk: %ld\n",
 465 +                               PTR_ERR(scp->clk[MT8173_CLK_MFG]));
 466 +               return PTR_ERR(scp->clk[MT8173_CLK_MFG]);
 467 +       }
 468 +
 469 +       scp->infracfg = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
 470 +                       "infracfg");
 471 +       if (IS_ERR(scp->infracfg)) {
 472 +               dev_err(&pdev->dev, "Cannot find infracfg controller: %ld\n",
 473 +                               PTR_ERR(scp->infracfg));
 474 +               return PTR_ERR(scp->infracfg);
 475 +       }
 476 +
 477 +       pd_data->num_domains = NUM_DOMAINS;
 478 +
 479 +       for (i = 0; i < NUM_DOMAINS; i++) {
 480 +               struct scp_domain *scpd = &scp->domains[i];
 481 +               struct generic_pm_domain *genpd = &scpd->genpd;
 482 +               const struct scp_domain_data *data = &scp_domain_data[i];
 483 +
 484 +               pd_data->domains[i] = genpd;
 485 +               scpd->scp = scp;
 486 +
 487 +               scpd->sta_mask = data->sta_mask;
 488 +               scpd->ctl_addr = scp->base + data->ctl_offs;
 489 +               scpd->sram_pdn_bits = data->sram_pdn_bits;
 490 +               scpd->sram_pdn_ack_bits = data->sram_pdn_ack_bits;
 491 +               scpd->bus_prot_mask = data->bus_prot_mask;
 492 +               if (data->clk_id != MT8173_CLK_NONE)
 493 +                       scpd->clk = scp->clk[data->clk_id];
 494 +
 495 +               genpd->name = data->name;
 496 +               genpd->power_off = scpsys_power_off;
 497 +               genpd->power_on = scpsys_power_on;
 498 +
 499 +               /*
 500 +                * Initially turn on all domains to make the domains usable
 501 +                * with !CONFIG_PM and to get the hardware in sync with the
 502 +                * software.  The unused domains will be switched off during
 503 +                * late_init time.
 504 +                */
 505 +               genpd->power_on(genpd);
 506 +
 507 +               pm_genpd_init(genpd, NULL, false);
 508 +       }
 509 +
 510 +       /*
 511 +        * We are not allowed to fail here since there is no way to unregister
 512 +        * a power domain. Once registered above we have to keep the domains
 513 +        * valid.
 514 +        */
 515 +
 516 +       ret = pm_genpd_add_subdomain(pd_data->domains[MT8173_POWER_DOMAIN_MFG_ASYNC],
 517 +               pd_data->domains[MT8173_POWER_DOMAIN_MFG_2D]);
 518 +       if (ret && IS_ENABLED(CONFIG_PM))
 519 +               dev_err(&pdev->dev, "Failed to add subdomain: %d\n", ret);
 520 +
 521 +       ret = pm_genpd_add_subdomain(pd_data->domains[MT8173_POWER_DOMAIN_MFG_2D],
 522 +               pd_data->domains[MT8173_POWER_DOMAIN_MFG]);
 523 +       if (ret && IS_ENABLED(CONFIG_PM))
 524 +               dev_err(&pdev->dev, "Failed to add subdomain: %d\n", ret);
 525 +
 526 +       ret = of_genpd_add_provider_onecell(pdev->dev.of_node, pd_data);
 527 +       if (ret)
 528 +               dev_err(&pdev->dev, "Failed to add OF provider: %d\n", ret);
 529 +
 530 +       return 0;
 531 +}
 532 +
 533 +static const struct of_device_id of_scpsys_match_tbl[] = {
 534 +       {
 535 +               .compatible = "mediatek,mt8173-scpsys",
 536 +       }, {
 537 +               /* sentinel */
 538 +       }
 539 +};
 540 +
 541 +static struct platform_driver scpsys_drv = {
 542 +       .driver = {
 543 +               .name = "mtk-scpsys",
 544 +               .owner = THIS_MODULE,
 545 +               .of_match_table = of_match_ptr(of_scpsys_match_tbl),
 546 +       },
 547 +};
 548 +
 549 +module_platform_driver_probe(scpsys_drv, scpsys_probe);
 550 diff --git a/include/dt-bindings/power/mt8173-power.h b/include/dt-bindings/power/mt8173-power.h
 551 new file mode 100644
 552 index 0000000..b34cee9
 553 --- /dev/null
 554 +++ b/include/dt-bindings/power/mt8173-power.h
 555 @@ -0,0 +1,15 @@
 556 +#ifndef _DT_BINDINGS_POWER_MT8183_POWER_H
 557 +#define _DT_BINDINGS_POWER_MT8183_POWER_H
 558 +
 559 +#define MT8173_POWER_DOMAIN_VDEC       0
 560 +#define MT8173_POWER_DOMAIN_VENC       1
 561 +#define MT8173_POWER_DOMAIN_ISP                2
 562 +#define MT8173_POWER_DOMAIN_MM         3
 563 +#define MT8173_POWER_DOMAIN_VENC_LT    4
 564 +#define MT8173_POWER_DOMAIN_AUDIO      5
 565 +#define MT8173_POWER_DOMAIN_USB                6
 566 +#define MT8173_POWER_DOMAIN_MFG_ASYNC  7
 567 +#define MT8173_POWER_DOMAIN_MFG_2D     8
 568 +#define MT8173_POWER_DOMAIN_MFG                9
 569 +
 570 +#endif /* _DT_BINDINGS_POWER_MT8183_POWER_H */
 571 --
 572 1.7.10.4
 573