Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright 2017 Impinj, Inc
4 * Author: Andrey Smirnov <andrew.smirnov@gmail.com>
5 *
6 * Based on the code of analogus driver:
7 *
8 * Copyright 2015-2017 Pengutronix, Lucas Stach <kernel@pengutronix.de>
9 */
10
11#include <linux/clk.h>
12#include <linux/of_device.h>
13#include <linux/platform_device.h>
14#include <linux/pm_domain.h>
15#include <linux/regmap.h>
16#include <linux/regulator/consumer.h>
17#include <linux/sizes.h>
18#include <dt-bindings/power/imx7-power.h>
19#include <dt-bindings/power/imx8mq-power.h>
20
21#define GPC_LPCR_A_CORE_BSC 0x000
22
23#define GPC_PGC_CPU_MAPPING 0x0ec
24
25#define IMX7_USB_HSIC_PHY_A_CORE_DOMAIN BIT(6)
26#define IMX7_USB_OTG2_PHY_A_CORE_DOMAIN BIT(5)
27#define IMX7_USB_OTG1_PHY_A_CORE_DOMAIN BIT(4)
28#define IMX7_PCIE_PHY_A_CORE_DOMAIN BIT(3)
29#define IMX7_MIPI_PHY_A_CORE_DOMAIN BIT(2)
30
31#define IMX8M_PCIE2_A53_DOMAIN BIT(15)
32#define IMX8M_MIPI_CSI2_A53_DOMAIN BIT(14)
33#define IMX8M_MIPI_CSI1_A53_DOMAIN BIT(13)
34#define IMX8M_DISP_A53_DOMAIN BIT(12)
35#define IMX8M_HDMI_A53_DOMAIN BIT(11)
36#define IMX8M_VPU_A53_DOMAIN BIT(10)
37#define IMX8M_GPU_A53_DOMAIN BIT(9)
38#define IMX8M_DDR2_A53_DOMAIN BIT(8)
39#define IMX8M_DDR1_A53_DOMAIN BIT(7)
40#define IMX8M_OTG2_A53_DOMAIN BIT(5)
41#define IMX8M_OTG1_A53_DOMAIN BIT(4)
42#define IMX8M_PCIE1_A53_DOMAIN BIT(3)
43#define IMX8M_MIPI_A53_DOMAIN BIT(2)
44
45#define GPC_PU_PGC_SW_PUP_REQ 0x0f8
46#define GPC_PU_PGC_SW_PDN_REQ 0x104
47
48#define IMX7_USB_HSIC_PHY_SW_Pxx_REQ BIT(4)
49#define IMX7_USB_OTG2_PHY_SW_Pxx_REQ BIT(3)
50#define IMX7_USB_OTG1_PHY_SW_Pxx_REQ BIT(2)
51#define IMX7_PCIE_PHY_SW_Pxx_REQ BIT(1)
52#define IMX7_MIPI_PHY_SW_Pxx_REQ BIT(0)
53
54#define IMX8M_PCIE2_SW_Pxx_REQ BIT(13)
55#define IMX8M_MIPI_CSI2_SW_Pxx_REQ BIT(12)
56#define IMX8M_MIPI_CSI1_SW_Pxx_REQ BIT(11)
57#define IMX8M_DISP_SW_Pxx_REQ BIT(10)
58#define IMX8M_HDMI_SW_Pxx_REQ BIT(9)
59#define IMX8M_VPU_SW_Pxx_REQ BIT(8)
60#define IMX8M_GPU_SW_Pxx_REQ BIT(7)
61#define IMX8M_DDR2_SW_Pxx_REQ BIT(6)
62#define IMX8M_DDR1_SW_Pxx_REQ BIT(5)
63#define IMX8M_OTG2_SW_Pxx_REQ BIT(3)
64#define IMX8M_OTG1_SW_Pxx_REQ BIT(2)
65#define IMX8M_PCIE1_SW_Pxx_REQ BIT(1)
66#define IMX8M_MIPI_SW_Pxx_REQ BIT(0)
67
68#define GPC_M4_PU_PDN_FLG 0x1bc
69
70#define GPC_PU_PWRHSK 0x1fc
71
72#define IMX8M_GPU_HSK_PWRDNREQN BIT(6)
73#define IMX8M_VPU_HSK_PWRDNREQN BIT(5)
74#define IMX8M_DISP_HSK_PWRDNREQN BIT(4)
75
76/*
77 * The PGC offset values in Reference Manual
78 * (Rev. 1, 01/2018 and the older ones) GPC chapter's
79 * GPC_PGC memory map are incorrect, below offset
80 * values are from design RTL.
81 */
82#define IMX7_PGC_MIPI 16
83#define IMX7_PGC_PCIE 17
84#define IMX7_PGC_USB_HSIC 20
85
86#define IMX8M_PGC_MIPI 16
87#define IMX8M_PGC_PCIE1 17
88#define IMX8M_PGC_OTG1 18
89#define IMX8M_PGC_OTG2 19
90#define IMX8M_PGC_DDR1 21
91#define IMX8M_PGC_GPU 23
92#define IMX8M_PGC_VPU 24
93#define IMX8M_PGC_DISP 26
94#define IMX8M_PGC_MIPI_CSI1 27
95#define IMX8M_PGC_MIPI_CSI2 28
96#define IMX8M_PGC_PCIE2 29
97
98#define GPC_PGC_CTRL(n) (0x800 + (n) * 0x40)
99#define GPC_PGC_SR(n) (GPC_PGC_CTRL(n) + 0xc)
100
101#define GPC_PGC_CTRL_PCR BIT(0)
102
103#define GPC_CLK_MAX 6
104
105struct imx_pgc_domain {
106 struct generic_pm_domain genpd;
107 struct regmap *regmap;
108 struct regulator *regulator;
109 struct clk *clk[GPC_CLK_MAX];
110 int num_clks;
111
112 unsigned int pgc;
113
114 const struct {
115 u32 pxx;
116 u32 map;
117 u32 hsk;
118 } bits;
119
120 const int voltage;
121 struct device *dev;
122};
123
124struct imx_pgc_domain_data {
125 const struct imx_pgc_domain *domains;
126 size_t domains_num;
127 const struct regmap_access_table *reg_access_table;
128};
129
130static int imx_gpc_pu_pgc_sw_pxx_req(struct generic_pm_domain *genpd,
131 bool on)
132{
133 struct imx_pgc_domain *domain = container_of(genpd,
134 struct imx_pgc_domain,
135 genpd);
136 unsigned int offset = on ?
137 GPC_PU_PGC_SW_PUP_REQ : GPC_PU_PGC_SW_PDN_REQ;
138 const bool enable_power_control = !on;
139 const bool has_regulator = !IS_ERR(domain->regulator);
140 int i, ret = 0;
141 u32 pxx_req;
142
143 regmap_update_bits(domain->regmap, GPC_PGC_CPU_MAPPING,
144 domain->bits.map, domain->bits.map);
145
146 if (has_regulator && on) {
147 ret = regulator_enable(domain->regulator);
148 if (ret) {
149 dev_err(domain->dev, "failed to enable regulator\n");
150 goto unmap;
151 }
152 }
153
154 /* Enable reset clocks for all devices in the domain */
155 for (i = 0; i < domain->num_clks; i++)
156 clk_prepare_enable(domain->clk[i]);
157
158 if (enable_power_control)
159 regmap_update_bits(domain->regmap, GPC_PGC_CTRL(domain->pgc),
160 GPC_PGC_CTRL_PCR, GPC_PGC_CTRL_PCR);
161
162 if (domain->bits.hsk)
163 regmap_update_bits(domain->regmap, GPC_PU_PWRHSK,
164 domain->bits.hsk, on ? domain->bits.hsk : 0);
165
166 regmap_update_bits(domain->regmap, offset,
167 domain->bits.pxx, domain->bits.pxx);
168
169 /*
170 * As per "5.5.9.4 Example Code 4" in IMX7DRM.pdf wait
171 * for PUP_REQ/PDN_REQ bit to be cleared
172 */
173 ret = regmap_read_poll_timeout(domain->regmap, offset, pxx_req,
174 !(pxx_req & domain->bits.pxx),
175 0, USEC_PER_MSEC);
176 if (ret) {
177 dev_err(domain->dev, "failed to command PGC\n");
178 /*
179 * If we were in a process of enabling a
180 * domain and failed we might as well disable
181 * the regulator we just enabled. And if it
182 * was the opposite situation and we failed to
183 * power down -- keep the regulator on
184 */
185 on = !on;
186 }
187
188 if (enable_power_control)
189 regmap_update_bits(domain->regmap, GPC_PGC_CTRL(domain->pgc),
190 GPC_PGC_CTRL_PCR, 0);
191
192 /* Disable reset clocks for all devices in the domain */
193 for (i = 0; i < domain->num_clks; i++)
194 clk_disable_unprepare(domain->clk[i]);
195
196 if (has_regulator && !on) {
197 int err;
198
199 err = regulator_disable(domain->regulator);
200 if (err)
201 dev_err(domain->dev,
202 "failed to disable regulator: %d\n", err);
203 /* Preserve earlier error code */
204 ret = ret ?: err;
205 }
206unmap:
207 regmap_update_bits(domain->regmap, GPC_PGC_CPU_MAPPING,
208 domain->bits.map, 0);
209 return ret;
210}
211
212static int imx_gpc_pu_pgc_sw_pup_req(struct generic_pm_domain *genpd)
213{
214 return imx_gpc_pu_pgc_sw_pxx_req(genpd, true);
215}
216
217static int imx_gpc_pu_pgc_sw_pdn_req(struct generic_pm_domain *genpd)
218{
219 return imx_gpc_pu_pgc_sw_pxx_req(genpd, false);
220}
221
222static const struct imx_pgc_domain imx7_pgc_domains[] = {
223 [IMX7_POWER_DOMAIN_MIPI_PHY] = {
224 .genpd = {
225 .name = "mipi-phy",
226 },
227 .bits = {
228 .pxx = IMX7_MIPI_PHY_SW_Pxx_REQ,
229 .map = IMX7_MIPI_PHY_A_CORE_DOMAIN,
230 },
231 .voltage = 1000000,
232 .pgc = IMX7_PGC_MIPI,
233 },
234
235 [IMX7_POWER_DOMAIN_PCIE_PHY] = {
236 .genpd = {
237 .name = "pcie-phy",
238 },
239 .bits = {
240 .pxx = IMX7_PCIE_PHY_SW_Pxx_REQ,
241 .map = IMX7_PCIE_PHY_A_CORE_DOMAIN,
242 },
243 .voltage = 1000000,
244 .pgc = IMX7_PGC_PCIE,
245 },
246
247 [IMX7_POWER_DOMAIN_USB_HSIC_PHY] = {
248 .genpd = {
249 .name = "usb-hsic-phy",
250 },
251 .bits = {
252 .pxx = IMX7_USB_HSIC_PHY_SW_Pxx_REQ,
253 .map = IMX7_USB_HSIC_PHY_A_CORE_DOMAIN,
254 },
255 .voltage = 1200000,
256 .pgc = IMX7_PGC_USB_HSIC,
257 },
258};
259
260static const struct regmap_range imx7_yes_ranges[] = {
261 regmap_reg_range(GPC_LPCR_A_CORE_BSC,
262 GPC_M4_PU_PDN_FLG),
263 regmap_reg_range(GPC_PGC_CTRL(IMX7_PGC_MIPI),
264 GPC_PGC_SR(IMX7_PGC_MIPI)),
265 regmap_reg_range(GPC_PGC_CTRL(IMX7_PGC_PCIE),
266 GPC_PGC_SR(IMX7_PGC_PCIE)),
267 regmap_reg_range(GPC_PGC_CTRL(IMX7_PGC_USB_HSIC),
268 GPC_PGC_SR(IMX7_PGC_USB_HSIC)),
269};
270
271static const struct regmap_access_table imx7_access_table = {
272 .yes_ranges = imx7_yes_ranges,
273 .n_yes_ranges = ARRAY_SIZE(imx7_yes_ranges),
274};
275
276static const struct imx_pgc_domain_data imx7_pgc_domain_data = {
277 .domains = imx7_pgc_domains,
278 .domains_num = ARRAY_SIZE(imx7_pgc_domains),
279 .reg_access_table = &imx7_access_table,
280};
281
282static const struct imx_pgc_domain imx8m_pgc_domains[] = {
283 [IMX8M_POWER_DOMAIN_MIPI] = {
284 .genpd = {
285 .name = "mipi",
286 },
287 .bits = {
288 .pxx = IMX8M_MIPI_SW_Pxx_REQ,
289 .map = IMX8M_MIPI_A53_DOMAIN,
290 },
291 .pgc = IMX8M_PGC_MIPI,
292 },
293
294 [IMX8M_POWER_DOMAIN_PCIE1] = {
295 .genpd = {
296 .name = "pcie1",
297 },
298 .bits = {
299 .pxx = IMX8M_PCIE1_SW_Pxx_REQ,
300 .map = IMX8M_PCIE1_A53_DOMAIN,
301 },
302 .pgc = IMX8M_PGC_PCIE1,
303 },
304
305 [IMX8M_POWER_DOMAIN_USB_OTG1] = {
306 .genpd = {
307 .name = "usb-otg1",
308 },
309 .bits = {
310 .pxx = IMX8M_OTG1_SW_Pxx_REQ,
311 .map = IMX8M_OTG1_A53_DOMAIN,
312 },
313 .pgc = IMX8M_PGC_OTG1,
314 },
315
316 [IMX8M_POWER_DOMAIN_USB_OTG2] = {
317 .genpd = {
318 .name = "usb-otg2",
319 },
320 .bits = {
321 .pxx = IMX8M_OTG2_SW_Pxx_REQ,
322 .map = IMX8M_OTG2_A53_DOMAIN,
323 },
324 .pgc = IMX8M_PGC_OTG2,
325 },
326
327 [IMX8M_POWER_DOMAIN_DDR1] = {
328 .genpd = {
329 .name = "ddr1",
330 },
331 .bits = {
332 .pxx = IMX8M_DDR1_SW_Pxx_REQ,
333 .map = IMX8M_DDR2_A53_DOMAIN,
334 },
335 .pgc = IMX8M_PGC_DDR1,
336 },
337
338 [IMX8M_POWER_DOMAIN_GPU] = {
339 .genpd = {
340 .name = "gpu",
341 },
342 .bits = {
343 .pxx = IMX8M_GPU_SW_Pxx_REQ,
344 .map = IMX8M_GPU_A53_DOMAIN,
345 .hsk = IMX8M_GPU_HSK_PWRDNREQN,
346 },
347 .pgc = IMX8M_PGC_GPU,
348 },
349
350 [IMX8M_POWER_DOMAIN_VPU] = {
351 .genpd = {
352 .name = "vpu",
353 },
354 .bits = {
355 .pxx = IMX8M_VPU_SW_Pxx_REQ,
356 .map = IMX8M_VPU_A53_DOMAIN,
357 .hsk = IMX8M_VPU_HSK_PWRDNREQN,
358 },
359 .pgc = IMX8M_PGC_VPU,
360 },
361
362 [IMX8M_POWER_DOMAIN_DISP] = {
363 .genpd = {
364 .name = "disp",
365 },
366 .bits = {
367 .pxx = IMX8M_DISP_SW_Pxx_REQ,
368 .map = IMX8M_DISP_A53_DOMAIN,
369 .hsk = IMX8M_DISP_HSK_PWRDNREQN,
370 },
371 .pgc = IMX8M_PGC_DISP,
372 },
373
374 [IMX8M_POWER_DOMAIN_MIPI_CSI1] = {
375 .genpd = {
376 .name = "mipi-csi1",
377 },
378 .bits = {
379 .pxx = IMX8M_MIPI_CSI1_SW_Pxx_REQ,
380 .map = IMX8M_MIPI_CSI1_A53_DOMAIN,
381 },
382 .pgc = IMX8M_PGC_MIPI_CSI1,
383 },
384
385 [IMX8M_POWER_DOMAIN_MIPI_CSI2] = {
386 .genpd = {
387 .name = "mipi-csi2",
388 },
389 .bits = {
390 .pxx = IMX8M_MIPI_CSI2_SW_Pxx_REQ,
391 .map = IMX8M_MIPI_CSI2_A53_DOMAIN,
392 },
393 .pgc = IMX8M_PGC_MIPI_CSI2,
394 },
395
396 [IMX8M_POWER_DOMAIN_PCIE2] = {
397 .genpd = {
398 .name = "pcie2",
399 },
400 .bits = {
401 .pxx = IMX8M_PCIE2_SW_Pxx_REQ,
402 .map = IMX8M_PCIE2_A53_DOMAIN,
403 },
404 .pgc = IMX8M_PGC_PCIE2,
405 },
406};
407
408static const struct regmap_range imx8m_yes_ranges[] = {
409 regmap_reg_range(GPC_LPCR_A_CORE_BSC,
410 GPC_PU_PWRHSK),
411 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_MIPI),
412 GPC_PGC_SR(IMX8M_PGC_MIPI)),
413 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_PCIE1),
414 GPC_PGC_SR(IMX8M_PGC_PCIE1)),
415 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_OTG1),
416 GPC_PGC_SR(IMX8M_PGC_OTG1)),
417 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_OTG2),
418 GPC_PGC_SR(IMX8M_PGC_OTG2)),
419 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_DDR1),
420 GPC_PGC_SR(IMX8M_PGC_DDR1)),
421 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_GPU),
422 GPC_PGC_SR(IMX8M_PGC_GPU)),
423 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_VPU),
424 GPC_PGC_SR(IMX8M_PGC_VPU)),
425 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_DISP),
426 GPC_PGC_SR(IMX8M_PGC_DISP)),
427 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_MIPI_CSI1),
428 GPC_PGC_SR(IMX8M_PGC_MIPI_CSI1)),
429 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_MIPI_CSI2),
430 GPC_PGC_SR(IMX8M_PGC_MIPI_CSI2)),
431 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_PCIE2),
432 GPC_PGC_SR(IMX8M_PGC_PCIE2)),
433};
434
435static const struct regmap_access_table imx8m_access_table = {
436 .yes_ranges = imx8m_yes_ranges,
437 .n_yes_ranges = ARRAY_SIZE(imx8m_yes_ranges),
438};
439
440static const struct imx_pgc_domain_data imx8m_pgc_domain_data = {
441 .domains = imx8m_pgc_domains,
442 .domains_num = ARRAY_SIZE(imx8m_pgc_domains),
443 .reg_access_table = &imx8m_access_table,
444};
445
446static int imx_pgc_get_clocks(struct imx_pgc_domain *domain)
447{
448 int i, ret;
449
450 for (i = 0; ; i++) {
451 struct clk *clk = of_clk_get(domain->dev->of_node, i);
452 if (IS_ERR(clk))
453 break;
454 if (i >= GPC_CLK_MAX) {
455 dev_err(domain->dev, "more than %d clocks\n",
456 GPC_CLK_MAX);
457 ret = -EINVAL;
458 goto clk_err;
459 }
460 domain->clk[i] = clk;
461 }
462 domain->num_clks = i;
463
464 return 0;
465
466clk_err:
467 while (i--)
468 clk_put(domain->clk[i]);
469
470 return ret;
471}
472
473static void imx_pgc_put_clocks(struct imx_pgc_domain *domain)
474{
475 int i;
476
477 for (i = domain->num_clks - 1; i >= 0; i--)
478 clk_put(domain->clk[i]);
479}
480
481static int imx_pgc_domain_probe(struct platform_device *pdev)
482{
483 struct imx_pgc_domain *domain = pdev->dev.platform_data;
484 int ret;
485
486 domain->dev = &pdev->dev;
487
488 domain->regulator = devm_regulator_get_optional(domain->dev, "power");
489 if (IS_ERR(domain->regulator)) {
490 if (PTR_ERR(domain->regulator) != -ENODEV) {
491 if (PTR_ERR(domain->regulator) != -EPROBE_DEFER)
492 dev_err(domain->dev, "Failed to get domain's regulator\n");
493 return PTR_ERR(domain->regulator);
494 }
495 } else if (domain->voltage) {
496 regulator_set_voltage(domain->regulator,
497 domain->voltage, domain->voltage);
498 }
499
500 ret = imx_pgc_get_clocks(domain);
501 if (ret) {
502 if (ret != -EPROBE_DEFER)
503 dev_err(domain->dev, "Failed to get domain's clocks\n");
504 return ret;
505 }
506
507 ret = pm_genpd_init(&domain->genpd, NULL, true);
508 if (ret) {
509 dev_err(domain->dev, "Failed to init power domain\n");
510 imx_pgc_put_clocks(domain);
511 return ret;
512 }
513
514 ret = of_genpd_add_provider_simple(domain->dev->of_node,
515 &domain->genpd);
516 if (ret) {
517 dev_err(domain->dev, "Failed to add genpd provider\n");
518 pm_genpd_remove(&domain->genpd);
519 imx_pgc_put_clocks(domain);
520 }
521
522 return ret;
523}
524
525static int imx_pgc_domain_remove(struct platform_device *pdev)
526{
527 struct imx_pgc_domain *domain = pdev->dev.platform_data;
528
529 of_genpd_del_provider(domain->dev->of_node);
530 pm_genpd_remove(&domain->genpd);
531 imx_pgc_put_clocks(domain);
532
533 return 0;
534}
535
536static const struct platform_device_id imx_pgc_domain_id[] = {
537 { "imx-pgc-domain", },
538 { },
539};
540
541static struct platform_driver imx_pgc_domain_driver = {
542 .driver = {
543 .name = "imx-pgc",
544 },
545 .probe = imx_pgc_domain_probe,
546 .remove = imx_pgc_domain_remove,
547 .id_table = imx_pgc_domain_id,
548};
549builtin_platform_driver(imx_pgc_domain_driver)
550
551static int imx_gpcv2_probe(struct platform_device *pdev)
552{
553 const struct imx_pgc_domain_data *domain_data =
554 of_device_get_match_data(&pdev->dev);
555
556 struct regmap_config regmap_config = {
557 .reg_bits = 32,
558 .val_bits = 32,
559 .reg_stride = 4,
560 .rd_table = domain_data->reg_access_table,
561 .wr_table = domain_data->reg_access_table,
562 .max_register = SZ_4K,
563 };
564 struct device *dev = &pdev->dev;
565 struct device_node *pgc_np, *np;
566 struct regmap *regmap;
567 void __iomem *base;
568 int ret;
569
570 pgc_np = of_get_child_by_name(dev->of_node, "pgc");
571 if (!pgc_np) {
572 dev_err(dev, "No power domains specified in DT\n");
573 return -EINVAL;
574 }
575
576 base = devm_platform_ioremap_resource(pdev, 0);
577 if (IS_ERR(base))
578 return PTR_ERR(base);
579
580 regmap = devm_regmap_init_mmio(dev, base, ®map_config);
581 if (IS_ERR(regmap)) {
582 ret = PTR_ERR(regmap);
583 dev_err(dev, "failed to init regmap (%d)\n", ret);
584 return ret;
585 }
586
587 for_each_child_of_node(pgc_np, np) {
588 struct platform_device *pd_pdev;
589 struct imx_pgc_domain *domain;
590 u32 domain_index;
591
592 ret = of_property_read_u32(np, "reg", &domain_index);
593 if (ret) {
594 dev_err(dev, "Failed to read 'reg' property\n");
595 of_node_put(np);
596 return ret;
597 }
598
599 if (domain_index >= domain_data->domains_num) {
600 dev_warn(dev,
601 "Domain index %d is out of bounds\n",
602 domain_index);
603 continue;
604 }
605
606 pd_pdev = platform_device_alloc("imx-pgc-domain",
607 domain_index);
608 if (!pd_pdev) {
609 dev_err(dev, "Failed to allocate platform device\n");
610 of_node_put(np);
611 return -ENOMEM;
612 }
613
614 ret = platform_device_add_data(pd_pdev,
615 &domain_data->domains[domain_index],
616 sizeof(domain_data->domains[domain_index]));
617 if (ret) {
618 platform_device_put(pd_pdev);
619 of_node_put(np);
620 return ret;
621 }
622
623 domain = pd_pdev->dev.platform_data;
624 domain->regmap = regmap;
625 domain->genpd.power_on = imx_gpc_pu_pgc_sw_pup_req;
626 domain->genpd.power_off = imx_gpc_pu_pgc_sw_pdn_req;
627
628 pd_pdev->dev.parent = dev;
629 pd_pdev->dev.of_node = np;
630
631 ret = platform_device_add(pd_pdev);
632 if (ret) {
633 platform_device_put(pd_pdev);
634 of_node_put(np);
635 return ret;
636 }
637 }
638
639 return 0;
640}
641
642static const struct of_device_id imx_gpcv2_dt_ids[] = {
643 { .compatible = "fsl,imx7d-gpc", .data = &imx7_pgc_domain_data, },
644 { .compatible = "fsl,imx8mq-gpc", .data = &imx8m_pgc_domain_data, },
645 { }
646};
647
648static struct platform_driver imx_gpc_driver = {
649 .driver = {
650 .name = "imx-gpcv2",
651 .of_match_table = imx_gpcv2_dt_ids,
652 },
653 .probe = imx_gpcv2_probe,
654};
655builtin_platform_driver(imx_gpc_driver)
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright 2017 Impinj, Inc
4 * Author: Andrey Smirnov <andrew.smirnov@gmail.com>
5 *
6 * Based on the code of analogus driver:
7 *
8 * Copyright 2015-2017 Pengutronix, Lucas Stach <kernel@pengutronix.de>
9 */
10
11#include <linux/clk.h>
12#include <linux/of_device.h>
13#include <linux/platform_device.h>
14#include <linux/pm_domain.h>
15#include <linux/regmap.h>
16#include <linux/regulator/consumer.h>
17#include <dt-bindings/power/imx7-power.h>
18#include <dt-bindings/power/imx8mq-power.h>
19
20#define GPC_LPCR_A_CORE_BSC 0x000
21
22#define GPC_PGC_CPU_MAPPING 0x0ec
23
24#define IMX7_USB_HSIC_PHY_A_CORE_DOMAIN BIT(6)
25#define IMX7_USB_OTG2_PHY_A_CORE_DOMAIN BIT(5)
26#define IMX7_USB_OTG1_PHY_A_CORE_DOMAIN BIT(4)
27#define IMX7_PCIE_PHY_A_CORE_DOMAIN BIT(3)
28#define IMX7_MIPI_PHY_A_CORE_DOMAIN BIT(2)
29
30#define IMX8M_PCIE2_A53_DOMAIN BIT(15)
31#define IMX8M_MIPI_CSI2_A53_DOMAIN BIT(14)
32#define IMX8M_MIPI_CSI1_A53_DOMAIN BIT(13)
33#define IMX8M_DISP_A53_DOMAIN BIT(12)
34#define IMX8M_HDMI_A53_DOMAIN BIT(11)
35#define IMX8M_VPU_A53_DOMAIN BIT(10)
36#define IMX8M_GPU_A53_DOMAIN BIT(9)
37#define IMX8M_DDR2_A53_DOMAIN BIT(8)
38#define IMX8M_DDR1_A53_DOMAIN BIT(7)
39#define IMX8M_OTG2_A53_DOMAIN BIT(5)
40#define IMX8M_OTG1_A53_DOMAIN BIT(4)
41#define IMX8M_PCIE1_A53_DOMAIN BIT(3)
42#define IMX8M_MIPI_A53_DOMAIN BIT(2)
43
44#define GPC_PU_PGC_SW_PUP_REQ 0x0f8
45#define GPC_PU_PGC_SW_PDN_REQ 0x104
46
47#define IMX7_USB_HSIC_PHY_SW_Pxx_REQ BIT(4)
48#define IMX7_USB_OTG2_PHY_SW_Pxx_REQ BIT(3)
49#define IMX7_USB_OTG1_PHY_SW_Pxx_REQ BIT(2)
50#define IMX7_PCIE_PHY_SW_Pxx_REQ BIT(1)
51#define IMX7_MIPI_PHY_SW_Pxx_REQ BIT(0)
52
53#define IMX8M_PCIE2_SW_Pxx_REQ BIT(13)
54#define IMX8M_MIPI_CSI2_SW_Pxx_REQ BIT(12)
55#define IMX8M_MIPI_CSI1_SW_Pxx_REQ BIT(11)
56#define IMX8M_DISP_SW_Pxx_REQ BIT(10)
57#define IMX8M_HDMI_SW_Pxx_REQ BIT(9)
58#define IMX8M_VPU_SW_Pxx_REQ BIT(8)
59#define IMX8M_GPU_SW_Pxx_REQ BIT(7)
60#define IMX8M_DDR2_SW_Pxx_REQ BIT(6)
61#define IMX8M_DDR1_SW_Pxx_REQ BIT(5)
62#define IMX8M_OTG2_SW_Pxx_REQ BIT(3)
63#define IMX8M_OTG1_SW_Pxx_REQ BIT(2)
64#define IMX8M_PCIE1_SW_Pxx_REQ BIT(1)
65#define IMX8M_MIPI_SW_Pxx_REQ BIT(0)
66
67#define GPC_M4_PU_PDN_FLG 0x1bc
68
69#define GPC_PU_PWRHSK 0x1fc
70
71#define IMX8M_GPU_HSK_PWRDNREQN BIT(6)
72#define IMX8M_VPU_HSK_PWRDNREQN BIT(5)
73#define IMX8M_DISP_HSK_PWRDNREQN BIT(4)
74
75/*
76 * The PGC offset values in Reference Manual
77 * (Rev. 1, 01/2018 and the older ones) GPC chapter's
78 * GPC_PGC memory map are incorrect, below offset
79 * values are from design RTL.
80 */
81#define IMX7_PGC_MIPI 16
82#define IMX7_PGC_PCIE 17
83#define IMX7_PGC_USB_HSIC 20
84
85#define IMX8M_PGC_MIPI 16
86#define IMX8M_PGC_PCIE1 17
87#define IMX8M_PGC_OTG1 18
88#define IMX8M_PGC_OTG2 19
89#define IMX8M_PGC_DDR1 21
90#define IMX8M_PGC_GPU 23
91#define IMX8M_PGC_VPU 24
92#define IMX8M_PGC_DISP 26
93#define IMX8M_PGC_MIPI_CSI1 27
94#define IMX8M_PGC_MIPI_CSI2 28
95#define IMX8M_PGC_PCIE2 29
96
97#define GPC_PGC_CTRL(n) (0x800 + (n) * 0x40)
98#define GPC_PGC_SR(n) (GPC_PGC_CTRL(n) + 0xc)
99
100#define GPC_PGC_CTRL_PCR BIT(0)
101
102#define GPC_CLK_MAX 6
103
104struct imx_pgc_domain {
105 struct generic_pm_domain genpd;
106 struct regmap *regmap;
107 struct regulator *regulator;
108 struct clk *clk[GPC_CLK_MAX];
109 int num_clks;
110
111 unsigned int pgc;
112
113 const struct {
114 u32 pxx;
115 u32 map;
116 u32 hsk;
117 } bits;
118
119 const int voltage;
120 struct device *dev;
121};
122
123struct imx_pgc_domain_data {
124 const struct imx_pgc_domain *domains;
125 size_t domains_num;
126 const struct regmap_access_table *reg_access_table;
127};
128
129static int imx_gpc_pu_pgc_sw_pxx_req(struct generic_pm_domain *genpd,
130 bool on)
131{
132 struct imx_pgc_domain *domain = container_of(genpd,
133 struct imx_pgc_domain,
134 genpd);
135 unsigned int offset = on ?
136 GPC_PU_PGC_SW_PUP_REQ : GPC_PU_PGC_SW_PDN_REQ;
137 const bool enable_power_control = !on;
138 const bool has_regulator = !IS_ERR(domain->regulator);
139 int i, ret = 0;
140 u32 pxx_req;
141
142 regmap_update_bits(domain->regmap, GPC_PGC_CPU_MAPPING,
143 domain->bits.map, domain->bits.map);
144
145 if (has_regulator && on) {
146 ret = regulator_enable(domain->regulator);
147 if (ret) {
148 dev_err(domain->dev, "failed to enable regulator\n");
149 goto unmap;
150 }
151 }
152
153 /* Enable reset clocks for all devices in the domain */
154 for (i = 0; i < domain->num_clks; i++)
155 clk_prepare_enable(domain->clk[i]);
156
157 if (enable_power_control)
158 regmap_update_bits(domain->regmap, GPC_PGC_CTRL(domain->pgc),
159 GPC_PGC_CTRL_PCR, GPC_PGC_CTRL_PCR);
160
161 if (domain->bits.hsk)
162 regmap_update_bits(domain->regmap, GPC_PU_PWRHSK,
163 domain->bits.hsk, on ? domain->bits.hsk : 0);
164
165 regmap_update_bits(domain->regmap, offset,
166 domain->bits.pxx, domain->bits.pxx);
167
168 /*
169 * As per "5.5.9.4 Example Code 4" in IMX7DRM.pdf wait
170 * for PUP_REQ/PDN_REQ bit to be cleared
171 */
172 ret = regmap_read_poll_timeout(domain->regmap, offset, pxx_req,
173 !(pxx_req & domain->bits.pxx),
174 0, USEC_PER_MSEC);
175 if (ret) {
176 dev_err(domain->dev, "failed to command PGC\n");
177 /*
178 * If we were in a process of enabling a
179 * domain and failed we might as well disable
180 * the regulator we just enabled. And if it
181 * was the opposite situation and we failed to
182 * power down -- keep the regulator on
183 */
184 on = !on;
185 }
186
187 if (enable_power_control)
188 regmap_update_bits(domain->regmap, GPC_PGC_CTRL(domain->pgc),
189 GPC_PGC_CTRL_PCR, 0);
190
191 /* Disable reset clocks for all devices in the domain */
192 for (i = 0; i < domain->num_clks; i++)
193 clk_disable_unprepare(domain->clk[i]);
194
195 if (has_regulator && !on) {
196 int err;
197
198 err = regulator_disable(domain->regulator);
199 if (err)
200 dev_err(domain->dev,
201 "failed to disable regulator: %d\n", err);
202 /* Preserve earlier error code */
203 ret = ret ?: err;
204 }
205unmap:
206 regmap_update_bits(domain->regmap, GPC_PGC_CPU_MAPPING,
207 domain->bits.map, 0);
208 return ret;
209}
210
211static int imx_gpc_pu_pgc_sw_pup_req(struct generic_pm_domain *genpd)
212{
213 return imx_gpc_pu_pgc_sw_pxx_req(genpd, true);
214}
215
216static int imx_gpc_pu_pgc_sw_pdn_req(struct generic_pm_domain *genpd)
217{
218 return imx_gpc_pu_pgc_sw_pxx_req(genpd, false);
219}
220
221static const struct imx_pgc_domain imx7_pgc_domains[] = {
222 [IMX7_POWER_DOMAIN_MIPI_PHY] = {
223 .genpd = {
224 .name = "mipi-phy",
225 },
226 .bits = {
227 .pxx = IMX7_MIPI_PHY_SW_Pxx_REQ,
228 .map = IMX7_MIPI_PHY_A_CORE_DOMAIN,
229 },
230 .voltage = 1000000,
231 .pgc = IMX7_PGC_MIPI,
232 },
233
234 [IMX7_POWER_DOMAIN_PCIE_PHY] = {
235 .genpd = {
236 .name = "pcie-phy",
237 },
238 .bits = {
239 .pxx = IMX7_PCIE_PHY_SW_Pxx_REQ,
240 .map = IMX7_PCIE_PHY_A_CORE_DOMAIN,
241 },
242 .voltage = 1000000,
243 .pgc = IMX7_PGC_PCIE,
244 },
245
246 [IMX7_POWER_DOMAIN_USB_HSIC_PHY] = {
247 .genpd = {
248 .name = "usb-hsic-phy",
249 },
250 .bits = {
251 .pxx = IMX7_USB_HSIC_PHY_SW_Pxx_REQ,
252 .map = IMX7_USB_HSIC_PHY_A_CORE_DOMAIN,
253 },
254 .voltage = 1200000,
255 .pgc = IMX7_PGC_USB_HSIC,
256 },
257};
258
259static const struct regmap_range imx7_yes_ranges[] = {
260 regmap_reg_range(GPC_LPCR_A_CORE_BSC,
261 GPC_M4_PU_PDN_FLG),
262 regmap_reg_range(GPC_PGC_CTRL(IMX7_PGC_MIPI),
263 GPC_PGC_SR(IMX7_PGC_MIPI)),
264 regmap_reg_range(GPC_PGC_CTRL(IMX7_PGC_PCIE),
265 GPC_PGC_SR(IMX7_PGC_PCIE)),
266 regmap_reg_range(GPC_PGC_CTRL(IMX7_PGC_USB_HSIC),
267 GPC_PGC_SR(IMX7_PGC_USB_HSIC)),
268};
269
270static const struct regmap_access_table imx7_access_table = {
271 .yes_ranges = imx7_yes_ranges,
272 .n_yes_ranges = ARRAY_SIZE(imx7_yes_ranges),
273};
274
275static const struct imx_pgc_domain_data imx7_pgc_domain_data = {
276 .domains = imx7_pgc_domains,
277 .domains_num = ARRAY_SIZE(imx7_pgc_domains),
278 .reg_access_table = &imx7_access_table,
279};
280
281static const struct imx_pgc_domain imx8m_pgc_domains[] = {
282 [IMX8M_POWER_DOMAIN_MIPI] = {
283 .genpd = {
284 .name = "mipi",
285 },
286 .bits = {
287 .pxx = IMX8M_MIPI_SW_Pxx_REQ,
288 .map = IMX8M_MIPI_A53_DOMAIN,
289 },
290 .pgc = IMX8M_PGC_MIPI,
291 },
292
293 [IMX8M_POWER_DOMAIN_PCIE1] = {
294 .genpd = {
295 .name = "pcie1",
296 },
297 .bits = {
298 .pxx = IMX8M_PCIE1_SW_Pxx_REQ,
299 .map = IMX8M_PCIE1_A53_DOMAIN,
300 },
301 .pgc = IMX8M_PGC_PCIE1,
302 },
303
304 [IMX8M_POWER_DOMAIN_USB_OTG1] = {
305 .genpd = {
306 .name = "usb-otg1",
307 },
308 .bits = {
309 .pxx = IMX8M_OTG1_SW_Pxx_REQ,
310 .map = IMX8M_OTG1_A53_DOMAIN,
311 },
312 .pgc = IMX8M_PGC_OTG1,
313 },
314
315 [IMX8M_POWER_DOMAIN_USB_OTG2] = {
316 .genpd = {
317 .name = "usb-otg2",
318 },
319 .bits = {
320 .pxx = IMX8M_OTG2_SW_Pxx_REQ,
321 .map = IMX8M_OTG2_A53_DOMAIN,
322 },
323 .pgc = IMX8M_PGC_OTG2,
324 },
325
326 [IMX8M_POWER_DOMAIN_DDR1] = {
327 .genpd = {
328 .name = "ddr1",
329 },
330 .bits = {
331 .pxx = IMX8M_DDR1_SW_Pxx_REQ,
332 .map = IMX8M_DDR2_A53_DOMAIN,
333 },
334 .pgc = IMX8M_PGC_DDR1,
335 },
336
337 [IMX8M_POWER_DOMAIN_GPU] = {
338 .genpd = {
339 .name = "gpu",
340 },
341 .bits = {
342 .pxx = IMX8M_GPU_SW_Pxx_REQ,
343 .map = IMX8M_GPU_A53_DOMAIN,
344 .hsk = IMX8M_GPU_HSK_PWRDNREQN,
345 },
346 .pgc = IMX8M_PGC_GPU,
347 },
348
349 [IMX8M_POWER_DOMAIN_VPU] = {
350 .genpd = {
351 .name = "vpu",
352 },
353 .bits = {
354 .pxx = IMX8M_VPU_SW_Pxx_REQ,
355 .map = IMX8M_VPU_A53_DOMAIN,
356 .hsk = IMX8M_VPU_HSK_PWRDNREQN,
357 },
358 .pgc = IMX8M_PGC_VPU,
359 },
360
361 [IMX8M_POWER_DOMAIN_DISP] = {
362 .genpd = {
363 .name = "disp",
364 },
365 .bits = {
366 .pxx = IMX8M_DISP_SW_Pxx_REQ,
367 .map = IMX8M_DISP_A53_DOMAIN,
368 .hsk = IMX8M_DISP_HSK_PWRDNREQN,
369 },
370 .pgc = IMX8M_PGC_DISP,
371 },
372
373 [IMX8M_POWER_DOMAIN_MIPI_CSI1] = {
374 .genpd = {
375 .name = "mipi-csi1",
376 },
377 .bits = {
378 .pxx = IMX8M_MIPI_CSI1_SW_Pxx_REQ,
379 .map = IMX8M_MIPI_CSI1_A53_DOMAIN,
380 },
381 .pgc = IMX8M_PGC_MIPI_CSI1,
382 },
383
384 [IMX8M_POWER_DOMAIN_MIPI_CSI2] = {
385 .genpd = {
386 .name = "mipi-csi2",
387 },
388 .bits = {
389 .pxx = IMX8M_MIPI_CSI2_SW_Pxx_REQ,
390 .map = IMX8M_MIPI_CSI2_A53_DOMAIN,
391 },
392 .pgc = IMX8M_PGC_MIPI_CSI2,
393 },
394
395 [IMX8M_POWER_DOMAIN_PCIE2] = {
396 .genpd = {
397 .name = "pcie2",
398 },
399 .bits = {
400 .pxx = IMX8M_PCIE2_SW_Pxx_REQ,
401 .map = IMX8M_PCIE2_A53_DOMAIN,
402 },
403 .pgc = IMX8M_PGC_PCIE2,
404 },
405};
406
407static const struct regmap_range imx8m_yes_ranges[] = {
408 regmap_reg_range(GPC_LPCR_A_CORE_BSC,
409 GPC_PU_PWRHSK),
410 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_MIPI),
411 GPC_PGC_SR(IMX8M_PGC_MIPI)),
412 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_PCIE1),
413 GPC_PGC_SR(IMX8M_PGC_PCIE1)),
414 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_OTG1),
415 GPC_PGC_SR(IMX8M_PGC_OTG1)),
416 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_OTG2),
417 GPC_PGC_SR(IMX8M_PGC_OTG2)),
418 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_DDR1),
419 GPC_PGC_SR(IMX8M_PGC_DDR1)),
420 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_GPU),
421 GPC_PGC_SR(IMX8M_PGC_GPU)),
422 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_VPU),
423 GPC_PGC_SR(IMX8M_PGC_VPU)),
424 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_DISP),
425 GPC_PGC_SR(IMX8M_PGC_DISP)),
426 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_MIPI_CSI1),
427 GPC_PGC_SR(IMX8M_PGC_MIPI_CSI1)),
428 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_MIPI_CSI2),
429 GPC_PGC_SR(IMX8M_PGC_MIPI_CSI2)),
430 regmap_reg_range(GPC_PGC_CTRL(IMX8M_PGC_PCIE2),
431 GPC_PGC_SR(IMX8M_PGC_PCIE2)),
432};
433
434static const struct regmap_access_table imx8m_access_table = {
435 .yes_ranges = imx8m_yes_ranges,
436 .n_yes_ranges = ARRAY_SIZE(imx8m_yes_ranges),
437};
438
439static const struct imx_pgc_domain_data imx8m_pgc_domain_data = {
440 .domains = imx8m_pgc_domains,
441 .domains_num = ARRAY_SIZE(imx8m_pgc_domains),
442 .reg_access_table = &imx8m_access_table,
443};
444
445static int imx_pgc_get_clocks(struct imx_pgc_domain *domain)
446{
447 int i, ret;
448
449 for (i = 0; ; i++) {
450 struct clk *clk = of_clk_get(domain->dev->of_node, i);
451 if (IS_ERR(clk))
452 break;
453 if (i >= GPC_CLK_MAX) {
454 dev_err(domain->dev, "more than %d clocks\n",
455 GPC_CLK_MAX);
456 ret = -EINVAL;
457 goto clk_err;
458 }
459 domain->clk[i] = clk;
460 }
461 domain->num_clks = i;
462
463 return 0;
464
465clk_err:
466 while (i--)
467 clk_put(domain->clk[i]);
468
469 return ret;
470}
471
472static void imx_pgc_put_clocks(struct imx_pgc_domain *domain)
473{
474 int i;
475
476 for (i = domain->num_clks - 1; i >= 0; i--)
477 clk_put(domain->clk[i]);
478}
479
480static int imx_pgc_domain_probe(struct platform_device *pdev)
481{
482 struct imx_pgc_domain *domain = pdev->dev.platform_data;
483 int ret;
484
485 domain->dev = &pdev->dev;
486
487 domain->regulator = devm_regulator_get_optional(domain->dev, "power");
488 if (IS_ERR(domain->regulator)) {
489 if (PTR_ERR(domain->regulator) != -ENODEV) {
490 if (PTR_ERR(domain->regulator) != -EPROBE_DEFER)
491 dev_err(domain->dev, "Failed to get domain's regulator\n");
492 return PTR_ERR(domain->regulator);
493 }
494 } else if (domain->voltage) {
495 regulator_set_voltage(domain->regulator,
496 domain->voltage, domain->voltage);
497 }
498
499 ret = imx_pgc_get_clocks(domain);
500 if (ret) {
501 if (ret != -EPROBE_DEFER)
502 dev_err(domain->dev, "Failed to get domain's clocks\n");
503 return ret;
504 }
505
506 ret = pm_genpd_init(&domain->genpd, NULL, true);
507 if (ret) {
508 dev_err(domain->dev, "Failed to init power domain\n");
509 imx_pgc_put_clocks(domain);
510 return ret;
511 }
512
513 ret = of_genpd_add_provider_simple(domain->dev->of_node,
514 &domain->genpd);
515 if (ret) {
516 dev_err(domain->dev, "Failed to add genpd provider\n");
517 pm_genpd_remove(&domain->genpd);
518 imx_pgc_put_clocks(domain);
519 }
520
521 return ret;
522}
523
524static int imx_pgc_domain_remove(struct platform_device *pdev)
525{
526 struct imx_pgc_domain *domain = pdev->dev.platform_data;
527
528 of_genpd_del_provider(domain->dev->of_node);
529 pm_genpd_remove(&domain->genpd);
530 imx_pgc_put_clocks(domain);
531
532 return 0;
533}
534
535static const struct platform_device_id imx_pgc_domain_id[] = {
536 { "imx-pgc-domain", },
537 { },
538};
539
540static struct platform_driver imx_pgc_domain_driver = {
541 .driver = {
542 .name = "imx-pgc",
543 },
544 .probe = imx_pgc_domain_probe,
545 .remove = imx_pgc_domain_remove,
546 .id_table = imx_pgc_domain_id,
547};
548builtin_platform_driver(imx_pgc_domain_driver)
549
550static int imx_gpcv2_probe(struct platform_device *pdev)
551{
552 const struct imx_pgc_domain_data *domain_data =
553 of_device_get_match_data(&pdev->dev);
554
555 struct regmap_config regmap_config = {
556 .reg_bits = 32,
557 .val_bits = 32,
558 .reg_stride = 4,
559 .rd_table = domain_data->reg_access_table,
560 .wr_table = domain_data->reg_access_table,
561 .max_register = SZ_4K,
562 };
563 struct device *dev = &pdev->dev;
564 struct device_node *pgc_np, *np;
565 struct regmap *regmap;
566 void __iomem *base;
567 int ret;
568
569 pgc_np = of_get_child_by_name(dev->of_node, "pgc");
570 if (!pgc_np) {
571 dev_err(dev, "No power domains specified in DT\n");
572 return -EINVAL;
573 }
574
575 base = devm_platform_ioremap_resource(pdev, 0);
576 if (IS_ERR(base))
577 return PTR_ERR(base);
578
579 regmap = devm_regmap_init_mmio(dev, base, ®map_config);
580 if (IS_ERR(regmap)) {
581 ret = PTR_ERR(regmap);
582 dev_err(dev, "failed to init regmap (%d)\n", ret);
583 return ret;
584 }
585
586 for_each_child_of_node(pgc_np, np) {
587 struct platform_device *pd_pdev;
588 struct imx_pgc_domain *domain;
589 u32 domain_index;
590
591 ret = of_property_read_u32(np, "reg", &domain_index);
592 if (ret) {
593 dev_err(dev, "Failed to read 'reg' property\n");
594 of_node_put(np);
595 return ret;
596 }
597
598 if (domain_index >= domain_data->domains_num) {
599 dev_warn(dev,
600 "Domain index %d is out of bounds\n",
601 domain_index);
602 continue;
603 }
604
605 pd_pdev = platform_device_alloc("imx-pgc-domain",
606 domain_index);
607 if (!pd_pdev) {
608 dev_err(dev, "Failed to allocate platform device\n");
609 of_node_put(np);
610 return -ENOMEM;
611 }
612
613 ret = platform_device_add_data(pd_pdev,
614 &domain_data->domains[domain_index],
615 sizeof(domain_data->domains[domain_index]));
616 if (ret) {
617 platform_device_put(pd_pdev);
618 of_node_put(np);
619 return ret;
620 }
621
622 domain = pd_pdev->dev.platform_data;
623 domain->regmap = regmap;
624 domain->genpd.power_on = imx_gpc_pu_pgc_sw_pup_req;
625 domain->genpd.power_off = imx_gpc_pu_pgc_sw_pdn_req;
626
627 pd_pdev->dev.parent = dev;
628 pd_pdev->dev.of_node = np;
629
630 ret = platform_device_add(pd_pdev);
631 if (ret) {
632 platform_device_put(pd_pdev);
633 of_node_put(np);
634 return ret;
635 }
636 }
637
638 return 0;
639}
640
641static const struct of_device_id imx_gpcv2_dt_ids[] = {
642 { .compatible = "fsl,imx7d-gpc", .data = &imx7_pgc_domain_data, },
643 { .compatible = "fsl,imx8mq-gpc", .data = &imx8m_pgc_domain_data, },
644 { }
645};
646
647static struct platform_driver imx_gpc_driver = {
648 .driver = {
649 .name = "imx-gpcv2",
650 .of_match_table = imx_gpcv2_dt_ids,
651 },
652 .probe = imx_gpcv2_probe,
653};
654builtin_platform_driver(imx_gpc_driver)