1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * System Control and Management Interface (SCMI) Message Mailbox Transport
  4 * driver.
  5 *
  6 * Copyright (C) 2019 ARM Ltd.
  7 */
  8
  9#include <linux/err.h>
 10#include <linux/device.h>
 11#include <linux/mailbox_client.h>
 12#include <linux/of.h>
 13#include <linux/of_address.h>
 14#include <linux/slab.h>
 15
 16#include "common.h"
 17
 18/**
 19 * struct scmi_mailbox - Structure representing a SCMI mailbox transport
 20 *
 21 * @cl: Mailbox Client
 22 * @chan: Transmit/Receive mailbox channel
 23 * @cinfo: SCMI channel info
 24 * @shmem: Transmit/Receive shared memory area
 25 */
 26struct scmi_mailbox {
 27	struct mbox_client cl;
 28	struct mbox_chan *chan;
 29	struct scmi_chan_info *cinfo;
 30	struct scmi_shared_mem __iomem *shmem;
 31};
 32
 33#define client_to_scmi_mailbox(c) container_of(c, struct scmi_mailbox, cl)
 34
 35static void tx_prepare(struct mbox_client *cl, void *m)
 36{
 37	struct scmi_mailbox *smbox = client_to_scmi_mailbox(cl);
 38
 39	shmem_tx_prepare(smbox->shmem, m);
 40}
 41
 42static void rx_callback(struct mbox_client *cl, void *m)
 43{
 44	struct scmi_mailbox *smbox = client_to_scmi_mailbox(cl);
 45
 46	scmi_rx_callback(smbox->cinfo, shmem_read_header(smbox->shmem));
 47}
 48
 49static bool mailbox_chan_available(struct device *dev, int idx)
 50{
 51	return !of_parse_phandle_with_args(dev->of_node, "mboxes",
 52					   "#mbox-cells", idx, NULL);
 53}
 54
 55static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev,
 56			      bool tx)
 57{
 58	const char *desc = tx ? "Tx" : "Rx";
 59	struct device *cdev = cinfo->dev;
 60	struct scmi_mailbox *smbox;
 61	struct device_node *shmem;
 62	int ret, idx = tx ? 0 : 1;
 63	struct mbox_client *cl;
 64	resource_size_t size;
 65	struct resource res;
 66
 67	smbox = devm_kzalloc(dev, sizeof(*smbox), GFP_KERNEL);
 68	if (!smbox)
 69		return -ENOMEM;
 70
 71	shmem = of_parse_phandle(cdev->of_node, "shmem", idx);
 72	ret = of_address_to_resource(shmem, 0, &res);
 73	of_node_put(shmem);
 74	if (ret) {
 75		dev_err(cdev, "failed to get SCMI %s shared memory\n", desc);
 76		return ret;
 77	}
 78
 79	size = resource_size(&res);
 80	smbox->shmem = devm_ioremap(dev, res.start, size);
 81	if (!smbox->shmem) {
 82		dev_err(dev, "failed to ioremap SCMI %s shared memory\n", desc);
 83		return -EADDRNOTAVAIL;
 84	}
 85
 86	cl = &smbox->cl;
 87	cl->dev = cdev;
 88	cl->tx_prepare = tx ? tx_prepare : NULL;
 89	cl->rx_callback = rx_callback;
 90	cl->tx_block = false;
 91	cl->knows_txdone = tx;
 92
 93	smbox->chan = mbox_request_channel(cl, tx ? 0 : 1);
 94	if (IS_ERR(smbox->chan)) {
 95		ret = PTR_ERR(smbox->chan);
 96		if (ret != -EPROBE_DEFER)
 97			dev_err(cdev, "failed to request SCMI %s mailbox\n",
 98				tx ? "Tx" : "Rx");
 99		return ret;
100	}
101
102	cinfo->transport_info = smbox;
103	smbox->cinfo = cinfo;
104
105	return 0;
106}
107
108static int mailbox_chan_free(int id, void *p, void *data)
109{
110	struct scmi_chan_info *cinfo = p;
111	struct scmi_mailbox *smbox = cinfo->transport_info;
112
113	if (!IS_ERR(smbox->chan)) {
114		mbox_free_channel(smbox->chan);
115		cinfo->transport_info = NULL;
116		smbox->chan = NULL;
117		smbox->cinfo = NULL;
118	}
119
120	scmi_free_channel(cinfo, data, id);
121
122	return 0;
123}
124
125static int mailbox_send_message(struct scmi_chan_info *cinfo,
126				struct scmi_xfer *xfer)
127{
128	struct scmi_mailbox *smbox = cinfo->transport_info;
129	int ret;
130
131	ret = mbox_send_message(smbox->chan, xfer);
132
133	/* mbox_send_message returns non-negative value on success, so reset */
134	if (ret > 0)
135		ret = 0;
136
137	return ret;
138}
139
140static void mailbox_mark_txdone(struct scmi_chan_info *cinfo, int ret)
141{
142	struct scmi_mailbox *smbox = cinfo->transport_info;
143
144	/*
145	 * NOTE: we might prefer not to need the mailbox ticker to manage the
146	 * transfer queueing since the protocol layer queues things by itself.
147	 * Unfortunately, we have to kick the mailbox framework after we have
148	 * received our message.
149	 */
150	mbox_client_txdone(smbox->chan, ret);
151}
152
153static void mailbox_fetch_response(struct scmi_chan_info *cinfo,
154				   struct scmi_xfer *xfer)
155{
156	struct scmi_mailbox *smbox = cinfo->transport_info;
157
158	shmem_fetch_response(smbox->shmem, xfer);
159}
160
161static void mailbox_fetch_notification(struct scmi_chan_info *cinfo,
162				       size_t max_len, struct scmi_xfer *xfer)
163{
164	struct scmi_mailbox *smbox = cinfo->transport_info;
165
166	shmem_fetch_notification(smbox->shmem, max_len, xfer);
167}
168
169static void mailbox_clear_channel(struct scmi_chan_info *cinfo)
170{
171	struct scmi_mailbox *smbox = cinfo->transport_info;
172
173	shmem_clear_channel(smbox->shmem);
174}
175
176static bool
177mailbox_poll_done(struct scmi_chan_info *cinfo, struct scmi_xfer *xfer)
178{
179	struct scmi_mailbox *smbox = cinfo->transport_info;
180
181	return shmem_poll_done(smbox->shmem, xfer);
182}
183
184static struct scmi_transport_ops scmi_mailbox_ops = {
185	.chan_available = mailbox_chan_available,
186	.chan_setup = mailbox_chan_setup,
187	.chan_free = mailbox_chan_free,
188	.send_message = mailbox_send_message,
189	.mark_txdone = mailbox_mark_txdone,
190	.fetch_response = mailbox_fetch_response,
191	.fetch_notification = mailbox_fetch_notification,
192	.clear_channel = mailbox_clear_channel,
193	.poll_done = mailbox_poll_done,
194};
195
196const struct scmi_desc scmi_mailbox_desc = {
197	.ops = &scmi_mailbox_ops,
198	.max_rx_timeout_ms = 30, /* We may increase this if required */
199	.max_msg = 20, /* Limited by MBOX_TX_QUEUE_LEN */
200	.max_msg_size = 128,
201};