rpmsg_virtio.h

Go to the documentation of this file.

/*
 * rpmsg based on virtio
 *
 * Copyright (C) 2018 Linaro, Inc.
 *
 * All rights reserved.
 * Copyright (c) 2016 Freescale Semiconductor, Inc. All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _RPMSG_VIRTIO_H_
#define _RPMSG_VIRTIO_H_
 
#include <metal/io.h>
#include <metal/mutex.h>
#include <metal/cache.h>
#include <openamp/rpmsg.h>
#include <openamp/virtio.h>
 
#if defined __cplusplus
extern "C" {
#endif
 
/* Configurable parameters */
#ifndef RPMSG_BUFFER_SIZE
#define RPMSG_BUFFER_SIZE       (512)
#endif
 
/* The feature bitmap for virtio rpmsg */
#define VIRTIO_RPMSG_F_NS       0 /* RP supports name service notifications */
 
#if defined(VIRTIO_USE_DCACHE)
#define BUFFER_FLUSH(x, s)              metal_cache_flush(x, s)
#define BUFFER_INVALIDATE(x, s)         metal_cache_invalidate(x, s)
#else
#define BUFFER_FLUSH(x, s)              do { } while (0)
#define BUFFER_INVALIDATE(x, s)         do { } while (0)
#endif /* VIRTIO_USE_DCACHE */
 
/* Callback handler for rpmsg virtio service */
typedef int (*rpmsg_virtio_notify_wait_cb)(struct rpmsg_device *rdev, uint32_t id);
 
struct rpmsg_virtio_shm_pool {
        void *base;
 
        size_t avail;
 
        size_t size;
};
 
struct rpmsg_virtio_config {
        uint32_t h2r_buf_size;
 
        uint32_t r2h_buf_size;
 
        bool split_shpool;
};
 
struct rpmsg_virtio_device {
        struct rpmsg_device rdev;
 
        struct rpmsg_virtio_config config;
 
        struct virtio_device *vdev;
 
        struct virtqueue *rvq;
 
        struct virtqueue *svq;
 
        struct metal_io_region *shbuf_io;
 
        struct rpmsg_virtio_shm_pool *shpool;
 
        struct metal_list reclaimer;
 
        rpmsg_virtio_notify_wait_cb notify_wait_cb;
};
 
#define RPMSG_REMOTE    VIRTIO_DEV_DEVICE
#define RPMSG_HOST      VIRTIO_DEV_DRIVER
 
static inline void rpmsg_virtio_set_wait_cb(struct rpmsg_virtio_device *rvdev,
                                            rpmsg_virtio_notify_wait_cb notify_wait_cb)
{
        rvdev->notify_wait_cb = notify_wait_cb;
}
 
static inline unsigned int
rpmsg_virtio_get_role(struct rpmsg_virtio_device *rvdev)
{
        return rvdev->vdev->role;
}
 
__deprecated
static inline void rpmsg_virtio_set_status(struct rpmsg_virtio_device *rvdev,
                                           uint8_t status)
{
        rvdev->vdev->func->set_status(rvdev->vdev, status);
}
 
__deprecated
static inline uint8_t rpmsg_virtio_get_status(struct rpmsg_virtio_device *rvdev)
{
        return rvdev->vdev->func->get_status(rvdev->vdev);
}
 
__deprecated
static inline uint32_t
rpmsg_virtio_get_features(struct rpmsg_virtio_device *rvdev)
{
        return rvdev->vdev->func->get_features(rvdev->vdev);
}
 
__deprecated
static inline void
rpmsg_virtio_read_config(struct rpmsg_virtio_device *rvdev,
                         uint32_t offset, void *dst, int length)
{
        rvdev->vdev->func->read_config(rvdev->vdev, offset, dst, length);
}
 
__deprecated
static inline void
rpmsg_virtio_write_config(struct rpmsg_virtio_device *rvdev,
                         uint32_t offset, void *src, int length)
{
        rvdev->vdev->func->write_config(rvdev->vdev, offset, src, length);
}
 
__deprecated
static inline int
rpmsg_virtio_create_virtqueues(struct rpmsg_virtio_device *rvdev,
                               int flags, unsigned int nvqs,
                               const char *names[],
                               vq_callback *callbacks)
{
        return virtio_create_virtqueues(rvdev->vdev, flags, nvqs, names,
                                        callbacks, NULL);
}
 
__deprecated
static inline void
rpmsg_virtio_delete_virtqueues(struct rpmsg_virtio_device *rvdev)
{
        virtio_delete_virtqueues(rvdev->vdev);
}
 
int rpmsg_virtio_get_tx_buffer_size(struct rpmsg_device *rdev);
 
int rpmsg_virtio_get_rx_buffer_size(struct rpmsg_device *rdev);
 
static inline int rpmsg_virtio_get_buffer_size(struct rpmsg_device *rdev)
{
        return rpmsg_virtio_get_tx_buffer_size(rdev);
}
 
int rpmsg_init_vdev(struct rpmsg_virtio_device *rvdev,
                    struct virtio_device *vdev,
                    rpmsg_ns_bind_cb ns_bind_cb,
                    struct metal_io_region *shm_io,
                    struct rpmsg_virtio_shm_pool *shpool);
 
int rpmsg_init_vdev_with_config(struct rpmsg_virtio_device *rvdev,
                                struct virtio_device *vdev,
                                rpmsg_ns_bind_cb ns_bind_cb,
                                struct metal_io_region *shm_io,
                                struct rpmsg_virtio_shm_pool *shpool,
                                const struct rpmsg_virtio_config *config);
 
void rpmsg_deinit_vdev(struct rpmsg_virtio_device *rvdev);
 
void rpmsg_virtio_init_shm_pool(struct rpmsg_virtio_shm_pool *shpool,
                                void *shbuf, size_t size);
 
static inline struct rpmsg_device *
rpmsg_virtio_get_rpmsg_device(struct rpmsg_virtio_device *rvdev)
{
        if (!rvdev)
                return NULL;
 
        return &rvdev->rdev;
}
 
metal_weak void *
rpmsg_virtio_shm_pool_get_buffer(struct rpmsg_virtio_shm_pool *shpool,
                                 size_t size);
 
#if defined __cplusplus
}
#endif
 
#endif  /* _RPMSG_VIRTIO_H_ */