1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2018, The Linux Foundation. All rights reserved.*/
5 #include <linux/init.h>
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/mutex.h>
9 #include <linux/pm_domain.h>
10 #include <linux/slab.h>
12 #include <linux/of_device.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>
19 #define domain_to_rpmhpd(domain) container_of(domain, struct rpmhpd, pd)
21 #define RPMH_ARC_MAX_LEVELS 16
24 * struct rpmhpd - top level RPMh power domain resource data structure
25 * @dev: rpmh power domain controller device
26 * @pd: generic_pm_domain corrresponding to the power domain
27 * @parent: generic_pm_domain corrresponding to the parent's power domain
28 * @peer: A peer power domain in case Active only Voting is
30 * @active_only: True if it represents an Active only peer
31 * @corner: current corner
32 * @active_corner: current active corner
33 * @level: An array of level (vlvl) to corner (hlvl) mappings
35 * @level_count: Number of levels supported by the power domain. max
37 * @enabled: true if the power domain is enabled
38 * @res_name: Resource name used for cmd-db lookup
39 * @addr: Resource address as looped up using resource name from
44 struct generic_pm_domain pd
;
45 struct generic_pm_domain
*parent
;
47 const bool active_only
;
49 unsigned int active_corner
;
50 u32 level
[RPMH_ARC_MAX_LEVELS
];
58 struct rpmhpd
**rpmhpds
;
62 static DEFINE_MUTEX(rpmhpd_lock
);
64 /* SDM845 RPMH powerdomains */
66 static struct rpmhpd sdm845_ebi
= {
67 .pd
= { .name
= "ebi", },
68 .res_name
= "ebi.lvl",
71 static struct rpmhpd sdm845_lmx
= {
72 .pd
= { .name
= "lmx", },
73 .res_name
= "lmx.lvl",
76 static struct rpmhpd sdm845_lcx
= {
77 .pd
= { .name
= "lcx", },
78 .res_name
= "lcx.lvl",
81 static struct rpmhpd sdm845_gfx
= {
82 .pd
= { .name
= "gfx", },
83 .res_name
= "gfx.lvl",
86 static struct rpmhpd sdm845_mss
= {
87 .pd
= { .name
= "mss", },
88 .res_name
= "mss.lvl",
91 static struct rpmhpd sdm845_mx_ao
;
92 static struct rpmhpd sdm845_mx
= {
93 .pd
= { .name
= "mx", },
94 .peer
= &sdm845_mx_ao
,
98 static struct rpmhpd sdm845_mx_ao
= {
99 .pd
= { .name
= "mx_ao", },
102 .res_name
= "mx.lvl",
105 static struct rpmhpd sdm845_cx_ao
;
106 static struct rpmhpd sdm845_cx
= {
107 .pd
= { .name
= "cx", },
108 .peer
= &sdm845_cx_ao
,
109 .parent
= &sdm845_mx
.pd
,
110 .res_name
= "cx.lvl",
113 static struct rpmhpd sdm845_cx_ao
= {
114 .pd
= { .name
= "cx_ao", },
117 .parent
= &sdm845_mx_ao
.pd
,
118 .res_name
= "cx.lvl",
121 static struct rpmhpd
*sdm845_rpmhpds
[] = {
122 [SDM845_EBI
] = &sdm845_ebi
,
123 [SDM845_MX
] = &sdm845_mx
,
124 [SDM845_MX_AO
] = &sdm845_mx_ao
,
125 [SDM845_CX
] = &sdm845_cx
,
126 [SDM845_CX_AO
] = &sdm845_cx_ao
,
127 [SDM845_LMX
] = &sdm845_lmx
,
128 [SDM845_LCX
] = &sdm845_lcx
,
129 [SDM845_GFX
] = &sdm845_gfx
,
130 [SDM845_MSS
] = &sdm845_mss
,
133 static const struct rpmhpd_desc sdm845_desc
= {
134 .rpmhpds
= sdm845_rpmhpds
,
135 .num_pds
= ARRAY_SIZE(sdm845_rpmhpds
),
138 /* SDX55 RPMH powerdomains */
139 static struct rpmhpd
*sdx55_rpmhpds
[] = {
140 [SDX55_MSS
] = &sdm845_mss
,
141 [SDX55_MX
] = &sdm845_mx
,
142 [SDX55_CX
] = &sdm845_cx
,
145 static const struct rpmhpd_desc sdx55_desc
= {
146 .rpmhpds
= sdx55_rpmhpds
,
147 .num_pds
= ARRAY_SIZE(sdx55_rpmhpds
),
150 /* SM8150 RPMH powerdomains */
152 static struct rpmhpd sm8150_mmcx_ao
;
153 static struct rpmhpd sm8150_mmcx
= {
154 .pd
= { .name
= "mmcx", },
155 .peer
= &sm8150_mmcx_ao
,
156 .res_name
= "mmcx.lvl",
159 static struct rpmhpd sm8150_mmcx_ao
= {
160 .pd
= { .name
= "mmcx_ao", },
162 .peer
= &sm8150_mmcx
,
163 .res_name
= "mmcx.lvl",
166 static struct rpmhpd
*sm8150_rpmhpds
[] = {
167 [SM8150_MSS
] = &sdm845_mss
,
168 [SM8150_EBI
] = &sdm845_ebi
,
169 [SM8150_LMX
] = &sdm845_lmx
,
170 [SM8150_LCX
] = &sdm845_lcx
,
171 [SM8150_GFX
] = &sdm845_gfx
,
172 [SM8150_MX
] = &sdm845_mx
,
173 [SM8150_MX_AO
] = &sdm845_mx_ao
,
174 [SM8150_CX
] = &sdm845_cx
,
175 [SM8150_CX_AO
] = &sdm845_cx_ao
,
176 [SM8150_MMCX
] = &sm8150_mmcx
,
177 [SM8150_MMCX_AO
] = &sm8150_mmcx_ao
,
180 static const struct rpmhpd_desc sm8150_desc
= {
181 .rpmhpds
= sm8150_rpmhpds
,
182 .num_pds
= ARRAY_SIZE(sm8150_rpmhpds
),
185 static struct rpmhpd
*sm8250_rpmhpds
[] = {
186 [SM8250_CX
] = &sdm845_cx
,
187 [SM8250_CX_AO
] = &sdm845_cx_ao
,
188 [SM8250_EBI
] = &sdm845_ebi
,
189 [SM8250_GFX
] = &sdm845_gfx
,
190 [SM8250_LCX
] = &sdm845_lcx
,
191 [SM8250_LMX
] = &sdm845_lmx
,
192 [SM8250_MMCX
] = &sm8150_mmcx
,
193 [SM8250_MMCX_AO
] = &sm8150_mmcx_ao
,
194 [SM8250_MX
] = &sdm845_mx
,
195 [SM8250_MX_AO
] = &sdm845_mx_ao
,
198 static const struct rpmhpd_desc sm8250_desc
= {
199 .rpmhpds
= sm8250_rpmhpds
,
200 .num_pds
= ARRAY_SIZE(sm8250_rpmhpds
),
203 /* SM8350 Power domains */
204 static struct rpmhpd sm8350_mxc_ao
;
205 static struct rpmhpd sm8350_mxc
= {
206 .pd
= { .name
= "mxc", },
207 .peer
= &sm8150_mmcx_ao
,
208 .res_name
= "mxc.lvl",
211 static struct rpmhpd sm8350_mxc_ao
= {
212 .pd
= { .name
= "mxc_ao", },
215 .res_name
= "mxc.lvl",
218 static struct rpmhpd
*sm8350_rpmhpds
[] = {
219 [SM8350_CX
] = &sdm845_cx
,
220 [SM8350_CX_AO
] = &sdm845_cx_ao
,
221 [SM8350_EBI
] = &sdm845_ebi
,
222 [SM8350_GFX
] = &sdm845_gfx
,
223 [SM8350_LCX
] = &sdm845_lcx
,
224 [SM8350_LMX
] = &sdm845_lmx
,
225 [SM8350_MMCX
] = &sm8150_mmcx
,
226 [SM8350_MMCX_AO
] = &sm8150_mmcx_ao
,
227 [SM8350_MX
] = &sdm845_mx
,
228 [SM8350_MX_AO
] = &sdm845_mx_ao
,
229 [SM8350_MXC
] = &sm8350_mxc
,
230 [SM8350_MXC_AO
] = &sm8350_mxc_ao
,
231 [SM8350_MSS
] = &sdm845_mss
,
234 static const struct rpmhpd_desc sm8350_desc
= {
235 .rpmhpds
= sm8350_rpmhpds
,
236 .num_pds
= ARRAY_SIZE(sm8350_rpmhpds
),
239 /* SC7180 RPMH powerdomains */
240 static struct rpmhpd
*sc7180_rpmhpds
[] = {
241 [SC7180_CX
] = &sdm845_cx
,
242 [SC7180_CX_AO
] = &sdm845_cx_ao
,
243 [SC7180_GFX
] = &sdm845_gfx
,
244 [SC7180_MX
] = &sdm845_mx
,
245 [SC7180_MX_AO
] = &sdm845_mx_ao
,
246 [SC7180_LMX
] = &sdm845_lmx
,
247 [SC7180_LCX
] = &sdm845_lcx
,
248 [SC7180_MSS
] = &sdm845_mss
,
251 static const struct rpmhpd_desc sc7180_desc
= {
252 .rpmhpds
= sc7180_rpmhpds
,
253 .num_pds
= ARRAY_SIZE(sc7180_rpmhpds
),
256 /* SC7280 RPMH powerdomains */
257 static struct rpmhpd
*sc7280_rpmhpds
[] = {
258 [SC7280_CX
] = &sdm845_cx
,
259 [SC7280_CX_AO
] = &sdm845_cx_ao
,
260 [SC7280_EBI
] = &sdm845_ebi
,
261 [SC7280_GFX
] = &sdm845_gfx
,
262 [SC7280_MX
] = &sdm845_mx
,
263 [SC7280_MX_AO
] = &sdm845_mx_ao
,
264 [SC7280_LMX
] = &sdm845_lmx
,
265 [SC7280_LCX
] = &sdm845_lcx
,
266 [SC7280_MSS
] = &sdm845_mss
,
269 static const struct rpmhpd_desc sc7280_desc
= {
270 .rpmhpds
= sc7280_rpmhpds
,
271 .num_pds
= ARRAY_SIZE(sc7280_rpmhpds
),
274 static const struct of_device_id rpmhpd_match_table
[] = {
275 { .compatible
= "qcom,sc7180-rpmhpd", .data
= &sc7180_desc
},
276 { .compatible
= "qcom,sc7280-rpmhpd", .data
= &sc7280_desc
},
277 { .compatible
= "qcom,sdm845-rpmhpd", .data
= &sdm845_desc
},
278 { .compatible
= "qcom,sdx55-rpmhpd", .data
= &sdx55_desc
},
279 { .compatible
= "qcom,sm8150-rpmhpd", .data
= &sm8150_desc
},
280 { .compatible
= "qcom,sm8250-rpmhpd", .data
= &sm8250_desc
},
281 { .compatible
= "qcom,sm8350-rpmhpd", .data
= &sm8350_desc
},
284 MODULE_DEVICE_TABLE(of
, rpmhpd_match_table
);
286 static int rpmhpd_send_corner(struct rpmhpd
*pd
, int state
,
287 unsigned int corner
, bool sync
)
289 struct tcs_cmd cmd
= {
295 * Wait for an ack only when we are increasing the
296 * perf state of the power domain
299 return rpmh_write(pd
->dev
, state
, &cmd
, 1);
301 return rpmh_write_async(pd
->dev
, state
, &cmd
, 1);
304 static void to_active_sleep(struct rpmhpd
*pd
, unsigned int corner
,
305 unsigned int *active
, unsigned int *sleep
)
316 * This function is used to aggregate the votes across the active only
317 * resources and its peers. The aggregated votes are sent to RPMh as
318 * ACTIVE_ONLY votes (which take effect immediately), as WAKE_ONLY votes
319 * (applied by RPMh on system wakeup) and as SLEEP votes (applied by RPMh
321 * We send ACTIVE_ONLY votes for resources without any peers. For others,
322 * which have an active only peer, all 3 votes are sent.
324 static int rpmhpd_aggregate_corner(struct rpmhpd
*pd
, unsigned int corner
)
327 struct rpmhpd
*peer
= pd
->peer
;
328 unsigned int active_corner
, sleep_corner
;
329 unsigned int this_active_corner
= 0, this_sleep_corner
= 0;
330 unsigned int peer_active_corner
= 0, peer_sleep_corner
= 0;
332 to_active_sleep(pd
, corner
, &this_active_corner
, &this_sleep_corner
);
334 if (peer
&& peer
->enabled
)
335 to_active_sleep(peer
, peer
->corner
, &peer_active_corner
,
338 active_corner
= max(this_active_corner
, peer_active_corner
);
340 ret
= rpmhpd_send_corner(pd
, RPMH_ACTIVE_ONLY_STATE
, active_corner
,
341 active_corner
> pd
->active_corner
);
345 pd
->active_corner
= active_corner
;
348 peer
->active_corner
= active_corner
;
350 ret
= rpmhpd_send_corner(pd
, RPMH_WAKE_ONLY_STATE
,
351 active_corner
, false);
355 sleep_corner
= max(this_sleep_corner
, peer_sleep_corner
);
357 return rpmhpd_send_corner(pd
, RPMH_SLEEP_STATE
, sleep_corner
,
364 static int rpmhpd_power_on(struct generic_pm_domain
*domain
)
366 struct rpmhpd
*pd
= domain_to_rpmhpd(domain
);
369 mutex_lock(&rpmhpd_lock
);
372 ret
= rpmhpd_aggregate_corner(pd
, pd
->corner
);
377 mutex_unlock(&rpmhpd_lock
);
382 static int rpmhpd_power_off(struct generic_pm_domain
*domain
)
384 struct rpmhpd
*pd
= domain_to_rpmhpd(domain
);
387 mutex_lock(&rpmhpd_lock
);
389 ret
= rpmhpd_aggregate_corner(pd
, pd
->level
[0]);
394 mutex_unlock(&rpmhpd_lock
);
399 static int rpmhpd_set_performance_state(struct generic_pm_domain
*domain
,
402 struct rpmhpd
*pd
= domain_to_rpmhpd(domain
);
405 mutex_lock(&rpmhpd_lock
);
407 for (i
= 0; i
< pd
->level_count
; i
++)
408 if (level
<= pd
->level
[i
])
412 * If the level requested is more than that supported by the
413 * max corner, just set it to max anyway.
415 if (i
== pd
->level_count
)
419 ret
= rpmhpd_aggregate_corner(pd
, i
);
426 mutex_unlock(&rpmhpd_lock
);
431 static unsigned int rpmhpd_get_performance_state(struct generic_pm_domain
*genpd
,
432 struct dev_pm_opp
*opp
)
434 return dev_pm_opp_get_level(opp
);
437 static int rpmhpd_update_level_mapping(struct rpmhpd
*rpmhpd
)
442 buf
= cmd_db_read_aux_data(rpmhpd
->res_name
, &rpmhpd
->level_count
);
446 /* 2 bytes used for each command DB aux data entry */
447 rpmhpd
->level_count
>>= 1;
449 if (rpmhpd
->level_count
> RPMH_ARC_MAX_LEVELS
)
452 for (i
= 0; i
< rpmhpd
->level_count
; i
++) {
453 rpmhpd
->level
[i
] = buf
[i
];
456 * The AUX data may be zero padded. These 0 valued entries at
457 * the end of the map must be ignored.
459 if (i
> 0 && rpmhpd
->level
[i
] == 0) {
460 rpmhpd
->level_count
= i
;
463 pr_debug("%s: ARC hlvl=%2d --> vlvl=%4u\n", rpmhpd
->res_name
, i
,
470 static int rpmhpd_probe(struct platform_device
*pdev
)
474 struct device
*dev
= &pdev
->dev
;
475 struct genpd_onecell_data
*data
;
476 struct rpmhpd
**rpmhpds
;
477 const struct rpmhpd_desc
*desc
;
479 desc
= of_device_get_match_data(dev
);
483 rpmhpds
= desc
->rpmhpds
;
484 num_pds
= desc
->num_pds
;
486 data
= devm_kzalloc(dev
, sizeof(*data
), GFP_KERNEL
);
490 data
->domains
= devm_kcalloc(dev
, num_pds
, sizeof(*data
->domains
),
495 data
->num_domains
= num_pds
;
497 for (i
= 0; i
< num_pds
; i
++) {
499 dev_warn(dev
, "rpmhpds[%d] is empty\n", i
);
503 rpmhpds
[i
]->dev
= dev
;
504 rpmhpds
[i
]->addr
= cmd_db_read_addr(rpmhpds
[i
]->res_name
);
505 if (!rpmhpds
[i
]->addr
) {
506 dev_err(dev
, "Could not find RPMh address for resource %s\n",
507 rpmhpds
[i
]->res_name
);
511 ret
= cmd_db_read_slave_id(rpmhpds
[i
]->res_name
);
512 if (ret
!= CMD_DB_HW_ARC
) {
513 dev_err(dev
, "RPMh slave ID mismatch\n");
517 ret
= rpmhpd_update_level_mapping(rpmhpds
[i
]);
521 rpmhpds
[i
]->pd
.power_off
= rpmhpd_power_off
;
522 rpmhpds
[i
]->pd
.power_on
= rpmhpd_power_on
;
523 rpmhpds
[i
]->pd
.set_performance_state
= rpmhpd_set_performance_state
;
524 rpmhpds
[i
]->pd
.opp_to_performance_state
= rpmhpd_get_performance_state
;
525 pm_genpd_init(&rpmhpds
[i
]->pd
, NULL
, true);
527 data
->domains
[i
] = &rpmhpds
[i
]->pd
;
531 for (i
= 0; i
< num_pds
; i
++) {
534 if (rpmhpds
[i
]->parent
)
535 pm_genpd_add_subdomain(rpmhpds
[i
]->parent
,
539 return of_genpd_add_provider_onecell(pdev
->dev
.of_node
, data
);
542 static struct platform_driver rpmhpd_driver
= {
544 .name
= "qcom-rpmhpd",
545 .of_match_table
= rpmhpd_match_table
,
546 .suppress_bind_attrs
= true,
548 .probe
= rpmhpd_probe
,
551 static int __init
rpmhpd_init(void)
553 return platform_driver_register(&rpmhpd_driver
);
555 core_initcall(rpmhpd_init
);
557 MODULE_DESCRIPTION("Qualcomm Technologies, Inc. RPMh Power Domain Driver");
558 MODULE_LICENSE("GPL v2");