[thirdparty/u-boot.git] / drivers / firmware / scmi / mailbox_agent.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2020 Linaro Limited.
 */

#define LOG_CATEGORY UCLASS_SCMI_AGENT

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <mailbox.h>
#include <scmi_agent.h>
#include <scmi_agent-uclass.h>
#include <dm/device_compat.h>
#include <dm/devres.h>
#include <linux/compat.h>

#include "smt.h"

#define TIMEOUT_US_10MS			10000

/**
 * struct scmi_mbox_channel - Description of an SCMI mailbox transport
 * @smt:	Shared memory buffer
 * @mbox:	Mailbox channel description
 * @timeout_us:	Timeout in microseconds for the mailbox transfer
 */
struct scmi_mbox_channel {
	struct scmi_smt smt;
	struct mbox_chan mbox;
	ulong timeout_us;
};

/**
 * struct scmi_channel - Channel instance referenced in SCMI drivers
 * @ref: Reference to local channel instance
 **/
struct scmi_channel {
	struct scmi_mbox_channel ref;
};

static int scmi_mbox_process_msg(struct udevice *dev,
				 struct scmi_channel *channel,
				 struct scmi_msg *msg)
{
	struct scmi_mbox_channel *chan = &channel->ref;
	int ret;

	ret = scmi_write_msg_to_smt(dev, &chan->smt, msg);
	if (ret)
		return ret;

	/* Give shm addr to mbox in case it is meaningful */
	ret = mbox_send(&chan->mbox, chan->smt.buf);
	if (ret) {
		dev_err(dev, "Message send failed: %d\n", ret);
		goto out;
	}

	/* Receive the response */
	ret = mbox_recv(&chan->mbox, chan->smt.buf, chan->timeout_us);
	if (ret) {
		dev_err(dev, "Response failed: %d, abort\n", ret);
		goto out;
	}

	ret = scmi_read_resp_from_smt(dev, &chan->smt, msg);

out:
	scmi_clear_smt_channel(&chan->smt);

	return ret;
}

static int setup_channel(struct udevice *dev, struct scmi_mbox_channel *chan)
{
	int ret;

	ret = mbox_get_by_index(dev, 0, &chan->mbox);
	if (ret) {
		dev_err(dev, "Failed to find mailbox: %d\n", ret);
		return ret;
	}

	ret = scmi_dt_get_smt_buffer(dev, &chan->smt);
	if (ret) {
		dev_err(dev, "Failed to get shm resources: %d\n", ret);
		return ret;
	}

	chan->timeout_us = TIMEOUT_US_10MS;

	return 0;
}

static int scmi_mbox_get_channel(struct udevice *dev,
				 struct udevice *protocol,
				 struct scmi_channel **channel)
{
	struct scmi_mbox_channel *base_chan = dev_get_plat(dev);
	struct scmi_mbox_channel *chan;
	int ret;

	if (!dev_read_prop(protocol, "shmem", NULL)) {
		/* Uses agent base channel */
		*channel = container_of(base_chan, struct scmi_channel, ref);

		return 0;
	}

	chan = calloc(1, sizeof(*chan));
	if (!chan)
		return -ENOMEM;

	/* Setup a dedicated channel for the protocol */
	ret = setup_channel(protocol, chan);
	if (ret) {
		free(chan);
		return ret;
	}

	*channel = (void *)chan;

	return 0;
}

int scmi_mbox_of_to_plat(struct udevice *dev)
{
	struct scmi_mbox_channel *chan = dev_get_plat(dev);

	return setup_channel(dev, chan);
}

static const struct udevice_id scmi_mbox_ids[] = {
	{ .compatible = "arm,scmi" },
	{ }
};

static const struct scmi_agent_ops scmi_mbox_ops = {
	.of_get_channel = scmi_mbox_get_channel,
	.process_msg = scmi_mbox_process_msg,
};

U_BOOT_DRIVER(scmi_mbox) = {
	.name		= "scmi-over-mailbox",
	.id		= UCLASS_SCMI_AGENT,
	.of_match	= scmi_mbox_ids,
	.plat_auto	= sizeof(struct scmi_mbox_channel),
	.of_to_plat	= scmi_mbox_of_to_plat,
	.ops		= &scmi_mbox_ops,
};
Commit	Line	Data
240720e9 EC	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2020 Linaro Limited.
	4	*/
	5
9f5e4aa6 PD	6	#define LOG_CATEGORY UCLASS_SCMI_AGENT
9f5e4aa6 PD	7
d678a59d	8	#include <common.h>
240720e9 EC	9	#include <dm.h>
	10	#include <errno.h>
	11	#include <mailbox.h>
	12	#include <scmi_agent.h>
	13	#include <scmi_agent-uclass.h>
0689dc53	14	#include <dm/device_compat.h>
240720e9 EC	15	#include <dm/devres.h>
	16	#include <linux/compat.h>
	17
	18	#include "smt.h"
	19
	20	#define TIMEOUT_US_10MS 10000
	21
	22	/**
	23	* struct scmi_mbox_channel - Description of an SCMI mailbox transport
	24	* @smt: Shared memory buffer
	25	* @mbox: Mailbox channel description
	26	* @timeout_us: Timeout in microseconds for the mailbox transfer
	27	*/
	28	struct scmi_mbox_channel {
	29	struct scmi_smt smt;
	30	struct mbox_chan mbox;
	31	ulong timeout_us;
	32	};
	33
b5d32ea4 EC	34	/**
	35	* struct scmi_channel - Channel instance referenced in SCMI drivers
	36	* @ref: Reference to local channel instance
	37	**/
	38	struct scmi_channel {
	39	struct scmi_mbox_channel ref;
	40	};
	41
85dc5828 EC	42	static int scmi_mbox_process_msg(struct udevice *dev,
	43	struct scmi_channel *channel,
	44	struct scmi_msg *msg)
240720e9	45	{
c08decd2	46	struct scmi_mbox_channel *chan = &channel->ref;
240720e9 EC	47	int ret;
	48
	49	ret = scmi_write_msg_to_smt(dev, &chan->smt, msg);
	50	if (ret)
	51	return ret;
	52
	53	/* Give shm addr to mbox in case it is meaningful */
	54	ret = mbox_send(&chan->mbox, chan->smt.buf);
	55	if (ret) {
	56	dev_err(dev, "Message send failed: %d\n", ret);
	57	goto out;
	58	}
	59
	60	/* Receive the response */
	61	ret = mbox_recv(&chan->mbox, chan->smt.buf, chan->timeout_us);
	62	if (ret) {
	63	dev_err(dev, "Response failed: %d, abort\n", ret);
	64	goto out;
	65	}
	66
	67	ret = scmi_read_resp_from_smt(dev, &chan->smt, msg);
	68
	69	out:
	70	scmi_clear_smt_channel(&chan->smt);
	71
	72	return ret;
	73	}
	74
b5d32ea4	75	static int setup_channel(struct udevice dev, struct scmi_mbox_channel chan)
240720e9	76	{
240720e9 EC	77	int ret;
240720e9 EC	78
240720e9 EC	79	ret = mbox_get_by_index(dev, 0, &chan->mbox);
	80	if (ret) {
	81	dev_err(dev, "Failed to find mailbox: %d\n", ret);
7b499390	82	return ret;
240720e9 EC	83	}
	84
	85	ret = scmi_dt_get_smt_buffer(dev, &chan->smt);
b5d32ea4	86	if (ret) {
240720e9	87	dev_err(dev, "Failed to get shm resources: %d\n", ret);
b5d32ea4 EC	88	return ret;
b5d32ea4 EC	89	}
240720e9	90
b5d32ea4 EC	91	chan->timeout_us = TIMEOUT_US_10MS;
	92
	93	return 0;
	94	}
	95
	96	static int scmi_mbox_get_channel(struct udevice *dev,
689204be	97	struct udevice *protocol,
b5d32ea4 EC	98	struct scmi_channel **channel)
b5d32ea4 EC	99	{
eebb967d	100	struct scmi_mbox_channel *base_chan = dev_get_plat(dev);
b5d32ea4 EC	101	struct scmi_mbox_channel *chan;
	102	int ret;
	103
689204be	104	if (!dev_read_prop(protocol, "shmem", NULL)) {
b5d32ea4 EC	105	/* Uses agent base channel */
	106	*channel = container_of(base_chan, struct scmi_channel, ref);
	107
	108	return 0;
	109	}
	110
	111	chan = calloc(1, sizeof(*chan));
	112	if (!chan)
	113	return -ENOMEM;
	114
	115	/* Setup a dedicated channel for the protocol */
689204be	116	ret = setup_channel(protocol, chan);
b5d32ea4 EC	117	if (ret) {
	118	free(chan);
	119	return ret;
	120	}
	121
	122	channel = (void )chan;
	123
	124	return 0;
	125	}
	126
	127	int scmi_mbox_of_to_plat(struct udevice *dev)
	128	{
	129	struct scmi_mbox_channel *chan = dev_get_plat(dev);
	130
	131	return setup_channel(dev, chan);
240720e9 EC	132	}
	133
	134	static const struct udevice_id scmi_mbox_ids[] = {
	135	{ .compatible = "arm,scmi" },
	136	{ }
	137	};
	138
	139	static const struct scmi_agent_ops scmi_mbox_ops = {
b5d32ea4	140	.of_get_channel = scmi_mbox_get_channel,
240720e9 EC	141	.process_msg = scmi_mbox_process_msg,
	142	};
	143
	144	U_BOOT_DRIVER(scmi_mbox) = {
	145	.name = "scmi-over-mailbox",
	146	.id = UCLASS_SCMI_AGENT,
	147	.of_match = scmi_mbox_ids,
88a304f8 EC	148	.plat_auto = sizeof(struct scmi_mbox_channel),
88a304f8 EC	149	.of_to_plat = scmi_mbox_of_to_plat,
240720e9 EC	150	.ops = &scmi_mbox_ops,
240720e9 EC	151	};