1 // SPDX-License-Identifier: GPL-2.0
3 * System Control and Management Interface (SCMI) Performance Protocol
5 * Copyright (C) 2018-2023 ARM Ltd.
8 #define pr_fmt(fmt) "SCMI Notifications PERF - " fmt
10 #include <linux/bits.h>
11 #include <linux/hashtable.h>
13 #include <linux/log2.h>
14 #include <linux/module.h>
16 #include <linux/platform_device.h>
17 #include <linux/pm_opp.h>
18 #include <linux/scmi_protocol.h>
19 #include <linux/sort.h>
20 #include <linux/xarray.h>
22 #include <trace/events/scmi.h>
24 #include "protocols.h"
29 enum scmi_performance_protocol_cmd {
30 PERF_DOMAIN_ATTRIBUTES = 0x3,
31 PERF_DESCRIBE_LEVELS = 0x4,
32 PERF_LIMITS_SET = 0x5,
33 PERF_LIMITS_GET = 0x6,
36 PERF_NOTIFY_LIMITS = 0x9,
37 PERF_NOTIFY_LEVEL = 0xa,
38 PERF_DESCRIBE_FASTCHANNEL = 0xb,
39 PERF_DOMAIN_NAME_GET = 0xc,
54 struct hlist_node hash;
57 struct scmi_msg_resp_perf_attributes {
60 #define POWER_SCALE_IN_MILLIWATT(x) ((x) & BIT(0))
61 #define POWER_SCALE_IN_MICROWATT(x) ((x) & BIT(1))
62 __le32 stats_addr_low;
63 __le32 stats_addr_high;
67 struct scmi_msg_resp_perf_domain_attributes {
69 #define SUPPORTS_SET_LIMITS(x) ((x) & BIT(31))
70 #define SUPPORTS_SET_PERF_LVL(x) ((x) & BIT(30))
71 #define SUPPORTS_PERF_LIMIT_NOTIFY(x) ((x) & BIT(29))
72 #define SUPPORTS_PERF_LEVEL_NOTIFY(x) ((x) & BIT(28))
73 #define SUPPORTS_PERF_FASTCHANNELS(x) ((x) & BIT(27))
74 #define SUPPORTS_EXTENDED_NAMES(x) ((x) & BIT(26))
75 #define SUPPORTS_LEVEL_INDEXING(x) ((x) & BIT(25))
77 __le32 sustained_freq_khz;
78 __le32 sustained_perf_level;
79 u8 name[SCMI_SHORT_NAME_MAX_SIZE];
82 struct scmi_msg_perf_describe_levels {
87 struct scmi_perf_set_limits {
93 struct scmi_perf_get_limits {
98 struct scmi_perf_set_level {
103 struct scmi_perf_notify_level_or_limits {
105 __le32 notify_enable;
108 struct scmi_perf_limits_notify_payld {
115 struct scmi_perf_level_notify_payld {
118 __le32 performance_level;
121 struct scmi_msg_resp_perf_describe_levels {
123 __le16 num_remaining;
127 __le16 transition_latency_us;
132 struct scmi_msg_resp_perf_describe_levels_v4 {
134 __le16 num_remaining;
138 __le16 transition_latency_us;
140 __le32 indicative_freq;
145 struct perf_dom_info {
148 bool perf_limit_notify;
149 bool perf_level_notify;
150 bool perf_fastchannels;
151 bool level_indexing_mode;
153 u32 sustained_freq_khz;
154 u32 sustained_perf_level;
156 struct scmi_perf_domain_info info;
157 struct scmi_opp opp[MAX_OPPS];
158 struct scmi_fc_info *fc_info;
159 struct xarray opps_by_idx;
160 struct xarray opps_by_lvl;
161 DECLARE_HASHTABLE(opps_by_freq, ilog2(MAX_OPPS));
164 #define LOOKUP_BY_FREQ(__htp, __freq) \
166 /* u32 cast is needed to pick right hash func */ \
167 u32 f_ = (u32)(__freq); \
168 struct scmi_opp *_opp; \
170 hash_for_each_possible((__htp), _opp, hash, f_) \
171 if (_opp->indicative_freq == f_) \
176 struct scmi_perf_info {
179 enum scmi_power_scale power_scale;
182 struct perf_dom_info *dom_info;
185 static enum scmi_performance_protocol_cmd evt_2_cmd[] = {
190 static int scmi_perf_attributes_get(const struct scmi_protocol_handle *ph,
191 struct scmi_perf_info *pi)
195 struct scmi_msg_resp_perf_attributes *attr;
197 ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0,
204 ret = ph->xops->do_xfer(ph, t);
206 u16 flags = le16_to_cpu(attr->flags);
208 pi->num_domains = le16_to_cpu(attr->num_domains);
210 if (POWER_SCALE_IN_MILLIWATT(flags))
211 pi->power_scale = SCMI_POWER_MILLIWATTS;
212 if (PROTOCOL_REV_MAJOR(pi->version) >= 0x3)
213 if (POWER_SCALE_IN_MICROWATT(flags))
214 pi->power_scale = SCMI_POWER_MICROWATTS;
216 pi->stats_addr = le32_to_cpu(attr->stats_addr_low) |
217 (u64)le32_to_cpu(attr->stats_addr_high) << 32;
218 pi->stats_size = le32_to_cpu(attr->stats_size);
221 ph->xops->xfer_put(ph, t);
225 static void scmi_perf_xa_destroy(void *data)
228 struct scmi_perf_info *pinfo = data;
230 for (domain = 0; domain < pinfo->num_domains; domain++) {
231 xa_destroy(&((pinfo->dom_info + domain)->opps_by_idx));
232 xa_destroy(&((pinfo->dom_info + domain)->opps_by_lvl));
237 scmi_perf_domain_attributes_get(const struct scmi_protocol_handle *ph,
238 struct perf_dom_info *dom_info,
244 struct scmi_msg_resp_perf_domain_attributes *attr;
246 ret = ph->xops->xfer_get_init(ph, PERF_DOMAIN_ATTRIBUTES,
247 sizeof(dom_info->id), sizeof(*attr), &t);
251 put_unaligned_le32(dom_info->id, t->tx.buf);
254 ret = ph->xops->do_xfer(ph, t);
256 flags = le32_to_cpu(attr->flags);
258 dom_info->set_limits = SUPPORTS_SET_LIMITS(flags);
259 dom_info->info.set_perf = SUPPORTS_SET_PERF_LVL(flags);
260 dom_info->perf_limit_notify = SUPPORTS_PERF_LIMIT_NOTIFY(flags);
261 dom_info->perf_level_notify = SUPPORTS_PERF_LEVEL_NOTIFY(flags);
262 dom_info->perf_fastchannels = SUPPORTS_PERF_FASTCHANNELS(flags);
263 if (PROTOCOL_REV_MAJOR(version) >= 0x4)
264 dom_info->level_indexing_mode =
265 SUPPORTS_LEVEL_INDEXING(flags);
266 dom_info->sustained_freq_khz =
267 le32_to_cpu(attr->sustained_freq_khz);
268 dom_info->sustained_perf_level =
269 le32_to_cpu(attr->sustained_perf_level);
270 if (!dom_info->sustained_freq_khz ||
271 !dom_info->sustained_perf_level)
272 /* CPUFreq converts to kHz, hence default 1000 */
273 dom_info->mult_factor = 1000;
275 dom_info->mult_factor =
276 (dom_info->sustained_freq_khz * 1000) /
277 dom_info->sustained_perf_level;
278 strscpy(dom_info->info.name, attr->name,
279 SCMI_SHORT_NAME_MAX_SIZE);
282 ph->xops->xfer_put(ph, t);
285 * If supported overwrite short name with the extended one;
286 * on error just carry on and use already provided short name.
288 if (!ret && PROTOCOL_REV_MAJOR(version) >= 0x3 &&
289 SUPPORTS_EXTENDED_NAMES(flags))
290 ph->hops->extended_name_get(ph, PERF_DOMAIN_NAME_GET,
291 dom_info->id, dom_info->info.name,
294 if (dom_info->level_indexing_mode) {
295 xa_init(&dom_info->opps_by_idx);
296 xa_init(&dom_info->opps_by_lvl);
297 hash_init(dom_info->opps_by_freq);
303 static int opp_cmp_func(const void *opp1, const void *opp2)
305 const struct scmi_opp *t1 = opp1, *t2 = opp2;
307 return t1->perf - t2->perf;
310 struct scmi_perf_ipriv {
312 struct perf_dom_info *perf_dom;
315 static void iter_perf_levels_prepare_message(void *message,
316 unsigned int desc_index,
319 struct scmi_msg_perf_describe_levels *msg = message;
320 const struct scmi_perf_ipriv *p = priv;
322 msg->domain = cpu_to_le32(p->perf_dom->id);
323 /* Set the number of OPPs to be skipped/already read */
324 msg->level_index = cpu_to_le32(desc_index);
327 static int iter_perf_levels_update_state(struct scmi_iterator_state *st,
328 const void *response, void *priv)
330 const struct scmi_msg_resp_perf_describe_levels *r = response;
332 st->num_returned = le16_to_cpu(r->num_returned);
333 st->num_remaining = le16_to_cpu(r->num_remaining);
339 process_response_opp(struct scmi_opp *opp, unsigned int loop_idx,
340 const struct scmi_msg_resp_perf_describe_levels *r)
342 opp->perf = le32_to_cpu(r->opp[loop_idx].perf_val);
343 opp->power = le32_to_cpu(r->opp[loop_idx].power);
344 opp->trans_latency_us =
345 le16_to_cpu(r->opp[loop_idx].transition_latency_us);
349 process_response_opp_v4(struct perf_dom_info *dom, struct scmi_opp *opp,
350 unsigned int loop_idx,
351 const struct scmi_msg_resp_perf_describe_levels_v4 *r)
353 opp->perf = le32_to_cpu(r->opp[loop_idx].perf_val);
354 opp->power = le32_to_cpu(r->opp[loop_idx].power);
355 opp->trans_latency_us =
356 le16_to_cpu(r->opp[loop_idx].transition_latency_us);
358 /* Note that PERF v4 reports always five 32-bit words */
359 opp->indicative_freq = le32_to_cpu(r->opp[loop_idx].indicative_freq);
360 if (dom->level_indexing_mode) {
361 opp->level_index = le32_to_cpu(r->opp[loop_idx].level_index);
363 xa_store(&dom->opps_by_idx, opp->level_index, opp, GFP_KERNEL);
364 xa_store(&dom->opps_by_lvl, opp->perf, opp, GFP_KERNEL);
365 hash_add(dom->opps_by_freq, &opp->hash, opp->indicative_freq);
370 iter_perf_levels_process_response(const struct scmi_protocol_handle *ph,
371 const void *response,
372 struct scmi_iterator_state *st, void *priv)
374 struct scmi_opp *opp;
375 struct scmi_perf_ipriv *p = priv;
377 opp = &p->perf_dom->opp[st->desc_index + st->loop_idx];
378 if (PROTOCOL_REV_MAJOR(p->version) <= 0x3)
379 process_response_opp(opp, st->loop_idx, response);
381 process_response_opp_v4(p->perf_dom, opp, st->loop_idx,
383 p->perf_dom->opp_count++;
385 dev_dbg(ph->dev, "Level %d Power %d Latency %dus Ifreq %d Index %d\n",
386 opp->perf, opp->power, opp->trans_latency_us,
387 opp->indicative_freq, opp->level_index);
393 scmi_perf_describe_levels_get(const struct scmi_protocol_handle *ph,
394 struct perf_dom_info *perf_dom, u32 version)
398 struct scmi_iterator_ops ops = {
399 .prepare_message = iter_perf_levels_prepare_message,
400 .update_state = iter_perf_levels_update_state,
401 .process_response = iter_perf_levels_process_response,
403 struct scmi_perf_ipriv ppriv = {
405 .perf_dom = perf_dom,
408 iter = ph->hops->iter_response_init(ph, &ops, MAX_OPPS,
409 PERF_DESCRIBE_LEVELS,
410 sizeof(struct scmi_msg_perf_describe_levels),
413 return PTR_ERR(iter);
415 ret = ph->hops->iter_response_run(iter);
419 if (perf_dom->opp_count)
420 sort(perf_dom->opp, perf_dom->opp_count,
421 sizeof(struct scmi_opp), opp_cmp_func, NULL);
426 static int scmi_perf_num_domains_get(const struct scmi_protocol_handle *ph)
428 struct scmi_perf_info *pi = ph->get_priv(ph);
430 return pi->num_domains;
433 static inline struct perf_dom_info *
434 scmi_perf_domain_lookup(const struct scmi_protocol_handle *ph, u32 domain)
436 struct scmi_perf_info *pi = ph->get_priv(ph);
438 if (domain >= pi->num_domains)
439 return ERR_PTR(-EINVAL);
441 return pi->dom_info + domain;
444 static const struct scmi_perf_domain_info *
445 scmi_perf_info_get(const struct scmi_protocol_handle *ph, u32 domain)
447 struct perf_dom_info *dom;
449 dom = scmi_perf_domain_lookup(ph, domain);
451 return ERR_PTR(-EINVAL);
456 static int scmi_perf_msg_limits_set(const struct scmi_protocol_handle *ph,
457 u32 domain, u32 max_perf, u32 min_perf)
461 struct scmi_perf_set_limits *limits;
463 ret = ph->xops->xfer_get_init(ph, PERF_LIMITS_SET,
464 sizeof(*limits), 0, &t);
469 limits->domain = cpu_to_le32(domain);
470 limits->max_level = cpu_to_le32(max_perf);
471 limits->min_level = cpu_to_le32(min_perf);
473 ret = ph->xops->do_xfer(ph, t);
475 ph->xops->xfer_put(ph, t);
479 static int __scmi_perf_limits_set(const struct scmi_protocol_handle *ph,
480 struct perf_dom_info *dom, u32 max_perf,
483 if (dom->fc_info && dom->fc_info[PERF_FC_LIMIT].set_addr) {
484 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LIMIT];
486 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LIMITS_SET,
487 dom->id, min_perf, max_perf);
488 iowrite32(max_perf, fci->set_addr);
489 iowrite32(min_perf, fci->set_addr + 4);
490 ph->hops->fastchannel_db_ring(fci->set_db);
494 return scmi_perf_msg_limits_set(ph, dom->id, max_perf, min_perf);
497 static int scmi_perf_limits_set(const struct scmi_protocol_handle *ph,
498 u32 domain, u32 max_perf, u32 min_perf)
500 struct scmi_perf_info *pi = ph->get_priv(ph);
501 struct perf_dom_info *dom;
503 dom = scmi_perf_domain_lookup(ph, domain);
507 if (PROTOCOL_REV_MAJOR(pi->version) >= 0x3 && !max_perf && !min_perf)
510 if (dom->level_indexing_mode) {
511 struct scmi_opp *opp;
514 opp = xa_load(&dom->opps_by_lvl, min_perf);
518 min_perf = opp->level_index;
522 opp = xa_load(&dom->opps_by_lvl, max_perf);
526 max_perf = opp->level_index;
530 return __scmi_perf_limits_set(ph, dom, max_perf, min_perf);
533 static int scmi_perf_msg_limits_get(const struct scmi_protocol_handle *ph,
534 u32 domain, u32 *max_perf, u32 *min_perf)
538 struct scmi_perf_get_limits *limits;
540 ret = ph->xops->xfer_get_init(ph, PERF_LIMITS_GET,
541 sizeof(__le32), 0, &t);
545 put_unaligned_le32(domain, t->tx.buf);
547 ret = ph->xops->do_xfer(ph, t);
551 *max_perf = le32_to_cpu(limits->max_level);
552 *min_perf = le32_to_cpu(limits->min_level);
555 ph->xops->xfer_put(ph, t);
559 static int __scmi_perf_limits_get(const struct scmi_protocol_handle *ph,
560 struct perf_dom_info *dom, u32 *max_perf,
563 if (dom->fc_info && dom->fc_info[PERF_FC_LIMIT].get_addr) {
564 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LIMIT];
566 *max_perf = ioread32(fci->get_addr);
567 *min_perf = ioread32(fci->get_addr + 4);
568 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LIMITS_GET,
569 dom->id, *min_perf, *max_perf);
573 return scmi_perf_msg_limits_get(ph, dom->id, max_perf, min_perf);
576 static int scmi_perf_limits_get(const struct scmi_protocol_handle *ph,
577 u32 domain, u32 *max_perf, u32 *min_perf)
580 struct perf_dom_info *dom;
582 dom = scmi_perf_domain_lookup(ph, domain);
586 ret = __scmi_perf_limits_get(ph, dom, max_perf, min_perf);
590 if (dom->level_indexing_mode) {
591 struct scmi_opp *opp;
593 opp = xa_load(&dom->opps_by_idx, *min_perf);
597 *min_perf = opp->perf;
599 opp = xa_load(&dom->opps_by_idx, *max_perf);
603 *max_perf = opp->perf;
609 static int scmi_perf_msg_level_set(const struct scmi_protocol_handle *ph,
610 u32 domain, u32 level, bool poll)
614 struct scmi_perf_set_level *lvl;
616 ret = ph->xops->xfer_get_init(ph, PERF_LEVEL_SET, sizeof(*lvl), 0, &t);
620 t->hdr.poll_completion = poll;
622 lvl->domain = cpu_to_le32(domain);
623 lvl->level = cpu_to_le32(level);
625 ret = ph->xops->do_xfer(ph, t);
627 ph->xops->xfer_put(ph, t);
631 static int __scmi_perf_level_set(const struct scmi_protocol_handle *ph,
632 struct perf_dom_info *dom, u32 level,
635 if (dom->fc_info && dom->fc_info[PERF_FC_LEVEL].set_addr) {
636 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LEVEL];
638 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LEVEL_SET,
640 iowrite32(level, fci->set_addr);
641 ph->hops->fastchannel_db_ring(fci->set_db);
645 return scmi_perf_msg_level_set(ph, dom->id, level, poll);
648 static int scmi_perf_level_set(const struct scmi_protocol_handle *ph,
649 u32 domain, u32 level, bool poll)
651 struct perf_dom_info *dom;
653 dom = scmi_perf_domain_lookup(ph, domain);
657 if (dom->level_indexing_mode) {
658 struct scmi_opp *opp;
660 opp = xa_load(&dom->opps_by_lvl, level);
664 level = opp->level_index;
667 return __scmi_perf_level_set(ph, dom, level, poll);
670 static int scmi_perf_msg_level_get(const struct scmi_protocol_handle *ph,
671 u32 domain, u32 *level, bool poll)
676 ret = ph->xops->xfer_get_init(ph, PERF_LEVEL_GET,
677 sizeof(u32), sizeof(u32), &t);
681 t->hdr.poll_completion = poll;
682 put_unaligned_le32(domain, t->tx.buf);
684 ret = ph->xops->do_xfer(ph, t);
686 *level = get_unaligned_le32(t->rx.buf);
688 ph->xops->xfer_put(ph, t);
692 static int __scmi_perf_level_get(const struct scmi_protocol_handle *ph,
693 struct perf_dom_info *dom, u32 *level,
696 if (dom->fc_info && dom->fc_info[PERF_FC_LEVEL].get_addr) {
697 *level = ioread32(dom->fc_info[PERF_FC_LEVEL].get_addr);
698 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LEVEL_GET,
703 return scmi_perf_msg_level_get(ph, dom->id, level, poll);
706 static int scmi_perf_level_get(const struct scmi_protocol_handle *ph,
707 u32 domain, u32 *level, bool poll)
710 struct perf_dom_info *dom;
712 dom = scmi_perf_domain_lookup(ph, domain);
716 ret = __scmi_perf_level_get(ph, dom, level, poll);
720 if (dom->level_indexing_mode) {
721 struct scmi_opp *opp;
723 opp = xa_load(&dom->opps_by_idx, *level);
733 static int scmi_perf_level_limits_notify(const struct scmi_protocol_handle *ph,
734 u32 domain, int message_id,
739 struct scmi_perf_notify_level_or_limits *notify;
741 ret = ph->xops->xfer_get_init(ph, message_id, sizeof(*notify), 0, &t);
746 notify->domain = cpu_to_le32(domain);
747 notify->notify_enable = enable ? cpu_to_le32(BIT(0)) : 0;
749 ret = ph->xops->do_xfer(ph, t);
751 ph->xops->xfer_put(ph, t);
755 static void scmi_perf_domain_init_fc(const struct scmi_protocol_handle *ph,
756 u32 domain, struct scmi_fc_info **p_fc)
758 struct scmi_fc_info *fc;
760 fc = devm_kcalloc(ph->dev, PERF_FC_MAX, sizeof(*fc), GFP_KERNEL);
764 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
765 PERF_LEVEL_SET, 4, domain,
766 &fc[PERF_FC_LEVEL].set_addr,
767 &fc[PERF_FC_LEVEL].set_db);
769 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
770 PERF_LEVEL_GET, 4, domain,
771 &fc[PERF_FC_LEVEL].get_addr, NULL);
773 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
774 PERF_LIMITS_SET, 8, domain,
775 &fc[PERF_FC_LIMIT].set_addr,
776 &fc[PERF_FC_LIMIT].set_db);
778 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
779 PERF_LIMITS_GET, 8, domain,
780 &fc[PERF_FC_LIMIT].get_addr, NULL);
785 /* Device specific ops */
786 static int scmi_dev_domain_id(struct device *dev)
788 struct of_phandle_args clkspec;
790 if (of_parse_phandle_with_args(dev->of_node, "clocks", "#clock-cells",
794 return clkspec.args[0];
797 static int scmi_dvfs_device_opps_add(const struct scmi_protocol_handle *ph,
800 int idx, ret, domain;
802 struct scmi_opp *opp;
803 struct perf_dom_info *dom;
805 domain = scmi_dev_domain_id(dev);
809 dom = scmi_perf_domain_lookup(ph, domain);
813 for (opp = dom->opp, idx = 0; idx < dom->opp_count; idx++, opp++) {
814 if (!dom->level_indexing_mode)
815 freq = opp->perf * dom->mult_factor;
817 freq = opp->indicative_freq * 1000;
819 ret = dev_pm_opp_add(dev, freq, 0);
821 dev_warn(dev, "failed to add opp %luHz\n", freq);
824 if (!dom->level_indexing_mode)
825 freq = (--opp)->perf * dom->mult_factor;
827 freq = (--opp)->indicative_freq * 1000;
828 dev_pm_opp_remove(dev, freq);
833 dev_dbg(dev, "[%d][%s]:: Registered OPP[%d] %lu\n",
834 domain, dom->info.name, idx, freq);
840 scmi_dvfs_transition_latency_get(const struct scmi_protocol_handle *ph,
844 struct perf_dom_info *dom;
846 domain = scmi_dev_domain_id(dev);
850 dom = scmi_perf_domain_lookup(ph, domain);
855 return dom->opp[dom->opp_count - 1].trans_latency_us * 1000;
858 static int scmi_dvfs_freq_set(const struct scmi_protocol_handle *ph, u32 domain,
859 unsigned long freq, bool poll)
862 struct perf_dom_info *dom;
864 dom = scmi_perf_domain_lookup(ph, domain);
868 if (!dom->level_indexing_mode) {
869 level = freq / dom->mult_factor;
871 struct scmi_opp *opp;
873 opp = LOOKUP_BY_FREQ(dom->opps_by_freq, freq / 1000);
877 level = opp->level_index;
880 return __scmi_perf_level_set(ph, dom, level, poll);
883 static int scmi_dvfs_freq_get(const struct scmi_protocol_handle *ph, u32 domain,
884 unsigned long *freq, bool poll)
888 struct perf_dom_info *dom;
890 dom = scmi_perf_domain_lookup(ph, domain);
894 ret = __scmi_perf_level_get(ph, dom, &level, poll);
898 if (!dom->level_indexing_mode) {
899 *freq = level * dom->mult_factor;
901 struct scmi_opp *opp;
903 opp = xa_load(&dom->opps_by_idx, level);
907 *freq = opp->indicative_freq * 1000;
913 static int scmi_dvfs_est_power_get(const struct scmi_protocol_handle *ph,
914 u32 domain, unsigned long *freq,
915 unsigned long *power)
917 struct perf_dom_info *dom;
918 unsigned long opp_freq;
919 int idx, ret = -EINVAL;
920 struct scmi_opp *opp;
922 dom = scmi_perf_domain_lookup(ph, domain);
926 for (opp = dom->opp, idx = 0; idx < dom->opp_count; idx++, opp++) {
927 if (!dom->level_indexing_mode)
928 opp_freq = opp->perf * dom->mult_factor;
930 opp_freq = opp->indicative_freq * 1000;
932 if (opp_freq < *freq)
944 static bool scmi_fast_switch_possible(const struct scmi_protocol_handle *ph,
948 struct perf_dom_info *dom;
950 domain = scmi_dev_domain_id(dev);
954 dom = scmi_perf_domain_lookup(ph, domain);
958 return dom->fc_info && dom->fc_info[PERF_FC_LEVEL].set_addr;
961 static enum scmi_power_scale
962 scmi_power_scale_get(const struct scmi_protocol_handle *ph)
964 struct scmi_perf_info *pi = ph->get_priv(ph);
966 return pi->power_scale;
969 static const struct scmi_perf_proto_ops perf_proto_ops = {
970 .num_domains_get = scmi_perf_num_domains_get,
971 .info_get = scmi_perf_info_get,
972 .limits_set = scmi_perf_limits_set,
973 .limits_get = scmi_perf_limits_get,
974 .level_set = scmi_perf_level_set,
975 .level_get = scmi_perf_level_get,
976 .device_domain_id = scmi_dev_domain_id,
977 .transition_latency_get = scmi_dvfs_transition_latency_get,
978 .device_opps_add = scmi_dvfs_device_opps_add,
979 .freq_set = scmi_dvfs_freq_set,
980 .freq_get = scmi_dvfs_freq_get,
981 .est_power_get = scmi_dvfs_est_power_get,
982 .fast_switch_possible = scmi_fast_switch_possible,
983 .power_scale_get = scmi_power_scale_get,
986 static int scmi_perf_set_notify_enabled(const struct scmi_protocol_handle *ph,
987 u8 evt_id, u32 src_id, bool enable)
991 if (evt_id >= ARRAY_SIZE(evt_2_cmd))
994 cmd_id = evt_2_cmd[evt_id];
995 ret = scmi_perf_level_limits_notify(ph, src_id, cmd_id, enable);
997 pr_debug("FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n",
998 evt_id, src_id, ret);
1003 static void *scmi_perf_fill_custom_report(const struct scmi_protocol_handle *ph,
1004 u8 evt_id, ktime_t timestamp,
1005 const void *payld, size_t payld_sz,
1006 void *report, u32 *src_id)
1011 case SCMI_EVENT_PERFORMANCE_LIMITS_CHANGED:
1013 const struct scmi_perf_limits_notify_payld *p = payld;
1014 struct scmi_perf_limits_report *r = report;
1016 if (sizeof(*p) != payld_sz)
1019 r->timestamp = timestamp;
1020 r->agent_id = le32_to_cpu(p->agent_id);
1021 r->domain_id = le32_to_cpu(p->domain_id);
1022 r->range_max = le32_to_cpu(p->range_max);
1023 r->range_min = le32_to_cpu(p->range_min);
1024 *src_id = r->domain_id;
1028 case SCMI_EVENT_PERFORMANCE_LEVEL_CHANGED:
1030 const struct scmi_perf_level_notify_payld *p = payld;
1031 struct scmi_perf_level_report *r = report;
1033 if (sizeof(*p) != payld_sz)
1036 r->timestamp = timestamp;
1037 r->agent_id = le32_to_cpu(p->agent_id);
1038 r->domain_id = le32_to_cpu(p->domain_id);
1039 r->performance_level = le32_to_cpu(p->performance_level);
1040 *src_id = r->domain_id;
1051 static int scmi_perf_get_num_sources(const struct scmi_protocol_handle *ph)
1053 struct scmi_perf_info *pi = ph->get_priv(ph);
1058 return pi->num_domains;
1061 static const struct scmi_event perf_events[] = {
1063 .id = SCMI_EVENT_PERFORMANCE_LIMITS_CHANGED,
1064 .max_payld_sz = sizeof(struct scmi_perf_limits_notify_payld),
1065 .max_report_sz = sizeof(struct scmi_perf_limits_report),
1068 .id = SCMI_EVENT_PERFORMANCE_LEVEL_CHANGED,
1069 .max_payld_sz = sizeof(struct scmi_perf_level_notify_payld),
1070 .max_report_sz = sizeof(struct scmi_perf_level_report),
1074 static const struct scmi_event_ops perf_event_ops = {
1075 .get_num_sources = scmi_perf_get_num_sources,
1076 .set_notify_enabled = scmi_perf_set_notify_enabled,
1077 .fill_custom_report = scmi_perf_fill_custom_report,
1080 static const struct scmi_protocol_events perf_protocol_events = {
1081 .queue_sz = SCMI_PROTO_QUEUE_SZ,
1082 .ops = &perf_event_ops,
1083 .evts = perf_events,
1084 .num_events = ARRAY_SIZE(perf_events),
1087 static int scmi_perf_protocol_init(const struct scmi_protocol_handle *ph)
1091 struct scmi_perf_info *pinfo;
1093 ret = ph->xops->version_get(ph, &version);
1097 dev_dbg(ph->dev, "Performance Version %d.%d\n",
1098 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
1100 pinfo = devm_kzalloc(ph->dev, sizeof(*pinfo), GFP_KERNEL);
1104 pinfo->version = version;
1106 ret = scmi_perf_attributes_get(ph, pinfo);
1110 pinfo->dom_info = devm_kcalloc(ph->dev, pinfo->num_domains,
1111 sizeof(*pinfo->dom_info), GFP_KERNEL);
1112 if (!pinfo->dom_info)
1115 for (domain = 0; domain < pinfo->num_domains; domain++) {
1116 struct perf_dom_info *dom = pinfo->dom_info + domain;
1119 scmi_perf_domain_attributes_get(ph, dom, version);
1120 scmi_perf_describe_levels_get(ph, dom, version);
1122 if (dom->perf_fastchannels)
1123 scmi_perf_domain_init_fc(ph, dom->id, &dom->fc_info);
1126 ret = devm_add_action_or_reset(ph->dev, scmi_perf_xa_destroy, pinfo);
1130 return ph->set_priv(ph, pinfo);
1133 static const struct scmi_protocol scmi_perf = {
1134 .id = SCMI_PROTOCOL_PERF,
1135 .owner = THIS_MODULE,
1136 .instance_init = &scmi_perf_protocol_init,
1137 .ops = &perf_proto_ops,
1138 .events = &perf_protocol_events,
1141 DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(perf, scmi_perf)