1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2014 Intel Corporation 3 * Copyright(c) 2021 Red Hat, Inc. 4 */ 5 6 #ifndef _VIRTIO_H_ 7 #define _VIRTIO_H_ 8 9 #include <rte_ether.h> 10 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 */ 34 35 /* 36 * Do we get callbacks when the ring is completely used, 37 * even if we've suppressed them? 38 */ 39 #define VIRTIO_F_NOTIFY_ON_EMPTY 24 40 41 /* Can the device handle any descriptor layout? */ 42 #define VIRTIO_F_ANY_LAYOUT 27 43 44 /* We support indirect buffer descriptors */ 45 #define VIRTIO_RING_F_INDIRECT_DESC 28 46 47 #define VIRTIO_F_VERSION_1 32 48 #define VIRTIO_F_IOMMU_PLATFORM 33 49 #define VIRTIO_F_RING_PACKED 34 50 51 /* 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. 55 */ 56 #define VIRTIO_TRANSPORT_F_START 28 57 #define VIRTIO_TRANSPORT_F_END 34 58 59 /* 60 * Inorder feature indicates that all buffers are used by the device 61 * in the same order in which they have been made available. 62 */ 63 #define VIRTIO_F_IN_ORDER 35 64 65 /* 66 * This feature indicates that memory accesses by the driver and the device 67 * are ordered in a way described by the platform. 68 */ 69 #define VIRTIO_F_ORDER_PLATFORM 36 70 71 /* 72 * This feature indicates that the driver passes extra data (besides 73 * identifying the virtqueue) in its device notifications. 74 */ 75 #define VIRTIO_F_NOTIFICATION_DATA 38 76 77 /* Device set linkspeed and duplex */ 78 #define VIRTIO_NET_F_SPEED_DUPLEX 63 79 80 /* 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 83 * 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. 86 */ 87 #define VIRTIO_RING_F_EVENT_IDX 29 88 89 #define VIRTIO_NET_S_LINK_UP 1 /* Link is up */ 90 #define VIRTIO_NET_S_ANNOUNCE 2 /* Announcement is needed */ 91 92 /* 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. 99 * 100 * Note the sizeof(struct vring_desc) is 16 bytes. 101 */ 102 #define VIRTIO_MAX_INDIRECT ((int)(rte_mem_page_size() / 16)) 103 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) 114 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) 125 126 127 /* 128 * Maximum number of virtqueues per device. 129 */ 130 #define VIRTIO_MAX_VIRTQUEUE_PAIRS 8 131 #define VIRTIO_MAX_VIRTQUEUES (VIRTIO_MAX_VIRTQUEUE_PAIRS * 2 + 1) 132 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 141 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 150 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 157 158 /* The alignment to use between consumer and producer parts of vring. */ 159 #define VIRTIO_VRING_ALIGN 4096 160 161 /* 162 * This structure is just a reference to read net device specific 163 * config space; it is just a shadow structure. 164 * 165 */ 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 */ 170 uint16_t status; 171 uint16_t max_virtqueue_pairs; 172 uint16_t mtu; 173 /* 174 * speed, in units of 1Mb. All values 0 to INT_MAX are legal. 175 * Any other value stands for unknown. 176 */ 177 uint32_t speed; 178 /* 179 * 0x00 - half duplex 180 * 0x01 - full duplex 181 * Any other value stands for unknown. 182 */ 183 uint8_t duplex; 184 uint8_t rss_max_key_size; 185 uint16_t rss_max_indirection_table_length; 186 uint32_t supported_hash_types; 187 } __rte_packed; 188 189 struct virtio_hw { 190 struct virtqueue **vqs; 191 uint64_t guest_features; 192 uint16_t vtnet_hdr_size; 193 uint8_t started; 194 uint8_t weak_barriers; 195 uint8_t vlan_strip; 196 bool rx_ol_scatter; 197 uint8_t has_tx_offload; 198 uint8_t has_rx_offload; 199 uint8_t use_vec_rx; 200 uint8_t use_vec_tx; 201 uint8_t use_inorder_rx; 202 uint8_t use_inorder_tx; 203 uint8_t opened; 204 uint16_t port_id; 205 uint8_t mac_addr[RTE_ETHER_ADDR_LEN]; 206 /* 207 * Speed is specified via 'speed' devarg or 208 * negotiated via VIRTIO_NET_F_SPEED_DUPLEX 209 */ 210 bool get_speed_via_feat; 211 uint32_t speed; /* link speed in MB */ 212 uint8_t duplex; 213 uint8_t intr_lsc; 214 uint16_t max_mtu; 215 size_t max_rx_pkt_len; 216 /* 217 * App management thread and virtio interrupt handler thread 218 * both can change device state, this lock is meant to avoid 219 * such a contention. 220 */ 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; 226 uint16_t *rss_reta; 227 uint8_t *rss_key; 228 uint64_t req_guest_features; 229 struct virtnet_ctl *cvq; 230 bool use_va; 231 }; 232 233 struct virtio_ops { 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); 250 }; 251 252 /* 253 * This structure stores per-process data. Only virtio_ops for now. 254 */ 255 struct virtio_hw_internal { 256 const struct virtio_ops *virtio_ops; 257 }; 258 259 #define VIRTIO_OPS(hw) (virtio_hw_internal[(hw)->port_id].virtio_ops) 260 261 extern struct virtio_hw_internal virtio_hw_internal[RTE_MAX_ETHPORTS]; 262 263 264 static inline int 265 virtio_with_feature(struct virtio_hw *hw, uint64_t bit) 266 { 267 return (hw->guest_features & (1ULL << bit)) != 0; 268 } 269 270 static inline int 271 virtio_with_packed_queue(struct virtio_hw *hw) 272 { 273 return virtio_with_feature(hw, VIRTIO_F_RING_PACKED); 274 } 275 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_ */ 285