[mirror_ubuntu-jammy-kernel.git] / drivers / firmware / arm_scmi / base.c

// SPDX-License-Identifier: GPL-2.0
/*
 * System Control and Management Interface (SCMI) Base Protocol
 *
 * Copyright (C) 2018 ARM Ltd.
 */

#define pr_fmt(fmt) "SCMI Notifications BASE - " fmt

#include <linux/scmi_protocol.h>

#include "common.h"
#include "notify.h"

#define SCMI_BASE_NUM_SOURCES		1
#define SCMI_BASE_MAX_CMD_ERR_COUNT	1024

enum scmi_base_protocol_cmd {
	BASE_DISCOVER_VENDOR = 0x3,
	BASE_DISCOVER_SUB_VENDOR = 0x4,
	BASE_DISCOVER_IMPLEMENT_VERSION = 0x5,
	BASE_DISCOVER_LIST_PROTOCOLS = 0x6,
	BASE_DISCOVER_AGENT = 0x7,
	BASE_NOTIFY_ERRORS = 0x8,
	BASE_SET_DEVICE_PERMISSIONS = 0x9,
	BASE_SET_PROTOCOL_PERMISSIONS = 0xa,
	BASE_RESET_AGENT_CONFIGURATION = 0xb,
};

struct scmi_msg_resp_base_attributes {
	u8 num_protocols;
	u8 num_agents;
	__le16 reserved;
};

struct scmi_msg_base_error_notify {
	__le32 event_control;
#define BASE_TP_NOTIFY_ALL	BIT(0)
};

struct scmi_base_error_notify_payld {
	__le32 agent_id;
	__le32 error_status;
#define IS_FATAL_ERROR(x)	((x) & BIT(31))
#define ERROR_CMD_COUNT(x)	FIELD_GET(GENMASK(9, 0), (x))
	__le64 msg_reports[SCMI_BASE_MAX_CMD_ERR_COUNT];
};

/**
 * scmi_base_attributes_get() - gets the implementation details
 *	that are associated with the base protocol.
 *
 * @handle: SCMI entity handle
 *
 * Return: 0 on success, else appropriate SCMI error.
 */
static int scmi_base_attributes_get(const struct scmi_handle *handle)
{
	int ret;
	struct scmi_xfer *t;
	struct scmi_msg_resp_base_attributes *attr_info;
	struct scmi_revision_info *rev = handle->version;

	ret = scmi_xfer_get_init(handle, PROTOCOL_ATTRIBUTES,
				 SCMI_PROTOCOL_BASE, 0, sizeof(*attr_info), &t);
	if (ret)
		return ret;

	ret = scmi_do_xfer(handle, t);
	if (!ret) {
		attr_info = t->rx.buf;
		rev->num_protocols = attr_info->num_protocols;
		rev->num_agents = attr_info->num_agents;
	}

	scmi_xfer_put(handle, t);

	return ret;
}

/**
 * scmi_base_vendor_id_get() - gets vendor/subvendor identifier ASCII string.
 *
 * @handle: SCMI entity handle
 * @sub_vendor: specify true if sub-vendor ID is needed
 *
 * Return: 0 on success, else appropriate SCMI error.
 */
static int
scmi_base_vendor_id_get(const struct scmi_handle *handle, bool sub_vendor)
{
	u8 cmd;
	int ret, size;
	char *vendor_id;
	struct scmi_xfer *t;
	struct scmi_revision_info *rev = handle->version;

	if (sub_vendor) {
		cmd = BASE_DISCOVER_SUB_VENDOR;
		vendor_id = rev->sub_vendor_id;
		size = ARRAY_SIZE(rev->sub_vendor_id);
	} else {
		cmd = BASE_DISCOVER_VENDOR;
		vendor_id = rev->vendor_id;
		size = ARRAY_SIZE(rev->vendor_id);
	}

	ret = scmi_xfer_get_init(handle, cmd, SCMI_PROTOCOL_BASE, 0, size, &t);
	if (ret)
		return ret;

	ret = scmi_do_xfer(handle, t);
	if (!ret)
		memcpy(vendor_id, t->rx.buf, size);

	scmi_xfer_put(handle, t);

	return ret;
}

/**
 * scmi_base_implementation_version_get() - gets a vendor-specific
 *	implementation 32-bit version. The format of the version number is
 *	vendor-specific
 *
 * @handle: SCMI entity handle
 *
 * Return: 0 on success, else appropriate SCMI error.
 */
static int
scmi_base_implementation_version_get(const struct scmi_handle *handle)
{
	int ret;
	__le32 *impl_ver;
	struct scmi_xfer *t;
	struct scmi_revision_info *rev = handle->version;

	ret = scmi_xfer_get_init(handle, BASE_DISCOVER_IMPLEMENT_VERSION,
				 SCMI_PROTOCOL_BASE, 0, sizeof(*impl_ver), &t);
	if (ret)
		return ret;

	ret = scmi_do_xfer(handle, t);
	if (!ret) {
		impl_ver = t->rx.buf;
		rev->impl_ver = le32_to_cpu(*impl_ver);
	}

	scmi_xfer_put(handle, t);

	return ret;
}

/**
 * scmi_base_implementation_list_get() - gets the list of protocols it is
 *	OSPM is allowed to access
 *
 * @handle: SCMI entity handle
 * @protocols_imp: pointer to hold the list of protocol identifiers
 *
 * Return: 0 on success, else appropriate SCMI error.
 */
static int scmi_base_implementation_list_get(const struct scmi_handle *handle,
					     u8 *protocols_imp)
{
	u8 *list;
	int ret, loop;
	struct scmi_xfer *t;
	__le32 *num_skip, *num_ret;
	u32 tot_num_ret = 0, loop_num_ret;
	struct device *dev = handle->dev;

	ret = scmi_xfer_get_init(handle, BASE_DISCOVER_LIST_PROTOCOLS,
				 SCMI_PROTOCOL_BASE, sizeof(*num_skip), 0, &t);
	if (ret)
		return ret;

	num_skip = t->tx.buf;
	num_ret = t->rx.buf;
	list = t->rx.buf + sizeof(*num_ret);

	do {
		/* Set the number of protocols to be skipped/already read */
		*num_skip = cpu_to_le32(tot_num_ret);

		ret = scmi_do_xfer(handle, t);
		if (ret)
			break;

		loop_num_ret = le32_to_cpu(*num_ret);
		if (tot_num_ret + loop_num_ret > MAX_PROTOCOLS_IMP) {
			dev_err(dev, "No. of Protocol > MAX_PROTOCOLS_IMP");
			break;
		}

		for (loop = 0; loop < loop_num_ret; loop++)
			protocols_imp[tot_num_ret + loop] = *(list + loop);

		tot_num_ret += loop_num_ret;
	} while (loop_num_ret);

	scmi_xfer_put(handle, t);

	return ret;
}

/**
 * scmi_base_discover_agent_get() - discover the name of an agent
 *
 * @handle: SCMI entity handle
 * @id: Agent identifier
 * @name: Agent identifier ASCII string
 *
 * An agent id of 0 is reserved to identify the platform itself.
 * Generally operating system is represented as "OSPM"
 *
 * Return: 0 on success, else appropriate SCMI error.
 */
static int scmi_base_discover_agent_get(const struct scmi_handle *handle,
					int id, char *name)
{
	int ret;
	struct scmi_xfer *t;

	ret = scmi_xfer_get_init(handle, BASE_DISCOVER_AGENT,
				 SCMI_PROTOCOL_BASE, sizeof(__le32),
				 SCMI_MAX_STR_SIZE, &t);
	if (ret)
		return ret;

	put_unaligned_le32(id, t->tx.buf);

	ret = scmi_do_xfer(handle, t);
	if (!ret)
		strlcpy(name, t->rx.buf, SCMI_MAX_STR_SIZE);

	scmi_xfer_put(handle, t);

	return ret;
}

static int scmi_base_error_notify(const struct scmi_handle *handle, bool enable)
{
	int ret;
	u32 evt_cntl = enable ? BASE_TP_NOTIFY_ALL : 0;
	struct scmi_xfer *t;
	struct scmi_msg_base_error_notify *cfg;

	ret = scmi_xfer_get_init(handle, BASE_NOTIFY_ERRORS,
				 SCMI_PROTOCOL_BASE, sizeof(*cfg), 0, &t);
	if (ret)
		return ret;

	cfg = t->tx.buf;
	cfg->event_control = cpu_to_le32(evt_cntl);

	ret = scmi_do_xfer(handle, t);

	scmi_xfer_put(handle, t);
	return ret;
}

static int scmi_base_set_notify_enabled(const struct scmi_handle *handle,
					u8 evt_id, u32 src_id, bool enable)
{
	int ret;

	ret = scmi_base_error_notify(handle, enable);
	if (ret)
		pr_debug("FAIL_ENABLED - evt[%X] ret:%d\n", evt_id, ret);

	return ret;
}

static void *scmi_base_fill_custom_report(const struct scmi_handle *handle,
					  u8 evt_id, ktime_t timestamp,
					  const void *payld, size_t payld_sz,
					  void *report, u32 *src_id)
{
	int i;
	const struct scmi_base_error_notify_payld *p = payld;
	struct scmi_base_error_report *r = report;

	/*
	 * BaseError notification payload is variable in size but
	 * up to a maximum length determined by the struct ponted by p.
	 * Instead payld_sz is the effective length of this notification
	 * payload so cannot be greater of the maximum allowed size as
	 * pointed by p.
	 */
	if (evt_id != SCMI_EVENT_BASE_ERROR_EVENT || sizeof(*p) < payld_sz)
		return NULL;

	r->timestamp = timestamp;
	r->agent_id = le32_to_cpu(p->agent_id);
	r->fatal = IS_FATAL_ERROR(le32_to_cpu(p->error_status));
	r->cmd_count = ERROR_CMD_COUNT(le32_to_cpu(p->error_status));
	for (i = 0; i < r->cmd_count; i++)
		r->reports[i] = le64_to_cpu(p->msg_reports[i]);
	*src_id = 0;

	return r;
}

static const struct scmi_event base_events[] = {
	{
		.id = SCMI_EVENT_BASE_ERROR_EVENT,
		.max_payld_sz = sizeof(struct scmi_base_error_notify_payld),
		.max_report_sz = sizeof(struct scmi_base_error_report) +
				  SCMI_BASE_MAX_CMD_ERR_COUNT * sizeof(u64),
	},
};

static const struct scmi_event_ops base_event_ops = {
	.set_notify_enabled = scmi_base_set_notify_enabled,
	.fill_custom_report = scmi_base_fill_custom_report,
};

int scmi_base_protocol_init(struct scmi_handle *h)
{
	int id, ret;
	u8 *prot_imp;
	u32 version;
	char name[SCMI_MAX_STR_SIZE];
	const struct scmi_handle *handle = h;
	struct device *dev = handle->dev;
	struct scmi_revision_info *rev = handle->version;

	ret = scmi_version_get(handle, SCMI_PROTOCOL_BASE, &version);
	if (ret)
		return ret;

	prot_imp = devm_kcalloc(dev, MAX_PROTOCOLS_IMP, sizeof(u8), GFP_KERNEL);
	if (!prot_imp)
		return -ENOMEM;

	rev->major_ver = PROTOCOL_REV_MAJOR(version),
	rev->minor_ver = PROTOCOL_REV_MINOR(version);

	scmi_base_attributes_get(handle);
	scmi_base_vendor_id_get(handle, false);
	scmi_base_vendor_id_get(handle, true);
	scmi_base_implementation_version_get(handle);
	scmi_base_implementation_list_get(handle, prot_imp);
	scmi_setup_protocol_implemented(handle, prot_imp);

	dev_info(dev, "SCMI Protocol v%d.%d '%s:%s' Firmware version 0x%x\n",
		 rev->major_ver, rev->minor_ver, rev->vendor_id,
		 rev->sub_vendor_id, rev->impl_ver);
	dev_dbg(dev, "Found %d protocol(s) %d agent(s)\n", rev->num_protocols,
		rev->num_agents);

	scmi_register_protocol_events(handle, SCMI_PROTOCOL_BASE,
				      (4 * SCMI_PROTO_QUEUE_SZ),
				      &base_event_ops, base_events,
				      ARRAY_SIZE(base_events),
				      SCMI_BASE_NUM_SOURCES);

	for (id = 0; id < rev->num_agents; id++) {
		scmi_base_discover_agent_get(handle, id, name);
		dev_dbg(dev, "Agent %d: %s\n", id, name);
	}

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