drivers/firmware/arm_scmi/mailbox.c

   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  */
  26 struct 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
  35 static 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
  42 static 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
  49 static 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
  55 static int mailbox_chan_validate(struct device *cdev)
  56 {
  57         int num_mb, num_sh, ret = 0;
  58         struct device_node *np = cdev->of_node;
  59
  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));
  66                 return -EINVAL;
  67         }
  68
  69         if (num_sh > 1) {
  70                 struct device_node *np_tx, *np_rx;
  71
  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));
  78                         ret = -EINVAL;
  79                 }
  80
  81                 of_node_put(np_tx);
  82                 of_node_put(np_rx);
  83         }
  84
  85         return ret;
  86 }
  87
  88 static int mailbox_chan_setup(struct scmi_chan_info *cinfo, struct device *dev,
  89                               bool tx)
  90 {
  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;
  97         resource_size_t size;
  98         struct resource res;
  99
 100         ret = mailbox_chan_validate(cdev);
 101         if (ret)
 102                 return ret;
 103
 104         smbox = devm_kzalloc(dev, sizeof(*smbox), GFP_KERNEL);
 105         if (!smbox)
 106                 return -ENOMEM;
 107
 108         shmem = of_parse_phandle(cdev->of_node, "shmem", idx);
 109         ret = of_address_to_resource(shmem, 0, &res);
 110         of_node_put(shmem);
 111         if (ret) {
 112                 dev_err(cdev, "failed to get SCMI %s shared memory\n", desc);
 113                 return ret;
 114         }
 115
 116         size = resource_size(&res);
 117         smbox->shmem = devm_ioremap(dev, res.start, size);
 118         if (!smbox->shmem) {
 119                 dev_err(dev, "failed to ioremap SCMI %s shared memory\n", desc);
 120                 return -EADDRNOTAVAIL;
 121         }
 122
 123         cl = &smbox->cl;
 124         cl->dev = cdev;
 125         cl->tx_prepare = tx ? tx_prepare : NULL;
 126         cl->rx_callback = rx_callback;
 127         cl->tx_block = false;
 128         cl->knows_txdone = tx;
 129
 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",
 135                                 tx ? "Tx" : "Rx");
 136                 return ret;
 137         }
 138
 139         cinfo->transport_info = smbox;
 140         smbox->cinfo = cinfo;
 141
 142         return 0;
 143 }
 144
 145 static int mailbox_chan_free(int id, void *p, void *data)
 146 {
 147         struct scmi_chan_info *cinfo = p;
 148         struct scmi_mailbox *smbox = cinfo->transport_info;
 149
 150         if (smbox && !IS_ERR(smbox->chan)) {
 151                 mbox_free_channel(smbox->chan);
 152                 cinfo->transport_info = NULL;
 153                 smbox->chan = NULL;
 154                 smbox->cinfo = NULL;
 155         }
 156
 157         scmi_free_channel(cinfo, data, id);
 158
 159         return 0;
 160 }
 161
 162 static int mailbox_send_message(struct scmi_chan_info *cinfo,
 163                                 struct scmi_xfer *xfer)
 164 {
 165         struct scmi_mailbox *smbox = cinfo->transport_info;
 166         int ret;
 167
 168         ret = mbox_send_message(smbox->chan, xfer);
 169
 170         /* mbox_send_message returns non-negative value on success, so reset */
 171         if (ret > 0)
 172                 ret = 0;
 173
 174         return ret;
 175 }
 176
 177 static void mailbox_mark_txdone(struct scmi_chan_info *cinfo, int ret)
 178 {
 179         struct scmi_mailbox *smbox = cinfo->transport_info;
 180
 181         /*
 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.
 186          */
 187         mbox_client_txdone(smbox->chan, ret);
 188 }
 189
 190 static void mailbox_fetch_response(struct scmi_chan_info *cinfo,
 191                                    struct scmi_xfer *xfer)
 192 {
 193         struct scmi_mailbox *smbox = cinfo->transport_info;
 194
 195         shmem_fetch_response(smbox->shmem, xfer);
 196 }
 197
 198 static void mailbox_fetch_notification(struct scmi_chan_info *cinfo,
 199                                        size_t max_len, struct scmi_xfer *xfer)
 200 {
 201         struct scmi_mailbox *smbox = cinfo->transport_info;
 202
 203         shmem_fetch_notification(smbox->shmem, max_len, xfer);
 204 }
 205
 206 static void mailbox_clear_channel(struct scmi_chan_info *cinfo)
 207 {
 208         struct scmi_mailbox *smbox = cinfo->transport_info;
 209
 210         shmem_clear_channel(smbox->shmem);
 211 }
 212
 213 static bool
 214 mailbox_poll_done(struct scmi_chan_info *cinfo, struct scmi_xfer *xfer)
 215 {
 216         struct scmi_mailbox *smbox = cinfo->transport_info;
 217
 218         return shmem_poll_done(smbox->shmem, xfer);
 219 }
 220
 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,
 231 };
 232
 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 */
 237         .max_msg_size = 128,
 238 };