1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2018, The Linux Foundation. All rights reserved.*/
3
4 #include <linux/cleanup.h>
5 #include <linux/err.h>
6 #include <linux/init.h>
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/mutex.h>
10 #include <linux/pm_domain.h>
11 #include <linux/slab.h>
12 #include <linux/of.h>
13 #include <linux/platform_device.h>
14 #include <linux/pm_opp.h>
15 #include <soc/qcom/cmd-db.h>
16 #include <soc/qcom/rpmh.h>
17 #include <dt-bindings/power/qcom-rpmpd.h>
18 #include <dt-bindings/power/qcom,rpmhpd.h>
19
20 #define domain_to_rpmhpd(domain) container_of(domain, struct rpmhpd, pd)
21
22 #define RPMH_ARC_MAX_LEVELS 32
23
24 /**
25 * struct rpmhpd - top level RPMh power domain resource data structure
26 * @dev: rpmh power domain controller device
27 * @pd: generic_pm_domain corresponding to the power domain
28 * @parent: generic_pm_domain corresponding to the parent's power domain
29 * @peer: A peer power domain in case Active only Voting is
30 * supported
31 * @active_only: True if it represents an Active only peer
32 * @corner: current corner
33 * @active_corner: current active corner
34 * @enable_corner: lowest non-zero corner
35 * @level: An array of level (vlvl) to corner (hlvl) mappings
36 * derived from cmd-db
37 * @level_count: Number of levels supported by the power domain. max
38 * being 16 (0 - 15)
39 * @enabled: true if the power domain is enabled
40 * @res_name: Resource name used for cmd-db lookup
41 * @addr: Resource address as looped up using resource name from
42 * cmd-db
43 * @state_synced: Indicator that sync_state has been invoked for the rpmhpd resource
44 */
45 struct rpmhpd {
46 struct device *dev;
47 struct generic_pm_domain pd;
48 struct generic_pm_domain *parent;
49 struct rpmhpd *peer;
50 const bool active_only;
51 unsigned int corner;
52 unsigned int active_corner;
53 unsigned int enable_corner;
54 u32 level[RPMH_ARC_MAX_LEVELS];
55 size_t level_count;
56 bool enabled;
57 const char *res_name;
58 u32 addr;
59 bool state_synced;
60 };
61
62 struct rpmhpd_desc {
63 struct rpmhpd **rpmhpds;
64 size_t num_pds;
65 };
66
67 static DEFINE_MUTEX(rpmhpd_lock);
68
69 /* RPMH powerdomains */
70
71 static struct rpmhpd cx_ao;
72 static struct rpmhpd mx;
73 static struct rpmhpd mx_ao;
74 static struct rpmhpd cx = {
75 .pd = { .name = "cx", },
76 .peer = &cx_ao,
77 .res_name = "cx.lvl",
78 };
79
80 static struct rpmhpd cx_ao = {
81 .pd = { .name = "cx_ao", },
82 .active_only = true,
83 .peer = &cx,
84 .res_name = "cx.lvl",
85 };
86
87 static struct rpmhpd cx_ao_w_mx_parent;
88 static struct rpmhpd cx_w_mx_parent = {
89 .pd = { .name = "cx", },
90 .peer = &cx_ao_w_mx_parent,
91 .parent = &mx.pd,
92 .res_name = "cx.lvl",
93 };
94
95 static struct rpmhpd cx_ao_w_mx_parent = {
96 .pd = { .name = "cx_ao", },
97 .active_only = true,
98 .peer = &cx_w_mx_parent,
99 .parent = &mx_ao.pd,
100 .res_name = "cx.lvl",
101 };
102
103 static struct rpmhpd dcx = {
104 .pd = { .name = "dcx", },
105 .res_name = "dcx.lvl",
106 };
107
108 static struct rpmhpd ebi = {
109 .pd = { .name = "ebi", },
110 .res_name = "ebi.lvl",
111 };
112
113 static struct rpmhpd gbx = {
114 .pd = { .name = "gbx", },
115 .res_name = "gbx.lvl",
116 };
117
118 static struct rpmhpd gfx = {
119 .pd = { .name = "gfx", },
120 .res_name = "gfx.lvl",
121 };
122
123 static struct rpmhpd gfx1 = {
124 .pd = { .name = "gfx1", },
125 .res_name = "gfx1.lvl",
126 };
127
128 static struct rpmhpd lcx = {
129 .pd = { .name = "lcx", },
130 .res_name = "lcx.lvl",
131 };
132
133 static struct rpmhpd lmx = {
134 .pd = { .name = "lmx", },
135 .res_name = "lmx.lvl",
136 };
137
138 static struct rpmhpd mmcx_ao;
139 static struct rpmhpd mmcx = {
140 .pd = { .name = "mmcx", },
141 .peer = &mmcx_ao,
142 .res_name = "mmcx.lvl",
143 };
144
145 static struct rpmhpd mmcx_ao = {
146 .pd = { .name = "mmcx_ao", },
147 .active_only = true,
148 .peer = &mmcx,
149 .res_name = "mmcx.lvl",
150 };
151
152 static struct rpmhpd mmcx_ao_w_cx_parent;
153 static struct rpmhpd mmcx_w_cx_parent = {
154 .pd = { .name = "mmcx", },
155 .peer = &mmcx_ao_w_cx_parent,
156 .parent = &cx.pd,
157 .res_name = "mmcx.lvl",
158 };
159
160 static struct rpmhpd mmcx_ao_w_cx_parent = {
161 .pd = { .name = "mmcx_ao", },
162 .active_only = true,
163 .peer = &mmcx_w_cx_parent,
164 .parent = &cx_ao.pd,
165 .res_name = "mmcx.lvl",
166 };
167
168 static struct rpmhpd mss = {
169 .pd = { .name = "mss", },
170 .res_name = "mss.lvl",
171 };
172
173 static struct rpmhpd mx_ao;
174 static struct rpmhpd mx = {
175 .pd = { .name = "mx", },
176 .peer = &mx_ao,
177 .res_name = "mx.lvl",
178 };
179
180 static struct rpmhpd mx_ao = {
181 .pd = { .name = "mx_ao", },
182 .active_only = true,
183 .peer = &mx,
184 .res_name = "mx.lvl",
185 };
186
187 static struct rpmhpd mxc_ao;
188 static struct rpmhpd mxc = {
189 .pd = { .name = "mxc", },
190 .peer = &mxc_ao,
191 .res_name = "mxc.lvl",
192 };
193
194 static struct rpmhpd mxc_ao = {
195 .pd = { .name = "mxc_ao", },
196 .active_only = true,
197 .peer = &mxc,
198 .res_name = "mxc.lvl",
199 };
200
201 static struct rpmhpd nsp = {
202 .pd = { .name = "nsp", },
203 .res_name = "nsp.lvl",
204 };
205
206 static struct rpmhpd nsp0 = {
207 .pd = { .name = "nsp0", },
208 .res_name = "nsp0.lvl",
209 };
210
211 static struct rpmhpd nsp1 = {
212 .pd = { .name = "nsp1", },
213 .res_name = "nsp1.lvl",
214 };
215
216 static struct rpmhpd nsp2 = {
217 .pd = { .name = "nsp2", },
218 .res_name = "nsp2.lvl",
219 };
220
221 static struct rpmhpd nsp3 = {
222 .pd = { .name = "nsp3", },
223 .res_name = "nsp3.lvl",
224 };
225
226 static struct rpmhpd qphy = {
227 .pd = { .name = "qphy", },
228 .res_name = "qphy.lvl",
229 };
230
231 static struct rpmhpd gmxc = {
232 .pd = { .name = "gmxc", },
233 .res_name = "gmxc.lvl",
234 };
235
236 /* Eliza RPMH powerdomains */
237 static struct rpmhpd *eliza_rpmhpds[] = {
238 [RPMHPD_CX] = &cx,
239 [RPMHPD_CX_AO] = &cx_ao,
240 [RPMHPD_EBI] = &ebi,
241 [RPMHPD_GFX] = &gfx,
242 [RPMHPD_LCX] = &lcx,
243 [RPMHPD_LMX] = &lmx,
244 [RPMHPD_MSS] = &mss,
245 [RPMHPD_MX] = &mx,
246 [RPMHPD_MX_AO] = &mx_ao,
247 [RPMHPD_NSP] = &nsp,
248 };
249
250 static const struct rpmhpd_desc eliza_desc = {
251 .rpmhpds = eliza_rpmhpds,
252 .num_pds = ARRAY_SIZE(eliza_rpmhpds),
253 };
254
255 /* Milos RPMH powerdomains */
256 static struct rpmhpd *milos_rpmhpds[] = {
257 [RPMHPD_CX] = &cx,
258 [RPMHPD_CX_AO] = &cx_ao,
259 [RPMHPD_EBI] = &ebi,
260 [RPMHPD_GFX] = &gfx,
261 [RPMHPD_LCX] = &lcx,
262 [RPMHPD_LMX] = &lmx,
263 [RPMHPD_MSS] = &mss,
264 [RPMHPD_MX] = &mx,
265 [RPMHPD_MX_AO] = &mx_ao,
266 };
267
268 static const struct rpmhpd_desc milos_desc = {
269 .rpmhpds = milos_rpmhpds,
270 .num_pds = ARRAY_SIZE(milos_rpmhpds),
271 };
272
273 /* SA8540P RPMH powerdomains */
274 static struct rpmhpd *sa8540p_rpmhpds[] = {
275 [SC8280XP_CX] = &cx,
276 [SC8280XP_CX_AO] = &cx_ao,
277 [SC8280XP_EBI] = &ebi,
278 [SC8280XP_LCX] = &lcx,
279 [SC8280XP_LMX] = &lmx,
280 [SC8280XP_MMCX] = &mmcx,
281 [SC8280XP_MMCX_AO] = &mmcx_ao,
282 [SC8280XP_MX] = &mx,
283 [SC8280XP_MX_AO] = &mx_ao,
284 [SC8280XP_MXC] = &mxc,
285 [SC8280XP_MXC_AO] = &mxc_ao,
286 [SC8280XP_NSP] = &nsp,
287 };
288
289 static const struct rpmhpd_desc sa8540p_desc = {
290 .rpmhpds = sa8540p_rpmhpds,
291 .num_pds = ARRAY_SIZE(sa8540p_rpmhpds),
292 };
293
294 /* SA8775P RPMH power domains */
295 static struct rpmhpd *sa8775p_rpmhpds[] = {
296 [SA8775P_CX] = &cx,
297 [SA8775P_CX_AO] = &cx_ao,
298 [SA8775P_EBI] = &ebi,
299 [SA8775P_GFX] = &gfx,
300 [SA8775P_LCX] = &lcx,
301 [SA8775P_LMX] = &lmx,
302 [SA8775P_MMCX] = &mmcx,
303 [SA8775P_MMCX_AO] = &mmcx_ao,
304 [SA8775P_MX] = &mx,
305 [SA8775P_MX_AO] = &mx_ao,
306 [SA8775P_MXC] = &mxc,
307 [SA8775P_MXC_AO] = &mxc_ao,
308 [SA8775P_NSP0] = &nsp0,
309 [SA8775P_NSP1] = &nsp1,
310 };
311
312 static const struct rpmhpd_desc sa8775p_desc = {
313 .rpmhpds = sa8775p_rpmhpds,
314 .num_pds = ARRAY_SIZE(sa8775p_rpmhpds),
315 };
316
317 /* Nord RPMH powerdomains */
318 static struct rpmhpd *nord_rpmhpds[] = {
319 [RPMHPD_CX] = &cx,
320 [RPMHPD_CX_AO] = &cx_ao,
321 [RPMHPD_EBI] = &ebi,
322 [RPMHPD_GFX] = &gfx,
323 [RPMHPD_GFX1] = &gfx1,
324 [RPMHPD_MMCX] = &mmcx,
325 [RPMHPD_MMCX_AO] = &mmcx_ao,
326 [RPMHPD_MX] = &mx,
327 [RPMHPD_MX_AO] = &mx_ao,
328 [RPMHPD_MXC] = &mxc,
329 [RPMHPD_MXC_AO] = &mxc_ao,
330 [RPMHPD_NSP0] = &nsp0,
331 [RPMHPD_NSP1] = &nsp1,
332 [RPMHPD_NSP2] = &nsp2,
333 [RPMHPD_NSP3] = &nsp3,
334 };
335
336 static const struct rpmhpd_desc nord_desc = {
337 .rpmhpds = nord_rpmhpds,
338 .num_pds = ARRAY_SIZE(nord_rpmhpds),
339 };
340
341 /* SAR2130P RPMH powerdomains */
342 static struct rpmhpd *sar2130p_rpmhpds[] = {
343 [RPMHPD_CX] = &cx,
344 [RPMHPD_CX_AO] = &cx_ao,
345 [RPMHPD_EBI] = &ebi,
346 [RPMHPD_GFX] = &gfx,
347 [RPMHPD_LCX] = &lcx,
348 [RPMHPD_LMX] = &lmx,
349 [RPMHPD_MMCX] = &mmcx_w_cx_parent,
350 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent,
351 [RPMHPD_MSS] = &mss,
352 [RPMHPD_MX] = &mx,
353 [RPMHPD_MX_AO] = &mx_ao,
354 [RPMHPD_MXC] = &mxc,
355 [RPMHPD_MXC_AO] = &mxc_ao,
356 [RPMHPD_NSP] = &nsp,
357 [RPMHPD_QPHY] = &qphy,
358 };
359
360 static const struct rpmhpd_desc sar2130p_desc = {
361 .rpmhpds = sar2130p_rpmhpds,
362 .num_pds = ARRAY_SIZE(sar2130p_rpmhpds),
363 };
364
365 /* SDM670 RPMH powerdomains */
366 static struct rpmhpd *sdm670_rpmhpds[] = {
367 [SDM670_CX] = &cx_w_mx_parent,
368 [SDM670_CX_AO] = &cx_ao_w_mx_parent,
369 [SDM670_GFX] = &gfx,
370 [SDM670_LCX] = &lcx,
371 [SDM670_LMX] = &lmx,
372 [SDM670_MSS] = &mss,
373 [SDM670_MX] = &mx,
374 [SDM670_MX_AO] = &mx_ao,
375 };
376
377 static const struct rpmhpd_desc sdm670_desc = {
378 .rpmhpds = sdm670_rpmhpds,
379 .num_pds = ARRAY_SIZE(sdm670_rpmhpds),
380 };
381
382 /* SDM845 RPMH powerdomains */
383 static struct rpmhpd *sdm845_rpmhpds[] = {
384 [SDM845_CX] = &cx_w_mx_parent,
385 [SDM845_CX_AO] = &cx_ao_w_mx_parent,
386 [SDM845_EBI] = &ebi,
387 [SDM845_GFX] = &gfx,
388 [SDM845_LCX] = &lcx,
389 [SDM845_LMX] = &lmx,
390 [SDM845_MSS] = &mss,
391 [SDM845_MX] = &mx,
392 [SDM845_MX_AO] = &mx_ao,
393 };
394
395 static const struct rpmhpd_desc sdm845_desc = {
396 .rpmhpds = sdm845_rpmhpds,
397 .num_pds = ARRAY_SIZE(sdm845_rpmhpds),
398 };
399
400 /* SDX55 RPMH powerdomains */
401 static struct rpmhpd *sdx55_rpmhpds[] = {
402 [SDX55_CX] = &cx_w_mx_parent,
403 [SDX55_MSS] = &mss,
404 [SDX55_MX] = &mx,
405 };
406
407 static const struct rpmhpd_desc sdx55_desc = {
408 .rpmhpds = sdx55_rpmhpds,
409 .num_pds = ARRAY_SIZE(sdx55_rpmhpds),
410 };
411
412 /* SDX65 RPMH powerdomains */
413 static struct rpmhpd *sdx65_rpmhpds[] = {
414 [SDX65_CX] = &cx_w_mx_parent,
415 [SDX65_CX_AO] = &cx_ao_w_mx_parent,
416 [SDX65_MSS] = &mss,
417 [SDX65_MX] = &mx,
418 [SDX65_MX_AO] = &mx_ao,
419 [SDX65_MXC] = &mxc,
420 };
421
422 static const struct rpmhpd_desc sdx65_desc = {
423 .rpmhpds = sdx65_rpmhpds,
424 .num_pds = ARRAY_SIZE(sdx65_rpmhpds),
425 };
426
427 /* SDX75 RPMH powerdomains */
428 static struct rpmhpd *sdx75_rpmhpds[] = {
429 [RPMHPD_CX] = &cx,
430 [RPMHPD_CX_AO] = &cx_ao,
431 [RPMHPD_MSS] = &mss,
432 [RPMHPD_MX] = &mx,
433 [RPMHPD_MX_AO] = &mx_ao,
434 [RPMHPD_MXC] = &mxc,
435 };
436
437 static const struct rpmhpd_desc sdx75_desc = {
438 .rpmhpds = sdx75_rpmhpds,
439 .num_pds = ARRAY_SIZE(sdx75_rpmhpds),
440 };
441
442 /* SM4450 RPMH powerdomains */
443 static struct rpmhpd *sm4450_rpmhpds[] = {
444 [RPMHPD_CX] = &cx,
445 [RPMHPD_CX_AO] = &cx_ao,
446 [RPMHPD_EBI] = &ebi,
447 [RPMHPD_LMX] = &lmx,
448 [RPMHPD_MSS] = &mss,
449 [RPMHPD_MX] = &mx,
450 };
451
452 static const struct rpmhpd_desc sm4450_desc = {
453 .rpmhpds = sm4450_rpmhpds,
454 .num_pds = ARRAY_SIZE(sm4450_rpmhpds),
455 };
456
457 /* SM6350 RPMH powerdomains */
458 static struct rpmhpd *sm6350_rpmhpds[] = {
459 [SM6350_CX] = &cx_w_mx_parent,
460 [SM6350_GFX] = &gfx,
461 [SM6350_LCX] = &lcx,
462 [SM6350_LMX] = &lmx,
463 [SM6350_MSS] = &mss,
464 [SM6350_MX] = &mx,
465 };
466
467 static const struct rpmhpd_desc sm6350_desc = {
468 .rpmhpds = sm6350_rpmhpds,
469 .num_pds = ARRAY_SIZE(sm6350_rpmhpds),
470 };
471
472 /* SM7150 RPMH powerdomains */
473 static struct rpmhpd *sm7150_rpmhpds[] = {
474 [RPMHPD_CX] = &cx_w_mx_parent,
475 [RPMHPD_CX_AO] = &cx_ao_w_mx_parent,
476 [RPMHPD_GFX] = &gfx,
477 [RPMHPD_LCX] = &lcx,
478 [RPMHPD_LMX] = &lmx,
479 [RPMHPD_MSS] = &mss,
480 [RPMHPD_MX] = &mx,
481 [RPMHPD_MX_AO] = &mx_ao,
482 };
483
484 static const struct rpmhpd_desc sm7150_desc = {
485 .rpmhpds = sm7150_rpmhpds,
486 .num_pds = ARRAY_SIZE(sm7150_rpmhpds),
487 };
488
489 /* SM8150 RPMH powerdomains */
490 static struct rpmhpd *sm8150_rpmhpds[] = {
491 [SM8150_CX] = &cx_w_mx_parent,
492 [SM8150_CX_AO] = &cx_ao_w_mx_parent,
493 [SM8150_EBI] = &ebi,
494 [SM8150_GFX] = &gfx,
495 [SM8150_LCX] = &lcx,
496 [SM8150_LMX] = &lmx,
497 [SM8150_MMCX] = &mmcx,
498 [SM8150_MMCX_AO] = &mmcx_ao,
499 [SM8150_MSS] = &mss,
500 [SM8150_MX] = &mx,
501 [SM8150_MX_AO] = &mx_ao,
502 };
503
504 static const struct rpmhpd_desc sm8150_desc = {
505 .rpmhpds = sm8150_rpmhpds,
506 .num_pds = ARRAY_SIZE(sm8150_rpmhpds),
507 };
508
509 static struct rpmhpd *sa8155p_rpmhpds[] = {
510 [SA8155P_CX] = &cx_w_mx_parent,
511 [SA8155P_CX_AO] = &cx_ao_w_mx_parent,
512 [SA8155P_EBI] = &ebi,
513 [SA8155P_GFX] = &gfx,
514 [SA8155P_MSS] = &mss,
515 [SA8155P_MX] = &mx,
516 [SA8155P_MX_AO] = &mx_ao,
517 };
518
519 static const struct rpmhpd_desc sa8155p_desc = {
520 .rpmhpds = sa8155p_rpmhpds,
521 .num_pds = ARRAY_SIZE(sa8155p_rpmhpds),
522 };
523
524 /* SM8250 RPMH powerdomains */
525 static struct rpmhpd *sm8250_rpmhpds[] = {
526 [RPMHPD_CX] = &cx_w_mx_parent,
527 [RPMHPD_CX_AO] = &cx_ao_w_mx_parent,
528 [RPMHPD_EBI] = &ebi,
529 [RPMHPD_GFX] = &gfx,
530 [RPMHPD_LCX] = &lcx,
531 [RPMHPD_LMX] = &lmx,
532 [RPMHPD_MMCX] = &mmcx,
533 [RPMHPD_MMCX_AO] = &mmcx_ao,
534 [RPMHPD_MX] = &mx,
535 [RPMHPD_MX_AO] = &mx_ao,
536 };
537
538 static const struct rpmhpd_desc sm8250_desc = {
539 .rpmhpds = sm8250_rpmhpds,
540 .num_pds = ARRAY_SIZE(sm8250_rpmhpds),
541 };
542
543 /* SM8350 Power domains */
544 static struct rpmhpd *sm8350_rpmhpds[] = {
545 [RPMHPD_CX] = &cx_w_mx_parent,
546 [RPMHPD_CX_AO] = &cx_ao_w_mx_parent,
547 [RPMHPD_EBI] = &ebi,
548 [RPMHPD_GFX] = &gfx,
549 [RPMHPD_LCX] = &lcx,
550 [RPMHPD_LMX] = &lmx,
551 [RPMHPD_MMCX] = &mmcx,
552 [RPMHPD_MMCX_AO] = &mmcx_ao,
553 [RPMHPD_MSS] = &mss,
554 [RPMHPD_MX] = &mx,
555 [RPMHPD_MX_AO] = &mx_ao,
556 [RPMHPD_MXC] = &mxc,
557 [RPMHPD_MXC_AO] = &mxc_ao,
558 };
559
560 static const struct rpmhpd_desc sm8350_desc = {
561 .rpmhpds = sm8350_rpmhpds,
562 .num_pds = ARRAY_SIZE(sm8350_rpmhpds),
563 };
564
565 /* SM8450 RPMH powerdomains */
566 static struct rpmhpd *sm8450_rpmhpds[] = {
567 [RPMHPD_CX] = &cx,
568 [RPMHPD_CX_AO] = &cx_ao,
569 [RPMHPD_EBI] = &ebi,
570 [RPMHPD_GFX] = &gfx,
571 [RPMHPD_LCX] = &lcx,
572 [RPMHPD_LMX] = &lmx,
573 [RPMHPD_MMCX] = &mmcx_w_cx_parent,
574 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent,
575 [RPMHPD_MSS] = &mss,
576 [RPMHPD_MX] = &mx,
577 [RPMHPD_MX_AO] = &mx_ao,
578 [RPMHPD_MXC] = &mxc,
579 [RPMHPD_MXC_AO] = &mxc_ao,
580 };
581
582 static const struct rpmhpd_desc sm8450_desc = {
583 .rpmhpds = sm8450_rpmhpds,
584 .num_pds = ARRAY_SIZE(sm8450_rpmhpds),
585 };
586
587 /* SM8550 RPMH powerdomains */
588 static struct rpmhpd *sm8550_rpmhpds[] = {
589 [RPMHPD_CX] = &cx,
590 [RPMHPD_CX_AO] = &cx_ao,
591 [RPMHPD_EBI] = &ebi,
592 [RPMHPD_GFX] = &gfx,
593 [RPMHPD_LCX] = &lcx,
594 [RPMHPD_LMX] = &lmx,
595 [RPMHPD_MMCX] = &mmcx_w_cx_parent,
596 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent,
597 [RPMHPD_MSS] = &mss,
598 [RPMHPD_MX] = &mx,
599 [RPMHPD_MX_AO] = &mx_ao,
600 [RPMHPD_MXC] = &mxc,
601 [RPMHPD_MXC_AO] = &mxc_ao,
602 [RPMHPD_NSP] = &nsp,
603 };
604
605 static const struct rpmhpd_desc sm8550_desc = {
606 .rpmhpds = sm8550_rpmhpds,
607 .num_pds = ARRAY_SIZE(sm8550_rpmhpds),
608 };
609
610 /* SM8650 RPMH powerdomains */
611 static struct rpmhpd *sm8650_rpmhpds[] = {
612 [RPMHPD_CX] = &cx,
613 [RPMHPD_CX_AO] = &cx_ao,
614 [RPMHPD_EBI] = &ebi,
615 [RPMHPD_GFX] = &gfx,
616 [RPMHPD_LCX] = &lcx,
617 [RPMHPD_LMX] = &lmx,
618 [RPMHPD_MMCX] = &mmcx_w_cx_parent,
619 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent,
620 [RPMHPD_MSS] = &mss,
621 [RPMHPD_MX] = &mx,
622 [RPMHPD_MX_AO] = &mx_ao,
623 [RPMHPD_MXC] = &mxc,
624 [RPMHPD_MXC_AO] = &mxc_ao,
625 [RPMHPD_NSP] = &nsp,
626 [RPMHPD_NSP2] = &nsp2,
627 };
628
629 static const struct rpmhpd_desc sm8650_desc = {
630 .rpmhpds = sm8650_rpmhpds,
631 .num_pds = ARRAY_SIZE(sm8650_rpmhpds),
632 };
633
634 /* SM8750 RPMH powerdomains */
635 static struct rpmhpd *sm8750_rpmhpds[] = {
636 [RPMHPD_CX] = &cx,
637 [RPMHPD_CX_AO] = &cx_ao,
638 [RPMHPD_EBI] = &ebi,
639 [RPMHPD_GFX] = &gfx,
640 [RPMHPD_GMXC] = &gmxc,
641 [RPMHPD_LCX] = &lcx,
642 [RPMHPD_LMX] = &lmx,
643 [RPMHPD_MX] = &mx,
644 [RPMHPD_MX_AO] = &mx_ao,
645 [RPMHPD_MMCX] = &mmcx_w_cx_parent,
646 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent,
647 [RPMHPD_MSS] = &mss,
648 [RPMHPD_MXC] = &mxc,
649 [RPMHPD_MXC_AO] = &mxc_ao,
650 [RPMHPD_NSP] = &nsp,
651 [RPMHPD_NSP2] = &nsp2,
652 };
653
654 static const struct rpmhpd_desc sm8750_desc = {
655 .rpmhpds = sm8750_rpmhpds,
656 .num_pds = ARRAY_SIZE(sm8750_rpmhpds),
657 };
658
659 /* KAANAPALI RPMH powerdomains */
660 static struct rpmhpd *kaanapali_rpmhpds[] = {
661 [RPMHPD_CX] = &cx,
662 [RPMHPD_CX_AO] = &cx_ao,
663 [RPMHPD_EBI] = &ebi,
664 [RPMHPD_GFX] = &gfx,
665 [RPMHPD_GMXC] = &gmxc,
666 [RPMHPD_LCX] = &lcx,
667 [RPMHPD_LMX] = &lmx,
668 [RPMHPD_MX] = &mx,
669 [RPMHPD_MX_AO] = &mx_ao,
670 [RPMHPD_MMCX] = &mmcx,
671 [RPMHPD_MMCX_AO] = &mmcx_ao,
672 [RPMHPD_MSS] = &mss,
673 [RPMHPD_MXC] = &mxc,
674 [RPMHPD_MXC_AO] = &mxc_ao,
675 [RPMHPD_NSP] = &nsp,
676 [RPMHPD_NSP2] = &nsp2,
677 };
678
679 static const struct rpmhpd_desc kaanapali_desc = {
680 .rpmhpds = kaanapali_rpmhpds,
681 .num_pds = ARRAY_SIZE(kaanapali_rpmhpds),
682 };
683
684 /* Hawi RPMH powerdomains */
685 static struct rpmhpd *hawi_rpmhpds[] = {
686 [RPMHPD_CX] = &cx,
687 [RPMHPD_CX_AO] = &cx_ao,
688 [RPMHPD_DCX] = &dcx,
689 [RPMHPD_EBI] = &ebi,
690 [RPMHPD_GBX] = &gbx,
691 [RPMHPD_GFX] = &gfx,
692 [RPMHPD_GMXC] = &gmxc,
693 [RPMHPD_LCX] = &lcx,
694 [RPMHPD_LMX] = &lmx,
695 [RPMHPD_MMCX] = &mmcx,
696 [RPMHPD_MMCX_AO] = &mmcx_ao,
697 [RPMHPD_MSS] = &mss,
698 [RPMHPD_MX] = &mx,
699 [RPMHPD_MX_AO] = &mx_ao,
700 [RPMHPD_MXC] = &mxc,
701 [RPMHPD_MXC_AO] = &mxc_ao,
702 [RPMHPD_NSP] = &nsp,
703 [RPMHPD_NSP2] = &nsp2,
704 };
705
706 static const struct rpmhpd_desc hawi_desc = {
707 .rpmhpds = hawi_rpmhpds,
708 .num_pds = ARRAY_SIZE(hawi_rpmhpds),
709 };
710
711 /* QDU1000/QRU1000 RPMH powerdomains */
712 static struct rpmhpd *qdu1000_rpmhpds[] = {
713 [QDU1000_CX] = &cx,
714 [QDU1000_EBI] = &ebi,
715 [QDU1000_MSS] = &mss,
716 [QDU1000_MX] = &mx,
717 };
718
719 static const struct rpmhpd_desc qdu1000_desc = {
720 .rpmhpds = qdu1000_rpmhpds,
721 .num_pds = ARRAY_SIZE(qdu1000_rpmhpds),
722 };
723
724 /* SC7180 RPMH powerdomains */
725 static struct rpmhpd *sc7180_rpmhpds[] = {
726 [SC7180_CX] = &cx_w_mx_parent,
727 [SC7180_CX_AO] = &cx_ao_w_mx_parent,
728 [SC7180_GFX] = &gfx,
729 [SC7180_LCX] = &lcx,
730 [SC7180_LMX] = &lmx,
731 [SC7180_MSS] = &mss,
732 [SC7180_MX] = &mx,
733 [SC7180_MX_AO] = &mx_ao,
734 };
735
736 static const struct rpmhpd_desc sc7180_desc = {
737 .rpmhpds = sc7180_rpmhpds,
738 .num_pds = ARRAY_SIZE(sc7180_rpmhpds),
739 };
740
741 /* SC7280 RPMH powerdomains */
742 static struct rpmhpd *sc7280_rpmhpds[] = {
743 [SC7280_CX] = &cx,
744 [SC7280_CX_AO] = &cx_ao,
745 [SC7280_EBI] = &ebi,
746 [SC7280_GFX] = &gfx,
747 [SC7280_LCX] = &lcx,
748 [SC7280_LMX] = &lmx,
749 [SC7280_MSS] = &mss,
750 [SC7280_MX] = &mx,
751 [SC7280_MX_AO] = &mx_ao,
752 };
753
754 static const struct rpmhpd_desc sc7280_desc = {
755 .rpmhpds = sc7280_rpmhpds,
756 .num_pds = ARRAY_SIZE(sc7280_rpmhpds),
757 };
758
759 /* SC8180x RPMH powerdomains */
760 static struct rpmhpd *sc8180x_rpmhpds[] = {
761 [SC8180X_CX] = &cx_w_mx_parent,
762 [SC8180X_CX_AO] = &cx_ao_w_mx_parent,
763 [SC8180X_EBI] = &ebi,
764 [SC8180X_GFX] = &gfx,
765 [SC8180X_LCX] = &lcx,
766 [SC8180X_LMX] = &lmx,
767 [SC8180X_MMCX] = &mmcx,
768 [SC8180X_MMCX_AO] = &mmcx_ao,
769 [SC8180X_MSS] = &mss,
770 [SC8180X_MX] = &mx,
771 [SC8180X_MX_AO] = &mx_ao,
772 };
773
774 static const struct rpmhpd_desc sc8180x_desc = {
775 .rpmhpds = sc8180x_rpmhpds,
776 .num_pds = ARRAY_SIZE(sc8180x_rpmhpds),
777 };
778
779 /* SC8280xp RPMH powerdomains */
780 static struct rpmhpd *sc8280xp_rpmhpds[] = {
781 [SC8280XP_CX] = &cx,
782 [SC8280XP_CX_AO] = &cx_ao,
783 [SC8280XP_EBI] = &ebi,
784 [SC8280XP_GFX] = &gfx,
785 [SC8280XP_LCX] = &lcx,
786 [SC8280XP_LMX] = &lmx,
787 [SC8280XP_MMCX] = &mmcx,
788 [SC8280XP_MMCX_AO] = &mmcx_ao,
789 [SC8280XP_MX] = &mx,
790 [SC8280XP_MX_AO] = &mx_ao,
791 [SC8280XP_MXC] = &mxc,
792 [SC8280XP_MXC_AO] = &mxc_ao,
793 [SC8280XP_NSP] = &nsp,
794 [SC8280XP_QPHY] = &qphy,
795 };
796
797 static const struct rpmhpd_desc sc8280xp_desc = {
798 .rpmhpds = sc8280xp_rpmhpds,
799 .num_pds = ARRAY_SIZE(sc8280xp_rpmhpds),
800 };
801
802 /* Glymur RPMH powerdomains */
803 static struct rpmhpd *glymur_rpmhpds[] = {
804 [RPMHPD_CX] = &cx,
805 [RPMHPD_CX_AO] = &cx_ao,
806 [RPMHPD_EBI] = &ebi,
807 [RPMHPD_GFX] = &gfx,
808 [RPMHPD_GMXC] = &gmxc,
809 [RPMHPD_LCX] = &lcx,
810 [RPMHPD_LMX] = &lmx,
811 [RPMHPD_MMCX] = &mmcx,
812 [RPMHPD_MMCX_AO] = &mmcx_ao,
813 [RPMHPD_MSS] = &mss,
814 [RPMHPD_MX] = &mx,
815 [RPMHPD_MX_AO] = &mx_ao,
816 [RPMHPD_MXC] = &mxc,
817 [RPMHPD_MXC_AO] = &mxc_ao,
818 [RPMHPD_NSP] = &nsp,
819 [RPMHPD_NSP2] = &nsp2,
820 };
821
822 static const struct rpmhpd_desc glymur_desc = {
823 .rpmhpds = glymur_rpmhpds,
824 .num_pds = ARRAY_SIZE(glymur_rpmhpds),
825 };
826
827 /* X1E80100 RPMH powerdomains */
828 static struct rpmhpd *x1e80100_rpmhpds[] = {
829 [RPMHPD_CX] = &cx,
830 [RPMHPD_CX_AO] = &cx_ao,
831 [RPMHPD_EBI] = &ebi,
832 [RPMHPD_GFX] = &gfx,
833 [RPMHPD_GMXC] = &gmxc,
834 [RPMHPD_LCX] = &lcx,
835 [RPMHPD_LMX] = &lmx,
836 [RPMHPD_MMCX] = &mmcx,
837 [RPMHPD_MMCX_AO] = &mmcx_ao,
838 [RPMHPD_MX] = &mx,
839 [RPMHPD_MX_AO] = &mx_ao,
840 [RPMHPD_MXC] = &mxc,
841 [RPMHPD_NSP] = &nsp,
842 };
843
844 static const struct rpmhpd_desc x1e80100_desc = {
845 .rpmhpds = x1e80100_rpmhpds,
846 .num_pds = ARRAY_SIZE(x1e80100_rpmhpds),
847 };
848
849 /* QCS8300 RPMH power domains */
850 static struct rpmhpd *qcs8300_rpmhpds[] = {
851 [RPMHPD_CX] = &cx,
852 [RPMHPD_CX_AO] = &cx_ao,
853 [RPMHPD_EBI] = &ebi,
854 [RPMHPD_GFX] = &gfx,
855 [RPMHPD_LCX] = &lcx,
856 [RPMHPD_LMX] = &lmx,
857 [RPMHPD_MMCX] = &mmcx_w_cx_parent,
858 [RPMHPD_MMCX_AO] = &mmcx_ao_w_cx_parent,
859 [RPMHPD_MX] = &mx,
860 [RPMHPD_MX_AO] = &mx_ao,
861 [RPMHPD_MXC] = &mxc,
862 [RPMHPD_MXC_AO] = &mxc_ao,
863 [RPMHPD_NSP0] = &nsp0,
864 [RPMHPD_NSP1] = &nsp1,
865 };
866
867 static const struct rpmhpd_desc qcs8300_desc = {
868 .rpmhpds = qcs8300_rpmhpds,
869 .num_pds = ARRAY_SIZE(qcs8300_rpmhpds),
870 };
871
872 /* QCS615 RPMH powerdomains */
873 static struct rpmhpd *qcs615_rpmhpds[] = {
874 [RPMHPD_CX] = &cx,
875 [RPMHPD_CX_AO] = &cx_ao,
876 };
877
878 static const struct rpmhpd_desc qcs615_desc = {
879 .rpmhpds = qcs615_rpmhpds,
880 .num_pds = ARRAY_SIZE(qcs615_rpmhpds),
881 };
882
883 static const struct of_device_id rpmhpd_match_table[] = {
884 { .compatible = "qcom,eliza-rpmhpd", .data = &eliza_desc },
885 { .compatible = "qcom,glymur-rpmhpd", .data = &glymur_desc },
886 { .compatible = "qcom,hawi-rpmhpd", .data = &hawi_desc },
887 { .compatible = "qcom,kaanapali-rpmhpd", .data = &kaanapali_desc },
888 { .compatible = "qcom,milos-rpmhpd", .data = &milos_desc },
889 { .compatible = "qcom,nord-rpmhpd", .data = &nord_desc },
890 { .compatible = "qcom,qcs615-rpmhpd", .data = &qcs615_desc },
891 { .compatible = "qcom,qcs8300-rpmhpd", .data = &qcs8300_desc },
892 { .compatible = "qcom,qdu1000-rpmhpd", .data = &qdu1000_desc },
893 { .compatible = "qcom,sa8155p-rpmhpd", .data = &sa8155p_desc },
894 { .compatible = "qcom,sa8540p-rpmhpd", .data = &sa8540p_desc },
895 { .compatible = "qcom,sa8775p-rpmhpd", .data = &sa8775p_desc },
896 { .compatible = "qcom,sar2130p-rpmhpd", .data = &sar2130p_desc},
897 { .compatible = "qcom,sc7180-rpmhpd", .data = &sc7180_desc },
898 { .compatible = "qcom,sc7280-rpmhpd", .data = &sc7280_desc },
899 { .compatible = "qcom,sc8180x-rpmhpd", .data = &sc8180x_desc },
900 { .compatible = "qcom,sc8280xp-rpmhpd", .data = &sc8280xp_desc },
901 { .compatible = "qcom,sdm670-rpmhpd", .data = &sdm670_desc },
902 { .compatible = "qcom,sdm845-rpmhpd", .data = &sdm845_desc },
903 { .compatible = "qcom,sdx55-rpmhpd", .data = &sdx55_desc},
904 { .compatible = "qcom,sdx65-rpmhpd", .data = &sdx65_desc},
905 { .compatible = "qcom,sdx75-rpmhpd", .data = &sdx75_desc},
906 { .compatible = "qcom,sm4450-rpmhpd", .data = &sm4450_desc },
907 { .compatible = "qcom,sm6350-rpmhpd", .data = &sm6350_desc },
908 { .compatible = "qcom,sm7150-rpmhpd", .data = &sm7150_desc },
909 { .compatible = "qcom,sm8150-rpmhpd", .data = &sm8150_desc },
910 { .compatible = "qcom,sm8250-rpmhpd", .data = &sm8250_desc },
911 { .compatible = "qcom,sm8350-rpmhpd", .data = &sm8350_desc },
912 { .compatible = "qcom,sm8450-rpmhpd", .data = &sm8450_desc },
913 { .compatible = "qcom,sm8550-rpmhpd", .data = &sm8550_desc },
914 { .compatible = "qcom,sm8650-rpmhpd", .data = &sm8650_desc },
915 { .compatible = "qcom,sm8750-rpmhpd", .data = &sm8750_desc },
916 { .compatible = "qcom,x1e80100-rpmhpd", .data = &x1e80100_desc },
917 { }
918 };
919 MODULE_DEVICE_TABLE(of, rpmhpd_match_table);
920
rpmhpd_send_corner(struct rpmhpd * pd,int state,unsigned int corner,bool sync)921 static int rpmhpd_send_corner(struct rpmhpd *pd, int state,
922 unsigned int corner, bool sync)
923 {
924 struct tcs_cmd cmd = {
925 .addr = pd->addr,
926 .data = corner,
927 };
928
929 /*
930 * Wait for an ack only when we are increasing the
931 * perf state of the power domain
932 */
933 if (sync)
934 return rpmh_write(pd->dev, state, &cmd, 1);
935 else
936 return rpmh_write_async(pd->dev, state, &cmd, 1);
937 }
938
to_active_sleep(struct rpmhpd * pd,unsigned int corner,unsigned int * active,unsigned int * sleep)939 static void to_active_sleep(struct rpmhpd *pd, unsigned int corner,
940 unsigned int *active, unsigned int *sleep)
941 {
942 *active = corner;
943
944 if (pd->active_only)
945 *sleep = 0;
946 else
947 *sleep = *active;
948 }
949
950 /*
951 * This function is used to aggregate the votes across the active only
952 * resources and its peers. The aggregated votes are sent to RPMh as
953 * ACTIVE_ONLY votes (which take effect immediately), as WAKE_ONLY votes
954 * (applied by RPMh on system wakeup) and as SLEEP votes (applied by RPMh
955 * on system sleep).
956 * We send ACTIVE_ONLY votes for resources without any peers. For others,
957 * which have an active only peer, all 3 votes are sent.
958 */
rpmhpd_aggregate_corner(struct rpmhpd * pd,unsigned int corner)959 static int rpmhpd_aggregate_corner(struct rpmhpd *pd, unsigned int corner)
960 {
961 int ret;
962 struct rpmhpd *peer = pd->peer;
963 unsigned int active_corner, sleep_corner;
964 unsigned int this_active_corner = 0, this_sleep_corner = 0;
965 unsigned int peer_active_corner = 0, peer_sleep_corner = 0;
966 unsigned int peer_enabled_corner;
967
968 if (pd->state_synced) {
969 to_active_sleep(pd, corner, &this_active_corner, &this_sleep_corner);
970 } else {
971 /* Clamp to highest corner if sync_state hasn't happened */
972 this_active_corner = pd->level_count - 1;
973 this_sleep_corner = pd->level_count - 1;
974 }
975
976 if (peer && peer->enabled) {
977 peer_enabled_corner = max(peer->corner, peer->enable_corner);
978 to_active_sleep(peer, peer_enabled_corner, &peer_active_corner,
979 &peer_sleep_corner);
980 }
981
982 active_corner = max(this_active_corner, peer_active_corner);
983
984 ret = rpmhpd_send_corner(pd, RPMH_ACTIVE_ONLY_STATE, active_corner,
985 active_corner > pd->active_corner);
986 if (ret)
987 return ret;
988
989 pd->active_corner = active_corner;
990
991 if (peer) {
992 peer->active_corner = active_corner;
993
994 ret = rpmhpd_send_corner(pd, RPMH_WAKE_ONLY_STATE,
995 active_corner, false);
996 if (ret)
997 return ret;
998
999 sleep_corner = max(this_sleep_corner, peer_sleep_corner);
1000
1001 return rpmhpd_send_corner(pd, RPMH_SLEEP_STATE, sleep_corner,
1002 false);
1003 }
1004
1005 return ret;
1006 }
1007
rpmhpd_power_on(struct generic_pm_domain * domain)1008 static int rpmhpd_power_on(struct generic_pm_domain *domain)
1009 {
1010 struct rpmhpd *pd = domain_to_rpmhpd(domain);
1011 unsigned int corner;
1012 int ret;
1013
1014 mutex_lock(&rpmhpd_lock);
1015
1016 corner = max(pd->corner, pd->enable_corner);
1017 ret = rpmhpd_aggregate_corner(pd, corner);
1018 if (!ret)
1019 pd->enabled = true;
1020
1021 mutex_unlock(&rpmhpd_lock);
1022
1023 return ret;
1024 }
1025
rpmhpd_power_off(struct generic_pm_domain * domain)1026 static int rpmhpd_power_off(struct generic_pm_domain *domain)
1027 {
1028 struct rpmhpd *pd = domain_to_rpmhpd(domain);
1029 int ret;
1030
1031 mutex_lock(&rpmhpd_lock);
1032
1033 ret = rpmhpd_aggregate_corner(pd, 0);
1034 if (!ret)
1035 pd->enabled = false;
1036
1037 mutex_unlock(&rpmhpd_lock);
1038
1039 return ret;
1040 }
1041
rpmhpd_set_performance_state(struct generic_pm_domain * domain,unsigned int level)1042 static int rpmhpd_set_performance_state(struct generic_pm_domain *domain,
1043 unsigned int level)
1044 {
1045 struct rpmhpd *pd = domain_to_rpmhpd(domain);
1046 int ret, i;
1047
1048 guard(mutex)(&rpmhpd_lock);
1049
1050 for (i = 0; i < pd->level_count; i++)
1051 if (level <= pd->level[i])
1052 break;
1053
1054 /*
1055 * If the level requested is more than that supported by the
1056 * max corner, just set it to max anyway.
1057 */
1058 if (i == pd->level_count)
1059 i--;
1060
1061 if (pd->enabled) {
1062 /* Ensure that the domain isn't turn off */
1063 if (i < pd->enable_corner)
1064 i = pd->enable_corner;
1065
1066 ret = rpmhpd_aggregate_corner(pd, i);
1067 if (ret)
1068 return ret;
1069 }
1070
1071 pd->corner = i;
1072
1073 return 0;
1074 }
1075
rpmhpd_update_level_mapping(struct rpmhpd * rpmhpd)1076 static int rpmhpd_update_level_mapping(struct rpmhpd *rpmhpd)
1077 {
1078 int i;
1079 const u16 *buf;
1080
1081 buf = cmd_db_read_aux_data(rpmhpd->res_name, &rpmhpd->level_count);
1082 if (IS_ERR(buf))
1083 return PTR_ERR(buf);
1084
1085 /* 2 bytes used for each command DB aux data entry */
1086 rpmhpd->level_count >>= 1;
1087
1088 if (rpmhpd->level_count > RPMH_ARC_MAX_LEVELS)
1089 return -EINVAL;
1090
1091 for (i = 0; i < rpmhpd->level_count; i++) {
1092 /*
1093 * Most HW won't function properly at Retention. The minimum
1094 * operational level is the first level above Retention. The
1095 * small subset of HW that can operate at Retention isn't
1096 * controlled by HLOS. Skip the Retention level to avoid HW
1097 * failures when the PD is enabled without first having an
1098 * explicit OPP level set.
1099 */
1100 if (buf[i] == RPMH_REGULATOR_LEVEL_RETENTION)
1101 continue;
1102
1103 rpmhpd->level[i] = buf[i];
1104
1105 /* Remember the first corner with non-zero level */
1106 if (!rpmhpd->level[rpmhpd->enable_corner] && rpmhpd->level[i])
1107 rpmhpd->enable_corner = i;
1108
1109 /*
1110 * The AUX data may be zero padded. These 0 valued entries at
1111 * the end of the map must be ignored.
1112 */
1113 if (i > 0 && rpmhpd->level[i] == 0) {
1114 rpmhpd->level_count = i;
1115 break;
1116 }
1117 pr_debug("%s: ARC hlvl=%2d --> vlvl=%4u\n", rpmhpd->res_name, i,
1118 rpmhpd->level[i]);
1119 }
1120
1121 return 0;
1122 }
1123
rpmhpd_probe(struct platform_device * pdev)1124 static int rpmhpd_probe(struct platform_device *pdev)
1125 {
1126 int i, ret;
1127 size_t num_pds;
1128 struct device *dev = &pdev->dev;
1129 struct genpd_onecell_data *data;
1130 struct rpmhpd **rpmhpds;
1131 const struct rpmhpd_desc *desc;
1132
1133 desc = of_device_get_match_data(dev);
1134 if (!desc)
1135 return -EINVAL;
1136
1137 rpmhpds = desc->rpmhpds;
1138 num_pds = desc->num_pds;
1139
1140 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
1141 if (!data)
1142 return -ENOMEM;
1143
1144 data->domains = devm_kcalloc(dev, num_pds, sizeof(*data->domains),
1145 GFP_KERNEL);
1146 if (!data->domains)
1147 return -ENOMEM;
1148
1149 data->num_domains = num_pds;
1150
1151 for (i = 0; i < num_pds; i++) {
1152 if (!rpmhpds[i])
1153 continue;
1154
1155 rpmhpds[i]->dev = dev;
1156 rpmhpds[i]->addr = cmd_db_read_addr(rpmhpds[i]->res_name);
1157 if (!rpmhpds[i]->addr) {
1158 dev_err(dev, "Could not find RPMh address for resource %s\n",
1159 rpmhpds[i]->res_name);
1160 return -ENODEV;
1161 }
1162
1163 ret = cmd_db_read_slave_id(rpmhpds[i]->res_name);
1164 if (ret != CMD_DB_HW_ARC) {
1165 dev_err(dev, "RPMh slave ID mismatch\n");
1166 return -EINVAL;
1167 }
1168
1169 ret = rpmhpd_update_level_mapping(rpmhpds[i]);
1170 if (ret)
1171 return ret;
1172
1173 rpmhpds[i]->pd.power_off = rpmhpd_power_off;
1174 rpmhpds[i]->pd.power_on = rpmhpd_power_on;
1175 rpmhpds[i]->pd.set_performance_state = rpmhpd_set_performance_state;
1176 pm_genpd_init(&rpmhpds[i]->pd, NULL, true);
1177
1178 data->domains[i] = &rpmhpds[i]->pd;
1179 }
1180
1181 /* Add subdomains */
1182 for (i = 0; i < num_pds; i++) {
1183 if (!rpmhpds[i])
1184 continue;
1185 if (rpmhpds[i]->parent)
1186 pm_genpd_add_subdomain(rpmhpds[i]->parent,
1187 &rpmhpds[i]->pd);
1188 }
1189
1190 return of_genpd_add_provider_onecell(pdev->dev.of_node, data);
1191 }
1192
rpmhpd_sync_state(struct device * dev)1193 static void rpmhpd_sync_state(struct device *dev)
1194 {
1195 const struct rpmhpd_desc *desc = of_device_get_match_data(dev);
1196 struct rpmhpd **rpmhpds = desc->rpmhpds;
1197 unsigned int corner;
1198 struct rpmhpd *pd;
1199 unsigned int i;
1200 int ret;
1201
1202 of_genpd_sync_state(dev->of_node);
1203
1204 mutex_lock(&rpmhpd_lock);
1205 for (i = 0; i < desc->num_pds; i++) {
1206 pd = rpmhpds[i];
1207 if (!pd)
1208 continue;
1209
1210 pd->state_synced = true;
1211 if (pd->enabled)
1212 corner = max(pd->corner, pd->enable_corner);
1213 else
1214 corner = 0;
1215
1216 ret = rpmhpd_aggregate_corner(pd, corner);
1217 if (ret)
1218 dev_err(dev, "failed to sync %s\n", pd->res_name);
1219 }
1220 mutex_unlock(&rpmhpd_lock);
1221 }
1222
1223 static struct platform_driver rpmhpd_driver = {
1224 .driver = {
1225 .name = "qcom-rpmhpd",
1226 .of_match_table = rpmhpd_match_table,
1227 .suppress_bind_attrs = true,
1228 .sync_state = rpmhpd_sync_state,
1229 },
1230 .probe = rpmhpd_probe,
1231 };
1232
rpmhpd_init(void)1233 static int __init rpmhpd_init(void)
1234 {
1235 return platform_driver_register(&rpmhpd_driver);
1236 }
1237 core_initcall(rpmhpd_init);
1238
1239 MODULE_DESCRIPTION("Qualcomm Technologies, Inc. RPMh Power Domain Driver");
1240 MODULE_LICENSE("GPL v2");
1241