drivers/remoteproc/remoteproc_virtio.c

   1 /*
   2  * Remote processor messaging transport (OMAP platform-specific bits)
   3  *
   4  * Copyright (C) 2011 Texas Instruments, Inc.
   5  * Copyright (C) 2011 Google, Inc.
   6  *
   7  * Ohad Ben-Cohen <ohad@wizery.com>
   8  * Brian Swetland <swetland@google.com>
   9  *
  10  * This software is licensed under the terms of the GNU General Public
  11  * License version 2, as published by the Free Software Foundation, and
  12  * may be copied, distributed, and modified under those terms.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  */
  19
  20 #include <linux/dma-mapping.h>
  21 #include <linux/export.h>
  22 #include <linux/of_reserved_mem.h>
  23 #include <linux/remoteproc.h>
  24 #include <linux/virtio.h>
  25 #include <linux/virtio_config.h>
  26 #include <linux/virtio_ids.h>
  27 #include <linux/virtio_ring.h>
  28 #include <linux/err.h>
  29 #include <linux/kref.h>
  30 #include <linux/slab.h>
  31
  32 #include "remoteproc_internal.h"
  33
  34 /* kick the remote processor, and let it know which virtqueue to poke at */
  35 static bool rproc_virtio_notify(struct virtqueue *vq)
  36 {
  37         struct rproc_vring *rvring = vq->priv;
  38         struct rproc *rproc = rvring->rvdev->rproc;
  39         int notifyid = rvring->notifyid;
  40
  41         dev_dbg(&rproc->dev, "kicking vq index: %d\n", notifyid);
  42
  43         rproc->ops->kick(rproc, notifyid);
  44         return true;
  45 }
  46
  47 /**
  48  * rproc_vq_interrupt() - tell remoteproc that a virtqueue is interrupted
  49  * @rproc: handle to the remote processor
  50  * @notifyid: index of the signalled virtqueue (unique per this @rproc)
  51  *
  52  * This function should be called by the platform-specific rproc driver,
  53  * when the remote processor signals that a specific virtqueue has pending
  54  * messages available.
  55  *
  56  * Returns IRQ_NONE if no message was found in the @notifyid virtqueue,
  57  * and otherwise returns IRQ_HANDLED.
  58  */
  59 irqreturn_t rproc_vq_interrupt(struct rproc *rproc, int notifyid)
  60 {
  61         struct rproc_vring *rvring;
  62
  63         dev_dbg(&rproc->dev, "vq index %d is interrupted\n", notifyid);
  64
  65         rvring = idr_find(&rproc->notifyids, notifyid);
  66         if (!rvring || !rvring->vq)
  67                 return IRQ_NONE;
  68
  69         return vring_interrupt(0, rvring->vq);
  70 }
  71 EXPORT_SYMBOL(rproc_vq_interrupt);
  72
  73 static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
  74                                     unsigned int id,
  75                                     void (*callback)(struct virtqueue *vq),
  76                                     const char *name, bool ctx)
  77 {
  78         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
  79         struct rproc *rproc = vdev_to_rproc(vdev);
  80         struct device *dev = &rproc->dev;
  81         struct rproc_mem_entry *mem;
  82         struct rproc_vring *rvring;
  83         struct fw_rsc_vdev *rsc;
  84         struct virtqueue *vq;
  85         void *addr;
  86         int len, size;
  87
  88         /* we're temporarily limited to two virtqueues per rvdev */
  89         if (id >= ARRAY_SIZE(rvdev->vring))
  90                 return ERR_PTR(-EINVAL);
  91
  92         if (!name)
  93                 return NULL;
  94
  95         /* Search allocated memory region by name */
  96         mem = rproc_find_carveout_by_name(rproc, "vdev%dvring%d", rvdev->index,
  97                                           id);
  98         if (!mem || !mem->va)
  99                 return ERR_PTR(-ENOMEM);
 100
 101         rvring = &rvdev->vring[id];
 102         addr = mem->va;
 103         len = rvring->len;
 104
 105         /* zero vring */
 106         size = vring_size(len, rvring->align);
 107         memset(addr, 0, size);
 108
 109         dev_dbg(dev, "vring%d: va %pK qsz %d notifyid %d\n",
 110                 id, addr, len, rvring->notifyid);
 111
 112         /*
 113          * Create the new vq, and tell virtio we're not interested in
 114          * the 'weak' smp barriers, since we're talking with a real device.
 115          */
 116         vq = vring_new_virtqueue(id, len, rvring->align, vdev, false, ctx,
 117                                  addr, rproc_virtio_notify, callback, name);
 118         if (!vq) {
 119                 dev_err(dev, "vring_new_virtqueue %s failed\n", name);
 120                 rproc_free_vring(rvring);
 121                 return ERR_PTR(-ENOMEM);
 122         }
 123
 124         rvring->vq = vq;
 125         vq->priv = rvring;
 126
 127         /* Update vring in resource table */
 128         rsc = (void *)rproc->table_ptr + rvdev->rsc_offset;
 129         rsc->vring[id].da = mem->da;
 130
 131         return vq;
 132 }
 133
 134 static void __rproc_virtio_del_vqs(struct virtio_device *vdev)
 135 {
 136         struct virtqueue *vq, *n;
 137         struct rproc_vring *rvring;
 138
 139         list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
 140                 rvring = vq->priv;
 141                 rvring->vq = NULL;
 142                 vring_del_virtqueue(vq);
 143         }
 144 }
 145
 146 static void rproc_virtio_del_vqs(struct virtio_device *vdev)
 147 {
 148         __rproc_virtio_del_vqs(vdev);
 149 }
 150
 151 static int rproc_virtio_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
 152                                  struct virtqueue *vqs[],
 153                                  vq_callback_t *callbacks[],
 154                                  const char * const names[],
 155                                  const bool * ctx,
 156                                  struct irq_affinity *desc)
 157 {
 158         int i, ret, queue_idx = 0;
 159
 160         for (i = 0; i < nvqs; ++i) {
 161                 if (!names[i]) {
 162                         vqs[i] = NULL;
 163                         continue;
 164                 }
 165
 166                 vqs[i] = rp_find_vq(vdev, queue_idx++, callbacks[i], names[i],
 167                                     ctx ? ctx[i] : false);
 168                 if (IS_ERR(vqs[i])) {
 169                         ret = PTR_ERR(vqs[i]);
 170                         goto error;
 171                 }
 172         }
 173
 174         return 0;
 175
 176 error:
 177         __rproc_virtio_del_vqs(vdev);
 178         return ret;
 179 }
 180
 181 static u8 rproc_virtio_get_status(struct virtio_device *vdev)
 182 {
 183         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
 184         struct fw_rsc_vdev *rsc;
 185
 186         rsc = (void *)rvdev->rproc->table_ptr + rvdev->rsc_offset;
 187
 188         return rsc->status;
 189 }
 190
 191 static void rproc_virtio_set_status(struct virtio_device *vdev, u8 status)
 192 {
 193         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
 194         struct fw_rsc_vdev *rsc;
 195
 196         rsc = (void *)rvdev->rproc->table_ptr + rvdev->rsc_offset;
 197
 198         rsc->status = status;
 199         dev_dbg(&vdev->dev, "status: %d\n", status);
 200 }
 201
 202 static void rproc_virtio_reset(struct virtio_device *vdev)
 203 {
 204         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
 205         struct fw_rsc_vdev *rsc;
 206
 207         rsc = (void *)rvdev->rproc->table_ptr + rvdev->rsc_offset;
 208
 209         rsc->status = 0;
 210         dev_dbg(&vdev->dev, "reset !\n");
 211 }
 212
 213 /* provide the vdev features as retrieved from the firmware */
 214 static u64 rproc_virtio_get_features(struct virtio_device *vdev)
 215 {
 216         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
 217         struct fw_rsc_vdev *rsc;
 218
 219         rsc = (void *)rvdev->rproc->table_ptr + rvdev->rsc_offset;
 220
 221         return rsc->dfeatures;
 222 }
 223
 224 static void rproc_transport_features(struct virtio_device *vdev)
 225 {
 226         /*
 227          * Packed ring isn't enabled on remoteproc for now,
 228          * because remoteproc uses vring_new_virtqueue() which
 229          * creates virtio rings on preallocated memory.
 230          */
 231         __virtio_clear_bit(vdev, VIRTIO_F_RING_PACKED);
 232 }
 233
 234 static int rproc_virtio_finalize_features(struct virtio_device *vdev)
 235 {
 236         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
 237         struct fw_rsc_vdev *rsc;
 238
 239         rsc = (void *)rvdev->rproc->table_ptr + rvdev->rsc_offset;
 240
 241         /* Give virtio_ring a chance to accept features */
 242         vring_transport_features(vdev);
 243
 244         /* Give virtio_rproc a chance to accept features. */
 245         rproc_transport_features(vdev);
 246
 247         /* Make sure we don't have any features > 32 bits! */
 248         BUG_ON((u32)vdev->features != vdev->features);
 249
 250         /*
 251          * Remember the finalized features of our vdev, and provide it
 252          * to the remote processor once it is powered on.
 253          */
 254         rsc->gfeatures = vdev->features;
 255
 256         return 0;
 257 }
 258
 259 static void rproc_virtio_get(struct virtio_device *vdev, unsigned int offset,
 260                              void *buf, unsigned int len)
 261 {
 262         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
 263         struct fw_rsc_vdev *rsc;
 264         void *cfg;
 265
 266         rsc = (void *)rvdev->rproc->table_ptr + rvdev->rsc_offset;
 267         cfg = &rsc->vring[rsc->num_of_vrings];
 268
 269         if (offset + len > rsc->config_len || offset + len < len) {
 270                 dev_err(&vdev->dev, "rproc_virtio_get: access out of bounds\n");
 271                 return;
 272         }
 273
 274         memcpy(buf, cfg + offset, len);
 275 }
 276
 277 static void rproc_virtio_set(struct virtio_device *vdev, unsigned int offset,
 278                              const void *buf, unsigned int len)
 279 {
 280         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
 281         struct fw_rsc_vdev *rsc;
 282         void *cfg;
 283
 284         rsc = (void *)rvdev->rproc->table_ptr + rvdev->rsc_offset;
 285         cfg = &rsc->vring[rsc->num_of_vrings];
 286
 287         if (offset + len > rsc->config_len || offset + len < len) {
 288                 dev_err(&vdev->dev, "rproc_virtio_set: access out of bounds\n");
 289                 return;
 290         }
 291
 292         memcpy(cfg + offset, buf, len);
 293 }
 294
 295 static const struct virtio_config_ops rproc_virtio_config_ops = {
 296         .get_features   = rproc_virtio_get_features,
 297         .finalize_features = rproc_virtio_finalize_features,
 298         .find_vqs       = rproc_virtio_find_vqs,
 299         .del_vqs        = rproc_virtio_del_vqs,
 300         .reset          = rproc_virtio_reset,
 301         .set_status     = rproc_virtio_set_status,
 302         .get_status     = rproc_virtio_get_status,
 303         .get            = rproc_virtio_get,
 304         .set            = rproc_virtio_set,
 305 };
 306
 307 /*
 308  * This function is called whenever vdev is released, and is responsible
 309  * to decrement the remote processor's refcount which was taken when vdev was
 310  * added.
 311  *
 312  * Never call this function directly; it will be called by the driver
 313  * core when needed.
 314  */
 315 static void rproc_virtio_dev_release(struct device *dev)
 316 {
 317         struct virtio_device *vdev = dev_to_virtio(dev);
 318         struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
 319         struct rproc *rproc = vdev_to_rproc(vdev);
 320
 321         kfree(vdev);
 322
 323         kref_put(&rvdev->refcount, rproc_vdev_release);
 324
 325         put_device(&rproc->dev);
 326 }
 327
 328 /**
 329  * rproc_add_virtio_dev() - register an rproc-induced virtio device
 330  * @rvdev: the remote vdev
 331  *
 332  * This function registers a virtio device. This vdev's partent is
 333  * the rproc device.
 334  *
 335  * Returns 0 on success or an appropriate error value otherwise.
 336  */
 337 int rproc_add_virtio_dev(struct rproc_vdev *rvdev, int id)
 338 {
 339         struct rproc *rproc = rvdev->rproc;
 340         struct device *dev = &rvdev->dev;
 341         struct virtio_device *vdev;
 342         struct rproc_mem_entry *mem;
 343         int ret;
 344
 345         /* Try to find dedicated vdev buffer carveout */
 346         mem = rproc_find_carveout_by_name(rproc, "vdev%dbuffer", rvdev->index);
 347         if (mem) {
 348                 phys_addr_t pa;
 349
 350                 if (mem->of_resm_idx != -1) {
 351                         struct device_node *np = rproc->dev.parent->of_node;
 352
 353                         /* Associate reserved memory to vdev device */
 354                         ret = of_reserved_mem_device_init_by_idx(dev, np,
 355                                                                  mem->of_resm_idx);
 356                         if (ret) {
 357                                 dev_err(dev, "Can't associate reserved memory\n");
 358                                 goto out;
 359                         }
 360                 } else {
 361                         if (mem->va) {
 362                                 dev_warn(dev, "vdev %d buffer already mapped\n",
 363                                          rvdev->index);
 364                                 pa = rproc_va_to_pa(mem->va);
 365                         } else {
 366                                 /* Use dma address as carveout no memmapped yet */
 367                                 pa = (phys_addr_t)mem->dma;
 368                         }
 369
 370                         /* Associate vdev buffer memory pool to vdev subdev */
 371                         ret = dma_declare_coherent_memory(dev, pa,
 372                                                            mem->da,
 373                                                            mem->len);
 374                         if (ret < 0) {
 375                                 dev_err(dev, "Failed to associate buffer\n");
 376                                 goto out;
 377                         }
 378                 }
 379         }
 380
 381         /* Allocate virtio device */
 382         vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
 383         if (!vdev) {
 384                 ret = -ENOMEM;
 385                 goto out;
 386         }
 387         vdev->id.device = id,
 388         vdev->config = &rproc_virtio_config_ops,
 389         vdev->dev.parent = dev;
 390         vdev->dev.release = rproc_virtio_dev_release;
 391
 392         /*
 393          * We're indirectly making a non-temporary copy of the rproc pointer
 394          * here, because drivers probed with this vdev will indirectly
 395          * access the wrapping rproc.
 396          *
 397          * Therefore we must increment the rproc refcount here, and decrement
 398          * it _only_ when the vdev is released.
 399          */
 400         get_device(&rproc->dev);
 401
 402         /* Reference the vdev and vring allocations */
 403         kref_get(&rvdev->refcount);
 404
 405         ret = register_virtio_device(vdev);
 406         if (ret) {
 407                 put_device(&vdev->dev);
 408                 dev_err(dev, "failed to register vdev: %d\n", ret);
 409                 goto out;
 410         }
 411
 412         dev_info(dev, "registered %s (type %d)\n", dev_name(&vdev->dev), id);
 413
 414 out:
 415         return ret;
 416 }
 417
 418 /**
 419  * rproc_remove_virtio_dev() - remove an rproc-induced virtio device
 420  * @dev: the virtio device
 421  * @data: must be null
 422  *
 423  * This function unregisters an existing virtio device.
 424  */
 425 int rproc_remove_virtio_dev(struct device *dev, void *data)
 426 {
 427         struct virtio_device *vdev = dev_to_virtio(dev);
 428
 429         unregister_virtio_device(vdev);
 430         return 0;
 431 }