1// SPDX-License-Identifier: GPL-2.0
2/*
3 * System Control and Management Interface (SCMI) Base Protocol
4 *
5 * Copyright (C) 2018-2021 ARM Ltd.
6 */
7
8#define pr_fmt(fmt) "SCMI Notifications BASE - " fmt
9
10#include <linux/module.h>
11#include <linux/scmi_protocol.h>
12
13#include "common.h"
14#include "notify.h"
15
16/* Updated only after ALL the mandatory features for that version are merged */
17#define SCMI_PROTOCOL_SUPPORTED_VERSION		0x20000
18
19#define SCMI_BASE_NUM_SOURCES		1
20#define SCMI_BASE_MAX_CMD_ERR_COUNT	1024
21
22enum scmi_base_protocol_cmd {
23	BASE_DISCOVER_VENDOR = 0x3,
24	BASE_DISCOVER_SUB_VENDOR = 0x4,
25	BASE_DISCOVER_IMPLEMENT_VERSION = 0x5,
26	BASE_DISCOVER_LIST_PROTOCOLS = 0x6,
27	BASE_DISCOVER_AGENT = 0x7,
28	BASE_NOTIFY_ERRORS = 0x8,
29	BASE_SET_DEVICE_PERMISSIONS = 0x9,
30	BASE_SET_PROTOCOL_PERMISSIONS = 0xa,
31	BASE_RESET_AGENT_CONFIGURATION = 0xb,
32};
33
34struct scmi_msg_resp_base_attributes {
35	u8 num_protocols;
36	u8 num_agents;
37	__le16 reserved;
38};
39
40struct scmi_msg_resp_base_discover_agent {
41	__le32 agent_id;
42	u8 name[SCMI_SHORT_NAME_MAX_SIZE];
43};
44
45
46struct scmi_msg_base_error_notify {
47	__le32 event_control;
48#define BASE_TP_NOTIFY_ALL	BIT(0)
49};
50
51struct scmi_base_error_notify_payld {
52	__le32 agent_id;
53	__le32 error_status;
54#define IS_FATAL_ERROR(x)	((x) & BIT(31))
55#define ERROR_CMD_COUNT(x)	FIELD_GET(GENMASK(9, 0), (x))
56	__le64 msg_reports[SCMI_BASE_MAX_CMD_ERR_COUNT];
57};
58
59/**
60 * scmi_base_attributes_get() - gets the implementation details
61 *	that are associated with the base protocol.
62 *
63 * @ph: SCMI protocol handle
64 *
65 * Return: 0 on success, else appropriate SCMI error.
66 */
67static int scmi_base_attributes_get(const struct scmi_protocol_handle *ph)
68{
69	int ret;
70	struct scmi_xfer *t;
71	struct scmi_msg_resp_base_attributes *attr_info;
72	struct scmi_revision_info *rev = ph->get_priv(ph);
73
74	ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES,
75				      0, sizeof(*attr_info), &t);
76	if (ret)
77		return ret;
78
79	ret = ph->xops->do_xfer(ph, t);
80	if (!ret) {
81		attr_info = t->rx.buf;
82		rev->num_protocols = attr_info->num_protocols;
83		rev->num_agents = attr_info->num_agents;
84	}
85
86	ph->xops->xfer_put(ph, t);
87
88	return ret;
89}
90
91/**
92 * scmi_base_vendor_id_get() - gets vendor/subvendor identifier ASCII string.
93 *
94 * @ph: SCMI protocol handle
95 * @sub_vendor: specify true if sub-vendor ID is needed
96 *
97 * Return: 0 on success, else appropriate SCMI error.
98 */
99static int
100scmi_base_vendor_id_get(const struct scmi_protocol_handle *ph, bool sub_vendor)
101{
102	u8 cmd;
103	int ret, size;
104	char *vendor_id;
105	struct scmi_xfer *t;
106	struct scmi_revision_info *rev = ph->get_priv(ph);
107
108
109	if (sub_vendor) {
110		cmd = BASE_DISCOVER_SUB_VENDOR;
111		vendor_id = rev->sub_vendor_id;
112		size = ARRAY_SIZE(rev->sub_vendor_id);
113	} else {
114		cmd = BASE_DISCOVER_VENDOR;
115		vendor_id = rev->vendor_id;
116		size = ARRAY_SIZE(rev->vendor_id);
117	}
118
119	ret = ph->xops->xfer_get_init(ph, cmd, 0, size, &t);
120	if (ret)
121		return ret;
122
123	ret = ph->xops->do_xfer(ph, t);
124	if (!ret)
125		strscpy(vendor_id, t->rx.buf, size);
126
127	ph->xops->xfer_put(ph, t);
128
129	return ret;
130}
131
132/**
133 * scmi_base_implementation_version_get() - gets a vendor-specific
134 *	implementation 32-bit version. The format of the version number is
135 *	vendor-specific
136 *
137 * @ph: SCMI protocol handle
138 *
139 * Return: 0 on success, else appropriate SCMI error.
140 */
141static int
142scmi_base_implementation_version_get(const struct scmi_protocol_handle *ph)
143{
144	int ret;
145	__le32 *impl_ver;
146	struct scmi_xfer *t;
147	struct scmi_revision_info *rev = ph->get_priv(ph);
148
149	ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_IMPLEMENT_VERSION,
150				      0, sizeof(*impl_ver), &t);
151	if (ret)
152		return ret;
153
154	ret = ph->xops->do_xfer(ph, t);
155	if (!ret) {
156		impl_ver = t->rx.buf;
157		rev->impl_ver = le32_to_cpu(*impl_ver);
158	}
159
160	ph->xops->xfer_put(ph, t);
161
162	return ret;
163}
164
165/**
166 * scmi_base_implementation_list_get() - gets the list of protocols it is
167 *	OSPM is allowed to access
168 *
169 * @ph: SCMI protocol handle
170 * @protocols_imp: pointer to hold the list of protocol identifiers
171 *
172 * Return: 0 on success, else appropriate SCMI error.
173 */
174static int
175scmi_base_implementation_list_get(const struct scmi_protocol_handle *ph,
176				  u8 *protocols_imp)
177{
178	u8 *list;
179	int ret, loop;
180	struct scmi_xfer *t;
181	__le32 *num_skip, *num_ret;
182	u32 tot_num_ret = 0, loop_num_ret;
183	struct device *dev = ph->dev;
184	struct scmi_revision_info *rev = ph->get_priv(ph);
185
186	ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_LIST_PROTOCOLS,
187				      sizeof(*num_skip), 0, &t);
188	if (ret)
189		return ret;
190
191	num_skip = t->tx.buf;
192	num_ret = t->rx.buf;
193	list = t->rx.buf + sizeof(*num_ret);
194
195	do {
196		size_t real_list_sz;
197		u32 calc_list_sz;
198
199		/* Set the number of protocols to be skipped/already read */
200		*num_skip = cpu_to_le32(tot_num_ret);
201
202		ret = ph->xops->do_xfer(ph, t);
203		if (ret)
204			break;
205
206		loop_num_ret = le32_to_cpu(*num_ret);
207		if (!loop_num_ret)
208			break;
209
210		if (loop_num_ret > rev->num_protocols - tot_num_ret) {
211			dev_err(dev,
212				"No. Returned protocols > Total protocols.\n");
213			break;
214		}
215
216		if (t->rx.len < (sizeof(u32) * 2)) {
217			dev_err(dev, "Truncated reply - rx.len:%zd\n",
218				t->rx.len);
219			ret = -EPROTO;
220			break;
221		}
222
223		real_list_sz = t->rx.len - sizeof(u32);
224		calc_list_sz = (1 + (loop_num_ret - 1) / sizeof(u32)) *
225				sizeof(u32);
226		if (calc_list_sz != real_list_sz) {
227			dev_warn(dev,
228				 "Malformed reply - real_sz:%zd  calc_sz:%u  (loop_num_ret:%d)\n",
229				 real_list_sz, calc_list_sz, loop_num_ret);
230			/*
231			 * Bail out if the expected list size is bigger than the
232			 * total payload size of the received reply.
233			 */
234			if (calc_list_sz > real_list_sz) {
235				ret = -EPROTO;
236				break;
237			}
238		}
239
240		for (loop = 0; loop < loop_num_ret; loop++)
241			protocols_imp[tot_num_ret + loop] = *(list + loop);
242
243		tot_num_ret += loop_num_ret;
244
245		ph->xops->reset_rx_to_maxsz(ph, t);
246	} while (tot_num_ret < rev->num_protocols);
247
248	ph->xops->xfer_put(ph, t);
249
250	return ret;
251}
252
253/**
254 * scmi_base_discover_agent_get() - discover the name of an agent
255 *
256 * @ph: SCMI protocol handle
257 * @id: Agent identifier
258 * @name: Agent identifier ASCII string
259 *
260 * An agent id of 0 is reserved to identify the platform itself.
261 * Generally operating system is represented as "OSPM"
262 *
263 * Return: 0 on success, else appropriate SCMI error.
264 */
265static int scmi_base_discover_agent_get(const struct scmi_protocol_handle *ph,
266					int id, char *name)
267{
268	int ret;
269	struct scmi_msg_resp_base_discover_agent *agent_info;
270	struct scmi_xfer *t;
271
272	ret = ph->xops->xfer_get_init(ph, BASE_DISCOVER_AGENT,
273				      sizeof(__le32), sizeof(*agent_info), &t);
274	if (ret)
275		return ret;
276
277	put_unaligned_le32(id, t->tx.buf);
278
279	ret = ph->xops->do_xfer(ph, t);
280	if (!ret) {
281		agent_info = t->rx.buf;
282		strscpy(name, agent_info->name, SCMI_SHORT_NAME_MAX_SIZE);
283	}
284
285	ph->xops->xfer_put(ph, t);
286
287	return ret;
288}
289
290static int scmi_base_error_notify(const struct scmi_protocol_handle *ph,
291				  bool enable)
292{
293	int ret;
294	u32 evt_cntl = enable ? BASE_TP_NOTIFY_ALL : 0;
295	struct scmi_xfer *t;
296	struct scmi_msg_base_error_notify *cfg;
297
298	ret = ph->xops->xfer_get_init(ph, BASE_NOTIFY_ERRORS,
299				      sizeof(*cfg), 0, &t);
300	if (ret)
301		return ret;
302
303	cfg = t->tx.buf;
304	cfg->event_control = cpu_to_le32(evt_cntl);
305
306	ret = ph->xops->do_xfer(ph, t);
307
308	ph->xops->xfer_put(ph, t);
309	return ret;
310}
311
312static int scmi_base_set_notify_enabled(const struct scmi_protocol_handle *ph,
313					u8 evt_id, u32 src_id, bool enable)
314{
315	int ret;
316
317	ret = scmi_base_error_notify(ph, enable);
318	if (ret)
319		pr_debug("FAIL_ENABLED - evt[%X] ret:%d\n", evt_id, ret);
320
321	return ret;
322}
323
324static void *scmi_base_fill_custom_report(const struct scmi_protocol_handle *ph,
325					  u8 evt_id, ktime_t timestamp,
326					  const void *payld, size_t payld_sz,
327					  void *report, u32 *src_id)
328{
329	int i;
330	const struct scmi_base_error_notify_payld *p = payld;
331	struct scmi_base_error_report *r = report;
332
333	/*
334	 * BaseError notification payload is variable in size but
335	 * up to a maximum length determined by the struct ponted by p.
336	 * Instead payld_sz is the effective length of this notification
337	 * payload so cannot be greater of the maximum allowed size as
338	 * pointed by p.
339	 */
340	if (evt_id != SCMI_EVENT_BASE_ERROR_EVENT || sizeof(*p) < payld_sz)
341		return NULL;
342
343	r->timestamp = timestamp;
344	r->agent_id = le32_to_cpu(p->agent_id);
345	r->fatal = IS_FATAL_ERROR(le32_to_cpu(p->error_status));
346	r->cmd_count = ERROR_CMD_COUNT(le32_to_cpu(p->error_status));
347	for (i = 0; i < r->cmd_count; i++)
348		r->reports[i] = le64_to_cpu(p->msg_reports[i]);
349	*src_id = 0;
350
351	return r;
352}
353
354static const struct scmi_event base_events[] = {
355	{
356		.id = SCMI_EVENT_BASE_ERROR_EVENT,
357		.max_payld_sz = sizeof(struct scmi_base_error_notify_payld),
358		.max_report_sz = sizeof(struct scmi_base_error_report) +
359				  SCMI_BASE_MAX_CMD_ERR_COUNT * sizeof(u64),
360	},
361};
362
363static const struct scmi_event_ops base_event_ops = {
364	.set_notify_enabled = scmi_base_set_notify_enabled,
365	.fill_custom_report = scmi_base_fill_custom_report,
366};
367
368static const struct scmi_protocol_events base_protocol_events = {
369	.queue_sz = 4 * SCMI_PROTO_QUEUE_SZ,
370	.ops = &base_event_ops,
371	.evts = base_events,
372	.num_events = ARRAY_SIZE(base_events),
373	.num_sources = SCMI_BASE_NUM_SOURCES,
374};
375
376static int scmi_base_protocol_init(const struct scmi_protocol_handle *ph)
377{
378	int id, ret;
379	u8 *prot_imp;
380	u32 version;
381	char name[SCMI_SHORT_NAME_MAX_SIZE];
382	struct device *dev = ph->dev;
383	struct scmi_revision_info *rev = scmi_revision_area_get(ph);
384
385	ret = ph->xops->version_get(ph, &version);
386	if (ret)
387		return ret;
388
389	rev->major_ver = PROTOCOL_REV_MAJOR(version),
390	rev->minor_ver = PROTOCOL_REV_MINOR(version);
391	ph->set_priv(ph, rev, version);
392
393	ret = scmi_base_attributes_get(ph);
394	if (ret)
395		return ret;
396
397	prot_imp = devm_kcalloc(dev, rev->num_protocols, sizeof(u8),
398				GFP_KERNEL);
399	if (!prot_imp)
400		return -ENOMEM;
401
402	scmi_base_vendor_id_get(ph, false);
403	scmi_base_vendor_id_get(ph, true);
404	scmi_base_implementation_version_get(ph);
405	scmi_base_implementation_list_get(ph, prot_imp);
406
407	scmi_setup_protocol_implemented(ph, prot_imp);
408
409	dev_info(dev, "SCMI Protocol v%d.%d '%s:%s' Firmware version 0x%x\n",
410		 rev->major_ver, rev->minor_ver, rev->vendor_id,
411		 rev->sub_vendor_id, rev->impl_ver);
412	dev_dbg(dev, "Found %d protocol(s) %d agent(s)\n", rev->num_protocols,
413		rev->num_agents);
414
415	for (id = 0; id < rev->num_agents; id++) {
416		scmi_base_discover_agent_get(ph, id, name);
417		dev_dbg(dev, "Agent %d: %s\n", id, name);
418	}
419
420	return 0;
421}
422
423static const struct scmi_protocol scmi_base = {
424	.id = SCMI_PROTOCOL_BASE,
425	.owner = NULL,
426	.instance_init = &scmi_base_protocol_init,
427	.ops = NULL,
428	.events = &base_protocol_events,
429	.supported_version = SCMI_PROTOCOL_SUPPORTED_VERSION,
430};
431
432DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(base, scmi_base)
433