sys/dev/ixl/virtchnl.h

   1 /******************************************************************************
   2
   3   Copyright (c) 2013-2018, Intel Corporation
   4   All rights reserved.
   5
   6   Redistribution and use in source and binary forms, with or without
   7   modification, are permitted provided that the following conditions are met:
   8
   9    1. Redistributions of source code must retain the above copyright notice,
  10       this list of conditions and the following disclaimer.
  11
  12    2. Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in the
  14       documentation and/or other materials provided with the distribution.
  15
  16    3. Neither the name of the Intel Corporation nor the names of its
  17       contributors may be used to endorse or promote products derived from
  18       this software without specific prior written permission.
  19
  20   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30   POSSIBILITY OF SUCH DAMAGE.
  31
  32 ******************************************************************************/
  33 /*$FreeBSD$*/
  34
  35 #ifndef _VIRTCHNL_H_
  36 #define _VIRTCHNL_H_
  37
  38 /* Description:
  39  * This header file describes the VF-PF communication protocol used
  40  * by the drivers for all devices starting from our 40G product line
  41  *
  42  * Admin queue buffer usage:
  43  * desc->opcode is always aqc_opc_send_msg_to_pf
  44  * flags, retval, datalen, and data addr are all used normally.
  45  * The Firmware copies the cookie fields when sending messages between the
  46  * PF and VF, but uses all other fields internally. Due to this limitation,
  47  * we must send all messages as "indirect", i.e. using an external buffer.
  48  *
  49  * All the VSI indexes are relative to the VF. Each VF can have maximum of
  50  * three VSIs. All the queue indexes are relative to the VSI.  Each VF can
  51  * have a maximum of sixteen queues for all of its VSIs.
  52  *
  53  * The PF is required to return a status code in v_retval for all messages
  54  * except RESET_VF, which does not require any response. The return value
  55  * is of status_code type, defined in the shared type.h.
  56  *
  57  * In general, VF driver initialization should roughly follow the order of
  58  * these opcodes. The VF driver must first validate the API version of the
  59  * PF driver, then request a reset, then get resources, then configure
  60  * queues and interrupts. After these operations are complete, the VF
  61  * driver may start its queues, optionally add MAC and VLAN filters, and
  62  * process traffic.
  63  */
  64
  65 /* START GENERIC DEFINES
  66  * Need to ensure the following enums and defines hold the same meaning and
  67  * value in current and future projects
  68  */
  69
  70 /* Error Codes */
  71 enum virtchnl_status_code {
  72         VIRTCHNL_STATUS_SUCCESS                         = 0,
  73         VIRTCHNL_ERR_PARAM                              = -5,
  74         VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH             = -38,
  75         VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR             = -39,
  76         VIRTCHNL_STATUS_ERR_INVALID_VF_ID               = -40,
  77         VIRTCHNL_STATUS_NOT_SUPPORTED                   = -64,
  78 };
  79
  80 #define VIRTCHNL_LINK_SPEED_100MB_SHIFT         0x1
  81 #define VIRTCHNL_LINK_SPEED_1000MB_SHIFT        0x2
  82 #define VIRTCHNL_LINK_SPEED_10GB_SHIFT          0x3
  83 #define VIRTCHNL_LINK_SPEED_40GB_SHIFT          0x4
  84 #define VIRTCHNL_LINK_SPEED_20GB_SHIFT          0x5
  85 #define VIRTCHNL_LINK_SPEED_25GB_SHIFT          0x6
  86
  87 enum virtchnl_link_speed {
  88         VIRTCHNL_LINK_SPEED_UNKNOWN     = 0,
  89         VIRTCHNL_LINK_SPEED_100MB       = BIT(VIRTCHNL_LINK_SPEED_100MB_SHIFT),
  90         VIRTCHNL_LINK_SPEED_1GB         = BIT(VIRTCHNL_LINK_SPEED_1000MB_SHIFT),
  91         VIRTCHNL_LINK_SPEED_10GB        = BIT(VIRTCHNL_LINK_SPEED_10GB_SHIFT),
  92         VIRTCHNL_LINK_SPEED_40GB        = BIT(VIRTCHNL_LINK_SPEED_40GB_SHIFT),
  93         VIRTCHNL_LINK_SPEED_20GB        = BIT(VIRTCHNL_LINK_SPEED_20GB_SHIFT),
  94         VIRTCHNL_LINK_SPEED_25GB        = BIT(VIRTCHNL_LINK_SPEED_25GB_SHIFT),
  95 };
  96
  97 /* for hsplit_0 field of Rx HMC context */
  98 /* deprecated with AVF 1.0 */
  99 enum virtchnl_rx_hsplit {
 100         VIRTCHNL_RX_HSPLIT_NO_SPLIT      = 0,
 101         VIRTCHNL_RX_HSPLIT_SPLIT_L2      = 1,
 102         VIRTCHNL_RX_HSPLIT_SPLIT_IP      = 2,
 103         VIRTCHNL_RX_HSPLIT_SPLIT_TCP_UDP = 4,
 104         VIRTCHNL_RX_HSPLIT_SPLIT_SCTP    = 8,
 105 };
 106
 107 #define VIRTCHNL_ETH_LENGTH_OF_ADDRESS  6
 108 /* END GENERIC DEFINES */
 109
 110 /* Opcodes for VF-PF communication. These are placed in the v_opcode field
 111  * of the virtchnl_msg structure.
 112  */
 113 enum virtchnl_ops {
 114 /* The PF sends status change events to VFs using
 115  * the VIRTCHNL_OP_EVENT opcode.
 116  * VFs send requests to the PF using the other ops.
 117  * Use of "advanced opcode" features must be negotiated as part of capabilities
 118  * exchange and are not considered part of base mode feature set.
 119  */
 120         VIRTCHNL_OP_UNKNOWN = 0,
 121         VIRTCHNL_OP_VERSION = 1, /* must ALWAYS be 1 */
 122         VIRTCHNL_OP_RESET_VF = 2,
 123         VIRTCHNL_OP_GET_VF_RESOURCES = 3,
 124         VIRTCHNL_OP_CONFIG_TX_QUEUE = 4,
 125         VIRTCHNL_OP_CONFIG_RX_QUEUE = 5,
 126         VIRTCHNL_OP_CONFIG_VSI_QUEUES = 6,
 127         VIRTCHNL_OP_CONFIG_IRQ_MAP = 7,
 128         VIRTCHNL_OP_ENABLE_QUEUES = 8,
 129         VIRTCHNL_OP_DISABLE_QUEUES = 9,
 130         VIRTCHNL_OP_ADD_ETH_ADDR = 10,
 131         VIRTCHNL_OP_DEL_ETH_ADDR = 11,
 132         VIRTCHNL_OP_ADD_VLAN = 12,
 133         VIRTCHNL_OP_DEL_VLAN = 13,
 134         VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE = 14,
 135         VIRTCHNL_OP_GET_STATS = 15,
 136         VIRTCHNL_OP_RSVD = 16,
 137         VIRTCHNL_OP_EVENT = 17, /* must ALWAYS be 17 */
 138         VIRTCHNL_OP_IWARP = 20, /* advanced opcode */
 139         VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP = 21, /* advanced opcode */
 140         VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP = 22, /* advanced opcode */
 141         VIRTCHNL_OP_CONFIG_RSS_KEY = 23,
 142         VIRTCHNL_OP_CONFIG_RSS_LUT = 24,
 143         VIRTCHNL_OP_GET_RSS_HENA_CAPS = 25,
 144         VIRTCHNL_OP_SET_RSS_HENA = 26,
 145         VIRTCHNL_OP_ENABLE_VLAN_STRIPPING = 27,
 146         VIRTCHNL_OP_DISABLE_VLAN_STRIPPING = 28,
 147         VIRTCHNL_OP_REQUEST_QUEUES = 29,
 148
 149 };
 150
 151 /* This macro is used to generate a compilation error if a structure
 152  * is not exactly the correct length. It gives a divide by zero error if the
 153  * structure is not of the correct size, otherwise it creates an enum that is
 154  * never used.
 155  */
 156 #define VIRTCHNL_CHECK_STRUCT_LEN(n, X) enum virtchnl_static_assert_enum_##X \
 157         {virtchnl_static_assert_##X = (n) / ((sizeof(struct X) == (n)) ? 1 : 0)}
 158
 159 /* Virtual channel message descriptor. This overlays the admin queue
 160  * descriptor. All other data is passed in external buffers.
 161  */
 162
 163 struct virtchnl_msg {
 164         u8 pad[8];                       /* AQ flags/opcode/len/retval fields */
 165         enum virtchnl_ops v_opcode; /* avoid confusion with desc->opcode */
 166         enum virtchnl_status_code v_retval;  /* ditto for desc->retval */
 167         u32 vfid;                        /* used by PF when sending to VF */
 168 };
 169
 170 VIRTCHNL_CHECK_STRUCT_LEN(20, virtchnl_msg);
 171
 172 /* Message descriptions and data structures.*/
 173
 174 /* VIRTCHNL_OP_VERSION
 175  * VF posts its version number to the PF. PF responds with its version number
 176  * in the same format, along with a return code.
 177  * Reply from PF has its major/minor versions also in param0 and param1.
 178  * If there is a major version mismatch, then the VF cannot operate.
 179  * If there is a minor version mismatch, then the VF can operate but should
 180  * add a warning to the system log.
 181  *
 182  * This enum element MUST always be specified as == 1, regardless of other
 183  * changes in the API. The PF must always respond to this message without
 184  * error regardless of version mismatch.
 185  */
 186 #define VIRTCHNL_VERSION_MAJOR          1
 187 #define VIRTCHNL_VERSION_MINOR          1
 188 #define VIRTCHNL_VERSION_MINOR_NO_VF_CAPS       0
 189
 190 struct virtchnl_version_info {
 191         u32 major;
 192         u32 minor;
 193 };
 194
 195 VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_version_info);
 196
 197 #define VF_IS_V10(_v) (((_v)->major == 1) && ((_v)->minor == 0))
 198 #define VF_IS_V11(_ver) (((_ver)->major == 1) && ((_ver)->minor == 1))
 199
 200 /* VIRTCHNL_OP_RESET_VF
 201  * VF sends this request to PF with no parameters
 202  * PF does NOT respond! VF driver must delay then poll VFGEN_RSTAT register
 203  * until reset completion is indicated. The admin queue must be reinitialized
 204  * after this operation.
 205  *
 206  * When reset is complete, PF must ensure that all queues in all VSIs associated
 207  * with the VF are stopped, all queue configurations in the HMC are set to 0,
 208  * and all MAC and VLAN filters (except the default MAC address) on all VSIs
 209  * are cleared.
 210  */
 211
 212 /* VSI types that use VIRTCHNL interface for VF-PF communication. VSI_SRIOV
 213  * vsi_type should always be 6 for backward compatibility. Add other fields
 214  * as needed.
 215  */
 216 enum virtchnl_vsi_type {
 217         VIRTCHNL_VSI_TYPE_INVALID = 0,
 218         VIRTCHNL_VSI_SRIOV = 6,
 219 };
 220
 221 /* VIRTCHNL_OP_GET_VF_RESOURCES
 222  * Version 1.0 VF sends this request to PF with no parameters
 223  * Version 1.1 VF sends this request to PF with u32 bitmap of its capabilities
 224  * PF responds with an indirect message containing
 225  * virtchnl_vf_resource and one or more
 226  * virtchnl_vsi_resource structures.
 227  */
 228
 229 struct virtchnl_vsi_resource {
 230         u16 vsi_id;
 231         u16 num_queue_pairs;
 232         enum virtchnl_vsi_type vsi_type;
 233         u16 qset_handle;
 234         u8 default_mac_addr[VIRTCHNL_ETH_LENGTH_OF_ADDRESS];
 235 };
 236
 237 VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vsi_resource);
 238
 239 /* VF capability flags
 240  * VIRTCHNL_VF_OFFLOAD_L2 flag is inclusive of base mode L2 offloads including
 241  * TX/RX Checksum offloading and TSO for non-tunnelled packets.
 242  */
 243 #define VIRTCHNL_VF_OFFLOAD_L2                  0x00000001
 244 #define VIRTCHNL_VF_OFFLOAD_IWARP               0x00000002
 245 #define VIRTCHNL_VF_OFFLOAD_RSVD                0x00000004
 246 #define VIRTCHNL_VF_OFFLOAD_RSS_AQ              0x00000008
 247 #define VIRTCHNL_VF_OFFLOAD_RSS_REG             0x00000010
 248 #define VIRTCHNL_VF_OFFLOAD_WB_ON_ITR           0x00000020
 249 #define VIRTCHNL_VF_OFFLOAD_REQ_QUEUES          0x00000040
 250 #define VIRTCHNL_VF_OFFLOAD_VLAN                0x00010000
 251 #define VIRTCHNL_VF_OFFLOAD_RX_POLLING          0x00020000
 252 #define VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2       0x00040000
 253 #define VIRTCHNL_VF_OFFLOAD_RSS_PF              0X00080000
 254 #define VIRTCHNL_VF_OFFLOAD_ENCAP               0X00100000
 255 #define VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM          0X00200000
 256 #define VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM       0X00400000
 257
 258 #define VF_BASE_MODE_OFFLOADS (VIRTCHNL_VF_OFFLOAD_L2 | \
 259                                VIRTCHNL_VF_OFFLOAD_VLAN | \
 260                                VIRTCHNL_VF_OFFLOAD_RSS_PF)
 261
 262 struct virtchnl_vf_resource {
 263         u16 num_vsis;
 264         u16 num_queue_pairs;
 265         u16 max_vectors;
 266         u16 max_mtu;
 267
 268         u32 vf_cap_flags;
 269         u32 rss_key_size;
 270         u32 rss_lut_size;
 271
 272         struct virtchnl_vsi_resource vsi_res[1];
 273 };
 274
 275 VIRTCHNL_CHECK_STRUCT_LEN(36, virtchnl_vf_resource);
 276
 277 /* VIRTCHNL_OP_CONFIG_TX_QUEUE
 278  * VF sends this message to set up parameters for one TX queue.
 279  * External data buffer contains one instance of virtchnl_txq_info.
 280  * PF configures requested queue and returns a status code.
 281  */
 282
 283 /* Tx queue config info */
 284 struct virtchnl_txq_info {
 285         u16 vsi_id;
 286         u16 queue_id;
 287         u16 ring_len;           /* number of descriptors, multiple of 8 */
 288         u16 headwb_enabled; /* deprecated with AVF 1.0 */
 289         u64 dma_ring_addr;
 290         u64 dma_headwb_addr; /* deprecated with AVF 1.0 */
 291 };
 292
 293 VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_txq_info);
 294
 295 /* VIRTCHNL_OP_CONFIG_RX_QUEUE
 296  * VF sends this message to set up parameters for one RX queue.
 297  * External data buffer contains one instance of virtchnl_rxq_info.
 298  * PF configures requested queue and returns a status code.
 299  */
 300
 301 /* Rx queue config info */
 302 struct virtchnl_rxq_info {
 303         u16 vsi_id;
 304         u16 queue_id;
 305         u32 ring_len;           /* number of descriptors, multiple of 32 */
 306         u16 hdr_size;
 307         u16 splithdr_enabled; /* deprecated with AVF 1.0 */
 308         u32 databuffer_size;
 309         u32 max_pkt_size;
 310         u32 pad1;
 311         u64 dma_ring_addr;
 312         enum virtchnl_rx_hsplit rx_split_pos; /* deprecated with AVF 1.0 */
 313         u32 pad2;
 314 };
 315
 316 VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_rxq_info);
 317
 318 /* VIRTCHNL_OP_CONFIG_VSI_QUEUES
 319  * VF sends this message to set parameters for all active TX and RX queues
 320  * associated with the specified VSI.
 321  * PF configures queues and returns status.
 322  * If the number of queues specified is greater than the number of queues
 323  * associated with the VSI, an error is returned and no queues are configured.
 324  */
 325 struct virtchnl_queue_pair_info {
 326         /* NOTE: vsi_id and queue_id should be identical for both queues. */
 327         struct virtchnl_txq_info txq;
 328         struct virtchnl_rxq_info rxq;
 329 };
 330
 331 VIRTCHNL_CHECK_STRUCT_LEN(64, virtchnl_queue_pair_info);
 332
 333 struct virtchnl_vsi_queue_config_info {
 334         u16 vsi_id;
 335         u16 num_queue_pairs;
 336         u32 pad;
 337         struct virtchnl_queue_pair_info qpair[1];
 338 };
 339
 340 VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_vsi_queue_config_info);
 341
 342 /* VIRTCHNL_OP_REQUEST_QUEUES
 343  * VF sends this message to request the PF to allocate additional queues to
 344  * this VF.  Each VF gets a guaranteed number of queues on init but asking for
 345  * additional queues must be negotiated.  This is a best effort request as it
 346  * is possible the PF does not have enough queues left to support the request.
 347  * If the PF cannot support the number requested it will respond with the
 348  * maximum number it is able to support; otherwise it will respond with the
 349  * number requested.
 350  */
 351
 352 /* VF resource request */
 353 struct virtchnl_vf_res_request {
 354         u16 num_queue_pairs;
 355 };
 356
 357 /* VIRTCHNL_OP_CONFIG_IRQ_MAP
 358  * VF uses this message to map vectors to queues.
 359  * The rxq_map and txq_map fields are bitmaps used to indicate which queues
 360  * are to be associated with the specified vector.
 361  * The "other" causes are always mapped to vector 0.
 362  * PF configures interrupt mapping and returns status.
 363  */
 364 struct virtchnl_vector_map {
 365         u16 vsi_id;
 366         u16 vector_id;
 367         u16 rxq_map;
 368         u16 txq_map;
 369         u16 rxitr_idx;
 370         u16 txitr_idx;
 371 };
 372
 373 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_vector_map);
 374
 375 struct virtchnl_irq_map_info {
 376         u16 num_vectors;
 377         struct virtchnl_vector_map vecmap[1];
 378 };
 379
 380 VIRTCHNL_CHECK_STRUCT_LEN(14, virtchnl_irq_map_info);
 381
 382 /* VIRTCHNL_OP_ENABLE_QUEUES
 383  * VIRTCHNL_OP_DISABLE_QUEUES
 384  * VF sends these message to enable or disable TX/RX queue pairs.
 385  * The queues fields are bitmaps indicating which queues to act upon.
 386  * (Currently, we only support 16 queues per VF, but we make the field
 387  * u32 to allow for expansion.)
 388  * PF performs requested action and returns status.
 389  */
 390 struct virtchnl_queue_select {
 391         u16 vsi_id;
 392         u16 pad;
 393         u32 rx_queues;
 394         u32 tx_queues;
 395 };
 396
 397 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_queue_select);
 398
 399 /* VIRTCHNL_OP_ADD_ETH_ADDR
 400  * VF sends this message in order to add one or more unicast or multicast
 401  * address filters for the specified VSI.
 402  * PF adds the filters and returns status.
 403  */
 404
 405 /* VIRTCHNL_OP_DEL_ETH_ADDR
 406  * VF sends this message in order to remove one or more unicast or multicast
 407  * filters for the specified VSI.
 408  * PF removes the filters and returns status.
 409  */
 410
 411 struct virtchnl_ether_addr {
 412         u8 addr[VIRTCHNL_ETH_LENGTH_OF_ADDRESS];
 413         u8 pad[2];
 414 };
 415
 416 VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_ether_addr);
 417
 418 struct virtchnl_ether_addr_list {
 419         u16 vsi_id;
 420         u16 num_elements;
 421         struct virtchnl_ether_addr list[1];
 422 };
 423
 424 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_ether_addr_list);
 425
 426 /* VIRTCHNL_OP_ADD_VLAN
 427  * VF sends this message to add one or more VLAN tag filters for receives.
 428  * PF adds the filters and returns status.
 429  * If a port VLAN is configured by the PF, this operation will return an
 430  * error to the VF.
 431  */
 432
 433 /* VIRTCHNL_OP_DEL_VLAN
 434  * VF sends this message to remove one or more VLAN tag filters for receives.
 435  * PF removes the filters and returns status.
 436  * If a port VLAN is configured by the PF, this operation will return an
 437  * error to the VF.
 438  */
 439
 440 struct virtchnl_vlan_filter_list {
 441         u16 vsi_id;
 442         u16 num_elements;
 443         u16 vlan_id[1];
 444 };
 445
 446 VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_vlan_filter_list);
 447
 448 /* VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE
 449  * VF sends VSI id and flags.
 450  * PF returns status code in retval.
 451  * Note: we assume that broadcast accept mode is always enabled.
 452  */
 453 struct virtchnl_promisc_info {
 454         u16 vsi_id;
 455         u16 flags;
 456 };
 457
 458 VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_promisc_info);
 459
 460 #define FLAG_VF_UNICAST_PROMISC 0x00000001
 461 #define FLAG_VF_MULTICAST_PROMISC       0x00000002
 462
 463 /* VIRTCHNL_OP_GET_STATS
 464  * VF sends this message to request stats for the selected VSI. VF uses
 465  * the virtchnl_queue_select struct to specify the VSI. The queue_id
 466  * field is ignored by the PF.
 467  *
 468  * PF replies with struct eth_stats in an external buffer.
 469  */
 470
 471 /* VIRTCHNL_OP_CONFIG_RSS_KEY
 472  * VIRTCHNL_OP_CONFIG_RSS_LUT
 473  * VF sends these messages to configure RSS. Only supported if both PF
 474  * and VF drivers set the VIRTCHNL_VF_OFFLOAD_RSS_PF bit during
 475  * configuration negotiation. If this is the case, then the RSS fields in
 476  * the VF resource struct are valid.
 477  * Both the key and LUT are initialized to 0 by the PF, meaning that
 478  * RSS is effectively disabled until set up by the VF.
 479  */
 480 struct virtchnl_rss_key {
 481         u16 vsi_id;
 482         u16 key_len;
 483         u8 key[1];         /* RSS hash key, packed bytes */
 484 };
 485
 486 VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_rss_key);
 487
 488 struct virtchnl_rss_lut {
 489         u16 vsi_id;
 490         u16 lut_entries;
 491         u8 lut[1];        /* RSS lookup table */
 492 };
 493
 494 VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_rss_lut);
 495
 496 /* VIRTCHNL_OP_GET_RSS_HENA_CAPS
 497  * VIRTCHNL_OP_SET_RSS_HENA
 498  * VF sends these messages to get and set the hash filter enable bits for RSS.
 499  * By default, the PF sets these to all possible traffic types that the
 500  * hardware supports. The VF can query this value if it wants to change the
 501  * traffic types that are hashed by the hardware.
 502  */
 503 struct virtchnl_rss_hena {
 504         u64 hena;
 505 };
 506
 507 VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_rss_hena);
 508
 509 /* VIRTCHNL_OP_EVENT
 510  * PF sends this message to inform the VF driver of events that may affect it.
 511  * No direct response is expected from the VF, though it may generate other
 512  * messages in response to this one.
 513  */
 514 enum virtchnl_event_codes {
 515         VIRTCHNL_EVENT_UNKNOWN = 0,
 516         VIRTCHNL_EVENT_LINK_CHANGE,
 517         VIRTCHNL_EVENT_RESET_IMPENDING,
 518         VIRTCHNL_EVENT_PF_DRIVER_CLOSE,
 519 };
 520
 521 #define PF_EVENT_SEVERITY_INFO          0
 522 #define PF_EVENT_SEVERITY_ATTENTION     1
 523 #define PF_EVENT_SEVERITY_ACTION_REQUIRED       2
 524 #define PF_EVENT_SEVERITY_CERTAIN_DOOM  255
 525
 526 struct virtchnl_pf_event {
 527         enum virtchnl_event_codes event;
 528         union {
 529                 struct {
 530                         enum virtchnl_link_speed link_speed;
 531                         bool link_status;
 532                 } link_event;
 533         } event_data;
 534
 535         int severity;
 536 };
 537
 538 VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_pf_event);
 539
 540
 541 /* VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP
 542  * VF uses this message to request PF to map IWARP vectors to IWARP queues.
 543  * The request for this originates from the VF IWARP driver through
 544  * a client interface between VF LAN and VF IWARP driver.
 545  * A vector could have an AEQ and CEQ attached to it although
 546  * there is a single AEQ per VF IWARP instance in which case
 547  * most vectors will have an INVALID_IDX for aeq and valid idx for ceq.
 548  * There will never be a case where there will be multiple CEQs attached
 549  * to a single vector.
 550  * PF configures interrupt mapping and returns status.
 551  */
 552
 553 /* HW does not define a type value for AEQ; only for RX/TX and CEQ.
 554  * In order for us to keep the interface simple, SW will define a
 555  * unique type value for AEQ.
 556  */
 557 #define QUEUE_TYPE_PE_AEQ  0x80
 558 #define QUEUE_INVALID_IDX  0xFFFF
 559
 560 struct virtchnl_iwarp_qv_info {
 561         u32 v_idx; /* msix_vector */
 562         u16 ceq_idx;
 563         u16 aeq_idx;
 564         u8 itr_idx;
 565 };
 566
 567 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_iwarp_qv_info);
 568
 569 struct virtchnl_iwarp_qvlist_info {
 570         u32 num_vectors;
 571         struct virtchnl_iwarp_qv_info qv_info[1];
 572 };
 573
 574 VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_iwarp_qvlist_info);
 575
 576
 577 /* VF reset states - these are written into the RSTAT register:
 578  * VFGEN_RSTAT on the VF
 579  * When the PF initiates a reset, it writes 0
 580  * When the reset is complete, it writes 1
 581  * When the PF detects that the VF has recovered, it writes 2
 582  * VF checks this register periodically to determine if a reset has occurred,
 583  * then polls it to know when the reset is complete.
 584  * If either the PF or VF reads the register while the hardware
 585  * is in a reset state, it will return DEADBEEF, which, when masked
 586  * will result in 3.
 587  */
 588 enum virtchnl_vfr_states {
 589         VIRTCHNL_VFR_INPROGRESS = 0,
 590         VIRTCHNL_VFR_COMPLETED,
 591         VIRTCHNL_VFR_VFACTIVE,
 592 };
 593
 594 /**
 595  * virtchnl_vc_validate_vf_msg
 596  * @ver: Virtchnl version info
 597  * @v_opcode: Opcode for the message
 598  * @msg: pointer to the msg buffer
 599  * @msglen: msg length
 600  *
 601  * validate msg format against struct for each opcode
 602  */
 603 static inline int
 604 virtchnl_vc_validate_vf_msg(struct virtchnl_version_info *ver, u32 v_opcode,
 605                             u8 *msg, u16 msglen)
 606 {
 607         bool err_msg_format = FALSE;
 608         int valid_len = 0;
 609
 610         /* Validate message length. */
 611         switch (v_opcode) {
 612         case VIRTCHNL_OP_VERSION:
 613                 valid_len = sizeof(struct virtchnl_version_info);
 614                 break;
 615         case VIRTCHNL_OP_RESET_VF:
 616                 break;
 617         case VIRTCHNL_OP_GET_VF_RESOURCES:
 618                 if (VF_IS_V11(ver))
 619                         valid_len = sizeof(u32);
 620                 break;
 621         case VIRTCHNL_OP_CONFIG_TX_QUEUE:
 622                 valid_len = sizeof(struct virtchnl_txq_info);
 623                 break;
 624         case VIRTCHNL_OP_CONFIG_RX_QUEUE:
 625                 valid_len = sizeof(struct virtchnl_rxq_info);
 626                 break;
 627         case VIRTCHNL_OP_CONFIG_VSI_QUEUES:
 628                 valid_len = sizeof(struct virtchnl_vsi_queue_config_info);
 629                 if (msglen >= valid_len) {
 630                         struct virtchnl_vsi_queue_config_info *vqc =
 631                             (struct virtchnl_vsi_queue_config_info *)msg;
 632                         valid_len += (vqc->num_queue_pairs *
 633                                       sizeof(struct
 634                                              virtchnl_queue_pair_info));
 635                         if (vqc->num_queue_pairs == 0)
 636                                 err_msg_format = TRUE;
 637                 }
 638                 break;
 639         case VIRTCHNL_OP_CONFIG_IRQ_MAP:
 640                 valid_len = sizeof(struct virtchnl_irq_map_info);
 641                 if (msglen >= valid_len) {
 642                         struct virtchnl_irq_map_info *vimi =
 643                             (struct virtchnl_irq_map_info *)msg;
 644                         valid_len += (vimi->num_vectors *
 645                                       sizeof(struct virtchnl_vector_map));
 646                         if (vimi->num_vectors == 0)
 647                                 err_msg_format = TRUE;
 648                 }
 649                 break;
 650         case VIRTCHNL_OP_ENABLE_QUEUES:
 651         case VIRTCHNL_OP_DISABLE_QUEUES:
 652                 valid_len = sizeof(struct virtchnl_queue_select);
 653                 break;
 654         case VIRTCHNL_OP_ADD_ETH_ADDR:
 655         case VIRTCHNL_OP_DEL_ETH_ADDR:
 656                 valid_len = sizeof(struct virtchnl_ether_addr_list);
 657                 if (msglen >= valid_len) {
 658                         struct virtchnl_ether_addr_list *veal =
 659                             (struct virtchnl_ether_addr_list *)msg;
 660                         valid_len += veal->num_elements *
 661                             sizeof(struct virtchnl_ether_addr);
 662                         if (veal->num_elements == 0)
 663                                 err_msg_format = TRUE;
 664                 }
 665                 break;
 666         case VIRTCHNL_OP_ADD_VLAN:
 667         case VIRTCHNL_OP_DEL_VLAN:
 668                 valid_len = sizeof(struct virtchnl_vlan_filter_list);
 669                 if (msglen >= valid_len) {
 670                         struct virtchnl_vlan_filter_list *vfl =
 671                             (struct virtchnl_vlan_filter_list *)msg;
 672                         valid_len += vfl->num_elements * sizeof(u16);
 673                         if (vfl->num_elements == 0)
 674                                 err_msg_format = TRUE;
 675                 }
 676                 break;
 677         case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
 678                 valid_len = sizeof(struct virtchnl_promisc_info);
 679                 break;
 680         case VIRTCHNL_OP_GET_STATS:
 681                 valid_len = sizeof(struct virtchnl_queue_select);
 682                 break;
 683         case VIRTCHNL_OP_IWARP:
 684                 /* These messages are opaque to us and will be validated in
 685                  * the RDMA client code. We just need to check for nonzero
 686                  * length. The firmware will enforce max length restrictions.
 687                  */
 688                 if (msglen)
 689                         valid_len = msglen;
 690                 else
 691                         err_msg_format = TRUE;
 692                 break;
 693         case VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP:
 694                 break;
 695         case VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP:
 696                 valid_len = sizeof(struct virtchnl_iwarp_qvlist_info);
 697                 if (msglen >= valid_len) {
 698                         struct virtchnl_iwarp_qvlist_info *qv =
 699                                 (struct virtchnl_iwarp_qvlist_info *)msg;
 700                         if (qv->num_vectors == 0) {
 701                                 err_msg_format = TRUE;
 702                                 break;
 703                         }
 704                         valid_len += ((qv->num_vectors - 1) *
 705                                 sizeof(struct virtchnl_iwarp_qv_info));
 706                 }
 707                 break;
 708         case VIRTCHNL_OP_CONFIG_RSS_KEY:
 709                 valid_len = sizeof(struct virtchnl_rss_key);
 710                 if (msglen >= valid_len) {
 711                         struct virtchnl_rss_key *vrk =
 712                                 (struct virtchnl_rss_key *)msg;
 713                         valid_len += vrk->key_len - 1;
 714                 }
 715                 break;
 716         case VIRTCHNL_OP_CONFIG_RSS_LUT:
 717                 valid_len = sizeof(struct virtchnl_rss_lut);
 718                 if (msglen >= valid_len) {
 719                         struct virtchnl_rss_lut *vrl =
 720                                 (struct virtchnl_rss_lut *)msg;
 721                         valid_len += vrl->lut_entries - 1;
 722                 }
 723                 break;
 724         case VIRTCHNL_OP_GET_RSS_HENA_CAPS:
 725                 break;
 726         case VIRTCHNL_OP_SET_RSS_HENA:
 727                 valid_len = sizeof(struct virtchnl_rss_hena);
 728                 break;
 729         case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING:
 730         case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING:
 731                 break;
 732         case VIRTCHNL_OP_REQUEST_QUEUES:
 733                 valid_len = sizeof(struct virtchnl_vf_res_request);
 734                 break;
 735         /* These are always errors coming from the VF. */
 736         case VIRTCHNL_OP_EVENT:
 737         case VIRTCHNL_OP_UNKNOWN:
 738         default:
 739                 return VIRTCHNL_ERR_PARAM;
 740         }
 741         /* few more checks */
 742         if (err_msg_format || valid_len != msglen)
 743                 return VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH;
 744
 745         return 0;
 746 }
 747 #endif /* _VIRTCHNL_H_ */