google/gve/gve_adminq.h

0001 /* SPDX-License-Identifier: (GPL-2.0 OR MIT)
0002  * Google virtual Ethernet (gve) driver
0003  *
0004  * Copyright (C) 2015-2021 Google, Inc.
0005  */
0006
0007 #ifndef _GVE_ADMINQ_H
0008 #define _GVE_ADMINQ_H
0009
0010 #include <linux/build_bug.h>
0011
0012 /* Admin queue opcodes */
0013 enum gve_adminq_opcodes {
0014     GVE_ADMINQ_DESCRIBE_DEVICE      = 0x1,
0015     GVE_ADMINQ_CONFIGURE_DEVICE_RESOURCES   = 0x2,
0016     GVE_ADMINQ_REGISTER_PAGE_LIST       = 0x3,
0017     GVE_ADMINQ_UNREGISTER_PAGE_LIST     = 0x4,
0018     GVE_ADMINQ_CREATE_TX_QUEUE      = 0x5,
0019     GVE_ADMINQ_CREATE_RX_QUEUE      = 0x6,
0020     GVE_ADMINQ_DESTROY_TX_QUEUE     = 0x7,
0021     GVE_ADMINQ_DESTROY_RX_QUEUE     = 0x8,
0022     GVE_ADMINQ_DECONFIGURE_DEVICE_RESOURCES = 0x9,
0023     GVE_ADMINQ_SET_DRIVER_PARAMETER     = 0xB,
0024     GVE_ADMINQ_REPORT_STATS         = 0xC,
0025     GVE_ADMINQ_REPORT_LINK_SPEED        = 0xD,
0026     GVE_ADMINQ_GET_PTYPE_MAP        = 0xE,
0027 };
0028
0029 /* Admin queue status codes */
0030 enum gve_adminq_statuses {
0031     GVE_ADMINQ_COMMAND_UNSET            = 0x0,
0032     GVE_ADMINQ_COMMAND_PASSED           = 0x1,
0033     GVE_ADMINQ_COMMAND_ERROR_ABORTED        = 0xFFFFFFF0,
0034     GVE_ADMINQ_COMMAND_ERROR_ALREADY_EXISTS     = 0xFFFFFFF1,
0035     GVE_ADMINQ_COMMAND_ERROR_CANCELLED      = 0xFFFFFFF2,
0036     GVE_ADMINQ_COMMAND_ERROR_DATALOSS       = 0xFFFFFFF3,
0037     GVE_ADMINQ_COMMAND_ERROR_DEADLINE_EXCEEDED  = 0xFFFFFFF4,
0038     GVE_ADMINQ_COMMAND_ERROR_FAILED_PRECONDITION    = 0xFFFFFFF5,
0039     GVE_ADMINQ_COMMAND_ERROR_INTERNAL_ERROR     = 0xFFFFFFF6,
0040     GVE_ADMINQ_COMMAND_ERROR_INVALID_ARGUMENT   = 0xFFFFFFF7,
0041     GVE_ADMINQ_COMMAND_ERROR_NOT_FOUND      = 0xFFFFFFF8,
0042     GVE_ADMINQ_COMMAND_ERROR_OUT_OF_RANGE       = 0xFFFFFFF9,
0043     GVE_ADMINQ_COMMAND_ERROR_PERMISSION_DENIED  = 0xFFFFFFFA,
0044     GVE_ADMINQ_COMMAND_ERROR_UNAUTHENTICATED    = 0xFFFFFFFB,
0045     GVE_ADMINQ_COMMAND_ERROR_RESOURCE_EXHAUSTED = 0xFFFFFFFC,
0046     GVE_ADMINQ_COMMAND_ERROR_UNAVAILABLE        = 0xFFFFFFFD,
0047     GVE_ADMINQ_COMMAND_ERROR_UNIMPLEMENTED      = 0xFFFFFFFE,
0048     GVE_ADMINQ_COMMAND_ERROR_UNKNOWN_ERROR      = 0xFFFFFFFF,
0049 };
0050
0051 #define GVE_ADMINQ_DEVICE_DESCRIPTOR_VERSION 1
0052
0053 /* All AdminQ command structs should be naturally packed. The static_assert
0054  * calls make sure this is the case at compile time.
0055  */
0056
0057 struct gve_adminq_describe_device {
0058     __be64 device_descriptor_addr;
0059     __be32 device_descriptor_version;
0060     __be32 available_length;
0061 };
0062
0063 static_assert(sizeof(struct gve_adminq_describe_device) == 16);
0064
0065 struct gve_device_descriptor {
0066     __be64 max_registered_pages;
0067     __be16 reserved1;
0068     __be16 tx_queue_entries;
0069     __be16 rx_queue_entries;
0070     __be16 default_num_queues;
0071     __be16 mtu;
0072     __be16 counters;
0073     __be16 tx_pages_per_qpl;
0074     __be16 rx_pages_per_qpl;
0075     u8  mac[ETH_ALEN];
0076     __be16 num_device_options;
0077     __be16 total_length;
0078     u8  reserved2[6];
0079 };
0080
0081 static_assert(sizeof(struct gve_device_descriptor) == 40);
0082
0083 struct gve_device_option {
0084     __be16 option_id;
0085     __be16 option_length;
0086     __be32 required_features_mask;
0087 };
0088
0089 static_assert(sizeof(struct gve_device_option) == 8);
0090
0091 struct gve_device_option_gqi_rda {
0092     __be32 supported_features_mask;
0093 };
0094
0095 static_assert(sizeof(struct gve_device_option_gqi_rda) == 4);
0096
0097 struct gve_device_option_gqi_qpl {
0098     __be32 supported_features_mask;
0099 };
0100
0101 static_assert(sizeof(struct gve_device_option_gqi_qpl) == 4);
0102
0103 struct gve_device_option_dqo_rda {
0104     __be32 supported_features_mask;
0105     __be16 tx_comp_ring_entries;
0106     __be16 rx_buff_ring_entries;
0107 };
0108
0109 static_assert(sizeof(struct gve_device_option_dqo_rda) == 8);
0110
0111 struct gve_device_option_jumbo_frames {
0112     __be32 supported_features_mask;
0113     __be16 max_mtu;
0114     u8 padding[2];
0115 };
0116
0117 static_assert(sizeof(struct gve_device_option_jumbo_frames) == 8);
0118
0119 /* Terminology:
0120  *
0121  * RDA - Raw DMA Addressing - Buffers associated with SKBs are directly DMA
0122  *       mapped and read/updated by the device.
0123  *
0124  * QPL - Queue Page Lists - Driver uses bounce buffers which are DMA mapped with
0125  *       the device for read/write and data is copied from/to SKBs.
0126  */
0127 enum gve_dev_opt_id {
0128     GVE_DEV_OPT_ID_GQI_RAW_ADDRESSING = 0x1,
0129     GVE_DEV_OPT_ID_GQI_RDA = 0x2,
0130     GVE_DEV_OPT_ID_GQI_QPL = 0x3,
0131     GVE_DEV_OPT_ID_DQO_RDA = 0x4,
0132     GVE_DEV_OPT_ID_JUMBO_FRAMES = 0x8,
0133 };
0134
0135 enum gve_dev_opt_req_feat_mask {
0136     GVE_DEV_OPT_REQ_FEAT_MASK_GQI_RAW_ADDRESSING = 0x0,
0137     GVE_DEV_OPT_REQ_FEAT_MASK_GQI_RDA = 0x0,
0138     GVE_DEV_OPT_REQ_FEAT_MASK_GQI_QPL = 0x0,
0139     GVE_DEV_OPT_REQ_FEAT_MASK_DQO_RDA = 0x0,
0140     GVE_DEV_OPT_REQ_FEAT_MASK_JUMBO_FRAMES = 0x0,
0141 };
0142
0143 enum gve_sup_feature_mask {
0144     GVE_SUP_JUMBO_FRAMES_MASK = 1 << 2,
0145 };
0146
0147 #define GVE_DEV_OPT_LEN_GQI_RAW_ADDRESSING 0x0
0148
0149 struct gve_adminq_configure_device_resources {
0150     __be64 counter_array;
0151     __be64 irq_db_addr;
0152     __be32 num_counters;
0153     __be32 num_irq_dbs;
0154     __be32 irq_db_stride;
0155     __be32 ntfy_blk_msix_base_idx;
0156     u8 queue_format;
0157     u8 padding[7];
0158 };
0159
0160 static_assert(sizeof(struct gve_adminq_configure_device_resources) == 40);
0161
0162 struct gve_adminq_register_page_list {
0163     __be32 page_list_id;
0164     __be32 num_pages;
0165     __be64 page_address_list_addr;
0166 };
0167
0168 static_assert(sizeof(struct gve_adminq_register_page_list) == 16);
0169
0170 struct gve_adminq_unregister_page_list {
0171     __be32 page_list_id;
0172 };
0173
0174 static_assert(sizeof(struct gve_adminq_unregister_page_list) == 4);
0175
0176 #define GVE_RAW_ADDRESSING_QPL_ID 0xFFFFFFFF
0177
0178 struct gve_adminq_create_tx_queue {
0179     __be32 queue_id;
0180     __be32 reserved;
0181     __be64 queue_resources_addr;
0182     __be64 tx_ring_addr;
0183     __be32 queue_page_list_id;
0184     __be32 ntfy_id;
0185     __be64 tx_comp_ring_addr;
0186     __be16 tx_ring_size;
0187     __be16 tx_comp_ring_size;
0188     u8 padding[4];
0189 };
0190
0191 static_assert(sizeof(struct gve_adminq_create_tx_queue) == 48);
0192
0193 struct gve_adminq_create_rx_queue {
0194     __be32 queue_id;
0195     __be32 index;
0196     __be32 reserved;
0197     __be32 ntfy_id;
0198     __be64 queue_resources_addr;
0199     __be64 rx_desc_ring_addr;
0200     __be64 rx_data_ring_addr;
0201     __be32 queue_page_list_id;
0202     __be16 rx_ring_size;
0203     __be16 packet_buffer_size;
0204     __be16 rx_buff_ring_size;
0205     u8 enable_rsc;
0206     u8 padding[5];
0207 };
0208
0209 static_assert(sizeof(struct gve_adminq_create_rx_queue) == 56);
0210
0211 /* Queue resources that are shared with the device */
0212 struct gve_queue_resources {
0213     union {
0214         struct {
0215             __be32 db_index;    /* Device -> Guest */
0216             __be32 counter_index;   /* Device -> Guest */
0217         };
0218         u8 reserved[64];
0219     };
0220 };
0221
0222 static_assert(sizeof(struct gve_queue_resources) == 64);
0223
0224 struct gve_adminq_destroy_tx_queue {
0225     __be32 queue_id;
0226 };
0227
0228 static_assert(sizeof(struct gve_adminq_destroy_tx_queue) == 4);
0229
0230 struct gve_adminq_destroy_rx_queue {
0231     __be32 queue_id;
0232 };
0233
0234 static_assert(sizeof(struct gve_adminq_destroy_rx_queue) == 4);
0235
0236 /* GVE Set Driver Parameter Types */
0237 enum gve_set_driver_param_types {
0238     GVE_SET_PARAM_MTU   = 0x1,
0239 };
0240
0241 struct gve_adminq_set_driver_parameter {
0242     __be32 parameter_type;
0243     u8 reserved[4];
0244     __be64 parameter_value;
0245 };
0246
0247 static_assert(sizeof(struct gve_adminq_set_driver_parameter) == 16);
0248
0249 struct gve_adminq_report_stats {
0250     __be64 stats_report_len;
0251     __be64 stats_report_addr;
0252     __be64 interval;
0253 };
0254
0255 static_assert(sizeof(struct gve_adminq_report_stats) == 24);
0256
0257 struct gve_adminq_report_link_speed {
0258     __be64 link_speed_address;
0259 };
0260
0261 static_assert(sizeof(struct gve_adminq_report_link_speed) == 8);
0262
0263 struct stats {
0264     __be32 stat_name;
0265     __be32 queue_id;
0266     __be64 value;
0267 };
0268
0269 static_assert(sizeof(struct stats) == 16);
0270
0271 struct gve_stats_report {
0272     __be64 written_count;
0273     struct stats stats[];
0274 };
0275
0276 static_assert(sizeof(struct gve_stats_report) == 8);
0277
0278 enum gve_stat_names {
0279     // stats from gve
0280     TX_WAKE_CNT         = 1,
0281     TX_STOP_CNT         = 2,
0282     TX_FRAMES_SENT          = 3,
0283     TX_BYTES_SENT           = 4,
0284     TX_LAST_COMPLETION_PROCESSED    = 5,
0285     RX_NEXT_EXPECTED_SEQUENCE   = 6,
0286     RX_BUFFERS_POSTED       = 7,
0287     TX_TIMEOUT_CNT          = 8,
0288     // stats from NIC
0289     RX_QUEUE_DROP_CNT       = 65,
0290     RX_NO_BUFFERS_POSTED        = 66,
0291     RX_DROPS_PACKET_OVER_MRU    = 67,
0292     RX_DROPS_INVALID_CHECKSUM   = 68,
0293 };
0294
0295 enum gve_l3_type {
0296     /* Must be zero so zero initialized LUT is unknown. */
0297     GVE_L3_TYPE_UNKNOWN = 0,
0298     GVE_L3_TYPE_OTHER,
0299     GVE_L3_TYPE_IPV4,
0300     GVE_L3_TYPE_IPV6,
0301 };
0302
0303 enum gve_l4_type {
0304     /* Must be zero so zero initialized LUT is unknown. */
0305     GVE_L4_TYPE_UNKNOWN = 0,
0306     GVE_L4_TYPE_OTHER,
0307     GVE_L4_TYPE_TCP,
0308     GVE_L4_TYPE_UDP,
0309     GVE_L4_TYPE_ICMP,
0310     GVE_L4_TYPE_SCTP,
0311 };
0312
0313 /* These are control path types for PTYPE which are the same as the data path
0314  * types.
0315  */
0316 struct gve_ptype_entry {
0317     u8 l3_type;
0318     u8 l4_type;
0319 };
0320
0321 struct gve_ptype_map {
0322     struct gve_ptype_entry ptypes[1 << 10]; /* PTYPES are always 10 bits. */
0323 };
0324
0325 struct gve_adminq_get_ptype_map {
0326     __be64 ptype_map_len;
0327     __be64 ptype_map_addr;
0328 };
0329
0330 union gve_adminq_command {
0331     struct {
0332         __be32 opcode;
0333         __be32 status;
0334         union {
0335             struct gve_adminq_configure_device_resources
0336                         configure_device_resources;
0337             struct gve_adminq_create_tx_queue create_tx_queue;
0338             struct gve_adminq_create_rx_queue create_rx_queue;
0339             struct gve_adminq_destroy_tx_queue destroy_tx_queue;
0340             struct gve_adminq_destroy_rx_queue destroy_rx_queue;
0341             struct gve_adminq_describe_device describe_device;
0342             struct gve_adminq_register_page_list reg_page_list;
0343             struct gve_adminq_unregister_page_list unreg_page_list;
0344             struct gve_adminq_set_driver_parameter set_driver_param;
0345             struct gve_adminq_report_stats report_stats;
0346             struct gve_adminq_report_link_speed report_link_speed;
0347             struct gve_adminq_get_ptype_map get_ptype_map;
0348         };
0349     };
0350     u8 reserved[64];
0351 };
0352
0353 static_assert(sizeof(union gve_adminq_command) == 64);
0354
0355 int gve_adminq_alloc(struct device *dev, struct gve_priv *priv);
0356 void gve_adminq_free(struct device *dev, struct gve_priv *priv);
0357 void gve_adminq_release(struct gve_priv *priv);
0358 int gve_adminq_describe_device(struct gve_priv *priv);
0359 int gve_adminq_configure_device_resources(struct gve_priv *priv,
0360                       dma_addr_t counter_array_bus_addr,
0361                       u32 num_counters,
0362                       dma_addr_t db_array_bus_addr,
0363                       u32 num_ntfy_blks);
0364 int gve_adminq_deconfigure_device_resources(struct gve_priv *priv);
0365 int gve_adminq_create_tx_queues(struct gve_priv *priv, u32 num_queues);
0366 int gve_adminq_destroy_tx_queues(struct gve_priv *priv, u32 queue_id);
0367 int gve_adminq_create_rx_queues(struct gve_priv *priv, u32 num_queues);
0368 int gve_adminq_destroy_rx_queues(struct gve_priv *priv, u32 queue_id);
0369 int gve_adminq_register_page_list(struct gve_priv *priv,
0370                   struct gve_queue_page_list *qpl);
0371 int gve_adminq_unregister_page_list(struct gve_priv *priv, u32 page_list_id);
0372 int gve_adminq_set_mtu(struct gve_priv *priv, u64 mtu);
0373 int gve_adminq_report_stats(struct gve_priv *priv, u64 stats_report_len,
0374                 dma_addr_t stats_report_addr, u64 interval);
0375 int gve_adminq_report_link_speed(struct gve_priv *priv);
0376
0377 struct gve_ptype_lut;
0378 int gve_adminq_get_ptype_map_dqo(struct gve_priv *priv,
0379                  struct gve_ptype_lut *ptype_lut);
0380
0381 #endif /* _GVE_ADMINQ_H */