1 // SPDX-License-Identifier: GPL-2.0
3 * System Control and Management Interface (SCMI) Message Mailbox Transport
6 * Copyright (C) 2019 ARM Ltd.
10 #include <linux/device.h>
11 #include <linux/mailbox_client.h>
13 #include <linux/of_address.h>
14 #include <linux/slab.h>
19 * struct scmi_mailbox - Structure representing a SCMI mailbox transport
22 * @chan: Transmit/Receive mailbox channel
23 * @cinfo: SCMI channel info
24 * @shmem: Transmit/Receive shared memory area
27 struct mbox_client cl;
28 struct mbox_chan *chan;
29 struct scmi_chan_info *cinfo;
30 struct scmi_shared_mem __iomem *shmem;
33 #define client_to_scmi_mailbox(c) container_of(c, struct scmi_mailbox, cl)
35 static void tx_prepare(struct mbox_client *cl, void *m)
37 struct scmi_mailbox *smbox = client_to_scmi_mailbox(cl);
39 shmem_tx_prepare(smbox->shmem, m);
42 static void rx_callback(struct mbox_client *cl, void *m)
44 struct scmi_mailbox *smbox = client_to_scmi_mailbox(cl);
46 scmi_rx_callback(smbox->cinfo, shmem_read_header(smbox->shmem));
49 static bool mailbox_chan_available(struct device *dev, int idx)
51 return !of_parse_phandle_with_args(dev->of_node, "mboxes",
52 "#mbox-cells", idx, NULL);
55 static int mailbox_chan_validate(struct device *cdev)
57 int num_mb, num_sh, ret = 0;
58 struct device_node *np = cdev->of_node;
60 num_mb = of_count_phandle_with_args(np, "mboxes", "#mbox-cells");
61 num_sh = of_count_phandle_with_args(np, "shmem", NULL);
62 /* Bail out if mboxes and shmem descriptors are inconsistent */
63 if (num_mb <= 0 || num_sh > 2 || num_mb != num_sh) {
64 dev_warn(cdev, "Invalid channel descriptor for '%s'\n",
65 of_node_full_name(np));
70 struct device_node *np_tx, *np_rx;
72 np_tx = of_parse_phandle(np, "shmem", 0);
73 np_rx = of_parse_phandle(np, "shmem", 1);
74 /* SCMI Tx and Rx shared mem areas have to be distinct */
75 if (!np_tx || !np_rx || np_tx == np_rx) {
76 dev_warn(cdev, "Invalid shmem descriptor for '%s'\n",
77 of_node_full_name(np));
88 static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev,
91 const char *desc = tx ? "Tx" : "Rx";
92 struct device *cdev = cinfo->dev;
93 struct scmi_mailbox *smbox;
94 struct device_node *shmem;
95 int ret, idx = tx ? 0 : 1;
96 struct mbox_client *cl;
100 ret = mailbox_chan_validate(cdev);
104 smbox = devm_kzalloc(dev, sizeof(*smbox), GFP_KERNEL);
108 shmem = of_parse_phandle(cdev->of_node, "shmem", idx);
109 ret = of_address_to_resource(shmem, 0, &res);
112 dev_err(cdev, "failed to get SCMI %s shared memory\n", desc);
116 size = resource_size(&res);
117 smbox->shmem = devm_ioremap(dev, res.start, size);
119 dev_err(dev, "failed to ioremap SCMI %s shared memory\n", desc);
120 return -EADDRNOTAVAIL;
125 cl->tx_prepare = tx ? tx_prepare : NULL;
126 cl->rx_callback = rx_callback;
127 cl->tx_block = false;
128 cl->knows_txdone = tx;
130 smbox->chan = mbox_request_channel(cl, tx ? 0 : 1);
131 if (IS_ERR(smbox->chan)) {
132 ret = PTR_ERR(smbox->chan);
133 if (ret != -EPROBE_DEFER)
134 dev_err(cdev, "failed to request SCMI %s mailbox\n",
139 cinfo->transport_info = smbox;
140 smbox->cinfo = cinfo;
145 static int mailbox_chan_free(int id, void *p, void *data)
147 struct scmi_chan_info *cinfo = p;
148 struct scmi_mailbox *smbox = cinfo->transport_info;
150 if (smbox && !IS_ERR(smbox->chan)) {
151 mbox_free_channel(smbox->chan);
152 cinfo->transport_info = NULL;
157 scmi_free_channel(cinfo, data, id);
162 static int mailbox_send_message(struct scmi_chan_info *cinfo,
163 struct scmi_xfer *xfer)
165 struct scmi_mailbox *smbox = cinfo->transport_info;
168 ret = mbox_send_message(smbox->chan, xfer);
170 /* mbox_send_message returns non-negative value on success, so reset */
177 static void mailbox_mark_txdone(struct scmi_chan_info *cinfo, int ret)
179 struct scmi_mailbox *smbox = cinfo->transport_info;
182 * NOTE: we might prefer not to need the mailbox ticker to manage the
183 * transfer queueing since the protocol layer queues things by itself.
184 * Unfortunately, we have to kick the mailbox framework after we have
185 * received our message.
187 mbox_client_txdone(smbox->chan, ret);
190 static void mailbox_fetch_response(struct scmi_chan_info *cinfo,
191 struct scmi_xfer *xfer)
193 struct scmi_mailbox *smbox = cinfo->transport_info;
195 shmem_fetch_response(smbox->shmem, xfer);
198 static void mailbox_fetch_notification(struct scmi_chan_info *cinfo,
199 size_t max_len, struct scmi_xfer *xfer)
201 struct scmi_mailbox *smbox = cinfo->transport_info;
203 shmem_fetch_notification(smbox->shmem, max_len, xfer);
206 static void mailbox_clear_channel(struct scmi_chan_info *cinfo)
208 struct scmi_mailbox *smbox = cinfo->transport_info;
210 shmem_clear_channel(smbox->shmem);
214 mailbox_poll_done(struct scmi_chan_info *cinfo, struct scmi_xfer *xfer)
216 struct scmi_mailbox *smbox = cinfo->transport_info;
218 return shmem_poll_done(smbox->shmem, xfer);
221 static const struct scmi_transport_ops scmi_mailbox_ops = {
222 .chan_available = mailbox_chan_available,
223 .chan_setup = mailbox_chan_setup,
224 .chan_free = mailbox_chan_free,
225 .send_message = mailbox_send_message,
226 .mark_txdone = mailbox_mark_txdone,
227 .fetch_response = mailbox_fetch_response,
228 .fetch_notification = mailbox_fetch_notification,
229 .clear_channel = mailbox_clear_channel,
230 .poll_done = mailbox_poll_done,
233 const struct scmi_desc scmi_mailbox_desc = {
234 .ops = &scmi_mailbox_ops,
235 .max_rx_timeout_ms = 30, /* We may increase this if required */
236 .max_msg = 20, /* Limited by MBOX_TX_QUEUE_LEN */