Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2020 Collabora Ltd.
4 */
5#include <linux/clk.h>
6#include <linux/clk-provider.h>
7#include <linux/init.h>
8#include <linux/io.h>
9#include <linux/iopoll.h>
10#include <linux/mfd/syscon.h>
11#include <linux/of_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/soc/mediatek/infracfg.h>
18
19#include "mt6795-pm-domains.h"
20#include "mt8167-pm-domains.h"
21#include "mt8173-pm-domains.h"
22#include "mt8183-pm-domains.h"
23#include "mt8186-pm-domains.h"
24#include "mt8192-pm-domains.h"
25#include "mt8195-pm-domains.h"
26
27#define MTK_POLL_DELAY_US 10
28#define MTK_POLL_TIMEOUT USEC_PER_SEC
29
30#define PWR_RST_B_BIT BIT(0)
31#define PWR_ISO_BIT BIT(1)
32#define PWR_ON_BIT BIT(2)
33#define PWR_ON_2ND_BIT BIT(3)
34#define PWR_CLK_DIS_BIT BIT(4)
35#define PWR_SRAM_CLKISO_BIT BIT(5)
36#define PWR_SRAM_ISOINT_B_BIT BIT(6)
37
38struct scpsys_domain {
39 struct generic_pm_domain genpd;
40 const struct scpsys_domain_data *data;
41 struct scpsys *scpsys;
42 int num_clks;
43 struct clk_bulk_data *clks;
44 int num_subsys_clks;
45 struct clk_bulk_data *subsys_clks;
46 struct regmap *infracfg;
47 struct regmap *smi;
48 struct regulator *supply;
49};
50
51struct scpsys {
52 struct device *dev;
53 struct regmap *base;
54 const struct scpsys_soc_data *soc_data;
55 struct genpd_onecell_data pd_data;
56 struct generic_pm_domain *domains[];
57};
58
59#define to_scpsys_domain(gpd) container_of(gpd, struct scpsys_domain, genpd)
60
61static bool scpsys_domain_is_on(struct scpsys_domain *pd)
62{
63 struct scpsys *scpsys = pd->scpsys;
64 u32 status, status2;
65
66 regmap_read(scpsys->base, pd->data->pwr_sta_offs, &status);
67 status &= pd->data->sta_mask;
68
69 regmap_read(scpsys->base, pd->data->pwr_sta2nd_offs, &status2);
70 status2 &= pd->data->sta_mask;
71
72 /* A domain is on when both status bits are set. */
73 return status && status2;
74}
75
76static int scpsys_sram_enable(struct scpsys_domain *pd)
77{
78 u32 pdn_ack = pd->data->sram_pdn_ack_bits;
79 struct scpsys *scpsys = pd->scpsys;
80 unsigned int tmp;
81 int ret;
82
83 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, pd->data->sram_pdn_bits);
84
85 /* Either wait until SRAM_PDN_ACK all 1 or 0 */
86 ret = regmap_read_poll_timeout(scpsys->base, pd->data->ctl_offs, tmp,
87 (tmp & pdn_ack) == 0, MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
88 if (ret < 0)
89 return ret;
90
91 if (MTK_SCPD_CAPS(pd, MTK_SCPD_SRAM_ISO)) {
92 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_ISOINT_B_BIT);
93 udelay(1);
94 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_CLKISO_BIT);
95 }
96
97 return 0;
98}
99
100static int scpsys_sram_disable(struct scpsys_domain *pd)
101{
102 u32 pdn_ack = pd->data->sram_pdn_ack_bits;
103 struct scpsys *scpsys = pd->scpsys;
104 unsigned int tmp;
105
106 if (MTK_SCPD_CAPS(pd, MTK_SCPD_SRAM_ISO)) {
107 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_CLKISO_BIT);
108 udelay(1);
109 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_SRAM_ISOINT_B_BIT);
110 }
111
112 regmap_set_bits(scpsys->base, pd->data->ctl_offs, pd->data->sram_pdn_bits);
113
114 /* Either wait until SRAM_PDN_ACK all 1 or 0 */
115 return regmap_read_poll_timeout(scpsys->base, pd->data->ctl_offs, tmp,
116 (tmp & pdn_ack) == pdn_ack, MTK_POLL_DELAY_US,
117 MTK_POLL_TIMEOUT);
118}
119
120static int _scpsys_bus_protect_enable(const struct scpsys_bus_prot_data *bpd, struct regmap *regmap)
121{
122 int i, ret;
123
124 for (i = 0; i < SPM_MAX_BUS_PROT_DATA; i++) {
125 u32 val, mask = bpd[i].bus_prot_mask;
126
127 if (!mask)
128 break;
129
130 if (bpd[i].bus_prot_reg_update)
131 regmap_set_bits(regmap, bpd[i].bus_prot_set, mask);
132 else
133 regmap_write(regmap, bpd[i].bus_prot_set, mask);
134
135 ret = regmap_read_poll_timeout(regmap, bpd[i].bus_prot_sta,
136 val, (val & mask) == mask,
137 MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
138 if (ret)
139 return ret;
140 }
141
142 return 0;
143}
144
145static int scpsys_bus_protect_enable(struct scpsys_domain *pd)
146{
147 int ret;
148
149 ret = _scpsys_bus_protect_enable(pd->data->bp_infracfg, pd->infracfg);
150 if (ret)
151 return ret;
152
153 return _scpsys_bus_protect_enable(pd->data->bp_smi, pd->smi);
154}
155
156static int _scpsys_bus_protect_disable(const struct scpsys_bus_prot_data *bpd,
157 struct regmap *regmap)
158{
159 int i, ret;
160
161 for (i = SPM_MAX_BUS_PROT_DATA - 1; i >= 0; i--) {
162 u32 val, mask = bpd[i].bus_prot_mask;
163
164 if (!mask)
165 continue;
166
167 if (bpd[i].bus_prot_reg_update)
168 regmap_clear_bits(regmap, bpd[i].bus_prot_clr, mask);
169 else
170 regmap_write(regmap, bpd[i].bus_prot_clr, mask);
171
172 if (bpd[i].ignore_clr_ack)
173 continue;
174
175 ret = regmap_read_poll_timeout(regmap, bpd[i].bus_prot_sta,
176 val, !(val & mask),
177 MTK_POLL_DELAY_US, MTK_POLL_TIMEOUT);
178 if (ret)
179 return ret;
180 }
181
182 return 0;
183}
184
185static int scpsys_bus_protect_disable(struct scpsys_domain *pd)
186{
187 int ret;
188
189 ret = _scpsys_bus_protect_disable(pd->data->bp_smi, pd->smi);
190 if (ret)
191 return ret;
192
193 return _scpsys_bus_protect_disable(pd->data->bp_infracfg, pd->infracfg);
194}
195
196static int scpsys_regulator_enable(struct regulator *supply)
197{
198 return supply ? regulator_enable(supply) : 0;
199}
200
201static int scpsys_regulator_disable(struct regulator *supply)
202{
203 return supply ? regulator_disable(supply) : 0;
204}
205
206static int scpsys_power_on(struct generic_pm_domain *genpd)
207{
208 struct scpsys_domain *pd = container_of(genpd, struct scpsys_domain, genpd);
209 struct scpsys *scpsys = pd->scpsys;
210 bool tmp;
211 int ret;
212
213 ret = scpsys_regulator_enable(pd->supply);
214 if (ret)
215 return ret;
216
217 ret = clk_bulk_prepare_enable(pd->num_clks, pd->clks);
218 if (ret)
219 goto err_reg;
220
221 /* subsys power on */
222 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_BIT);
223 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_2ND_BIT);
224
225 /* wait until PWR_ACK = 1 */
226 ret = readx_poll_timeout(scpsys_domain_is_on, pd, tmp, tmp, MTK_POLL_DELAY_US,
227 MTK_POLL_TIMEOUT);
228 if (ret < 0)
229 goto err_pwr_ack;
230
231 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_CLK_DIS_BIT);
232 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ISO_BIT);
233 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_RST_B_BIT);
234
235 ret = clk_bulk_prepare_enable(pd->num_subsys_clks, pd->subsys_clks);
236 if (ret)
237 goto err_pwr_ack;
238
239 ret = scpsys_sram_enable(pd);
240 if (ret < 0)
241 goto err_disable_subsys_clks;
242
243 ret = scpsys_bus_protect_disable(pd);
244 if (ret < 0)
245 goto err_disable_sram;
246
247 return 0;
248
249err_disable_sram:
250 scpsys_sram_disable(pd);
251err_disable_subsys_clks:
252 clk_bulk_disable_unprepare(pd->num_subsys_clks, pd->subsys_clks);
253err_pwr_ack:
254 clk_bulk_disable_unprepare(pd->num_clks, pd->clks);
255err_reg:
256 scpsys_regulator_disable(pd->supply);
257 return ret;
258}
259
260static int scpsys_power_off(struct generic_pm_domain *genpd)
261{
262 struct scpsys_domain *pd = container_of(genpd, struct scpsys_domain, genpd);
263 struct scpsys *scpsys = pd->scpsys;
264 bool tmp;
265 int ret;
266
267 ret = scpsys_bus_protect_enable(pd);
268 if (ret < 0)
269 return ret;
270
271 ret = scpsys_sram_disable(pd);
272 if (ret < 0)
273 return ret;
274
275 clk_bulk_disable_unprepare(pd->num_subsys_clks, pd->subsys_clks);
276
277 /* subsys power off */
278 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_ISO_BIT);
279 regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_CLK_DIS_BIT);
280 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_RST_B_BIT);
281 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_2ND_BIT);
282 regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ON_BIT);
283
284 /* wait until PWR_ACK = 0 */
285 ret = readx_poll_timeout(scpsys_domain_is_on, pd, tmp, !tmp, MTK_POLL_DELAY_US,
286 MTK_POLL_TIMEOUT);
287 if (ret < 0)
288 return ret;
289
290 clk_bulk_disable_unprepare(pd->num_clks, pd->clks);
291
292 scpsys_regulator_disable(pd->supply);
293
294 return 0;
295}
296
297static struct
298generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_node *node)
299{
300 const struct scpsys_domain_data *domain_data;
301 struct scpsys_domain *pd;
302 struct device_node *root_node = scpsys->dev->of_node;
303 struct device_node *smi_node;
304 struct property *prop;
305 const char *clk_name;
306 int i, ret, num_clks;
307 struct clk *clk;
308 int clk_ind = 0;
309 u32 id;
310
311 ret = of_property_read_u32(node, "reg", &id);
312 if (ret) {
313 dev_err(scpsys->dev, "%pOF: failed to retrieve domain id from reg: %d\n",
314 node, ret);
315 return ERR_PTR(-EINVAL);
316 }
317
318 if (id >= scpsys->soc_data->num_domains) {
319 dev_err(scpsys->dev, "%pOF: invalid domain id %d\n", node, id);
320 return ERR_PTR(-EINVAL);
321 }
322
323 domain_data = &scpsys->soc_data->domains_data[id];
324 if (domain_data->sta_mask == 0) {
325 dev_err(scpsys->dev, "%pOF: undefined domain id %d\n", node, id);
326 return ERR_PTR(-EINVAL);
327 }
328
329 pd = devm_kzalloc(scpsys->dev, sizeof(*pd), GFP_KERNEL);
330 if (!pd)
331 return ERR_PTR(-ENOMEM);
332
333 pd->data = domain_data;
334 pd->scpsys = scpsys;
335
336 if (MTK_SCPD_CAPS(pd, MTK_SCPD_DOMAIN_SUPPLY)) {
337 /*
338 * Find regulator in current power domain node.
339 * devm_regulator_get() finds regulator in a node and its child
340 * node, so set of_node to current power domain node then change
341 * back to original node after regulator is found for current
342 * power domain node.
343 */
344 scpsys->dev->of_node = node;
345 pd->supply = devm_regulator_get(scpsys->dev, "domain");
346 scpsys->dev->of_node = root_node;
347 if (IS_ERR(pd->supply)) {
348 dev_err_probe(scpsys->dev, PTR_ERR(pd->supply),
349 "%pOF: failed to get power supply.\n",
350 node);
351 return ERR_CAST(pd->supply);
352 }
353 }
354
355 pd->infracfg = syscon_regmap_lookup_by_phandle_optional(node, "mediatek,infracfg");
356 if (IS_ERR(pd->infracfg))
357 return ERR_CAST(pd->infracfg);
358
359 smi_node = of_parse_phandle(node, "mediatek,smi", 0);
360 if (smi_node) {
361 pd->smi = device_node_to_regmap(smi_node);
362 of_node_put(smi_node);
363 if (IS_ERR(pd->smi))
364 return ERR_CAST(pd->smi);
365 }
366
367 num_clks = of_clk_get_parent_count(node);
368 if (num_clks > 0) {
369 /* Calculate number of subsys_clks */
370 of_property_for_each_string(node, "clock-names", prop, clk_name) {
371 char *subsys;
372
373 subsys = strchr(clk_name, '-');
374 if (subsys)
375 pd->num_subsys_clks++;
376 else
377 pd->num_clks++;
378 }
379
380 pd->clks = devm_kcalloc(scpsys->dev, pd->num_clks, sizeof(*pd->clks), GFP_KERNEL);
381 if (!pd->clks)
382 return ERR_PTR(-ENOMEM);
383
384 pd->subsys_clks = devm_kcalloc(scpsys->dev, pd->num_subsys_clks,
385 sizeof(*pd->subsys_clks), GFP_KERNEL);
386 if (!pd->subsys_clks)
387 return ERR_PTR(-ENOMEM);
388
389 }
390
391 for (i = 0; i < pd->num_clks; i++) {
392 clk = of_clk_get(node, i);
393 if (IS_ERR(clk)) {
394 ret = PTR_ERR(clk);
395 dev_err_probe(scpsys->dev, ret,
396 "%pOF: failed to get clk at index %d\n", node, i);
397 goto err_put_clocks;
398 }
399
400 pd->clks[clk_ind++].clk = clk;
401 }
402
403 for (i = 0; i < pd->num_subsys_clks; i++) {
404 clk = of_clk_get(node, i + clk_ind);
405 if (IS_ERR(clk)) {
406 ret = PTR_ERR(clk);
407 dev_err_probe(scpsys->dev, ret,
408 "%pOF: failed to get clk at index %d\n", node,
409 i + clk_ind);
410 goto err_put_subsys_clocks;
411 }
412
413 pd->subsys_clks[i].clk = clk;
414 }
415
416 /*
417 * Initially turn on all domains to make the domains usable
418 * with !CONFIG_PM and to get the hardware in sync with the
419 * software. The unused domains will be switched off during
420 * late_init time.
421 */
422 if (MTK_SCPD_CAPS(pd, MTK_SCPD_KEEP_DEFAULT_OFF)) {
423 if (scpsys_domain_is_on(pd))
424 dev_warn(scpsys->dev,
425 "%pOF: A default off power domain has been ON\n", node);
426 } else {
427 ret = scpsys_power_on(&pd->genpd);
428 if (ret < 0) {
429 dev_err(scpsys->dev, "%pOF: failed to power on domain: %d\n", node, ret);
430 goto err_put_subsys_clocks;
431 }
432
433 if (MTK_SCPD_CAPS(pd, MTK_SCPD_ALWAYS_ON))
434 pd->genpd.flags |= GENPD_FLAG_ALWAYS_ON;
435 }
436
437 if (scpsys->domains[id]) {
438 ret = -EINVAL;
439 dev_err(scpsys->dev,
440 "power domain with id %d already exists, check your device-tree\n", id);
441 goto err_put_subsys_clocks;
442 }
443
444 if (!pd->data->name)
445 pd->genpd.name = node->name;
446 else
447 pd->genpd.name = pd->data->name;
448
449 pd->genpd.power_off = scpsys_power_off;
450 pd->genpd.power_on = scpsys_power_on;
451
452 if (MTK_SCPD_CAPS(pd, MTK_SCPD_ACTIVE_WAKEUP))
453 pd->genpd.flags |= GENPD_FLAG_ACTIVE_WAKEUP;
454
455 if (MTK_SCPD_CAPS(pd, MTK_SCPD_KEEP_DEFAULT_OFF))
456 pm_genpd_init(&pd->genpd, NULL, true);
457 else
458 pm_genpd_init(&pd->genpd, NULL, false);
459
460 scpsys->domains[id] = &pd->genpd;
461
462 return scpsys->pd_data.domains[id];
463
464err_put_subsys_clocks:
465 clk_bulk_put(pd->num_subsys_clks, pd->subsys_clks);
466err_put_clocks:
467 clk_bulk_put(pd->num_clks, pd->clks);
468 return ERR_PTR(ret);
469}
470
471static int scpsys_add_subdomain(struct scpsys *scpsys, struct device_node *parent)
472{
473 struct generic_pm_domain *child_pd, *parent_pd;
474 struct device_node *child;
475 int ret;
476
477 for_each_child_of_node(parent, child) {
478 u32 id;
479
480 ret = of_property_read_u32(parent, "reg", &id);
481 if (ret) {
482 dev_err(scpsys->dev, "%pOF: failed to get parent domain id\n", child);
483 goto err_put_node;
484 }
485
486 if (!scpsys->pd_data.domains[id]) {
487 ret = -EINVAL;
488 dev_err(scpsys->dev, "power domain with id %d does not exist\n", id);
489 goto err_put_node;
490 }
491
492 parent_pd = scpsys->pd_data.domains[id];
493
494 child_pd = scpsys_add_one_domain(scpsys, child);
495 if (IS_ERR(child_pd)) {
496 ret = PTR_ERR(child_pd);
497 dev_err_probe(scpsys->dev, ret, "%pOF: failed to get child domain id\n",
498 child);
499 goto err_put_node;
500 }
501
502 ret = pm_genpd_add_subdomain(parent_pd, child_pd);
503 if (ret) {
504 dev_err(scpsys->dev, "failed to add %s subdomain to parent %s\n",
505 child_pd->name, parent_pd->name);
506 goto err_put_node;
507 } else {
508 dev_dbg(scpsys->dev, "%s add subdomain: %s\n", parent_pd->name,
509 child_pd->name);
510 }
511
512 /* recursive call to add all subdomains */
513 ret = scpsys_add_subdomain(scpsys, child);
514 if (ret)
515 goto err_put_node;
516 }
517
518 return 0;
519
520err_put_node:
521 of_node_put(child);
522 return ret;
523}
524
525static void scpsys_remove_one_domain(struct scpsys_domain *pd)
526{
527 int ret;
528
529 if (scpsys_domain_is_on(pd))
530 scpsys_power_off(&pd->genpd);
531
532 /*
533 * We're in the error cleanup already, so we only complain,
534 * but won't emit another error on top of the original one.
535 */
536 ret = pm_genpd_remove(&pd->genpd);
537 if (ret < 0)
538 dev_err(pd->scpsys->dev,
539 "failed to remove domain '%s' : %d - state may be inconsistent\n",
540 pd->genpd.name, ret);
541
542 clk_bulk_put(pd->num_clks, pd->clks);
543 clk_bulk_put(pd->num_subsys_clks, pd->subsys_clks);
544}
545
546static void scpsys_domain_cleanup(struct scpsys *scpsys)
547{
548 struct generic_pm_domain *genpd;
549 struct scpsys_domain *pd;
550 int i;
551
552 for (i = scpsys->pd_data.num_domains - 1; i >= 0; i--) {
553 genpd = scpsys->pd_data.domains[i];
554 if (genpd) {
555 pd = to_scpsys_domain(genpd);
556 scpsys_remove_one_domain(pd);
557 }
558 }
559}
560
561static const struct of_device_id scpsys_of_match[] = {
562 {
563 .compatible = "mediatek,mt6795-power-controller",
564 .data = &mt6795_scpsys_data,
565 },
566 {
567 .compatible = "mediatek,mt8167-power-controller",
568 .data = &mt8167_scpsys_data,
569 },
570 {
571 .compatible = "mediatek,mt8173-power-controller",
572 .data = &mt8173_scpsys_data,
573 },
574 {
575 .compatible = "mediatek,mt8183-power-controller",
576 .data = &mt8183_scpsys_data,
577 },
578 {
579 .compatible = "mediatek,mt8186-power-controller",
580 .data = &mt8186_scpsys_data,
581 },
582 {
583 .compatible = "mediatek,mt8192-power-controller",
584 .data = &mt8192_scpsys_data,
585 },
586 {
587 .compatible = "mediatek,mt8195-power-controller",
588 .data = &mt8195_scpsys_data,
589 },
590 { }
591};
592
593static int scpsys_probe(struct platform_device *pdev)
594{
595 struct device *dev = &pdev->dev;
596 struct device_node *np = dev->of_node;
597 const struct scpsys_soc_data *soc;
598 struct device_node *node;
599 struct device *parent;
600 struct scpsys *scpsys;
601 int ret;
602
603 soc = of_device_get_match_data(&pdev->dev);
604 if (!soc) {
605 dev_err(&pdev->dev, "no power controller data\n");
606 return -EINVAL;
607 }
608
609 scpsys = devm_kzalloc(dev, struct_size(scpsys, domains, soc->num_domains), GFP_KERNEL);
610 if (!scpsys)
611 return -ENOMEM;
612
613 scpsys->dev = dev;
614 scpsys->soc_data = soc;
615
616 scpsys->pd_data.domains = scpsys->domains;
617 scpsys->pd_data.num_domains = soc->num_domains;
618
619 parent = dev->parent;
620 if (!parent) {
621 dev_err(dev, "no parent for syscon devices\n");
622 return -ENODEV;
623 }
624
625 scpsys->base = syscon_node_to_regmap(parent->of_node);
626 if (IS_ERR(scpsys->base)) {
627 dev_err(dev, "no regmap available\n");
628 return PTR_ERR(scpsys->base);
629 }
630
631 ret = -ENODEV;
632 for_each_available_child_of_node(np, node) {
633 struct generic_pm_domain *domain;
634
635 domain = scpsys_add_one_domain(scpsys, node);
636 if (IS_ERR(domain)) {
637 ret = PTR_ERR(domain);
638 of_node_put(node);
639 goto err_cleanup_domains;
640 }
641
642 ret = scpsys_add_subdomain(scpsys, node);
643 if (ret) {
644 of_node_put(node);
645 goto err_cleanup_domains;
646 }
647 }
648
649 if (ret) {
650 dev_dbg(dev, "no power domains present\n");
651 return ret;
652 }
653
654 ret = of_genpd_add_provider_onecell(np, &scpsys->pd_data);
655 if (ret) {
656 dev_err(dev, "failed to add provider: %d\n", ret);
657 goto err_cleanup_domains;
658 }
659
660 return 0;
661
662err_cleanup_domains:
663 scpsys_domain_cleanup(scpsys);
664 return ret;
665}
666
667static struct platform_driver scpsys_pm_domain_driver = {
668 .probe = scpsys_probe,
669 .driver = {
670 .name = "mtk-power-controller",
671 .suppress_bind_attrs = true,
672 .of_match_table = scpsys_of_match,
673 },
674};
675builtin_platform_driver(scpsys_pm_domain_driver);