1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 2023-2024 Google LLC 5 * 6 * Redistribution and use in source and binary forms, with or without modification, 7 * are permitted provided that the following conditions are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright notice, this 10 * list of conditions and the following disclaimer. 11 * 12 * 2. Redistributions in binary form must reproduce the above copyright notice, 13 * this list of conditions and the following disclaimer in the documentation 14 * and/or other materials provided with the distribution. 15 * 16 * 3. Neither the name of the copyright holder nor the names of its contributors 17 * may be used to endorse or promote products derived from this software without 18 * specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 22 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 24 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 25 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 27 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 #ifndef _GVE_AQ_H_ 32 #define _GVE_AQ_H_ 1 33 34 #include <sys/types.h> 35 #include <net/if.h> 36 #include <net/iflib.h> 37 #include <machine/bus.h> 38 #include <machine/resource.h> 39 40 /* Admin queue opcodes */ 41 enum gve_adminq_opcodes { 42 GVE_ADMINQ_DESCRIBE_DEVICE = 0x1, 43 GVE_ADMINQ_CONFIGURE_DEVICE_RESOURCES = 0x2, 44 GVE_ADMINQ_REGISTER_PAGE_LIST = 0x3, 45 GVE_ADMINQ_UNREGISTER_PAGE_LIST = 0x4, 46 GVE_ADMINQ_CREATE_TX_QUEUE = 0x5, 47 GVE_ADMINQ_CREATE_RX_QUEUE = 0x6, 48 GVE_ADMINQ_DESTROY_TX_QUEUE = 0x7, 49 GVE_ADMINQ_DESTROY_RX_QUEUE = 0x8, 50 GVE_ADMINQ_DECONFIGURE_DEVICE_RESOURCES = 0x9, 51 GVE_ADMINQ_SET_DRIVER_PARAMETER = 0xB, 52 GVE_ADMINQ_REPORT_STATS = 0xC, 53 GVE_ADMINQ_REPORT_LINK_SPEED = 0xD, 54 GVE_ADMINQ_GET_PTYPE_MAP = 0xE, 55 GVE_ADMINQ_VERIFY_DRIVER_COMPATIBILITY = 0xF, 56 }; 57 58 /* Admin queue status codes */ 59 enum gve_adminq_statuses { 60 GVE_ADMINQ_COMMAND_UNSET = 0x0, 61 GVE_ADMINQ_COMMAND_PASSED = 0x1, 62 GVE_ADMINQ_COMMAND_ERROR_ABORTED = 0xFFFFFFF0, 63 GVE_ADMINQ_COMMAND_ERROR_ALREADY_EXISTS = 0xFFFFFFF1, 64 GVE_ADMINQ_COMMAND_ERROR_CANCELLED = 0xFFFFFFF2, 65 GVE_ADMINQ_COMMAND_ERROR_DATALOSS = 0xFFFFFFF3, 66 GVE_ADMINQ_COMMAND_ERROR_DEADLINE_EXCEEDED = 0xFFFFFFF4, 67 GVE_ADMINQ_COMMAND_ERROR_FAILED_PRECONDITION = 0xFFFFFFF5, 68 GVE_ADMINQ_COMMAND_ERROR_INTERNAL_ERROR = 0xFFFFFFF6, 69 GVE_ADMINQ_COMMAND_ERROR_INVALID_ARGUMENT = 0xFFFFFFF7, 70 GVE_ADMINQ_COMMAND_ERROR_NOT_FOUND = 0xFFFFFFF8, 71 GVE_ADMINQ_COMMAND_ERROR_OUT_OF_RANGE = 0xFFFFFFF9, 72 GVE_ADMINQ_COMMAND_ERROR_PERMISSION_DENIED = 0xFFFFFFFA, 73 GVE_ADMINQ_COMMAND_ERROR_UNAUTHENTICATED = 0xFFFFFFFB, 74 GVE_ADMINQ_COMMAND_ERROR_RESOURCE_EXHAUSTED = 0xFFFFFFFC, 75 GVE_ADMINQ_COMMAND_ERROR_UNAVAILABLE = 0xFFFFFFFD, 76 GVE_ADMINQ_COMMAND_ERROR_UNIMPLEMENTED = 0xFFFFFFFE, 77 GVE_ADMINQ_COMMAND_ERROR_UNKNOWN_ERROR = 0xFFFFFFFF, 78 }; 79 80 #define GVE_ADMINQ_DEVICE_DESCRIPTOR_VERSION 1 81 82 /* 83 * All AdminQ command structs should be naturally packed. The static_assert 84 * calls make sure this is the case at compile time. 85 */ 86 87 struct gve_adminq_describe_device { 88 __be64 device_descriptor_addr; 89 __be32 device_descriptor_version; 90 __be32 available_length; 91 }; 92 93 _Static_assert(sizeof(struct gve_adminq_describe_device) == 16, 94 "gve: bad admin queue struct length"); 95 96 struct gve_device_descriptor { 97 __be64 max_registered_pages; 98 __be16 reserved1; 99 __be16 tx_queue_entries; 100 __be16 rx_queue_entries; 101 __be16 default_num_queues; 102 __be16 mtu; 103 __be16 counters; 104 __be16 reserved2; 105 __be16 rx_pages_per_qpl; 106 uint8_t mac[ETHER_ADDR_LEN]; 107 __be16 num_device_options; 108 __be16 total_length; 109 uint8_t reserved3[6]; 110 }; 111 112 _Static_assert(sizeof(struct gve_device_descriptor) == 40, 113 "gve: bad admin queue struct length"); 114 115 struct gve_device_option { 116 __be16 option_id; 117 __be16 option_length; 118 __be32 required_features_mask; 119 }; 120 121 _Static_assert(sizeof(struct gve_device_option) == 8, 122 "gve: bad admin queue struct length"); 123 124 struct gve_device_option_gqi_rda { 125 __be32 supported_features_mask; 126 }; 127 128 _Static_assert(sizeof(struct gve_device_option_gqi_rda) == 4, 129 "gve: bad admin queue struct length"); 130 131 struct gve_device_option_gqi_qpl { 132 __be32 supported_features_mask; 133 }; 134 135 _Static_assert(sizeof(struct gve_device_option_gqi_qpl) == 4, 136 "gve: bad admin queue struct length"); 137 138 struct gve_device_option_dqo_rda { 139 __be32 supported_features_mask; 140 __be16 tx_comp_ring_entries; 141 __be16 rx_buff_ring_entries; 142 }; 143 144 _Static_assert(sizeof(struct gve_device_option_dqo_rda) == 8, 145 "gve: bad admin queue struct length"); 146 147 struct gve_device_option_dqo_qpl { 148 __be32 supported_features_mask; 149 __be16 tx_comp_ring_entries; 150 __be16 rx_buff_ring_entries; 151 }; 152 153 _Static_assert(sizeof(struct gve_device_option_dqo_qpl) == 8, 154 "gve: bad admin queue struct length"); 155 156 struct gve_ring_size_bound { 157 __be16 rx; 158 __be16 tx; 159 }; 160 161 _Static_assert(sizeof(struct gve_ring_size_bound) == 4, 162 "gve: bad admin queue struct length"); 163 164 struct gve_device_option_modify_ring { 165 __be32 supported_features_mask; 166 struct gve_ring_size_bound max_ring_size; 167 struct gve_ring_size_bound min_ring_size; 168 }; 169 170 _Static_assert(sizeof(struct gve_device_option_modify_ring) == 12, 171 "gve: bad admin queue struct length"); 172 173 struct gve_device_option_jumbo_frames { 174 __be32 supported_features_mask; 175 __be16 max_mtu; 176 uint8_t padding[2]; 177 }; 178 179 _Static_assert(sizeof(struct gve_device_option_jumbo_frames) == 8, 180 "gve: bad admin queue struct length"); 181 182 enum gve_dev_opt_id { 183 GVE_DEV_OPT_ID_GQI_RAW_ADDRESSING = 0x1, 184 GVE_DEV_OPT_ID_GQI_RDA = 0x2, 185 GVE_DEV_OPT_ID_GQI_QPL = 0x3, 186 GVE_DEV_OPT_ID_DQO_RDA = 0x4, 187 GVE_DEV_OPT_ID_MODIFY_RING = 0x6, 188 GVE_DEV_OPT_ID_DQO_QPL = 0x7, 189 GVE_DEV_OPT_ID_JUMBO_FRAMES = 0x8, 190 }; 191 192 /* 193 * These masks are way to predicate the use of a particular option on the driver 194 * having particular bug fixes represented by each bit position in the mask. 195 * Currently they are all zero because there are no known bugs preventing the 196 * use of any option. 197 */ 198 enum gve_dev_opt_req_feat_mask { 199 GVE_DEV_OPT_REQ_FEAT_MASK_GQI_RAW_ADDRESSING = 0x0, 200 GVE_DEV_OPT_REQ_FEAT_MASK_GQI_RDA = 0x0, 201 GVE_DEV_OPT_REQ_FEAT_MASK_GQI_QPL = 0x0, 202 GVE_DEV_OPT_REQ_FEAT_MASK_DQO_RDA = 0x0, 203 GVE_DEV_OPT_REQ_FEAT_MASK_DQO_QPL = 0x0, 204 GVE_DEV_OPT_REQ_FEAT_MASK_MODIFY_RING = 0x0, 205 GVE_DEV_OPT_REQ_FEAT_MASK_JUMBO_FRAMES = 0x0, 206 }; 207 208 enum gve_sup_feature_mask { 209 GVE_SUP_MODIFY_RING_MASK = 1 << 0, 210 GVE_SUP_JUMBO_FRAMES_MASK = 1 << 2, 211 }; 212 213 #define GVE_VERSION_STR_LEN 128 214 215 enum gve_driver_capability { 216 gve_driver_capability_gqi_qpl = 0, 217 gve_driver_capability_gqi_rda = 1, 218 gve_driver_capability_dqo_qpl = 2, 219 gve_driver_capability_dqo_rda = 3, 220 }; 221 222 #define GVE_CAP1(a) BIT((int) a) 223 #define GVE_CAP2(a) BIT(((int) a) - 64) 224 #define GVE_CAP3(a) BIT(((int) a) - 128) 225 #define GVE_CAP4(a) BIT(((int) a) - 192) 226 227 /* 228 * The following four defines describe 256 compatibility bits. 229 * Only a few bits (as shown in `gve_driver_compatibility`) are currently 230 * defined. The rest are reserved for future use. 231 */ 232 #define GVE_DRIVER_CAPABILITY_FLAGS1 \ 233 (GVE_CAP1(gve_driver_capability_gqi_qpl) | \ 234 GVE_CAP1(gve_driver_capability_dqo_qpl) | \ 235 GVE_CAP1(gve_driver_capability_dqo_rda)) 236 #define GVE_DRIVER_CAPABILITY_FLAGS2 0x0 237 #define GVE_DRIVER_CAPABILITY_FLAGS3 0x0 238 #define GVE_DRIVER_CAPABILITY_FLAGS4 0x0 239 240 struct gve_driver_info { 241 uint8_t os_type; 242 uint8_t driver_major; 243 uint8_t driver_minor; 244 uint8_t driver_sub; 245 __be32 os_version_major; 246 __be32 os_version_minor; 247 __be32 os_version_sub; 248 __be64 driver_capability_flags[4]; 249 uint8_t os_version_str1[GVE_VERSION_STR_LEN]; 250 uint8_t os_version_str2[GVE_VERSION_STR_LEN]; 251 }; 252 253 struct gve_adminq_verify_driver_compatibility { 254 __be64 driver_info_len; 255 __be64 driver_info_addr; 256 }; 257 258 _Static_assert(sizeof(struct gve_adminq_verify_driver_compatibility) == 16, 259 "gve: bad admin queue struct length"); 260 261 struct gve_adminq_configure_device_resources { 262 __be64 counter_array; 263 __be64 irq_db_addr; 264 __be32 num_counters; 265 __be32 num_irq_dbs; 266 __be32 irq_db_stride; 267 __be32 ntfy_blk_msix_base_idx; 268 uint8_t queue_format; 269 uint8_t padding[7]; 270 }; 271 272 _Static_assert(sizeof(struct gve_adminq_configure_device_resources) == 40, 273 "gve: bad admin queue struct length"); 274 275 struct gve_adminq_register_page_list { 276 __be32 page_list_id; 277 __be32 num_pages; 278 __be64 page_address_list_addr; 279 __be64 page_size; 280 }; 281 282 _Static_assert(sizeof(struct gve_adminq_register_page_list) == 24, 283 "gve: bad admin queue struct length"); 284 285 struct gve_adminq_unregister_page_list { 286 __be32 page_list_id; 287 }; 288 289 _Static_assert(sizeof(struct gve_adminq_unregister_page_list) == 4, 290 "gve: bad admin queue struct length"); 291 292 struct gve_adminq_create_tx_queue { 293 __be32 queue_id; 294 __be32 reserved; 295 __be64 queue_resources_addr; 296 __be64 tx_ring_addr; 297 __be32 queue_page_list_id; 298 __be32 ntfy_id; 299 __be64 tx_comp_ring_addr; 300 __be16 tx_ring_size; 301 __be16 tx_comp_ring_size; 302 uint8_t padding[4]; 303 }; 304 305 _Static_assert(sizeof(struct gve_adminq_create_tx_queue) == 48, 306 "gve: bad admin queue struct length"); 307 308 #define GVE_RAW_ADDRESSING_QPL_ID 0xFFFFFFFF 309 310 struct gve_adminq_create_rx_queue { 311 __be32 queue_id; 312 __be32 index; 313 __be32 reserved; 314 __be32 ntfy_id; 315 __be64 queue_resources_addr; 316 __be64 rx_desc_ring_addr; 317 __be64 rx_data_ring_addr; 318 __be32 queue_page_list_id; 319 __be16 rx_ring_size; 320 __be16 packet_buffer_size; 321 __be16 rx_buff_ring_size; 322 uint8_t enable_rsc; 323 uint8_t padding[5]; 324 }; 325 326 _Static_assert(sizeof(struct gve_adminq_create_rx_queue) == 56, 327 "gve: bad admin queue struct length"); 328 329 /* Queue resources that are shared with the device */ 330 struct gve_queue_resources { 331 union { 332 struct { 333 __be32 db_index; /* Device -> Guest */ 334 __be32 counter_index; /* Device -> Guest */ 335 }; 336 uint8_t reserved[64]; 337 }; 338 }; 339 340 _Static_assert(sizeof(struct gve_queue_resources) == 64, 341 "gve: bad admin queue struct length"); 342 343 struct gve_adminq_destroy_tx_queue { 344 __be32 queue_id; 345 }; 346 347 _Static_assert(sizeof(struct gve_adminq_destroy_tx_queue) == 4, 348 "gve: bad admin queue struct length"); 349 350 struct gve_adminq_destroy_rx_queue { 351 __be32 queue_id; 352 }; 353 354 _Static_assert(sizeof(struct gve_adminq_destroy_rx_queue) == 4, 355 "gve: bad admin queue struct length"); 356 357 /* GVE Set Driver Parameter Types */ 358 enum gve_set_driver_param_types { 359 GVE_SET_PARAM_MTU = 0x1, 360 }; 361 362 struct gve_adminq_set_driver_parameter { 363 __be32 parameter_type; 364 uint8_t reserved[4]; 365 __be64 parameter_value; 366 }; 367 368 _Static_assert(sizeof(struct gve_adminq_set_driver_parameter) == 16, 369 "gve: bad admin queue struct length"); 370 371 struct stats { 372 __be32 stat_name; 373 __be32 queue_id; 374 __be64 value; 375 }; 376 377 _Static_assert(sizeof(struct stats) == 16, 378 "gve: bad admin queue struct length"); 379 380 /* These are control path types for PTYPE which are the same as the data path 381 * types. 382 */ 383 struct gve_ptype_entry { 384 uint8_t l3_type; 385 uint8_t l4_type; 386 }; 387 388 struct gve_ptype_map { 389 struct gve_ptype_entry ptypes[1 << 10]; /* PTYPES are always 10 bits. */ 390 }; 391 392 struct gve_adminq_get_ptype_map { 393 __be64 ptype_map_len; 394 __be64 ptype_map_addr; 395 }; 396 397 struct gve_adminq_command { 398 __be32 opcode; 399 __be32 status; 400 union { 401 struct gve_adminq_configure_device_resources 402 configure_device_resources; 403 struct gve_adminq_create_tx_queue create_tx_queue; 404 struct gve_adminq_create_rx_queue create_rx_queue; 405 struct gve_adminq_destroy_tx_queue destroy_tx_queue; 406 struct gve_adminq_destroy_rx_queue destroy_rx_queue; 407 struct gve_adminq_describe_device describe_device; 408 struct gve_adminq_register_page_list reg_page_list; 409 struct gve_adminq_unregister_page_list unreg_page_list; 410 struct gve_adminq_set_driver_parameter set_driver_param; 411 struct gve_adminq_verify_driver_compatibility 412 verify_driver_compatibility; 413 struct gve_adminq_get_ptype_map get_ptype_map; 414 uint8_t reserved[56]; 415 }; 416 }; 417 418 _Static_assert(sizeof(struct gve_adminq_command) == 64, 419 "gve: bad admin queue struct length"); 420 421 enum gve_l3_type { 422 /* Must be zero so zero initialized LUT is unknown. */ 423 GVE_L3_TYPE_UNKNOWN = 0, 424 GVE_L3_TYPE_OTHER, 425 GVE_L3_TYPE_IPV4, 426 GVE_L3_TYPE_IPV6, 427 }; 428 429 enum gve_l4_type { 430 /* Must be zero so zero initialized LUT is unknown. */ 431 GVE_L4_TYPE_UNKNOWN = 0, 432 GVE_L4_TYPE_OTHER, 433 GVE_L4_TYPE_TCP, 434 GVE_L4_TYPE_UDP, 435 GVE_L4_TYPE_ICMP, 436 GVE_L4_TYPE_SCTP, 437 }; 438 439 int gve_adminq_create_rx_queues(struct gve_priv *priv, uint32_t num_queues); 440 int gve_adminq_create_tx_queues(struct gve_priv *priv, uint32_t num_queues); 441 int gve_adminq_destroy_tx_queues(struct gve_priv *priv, uint32_t num_queues); 442 int gve_adminq_destroy_rx_queues(struct gve_priv *priv, uint32_t num_queues); 443 int gve_adminq_set_mtu(struct gve_priv *priv, uint32_t mtu); 444 int gve_adminq_alloc(struct gve_priv *priv); 445 void gve_reset_adminq(struct gve_priv *priv); 446 int gve_adminq_describe_device(struct gve_priv *priv); 447 int gve_adminq_configure_device_resources(struct gve_priv *priv); 448 int gve_adminq_deconfigure_device_resources(struct gve_priv *priv); 449 void gve_release_adminq(struct gve_priv *priv); 450 int gve_adminq_register_page_list(struct gve_priv *priv, 451 struct gve_queue_page_list *qpl); 452 int gve_adminq_unregister_page_list(struct gve_priv *priv, uint32_t page_list_id); 453 int gve_adminq_verify_driver_compatibility(struct gve_priv *priv, 454 uint64_t driver_info_len, vm_paddr_t driver_info_addr); 455 int gve_adminq_get_ptype_map_dqo(struct gve_priv *priv, 456 struct gve_ptype_lut *ptype_lut); 457 #endif /* _GVE_AQ_H_ */ 458