1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
3 * Copyright(c) 2021 Red Hat, Inc.
11 /* The feature bitmap for virtio net */
12 #define VIRTIO_NET_F_CSUM 0 /* Host handles pkts w/ partial csum */
13 #define VIRTIO_NET_F_GUEST_CSUM 1 /* Guest handles pkts w/ partial csum */
14 #define VIRTIO_NET_F_MTU 3 /* Initial MTU advice. */
15 #define VIRTIO_NET_F_MAC 5 /* Host has given MAC address. */
16 #define VIRTIO_NET_F_GUEST_TSO4 7 /* Guest can handle TSOv4 in. */
17 #define VIRTIO_NET_F_GUEST_TSO6 8 /* Guest can handle TSOv6 in. */
18 #define VIRTIO_NET_F_GUEST_ECN 9 /* Guest can handle TSO[6] w/ ECN in. */
19 #define VIRTIO_NET_F_GUEST_UFO 10 /* Guest can handle UFO in. */
20 #define VIRTIO_NET_F_HOST_TSO4 11 /* Host can handle TSOv4 in. */
21 #define VIRTIO_NET_F_HOST_TSO6 12 /* Host can handle TSOv6 in. */
22 #define VIRTIO_NET_F_HOST_ECN 13 /* Host can handle TSO[6] w/ ECN in. */
23 #define VIRTIO_NET_F_HOST_UFO 14 /* Host can handle UFO in. */
24 #define VIRTIO_NET_F_MRG_RXBUF 15 /* Host can merge receive buffers. */
25 #define VIRTIO_NET_F_STATUS 16 /* virtio_net_config.status available */
26 #define VIRTIO_NET_F_CTRL_VQ 17 /* Control channel available */
27 #define VIRTIO_NET_F_CTRL_RX 18 /* Control channel RX mode support */
28 #define VIRTIO_NET_F_CTRL_VLAN 19 /* Control channel VLAN filtering */
29 #define VIRTIO_NET_F_CTRL_RX_EXTRA 20 /* Extra RX mode control support */
30 #define VIRTIO_NET_F_GUEST_ANNOUNCE 21 /* Guest can announce device on the network */
31 #define VIRTIO_NET_F_MQ 22 /* Device supports Receive Flow Steering */
32 #define VIRTIO_NET_F_CTRL_MAC_ADDR 23 /* Set MAC address */
33 #define VIRTIO_NET_F_RSS 60 /* RSS supported */
36 * Do we get callbacks when the ring is completely used,
37 * even if we've suppressed them?
39 #define VIRTIO_F_NOTIFY_ON_EMPTY 24
41 /* Can the device handle any descriptor layout? */
42 #define VIRTIO_F_ANY_LAYOUT 27
44 /* We support indirect buffer descriptors */
45 #define VIRTIO_RING_F_INDIRECT_DESC 28
47 #define VIRTIO_F_VERSION_1 32
48 #define VIRTIO_F_IOMMU_PLATFORM 33
49 #define VIRTIO_F_RING_PACKED 34
52 * Some VirtIO feature bits (currently bits 28 through 31) are
53 * reserved for the transport being used (eg. virtio_ring), the
54 * rest are per-device feature bits.
56 #define VIRTIO_TRANSPORT_F_START 28
57 #define VIRTIO_TRANSPORT_F_END 34
60 * Inorder feature indicates that all buffers are used by the device
61 * in the same order in which they have been made available.
63 #define VIRTIO_F_IN_ORDER 35
66 * This feature indicates that memory accesses by the driver and the device
67 * are ordered in a way described by the platform.
69 #define VIRTIO_F_ORDER_PLATFORM 36
72 * This feature indicates that the driver passes extra data (besides
73 * identifying the virtqueue) in its device notifications.
75 #define VIRTIO_F_NOTIFICATION_DATA 38
77 /* Device set linkspeed and duplex */
78 #define VIRTIO_NET_F_SPEED_DUPLEX 63
81 * The Guest publishes the used index for which it expects an interrupt
82 * at the end of the avail ring. Host should ignore the avail->flags field
84 * The Host publishes the avail index for which it expects a kick
85 * at the end of the used ring. Guest should ignore the used->flags field.
87 #define VIRTIO_RING_F_EVENT_IDX 29
89 #define VIRTIO_NET_S_LINK_UP 1 /* Link is up */
90 #define VIRTIO_NET_S_ANNOUNCE 2 /* Announcement is needed */
93 * Each virtqueue indirect descriptor list must be physically contiguous.
94 * To allow us to malloc(9) each list individually, limit the number
95 * supported to what will fit in one page. With 4KB pages, this is a limit
96 * of 256 descriptors. If there is ever a need for more, we can switch to
97 * contigmalloc(9) for the larger allocations, similar to what
98 * bus_dmamem_alloc(9) does.
100 * Note the sizeof(struct vring_desc) is 16 bytes.
102 #define VIRTIO_MAX_INDIRECT ((int)(rte_mem_page_size() / 16))
104 /* Virtio RSS hash types */
105 #define VIRTIO_NET_HASH_TYPE_IPV4 RTE_BIT32(0)
106 #define VIRTIO_NET_HASH_TYPE_TCPV4 RTE_BIT32(1)
107 #define VIRTIO_NET_HASH_TYPE_UDPV4 RTE_BIT32(2)
108 #define VIRTIO_NET_HASH_TYPE_IPV6 RTE_BIT32(3)
109 #define VIRTIO_NET_HASH_TYPE_TCPV6 RTE_BIT32(4)
110 #define VIRTIO_NET_HASH_TYPE_UDPV6 RTE_BIT32(5)
111 #define VIRTIO_NET_HASH_TYPE_IP_EX RTE_BIT32(6)
112 #define VIRTIO_NET_HASH_TYPE_TCP_EX RTE_BIT32(7)
113 #define VIRTIO_NET_HASH_TYPE_UDP_EX RTE_BIT32(8)
115 #define VIRTIO_NET_HASH_TYPE_MASK ( \
116 VIRTIO_NET_HASH_TYPE_IPV4 | \
117 VIRTIO_NET_HASH_TYPE_TCPV4 | \
118 VIRTIO_NET_HASH_TYPE_UDPV4 | \
119 VIRTIO_NET_HASH_TYPE_IPV6 | \
120 VIRTIO_NET_HASH_TYPE_TCPV6 | \
121 VIRTIO_NET_HASH_TYPE_UDPV6 | \
122 VIRTIO_NET_HASH_TYPE_IP_EX | \
123 VIRTIO_NET_HASH_TYPE_TCP_EX | \
124 VIRTIO_NET_HASH_TYPE_UDP_EX)
128 * Maximum number of virtqueues per device.
130 #define VIRTIO_MAX_VIRTQUEUE_PAIRS 8
131 #define VIRTIO_MAX_VIRTQUEUES (VIRTIO_MAX_VIRTQUEUE_PAIRS * 2 + 1)
133 /* VirtIO device IDs. */
134 #define VIRTIO_ID_NETWORK 0x01
135 #define VIRTIO_ID_BLOCK 0x02
136 #define VIRTIO_ID_CONSOLE 0x03
137 #define VIRTIO_ID_ENTROPY 0x04
138 #define VIRTIO_ID_BALLOON 0x05
139 #define VIRTIO_ID_IOMEMORY 0x06
140 #define VIRTIO_ID_9P 0x09
142 /* Status byte for guest to report progress. */
143 #define VIRTIO_CONFIG_STATUS_RESET 0x00
144 #define VIRTIO_CONFIG_STATUS_ACK 0x01
145 #define VIRTIO_CONFIG_STATUS_DRIVER 0x02
146 #define VIRTIO_CONFIG_STATUS_DRIVER_OK 0x04
147 #define VIRTIO_CONFIG_STATUS_FEATURES_OK 0x08
148 #define VIRTIO_CONFIG_STATUS_DEV_NEED_RESET 0x40
149 #define VIRTIO_CONFIG_STATUS_FAILED 0x80
151 /* The bit of the ISR which indicates a device has an interrupt. */
152 #define VIRTIO_ISR_INTR 0x1
153 /* The bit of the ISR which indicates a device configuration change. */
154 #define VIRTIO_ISR_CONFIG 0x2
155 /* Vector value used to disable MSI for queue. */
156 #define VIRTIO_MSI_NO_VECTOR 0xFFFF
158 /* The alignment to use between consumer and producer parts of vring. */
159 #define VIRTIO_VRING_ALIGN 4096
162 * This structure is just a reference to read net device specific
163 * config space; it is just a shadow structure.
166 struct virtio_net_config {
167 /* The config defining mac address (if VIRTIO_NET_F_MAC) */
168 uint8_t mac[RTE_ETHER_ADDR_LEN];
169 /* See VIRTIO_NET_F_STATUS and VIRTIO_NET_S_* above */
171 uint16_t max_virtqueue_pairs;
174 * speed, in units of 1Mb. All values 0 to INT_MAX are legal.
175 * Any other value stands for unknown.
181 * Any other value stands for unknown.
184 uint8_t rss_max_key_size;
185 uint16_t rss_max_indirection_table_length;
186 uint32_t supported_hash_types;
190 struct virtqueue **vqs;
191 uint64_t guest_features;
192 uint16_t vtnet_hdr_size;
194 uint8_t weak_barriers;
197 uint8_t has_tx_offload;
198 uint8_t has_rx_offload;
201 uint8_t use_inorder_rx;
202 uint8_t use_inorder_tx;
205 uint8_t mac_addr[RTE_ETHER_ADDR_LEN];
207 * Speed is specified via 'speed' devarg or
208 * negotiated via VIRTIO_NET_F_SPEED_DUPLEX
210 bool get_speed_via_feat;
211 uint32_t speed; /* link speed in MB */
215 size_t max_rx_pkt_len;
217 * App management thread and virtio interrupt handler thread
218 * both can change device state, this lock is meant to avoid
221 rte_spinlock_t state_lock;
222 struct rte_mbuf **inject_pkts;
223 uint16_t max_queue_pairs;
224 uint16_t rss_rx_queues;
225 uint32_t rss_hash_types;
228 uint64_t req_guest_features;
229 struct virtnet_ctl *cvq;
234 void (*read_dev_cfg)(struct virtio_hw *hw, size_t offset, void *dst, int len);
235 void (*write_dev_cfg)(struct virtio_hw *hw, size_t offset, const void *src, int len);
236 uint8_t (*get_status)(struct virtio_hw *hw);
237 void (*set_status)(struct virtio_hw *hw, uint8_t status);
238 uint64_t (*get_features)(struct virtio_hw *hw);
239 void (*set_features)(struct virtio_hw *hw, uint64_t features);
240 int (*features_ok)(struct virtio_hw *hw);
241 uint8_t (*get_isr)(struct virtio_hw *hw);
242 uint16_t (*set_config_irq)(struct virtio_hw *hw, uint16_t vec);
243 uint16_t (*set_queue_irq)(struct virtio_hw *hw, struct virtqueue *vq, uint16_t vec);
244 uint16_t (*get_queue_num)(struct virtio_hw *hw, uint16_t queue_id);
245 int (*setup_queue)(struct virtio_hw *hw, struct virtqueue *vq);
246 void (*del_queue)(struct virtio_hw *hw, struct virtqueue *vq);
247 void (*notify_queue)(struct virtio_hw *hw, struct virtqueue *vq);
248 void (*intr_detect)(struct virtio_hw *hw);
249 int (*dev_close)(struct virtio_hw *hw);
253 * This structure stores per-process data. Only virtio_ops for now.
255 struct virtio_hw_internal {
256 const struct virtio_ops *virtio_ops;
259 #define VIRTIO_OPS(hw) (virtio_hw_internal[(hw)->port_id].virtio_ops)
261 extern struct virtio_hw_internal virtio_hw_internal[RTE_MAX_ETHPORTS];
265 virtio_with_feature(struct virtio_hw *hw, uint64_t bit)
267 return (hw->guest_features & (1ULL << bit)) != 0;
271 virtio_with_packed_queue(struct virtio_hw *hw)
273 return virtio_with_feature(hw, VIRTIO_F_RING_PACKED);
276 uint64_t virtio_negotiate_features(struct virtio_hw *hw, uint64_t host_features);
277 uint8_t virtio_get_status(struct virtio_hw *hw);
278 void virtio_set_status(struct virtio_hw *hw, uint8_t status);
279 void virtio_write_dev_config(struct virtio_hw *hw, size_t offset, const void *src, int length);
280 void virtio_read_dev_config(struct virtio_hw *hw, size_t offset, void *dst, int length);
281 void virtio_reset(struct virtio_hw *hw);
282 void virtio_reinit_complete(struct virtio_hw *hw);
283 uint8_t virtio_get_isr(struct virtio_hw *hw);
284 #endif /* _VIRTIO_H_ */