1 // SPDX-License-Identifier: BSD-3-Clause
2 /*
3 * Copyright (c) 2015-2019, Arm Limited and Contributors. All rights reserved.
4 * Copyright (c) 2019, Linaro Limited
5 */
6 #include <assert.h>
7 #include <confine_array_index.h>
8 #include <drivers/scmi-msg.h>
9 #include <drivers/scmi.h>
10 #include <string.h>
11 #include <trace.h>
12 #include <util.h>
13
14 #include "base.h"
15 #include "common.h"
16
17 static bool message_id_is_supported(unsigned int message_id);
18
report_version(struct scmi_msg * msg)19 static void report_version(struct scmi_msg *msg)
20 {
21 struct scmi_protocol_version_p2a return_values = {
22 .status = SCMI_SUCCESS,
23 .version = SCMI_PROTOCOL_VERSION_BASE,
24 };
25
26 if (msg->in_size) {
27 scmi_status_response(msg, SCMI_PROTOCOL_ERROR);
28 return;
29 }
30
31 scmi_write_response(msg, &return_values, sizeof(return_values));
32 }
33
report_attributes(struct scmi_msg * msg)34 static void report_attributes(struct scmi_msg *msg)
35 {
36 size_t protocol_count = plat_scmi_protocol_count();
37 struct scmi_protocol_attributes_p2a return_values = {
38 .status = SCMI_SUCCESS,
39 /* Null agent count since agent discovery is not supported */
40 .attributes = SCMI_BASE_PROTOCOL_ATTRIBUTES(protocol_count, 0),
41 };
42
43 if (msg->in_size) {
44 scmi_status_response(msg, SCMI_PROTOCOL_ERROR);
45 return;
46 }
47
48 scmi_write_response(msg, &return_values, sizeof(return_values));
49 }
50
report_message_attributes(struct scmi_msg * msg)51 static void report_message_attributes(struct scmi_msg *msg)
52 {
53 struct scmi_protocol_message_attributes_a2p *in_args = (void *)msg->in;
54 struct scmi_protocol_message_attributes_p2a return_values = {
55 .status = SCMI_SUCCESS,
56 /* For this protocol, attributes shall be zero */
57 .attributes = 0,
58 };
59
60 if (msg->in_size != sizeof(*in_args)) {
61 scmi_status_response(msg, SCMI_PROTOCOL_ERROR);
62 return;
63 }
64
65 if (!message_id_is_supported(in_args->message_id)) {
66 scmi_status_response(msg, SCMI_NOT_FOUND);
67 return;
68 }
69
70 scmi_write_response(msg, &return_values, sizeof(return_values));
71 }
72
discover_vendor(struct scmi_msg * msg)73 static void discover_vendor(struct scmi_msg *msg)
74 {
75 const char *name = plat_scmi_vendor_name();
76 struct scmi_base_discover_vendor_p2a return_values = {
77 .status = SCMI_SUCCESS,
78 };
79
80 if (msg->in_size) {
81 scmi_status_response(msg, SCMI_PROTOCOL_ERROR);
82 return;
83 }
84
85 COPY_NAME_IDENTIFIER(return_values.vendor_identifier, name);
86
87 scmi_write_response(msg, &return_values, sizeof(return_values));
88 }
89
discover_sub_vendor(struct scmi_msg * msg)90 static void discover_sub_vendor(struct scmi_msg *msg)
91 {
92 const char *name = plat_scmi_sub_vendor_name();
93 struct scmi_base_discover_sub_vendor_p2a return_values = {
94 .status = SCMI_SUCCESS,
95 };
96
97 if (msg->in_size) {
98 scmi_status_response(msg, SCMI_PROTOCOL_ERROR);
99 return;
100 }
101
102 COPY_NAME_IDENTIFIER(return_values.sub_vendor_identifier, name);
103
104 scmi_write_response(msg, &return_values, sizeof(return_values));
105 }
106
discover_implementation_version(struct scmi_msg * msg)107 static void discover_implementation_version(struct scmi_msg *msg)
108 {
109 struct scmi_protocol_version_p2a return_values = {
110 .status = SCMI_SUCCESS,
111 .version = SCMI_IMPL_VERSION,
112 };
113
114 if (msg->in_size) {
115 scmi_status_response(msg, SCMI_PROTOCOL_ERROR);
116 return;
117 }
118
119 scmi_write_response(msg, &return_values, sizeof(return_values));
120 }
121
count_protocols_in_list(const uint8_t * protocol_list)122 static unsigned int count_protocols_in_list(const uint8_t *protocol_list)
123 {
124 unsigned int count = 0;
125
126 if (protocol_list)
127 while (protocol_list[count])
128 count++;
129
130 return count;
131 }
132
133 #define MAX_PROTOCOL_IN_LIST 8u
134
discover_list_protocols(struct scmi_msg * msg)135 static void discover_list_protocols(struct scmi_msg *msg)
136 {
137 const struct scmi_base_discover_list_protocols_a2p *a2p = NULL;
138 struct scmi_base_discover_list_protocols_p2a p2a = {
139 .status = SCMI_SUCCESS,
140 };
141 uint8_t outargs[sizeof(p2a) + MAX_PROTOCOL_IN_LIST] = { };
142 const uint8_t *list = NULL;
143 unsigned int count = 0;
144
145 if (msg->in_size != sizeof(*a2p)) {
146 scmi_status_response(msg, SCMI_PROTOCOL_ERROR);
147 return;
148 }
149
150 assert(msg->out_size > sizeof(outargs));
151
152 a2p = (void *)msg->in;
153
154 list = plat_scmi_protocol_list(msg->channel_id);
155 count = count_protocols_in_list(list);
156 if (count > a2p->skip)
157 count = MIN(count - a2p->skip, MAX_PROTOCOL_IN_LIST);
158 else
159 count = 0;
160
161 p2a.num_protocols = count;
162
163 memcpy(outargs, &p2a, sizeof(p2a));
164 memcpy(outargs + sizeof(p2a), list + a2p->skip, count);
165
166 scmi_write_response(msg, outargs, sizeof(outargs));
167 }
168
169 static const scmi_msg_handler_t scmi_base_handler_table[] = {
170 [SCMI_PROTOCOL_VERSION] = report_version,
171 [SCMI_PROTOCOL_ATTRIBUTES] = report_attributes,
172 [SCMI_PROTOCOL_MESSAGE_ATTRIBUTES] = report_message_attributes,
173 [SCMI_BASE_DISCOVER_VENDOR] = discover_vendor,
174 [SCMI_BASE_DISCOVER_SUB_VENDOR] = discover_sub_vendor,
175 [SCMI_BASE_DISCOVER_IMPLEMENTATION_VERSION] =
176 discover_implementation_version,
177 [SCMI_BASE_DISCOVER_LIST_PROTOCOLS] = discover_list_protocols,
178 };
179
message_id_is_supported(unsigned int message_id)180 static bool message_id_is_supported(unsigned int message_id)
181 {
182 return message_id < ARRAY_SIZE(scmi_base_handler_table) &&
183 scmi_base_handler_table[message_id];
184 }
185
scmi_msg_get_base_handler(struct scmi_msg * msg)186 scmi_msg_handler_t scmi_msg_get_base_handler(struct scmi_msg *msg)
187 {
188 const size_t array_size = ARRAY_SIZE(scmi_base_handler_table);
189 unsigned int message_id = 0;
190
191 if (msg->message_id >= array_size) {
192 DMSG("Base handle not found %u", msg->message_id);
193 return NULL;
194 }
195
196 message_id = confine_array_index(msg->message_id, array_size);
197
198 return scmi_base_handler_table[message_id];
199 }
200