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 */
35static 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 */
59irqreturn_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}
71EXPORT_SYMBOL(rproc_vq_interrupt);
72
73static 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
134static 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
146static void rproc_virtio_del_vqs(struct virtio_device *vdev)
147{
148 __rproc_virtio_del_vqs(vdev);
149}
150
151static 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
176error:
177 __rproc_virtio_del_vqs(vdev);
178 return ret;
179}
180
181static 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
191static 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
202static 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 */
214static 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
224static 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
234static 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
259static 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
277static 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
295static 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 */
315static 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 */
337int 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
414out:
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 */
425int 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}
432