1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2016 Freescale Semiconductor, Inc. 4 * Copyright 2017-2018 NXP 5 * Dong Aisheng <aisheng.dong@nxp.com> 6 * 7 * Implementation of the SCU based Power Domains 8 * 9 * NOTE: a better implementation suggested by Ulf Hansson is using a 10 * single global power domain and implement the ->attach|detach_dev() 11 * callback for the genpd and use the regular of_genpd_add_provider_simple(). 12 * From within the ->attach_dev(), we could get the OF node for 13 * the device that is being attached and then parse the power-domain 14 * cell containing the "resource id" and store that in the per device 15 * struct generic_pm_domain_data (we have void pointer there for 16 * storing these kind of things). 17 * 18 * Additionally, we need to implement the ->stop() and ->start() 19 * callbacks of genpd, which is where you "power on/off" devices, 20 * rather than using the above ->power_on|off() callbacks. 21 * 22 * However, there're two known issues: 23 * 1. The ->attach_dev() of power domain infrastructure still does 24 * not support multi domains case as the struct device *dev passed 25 * in is a virtual PD device, it does not help for parsing the real 26 * device resource id from device tree, so it's unware of which 27 * real sub power domain of device should be attached. 28 * 29 * The framework needs some proper extension to support multi power 30 * domain cases. 31 * 32 * Update: Genpd assigns the ->of_node for the virtual device before it 33 * invokes ->attach_dev() callback, hence parsing for device resources via 34 * DT should work fine. 35 * 36 * 2. It also breaks most of current drivers as the driver probe sequence 37 * behavior changed if removing ->power_on|off() callback and use 38 * ->start() and ->stop() instead. genpd_dev_pm_attach will only power 39 * up the domain and attach device, but will not call .start() which 40 * relies on device runtime pm. That means the device power is still 41 * not up before running driver probe function. For SCU enabled 42 * platforms, all device drivers accessing registers/clock without power 43 * domain enabled will trigger a HW access error. That means we need fix 44 * most drivers probe sequence with proper runtime pm. 45 * 46 * Update: Runtime PM support isn't necessary. Instead, this can easily be 47 * fixed in drivers by adding a call to dev_pm_domain_start() during probe. 48 * 49 * In summary, the second part needs to be addressed via minor updates to the 50 * relevant drivers, before the "single global power domain" model can be used. 51 * 52 */ 53 54 #include <dt-bindings/firmware/imx/rsrc.h> 55 #include <linux/console.h> 56 #include <linux/firmware/imx/sci.h> 57 #include <linux/firmware/imx/svc/rm.h> 58 #include <linux/io.h> 59 #include <linux/module.h> 60 #include <linux/of.h> 61 #include <linux/of_address.h> 62 #include <linux/of_platform.h> 63 #include <linux/platform_device.h> 64 #include <linux/pm.h> 65 #include <linux/pm_domain.h> 66 #include <linux/slab.h> 67 68 /* SCU Power Mode Protocol definition */ 69 struct imx_sc_msg_req_set_resource_power_mode { 70 struct imx_sc_rpc_msg hdr; 71 u16 resource; 72 u8 mode; 73 } __packed __aligned(4); 74 75 struct req_get_resource_mode { 76 u16 resource; 77 }; 78 79 struct resp_get_resource_mode { 80 u8 mode; 81 }; 82 83 struct imx_sc_msg_req_get_resource_power_mode { 84 struct imx_sc_rpc_msg hdr; 85 union { 86 struct req_get_resource_mode req; 87 struct resp_get_resource_mode resp; 88 } data; 89 } __packed __aligned(4); 90 91 #define IMX_SCU_PD_NAME_SIZE 20 92 struct imx_sc_pm_domain { 93 struct generic_pm_domain pd; 94 char name[IMX_SCU_PD_NAME_SIZE]; 95 u32 rsrc; 96 }; 97 98 struct imx_sc_pd_range { 99 char *name; 100 u32 rsrc; 101 u8 num; 102 103 /* add domain index */ 104 bool postfix; 105 u8 start_from; 106 }; 107 108 struct imx_sc_pd_soc { 109 const struct imx_sc_pd_range *pd_ranges; 110 u8 num_ranges; 111 }; 112 113 static int imx_con_rsrc; 114 115 /* Align with the IMX_SC_PM_PW_MODE_[OFF,STBY,LP,ON] macros */ 116 static const char * const imx_sc_pm_mode[] = { 117 "IMX_SC_PM_PW_MODE_OFF", 118 "IMX_SC_PM_PW_MODE_STBY", 119 "IMX_SC_PM_PW_MODE_LP", 120 "IMX_SC_PM_PW_MODE_ON" 121 }; 122 123 static const struct imx_sc_pd_range imx8qxp_scu_pd_ranges[] = { 124 /* LSIO SS */ 125 { "pwm", IMX_SC_R_PWM_0, 8, true, 0 }, 126 { "gpio", IMX_SC_R_GPIO_0, 8, true, 0 }, 127 { "gpt", IMX_SC_R_GPT_0, 5, true, 0 }, 128 { "kpp", IMX_SC_R_KPP, 1, false, 0 }, 129 { "fspi", IMX_SC_R_FSPI_0, 2, true, 0 }, 130 { "mu_a", IMX_SC_R_MU_0A, 14, true, 0 }, 131 { "mu_b", IMX_SC_R_MU_5B, 9, true, 5 }, 132 133 /* CONN SS */ 134 { "usb", IMX_SC_R_USB_0, 2, true, 0 }, 135 { "usb0phy", IMX_SC_R_USB_0_PHY, 1, false, 0 }, 136 { "usb1phy", IMX_SC_R_USB_1_PHY, 1, false, 0}, 137 { "usb2", IMX_SC_R_USB_2, 1, false, 0 }, 138 { "usb2phy", IMX_SC_R_USB_2_PHY, 1, false, 0 }, 139 { "sdhc", IMX_SC_R_SDHC_0, 3, true, 0 }, 140 { "enet", IMX_SC_R_ENET_0, 2, true, 0 }, 141 { "nand", IMX_SC_R_NAND, 1, false, 0 }, 142 { "mlb", IMX_SC_R_MLB_0, 1, true, 0 }, 143 144 /* AUDIO SS */ 145 { "audio-pll0", IMX_SC_R_AUDIO_PLL_0, 1, false, 0 }, 146 { "audio-pll1", IMX_SC_R_AUDIO_PLL_1, 1, false, 0 }, 147 { "audio-clk-0", IMX_SC_R_AUDIO_CLK_0, 1, false, 0 }, 148 { "audio-clk-1", IMX_SC_R_AUDIO_CLK_1, 1, false, 0 }, 149 { "mclk-out-0", IMX_SC_R_MCLK_OUT_0, 1, false, 0 }, 150 { "mclk-out-1", IMX_SC_R_MCLK_OUT_1, 1, false, 0 }, 151 { "dma0-ch", IMX_SC_R_DMA_0_CH0, 32, true, 0 }, 152 { "dma1-ch", IMX_SC_R_DMA_1_CH0, 16, true, 0 }, 153 { "dma2-ch", IMX_SC_R_DMA_2_CH0, 32, true, 0 }, 154 { "dma3-ch", IMX_SC_R_DMA_3_CH0, 32, true, 0 }, 155 { "asrc0", IMX_SC_R_ASRC_0, 1, false, 0 }, 156 { "asrc1", IMX_SC_R_ASRC_1, 1, false, 0 }, 157 { "esai0", IMX_SC_R_ESAI_0, 1, false, 0 }, 158 { "esai1", IMX_SC_R_ESAI_1, 1, false, 0 }, 159 { "spdif0", IMX_SC_R_SPDIF_0, 1, false, 0 }, 160 { "spdif1", IMX_SC_R_SPDIF_1, 1, false, 0 }, 161 { "sai", IMX_SC_R_SAI_0, 3, true, 0 }, 162 { "sai3", IMX_SC_R_SAI_3, 1, false, 0 }, 163 { "sai4", IMX_SC_R_SAI_4, 1, false, 0 }, 164 { "sai5", IMX_SC_R_SAI_5, 1, false, 0 }, 165 { "sai6", IMX_SC_R_SAI_6, 1, false, 0 }, 166 { "sai7", IMX_SC_R_SAI_7, 1, false, 0 }, 167 { "amix", IMX_SC_R_AMIX, 1, false, 0 }, 168 { "mqs0", IMX_SC_R_MQS_0, 1, false, 0 }, 169 { "dsp", IMX_SC_R_DSP, 1, false, 0 }, 170 { "dsp-ram", IMX_SC_R_DSP_RAM, 1, false, 0 }, 171 172 /* DMA SS */ 173 { "can", IMX_SC_R_CAN_0, 3, true, 0 }, 174 { "ftm", IMX_SC_R_FTM_0, 2, true, 0 }, 175 { "lpi2c", IMX_SC_R_I2C_0, 5, true, 0 }, 176 { "adc", IMX_SC_R_ADC_0, 2, true, 0 }, 177 { "lcd", IMX_SC_R_LCD_0, 1, true, 0 }, 178 { "lcd-pll", IMX_SC_R_ELCDIF_PLL, 1, true, 0 }, 179 { "lcd0-pwm", IMX_SC_R_LCD_0_PWM_0, 1, true, 0 }, 180 { "lpuart", IMX_SC_R_UART_0, 5, true, 0 }, 181 { "sim", IMX_SC_R_EMVSIM_0, 2, true, 0 }, 182 { "lpspi", IMX_SC_R_SPI_0, 4, true, 0 }, 183 { "irqstr_dsp", IMX_SC_R_IRQSTR_DSP, 1, false, 0 }, 184 185 /* VPU SS */ 186 { "vpu", IMX_SC_R_VPU, 1, false, 0 }, 187 { "vpu-pid", IMX_SC_R_VPU_PID0, 8, true, 0 }, 188 { "vpu-dec0", IMX_SC_R_VPU_DEC_0, 1, false, 0 }, 189 { "vpu-enc0", IMX_SC_R_VPU_ENC_0, 1, false, 0 }, 190 { "vpu-enc1", IMX_SC_R_VPU_ENC_1, 1, false, 0 }, 191 { "vpu-mu0", IMX_SC_R_VPU_MU_0, 1, false, 0 }, 192 { "vpu-mu1", IMX_SC_R_VPU_MU_1, 1, false, 0 }, 193 { "vpu-mu2", IMX_SC_R_VPU_MU_2, 1, false, 0 }, 194 195 /* GPU SS */ 196 { "gpu0-pid", IMX_SC_R_GPU_0_PID0, 4, true, 0 }, 197 { "gpu1-pid", IMX_SC_R_GPU_1_PID0, 4, true, 0 }, 198 199 200 /* HSIO SS */ 201 { "pcie-a", IMX_SC_R_PCIE_A, 1, false, 0 }, 202 { "serdes-0", IMX_SC_R_SERDES_0, 1, false, 0 }, 203 { "pcie-b", IMX_SC_R_PCIE_B, 1, false, 0 }, 204 { "serdes-1", IMX_SC_R_SERDES_1, 1, false, 0 }, 205 { "sata-0", IMX_SC_R_SATA_0, 1, false, 0 }, 206 { "hsio-gpio", IMX_SC_R_HSIO_GPIO, 1, false, 0 }, 207 208 /* MIPI SS */ 209 { "mipi0", IMX_SC_R_MIPI_0, 1, false, 0 }, 210 { "mipi0-pwm0", IMX_SC_R_MIPI_0_PWM_0, 1, false, 0 }, 211 { "mipi0-i2c", IMX_SC_R_MIPI_0_I2C_0, 2, true, 0 }, 212 213 { "mipi1", IMX_SC_R_MIPI_1, 1, false, 0 }, 214 { "mipi1-pwm0", IMX_SC_R_MIPI_1_PWM_0, 1, false, 0 }, 215 { "mipi1-i2c", IMX_SC_R_MIPI_1_I2C_0, 2, true, 0 }, 216 217 /* LVDS SS */ 218 { "lvds0", IMX_SC_R_LVDS_0, 1, false, 0 }, 219 { "lvds0-pwm", IMX_SC_R_LVDS_0_PWM_0, 1, false, 0 }, 220 { "lvds0-lpi2c", IMX_SC_R_LVDS_0_I2C_0, 2, true, 0 }, 221 { "lvds1", IMX_SC_R_LVDS_1, 1, false, 0 }, 222 { "lvds1-pwm", IMX_SC_R_LVDS_1_PWM_0, 1, false, 0 }, 223 { "lvds1-lpi2c", IMX_SC_R_LVDS_1_I2C_0, 2, true, 0 }, 224 225 { "mipi1", IMX_SC_R_MIPI_1, 1, 0 }, 226 { "mipi1-pwm0", IMX_SC_R_MIPI_1_PWM_0, 1, 0 }, 227 { "mipi1-i2c", IMX_SC_R_MIPI_1_I2C_0, 2, 1 }, 228 { "lvds1", IMX_SC_R_LVDS_1, 1, 0 }, 229 230 /* DC SS */ 231 { "dc0", IMX_SC_R_DC_0, 1, false, 0 }, 232 { "dc0-pll", IMX_SC_R_DC_0_PLL_0, 2, true, 0 }, 233 { "dc0-video", IMX_SC_R_DC_0_VIDEO0, 2, true, 0 }, 234 235 { "dc1", IMX_SC_R_DC_1, 1, false, 0 }, 236 { "dc1-pll", IMX_SC_R_DC_1_PLL_0, 2, true, 0 }, 237 { "dc1-video", IMX_SC_R_DC_1_VIDEO0, 2, true, 0 }, 238 239 /* CM40 SS */ 240 { "cm40-i2c", IMX_SC_R_M4_0_I2C, 1, false, 0 }, 241 { "cm40-intmux", IMX_SC_R_M4_0_INTMUX, 1, false, 0 }, 242 { "cm40-pid", IMX_SC_R_M4_0_PID0, 5, true, 0}, 243 { "cm40-mu-a1", IMX_SC_R_M4_0_MU_1A, 1, false, 0}, 244 { "cm40-lpuart", IMX_SC_R_M4_0_UART, 1, false, 0}, 245 246 /* CM41 SS */ 247 { "cm41-i2c", IMX_SC_R_M4_1_I2C, 1, false, 0 }, 248 { "cm41-intmux", IMX_SC_R_M4_1_INTMUX, 1, false, 0 }, 249 { "cm41-pid", IMX_SC_R_M4_1_PID0, 5, true, 0}, 250 { "cm41-mu-a1", IMX_SC_R_M4_1_MU_1A, 1, false, 0}, 251 { "cm41-lpuart", IMX_SC_R_M4_1_UART, 1, false, 0}, 252 253 /* CM41 SS */ 254 { "cm41_i2c", IMX_SC_R_M4_1_I2C, 1, false, 0 }, 255 { "cm41_intmux", IMX_SC_R_M4_1_INTMUX, 1, false, 0 }, 256 257 /* DB SS */ 258 { "perf", IMX_SC_R_PERF, 1, false, 0}, 259 260 /* IMAGE SS */ 261 { "img-jpegdec-mp", IMX_SC_R_MJPEG_DEC_MP, 1, false, 0 }, 262 { "img-jpegdec-s0", IMX_SC_R_MJPEG_DEC_S0, 4, true, 0 }, 263 { "img-jpegenc-mp", IMX_SC_R_MJPEG_ENC_MP, 1, false, 0 }, 264 { "img-jpegenc-s0", IMX_SC_R_MJPEG_ENC_S0, 4, true, 0 }, 265 266 /* SECO SS */ 267 { "seco_mu", IMX_SC_R_SECO_MU_2, 3, true, 2}, 268 269 /* V2X SS */ 270 { "v2x_mu", IMX_SC_R_V2X_MU_0, 2, true, 0}, 271 { "v2x_mu", IMX_SC_R_V2X_MU_2, 1, true, 2}, 272 { "v2x_mu", IMX_SC_R_V2X_MU_3, 2, true, 3}, 273 { "img-pdma", IMX_SC_R_ISI_CH0, 8, true, 0 }, 274 { "img-csi0", IMX_SC_R_CSI_0, 1, false, 0 }, 275 { "img-csi0-i2c0", IMX_SC_R_CSI_0_I2C_0, 1, false, 0 }, 276 { "img-csi0-pwm0", IMX_SC_R_CSI_0_PWM_0, 1, false, 0 }, 277 { "img-csi1", IMX_SC_R_CSI_1, 1, false, 0 }, 278 { "img-csi1-i2c0", IMX_SC_R_CSI_1_I2C_0, 1, false, 0 }, 279 { "img-csi1-pwm0", IMX_SC_R_CSI_1_PWM_0, 1, false, 0 }, 280 { "img-parallel", IMX_SC_R_PI_0, 1, false, 0 }, 281 { "img-parallel-i2c0", IMX_SC_R_PI_0_I2C_0, 1, false, 0 }, 282 { "img-parallel-pwm0", IMX_SC_R_PI_0_PWM_0, 2, true, 0 }, 283 { "img-parallel-pll", IMX_SC_R_PI_0_PLL, 1, false, 0 }, 284 285 /* HDMI TX SS */ 286 { "hdmi-tx", IMX_SC_R_HDMI, 1, false, 0}, 287 { "hdmi-tx-i2s", IMX_SC_R_HDMI_I2S, 1, false, 0}, 288 { "hdmi-tx-i2c0", IMX_SC_R_HDMI_I2C_0, 1, false, 0}, 289 { "hdmi-tx-pll0", IMX_SC_R_HDMI_PLL_0, 1, false, 0}, 290 { "hdmi-tx-pll1", IMX_SC_R_HDMI_PLL_1, 1, false, 0}, 291 292 /* HDMI RX SS */ 293 { "hdmi-rx", IMX_SC_R_HDMI_RX, 1, false, 0}, 294 { "hdmi-rx-pwm", IMX_SC_R_HDMI_RX_PWM_0, 1, false, 0}, 295 { "hdmi-rx-i2c0", IMX_SC_R_HDMI_RX_I2C_0, 1, false, 0}, 296 { "hdmi-rx-bypass", IMX_SC_R_HDMI_RX_BYPASS, 1, false, 0}, 297 298 /* SECURITY SS */ 299 { "sec-jr", IMX_SC_R_CAAM_JR2, 2, true, 2}, 300 301 /* BOARD SS */ 302 { "board", IMX_SC_R_BOARD_R0, 8, true, 0}, 303 }; 304 305 static const struct imx_sc_pd_soc imx8qxp_scu_pd = { 306 .pd_ranges = imx8qxp_scu_pd_ranges, 307 .num_ranges = ARRAY_SIZE(imx8qxp_scu_pd_ranges), 308 }; 309 310 static struct imx_sc_ipc *pm_ipc_handle; 311 312 static inline struct imx_sc_pm_domain * 313 to_imx_sc_pd(struct generic_pm_domain *genpd) 314 { 315 return container_of(genpd, struct imx_sc_pm_domain, pd); 316 } 317 318 static void imx_sc_pd_get_console_rsrc(void) 319 { 320 struct of_phandle_args specs; 321 int ret; 322 323 if (!of_stdout) 324 return; 325 326 ret = of_parse_phandle_with_args(of_stdout, "power-domains", 327 "#power-domain-cells", 328 0, &specs); 329 if (ret) 330 return; 331 332 imx_con_rsrc = specs.args[0]; 333 } 334 335 static int imx_sc_get_pd_power(struct device *dev, u32 rsrc) 336 { 337 struct imx_sc_msg_req_get_resource_power_mode msg; 338 struct imx_sc_rpc_msg *hdr = &msg.hdr; 339 int ret; 340 341 hdr->ver = IMX_SC_RPC_VERSION; 342 hdr->svc = IMX_SC_RPC_SVC_PM; 343 hdr->func = IMX_SC_PM_FUNC_GET_RESOURCE_POWER_MODE; 344 hdr->size = 2; 345 346 msg.data.req.resource = rsrc; 347 348 ret = imx_scu_call_rpc(pm_ipc_handle, &msg, true); 349 if (ret) 350 dev_err(dev, "failed to get power resource %d mode, ret %d\n", 351 rsrc, ret); 352 353 return msg.data.resp.mode; 354 } 355 356 static int imx_sc_pd_power(struct generic_pm_domain *domain, bool power_on) 357 { 358 struct imx_sc_msg_req_set_resource_power_mode msg; 359 struct imx_sc_rpc_msg *hdr = &msg.hdr; 360 struct imx_sc_pm_domain *pd; 361 int ret; 362 363 pd = to_imx_sc_pd(domain); 364 365 hdr->ver = IMX_SC_RPC_VERSION; 366 hdr->svc = IMX_SC_RPC_SVC_PM; 367 hdr->func = IMX_SC_PM_FUNC_SET_RESOURCE_POWER_MODE; 368 hdr->size = 2; 369 370 msg.resource = pd->rsrc; 371 msg.mode = power_on ? IMX_SC_PM_PW_MODE_ON : IMX_SC_PM_PW_MODE_LP; 372 373 /* keep uart console power on for no_console_suspend */ 374 if (imx_con_rsrc == pd->rsrc && !console_suspend_enabled && !power_on) 375 return -EBUSY; 376 377 ret = imx_scu_call_rpc(pm_ipc_handle, &msg, true); 378 if (ret) 379 dev_err(&domain->dev, "failed to power %s resource %d ret %d\n", 380 power_on ? "up" : "off", pd->rsrc, ret); 381 382 return ret; 383 } 384 385 static int imx_sc_pd_power_on(struct generic_pm_domain *domain) 386 { 387 return imx_sc_pd_power(domain, true); 388 } 389 390 static int imx_sc_pd_power_off(struct generic_pm_domain *domain) 391 { 392 return imx_sc_pd_power(domain, false); 393 } 394 395 static struct generic_pm_domain *imx_scu_pd_xlate(struct of_phandle_args *spec, 396 void *data) 397 { 398 struct generic_pm_domain *domain = ERR_PTR(-ENOENT); 399 struct genpd_onecell_data *pd_data = data; 400 unsigned int i; 401 402 for (i = 0; i < pd_data->num_domains; i++) { 403 struct imx_sc_pm_domain *sc_pd; 404 405 sc_pd = to_imx_sc_pd(pd_data->domains[i]); 406 if (sc_pd->rsrc == spec->args[0]) { 407 domain = &sc_pd->pd; 408 break; 409 } 410 } 411 412 return domain; 413 } 414 415 static struct imx_sc_pm_domain * 416 imx_scu_add_pm_domain(struct device *dev, int idx, 417 const struct imx_sc_pd_range *pd_ranges) 418 { 419 struct imx_sc_pm_domain *sc_pd; 420 bool is_off; 421 int mode, ret; 422 423 if (!imx_sc_rm_is_resource_owned(pm_ipc_handle, pd_ranges->rsrc + idx)) 424 return NULL; 425 426 sc_pd = devm_kzalloc(dev, sizeof(*sc_pd), GFP_KERNEL); 427 if (!sc_pd) 428 return ERR_PTR(-ENOMEM); 429 430 sc_pd->rsrc = pd_ranges->rsrc + idx; 431 sc_pd->pd.power_off = imx_sc_pd_power_off; 432 sc_pd->pd.power_on = imx_sc_pd_power_on; 433 434 if (pd_ranges->postfix) 435 snprintf(sc_pd->name, sizeof(sc_pd->name), 436 "%s%i", pd_ranges->name, pd_ranges->start_from + idx); 437 else 438 snprintf(sc_pd->name, sizeof(sc_pd->name), 439 "%s", pd_ranges->name); 440 441 sc_pd->pd.name = sc_pd->name; 442 if (imx_con_rsrc == sc_pd->rsrc) 443 sc_pd->pd.flags = GENPD_FLAG_RPM_ALWAYS_ON; 444 445 mode = imx_sc_get_pd_power(dev, pd_ranges->rsrc + idx); 446 if (mode == IMX_SC_PM_PW_MODE_ON) 447 is_off = false; 448 else 449 is_off = true; 450 451 dev_dbg(dev, "%s : %s\n", sc_pd->name, imx_sc_pm_mode[mode]); 452 453 if (sc_pd->rsrc >= IMX_SC_R_LAST) { 454 dev_warn(dev, "invalid pd %s rsrc id %d found", 455 sc_pd->name, sc_pd->rsrc); 456 457 devm_kfree(dev, sc_pd); 458 return NULL; 459 } 460 461 ret = pm_genpd_init(&sc_pd->pd, NULL, is_off); 462 if (ret) { 463 dev_warn(dev, "failed to init pd %s rsrc id %d", 464 sc_pd->name, sc_pd->rsrc); 465 devm_kfree(dev, sc_pd); 466 return NULL; 467 } 468 469 return sc_pd; 470 } 471 472 static int imx_scu_init_pm_domains(struct device *dev, 473 const struct imx_sc_pd_soc *pd_soc) 474 { 475 const struct imx_sc_pd_range *pd_ranges = pd_soc->pd_ranges; 476 struct generic_pm_domain **domains; 477 struct genpd_onecell_data *pd_data; 478 struct imx_sc_pm_domain *sc_pd; 479 u32 count = 0; 480 int i, j; 481 482 for (i = 0; i < pd_soc->num_ranges; i++) 483 count += pd_ranges[i].num; 484 485 domains = devm_kcalloc(dev, count, sizeof(*domains), GFP_KERNEL); 486 if (!domains) 487 return -ENOMEM; 488 489 pd_data = devm_kzalloc(dev, sizeof(*pd_data), GFP_KERNEL); 490 if (!pd_data) 491 return -ENOMEM; 492 493 count = 0; 494 for (i = 0; i < pd_soc->num_ranges; i++) { 495 for (j = 0; j < pd_ranges[i].num; j++) { 496 sc_pd = imx_scu_add_pm_domain(dev, j, &pd_ranges[i]); 497 if (IS_ERR_OR_NULL(sc_pd)) 498 continue; 499 500 domains[count++] = &sc_pd->pd; 501 dev_dbg(dev, "added power domain %s\n", sc_pd->pd.name); 502 } 503 } 504 505 pd_data->domains = domains; 506 pd_data->num_domains = count; 507 pd_data->xlate = imx_scu_pd_xlate; 508 509 of_genpd_add_provider_onecell(dev->of_node, pd_data); 510 511 return 0; 512 } 513 514 static int imx_sc_pd_probe(struct platform_device *pdev) 515 { 516 const struct imx_sc_pd_soc *pd_soc; 517 int ret; 518 519 ret = imx_scu_get_handle(&pm_ipc_handle); 520 if (ret) 521 return ret; 522 523 pd_soc = of_device_get_match_data(&pdev->dev); 524 if (!pd_soc) 525 return -ENODEV; 526 527 imx_sc_pd_get_console_rsrc(); 528 529 return imx_scu_init_pm_domains(&pdev->dev, pd_soc); 530 } 531 532 static const struct of_device_id imx_sc_pd_match[] = { 533 { .compatible = "fsl,imx8qxp-scu-pd", &imx8qxp_scu_pd}, 534 { .compatible = "fsl,scu-pd", &imx8qxp_scu_pd}, 535 { /* sentinel */ } 536 }; 537 538 static struct platform_driver imx_sc_pd_driver = { 539 .driver = { 540 .name = "imx-scu-pd", 541 .of_match_table = imx_sc_pd_match, 542 .suppress_bind_attrs = true, 543 }, 544 .probe = imx_sc_pd_probe, 545 }; 546 builtin_platform_driver(imx_sc_pd_driver); 547 548 MODULE_AUTHOR("Dong Aisheng <aisheng.dong@nxp.com>"); 549 MODULE_DESCRIPTION("IMX SCU Power Domain driver"); 550 MODULE_LICENSE("GPL v2"); 551