1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * System Control and Management Interface (SCMI) Performance Protocol
4 *
5 * Copyright (C) 2018-2022 ARM Ltd.
6 */
7
8 #define pr_fmt(fmt) "SCMI Notifications PERF - " fmt
9
10 #include <linux/bits.h>
11 #include <linux/of.h>
12 #include <linux/io.h>
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/pm_opp.h>
16 #include <linux/scmi_protocol.h>
17 #include <linux/sort.h>
18
19 #include <trace/events/scmi.h>
20
21 #include "protocols.h"
22 #include "notify.h"
23
24 #define MAX_OPPS 16
25
26 enum scmi_performance_protocol_cmd {
27 PERF_DOMAIN_ATTRIBUTES = 0x3,
28 PERF_DESCRIBE_LEVELS = 0x4,
29 PERF_LIMITS_SET = 0x5,
30 PERF_LIMITS_GET = 0x6,
31 PERF_LEVEL_SET = 0x7,
32 PERF_LEVEL_GET = 0x8,
33 PERF_NOTIFY_LIMITS = 0x9,
34 PERF_NOTIFY_LEVEL = 0xa,
35 PERF_DESCRIBE_FASTCHANNEL = 0xb,
36 PERF_DOMAIN_NAME_GET = 0xc,
37 };
38
39 enum {
40 PERF_FC_LEVEL,
41 PERF_FC_LIMIT,
42 PERF_FC_MAX,
43 };
44
45 struct scmi_opp {
46 u32 perf;
47 u32 power;
48 u32 trans_latency_us;
49 };
50
51 struct scmi_msg_resp_perf_attributes {
52 __le16 num_domains;
53 __le16 flags;
54 #define POWER_SCALE_IN_MILLIWATT(x) ((x) & BIT(0))
55 #define POWER_SCALE_IN_MICROWATT(x) ((x) & BIT(1))
56 __le32 stats_addr_low;
57 __le32 stats_addr_high;
58 __le32 stats_size;
59 };
60
61 struct scmi_msg_resp_perf_domain_attributes {
62 __le32 flags;
63 #define SUPPORTS_SET_LIMITS(x) ((x) & BIT(31))
64 #define SUPPORTS_SET_PERF_LVL(x) ((x) & BIT(30))
65 #define SUPPORTS_PERF_LIMIT_NOTIFY(x) ((x) & BIT(29))
66 #define SUPPORTS_PERF_LEVEL_NOTIFY(x) ((x) & BIT(28))
67 #define SUPPORTS_PERF_FASTCHANNELS(x) ((x) & BIT(27))
68 #define SUPPORTS_EXTENDED_NAMES(x) ((x) & BIT(26))
69 __le32 rate_limit_us;
70 __le32 sustained_freq_khz;
71 __le32 sustained_perf_level;
72 u8 name[SCMI_SHORT_NAME_MAX_SIZE];
73 };
74
75 struct scmi_msg_perf_describe_levels {
76 __le32 domain;
77 __le32 level_index;
78 };
79
80 struct scmi_perf_set_limits {
81 __le32 domain;
82 __le32 max_level;
83 __le32 min_level;
84 };
85
86 struct scmi_perf_get_limits {
87 __le32 max_level;
88 __le32 min_level;
89 };
90
91 struct scmi_perf_set_level {
92 __le32 domain;
93 __le32 level;
94 };
95
96 struct scmi_perf_notify_level_or_limits {
97 __le32 domain;
98 __le32 notify_enable;
99 };
100
101 struct scmi_perf_limits_notify_payld {
102 __le32 agent_id;
103 __le32 domain_id;
104 __le32 range_max;
105 __le32 range_min;
106 };
107
108 struct scmi_perf_level_notify_payld {
109 __le32 agent_id;
110 __le32 domain_id;
111 __le32 performance_level;
112 };
113
114 struct scmi_msg_resp_perf_describe_levels {
115 __le16 num_returned;
116 __le16 num_remaining;
117 struct {
118 __le32 perf_val;
119 __le32 power;
120 __le16 transition_latency_us;
121 __le16 reserved;
122 } opp[];
123 };
124
125 struct perf_dom_info {
126 bool set_limits;
127 bool set_perf;
128 bool perf_limit_notify;
129 bool perf_level_notify;
130 bool perf_fastchannels;
131 u32 opp_count;
132 u32 sustained_freq_khz;
133 u32 sustained_perf_level;
134 u32 mult_factor;
135 char name[SCMI_MAX_STR_SIZE];
136 struct scmi_opp opp[MAX_OPPS];
137 struct scmi_fc_info *fc_info;
138 };
139
140 struct scmi_perf_info {
141 u32 version;
142 int num_domains;
143 enum scmi_power_scale power_scale;
144 u64 stats_addr;
145 u32 stats_size;
146 struct perf_dom_info *dom_info;
147 };
148
149 static enum scmi_performance_protocol_cmd evt_2_cmd[] = {
150 PERF_NOTIFY_LIMITS,
151 PERF_NOTIFY_LEVEL,
152 };
153
scmi_perf_attributes_get(const struct scmi_protocol_handle * ph,struct scmi_perf_info * pi)154 static int scmi_perf_attributes_get(const struct scmi_protocol_handle *ph,
155 struct scmi_perf_info *pi)
156 {
157 int ret;
158 struct scmi_xfer *t;
159 struct scmi_msg_resp_perf_attributes *attr;
160
161 ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0,
162 sizeof(*attr), &t);
163 if (ret)
164 return ret;
165
166 attr = t->rx.buf;
167
168 ret = ph->xops->do_xfer(ph, t);
169 if (!ret) {
170 u16 flags = le16_to_cpu(attr->flags);
171
172 pi->num_domains = le16_to_cpu(attr->num_domains);
173
174 if (POWER_SCALE_IN_MILLIWATT(flags))
175 pi->power_scale = SCMI_POWER_MILLIWATTS;
176 if (PROTOCOL_REV_MAJOR(pi->version) >= 0x3)
177 if (POWER_SCALE_IN_MICROWATT(flags))
178 pi->power_scale = SCMI_POWER_MICROWATTS;
179
180 pi->stats_addr = le32_to_cpu(attr->stats_addr_low) |
181 (u64)le32_to_cpu(attr->stats_addr_high) << 32;
182 pi->stats_size = le32_to_cpu(attr->stats_size);
183 }
184
185 ph->xops->xfer_put(ph, t);
186 return ret;
187 }
188
189 static int
scmi_perf_domain_attributes_get(const struct scmi_protocol_handle * ph,u32 domain,struct perf_dom_info * dom_info,u32 version)190 scmi_perf_domain_attributes_get(const struct scmi_protocol_handle *ph,
191 u32 domain, struct perf_dom_info *dom_info,
192 u32 version)
193 {
194 int ret;
195 u32 flags;
196 struct scmi_xfer *t;
197 struct scmi_msg_resp_perf_domain_attributes *attr;
198
199 ret = ph->xops->xfer_get_init(ph, PERF_DOMAIN_ATTRIBUTES,
200 sizeof(domain), sizeof(*attr), &t);
201 if (ret)
202 return ret;
203
204 put_unaligned_le32(domain, t->tx.buf);
205 attr = t->rx.buf;
206
207 ret = ph->xops->do_xfer(ph, t);
208 if (!ret) {
209 flags = le32_to_cpu(attr->flags);
210
211 dom_info->set_limits = SUPPORTS_SET_LIMITS(flags);
212 dom_info->set_perf = SUPPORTS_SET_PERF_LVL(flags);
213 dom_info->perf_limit_notify = SUPPORTS_PERF_LIMIT_NOTIFY(flags);
214 dom_info->perf_level_notify = SUPPORTS_PERF_LEVEL_NOTIFY(flags);
215 dom_info->perf_fastchannels = SUPPORTS_PERF_FASTCHANNELS(flags);
216 dom_info->sustained_freq_khz =
217 le32_to_cpu(attr->sustained_freq_khz);
218 dom_info->sustained_perf_level =
219 le32_to_cpu(attr->sustained_perf_level);
220 if (!dom_info->sustained_freq_khz ||
221 !dom_info->sustained_perf_level)
222 /* CPUFreq converts to kHz, hence default 1000 */
223 dom_info->mult_factor = 1000;
224 else
225 dom_info->mult_factor =
226 (dom_info->sustained_freq_khz * 1000) /
227 dom_info->sustained_perf_level;
228 strscpy(dom_info->name, attr->name, SCMI_SHORT_NAME_MAX_SIZE);
229 }
230
231 ph->xops->xfer_put(ph, t);
232
233 /*
234 * If supported overwrite short name with the extended one;
235 * on error just carry on and use already provided short name.
236 */
237 if (!ret && PROTOCOL_REV_MAJOR(version) >= 0x3 &&
238 SUPPORTS_EXTENDED_NAMES(flags))
239 ph->hops->extended_name_get(ph, PERF_DOMAIN_NAME_GET, domain,
240 dom_info->name, SCMI_MAX_STR_SIZE);
241
242 return ret;
243 }
244
opp_cmp_func(const void * opp1,const void * opp2)245 static int opp_cmp_func(const void *opp1, const void *opp2)
246 {
247 const struct scmi_opp *t1 = opp1, *t2 = opp2;
248
249 return t1->perf - t2->perf;
250 }
251
252 struct scmi_perf_ipriv {
253 u32 domain;
254 struct perf_dom_info *perf_dom;
255 };
256
iter_perf_levels_prepare_message(void * message,unsigned int desc_index,const void * priv)257 static void iter_perf_levels_prepare_message(void *message,
258 unsigned int desc_index,
259 const void *priv)
260 {
261 struct scmi_msg_perf_describe_levels *msg = message;
262 const struct scmi_perf_ipriv *p = priv;
263
264 msg->domain = cpu_to_le32(p->domain);
265 /* Set the number of OPPs to be skipped/already read */
266 msg->level_index = cpu_to_le32(desc_index);
267 }
268
iter_perf_levels_update_state(struct scmi_iterator_state * st,const void * response,void * priv)269 static int iter_perf_levels_update_state(struct scmi_iterator_state *st,
270 const void *response, void *priv)
271 {
272 const struct scmi_msg_resp_perf_describe_levels *r = response;
273
274 st->num_returned = le16_to_cpu(r->num_returned);
275 st->num_remaining = le16_to_cpu(r->num_remaining);
276
277 return 0;
278 }
279
280 static int
iter_perf_levels_process_response(const struct scmi_protocol_handle * ph,const void * response,struct scmi_iterator_state * st,void * priv)281 iter_perf_levels_process_response(const struct scmi_protocol_handle *ph,
282 const void *response,
283 struct scmi_iterator_state *st, void *priv)
284 {
285 struct scmi_opp *opp;
286 const struct scmi_msg_resp_perf_describe_levels *r = response;
287 struct scmi_perf_ipriv *p = priv;
288
289 opp = &p->perf_dom->opp[st->desc_index + st->loop_idx];
290 opp->perf = le32_to_cpu(r->opp[st->loop_idx].perf_val);
291 opp->power = le32_to_cpu(r->opp[st->loop_idx].power);
292 opp->trans_latency_us =
293 le16_to_cpu(r->opp[st->loop_idx].transition_latency_us);
294 p->perf_dom->opp_count++;
295
296 dev_dbg(ph->dev, "Level %d Power %d Latency %dus\n",
297 opp->perf, opp->power, opp->trans_latency_us);
298
299 return 0;
300 }
301
302 static int
scmi_perf_describe_levels_get(const struct scmi_protocol_handle * ph,u32 domain,struct perf_dom_info * perf_dom)303 scmi_perf_describe_levels_get(const struct scmi_protocol_handle *ph, u32 domain,
304 struct perf_dom_info *perf_dom)
305 {
306 int ret;
307 void *iter;
308 struct scmi_iterator_ops ops = {
309 .prepare_message = iter_perf_levels_prepare_message,
310 .update_state = iter_perf_levels_update_state,
311 .process_response = iter_perf_levels_process_response,
312 };
313 struct scmi_perf_ipriv ppriv = {
314 .domain = domain,
315 .perf_dom = perf_dom,
316 };
317
318 iter = ph->hops->iter_response_init(ph, &ops, MAX_OPPS,
319 PERF_DESCRIBE_LEVELS,
320 sizeof(struct scmi_msg_perf_describe_levels),
321 &ppriv);
322 if (IS_ERR(iter))
323 return PTR_ERR(iter);
324
325 ret = ph->hops->iter_response_run(iter);
326 if (ret)
327 return ret;
328
329 if (perf_dom->opp_count)
330 sort(perf_dom->opp, perf_dom->opp_count,
331 sizeof(struct scmi_opp), opp_cmp_func, NULL);
332
333 return ret;
334 }
335
scmi_perf_mb_limits_set(const struct scmi_protocol_handle * ph,u32 domain,u32 max_perf,u32 min_perf)336 static int scmi_perf_mb_limits_set(const struct scmi_protocol_handle *ph,
337 u32 domain, u32 max_perf, u32 min_perf)
338 {
339 int ret;
340 struct scmi_xfer *t;
341 struct scmi_perf_set_limits *limits;
342
343 ret = ph->xops->xfer_get_init(ph, PERF_LIMITS_SET,
344 sizeof(*limits), 0, &t);
345 if (ret)
346 return ret;
347
348 limits = t->tx.buf;
349 limits->domain = cpu_to_le32(domain);
350 limits->max_level = cpu_to_le32(max_perf);
351 limits->min_level = cpu_to_le32(min_perf);
352
353 ret = ph->xops->do_xfer(ph, t);
354
355 ph->xops->xfer_put(ph, t);
356 return ret;
357 }
358
scmi_perf_limits_set(const struct scmi_protocol_handle * ph,u32 domain,u32 max_perf,u32 min_perf)359 static int scmi_perf_limits_set(const struct scmi_protocol_handle *ph,
360 u32 domain, u32 max_perf, u32 min_perf)
361 {
362 struct scmi_perf_info *pi = ph->get_priv(ph);
363 struct perf_dom_info *dom = pi->dom_info + domain;
364
365 if (PROTOCOL_REV_MAJOR(pi->version) >= 0x3 && !max_perf && !min_perf)
366 return -EINVAL;
367
368 if (dom->fc_info && dom->fc_info[PERF_FC_LIMIT].set_addr) {
369 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LIMIT];
370
371 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LIMITS_SET,
372 domain, min_perf, max_perf);
373 iowrite32(max_perf, fci->set_addr);
374 iowrite32(min_perf, fci->set_addr + 4);
375 ph->hops->fastchannel_db_ring(fci->set_db);
376 return 0;
377 }
378
379 return scmi_perf_mb_limits_set(ph, domain, max_perf, min_perf);
380 }
381
scmi_perf_mb_limits_get(const struct scmi_protocol_handle * ph,u32 domain,u32 * max_perf,u32 * min_perf)382 static int scmi_perf_mb_limits_get(const struct scmi_protocol_handle *ph,
383 u32 domain, u32 *max_perf, u32 *min_perf)
384 {
385 int ret;
386 struct scmi_xfer *t;
387 struct scmi_perf_get_limits *limits;
388
389 ret = ph->xops->xfer_get_init(ph, PERF_LIMITS_GET,
390 sizeof(__le32), 0, &t);
391 if (ret)
392 return ret;
393
394 put_unaligned_le32(domain, t->tx.buf);
395
396 ret = ph->xops->do_xfer(ph, t);
397 if (!ret) {
398 limits = t->rx.buf;
399
400 *max_perf = le32_to_cpu(limits->max_level);
401 *min_perf = le32_to_cpu(limits->min_level);
402 }
403
404 ph->xops->xfer_put(ph, t);
405 return ret;
406 }
407
scmi_perf_limits_get(const struct scmi_protocol_handle * ph,u32 domain,u32 * max_perf,u32 * min_perf)408 static int scmi_perf_limits_get(const struct scmi_protocol_handle *ph,
409 u32 domain, u32 *max_perf, u32 *min_perf)
410 {
411 struct scmi_perf_info *pi = ph->get_priv(ph);
412 struct perf_dom_info *dom = pi->dom_info + domain;
413
414 if (dom->fc_info && dom->fc_info[PERF_FC_LIMIT].get_addr) {
415 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LIMIT];
416
417 *max_perf = ioread32(fci->get_addr);
418 *min_perf = ioread32(fci->get_addr + 4);
419 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LIMITS_GET,
420 domain, *min_perf, *max_perf);
421 return 0;
422 }
423
424 return scmi_perf_mb_limits_get(ph, domain, max_perf, min_perf);
425 }
426
scmi_perf_mb_level_set(const struct scmi_protocol_handle * ph,u32 domain,u32 level,bool poll)427 static int scmi_perf_mb_level_set(const struct scmi_protocol_handle *ph,
428 u32 domain, u32 level, bool poll)
429 {
430 int ret;
431 struct scmi_xfer *t;
432 struct scmi_perf_set_level *lvl;
433
434 ret = ph->xops->xfer_get_init(ph, PERF_LEVEL_SET, sizeof(*lvl), 0, &t);
435 if (ret)
436 return ret;
437
438 t->hdr.poll_completion = poll;
439 lvl = t->tx.buf;
440 lvl->domain = cpu_to_le32(domain);
441 lvl->level = cpu_to_le32(level);
442
443 ret = ph->xops->do_xfer(ph, t);
444
445 ph->xops->xfer_put(ph, t);
446 return ret;
447 }
448
scmi_perf_level_set(const struct scmi_protocol_handle * ph,u32 domain,u32 level,bool poll)449 static int scmi_perf_level_set(const struct scmi_protocol_handle *ph,
450 u32 domain, u32 level, bool poll)
451 {
452 struct scmi_perf_info *pi = ph->get_priv(ph);
453 struct perf_dom_info *dom = pi->dom_info + domain;
454
455 if (dom->fc_info && dom->fc_info[PERF_FC_LEVEL].set_addr) {
456 struct scmi_fc_info *fci = &dom->fc_info[PERF_FC_LEVEL];
457
458 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LEVEL_SET,
459 domain, level, 0);
460 iowrite32(level, fci->set_addr);
461 ph->hops->fastchannel_db_ring(fci->set_db);
462 return 0;
463 }
464
465 return scmi_perf_mb_level_set(ph, domain, level, poll);
466 }
467
scmi_perf_mb_level_get(const struct scmi_protocol_handle * ph,u32 domain,u32 * level,bool poll)468 static int scmi_perf_mb_level_get(const struct scmi_protocol_handle *ph,
469 u32 domain, u32 *level, bool poll)
470 {
471 int ret;
472 struct scmi_xfer *t;
473
474 ret = ph->xops->xfer_get_init(ph, PERF_LEVEL_GET,
475 sizeof(u32), sizeof(u32), &t);
476 if (ret)
477 return ret;
478
479 t->hdr.poll_completion = poll;
480 put_unaligned_le32(domain, t->tx.buf);
481
482 ret = ph->xops->do_xfer(ph, t);
483 if (!ret)
484 *level = get_unaligned_le32(t->rx.buf);
485
486 ph->xops->xfer_put(ph, t);
487 return ret;
488 }
489
scmi_perf_level_get(const struct scmi_protocol_handle * ph,u32 domain,u32 * level,bool poll)490 static int scmi_perf_level_get(const struct scmi_protocol_handle *ph,
491 u32 domain, u32 *level, bool poll)
492 {
493 struct scmi_perf_info *pi = ph->get_priv(ph);
494 struct perf_dom_info *dom = pi->dom_info + domain;
495
496 if (dom->fc_info && dom->fc_info[PERF_FC_LEVEL].get_addr) {
497 *level = ioread32(dom->fc_info[PERF_FC_LEVEL].get_addr);
498 trace_scmi_fc_call(SCMI_PROTOCOL_PERF, PERF_LEVEL_GET,
499 domain, *level, 0);
500 return 0;
501 }
502
503 return scmi_perf_mb_level_get(ph, domain, level, poll);
504 }
505
scmi_perf_level_limits_notify(const struct scmi_protocol_handle * ph,u32 domain,int message_id,bool enable)506 static int scmi_perf_level_limits_notify(const struct scmi_protocol_handle *ph,
507 u32 domain, int message_id,
508 bool enable)
509 {
510 int ret;
511 struct scmi_xfer *t;
512 struct scmi_perf_notify_level_or_limits *notify;
513
514 ret = ph->xops->xfer_get_init(ph, message_id, sizeof(*notify), 0, &t);
515 if (ret)
516 return ret;
517
518 notify = t->tx.buf;
519 notify->domain = cpu_to_le32(domain);
520 notify->notify_enable = enable ? cpu_to_le32(BIT(0)) : 0;
521
522 ret = ph->xops->do_xfer(ph, t);
523
524 ph->xops->xfer_put(ph, t);
525 return ret;
526 }
527
scmi_perf_domain_init_fc(const struct scmi_protocol_handle * ph,u32 domain,struct scmi_fc_info ** p_fc)528 static void scmi_perf_domain_init_fc(const struct scmi_protocol_handle *ph,
529 u32 domain, struct scmi_fc_info **p_fc)
530 {
531 struct scmi_fc_info *fc;
532
533 fc = devm_kcalloc(ph->dev, PERF_FC_MAX, sizeof(*fc), GFP_KERNEL);
534 if (!fc)
535 return;
536
537 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
538 PERF_LEVEL_SET, 4, domain,
539 &fc[PERF_FC_LEVEL].set_addr,
540 &fc[PERF_FC_LEVEL].set_db);
541
542 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
543 PERF_LEVEL_GET, 4, domain,
544 &fc[PERF_FC_LEVEL].get_addr, NULL);
545
546 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
547 PERF_LIMITS_SET, 8, domain,
548 &fc[PERF_FC_LIMIT].set_addr,
549 &fc[PERF_FC_LIMIT].set_db);
550
551 ph->hops->fastchannel_init(ph, PERF_DESCRIBE_FASTCHANNEL,
552 PERF_LIMITS_GET, 8, domain,
553 &fc[PERF_FC_LIMIT].get_addr, NULL);
554
555 *p_fc = fc;
556 }
557
558 /* Device specific ops */
scmi_dev_domain_id(struct device * dev)559 static int scmi_dev_domain_id(struct device *dev)
560 {
561 struct of_phandle_args clkspec;
562
563 if (of_parse_phandle_with_args(dev->of_node, "clocks", "#clock-cells",
564 0, &clkspec))
565 return -EINVAL;
566
567 return clkspec.args[0];
568 }
569
scmi_dvfs_device_opps_add(const struct scmi_protocol_handle * ph,struct device * dev)570 static int scmi_dvfs_device_opps_add(const struct scmi_protocol_handle *ph,
571 struct device *dev)
572 {
573 int idx, ret, domain;
574 unsigned long freq;
575 struct scmi_opp *opp;
576 struct perf_dom_info *dom;
577 struct scmi_perf_info *pi = ph->get_priv(ph);
578
579 domain = scmi_dev_domain_id(dev);
580 if (domain < 0)
581 return domain;
582
583 dom = pi->dom_info + domain;
584
585 for (opp = dom->opp, idx = 0; idx < dom->opp_count; idx++, opp++) {
586 freq = opp->perf * dom->mult_factor;
587
588 ret = dev_pm_opp_add(dev, freq, 0);
589 if (ret) {
590 dev_warn(dev, "failed to add opp %luHz\n", freq);
591
592 while (idx-- > 0) {
593 freq = (--opp)->perf * dom->mult_factor;
594 dev_pm_opp_remove(dev, freq);
595 }
596 return ret;
597 }
598 }
599 return 0;
600 }
601
602 static int
scmi_dvfs_transition_latency_get(const struct scmi_protocol_handle * ph,struct device * dev)603 scmi_dvfs_transition_latency_get(const struct scmi_protocol_handle *ph,
604 struct device *dev)
605 {
606 struct perf_dom_info *dom;
607 struct scmi_perf_info *pi = ph->get_priv(ph);
608 int domain = scmi_dev_domain_id(dev);
609
610 if (domain < 0)
611 return domain;
612
613 dom = pi->dom_info + domain;
614 /* uS to nS */
615 return dom->opp[dom->opp_count - 1].trans_latency_us * 1000;
616 }
617
scmi_dvfs_freq_set(const struct scmi_protocol_handle * ph,u32 domain,unsigned long freq,bool poll)618 static int scmi_dvfs_freq_set(const struct scmi_protocol_handle *ph, u32 domain,
619 unsigned long freq, bool poll)
620 {
621 struct scmi_perf_info *pi = ph->get_priv(ph);
622 struct perf_dom_info *dom = pi->dom_info + domain;
623
624 return scmi_perf_level_set(ph, domain, freq / dom->mult_factor, poll);
625 }
626
scmi_dvfs_freq_get(const struct scmi_protocol_handle * ph,u32 domain,unsigned long * freq,bool poll)627 static int scmi_dvfs_freq_get(const struct scmi_protocol_handle *ph, u32 domain,
628 unsigned long *freq, bool poll)
629 {
630 int ret;
631 u32 level;
632 struct scmi_perf_info *pi = ph->get_priv(ph);
633 struct perf_dom_info *dom = pi->dom_info + domain;
634
635 ret = scmi_perf_level_get(ph, domain, &level, poll);
636 if (!ret)
637 *freq = level * dom->mult_factor;
638
639 return ret;
640 }
641
scmi_dvfs_est_power_get(const struct scmi_protocol_handle * ph,u32 domain,unsigned long * freq,unsigned long * power)642 static int scmi_dvfs_est_power_get(const struct scmi_protocol_handle *ph,
643 u32 domain, unsigned long *freq,
644 unsigned long *power)
645 {
646 struct scmi_perf_info *pi = ph->get_priv(ph);
647 struct perf_dom_info *dom;
648 unsigned long opp_freq;
649 int idx, ret = -EINVAL;
650 struct scmi_opp *opp;
651
652 dom = pi->dom_info + domain;
653 if (!dom)
654 return -EIO;
655
656 for (opp = dom->opp, idx = 0; idx < dom->opp_count; idx++, opp++) {
657 opp_freq = opp->perf * dom->mult_factor;
658 if (opp_freq < *freq)
659 continue;
660
661 *freq = opp_freq;
662 *power = opp->power;
663 ret = 0;
664 break;
665 }
666
667 return ret;
668 }
669
scmi_fast_switch_possible(const struct scmi_protocol_handle * ph,struct device * dev)670 static bool scmi_fast_switch_possible(const struct scmi_protocol_handle *ph,
671 struct device *dev)
672 {
673 struct perf_dom_info *dom;
674 struct scmi_perf_info *pi = ph->get_priv(ph);
675
676 dom = pi->dom_info + scmi_dev_domain_id(dev);
677
678 return dom->fc_info && dom->fc_info[PERF_FC_LEVEL].set_addr;
679 }
680
681 static enum scmi_power_scale
scmi_power_scale_get(const struct scmi_protocol_handle * ph)682 scmi_power_scale_get(const struct scmi_protocol_handle *ph)
683 {
684 struct scmi_perf_info *pi = ph->get_priv(ph);
685
686 return pi->power_scale;
687 }
688
689 static const struct scmi_perf_proto_ops perf_proto_ops = {
690 .limits_set = scmi_perf_limits_set,
691 .limits_get = scmi_perf_limits_get,
692 .level_set = scmi_perf_level_set,
693 .level_get = scmi_perf_level_get,
694 .device_domain_id = scmi_dev_domain_id,
695 .transition_latency_get = scmi_dvfs_transition_latency_get,
696 .device_opps_add = scmi_dvfs_device_opps_add,
697 .freq_set = scmi_dvfs_freq_set,
698 .freq_get = scmi_dvfs_freq_get,
699 .est_power_get = scmi_dvfs_est_power_get,
700 .fast_switch_possible = scmi_fast_switch_possible,
701 .power_scale_get = scmi_power_scale_get,
702 };
703
scmi_perf_set_notify_enabled(const struct scmi_protocol_handle * ph,u8 evt_id,u32 src_id,bool enable)704 static int scmi_perf_set_notify_enabled(const struct scmi_protocol_handle *ph,
705 u8 evt_id, u32 src_id, bool enable)
706 {
707 int ret, cmd_id;
708
709 if (evt_id >= ARRAY_SIZE(evt_2_cmd))
710 return -EINVAL;
711
712 cmd_id = evt_2_cmd[evt_id];
713 ret = scmi_perf_level_limits_notify(ph, src_id, cmd_id, enable);
714 if (ret)
715 pr_debug("FAIL_ENABLED - evt[%X] dom[%d] - ret:%d\n",
716 evt_id, src_id, ret);
717
718 return ret;
719 }
720
scmi_perf_fill_custom_report(const struct scmi_protocol_handle * ph,u8 evt_id,ktime_t timestamp,const void * payld,size_t payld_sz,void * report,u32 * src_id)721 static void *scmi_perf_fill_custom_report(const struct scmi_protocol_handle *ph,
722 u8 evt_id, ktime_t timestamp,
723 const void *payld, size_t payld_sz,
724 void *report, u32 *src_id)
725 {
726 void *rep = NULL;
727
728 switch (evt_id) {
729 case SCMI_EVENT_PERFORMANCE_LIMITS_CHANGED:
730 {
731 const struct scmi_perf_limits_notify_payld *p = payld;
732 struct scmi_perf_limits_report *r = report;
733
734 if (sizeof(*p) != payld_sz)
735 break;
736
737 r->timestamp = timestamp;
738 r->agent_id = le32_to_cpu(p->agent_id);
739 r->domain_id = le32_to_cpu(p->domain_id);
740 r->range_max = le32_to_cpu(p->range_max);
741 r->range_min = le32_to_cpu(p->range_min);
742 *src_id = r->domain_id;
743 rep = r;
744 break;
745 }
746 case SCMI_EVENT_PERFORMANCE_LEVEL_CHANGED:
747 {
748 const struct scmi_perf_level_notify_payld *p = payld;
749 struct scmi_perf_level_report *r = report;
750
751 if (sizeof(*p) != payld_sz)
752 break;
753
754 r->timestamp = timestamp;
755 r->agent_id = le32_to_cpu(p->agent_id);
756 r->domain_id = le32_to_cpu(p->domain_id);
757 r->performance_level = le32_to_cpu(p->performance_level);
758 *src_id = r->domain_id;
759 rep = r;
760 break;
761 }
762 default:
763 break;
764 }
765
766 return rep;
767 }
768
scmi_perf_get_num_sources(const struct scmi_protocol_handle * ph)769 static int scmi_perf_get_num_sources(const struct scmi_protocol_handle *ph)
770 {
771 struct scmi_perf_info *pi = ph->get_priv(ph);
772
773 if (!pi)
774 return -EINVAL;
775
776 return pi->num_domains;
777 }
778
779 static const struct scmi_event perf_events[] = {
780 {
781 .id = SCMI_EVENT_PERFORMANCE_LIMITS_CHANGED,
782 .max_payld_sz = sizeof(struct scmi_perf_limits_notify_payld),
783 .max_report_sz = sizeof(struct scmi_perf_limits_report),
784 },
785 {
786 .id = SCMI_EVENT_PERFORMANCE_LEVEL_CHANGED,
787 .max_payld_sz = sizeof(struct scmi_perf_level_notify_payld),
788 .max_report_sz = sizeof(struct scmi_perf_level_report),
789 },
790 };
791
792 static const struct scmi_event_ops perf_event_ops = {
793 .get_num_sources = scmi_perf_get_num_sources,
794 .set_notify_enabled = scmi_perf_set_notify_enabled,
795 .fill_custom_report = scmi_perf_fill_custom_report,
796 };
797
798 static const struct scmi_protocol_events perf_protocol_events = {
799 .queue_sz = SCMI_PROTO_QUEUE_SZ,
800 .ops = &perf_event_ops,
801 .evts = perf_events,
802 .num_events = ARRAY_SIZE(perf_events),
803 };
804
scmi_perf_protocol_init(const struct scmi_protocol_handle * ph)805 static int scmi_perf_protocol_init(const struct scmi_protocol_handle *ph)
806 {
807 int domain, ret;
808 u32 version;
809 struct scmi_perf_info *pinfo;
810
811 ret = ph->xops->version_get(ph, &version);
812 if (ret)
813 return ret;
814
815 dev_dbg(ph->dev, "Performance Version %d.%d\n",
816 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
817
818 pinfo = devm_kzalloc(ph->dev, sizeof(*pinfo), GFP_KERNEL);
819 if (!pinfo)
820 return -ENOMEM;
821
822 ret = scmi_perf_attributes_get(ph, pinfo);
823 if (ret)
824 return ret;
825
826 pinfo->dom_info = devm_kcalloc(ph->dev, pinfo->num_domains,
827 sizeof(*pinfo->dom_info), GFP_KERNEL);
828 if (!pinfo->dom_info)
829 return -ENOMEM;
830
831 for (domain = 0; domain < pinfo->num_domains; domain++) {
832 struct perf_dom_info *dom = pinfo->dom_info + domain;
833
834 scmi_perf_domain_attributes_get(ph, domain, dom, version);
835 scmi_perf_describe_levels_get(ph, domain, dom);
836
837 if (dom->perf_fastchannels)
838 scmi_perf_domain_init_fc(ph, domain, &dom->fc_info);
839 }
840
841 pinfo->version = version;
842
843 return ph->set_priv(ph, pinfo);
844 }
845
846 static const struct scmi_protocol scmi_perf = {
847 .id = SCMI_PROTOCOL_PERF,
848 .owner = THIS_MODULE,
849 .instance_init = &scmi_perf_protocol_init,
850 .ops = &perf_proto_ops,
851 .events = &perf_protocol_events,
852 };
853
854 DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(perf, scmi_perf)
855