]> git.ipfire.org Git - thirdparty/kernel/stable.git/blob - drivers/firmware/arm_scmi/perf.c
projects / thirdparty / kernel / stable.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
KVM: x86: Ignore MSR_AMD64_TW_CFG access
[thirdparty/kernel/stable.git] / drivers / firmware / arm_scmi / perf.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * System Control and Management Interface (SCMI) Performance Protocol
4 *
5 * Copyright (C) 2018-2023 ARM Ltd.
6 */
7
8 #define pr_fmt(fmt) "SCMI Notifications PERF - " fmt
9
10 #include <linux/bits.h>
11 #include <linux/hashtable.h>
12 #include <linux/io.h>
13 #include <linux/log2.h>
14 #include <linux/module.h>
15 #include <linux/of.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>
21
22 #include <trace/events/scmi.h>
23
24 #include "protocols.h"
25 #include "notify.h"
26
27 #define MAX_OPPS 16
28
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,
34 PERF_LEVEL_SET = 0x7,
35 PERF_LEVEL_GET = 0x8,
36 PERF_NOTIFY_LIMITS = 0x9,
37 PERF_NOTIFY_LEVEL = 0xa,
38 PERF_DESCRIBE_FASTCHANNEL = 0xb,
39 PERF_DOMAIN_NAME_GET = 0xc,
40 };
41
42 enum {
43 PERF_FC_LEVEL,
44 PERF_FC_LIMIT,
45 PERF_FC_MAX,
46 };
47
48 struct scmi_opp {
49 u32 perf;
50 u32 power;
51 u32 trans_latency_us;
52 u32 indicative_freq;
53 u32 level_index;
54 struct hlist_node hash;
55 };
56
57 struct scmi_msg_resp_perf_attributes {
58 __le16 num_domains;
59 __le16 flags;
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;
64 __le32 stats_size;
65 };
66
67 struct scmi_msg_resp_perf_domain_attributes {
68 __le32 flags;
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))
76 __le32 rate_limit_us;
77 __le32 sustained_freq_khz;
78 __le32 sustained_perf_level;
79 u8 name[SCMI_SHORT_NAME_MAX_SIZE];
80 };
81
82 struct scmi_msg_perf_describe_levels {
83 __le32 domain;
84 __le32 level_index;
85 };
86
87 struct scmi_perf_set_limits {
88 __le32 domain;
89 __le32 max_level;
90 __le32 min_level;
91 };
92
93 struct scmi_perf_get_limits {
94 __le32 max_level;
95 __le32 min_level;
96 };
97
98 struct scmi_perf_set_level {
99 __le32 domain;
100 __le32 level;
101 };
102
103 struct scmi_perf_notify_level_or_limits {
104 __le32 domain;
105 __le32 notify_enable;
106 };
107
108 struct scmi_perf_limits_notify_payld {
109 __le32 agent_id;
110 __le32 domain_id;
111 __le32 range_max;
112 __le32 range_min;
113 };
114
115 struct scmi_perf_level_notify_payld {
116 __le32 agent_id;
117 __le32 domain_id;
118 __le32 performance_level;
119 };
120
121 struct scmi_msg_resp_perf_describe_levels {
122 __le16 num_returned;
123 __le16 num_remaining;
124 struct {
125 __le32 perf_val;
126 __le32 power;
127 __le16 transition_latency_us;
128 __le16 reserved;
129 } opp[];
130 };
131
132 struct scmi_msg_resp_perf_describe_levels_v4 {
133 __le16 num_returned;
134 __le16 num_remaining;
135 struct {
136 __le32 perf_val;
137 __le32 power;
138 __le16 transition_latency_us;
139 __le16 reserved;
140 __le32 indicative_freq;
141 __le32 level_index;
142 } opp[];
143 };
144
145 struct perf_dom_info {
146 u32 id;
147 bool set_limits;
148 bool set_perf;
149 bool perf_limit_notify;
150 bool perf_level_notify;
151 bool perf_fastchannels;
152 bool level_indexing_mode;
153 u32 opp_count;
154 u32 sustained_freq_khz;
155 u32 sustained_perf_level;
156 u32 mult_factor;
157 char name[SCMI_MAX_STR_SIZE];
158 struct scmi_opp opp[MAX_OPPS];
159 struct scmi_fc_info *fc_info;
160 struct xarray opps_by_idx;
161 struct xarray opps_by_lvl;
162 DECLARE_HASHTABLE(opps_by_freq, ilog2(MAX_OPPS));
163 };
164
165 #define LOOKUP_BY_FREQ(__htp, __freq) \
166 ({ \
167 /* u32 cast is needed to pick right hash func */ \
168 u32 f_ = (u32)(__freq); \
169 struct scmi_opp *_opp; \
170 \
171 hash_for_each_possible((__htp), _opp, hash, f_) \
172 if (_opp->indicative_freq == f_) \
173 break; \
174 _opp; \
175 })
176
177 struct scmi_perf_info {
178 u32 version;
179 u16 num_domains;
180 enum scmi_power_scale power_scale;
181 u64 stats_addr;
182 u32 stats_size;
183 struct perf_dom_info *dom_info;
184 };
185
186 static enum scmi_performance_protocol_cmd evt_2_cmd[] = {
187 PERF_NOTIFY_LIMITS,
188 PERF_NOTIFY_LEVEL,
189 };
190
191 static int scmi_perf_attributes_get(const struct scmi_protocol_handle *ph,
192 struct scmi_perf_info *pi)
193 {
194 int ret;
195 struct scmi_xfer *t;
196 struct scmi_msg_resp_perf_attributes *attr;
197
198 ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0,
199 sizeof(*attr), &t);
200 if (ret)
201 return ret;
202
203 attr = t->rx.buf;
204
205 ret = ph->xops->do_xfer(ph, t);
206 if (!ret) {
207 u16 flags = le16_to_cpu(attr->flags);
208
209 pi->num_domains = le16_to_cpu(attr->num_domains);
210
211 if (POWER_SCALE_IN_MILLIWATT(flags))
212 pi->power_scale = SCMI_POWER_MILLIWATTS;
213 if (PROTOCOL_REV_MAJOR(pi->version) >= 0x3)
214 if (POWER_SCALE_IN_MICROWATT(flags))
215 pi->power_scale = SCMI_POWER_MICROWATTS;
216
217 pi->stats_addr = le32_to_cpu(attr->stats_addr_low) |
218 (u64)le32_to_cpu(attr->stats_addr_high) << 32;
219 pi->stats_size = le32_to_cpu(attr->stats_size);
220 }
221
222 ph->xops->xfer_put(ph, t);
223 return ret;
224 }
225
226 static void scmi_perf_xa_destroy(void *data)
227 {
228 int domain;
229 struct scmi_perf_info *pinfo = data;
230
231 for (domain = 0; domain < pinfo->num_domains; domain++) {
232 xa_destroy(&((pinfo->dom_info + domain)->opps_by_idx));
233 xa_destroy(&((pinfo->dom_info + domain)->opps_by_lvl));
234 }
235 }
236
237 static int
238 scmi_perf_domain_attributes_get(const struct scmi_protocol_handle *ph,
239 struct perf_dom_info *dom_info,
240 u32 version)
241 {
242 int ret;
243 u32 flags;
244 struct scmi_xfer *t;
245 struct scmi_msg_resp_perf_domain_attributes *attr;
246
247 ret = ph->xops->xfer_get_init(ph, PERF_DOMAIN_ATTRIBUTES,
248 sizeof(dom_info->id), sizeof(*attr), &t);
249 if (ret)
250 return ret;
251
252 put_unaligned_le32(dom_info->id, t->tx.buf);
253 attr = t->rx.buf;
254
255 ret = ph->xops->do_xfer(ph, t);
256 if (!ret) {
257 flags = le32_to_cpu(attr->flags);
258
259 dom_info->set_limits = SUPPORTS_SET_LIMITS(flags);
260 dom_info->set_perf = SUPPORTS_SET_PERF_LVL(flags);
261 dom_info->perf_limit_notify = SUPPORTS_PERF_LIMIT_NOTIFY(flags);
262 dom_info->perf_level_notify = SUPPORTS_PERF_LEVEL_NOTIFY(flags);
263 dom_info->perf_fastchannels = SUPPORTS_PERF_FASTCHANNELS(flags);
264 if (PROTOCOL_REV_MAJOR(version) >= 0x4)
265 dom_info->level_indexing_mode =
266 SUPPORTS_LEVEL_INDEXING(flags);
267 dom_info->sustained_freq_khz =
268 le32_to_cpu(attr->sustained_freq_khz);
269 dom_info->sustained_perf_level =
270 le32_to_cpu(attr->sustained_perf_level);
271 if (!dom_info->sustained_freq_khz ||
272 !dom_info->sustained_perf_level)
273 /* CPUFreq converts to kHz, hence default 1000 */
274 dom_info->mult_factor = 1000;
275 else
276 dom_info->mult_factor =
277 (dom_info->sustained_freq_khz * 1000) /
278 dom_info->sustained_perf_level;
279 strscpy(dom_info->name, attr->name, SCMI_SHORT_NAME_MAX_SIZE);
280 }
281
282 ph->xops->xfer_put(ph, t);
283
284 /*
285 * If supported overwrite short name with the extended one;
286 * on error just carry on and use already provided short name.
287 */
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->name,
292 SCMI_MAX_STR_SIZE);
293
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);
298 }
299
300 return ret;
301 }
302
303 static int opp_cmp_func(const void *opp1, const void *opp2)
304 {
305 const struct scmi_opp *t1 = opp1, *t2 = opp2;
306
307 return t1->perf - t2->perf;
308 }
309
310 struct scmi_perf_ipriv {
311 u32 version;
312 struct perf_dom_info *perf_dom;
313 };
314
315 static void iter_perf_levels_prepare_message(void *message,
316 unsigned int desc_index,
317 const void *priv)
318 {
319 struct scmi_msg_perf_describe_levels *msg = message;
320 const struct scmi_perf_ipriv *p = priv;
321
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);
325 }
326
327 static int iter_perf_levels_update_state(struct scmi_iterator_state *st,
328 const void *response, void *priv)
329 {
330 const struct scmi_msg_resp_perf_describe_levels *r = response;
331
332 st->num_returned = le16_to_cpu(r->num_returned);
333 st->num_remaining = le16_to_cpu(r->num_remaining);
334
335 return 0;
336 }
337
338 static inline void
339 process_response_opp(struct scmi_opp *opp, unsigned int loop_idx,
340 const struct scmi_msg_resp_perf_describe_levels *r)
341 {
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);
346 }
347
348 static inline void
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)
352 {
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);
357
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);
362
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);
366 }
367 }
368
369 static int
370 iter_perf_levels_process_response(const struct scmi_protocol_handle *ph,
371 const void *response,
372 struct scmi_iterator_state *st, void *priv)
373 {
374 struct scmi_opp *opp;
375 struct scmi_perf_ipriv *p = priv;
376
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);
380 else
381 process_response_opp_v4(p->perf_dom, opp, st->loop_idx,
382 response);
383 p->perf_dom->opp_count++;
384
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);
388
389 return 0;
390 }
391
392 static int
393 scmi_perf_describe_levels_get(const struct scmi_protocol_handle *ph,
394 struct perf_dom_info *perf_dom, u32 version)
395 {
396 int ret;
397 void *iter;
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,
402 };
403 struct scmi_perf_ipriv ppriv = {
404 .version = version,
405 .perf_dom = perf_dom,
406 };
407
408 iter = ph->hops->iter_response_init(ph, &ops, MAX_OPPS,
409 PERF_DESCRIBE_LEVELS,
410 sizeof(struct scmi_msg_perf_describe_levels),
411 &ppriv);
412 if (IS_ERR(iter))
413 return PTR_ERR(iter);
414
415 ret = ph->hops->iter_response_run(iter);
416 if (ret)
417 return ret;
418
419 if (perf_dom->opp_count)
420 sort(perf_dom->opp, perf_dom->opp_count,
421 sizeof(struct scmi_opp), opp_cmp_func, NULL);
422
423 return ret;
424 }
425
426 static int scmi_perf_msg_limits_set(const struct scmi_protocol_handle *ph,
427 u32 domain, u32 max_perf, u32 min_perf)
428 {
429 int ret;
430 struct scmi_xfer *t;
431 struct scmi_perf_set_limits *limits;
432
433 ret = ph->xops->xfer_get_init(ph, PERF_LIMITS_SET,
434 sizeof(*limits), 0, &t);
435 if (ret)
436 return ret;
437
438 limits = t->tx.buf;
439 limits->domain = cpu_to_le32(domain);
440 limits->max_level = cpu_to_le32(max_perf);
441 limits->min_level = cpu_to_le32(min_perf);
442
443 ret = ph->xops->do_xfer(ph, t);
444
445 ph->xops->xfer_put(ph, t);
446 return ret;
447 }
448
449 static inline struct perf_dom_info *
450 scmi_perf_domain_lookup(const struct scmi_protocol_handle *ph, u32 domain)
451 {
452 struct scmi_perf_info *pi = ph->get_priv(ph);
453
454 if (domain >= pi->num_domains)
455 return ERR_PTR(-EINVAL);
456
457 return pi->dom_info + domain;
458 }
459
460 static int __scmi_perf_limits_set(const struct scmi_protocol_handle *ph,
461 struct perf_dom_info *dom, u32 max_perf,
462 u32 min_perf)
463 {
464 if (dom->fc_info && dom->fc_info[PERF_FC_LIMIT].set_addr) {
465 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LIMIT];
466
467 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LIMITS_SET,
468 dom->id, min_perf, max_perf);
469 iowrite32(max_perf, fci->set_addr);
470 iowrite32(min_perf, fci->set_addr + 4);
471 ph->hops->fastchannel_db_ring(fci->set_db);
472 return 0;
473 }
474
475 return scmi_perf_msg_limits_set(ph, dom->id, max_perf, min_perf);
476 }
477
478 static int scmi_perf_limits_set(const struct scmi_protocol_handle *ph,
479 u32 domain, u32 max_perf, u32 min_perf)
480 {
481 struct scmi_perf_info *pi = ph->get_priv(ph);
482 struct perf_dom_info *dom;
483
484 dom = scmi_perf_domain_lookup(ph, domain);
485 if (IS_ERR(dom))
486 return PTR_ERR(dom);
487
488 if (PROTOCOL_REV_MAJOR(pi->version) >= 0x3 && !max_perf && !min_perf)
489 return -EINVAL;
490
491 if (dom->level_indexing_mode) {
492 struct scmi_opp *opp;
493
494 if (min_perf) {
495 opp = xa_load(&dom->opps_by_lvl, min_perf);
496 if (!opp)
497 return -EIO;
498
499 min_perf = opp->level_index;
500 }
501
502 if (max_perf) {
503 opp = xa_load(&dom->opps_by_lvl, max_perf);
504 if (!opp)
505 return -EIO;
506
507 max_perf = opp->level_index;
508 }
509 }
510
511 return __scmi_perf_limits_set(ph, dom, max_perf, min_perf);
512 }
513
514 static int scmi_perf_msg_limits_get(const struct scmi_protocol_handle *ph,
515 u32 domain, u32 *max_perf, u32 *min_perf)
516 {
517 int ret;
518 struct scmi_xfer *t;
519 struct scmi_perf_get_limits *limits;
520
521 ret = ph->xops->xfer_get_init(ph, PERF_LIMITS_GET,
522 sizeof(__le32), 0, &t);
523 if (ret)
524 return ret;
525
526 put_unaligned_le32(domain, t->tx.buf);
527
528 ret = ph->xops->do_xfer(ph, t);
529 if (!ret) {
530 limits = t->rx.buf;
531
532 *max_perf = le32_to_cpu(limits->max_level);
533 *min_perf = le32_to_cpu(limits->min_level);
534 }
535
536 ph->xops->xfer_put(ph, t);
537 return ret;
538 }
539
540 static int __scmi_perf_limits_get(const struct scmi_protocol_handle *ph,
541 struct perf_dom_info *dom, u32 *max_perf,
542 u32 *min_perf)
543 {
544 if (dom->fc_info && dom->fc_info[PERF_FC_LIMIT].get_addr) {
545 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LIMIT];
546
547 *max_perf = ioread32(fci->get_addr);
548 *min_perf = ioread32(fci->get_addr + 4);
549 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LIMITS_GET,
550 dom->id, *min_perf, *max_perf);
551 return 0;
552 }
553
554 return scmi_perf_msg_limits_get(ph, dom->id, max_perf, min_perf);
555 }
556
557 static int scmi_perf_limits_get(const struct scmi_protocol_handle *ph,
558 u32 domain, u32 *max_perf, u32 *min_perf)
559 {
560 int ret;
561 struct perf_dom_info *dom;
562
563 dom = scmi_perf_domain_lookup(ph, domain);
564 if (IS_ERR(dom))
565 return PTR_ERR(dom);
566
567 ret = __scmi_perf_limits_get(ph, dom, max_perf, min_perf);
568 if (ret)
569 return ret;
570
571 if (dom->level_indexing_mode) {
572 struct scmi_opp *opp;
573
574 opp = xa_load(&dom->opps_by_idx, *min_perf);
575 if (!opp)
576 return -EIO;
577
578 *min_perf = opp->perf;
579
580 opp = xa_load(&dom->opps_by_idx, *max_perf);
581 if (!opp)
582 return -EIO;
583
584 *max_perf = opp->perf;
585 }
586
587 return 0;
588 }
589
590 static int scmi_perf_msg_level_set(const struct scmi_protocol_handle *ph,
591 u32 domain, u32 level, bool poll)
592 {
593 int ret;
594 struct scmi_xfer *t;
595 struct scmi_perf_set_level *lvl;
596
597 ret = ph->xops->xfer_get_init(ph, PERF_LEVEL_SET, sizeof(*lvl), 0, &t);
598 if (ret)
599 return ret;
600
601 t->hdr.poll_completion = poll;
602 lvl = t->tx.buf;
603 lvl->domain = cpu_to_le32(domain);
604 lvl->level = cpu_to_le32(level);
605
606 ret = ph->xops->do_xfer(ph, t);
607
608 ph->xops->xfer_put(ph, t);
609 return ret;
610 }
611
612 static int __scmi_perf_level_set(const struct scmi_protocol_handle *ph,
613 struct perf_dom_info *dom, u32 level,
614 bool poll)
615 {
616 if (dom->fc_info && dom->fc_info[PERF_FC_LEVEL].set_addr) {
617 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LEVEL];
618
619 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LEVEL_SET,
620 dom->id, level, 0);
621 iowrite32(level, fci->set_addr);
622 ph->hops->fastchannel_db_ring(fci->set_db);
623 return 0;
624 }
625
626 return scmi_perf_msg_level_set(ph, dom->id, level, poll);
627 }
628
629 static int scmi_perf_level_set(const struct scmi_protocol_handle *ph,
630 u32 domain, u32 level, bool poll)
631 {
632 struct perf_dom_info *dom;
633
634 dom = scmi_perf_domain_lookup(ph, domain);
635 if (IS_ERR(dom))
636 return PTR_ERR(dom);
637
638 if (dom->level_indexing_mode) {
639 struct scmi_opp *opp;
640
641 opp = xa_load(&dom->opps_by_lvl, level);
642 if (!opp)
643 return -EIO;
644
645 level = opp->level_index;
646 }
647
648 return __scmi_perf_level_set(ph, dom, level, poll);
649 }
650
651 static int scmi_perf_msg_level_get(const struct scmi_protocol_handle *ph,
652 u32 domain, u32 *level, bool poll)
653 {
654 int ret;
655 struct scmi_xfer *t;
656
657 ret = ph->xops->xfer_get_init(ph, PERF_LEVEL_GET,
658 sizeof(u32), sizeof(u32), &t);
659 if (ret)
660 return ret;
661
662 t->hdr.poll_completion = poll;
663 put_unaligned_le32(domain, t->tx.buf);
664
665 ret = ph->xops->do_xfer(ph, t);
666 if (!ret)
667 *level = get_unaligned_le32(t->rx.buf);
668
669 ph->xops->xfer_put(ph, t);
670 return ret;
671 }
672
673 static int __scmi_perf_level_get(const struct scmi_protocol_handle *ph,
674 struct perf_dom_info *dom, u32 *level,
675 bool poll)
676 {
677 if (dom->fc_info && dom->fc_info[PERF_FC_LEVEL].get_addr) {
678 *level = ioread32(dom->fc_info[PERF_FC_LEVEL].get_addr);
679 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LEVEL_GET,
680 dom->id, *level, 0);
681 return 0;
682 }
683
684 return scmi_perf_msg_level_get(ph, dom->id, level, poll);
685 }
686
687 static int scmi_perf_level_get(const struct scmi_protocol_handle *ph,
688 u32 domain, u32 *level, bool poll)
689 {
690 int ret;
691 struct perf_dom_info *dom;
692
693 dom = scmi_perf_domain_lookup(ph, domain);
694 if (IS_ERR(dom))
695 return PTR_ERR(dom);
696
697 ret = __scmi_perf_level_get(ph, dom, level, poll);
698 if (ret)
699 return ret;
700
701 if (dom->level_indexing_mode) {
702 struct scmi_opp *opp;
703
704 opp = xa_load(&dom->opps_by_idx, *level);
705 if (!opp)
706 return -EIO;
707
708 *level = opp->perf;
709 }
710
711 return 0;
712 }
713
714 static int scmi_perf_level_limits_notify(const struct scmi_protocol_handle *ph,
715 u32 domain, int message_id,
716 bool enable)
717 {
718 int ret;
719 struct scmi_xfer *t;
720 struct scmi_perf_notify_level_or_limits *notify;
721
722 ret = ph->xops->xfer_get_init(ph, message_id, sizeof(*notify), 0, &t);
723 if (ret)
724 return ret;
725
726 notify = t->tx.buf;
727 notify->domain = cpu_to_le32(domain);
728 notify->notify_enable = enable ? cpu_to_le32(BIT(0)) : 0;
729
730 ret = ph->xops->do_xfer(ph, t);
731
732 ph->xops->xfer_put(ph, t);
733 return ret;
734 }
735
736 static void scmi_perf_domain_init_fc(const struct scmi_protocol_handle *ph,
737 u32 domain, struct scmi_fc_info **p_fc)
738 {
739 struct scmi_fc_info *fc;
740
741 fc = devm_kcalloc(ph->dev, PERF_FC_MAX, sizeof(*fc), GFP_KERNEL);
742 if (!fc)
743 return;
744
745 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
746 PERF_LEVEL_SET, 4, domain,
747 &fc[PERF_FC_LEVEL].set_addr,
748 &fc[PERF_FC_LEVEL].set_db);
749
750 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
751 PERF_LEVEL_GET, 4, domain,
752 &fc[PERF_FC_LEVEL].get_addr, NULL);
753
754 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
755 PERF_LIMITS_SET, 8, domain,
756 &fc[PERF_FC_LIMIT].set_addr,
757 &fc[PERF_FC_LIMIT].set_db);
758
759 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
760 PERF_LIMITS_GET, 8, domain,
761 &fc[PERF_FC_LIMIT].get_addr, NULL);
762
763 *p_fc = fc;
764 }
765
766 /* Device specific ops */
767 static int scmi_dev_domain_id(struct device *dev)
768 {
769 struct of_phandle_args clkspec;
770
771 if (of_parse_phandle_with_args(dev->of_node, "clocks", "#clock-cells",
772 0, &clkspec))
773 return -EINVAL;
774
775 return clkspec.args[0];
776 }
777
778 static int scmi_dvfs_device_opps_add(const struct scmi_protocol_handle *ph,
779 struct device *dev)
780 {
781 int idx, ret, domain;
782 unsigned long freq;
783 struct scmi_opp *opp;
784 struct perf_dom_info *dom;
785
786 domain = scmi_dev_domain_id(dev);
787 if (domain < 0)
788 return -EINVAL;
789
790 dom = scmi_perf_domain_lookup(ph, domain);
791 if (IS_ERR(dom))
792 return PTR_ERR(dom);
793
794 for (opp = dom->opp, idx = 0; idx < dom->opp_count; idx++, opp++) {
795 if (!dom->level_indexing_mode)
796 freq = opp->perf * dom->mult_factor;
797 else
798 freq = opp->indicative_freq * 1000;
799
800 ret = dev_pm_opp_add(dev, freq, 0);
801 if (ret) {
802 dev_warn(dev, "failed to add opp %luHz\n", freq);
803
804 while (idx-- > 0) {
805 if (!dom->level_indexing_mode)
806 freq = (--opp)->perf * dom->mult_factor;
807 else
808 freq = (--opp)->indicative_freq * 1000;
809 dev_pm_opp_remove(dev, freq);
810 }
811 return ret;
812 }
813
814 dev_dbg(dev, "[%d][%s]:: Registered OPP[%d] %lu\n",
815 domain, dom->name, idx, freq);
816 }
817 return 0;
818 }
819
820 static int
821 scmi_dvfs_transition_latency_get(const struct scmi_protocol_handle *ph,
822 struct device *dev)
823 {
824 int domain;
825 struct perf_dom_info *dom;
826
827 domain = scmi_dev_domain_id(dev);
828 if (domain < 0)
829 return -EINVAL;
830
831 dom = scmi_perf_domain_lookup(ph, domain);
832 if (IS_ERR(dom))
833 return PTR_ERR(dom);
834
835 /* uS to nS */
836 return dom->opp[dom->opp_count - 1].trans_latency_us * 1000;
837 }
838
839 static int scmi_dvfs_freq_set(const struct scmi_protocol_handle *ph, u32 domain,
840 unsigned long freq, bool poll)
841 {
842 unsigned int level;
843 struct perf_dom_info *dom;
844
845 dom = scmi_perf_domain_lookup(ph, domain);
846 if (IS_ERR(dom))
847 return PTR_ERR(dom);
848
849 if (!dom->level_indexing_mode) {
850 level = freq / dom->mult_factor;
851 } else {
852 struct scmi_opp *opp;
853
854 opp = LOOKUP_BY_FREQ(dom->opps_by_freq, freq / 1000);
855 if (!opp)
856 return -EIO;
857
858 level = opp->level_index;
859 }
860
861 return __scmi_perf_level_set(ph, dom, level, poll);
862 }
863
864 static int scmi_dvfs_freq_get(const struct scmi_protocol_handle *ph, u32 domain,
865 unsigned long *freq, bool poll)
866 {
867 int ret;
868 u32 level;
869 struct perf_dom_info *dom;
870
871 dom = scmi_perf_domain_lookup(ph, domain);
872 if (IS_ERR(dom))
873 return PTR_ERR(dom);
874
875 ret = __scmi_perf_level_get(ph, dom, &level, poll);
876 if (ret)
877 return ret;
878
879 if (!dom->level_indexing_mode) {
880 *freq = level * dom->mult_factor;
881 } else {
882 struct scmi_opp *opp;
883
884 opp = xa_load(&dom->opps_by_idx, level);
885 if (!opp)
886 return -EIO;
887
888 *freq = opp->indicative_freq * 1000;
889 }
890
891 return ret;
892 }
893
894 static int scmi_dvfs_est_power_get(const struct scmi_protocol_handle *ph,
895 u32 domain, unsigned long *freq,
896 unsigned long *power)
897 {
898 struct perf_dom_info *dom;
899 unsigned long opp_freq;
900 int idx, ret = -EINVAL;
901 struct scmi_opp *opp;
902
903 dom = scmi_perf_domain_lookup(ph, domain);
904 if (IS_ERR(dom))
905 return PTR_ERR(dom);
906
907 for (opp = dom->opp, idx = 0; idx < dom->opp_count; idx++, opp++) {
908 if (!dom->level_indexing_mode)
909 opp_freq = opp->perf * dom->mult_factor;
910 else
911 opp_freq = opp->indicative_freq * 1000;
912
913 if (opp_freq < *freq)
914 continue;
915
916 *freq = opp_freq;
917 *power = opp->power;
918 ret = 0;
919 break;
920 }
921
922 return ret;
923 }
924
925 static bool scmi_fast_switch_possible(const struct scmi_protocol_handle *ph,
926 struct device *dev)
927 {
928 int domain;
929 struct perf_dom_info *dom;
930
931 domain = scmi_dev_domain_id(dev);
932 if (domain < 0)
933 return false;
934
935 dom = scmi_perf_domain_lookup(ph, domain);
936 if (IS_ERR(dom))
937 return false;
938
939 return dom->fc_info && dom->fc_info[PERF_FC_LEVEL].set_addr;
940 }
941
942 static enum scmi_power_scale
943 scmi_power_scale_get(const struct scmi_protocol_handle *ph)
944 {
945 struct scmi_perf_info *pi = ph->get_priv(ph);
946
947 return pi->power_scale;
948 }
949
950 static const struct scmi_perf_proto_ops perf_proto_ops = {
951 .limits_set = scmi_perf_limits_set,
952 .limits_get = scmi_perf_limits_get,
953 .level_set = scmi_perf_level_set,
954 .level_get = scmi_perf_level_get,
955 .device_domain_id = scmi_dev_domain_id,
956 .transition_latency_get = scmi_dvfs_transition_latency_get,
957 .device_opps_add = scmi_dvfs_device_opps_add,
958 .freq_set = scmi_dvfs_freq_set,
959 .freq_get = scmi_dvfs_freq_get,
960 .est_power_get = scmi_dvfs_est_power_get,
961 .fast_switch_possible = scmi_fast_switch_possible,
962 .power_scale_get = scmi_power_scale_get,
963 };
964
965 static int scmi_perf_set_notify_enabled(const struct scmi_protocol_handle *ph,
966 u8 evt_id, u32 src_id, bool enable)
967 {
968 int ret, cmd_id;
969
970 if (evt_id >= ARRAY_SIZE(evt_2_cmd))
971 return -EINVAL;
972
973 cmd_id = evt_2_cmd[evt_id];
974 ret = scmi_perf_level_limits_notify(ph, src_id, cmd_id, enable);
975 if (ret)
976 pr_debug("FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n",
977 evt_id, src_id, ret);
978
979 return ret;
980 }
981
982 static void *scmi_perf_fill_custom_report(const struct scmi_protocol_handle *ph,
983 u8 evt_id, ktime_t timestamp,
984 const void *payld, size_t payld_sz,
985 void *report, u32 *src_id)
986 {
987 void *rep = NULL;
988
989 switch (evt_id) {
990 case SCMI_EVENT_PERFORMANCE_LIMITS_CHANGED:
991 {
992 const struct scmi_perf_limits_notify_payld *p = payld;
993 struct scmi_perf_limits_report *r = report;
994
995 if (sizeof(*p) != payld_sz)
996 break;
997
998 r->timestamp = timestamp;
999 r->agent_id = le32_to_cpu(p->agent_id);
1000 r->domain_id = le32_to_cpu(p->domain_id);
1001 r->range_max = le32_to_cpu(p->range_max);
1002 r->range_min = le32_to_cpu(p->range_min);
1003 *src_id = r->domain_id;
1004 rep = r;
1005 break;
1006 }
1007 case SCMI_EVENT_PERFORMANCE_LEVEL_CHANGED:
1008 {
1009 const struct scmi_perf_level_notify_payld *p = payld;
1010 struct scmi_perf_level_report *r = report;
1011
1012 if (sizeof(*p) != payld_sz)
1013 break;
1014
1015 r->timestamp = timestamp;
1016 r->agent_id = le32_to_cpu(p->agent_id);
1017 r->domain_id = le32_to_cpu(p->domain_id);
1018 r->performance_level = le32_to_cpu(p->performance_level);
1019 *src_id = r->domain_id;
1020 rep = r;
1021 break;
1022 }
1023 default:
1024 break;
1025 }
1026
1027 return rep;
1028 }
1029
1030 static int scmi_perf_get_num_sources(const struct scmi_protocol_handle *ph)
1031 {
1032 struct scmi_perf_info *pi = ph->get_priv(ph);
1033
1034 if (!pi)
1035 return -EINVAL;
1036
1037 return pi->num_domains;
1038 }
1039
1040 static const struct scmi_event perf_events[] = {
1041 {
1042 .id = SCMI_EVENT_PERFORMANCE_LIMITS_CHANGED,
1043 .max_payld_sz = sizeof(struct scmi_perf_limits_notify_payld),
1044 .max_report_sz = sizeof(struct scmi_perf_limits_report),
1045 },
1046 {
1047 .id = SCMI_EVENT_PERFORMANCE_LEVEL_CHANGED,
1048 .max_payld_sz = sizeof(struct scmi_perf_level_notify_payld),
1049 .max_report_sz = sizeof(struct scmi_perf_level_report),
1050 },
1051 };
1052
1053 static const struct scmi_event_ops perf_event_ops = {
1054 .get_num_sources = scmi_perf_get_num_sources,
1055 .set_notify_enabled = scmi_perf_set_notify_enabled,
1056 .fill_custom_report = scmi_perf_fill_custom_report,
1057 };
1058
1059 static const struct scmi_protocol_events perf_protocol_events = {
1060 .queue_sz = SCMI_PROTO_QUEUE_SZ,
1061 .ops = &perf_event_ops,
1062 .evts = perf_events,
1063 .num_events = ARRAY_SIZE(perf_events),
1064 };
1065
1066 static int scmi_perf_protocol_init(const struct scmi_protocol_handle *ph)
1067 {
1068 int domain, ret;
1069 u32 version;
1070 struct scmi_perf_info *pinfo;
1071
1072 ret = ph->xops->version_get(ph, &version);
1073 if (ret)
1074 return ret;
1075
1076 dev_dbg(ph->dev, "Performance Version %d.%d\n",
1077 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
1078
1079 pinfo = devm_kzalloc(ph->dev, sizeof(*pinfo), GFP_KERNEL);
1080 if (!pinfo)
1081 return -ENOMEM;
1082
1083 ret = scmi_perf_attributes_get(ph, pinfo);
1084 if (ret)
1085 return ret;
1086
1087 pinfo->dom_info = devm_kcalloc(ph->dev, pinfo->num_domains,
1088 sizeof(*pinfo->dom_info), GFP_KERNEL);
1089 if (!pinfo->dom_info)
1090 return -ENOMEM;
1091
1092 for (domain = 0; domain < pinfo->num_domains; domain++) {
1093 struct perf_dom_info *dom = pinfo->dom_info + domain;
1094
1095 dom->id = domain;
1096 scmi_perf_domain_attributes_get(ph, dom, version);
1097 scmi_perf_describe_levels_get(ph, dom, version);
1098
1099 if (dom->perf_fastchannels)
1100 scmi_perf_domain_init_fc(ph, dom->id, &dom->fc_info);
1101 }
1102
1103 ret = devm_add_action_or_reset(ph->dev, scmi_perf_xa_destroy, pinfo);
1104 if (ret)
1105 return ret;
1106
1107 pinfo->version = version;
1108
1109 return ph->set_priv(ph, pinfo);
1110 }
1111
1112 static const struct scmi_protocol scmi_perf = {
1113 .id = SCMI_PROTOCOL_PERF,
1114 .owner = THIS_MODULE,
1115 .instance_init = &scmi_perf_protocol_init,
1116 .ops = &perf_proto_ops,
1117 .events = &perf_protocol_events,
1118 };
1119
1120 DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(perf, scmi_perf)
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git