| #ifndef VIRTQUEUE_H_ |
| #define VIRTQUEUE_H_ |
| |
| /*- |
| * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> |
| * Copyright (c) 2016 Freescale Semiconductor, Inc. |
| * Copyright 2016-2019 NXP |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice unmodified, this list of conditions, and the following |
| * disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * $FreeBSD$ |
| */ |
| |
| #include <stdbool.h> |
| #include <stdint.h> |
| #include "rpmsg_default_config.h" |
| typedef uint8_t boolean; |
| |
| #include "virtio_ring.h" |
| #include "llist.h" |
| |
| /*Error Codes*/ |
| #define VQ_ERROR_BASE (-3000) |
| #define ERROR_VRING_FULL (VQ_ERROR_BASE - 1) |
| #define ERROR_INVLD_DESC_IDX (VQ_ERROR_BASE - 2) |
| #define ERROR_EMPTY_RING (VQ_ERROR_BASE - 3) |
| #define ERROR_NO_MEM (VQ_ERROR_BASE - 4) |
| #define ERROR_VRING_MAX_DESC (VQ_ERROR_BASE - 5) |
| #define ERROR_VRING_ALIGN (VQ_ERROR_BASE - 6) |
| #define ERROR_VRING_NO_BUFF (VQ_ERROR_BASE - 7) |
| #define ERROR_VQUEUE_INVLD_PARAM (VQ_ERROR_BASE - 8) |
| |
| #define VQUEUE_SUCCESS (0) |
| #define VQUEUE_DEBUG (false) |
| |
| /* This is temporary macro to replace C NULL support. |
| * At the moment all the RTL specific functions are present in env. |
| * */ |
| #define VQ_NULL ((void *)0) |
| |
| /* The maximum virtqueue size is 2^15. Use that value as the end of |
| * descriptor chain terminator since it will never be a valid index |
| * in the descriptor table. This is used to verify we are correctly |
| * handling vq_free_cnt. |
| */ |
| #define VQ_RING_DESC_CHAIN_END (32768) |
| #define VIRTQUEUE_FLAG_INDIRECT (0x0001U) |
| #define VIRTQUEUE_FLAG_EVENT_IDX (0x0002U) |
| #define VIRTQUEUE_MAX_NAME_SZ (32) /* mind the alignment */ |
| |
| /* Support for indirect buffer descriptors. */ |
| #define VIRTIO_RING_F_INDIRECT_DESC (1 << 28) |
| |
| /* Support to suppress interrupt until specific index is reached. */ |
| #define VIRTIO_RING_F_EVENT_IDX (1 << 29) |
| |
| /* |
| * Hint on how long the next interrupt should be postponed. This is |
| * only used when the EVENT_IDX feature is negotiated. |
| */ |
| typedef enum |
| { |
| VQ_POSTPONE_SHORT, |
| VQ_POSTPONE_LONG, |
| VQ_POSTPONE_EMPTIED /* Until all available desc are used. */ |
| } vq_postpone_t; |
| |
| /* local virtqueue representation, not in shared memory */ |
| struct virtqueue |
| { |
| /* 32bit aligned { */ |
| char vq_name[VIRTQUEUE_MAX_NAME_SZ]; |
| uint32_t vq_flags; |
| int32_t vq_alignment; |
| int32_t vq_ring_size; |
| void *vq_ring_mem; |
| void (*callback_fc)(struct virtqueue *vq); |
| void (*notify_fc)(struct virtqueue *vq); |
| int32_t vq_max_indirect_size; |
| int32_t vq_indirect_mem_size; |
| struct vring vq_ring; |
| /* } 32bit aligned */ |
| |
| /* 16bit aligned { */ |
| uint16_t vq_queue_index; |
| uint16_t vq_nentries; |
| uint16_t vq_free_cnt; |
| uint16_t vq_queued_cnt; |
| |
| /* |
| * Head of the free chain in the descriptor table. If |
| * there are no free descriptors, this will be set to |
| * VQ_RING_DESC_CHAIN_END. |
| */ |
| uint16_t vq_desc_head_idx; |
| |
| /* |
| * Last consumed descriptor in the used table, |
| * trails vq_ring.used->idx. |
| */ |
| uint16_t vq_used_cons_idx; |
| |
| /* |
| * Last consumed descriptor in the available table - |
| * used by the consumer side. |
| */ |
| uint16_t vq_available_idx; |
| /* } 16bit aligned */ |
| |
| boolean avail_read; /* 8bit wide */ |
| boolean avail_write; /* 8bit wide */ |
| boolean used_read; /* 8bit wide */ |
| boolean used_write; /* 8bit wide */ |
| |
| uint16_t padd; /* aligned to 32bits after this: */ |
| |
| void *priv; /* private pointer, upper layer instance pointer */ |
| #if defined(RL_USE_ENVIRONMENT_CONTEXT) && (RL_USE_ENVIRONMENT_CONTEXT == 1) |
| void *env; /* private pointer to environment layer internal context */ |
| #endif |
| }; |
| |
| /* struct to hold vring specific information */ |
| struct vring_alloc_info |
| { |
| void *phy_addr; |
| uint32_t align; |
| uint16_t num_descs; |
| uint16_t pad; |
| }; |
| |
| struct vq_static_context |
| { |
| struct virtqueue vq; |
| }; |
| |
| typedef void vq_callback(struct virtqueue *vq); |
| typedef void vq_notify(struct virtqueue *vq); |
| |
| #if (VQUEUE_DEBUG == true) |
| #define VQASSERT_BOOL(_vq, _exp, _msg) \ |
| do \ |
| { \ |
| if (!(_exp)) \ |
| { \ |
| env_print("%s: %s - " _msg, __func__, (_vq)->vq_name); \ |
| while (1) \ |
| ; \ |
| } \ |
| } while (0) |
| #define VQASSERT(_vq, _exp, _msg) VQASSERT_BOOL(_vq, (_exp) != 0, _msg) |
| |
| #define VQ_RING_ASSERT_VALID_IDX(_vq, _idx) VQASSERT((_vq), (_idx) < (_vq)->vq_nentries, "invalid ring index") |
| |
| #define VQ_PARAM_CHK(condition, status_var, status_err) \ |
| if ((status_var == 0) && (condition)) \ |
| { \ |
| status_var = status_err; \ |
| } |
| |
| #define VQUEUE_BUSY(vq, dir) \ |
| if ((vq)->dir == false) \ |
| (vq)->dir = true; \ |
| else \ |
| VQASSERT(vq, (vq)->dir == false, "VirtQueue already in use") |
| |
| #define VQUEUE_IDLE(vq, dir) ((vq)->dir = false) |
| |
| #else |
| |
| #define KASSERT(cond, str) |
| #define VQASSERT(_vq, _exp, _msg) |
| #define VQ_RING_ASSERT_VALID_IDX(_vq, _idx) |
| #define VQ_PARAM_CHK(condition, status_var, status_err) |
| #define VQUEUE_BUSY(vq, dir) |
| #define VQUEUE_IDLE(vq, dir) |
| |
| #endif |
| |
| int32_t virtqueue_create(uint16_t id, |
| const char *name, |
| struct vring_alloc_info *ring, |
| void (*callback_fc)(struct virtqueue *vq), |
| void (*notify_fc)(struct virtqueue *vq), |
| struct virtqueue **v_queue); |
| |
| int32_t virtqueue_create_static(uint16_t id, |
| const char *name, |
| struct vring_alloc_info *ring, |
| void (*callback_fc)(struct virtqueue *vq), |
| void (*notify_fc)(struct virtqueue *vq), |
| struct virtqueue **v_queue, |
| struct vq_static_context *vq_ctxt); |
| |
| int32_t virtqueue_add_buffer(struct virtqueue *vq, uint16_t head_idx); |
| |
| int32_t virtqueue_fill_used_buffers(struct virtqueue *vq, void *buffer, uint32_t len); |
| |
| int32_t virtqueue_fill_avail_buffers(struct virtqueue *vq, void *buffer, uint32_t len); |
| |
| void *virtqueue_get_buffer(struct virtqueue *vq, uint32_t *len, uint16_t *idx); |
| |
| void *virtqueue_get_available_buffer(struct virtqueue *vq, uint16_t *avail_idx, uint32_t *len); |
| |
| int32_t virtqueue_add_consumed_buffer(struct virtqueue *vq, uint16_t head_idx, uint32_t len); |
| |
| void virtqueue_disable_cb(struct virtqueue *vq); |
| |
| int32_t virtqueue_enable_cb(struct virtqueue *vq); |
| |
| void virtqueue_kick(struct virtqueue *vq); |
| |
| void virtqueue_free(struct virtqueue *vq); |
| |
| void virtqueue_free_static(struct virtqueue *vq); |
| |
| void virtqueue_dump(struct virtqueue *vq); |
| |
| void virtqueue_notification(struct virtqueue *vq); |
| |
| uint32_t virtqueue_get_desc_size(struct virtqueue *vq); |
| |
| uint32_t virtqueue_get_buffer_length(struct virtqueue *vq, uint16_t idx); |
| |
| void vq_ring_init(struct virtqueue *vq); |
| |
| #endif /* VIRTQUEUE_H_ */ |