drivers/rpmsg/qcom_glink_smem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2016, Linaro Ltd
   4  */
   5
   6 #include <linux/io.h>
   7 #include <linux/module.h>
   8 #include <linux/of.h>
   9 #include <linux/of_address.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/mfd/syscon.h>
  13 #include <linux/slab.h>
  14 #include <linux/rpmsg.h>
  15 #include <linux/idr.h>
  16 #include <linux/circ_buf.h>
  17 #include <linux/soc/qcom/smem.h>
  18 #include <linux/sizes.h>
  19 #include <linux/delay.h>
  20 #include <linux/regmap.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/list.h>
  23
  24 #include <linux/rpmsg/qcom_glink.h>
  25
  26 #include "qcom_glink_native.h"
  27
  28 #define FIFO_FULL_RESERVE 8
  29 #define FIFO_ALIGNMENT 8
  30 #define TX_BLOCKED_CMD_RESERVE 8 /* size of struct read_notif_request */
  31
  32 #define SMEM_GLINK_NATIVE_XPRT_DESCRIPTOR       478
  33 #define SMEM_GLINK_NATIVE_XPRT_FIFO_0           479
  34 #define SMEM_GLINK_NATIVE_XPRT_FIFO_1           480
  35
  36 struct glink_smem_pipe {
  37         struct qcom_glink_pipe native;
  38
  39         __le32 *tail;
  40         __le32 *head;
  41
  42         void *fifo;
  43
  44         int remote_pid;
  45 };
  46
  47 #define to_smem_pipe(p) container_of(p, struct glink_smem_pipe, native)
  48
  49 static size_t glink_smem_rx_avail(struct qcom_glink_pipe *np)
  50 {
  51         struct glink_smem_pipe *pipe = to_smem_pipe(np);
  52         size_t len;
  53         void *fifo;
  54         u32 head;
  55         u32 tail;
  56
  57         if (!pipe->fifo) {
  58                 fifo = qcom_smem_get(pipe->remote_pid,
  59                                      SMEM_GLINK_NATIVE_XPRT_FIFO_1, &len);
  60                 if (IS_ERR(fifo)) {
  61                         pr_err("failed to acquire RX fifo handle: %ld\n",
  62                                PTR_ERR(fifo));
  63                         return 0;
  64                 }
  65
  66                 pipe->fifo = fifo;
  67                 pipe->native.length = len;
  68         }
  69
  70         head = le32_to_cpu(*pipe->head);
  71         tail = le32_to_cpu(*pipe->tail);
  72
  73         if (head < tail)
  74                 return pipe->native.length - tail + head;
  75         else
  76                 return head - tail;
  77 }
  78
  79 static void glink_smem_rx_peak(struct qcom_glink_pipe *np,
  80                                void *data, unsigned int offset, size_t count)
  81 {
  82         struct glink_smem_pipe *pipe = to_smem_pipe(np);
  83         size_t len;
  84         u32 tail;
  85
  86         tail = le32_to_cpu(*pipe->tail);
  87         tail += offset;
  88         if (tail >= pipe->native.length)
  89                 tail -= pipe->native.length;
  90
  91         len = min_t(size_t, count, pipe->native.length - tail);
  92         if (len)
  93                 memcpy_fromio(data, pipe->fifo + tail, len);
  94
  95         if (len != count)
  96                 memcpy_fromio(data + len, pipe->fifo, (count - len));
  97 }
  98
  99 static void glink_smem_rx_advance(struct qcom_glink_pipe *np,
 100                                   size_t count)
 101 {
 102         struct glink_smem_pipe *pipe = to_smem_pipe(np);
 103         u32 tail;
 104
 105         tail = le32_to_cpu(*pipe->tail);
 106
 107         tail += count;
 108         if (tail >= pipe->native.length)
 109                 tail -= pipe->native.length;
 110
 111         *pipe->tail = cpu_to_le32(tail);
 112 }
 113
 114 static size_t glink_smem_tx_avail(struct qcom_glink_pipe *np)
 115 {
 116         struct glink_smem_pipe *pipe = to_smem_pipe(np);
 117         u32 head;
 118         u32 tail;
 119         u32 avail;
 120
 121         head = le32_to_cpu(*pipe->head);
 122         tail = le32_to_cpu(*pipe->tail);
 123
 124         if (tail <= head)
 125                 avail = pipe->native.length - head + tail;
 126         else
 127                 avail = tail - head;
 128
 129         if (avail < (FIFO_FULL_RESERVE + TX_BLOCKED_CMD_RESERVE))
 130                 avail = 0;
 131         else
 132                 avail -= FIFO_FULL_RESERVE + TX_BLOCKED_CMD_RESERVE;
 133
 134         return avail;
 135 }
 136
 137 static unsigned int glink_smem_tx_write_one(struct glink_smem_pipe *pipe,
 138                                             unsigned int head,
 139                                             const void *data, size_t count)
 140 {
 141         size_t len;
 142
 143         len = min_t(size_t, count, pipe->native.length - head);
 144         if (len)
 145                 memcpy(pipe->fifo + head, data, len);
 146
 147         if (len != count)
 148                 memcpy(pipe->fifo, data + len, count - len);
 149
 150         head += count;
 151         if (head >= pipe->native.length)
 152                 head -= pipe->native.length;
 153
 154         return head;
 155 }
 156
 157 static void glink_smem_tx_write(struct qcom_glink_pipe *glink_pipe,
 158                                 const void *hdr, size_t hlen,
 159                                 const void *data, size_t dlen)
 160 {
 161         struct glink_smem_pipe *pipe = to_smem_pipe(glink_pipe);
 162         unsigned int head;
 163
 164         head = le32_to_cpu(*pipe->head);
 165
 166         head = glink_smem_tx_write_one(pipe, head, hdr, hlen);
 167         head = glink_smem_tx_write_one(pipe, head, data, dlen);
 168
 169         /* Ensure head is always aligned to 8 bytes */
 170         head = ALIGN(head, 8);
 171         if (head >= pipe->native.length)
 172                 head -= pipe->native.length;
 173
 174         /* Ensure ordering of fifo and head update */
 175         wmb();
 176
 177         *pipe->head = cpu_to_le32(head);
 178 }
 179
 180 static void qcom_glink_smem_release(struct device *dev)
 181 {
 182         kfree(dev);
 183 }
 184
 185 struct qcom_glink *qcom_glink_smem_register(struct device *parent,
 186                                             struct device_node *node)
 187 {
 188         struct glink_smem_pipe *rx_pipe;
 189         struct glink_smem_pipe *tx_pipe;
 190         struct qcom_glink *glink;
 191         struct device *dev;
 192         u32 remote_pid;
 193         __le32 *descs;
 194         size_t size;
 195         int ret;
 196
 197         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 198         if (!dev)
 199                 return ERR_PTR(-ENOMEM);
 200
 201         dev->parent = parent;
 202         dev->of_node = node;
 203         dev->release = qcom_glink_smem_release;
 204         dev_set_name(dev, "%s:%pOFn", dev_name(parent->parent), node);
 205         ret = device_register(dev);
 206         if (ret) {
 207                 pr_err("failed to register glink edge\n");
 208                 put_device(dev);
 209                 return ERR_PTR(ret);
 210         }
 211
 212         ret = of_property_read_u32(dev->of_node, "qcom,remote-pid",
 213                                    &remote_pid);
 214         if (ret) {
 215                 dev_err(dev, "failed to parse qcom,remote-pid\n");
 216                 goto err_put_dev;
 217         }
 218
 219         rx_pipe = devm_kzalloc(dev, sizeof(*rx_pipe), GFP_KERNEL);
 220         tx_pipe = devm_kzalloc(dev, sizeof(*tx_pipe), GFP_KERNEL);
 221         if (!rx_pipe || !tx_pipe) {
 222                 ret = -ENOMEM;
 223                 goto err_put_dev;
 224         }
 225
 226         ret = qcom_smem_alloc(remote_pid,
 227                               SMEM_GLINK_NATIVE_XPRT_DESCRIPTOR, 32);
 228         if (ret && ret != -EEXIST) {
 229                 dev_err(dev, "failed to allocate glink descriptors\n");
 230                 goto err_put_dev;
 231         }
 232
 233         descs = qcom_smem_get(remote_pid,
 234                               SMEM_GLINK_NATIVE_XPRT_DESCRIPTOR, &size);
 235         if (IS_ERR(descs)) {
 236                 dev_err(dev, "failed to acquire xprt descriptor\n");
 237                 ret = PTR_ERR(descs);
 238                 goto err_put_dev;
 239         }
 240
 241         if (size != 32) {
 242                 dev_err(dev, "glink descriptor of invalid size\n");
 243                 ret = -EINVAL;
 244                 goto err_put_dev;
 245         }
 246
 247         tx_pipe->tail = &descs[0];
 248         tx_pipe->head = &descs[1];
 249         rx_pipe->tail = &descs[2];
 250         rx_pipe->head = &descs[3];
 251
 252         ret = qcom_smem_alloc(remote_pid, SMEM_GLINK_NATIVE_XPRT_FIFO_0,
 253                               SZ_16K);
 254         if (ret && ret != -EEXIST) {
 255                 dev_err(dev, "failed to allocate TX fifo\n");
 256                 goto err_put_dev;
 257         }
 258
 259         tx_pipe->fifo = qcom_smem_get(remote_pid, SMEM_GLINK_NATIVE_XPRT_FIFO_0,
 260                                       &tx_pipe->native.length);
 261         if (IS_ERR(tx_pipe->fifo)) {
 262                 dev_err(dev, "failed to acquire TX fifo\n");
 263                 ret = PTR_ERR(tx_pipe->fifo);
 264                 goto err_put_dev;
 265         }
 266
 267         rx_pipe->native.avail = glink_smem_rx_avail;
 268         rx_pipe->native.peak = glink_smem_rx_peak;
 269         rx_pipe->native.advance = glink_smem_rx_advance;
 270         rx_pipe->remote_pid = remote_pid;
 271
 272         tx_pipe->native.avail = glink_smem_tx_avail;
 273         tx_pipe->native.write = glink_smem_tx_write;
 274         tx_pipe->remote_pid = remote_pid;
 275
 276         *rx_pipe->tail = 0;
 277         *tx_pipe->head = 0;
 278
 279         glink = qcom_glink_native_probe(dev,
 280                                         GLINK_FEATURE_INTENT_REUSE,
 281                                         &rx_pipe->native, &tx_pipe->native,
 282                                         false);
 283         if (IS_ERR(glink)) {
 284                 ret = PTR_ERR(glink);
 285                 goto err_put_dev;
 286         }
 287
 288         return glink;
 289
 290 err_put_dev:
 291         device_unregister(dev);
 292
 293         return ERR_PTR(ret);
 294 }
 295 EXPORT_SYMBOL_GPL(qcom_glink_smem_register);
 296
 297 void qcom_glink_smem_unregister(struct qcom_glink *glink)
 298 {
 299         qcom_glink_native_remove(glink);
 300         qcom_glink_native_unregister(glink);
 301 }
 302 EXPORT_SYMBOL_GPL(qcom_glink_smem_unregister);
 303
 304 MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@linaro.org>");
 305 MODULE_DESCRIPTION("Qualcomm GLINK SMEM driver");
 306 MODULE_LICENSE("GPL v2");