linux-imx

/*

 * Remote processor messaging transport (OMAP platform-specific bits)

 *

 * Copyright (C) 2011 Texas Instruments, Inc.

 * Copyright (C) 2011 Google, Inc.

 *

 * Ohad Ben-Cohen <ohad@wizery.com>

 * Brian Swetland <swetland@google.com>

 *

 * This software is licensed under the terms of the GNU General Public

 * License version 2, as published by the Free Software Foundation, and

 * may be copied, distributed, and modified under those terms.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

​

#include <linux/dma-mapping.h>

#include <linux/export.h>

#include <linux/of_reserved_mem.h>

#include <linux/remoteproc.h>

#include <linux/virtio.h>

#include <linux/virtio_config.h>

#include <linux/virtio_ids.h>

#include <linux/virtio_ring.h>

#include <linux/err.h>

#include <linux/kref.h>

#include <linux/slab.h>

​

#include "remoteproc_internal.h"

​

/* kick the remote processor, and let it know which virtqueue to poke at */

static bool rproc_virtio_notify(struct virtqueue *vq)

{

    struct rproc_vring *rvring = vq->priv;

    struct rproc *rproc = rvring->rvdev->rproc;

    int notifyid = rvring->notifyid;

​

    dev_dbg(&rproc->dev, "kicking vq index: %d\n", notifyid);

​

    rproc->ops->kick(rproc, notifyid);

    return true;

}

​

/**

 * rproc_vq_interrupt() - tell remoteproc that a virtqueue is interrupted

 * @rproc: handle to the remote processor

 * @notifyid: index of the signalled virtqueue (unique per this @rproc)

 *

 * This function should be called by the platform-specific rproc driver,

 * when the remote processor signals that a specific virtqueue has pending

 * messages available.

 *

 * Returns IRQ_NONE if no message was found in the @notifyid virtqueue,

 * and otherwise returns IRQ_HANDLED.

 */

irqreturn_t rproc_vq_interrupt(struct rproc *rproc, int notifyid)

{

    struct rproc_vring *rvring;

​

    dev_dbg(&rproc->dev, "vq index %d is interrupted\n", notifyid);

​

    rvring = idr_find(&rproc->notifyids, notifyid);

    if (!rvring || !rvring->vq)

        return IRQ_NONE;

​

    return vring_interrupt(0, rvring->vq);

}

EXPORT_SYMBOL(rproc_vq_interrupt);

​

static struct virtqueue *rp_find_vq(struct virtio_device *vdev,

                    unsigned int id,

                    void (*callback)(struct virtqueue *vq),

                    const char *name, bool ctx)

{

    struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);

    struct rproc *rproc = vdev_to_rproc(vdev);

    struct device *dev = &rproc->dev;

    struct rproc_mem_entry *mem;

    struct rproc_vring *rvring;

    struct fw_rsc_vdev *rsc;

    struct virtqueue *vq;

    void *addr;

    int len, size;

​

    /* we're temporarily limited to two virtqueues per rvdev */

    if (id >= ARRAY_SIZE(rvdev->vring))

        return ERR_PTR(-EINVAL);

​

    if (!name)