linux/drivers/net/ethernet/google/gve/gve_adminq.h
<<
>>
Prefs
   1/* SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2 * Google virtual Ethernet (gve) driver
   3 *
   4 * Copyright (C) 2015-2019 Google, Inc.
   5 */
   6
   7#ifndef _GVE_ADMINQ_H
   8#define _GVE_ADMINQ_H
   9
  10#include <linux/build_bug.h>
  11
  12/* Admin queue opcodes */
  13enum gve_adminq_opcodes {
  14        GVE_ADMINQ_DESCRIBE_DEVICE              = 0x1,
  15        GVE_ADMINQ_CONFIGURE_DEVICE_RESOURCES   = 0x2,
  16        GVE_ADMINQ_REGISTER_PAGE_LIST           = 0x3,
  17        GVE_ADMINQ_UNREGISTER_PAGE_LIST         = 0x4,
  18        GVE_ADMINQ_CREATE_TX_QUEUE              = 0x5,
  19        GVE_ADMINQ_CREATE_RX_QUEUE              = 0x6,
  20        GVE_ADMINQ_DESTROY_TX_QUEUE             = 0x7,
  21        GVE_ADMINQ_DESTROY_RX_QUEUE             = 0x8,
  22        GVE_ADMINQ_DECONFIGURE_DEVICE_RESOURCES = 0x9,
  23        GVE_ADMINQ_SET_DRIVER_PARAMETER         = 0xB,
  24};
  25
  26/* Admin queue status codes */
  27enum gve_adminq_statuses {
  28        GVE_ADMINQ_COMMAND_UNSET                        = 0x0,
  29        GVE_ADMINQ_COMMAND_PASSED                       = 0x1,
  30        GVE_ADMINQ_COMMAND_ERROR_ABORTED                = 0xFFFFFFF0,
  31        GVE_ADMINQ_COMMAND_ERROR_ALREADY_EXISTS         = 0xFFFFFFF1,
  32        GVE_ADMINQ_COMMAND_ERROR_CANCELLED              = 0xFFFFFFF2,
  33        GVE_ADMINQ_COMMAND_ERROR_DATALOSS               = 0xFFFFFFF3,
  34        GVE_ADMINQ_COMMAND_ERROR_DEADLINE_EXCEEDED      = 0xFFFFFFF4,
  35        GVE_ADMINQ_COMMAND_ERROR_FAILED_PRECONDITION    = 0xFFFFFFF5,
  36        GVE_ADMINQ_COMMAND_ERROR_INTERNAL_ERROR         = 0xFFFFFFF6,
  37        GVE_ADMINQ_COMMAND_ERROR_INVALID_ARGUMENT       = 0xFFFFFFF7,
  38        GVE_ADMINQ_COMMAND_ERROR_NOT_FOUND              = 0xFFFFFFF8,
  39        GVE_ADMINQ_COMMAND_ERROR_OUT_OF_RANGE           = 0xFFFFFFF9,
  40        GVE_ADMINQ_COMMAND_ERROR_PERMISSION_DENIED      = 0xFFFFFFFA,
  41        GVE_ADMINQ_COMMAND_ERROR_UNAUTHENTICATED        = 0xFFFFFFFB,
  42        GVE_ADMINQ_COMMAND_ERROR_RESOURCE_EXHAUSTED     = 0xFFFFFFFC,
  43        GVE_ADMINQ_COMMAND_ERROR_UNAVAILABLE            = 0xFFFFFFFD,
  44        GVE_ADMINQ_COMMAND_ERROR_UNIMPLEMENTED          = 0xFFFFFFFE,
  45        GVE_ADMINQ_COMMAND_ERROR_UNKNOWN_ERROR          = 0xFFFFFFFF,
  46};
  47
  48#define GVE_ADMINQ_DEVICE_DESCRIPTOR_VERSION 1
  49
  50/* All AdminQ command structs should be naturally packed. The static_assert
  51 * calls make sure this is the case at compile time.
  52 */
  53
  54struct gve_adminq_describe_device {
  55        __be64 device_descriptor_addr;
  56        __be32 device_descriptor_version;
  57        __be32 available_length;
  58};
  59
  60static_assert(sizeof(struct gve_adminq_describe_device) == 16);
  61
  62struct gve_device_descriptor {
  63        __be64 max_registered_pages;
  64        __be16 reserved1;
  65        __be16 tx_queue_entries;
  66        __be16 rx_queue_entries;
  67        __be16 default_num_queues;
  68        __be16 mtu;
  69        __be16 counters;
  70        __be16 tx_pages_per_qpl;
  71        __be16 rx_pages_per_qpl;
  72        u8  mac[ETH_ALEN];
  73        __be16 num_device_options;
  74        __be16 total_length;
  75        u8  reserved2[6];
  76};
  77
  78static_assert(sizeof(struct gve_device_descriptor) == 40);
  79
  80struct device_option {
  81        __be32 option_id;
  82        __be32 option_length;
  83};
  84
  85static_assert(sizeof(struct device_option) == 8);
  86
  87struct gve_adminq_configure_device_resources {
  88        __be64 counter_array;
  89        __be64 irq_db_addr;
  90        __be32 num_counters;
  91        __be32 num_irq_dbs;
  92        __be32 irq_db_stride;
  93        __be32 ntfy_blk_msix_base_idx;
  94};
  95
  96static_assert(sizeof(struct gve_adminq_configure_device_resources) == 32);
  97
  98struct gve_adminq_register_page_list {
  99        __be32 page_list_id;
 100        __be32 num_pages;
 101        __be64 page_address_list_addr;
 102};
 103
 104static_assert(sizeof(struct gve_adminq_register_page_list) == 16);
 105
 106struct gve_adminq_unregister_page_list {
 107        __be32 page_list_id;
 108};
 109
 110static_assert(sizeof(struct gve_adminq_unregister_page_list) == 4);
 111
 112struct gve_adminq_create_tx_queue {
 113        __be32 queue_id;
 114        __be32 reserved;
 115        __be64 queue_resources_addr;
 116        __be64 tx_ring_addr;
 117        __be32 queue_page_list_id;
 118        __be32 ntfy_id;
 119};
 120
 121static_assert(sizeof(struct gve_adminq_create_tx_queue) == 32);
 122
 123struct gve_adminq_create_rx_queue {
 124        __be32 queue_id;
 125        __be32 index;
 126        __be32 reserved;
 127        __be32 ntfy_id;
 128        __be64 queue_resources_addr;
 129        __be64 rx_desc_ring_addr;
 130        __be64 rx_data_ring_addr;
 131        __be32 queue_page_list_id;
 132        u8 padding[4];
 133};
 134
 135static_assert(sizeof(struct gve_adminq_create_rx_queue) == 48);
 136
 137/* Queue resources that are shared with the device */
 138struct gve_queue_resources {
 139        union {
 140                struct {
 141                        __be32 db_index;        /* Device -> Guest */
 142                        __be32 counter_index;   /* Device -> Guest */
 143                };
 144                u8 reserved[64];
 145        };
 146};
 147
 148static_assert(sizeof(struct gve_queue_resources) == 64);
 149
 150struct gve_adminq_destroy_tx_queue {
 151        __be32 queue_id;
 152};
 153
 154static_assert(sizeof(struct gve_adminq_destroy_tx_queue) == 4);
 155
 156struct gve_adminq_destroy_rx_queue {
 157        __be32 queue_id;
 158};
 159
 160static_assert(sizeof(struct gve_adminq_destroy_rx_queue) == 4);
 161
 162/* GVE Set Driver Parameter Types */
 163enum gve_set_driver_param_types {
 164        GVE_SET_PARAM_MTU       = 0x1,
 165};
 166
 167struct gve_adminq_set_driver_parameter {
 168        __be32 parameter_type;
 169        u8 reserved[4];
 170        __be64 parameter_value;
 171};
 172
 173static_assert(sizeof(struct gve_adminq_set_driver_parameter) == 16);
 174
 175union gve_adminq_command {
 176        struct {
 177                __be32 opcode;
 178                __be32 status;
 179                union {
 180                        struct gve_adminq_configure_device_resources
 181                                                configure_device_resources;
 182                        struct gve_adminq_create_tx_queue create_tx_queue;
 183                        struct gve_adminq_create_rx_queue create_rx_queue;
 184                        struct gve_adminq_destroy_tx_queue destroy_tx_queue;
 185                        struct gve_adminq_destroy_rx_queue destroy_rx_queue;
 186                        struct gve_adminq_describe_device describe_device;
 187                        struct gve_adminq_register_page_list reg_page_list;
 188                        struct gve_adminq_unregister_page_list unreg_page_list;
 189                        struct gve_adminq_set_driver_parameter set_driver_param;
 190                };
 191        };
 192        u8 reserved[64];
 193};
 194
 195static_assert(sizeof(union gve_adminq_command) == 64);
 196
 197int gve_adminq_alloc(struct device *dev, struct gve_priv *priv);
 198void gve_adminq_free(struct device *dev, struct gve_priv *priv);
 199void gve_adminq_release(struct gve_priv *priv);
 200int gve_adminq_execute_cmd(struct gve_priv *priv,
 201                           union gve_adminq_command *cmd_orig);
 202int gve_adminq_describe_device(struct gve_priv *priv);
 203int gve_adminq_configure_device_resources(struct gve_priv *priv,
 204                                          dma_addr_t counter_array_bus_addr,
 205                                          u32 num_counters,
 206                                          dma_addr_t db_array_bus_addr,
 207                                          u32 num_ntfy_blks);
 208int gve_adminq_deconfigure_device_resources(struct gve_priv *priv);
 209int gve_adminq_create_tx_queue(struct gve_priv *priv, u32 queue_id);
 210int gve_adminq_destroy_tx_queue(struct gve_priv *priv, u32 queue_id);
 211int gve_adminq_create_rx_queue(struct gve_priv *priv, u32 queue_id);
 212int gve_adminq_destroy_rx_queue(struct gve_priv *priv, u32 queue_id);
 213int gve_adminq_register_page_list(struct gve_priv *priv,
 214                                  struct gve_queue_page_list *qpl);
 215int gve_adminq_unregister_page_list(struct gve_priv *priv, u32 page_list_id);
 216int gve_adminq_set_mtu(struct gve_priv *priv, u64 mtu);
 217#endif /* _GVE_ADMINQ_H */
 218