crypto/qat: add device files
[dpdk.git] / drivers / crypto / virtio / virtqueue.h
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 HUAWEI TECHNOLOGIES CO., LTD.
3  */
4
5 #ifndef _VIRTQUEUE_H_
6 #define _VIRTQUEUE_H_
7
8 #include <stdint.h>
9
10 #include <rte_atomic.h>
11 #include <rte_memory.h>
12 #include <rte_memzone.h>
13 #include <rte_mempool.h>
14
15 #include "virtio_pci.h"
16 #include "virtio_ring.h"
17 #include "virtio_logs.h"
18 #include "virtio_crypto.h"
19
20 struct rte_mbuf;
21
22 /*
23  * Per virtio_config.h in Linux.
24  *     For virtio_pci on SMP, we don't need to order with respect to MMIO
25  *     accesses through relaxed memory I/O windows, so smp_mb() et al are
26  *     sufficient.
27  *
28  */
29 #define virtio_mb()     rte_smp_mb()
30 #define virtio_rmb()    rte_smp_rmb()
31 #define virtio_wmb()    rte_smp_wmb()
32
33 #define VIRTQUEUE_MAX_NAME_SZ 32
34
35 enum { VTCRYPTO_DATAQ = 0, VTCRYPTO_CTRLQ = 1 };
36
37 /**
38  * The maximum virtqueue size is 2^15. Use that value as the end of
39  * descriptor chain terminator since it will never be a valid index
40  * in the descriptor table. This is used to verify we are correctly
41  * handling vq_free_cnt.
42  */
43 #define VQ_RING_DESC_CHAIN_END 32768
44
45 struct vq_desc_extra {
46         void     *crypto_op;
47         void     *cookie;
48         uint16_t ndescs;
49 };
50
51 struct virtqueue {
52         /**< virtio_crypto_hw structure pointer. */
53         struct virtio_crypto_hw *hw;
54         /**< mem zone to populate RX ring. */
55         const struct rte_memzone *mz;
56         /**< memzone to populate hdr and request. */
57         struct rte_mempool *mpool;
58         uint8_t     dev_id;              /**< Device identifier. */
59         uint16_t    vq_queue_index;       /**< PCI queue index */
60
61         void        *vq_ring_virt_mem;    /**< linear address of vring*/
62         unsigned int vq_ring_size;
63         phys_addr_t vq_ring_mem;          /**< physical address of vring */
64
65         struct vring vq_ring;    /**< vring keeping desc, used and avail */
66         uint16_t    vq_free_cnt; /**< num of desc available */
67         uint16_t    vq_nentries; /**< vring desc numbers */
68
69         /**
70          * Head of the free chain in the descriptor table. If
71          * there are no free descriptors, this will be set to
72          * VQ_RING_DESC_CHAIN_END.
73          */
74         uint16_t  vq_desc_head_idx;
75         uint16_t  vq_desc_tail_idx;
76         /**
77          * Last consumed descriptor in the used table,
78          * trails vq_ring.used->idx.
79          */
80         uint16_t vq_used_cons_idx;
81         uint16_t vq_avail_idx;
82
83         /* Statistics */
84         uint64_t        packets_sent_total;
85         uint64_t        packets_sent_failed;
86         uint64_t        packets_received_total;
87         uint64_t        packets_received_failed;
88
89         uint16_t  *notify_addr;
90
91         struct vq_desc_extra vq_descx[0];
92 };
93
94 /**
95  * Tell the backend not to interrupt us.
96  */
97 void virtqueue_disable_intr(struct virtqueue *vq);
98
99 /**
100  *  Get all mbufs to be freed.
101  */
102 void virtqueue_detatch_unused(struct virtqueue *vq);
103
104 static inline int
105 virtqueue_full(const struct virtqueue *vq)
106 {
107         return vq->vq_free_cnt == 0;
108 }
109
110 #define VIRTQUEUE_NUSED(vq) \
111         ((uint16_t)((vq)->vq_ring.used->idx - (vq)->vq_used_cons_idx))
112
113 static inline void
114 vq_update_avail_idx(struct virtqueue *vq)
115 {
116         virtio_wmb();
117         vq->vq_ring.avail->idx = vq->vq_avail_idx;
118 }
119
120 static inline void
121 vq_update_avail_ring(struct virtqueue *vq, uint16_t desc_idx)
122 {
123         uint16_t avail_idx;
124         /*
125          * Place the head of the descriptor chain into the next slot and make
126          * it usable to the host. The chain is made available now rather than
127          * deferring to virtqueue_notify() in the hopes that if the host is
128          * currently running on another CPU, we can keep it processing the new
129          * descriptor.
130          */
131         avail_idx = (uint16_t)(vq->vq_avail_idx & (vq->vq_nentries - 1));
132         if (unlikely(vq->vq_ring.avail->ring[avail_idx] != desc_idx))
133                 vq->vq_ring.avail->ring[avail_idx] = desc_idx;
134         vq->vq_avail_idx++;
135 }
136
137 static inline int
138 virtqueue_kick_prepare(struct virtqueue *vq)
139 {
140         return !(vq->vq_ring.used->flags & VRING_USED_F_NO_NOTIFY);
141 }
142
143 static inline void
144 virtqueue_notify(struct virtqueue *vq)
145 {
146         /*
147          * Ensure updated avail->idx is visible to host.
148          * For virtio on IA, the notificaiton is through io port operation
149          * which is a serialization instruction itself.
150          */
151         VTPCI_OPS(vq->hw)->notify_queue(vq->hw, vq);
152 }
153
154 /**
155  * Dump virtqueue internal structures, for debug purpose only.
156  */
157 #define VIRTQUEUE_DUMP(vq) do { \
158         uint16_t used_idx, nused; \
159         used_idx = (vq)->vq_ring.used->idx; \
160         nused = (uint16_t)(used_idx - (vq)->vq_used_cons_idx); \
161         VIRTIO_CRYPTO_INIT_LOG_DBG(\
162           "VQ: - size=%d; free=%d; used=%d; desc_head_idx=%d;" \
163           " avail.idx=%d; used_cons_idx=%d; used.idx=%d;" \
164           " avail.flags=0x%x; used.flags=0x%x", \
165           (vq)->vq_nentries, (vq)->vq_free_cnt, nused, \
166           (vq)->vq_desc_head_idx, (vq)->vq_ring.avail->idx, \
167           (vq)->vq_used_cons_idx, (vq)->vq_ring.used->idx, \
168           (vq)->vq_ring.avail->flags, (vq)->vq_ring.used->flags); \
169 } while (0)
170
171 #endif /* _VIRTQUEUE_H_ */