From: "Zhang, Qi Z" <qi.z.zhang@intel.com>
To: "Qiao, Wenjing" <wenjing.qiao@intel.com>,
"Wu, Jingjing" <jingjing.wu@intel.com>,
"Xing, Beilei" <beilei.xing@intel.com>
Cc: "dev@dpdk.org" <dev@dpdk.org>
Subject: RE: [PATCH v2 01/15] common/idpf: remove virtchnl related shared code
Date: Mon, 24 Apr 2023 11:52:32 +0000 [thread overview]
Message-ID: <DM4PR11MB59949FD519EA20D891996C47D7679@DM4PR11MB5994.namprd11.prod.outlook.com> (raw)
In-Reply-To: <20230421084043.135503-2-wenjing.qiao@intel.com>
> -----Original Message-----
> From: Qiao, Wenjing <wenjing.qiao@intel.com>
> Sent: Friday, April 21, 2023 4:40 PM
> To: Wu, Jingjing <jingjing.wu@intel.com>; Xing, Beilei
> <beilei.xing@intel.com>; Zhang, Qi Z <qi.z.zhang@intel.com>
> Cc: dev@dpdk.org; Qiao, Wenjing <wenjing.qiao@intel.com>
> Subject: [PATCH v2 01/15] common/idpf: remove virtchnl related shared
> code
>
> Since virtchnl related shared code of iavf
> and idpf has the same sourse, so remove
> virtual related shared code of idpf.
We need to replace #include "virtchnl.h" with #include <virtchnl.h> as it is not expected to search the header file from current directly now.
>
> Signed-off-by: Wenjing Qiao <wenjing.qiao@intel.com>
> ---
> drivers/common/idpf/base/virtchnl.h | 2866 -----------------
> .../common/idpf/base/virtchnl_inline_ipsec.h | 567 ----
> drivers/common/idpf/meson.build | 2 +
> 3 files changed, 2 insertions(+), 3433 deletions(-)
> delete mode 100644 drivers/common/idpf/base/virtchnl.h
> delete mode 100644 drivers/common/idpf/base/virtchnl_inline_ipsec.h
>
> diff --git a/drivers/common/idpf/base/virtchnl.h
> b/drivers/common/idpf/base/virtchnl.h
> deleted file mode 100644
> index ea798e3971..0000000000
> --- a/drivers/common/idpf/base/virtchnl.h
> +++ /dev/null
> @@ -1,2866 +0,0 @@
> -/* SPDX-License-Identifier: BSD-3-Clause
> - * Copyright(c) 2001-2022 Intel Corporation
> - */
> -
> -#ifndef _VIRTCHNL_H_
> -#define _VIRTCHNL_H_
> -
> -/* Description:
> - * This header file describes the Virtual Function (VF) - Physical Function
> - * (PF) communication protocol used by the drivers for all devices starting
> - * from our 40G product line
> - *
> - * Admin queue buffer usage:
> - * desc->opcode is always aqc_opc_send_msg_to_pf
> - * flags, retval, datalen, and data addr are all used normally.
> - * The Firmware copies the cookie fields when sending messages between
> the
> - * PF and VF, but uses all other fields internally. Due to this limitation,
> - * we must send all messages as "indirect", i.e. using an external buffer.
> - *
> - * All the VSI indexes are relative to the VF. Each VF can have maximum of
> - * three VSIs. All the queue indexes are relative to the VSI. Each VF can
> - * have a maximum of sixteen queues for all of its VSIs.
> - *
> - * The PF is required to return a status code in v_retval for all messages
> - * except RESET_VF, which does not require any response. The returned
> value
> - * is of virtchnl_status_code type, defined here.
> - *
> - * In general, VF driver initialization should roughly follow the order of
> - * these opcodes. The VF driver must first validate the API version of the
> - * PF driver, then request a reset, then get resources, then configure
> - * queues and interrupts. After these operations are complete, the VF
> - * driver may start its queues, optionally add MAC and VLAN filters, and
> - * process traffic.
> - */
> -
> -/* START GENERIC DEFINES
> - * Need to ensure the following enums and defines hold the same meaning
> and
> - * value in current and future projects
> - */
> -
> -#define VIRTCHNL_ETH_LENGTH_OF_ADDRESS 6
> -
> -/* These macros are used to generate compilation errors if a
> structure/union
> - * is not exactly the correct length. It gives a divide by zero error if the
> - * structure/union is not of the correct size, otherwise it creates an enum
> - * that is never used.
> - */
> -#define VIRTCHNL_CHECK_STRUCT_LEN(n, X) enum
> virtchnl_static_assert_enum_##X \
> - { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) }
> -#define VIRTCHNL_CHECK_UNION_LEN(n, X) enum
> virtchnl_static_asset_enum_##X \
> - { virtchnl_static_assert_##X = (n)/((sizeof(union X) == (n)) ? 1 : 0) }
> -
> -
> -/* Error Codes
> - * Note that many older versions of various iAVF drivers convert the
> reported
> - * status code directly into an iavf_status enumeration. For this reason, it
> - * is important that the values of these enumerations line up.
> - */
> -enum virtchnl_status_code {
> - VIRTCHNL_STATUS_SUCCESS = 0,
> - VIRTCHNL_STATUS_ERR_PARAM = -5,
> - VIRTCHNL_STATUS_ERR_NO_MEMORY = -18,
> - VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH = -38,
> - VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR = -39,
> - VIRTCHNL_STATUS_ERR_INVALID_VF_ID = -40,
> - VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR = -53,
> - VIRTCHNL_STATUS_ERR_NOT_SUPPORTED = -64,
> -};
> -
> -/* Backward compatibility */
> -#define VIRTCHNL_ERR_PARAM VIRTCHNL_STATUS_ERR_PARAM
> -#define VIRTCHNL_STATUS_NOT_SUPPORTED
> VIRTCHNL_STATUS_ERR_NOT_SUPPORTED
> -
> -#define VIRTCHNL_LINK_SPEED_2_5GB_SHIFT 0x0
> -#define VIRTCHNL_LINK_SPEED_100MB_SHIFT 0x1
> -#define VIRTCHNL_LINK_SPEED_1000MB_SHIFT 0x2
> -#define VIRTCHNL_LINK_SPEED_10GB_SHIFT 0x3
> -#define VIRTCHNL_LINK_SPEED_40GB_SHIFT 0x4
> -#define VIRTCHNL_LINK_SPEED_20GB_SHIFT 0x5
> -#define VIRTCHNL_LINK_SPEED_25GB_SHIFT 0x6
> -#define VIRTCHNL_LINK_SPEED_5GB_SHIFT 0x7
> -
> -enum virtchnl_link_speed {
> - VIRTCHNL_LINK_SPEED_UNKNOWN = 0,
> - VIRTCHNL_LINK_SPEED_100MB =
> BIT(VIRTCHNL_LINK_SPEED_100MB_SHIFT),
> - VIRTCHNL_LINK_SPEED_1GB =
> BIT(VIRTCHNL_LINK_SPEED_1000MB_SHIFT),
> - VIRTCHNL_LINK_SPEED_10GB =
> BIT(VIRTCHNL_LINK_SPEED_10GB_SHIFT),
> - VIRTCHNL_LINK_SPEED_40GB =
> BIT(VIRTCHNL_LINK_SPEED_40GB_SHIFT),
> - VIRTCHNL_LINK_SPEED_20GB =
> BIT(VIRTCHNL_LINK_SPEED_20GB_SHIFT),
> - VIRTCHNL_LINK_SPEED_25GB =
> BIT(VIRTCHNL_LINK_SPEED_25GB_SHIFT),
> - VIRTCHNL_LINK_SPEED_2_5GB =
> BIT(VIRTCHNL_LINK_SPEED_2_5GB_SHIFT),
> - VIRTCHNL_LINK_SPEED_5GB =
> BIT(VIRTCHNL_LINK_SPEED_5GB_SHIFT),
> -};
> -
> -/* for hsplit_0 field of Rx HMC context */
> -/* deprecated with AVF 1.0 */
> -enum virtchnl_rx_hsplit {
> - VIRTCHNL_RX_HSPLIT_NO_SPLIT = 0,
> - VIRTCHNL_RX_HSPLIT_SPLIT_L2 = 1,
> - VIRTCHNL_RX_HSPLIT_SPLIT_IP = 2,
> - VIRTCHNL_RX_HSPLIT_SPLIT_TCP_UDP = 4,
> - VIRTCHNL_RX_HSPLIT_SPLIT_SCTP = 8,
> -};
> -
> -enum virtchnl_bw_limit_type {
> - VIRTCHNL_BW_SHAPER = 0,
> -};
> -/* END GENERIC DEFINES */
> -
> -/* Opcodes for VF-PF communication. These are placed in the v_opcode
> field
> - * of the virtchnl_msg structure.
> - */
> -enum virtchnl_ops {
> -/* The PF sends status change events to VFs using
> - * the VIRTCHNL_OP_EVENT opcode.
> - * VFs send requests to the PF using the other ops.
> - * Use of "advanced opcode" features must be negotiated as part of
> capabilities
> - * exchange and are not considered part of base mode feature set.
> - *
> - */
> - VIRTCHNL_OP_UNKNOWN = 0,
> - VIRTCHNL_OP_VERSION = 1, /* must ALWAYS be 1 */
> - VIRTCHNL_OP_RESET_VF = 2,
> - VIRTCHNL_OP_GET_VF_RESOURCES = 3,
> - VIRTCHNL_OP_CONFIG_TX_QUEUE = 4,
> - VIRTCHNL_OP_CONFIG_RX_QUEUE = 5,
> - VIRTCHNL_OP_CONFIG_VSI_QUEUES = 6,
> - VIRTCHNL_OP_CONFIG_IRQ_MAP = 7,
> - VIRTCHNL_OP_ENABLE_QUEUES = 8,
> - VIRTCHNL_OP_DISABLE_QUEUES = 9,
> - VIRTCHNL_OP_ADD_ETH_ADDR = 10,
> - VIRTCHNL_OP_DEL_ETH_ADDR = 11,
> - VIRTCHNL_OP_ADD_VLAN = 12,
> - VIRTCHNL_OP_DEL_VLAN = 13,
> - VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE = 14,
> - VIRTCHNL_OP_GET_STATS = 15,
> - VIRTCHNL_OP_RSVD = 16,
> - VIRTCHNL_OP_EVENT = 17, /* must ALWAYS be 17 */
> - /* opcode 19 is reserved */
> - /* opcodes 20, 21, and 22 are reserved */
> - VIRTCHNL_OP_CONFIG_RSS_KEY = 23,
> - VIRTCHNL_OP_CONFIG_RSS_LUT = 24,
> - VIRTCHNL_OP_GET_RSS_HENA_CAPS = 25,
> - VIRTCHNL_OP_SET_RSS_HENA = 26,
> - VIRTCHNL_OP_ENABLE_VLAN_STRIPPING = 27,
> - VIRTCHNL_OP_DISABLE_VLAN_STRIPPING = 28,
> - VIRTCHNL_OP_REQUEST_QUEUES = 29,
> - VIRTCHNL_OP_ENABLE_CHANNELS = 30,
> - VIRTCHNL_OP_DISABLE_CHANNELS = 31,
> - VIRTCHNL_OP_ADD_CLOUD_FILTER = 32,
> - VIRTCHNL_OP_DEL_CLOUD_FILTER = 33,
> - /* opcode 34 is reserved */
> - /* opcodes 38, 39, 40, 41, 42 and 43 are reserved */
> - /* opcode 44 is reserved */
> - VIRTCHNL_OP_ADD_RSS_CFG = 45,
> - VIRTCHNL_OP_DEL_RSS_CFG = 46,
> - VIRTCHNL_OP_ADD_FDIR_FILTER = 47,
> - VIRTCHNL_OP_DEL_FDIR_FILTER = 48,
> - VIRTCHNL_OP_GET_MAX_RSS_QREGION = 50,
> - VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS = 51,
> - VIRTCHNL_OP_ADD_VLAN_V2 = 52,
> - VIRTCHNL_OP_DEL_VLAN_V2 = 53,
> - VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 = 54,
> - VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2 = 55,
> - VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2 = 56,
> - VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2 = 57,
> - VIRTCHNL_OP_ENABLE_VLAN_FILTERING_V2 = 58,
> - VIRTCHNL_OP_DISABLE_VLAN_FILTERING_V2 = 59,
> - VIRTCHNL_OP_1588_PTP_GET_CAPS = 60,
> - VIRTCHNL_OP_1588_PTP_GET_TIME = 61,
> - VIRTCHNL_OP_1588_PTP_SET_TIME = 62,
> - VIRTCHNL_OP_1588_PTP_ADJ_TIME = 63,
> - VIRTCHNL_OP_1588_PTP_ADJ_FREQ = 64,
> - VIRTCHNL_OP_1588_PTP_TX_TIMESTAMP = 65,
> - VIRTCHNL_OP_GET_QOS_CAPS = 66,
> - VIRTCHNL_OP_CONFIG_QUEUE_TC_MAP = 67,
> - VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS = 68,
> - VIRTCHNL_OP_1588_PTP_SET_PIN_CFG = 69,
> - VIRTCHNL_OP_1588_PTP_EXT_TIMESTAMP = 70,
> - VIRTCHNL_OP_ENABLE_QUEUES_V2 = 107,
> - VIRTCHNL_OP_DISABLE_QUEUES_V2 = 108,
> - VIRTCHNL_OP_MAP_QUEUE_VECTOR = 111,
> - VIRTCHNL_OP_CONFIG_QUEUE_BW = 112,
> - VIRTCHNL_OP_CONFIG_QUANTA = 113,
> - VIRTCHNL_OP_MAX,
> -};
> -
> -static inline const char *virtchnl_op_str(enum virtchnl_ops v_opcode)
> -{
> - switch (v_opcode) {
> - case VIRTCHNL_OP_UNKNOWN:
> - return "VIRTCHNL_OP_UNKNOWN";
> - case VIRTCHNL_OP_VERSION:
> - return "VIRTCHNL_OP_VERSION";
> - case VIRTCHNL_OP_RESET_VF:
> - return "VIRTCHNL_OP_RESET_VF";
> - case VIRTCHNL_OP_GET_VF_RESOURCES:
> - return "VIRTCHNL_OP_GET_VF_RESOURCES";
> - case VIRTCHNL_OP_CONFIG_TX_QUEUE:
> - return "VIRTCHNL_OP_CONFIG_TX_QUEUE";
> - case VIRTCHNL_OP_CONFIG_RX_QUEUE:
> - return "VIRTCHNL_OP_CONFIG_RX_QUEUE";
> - case VIRTCHNL_OP_CONFIG_VSI_QUEUES:
> - return "VIRTCHNL_OP_CONFIG_VSI_QUEUES";
> - case VIRTCHNL_OP_CONFIG_IRQ_MAP:
> - return "VIRTCHNL_OP_CONFIG_IRQ_MAP";
> - case VIRTCHNL_OP_ENABLE_QUEUES:
> - return "VIRTCHNL_OP_ENABLE_QUEUES";
> - case VIRTCHNL_OP_DISABLE_QUEUES:
> - return "VIRTCHNL_OP_DISABLE_QUEUES";
> - case VIRTCHNL_OP_ADD_ETH_ADDR:
> - return "VIRTCHNL_OP_ADD_ETH_ADDR";
> - case VIRTCHNL_OP_DEL_ETH_ADDR:
> - return "VIRTCHNL_OP_DEL_ETH_ADDR";
> - case VIRTCHNL_OP_ADD_VLAN:
> - return "VIRTCHNL_OP_ADD_VLAN";
> - case VIRTCHNL_OP_DEL_VLAN:
> - return "VIRTCHNL_OP_DEL_VLAN";
> - case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
> - return "VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE";
> - case VIRTCHNL_OP_GET_STATS:
> - return "VIRTCHNL_OP_GET_STATS";
> - case VIRTCHNL_OP_RSVD:
> - return "VIRTCHNL_OP_RSVD";
> - case VIRTCHNL_OP_EVENT:
> - return "VIRTCHNL_OP_EVENT";
> - case VIRTCHNL_OP_CONFIG_RSS_KEY:
> - return "VIRTCHNL_OP_CONFIG_RSS_KEY";
> - case VIRTCHNL_OP_CONFIG_RSS_LUT:
> - return "VIRTCHNL_OP_CONFIG_RSS_LUT";
> - case VIRTCHNL_OP_GET_RSS_HENA_CAPS:
> - return "VIRTCHNL_OP_GET_RSS_HENA_CAPS";
> - case VIRTCHNL_OP_SET_RSS_HENA:
> - return "VIRTCHNL_OP_SET_RSS_HENA";
> - case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING:
> - return "VIRTCHNL_OP_ENABLE_VLAN_STRIPPING";
> - case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING:
> - return "VIRTCHNL_OP_DISABLE_VLAN_STRIPPING";
> - case VIRTCHNL_OP_REQUEST_QUEUES:
> - return "VIRTCHNL_OP_REQUEST_QUEUES";
> - case VIRTCHNL_OP_ENABLE_CHANNELS:
> - return "VIRTCHNL_OP_ENABLE_CHANNELS";
> - case VIRTCHNL_OP_DISABLE_CHANNELS:
> - return "VIRTCHNL_OP_DISABLE_CHANNELS";
> - case VIRTCHNL_OP_ADD_CLOUD_FILTER:
> - return "VIRTCHNL_OP_ADD_CLOUD_FILTER";
> - case VIRTCHNL_OP_DEL_CLOUD_FILTER:
> - return "VIRTCHNL_OP_DEL_CLOUD_FILTER";
> - case VIRTCHNL_OP_ADD_RSS_CFG:
> - return "VIRTCHNL_OP_ADD_RSS_CFG";
> - case VIRTCHNL_OP_DEL_RSS_CFG:
> - return "VIRTCHNL_OP_DEL_RSS_CFG";
> - case VIRTCHNL_OP_ADD_FDIR_FILTER:
> - return "VIRTCHNL_OP_ADD_FDIR_FILTER";
> - case VIRTCHNL_OP_DEL_FDIR_FILTER:
> - return "VIRTCHNL_OP_DEL_FDIR_FILTER";
> - case VIRTCHNL_OP_GET_MAX_RSS_QREGION:
> - return "VIRTCHNL_OP_GET_MAX_RSS_QREGION";
> - case VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS:
> - return "VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS";
> - case VIRTCHNL_OP_ADD_VLAN_V2:
> - return "VIRTCHNL_OP_ADD_VLAN_V2";
> - case VIRTCHNL_OP_DEL_VLAN_V2:
> - return "VIRTCHNL_OP_DEL_VLAN_V2";
> - case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2:
> - return "VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2";
> - case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2:
> - return "VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2";
> - case VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2:
> - return "VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2";
> - case VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2:
> - return "VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2";
> - case VIRTCHNL_OP_ENABLE_VLAN_FILTERING_V2:
> - return "VIRTCHNL_OP_ENABLE_VLAN_FILTERING_V2";
> - case VIRTCHNL_OP_DISABLE_VLAN_FILTERING_V2:
> - return "VIRTCHNL_OP_DISABLE_VLAN_FILTERING_V2";
> - case VIRTCHNL_OP_1588_PTP_GET_CAPS:
> - return "VIRTCHNL_OP_1588_PTP_GET_CAPS";
> - case VIRTCHNL_OP_1588_PTP_GET_TIME:
> - return "VIRTCHNL_OP_1588_PTP_GET_TIME";
> - case VIRTCHNL_OP_1588_PTP_SET_TIME:
> - return "VIRTCHNL_OP_1588_PTP_SET_TIME";
> - case VIRTCHNL_OP_1588_PTP_ADJ_TIME:
> - return "VIRTCHNL_OP_1588_PTP_ADJ_TIME";
> - case VIRTCHNL_OP_1588_PTP_ADJ_FREQ:
> - return "VIRTCHNL_OP_1588_PTP_ADJ_FREQ";
> - case VIRTCHNL_OP_1588_PTP_TX_TIMESTAMP:
> - return "VIRTCHNL_OP_1588_PTP_TX_TIMESTAMP";
> - case VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS:
> - return "VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS";
> - case VIRTCHNL_OP_1588_PTP_SET_PIN_CFG:
> - return "VIRTCHNL_OP_1588_PTP_SET_PIN_CFG";
> - case VIRTCHNL_OP_1588_PTP_EXT_TIMESTAMP:
> - return "VIRTCHNL_OP_1588_PTP_EXT_TIMESTAMP";
> - case VIRTCHNL_OP_ENABLE_QUEUES_V2:
> - return "VIRTCHNL_OP_ENABLE_QUEUES_V2";
> - case VIRTCHNL_OP_DISABLE_QUEUES_V2:
> - return "VIRTCHNL_OP_DISABLE_QUEUES_V2";
> - case VIRTCHNL_OP_MAP_QUEUE_VECTOR:
> - return "VIRTCHNL_OP_MAP_QUEUE_VECTOR";
> - case VIRTCHNL_OP_MAX:
> - return "VIRTCHNL_OP_MAX";
> - default:
> - return "Unsupported (update virtchnl.h)";
> - }
> -}
> -
> -static inline const char *virtchnl_stat_str(enum virtchnl_status_code
> v_status)
> -{
> - switch (v_status) {
> - case VIRTCHNL_STATUS_SUCCESS:
> - return "VIRTCHNL_STATUS_SUCCESS";
> - case VIRTCHNL_STATUS_ERR_PARAM:
> - return "VIRTCHNL_STATUS_ERR_PARAM";
> - case VIRTCHNL_STATUS_ERR_NO_MEMORY:
> - return "VIRTCHNL_STATUS_ERR_NO_MEMORY";
> - case VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH:
> - return "VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH";
> - case VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR:
> - return "VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR";
> - case VIRTCHNL_STATUS_ERR_INVALID_VF_ID:
> - return "VIRTCHNL_STATUS_ERR_INVALID_VF_ID";
> - case VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR:
> - return "VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR";
> - case VIRTCHNL_STATUS_ERR_NOT_SUPPORTED:
> - return "VIRTCHNL_STATUS_ERR_NOT_SUPPORTED";
> - default:
> - return "Unknown status code (update virtchnl.h)";
> - }
> -}
> -
> -/* Virtual channel message descriptor. This overlays the admin queue
> - * descriptor. All other data is passed in external buffers.
> - */
> -
> -struct virtchnl_msg {
> - u8 pad[8]; /* AQ flags/opcode/len/retval fields
> */
> -
> - /* avoid confusion with desc->opcode */
> - enum virtchnl_ops v_opcode;
> -
> - /* ditto for desc->retval */
> - enum virtchnl_status_code v_retval;
> - u32 vfid; /* used by PF when sending to VF */
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(20, virtchnl_msg);
> -
> -/* Message descriptions and data structures. */
> -
> -/* VIRTCHNL_OP_VERSION
> - * VF posts its version number to the PF. PF responds with its version
> number
> - * in the same format, along with a return code.
> - * Reply from PF has its major/minor versions also in param0 and param1.
> - * If there is a major version mismatch, then the VF cannot operate.
> - * If there is a minor version mismatch, then the VF can operate but should
> - * add a warning to the system log.
> - *
> - * This enum element MUST always be specified as == 1, regardless of other
> - * changes in the API. The PF must always respond to this message without
> - * error regardless of version mismatch.
> - */
> -#define VIRTCHNL_VERSION_MAJOR 1
> -#define VIRTCHNL_VERSION_MINOR 1
> -#define VIRTCHNL_VERSION_MAJOR_2 2
> -#define VIRTCHNL_VERSION_MINOR_0 0
> -#define VIRTCHNL_VERSION_MINOR_NO_VF_CAPS 0
> -
> -struct virtchnl_version_info {
> - u32 major;
> - u32 minor;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_version_info);
> -
> -#define VF_IS_V10(_ver) (((_ver)->major == 1) && ((_ver)->minor == 0))
> -#define VF_IS_V11(_ver) (((_ver)->major == 1) && ((_ver)->minor == 1))
> -#define VF_IS_V20(_ver) (((_ver)->major == 2) && ((_ver)->minor == 0))
> -
> -/* VIRTCHNL_OP_RESET_VF
> - * VF sends this request to PF with no parameters
> - * PF does NOT respond! VF driver must delay then poll VFGEN_RSTAT
> register
> - * until reset completion is indicated. The admin queue must be reinitialized
> - * after this operation.
> - *
> - * When reset is complete, PF must ensure that all queues in all VSIs
> associated
> - * with the VF are stopped, all queue configurations in the HMC are set to 0,
> - * and all MAC and VLAN filters (except the default MAC address) on all VSIs
> - * are cleared.
> - */
> -
> -/* VSI types that use VIRTCHNL interface for VF-PF communication.
> VSI_SRIOV
> - * vsi_type should always be 6 for backward compatibility. Add other fields
> - * as needed.
> - */
> -enum virtchnl_vsi_type {
> - VIRTCHNL_VSI_TYPE_INVALID = 0,
> - VIRTCHNL_VSI_SRIOV = 6,
> -};
> -
> -/* VIRTCHNL_OP_GET_VF_RESOURCES
> - * Version 1.0 VF sends this request to PF with no parameters
> - * Version 1.1 VF sends this request to PF with u32 bitmap of its capabilities
> - * PF responds with an indirect message containing
> - * virtchnl_vf_resource and one or more
> - * virtchnl_vsi_resource structures.
> - */
> -
> -struct virtchnl_vsi_resource {
> - u16 vsi_id;
> - u16 num_queue_pairs;
> -
> - /* see enum virtchnl_vsi_type */
> - s32 vsi_type;
> - u16 qset_handle;
> - u8 default_mac_addr[VIRTCHNL_ETH_LENGTH_OF_ADDRESS];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vsi_resource);
> -
> -/* VF capability flags
> - * VIRTCHNL_VF_OFFLOAD_L2 flag is inclusive of base mode L2 offloads
> including
> - * TX/RX Checksum offloading and TSO for non-tunnelled packets.
> - */
> -#define VIRTCHNL_VF_OFFLOAD_L2 BIT(0)
> -#define VIRTCHNL_VF_OFFLOAD_IWARP BIT(1)
> -#define VIRTCHNL_VF_CAP_RDMA
> VIRTCHNL_VF_OFFLOAD_IWARP
> -#define VIRTCHNL_VF_OFFLOAD_RSS_AQ BIT(3)
> -#define VIRTCHNL_VF_OFFLOAD_RSS_REG BIT(4)
> -#define VIRTCHNL_VF_OFFLOAD_WB_ON_ITR BIT(5)
> -#define VIRTCHNL_VF_OFFLOAD_REQ_QUEUES BIT(6)
> -/* used to negotiate communicating link speeds in Mbps */
> -#define VIRTCHNL_VF_CAP_ADV_LINK_SPEED BIT(7)
> - /* BIT(8) is reserved */
> -#define VIRTCHNL_VF_LARGE_NUM_QPAIRS BIT(9)
> -#define VIRTCHNL_VF_OFFLOAD_CRC BIT(10)
> -#define VIRTCHNL_VF_OFFLOAD_VLAN_V2 BIT(15)
> -#define VIRTCHNL_VF_OFFLOAD_VLAN BIT(16)
> -#define VIRTCHNL_VF_OFFLOAD_RX_POLLING BIT(17)
> -#define VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2 BIT(18)
> -#define VIRTCHNL_VF_OFFLOAD_RSS_PF BIT(19)
> -#define VIRTCHNL_VF_OFFLOAD_ENCAP BIT(20)
> -#define VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM BIT(21)
> -#define VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM BIT(22)
> -#define VIRTCHNL_VF_OFFLOAD_ADQ BIT(23)
> -#define VIRTCHNL_VF_OFFLOAD_ADQ_V2 BIT(24)
> -#define VIRTCHNL_VF_OFFLOAD_USO BIT(25)
> - /* BIT(26) is reserved */
> -#define VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF BIT(27)
> -#define VIRTCHNL_VF_OFFLOAD_FDIR_PF BIT(28)
> -#define VIRTCHNL_VF_OFFLOAD_QOS BIT(29)
> - /* BIT(30) is reserved */
> -#define VIRTCHNL_VF_CAP_PTP BIT(31)
> -
> -#define VF_BASE_MODE_OFFLOADS (VIRTCHNL_VF_OFFLOAD_L2 | \
> - VIRTCHNL_VF_OFFLOAD_VLAN | \
> - VIRTCHNL_VF_OFFLOAD_RSS_PF)
> -
> -struct virtchnl_vf_resource {
> - u16 num_vsis;
> - u16 num_queue_pairs;
> - u16 max_vectors;
> - u16 max_mtu;
> -
> - u32 vf_cap_flags;
> - u32 rss_key_size;
> - u32 rss_lut_size;
> -
> - struct virtchnl_vsi_resource vsi_res[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(36, virtchnl_vf_resource);
> -
> -/* VIRTCHNL_OP_CONFIG_TX_QUEUE
> - * VF sends this message to set up parameters for one TX queue.
> - * External data buffer contains one instance of virtchnl_txq_info.
> - * PF configures requested queue and returns a status code.
> - */
> -
> -/* Tx queue config info */
> -struct virtchnl_txq_info {
> - u16 vsi_id;
> - u16 queue_id;
> - u16 ring_len; /* number of descriptors, multiple of 8 */
> - u16 headwb_enabled; /* deprecated with AVF 1.0 */
> - u64 dma_ring_addr;
> - u64 dma_headwb_addr; /* deprecated with AVF 1.0 */
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_txq_info);
> -
> -/* RX descriptor IDs (range from 0 to 63) */
> -enum virtchnl_rx_desc_ids {
> - VIRTCHNL_RXDID_0_16B_BASE = 0,
> - VIRTCHNL_RXDID_1_32B_BASE = 1,
> - VIRTCHNL_RXDID_2_FLEX_SQ_NIC = 2,
> - VIRTCHNL_RXDID_3_FLEX_SQ_SW = 3,
> - VIRTCHNL_RXDID_4_FLEX_SQ_NIC_VEB = 4,
> - VIRTCHNL_RXDID_5_FLEX_SQ_NIC_ACL = 5,
> - VIRTCHNL_RXDID_6_FLEX_SQ_NIC_2 = 6,
> - VIRTCHNL_RXDID_7_HW_RSVD = 7,
> - /* 8 through 15 are reserved */
> - VIRTCHNL_RXDID_16_COMMS_GENERIC = 16,
> - VIRTCHNL_RXDID_17_COMMS_AUX_VLAN = 17,
> - VIRTCHNL_RXDID_18_COMMS_AUX_IPV4 = 18,
> - VIRTCHNL_RXDID_19_COMMS_AUX_IPV6 = 19,
> - VIRTCHNL_RXDID_20_COMMS_AUX_FLOW = 20,
> - VIRTCHNL_RXDID_21_COMMS_AUX_TCP = 21,
> - /* 22 through 63 are reserved */
> -};
> -
> -/* RX descriptor ID bitmasks */
> -enum virtchnl_rx_desc_id_bitmasks {
> - VIRTCHNL_RXDID_0_16B_BASE_M =
> BIT(VIRTCHNL_RXDID_0_16B_BASE),
> - VIRTCHNL_RXDID_1_32B_BASE_M =
> BIT(VIRTCHNL_RXDID_1_32B_BASE),
> - VIRTCHNL_RXDID_2_FLEX_SQ_NIC_M =
> BIT(VIRTCHNL_RXDID_2_FLEX_SQ_NIC),
> - VIRTCHNL_RXDID_3_FLEX_SQ_SW_M =
> BIT(VIRTCHNL_RXDID_3_FLEX_SQ_SW),
> - VIRTCHNL_RXDID_4_FLEX_SQ_NIC_VEB_M =
> BIT(VIRTCHNL_RXDID_4_FLEX_SQ_NIC_VEB),
> - VIRTCHNL_RXDID_5_FLEX_SQ_NIC_ACL_M =
> BIT(VIRTCHNL_RXDID_5_FLEX_SQ_NIC_ACL),
> - VIRTCHNL_RXDID_6_FLEX_SQ_NIC_2_M =
> BIT(VIRTCHNL_RXDID_6_FLEX_SQ_NIC_2),
> - VIRTCHNL_RXDID_7_HW_RSVD_M =
> BIT(VIRTCHNL_RXDID_7_HW_RSVD),
> - /* 9 through 15 are reserved */
> - VIRTCHNL_RXDID_16_COMMS_GENERIC_M =
> BIT(VIRTCHNL_RXDID_16_COMMS_GENERIC),
> - VIRTCHNL_RXDID_17_COMMS_AUX_VLAN_M =
> BIT(VIRTCHNL_RXDID_17_COMMS_AUX_VLAN),
> - VIRTCHNL_RXDID_18_COMMS_AUX_IPV4_M =
> BIT(VIRTCHNL_RXDID_18_COMMS_AUX_IPV4),
> - VIRTCHNL_RXDID_19_COMMS_AUX_IPV6_M =
> BIT(VIRTCHNL_RXDID_19_COMMS_AUX_IPV6),
> - VIRTCHNL_RXDID_20_COMMS_AUX_FLOW_M =
> BIT(VIRTCHNL_RXDID_20_COMMS_AUX_FLOW),
> - VIRTCHNL_RXDID_21_COMMS_AUX_TCP_M =
> BIT(VIRTCHNL_RXDID_21_COMMS_AUX_TCP),
> - /* 22 through 63 are reserved */
> -};
> -
> -/* virtchnl_rxq_info_flags
> - *
> - * Definition of bits in the flags field of the virtchnl_rxq_info structure.
> - */
> -enum virtchnl_rxq_info_flags {
> - /* If the VIRTCHNL_PTP_RX_TSTAMP bit of the flag field is set, this is
> - * a request to enable Rx timestamp. Other flag bits are currently
> - * reserved and they may be extended in the future.
> - */
> - VIRTCHNL_PTP_RX_TSTAMP = BIT(0),
> -};
> -
> -/* VIRTCHNL_OP_CONFIG_RX_QUEUE
> - * VF sends this message to set up parameters for one RX queue.
> - * External data buffer contains one instance of virtchnl_rxq_info.
> - * PF configures requested queue and returns a status code. The
> - * crc_disable flag disables CRC stripping on the VF. Setting
> - * the crc_disable flag to 1 will disable CRC stripping for each
> - * queue in the VF where the flag is set. The VIRTCHNL_VF_OFFLOAD_CRC
> - * offload must have been set prior to sending this info or the PF
> - * will ignore the request. This flag should be set the same for
> - * all of the queues for a VF.
> - */
> -
> -/* Rx queue config info */
> -struct virtchnl_rxq_info {
> - u16 vsi_id;
> - u16 queue_id;
> - u32 ring_len; /* number of descriptors, multiple of 32 */
> - u16 hdr_size;
> - u16 splithdr_enabled; /* deprecated with AVF 1.0 */
> - u32 databuffer_size;
> - u32 max_pkt_size;
> - u8 crc_disable;
> - u8 pad1[3];
> - u64 dma_ring_addr;
> -
> - /* see enum virtchnl_rx_hsplit; deprecated with AVF 1.0 */
> - s32 rx_split_pos;
> - u32 pad2;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_rxq_info);
> -
> -/* VIRTCHNL_OP_CONFIG_VSI_QUEUES
> - * VF sends this message to set parameters for active TX and RX queues
> - * associated with the specified VSI.
> - * PF configures queues and returns status.
> - * If the number of queues specified is greater than the number of queues
> - * associated with the VSI, an error is returned and no queues are
> configured.
> - * NOTE: The VF is not required to configure all queues in a single request.
> - * It may send multiple messages. PF drivers must correctly handle all VF
> - * requests.
> - */
> -struct virtchnl_queue_pair_info {
> - /* NOTE: vsi_id and queue_id should be identical for both queues. */
> - struct virtchnl_txq_info txq;
> - struct virtchnl_rxq_info rxq;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(64, virtchnl_queue_pair_info);
> -
> -struct virtchnl_vsi_queue_config_info {
> - u16 vsi_id;
> - u16 num_queue_pairs;
> - u32 pad;
> - struct virtchnl_queue_pair_info qpair[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_vsi_queue_config_info);
> -
> -/* VIRTCHNL_OP_REQUEST_QUEUES
> - * VF sends this message to request the PF to allocate additional queues to
> - * this VF. Each VF gets a guaranteed number of queues on init but asking
> for
> - * additional queues must be negotiated. This is a best effort request as it
> - * is possible the PF does not have enough queues left to support the
> request.
> - * If the PF cannot support the number requested it will respond with the
> - * maximum number it is able to support. If the request is successful, PF will
> - * then reset the VF to institute required changes.
> - */
> -
> -/* VF resource request */
> -struct virtchnl_vf_res_request {
> - u16 num_queue_pairs;
> -};
> -
> -/* VIRTCHNL_OP_CONFIG_IRQ_MAP
> - * VF uses this message to map vectors to queues.
> - * The rxq_map and txq_map fields are bitmaps used to indicate which
> queues
> - * are to be associated with the specified vector.
> - * The "other" causes are always mapped to vector 0. The VF may not
> request
> - * that vector 0 be used for traffic.
> - * PF configures interrupt mapping and returns status.
> - * NOTE: due to hardware requirements, all active queues (both TX and RX)
> - * should be mapped to interrupts, even if the driver intends to operate
> - * only in polling mode. In this case the interrupt may be disabled, but
> - * the ITR timer will still run to trigger writebacks.
> - */
> -struct virtchnl_vector_map {
> - u16 vsi_id;
> - u16 vector_id;
> - u16 rxq_map;
> - u16 txq_map;
> - u16 rxitr_idx;
> - u16 txitr_idx;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_vector_map);
> -
> -struct virtchnl_irq_map_info {
> - u16 num_vectors;
> - struct virtchnl_vector_map vecmap[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(14, virtchnl_irq_map_info);
> -
> -/* VIRTCHNL_OP_ENABLE_QUEUES
> - * VIRTCHNL_OP_DISABLE_QUEUES
> - * VF sends these message to enable or disable TX/RX queue pairs.
> - * The queues fields are bitmaps indicating which queues to act upon.
> - * (Currently, we only support 16 queues per VF, but we make the field
> - * u32 to allow for expansion.)
> - * PF performs requested action and returns status.
> - * NOTE: The VF is not required to enable/disable all queues in a single
> - * request. It may send multiple messages.
> - * PF drivers must correctly handle all VF requests.
> - */
> -struct virtchnl_queue_select {
> - u16 vsi_id;
> - u16 pad;
> - u32 rx_queues;
> - u32 tx_queues;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_queue_select);
> -
> -/* VIRTCHNL_OP_GET_MAX_RSS_QREGION
> - *
> - * if VIRTCHNL_VF_LARGE_NUM_QPAIRS was negotiated in
> VIRTCHNL_OP_GET_VF_RESOURCES
> - * then this op must be supported.
> - *
> - * VF sends this message in order to query the max RSS queue region
> - * size supported by PF, when VIRTCHNL_VF_LARGE_NUM_QPAIRS is
> enabled.
> - * This information should be used when configuring the RSS LUT and/or
> - * configuring queue region based filters.
> - *
> - * The maximum RSS queue region is 2^qregion_width. So, a qregion_width
> - * of 6 would inform the VF that the PF supports a maximum RSS queue
> region
> - * of 64.
> - *
> - * A queue region represents a range of queues that can be used to
> configure
> - * a RSS LUT. For example, if a VF is given 64 queues, but only a max queue
> - * region size of 16 (i.e. 2^qregion_width = 16) then it will only be able
> - * to configure the RSS LUT with queue indices from 0 to 15. However, other
> - * filters can be used to direct packets to queues >15 via specifying a queue
> - * base/offset and queue region width.
> - */
> -struct virtchnl_max_rss_qregion {
> - u16 vport_id;
> - u16 qregion_width;
> - u8 pad[4];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_max_rss_qregion);
> -
> -/* VIRTCHNL_OP_ADD_ETH_ADDR
> - * VF sends this message in order to add one or more unicast or multicast
> - * address filters for the specified VSI.
> - * PF adds the filters and returns status.
> - */
> -
> -/* VIRTCHNL_OP_DEL_ETH_ADDR
> - * VF sends this message in order to remove one or more unicast or
> multicast
> - * filters for the specified VSI.
> - * PF removes the filters and returns status.
> - */
> -
> -/* VIRTCHNL_ETHER_ADDR_LEGACY
> - * Prior to adding the @type member to virtchnl_ether_addr, there were 2
> pad
> - * bytes. Moving forward all VF drivers should not set type to
> - * VIRTCHNL_ETHER_ADDR_LEGACY. This is only here to not break
> previous/legacy
> - * behavior. The control plane function (i.e. PF) can use a best effort
> method
> - * of tracking the primary/device unicast in this case, but there is no
> - * guarantee and functionality depends on the implementation of the PF.
> - */
> -
> -/* VIRTCHNL_ETHER_ADDR_PRIMARY
> - * All VF drivers should set @type to VIRTCHNL_ETHER_ADDR_PRIMARY for
> the
> - * primary/device unicast MAC address filter for
> VIRTCHNL_OP_ADD_ETH_ADDR and
> - * VIRTCHNL_OP_DEL_ETH_ADDR. This allows for the underlying control
> plane
> - * function (i.e. PF) to accurately track and use this MAC address for
> - * displaying on the host and for VM/function reset.
> - */
> -
> -/* VIRTCHNL_ETHER_ADDR_EXTRA
> - * All VF drivers should set @type to VIRTCHNL_ETHER_ADDR_EXTRA for
> any extra
> - * unicast and/or multicast filters that are being added/deleted via
> - * VIRTCHNL_OP_DEL_ETH_ADDR/VIRTCHNL_OP_ADD_ETH_ADDR
> respectively.
> - */
> -struct virtchnl_ether_addr {
> - u8 addr[VIRTCHNL_ETH_LENGTH_OF_ADDRESS];
> - u8 type;
> -#define VIRTCHNL_ETHER_ADDR_LEGACY 0
> -#define VIRTCHNL_ETHER_ADDR_PRIMARY 1
> -#define VIRTCHNL_ETHER_ADDR_EXTRA 2
> -#define VIRTCHNL_ETHER_ADDR_TYPE_MASK 3 /* first two bits of type are
> valid */
> - u8 pad;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_ether_addr);
> -
> -struct virtchnl_ether_addr_list {
> - u16 vsi_id;
> - u16 num_elements;
> - struct virtchnl_ether_addr list[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_ether_addr_list);
> -
> -/* VIRTCHNL_OP_ADD_VLAN
> - * VF sends this message to add one or more VLAN tag filters for receives.
> - * PF adds the filters and returns status.
> - * If a port VLAN is configured by the PF, this operation will return an
> - * error to the VF.
> - */
> -
> -/* VIRTCHNL_OP_DEL_VLAN
> - * VF sends this message to remove one or more VLAN tag filters for
> receives.
> - * PF removes the filters and returns status.
> - * If a port VLAN is configured by the PF, this operation will return an
> - * error to the VF.
> - */
> -
> -struct virtchnl_vlan_filter_list {
> - u16 vsi_id;
> - u16 num_elements;
> - u16 vlan_id[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_vlan_filter_list);
> -
> -/* This enum is used for all of the VIRTCHNL_VF_OFFLOAD_VLAN_V2_CAPS
> related
> - * structures and opcodes.
> - *
> - * VIRTCHNL_VLAN_UNSUPPORTED - This field is not supported and if a VF
> driver
> - * populates it the PF should return
> VIRTCHNL_STATUS_ERR_NOT_SUPPORTED.
> - *
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 - This field supports 0x8100 ethertype.
> - * VIRTCHNL_VLAN_ETHERTYPE_88A8 - This field supports 0x88A8
> ethertype.
> - * VIRTCHNL_VLAN_ETHERTYPE_9100 - This field supports 0x9100 ethertype.
> - *
> - * VIRTCHNL_VLAN_ETHERTYPE_AND - Used when multiple ethertypes can
> be supported
> - * by the PF concurrently. For example, if the PF can support
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 AND
> VIRTCHNL_VLAN_ETHERTYPE_88A8 filters it
> - * would OR the following bits:
> - *
> - * VIRTHCNL_VLAN_ETHERTYPE_8100 |
> - * VIRTCHNL_VLAN_ETHERTYPE_88A8 |
> - * VIRTCHNL_VLAN_ETHERTYPE_AND;
> - *
> - * The VF would interpret this as VLAN filtering can be supported on both
> 0x8100
> - * and 0x88A8 VLAN ethertypes.
> - *
> - * VIRTCHNL_ETHERTYPE_XOR - Used when only a single ethertype can be
> supported
> - * by the PF concurrently. For example if the PF can support
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 XOR
> VIRTCHNL_VLAN_ETHERTYPE_88A8 stripping
> - * offload it would OR the following bits:
> - *
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 |
> - * VIRTCHNL_VLAN_ETHERTYPE_88A8 |
> - * VIRTCHNL_VLAN_ETHERTYPE_XOR;
> - *
> - * The VF would interpret this as VLAN stripping can be supported on either
> - * 0x8100 or 0x88a8 VLAN ethertypes. So when requesting VLAN stripping
> via
> - * VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 the specified ethertype will
> override
> - * the previously set value.
> - *
> - * VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1 - Used to tell the VF to insert
> and/or
> - * strip the VLAN tag using the L2TAG1 field of the Tx/Rx descriptors.
> - *
> - * VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2 - Used to tell the VF to insert
> hardware
> - * offloaded VLAN tags using the L2TAG2 field of the Tx descriptor.
> - *
> - * VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2 - Used to tell the VF to strip
> hardware
> - * offloaded VLAN tags using the L2TAG2_2 field of the Rx descriptor.
> - *
> - * VIRTCHNL_VLAN_PRIO - This field supports VLAN priority bits. This is used
> for
> - * VLAN filtering if the underlying PF supports it.
> - *
> - * VIRTCHNL_VLAN_TOGGLE_ALLOWED - This field is used to say whether a
> - * certain VLAN capability can be toggled. For example if the underlying
> PF/CP
> - * allows the VF to toggle VLAN filtering, stripping, and/or insertion it should
> - * set this bit along with the supported ethertypes.
> - */
> -enum virtchnl_vlan_support {
> - VIRTCHNL_VLAN_UNSUPPORTED = 0,
> - VIRTCHNL_VLAN_ETHERTYPE_8100 = 0x00000001,
> - VIRTCHNL_VLAN_ETHERTYPE_88A8 = 0x00000002,
> - VIRTCHNL_VLAN_ETHERTYPE_9100 = 0x00000004,
> - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG1 = 0x00000100,
> - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2 = 0x00000200,
> - VIRTCHNL_VLAN_TAG_LOCATION_L2TAG2_2 = 0x00000400,
> - VIRTCHNL_VLAN_PRIO = 0x01000000,
> - VIRTCHNL_VLAN_FILTER_MASK = 0x10000000,
> - VIRTCHNL_VLAN_ETHERTYPE_AND = 0x20000000,
> - VIRTCHNL_VLAN_ETHERTYPE_XOR = 0x40000000,
> - VIRTCHNL_VLAN_TOGGLE = 0x80000000
> -};
> -
> -/* This structure is used as part of the
> VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS
> - * for filtering, insertion, and stripping capabilities.
> - *
> - * If only outer capabilities are supported (for filtering, insertion, and/or
> - * stripping) then this refers to the outer most or single VLAN from the VF's
> - * perspective.
> - *
> - * If only inner capabilities are supported (for filtering, insertion, and/or
> - * stripping) then this refers to the outer most or single VLAN from the VF's
> - * perspective. Functionally this is the same as if only outer capabilities are
> - * supported. The VF driver is just forced to use the inner fields when
> - * adding/deleting filters and enabling/disabling offloads (if supported).
> - *
> - * If both outer and inner capabilities are supported (for filtering, insertion,
> - * and/or stripping) then outer refers to the outer most or single VLAN and
> - * inner refers to the second VLAN, if it exists, in the packet.
> - *
> - * There is no support for tunneled VLAN offloads, so outer or inner are
> never
> - * referring to a tunneled packet from the VF's perspective.
> - */
> -struct virtchnl_vlan_supported_caps {
> - u32 outer;
> - u32 inner;
> -};
> -
> -/* The PF populates these fields based on the supported VLAN filtering. If a
> - * field is VIRTCHNL_VLAN_UNSUPPORTED then it's not supported and the
> PF will
> - * reject any VIRTCHNL_OP_ADD_VLAN_V2 or VIRTCHNL_OP_DEL_VLAN_V2
> messages using
> - * the unsupported fields.
> - *
> - * Also, a VF is only allowed to toggle its VLAN filtering setting if the
> - * VIRTCHNL_VLAN_TOGGLE bit is set.
> - *
> - * The ethertype(s) specified in the ethertype_init field are the ethertypes
> - * enabled for VLAN filtering. VLAN filtering in this case refers to the outer
> - * most VLAN from the VF's perspective. If both inner and outer filtering are
> - * allowed then ethertype_init only refers to the outer most VLAN as only
> - * VLAN ethertype supported for inner VLAN filtering is
> - * VIRTCHNL_VLAN_ETHERTYPE_8100. By default, inner VLAN filtering is
> disabled
> - * when both inner and outer filtering are allowed.
> - *
> - * The max_filters field tells the VF how many VLAN filters it's allowed to
> have
> - * at any one time. If it exceeds this amount and tries to add another filter,
> - * then the request will be rejected by the PF. To prevent failures, the VF
> - * should keep track of how many VLAN filters it has added and not attempt
> to
> - * add more than max_filters.
> - */
> -struct virtchnl_vlan_filtering_caps {
> - struct virtchnl_vlan_supported_caps filtering_support;
> - u32 ethertype_init;
> - u16 max_filters;
> - u8 pad[2];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vlan_filtering_caps);
> -
> -/* This enum is used for the virtchnl_vlan_offload_caps structure to specify
> - * if the PF supports a different ethertype for stripping and insertion.
> - *
> - * VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION - The
> ethertype(s) specified
> - * for stripping affect the ethertype(s) specified for insertion and visa versa
> - * as well. If the VF tries to configure VLAN stripping via
> - * VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 with
> VIRTCHNL_VLAN_ETHERTYPE_8100 then
> - * that will be the ethertype for both stripping and insertion.
> - *
> - * VIRTCHNL_ETHERTYPE_MATCH_NOT_REQUIRED - The ethertype(s)
> specified for
> - * stripping do not affect the ethertype(s) specified for insertion and visa
> - * versa.
> - */
> -enum virtchnl_vlan_ethertype_match {
> - VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION = 0,
> - VIRTCHNL_ETHERTYPE_MATCH_NOT_REQUIRED = 1,
> -};
> -
> -/* The PF populates these fields based on the supported VLAN offloads. If a
> - * field is VIRTCHNL_VLAN_UNSUPPORTED then it's not supported and the
> PF will
> - * reject any VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 or
> - * VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2 messages using the
> unsupported fields.
> - *
> - * Also, a VF is only allowed to toggle its VLAN offload setting if the
> - * VIRTCHNL_VLAN_TOGGLE_ALLOWED bit is set.
> - *
> - * The VF driver needs to be aware of how the tags are stripped by
> hardware and
> - * inserted by the VF driver based on the level of offload support. The PF
> will
> - * populate these fields based on where the VLAN tags are expected to be
> - * offloaded via the VIRTHCNL_VLAN_TAG_LOCATION_* bits. The VF will
> need to
> - * interpret these fields. See the definition of the
> - * VIRTCHNL_VLAN_TAG_LOCATION_* bits above the virtchnl_vlan_support
> - * enumeration.
> - */
> -struct virtchnl_vlan_offload_caps {
> - struct virtchnl_vlan_supported_caps stripping_support;
> - struct virtchnl_vlan_supported_caps insertion_support;
> - u32 ethertype_init;
> - u8 ethertype_match;
> - u8 pad[3];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_vlan_offload_caps);
> -
> -/* VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS
> - * VF sends this message to determine its VLAN capabilities.
> - *
> - * PF will mark which capabilities it supports based on hardware support
> and
> - * current configuration. For example, if a port VLAN is configured the PF
> will
> - * not allow outer VLAN filtering, stripping, or insertion to be configured so
> - * it will block these features from the VF.
> - *
> - * The VF will need to cross reference its capabilities with the PFs
> - * capabilities in the response message from the PF to determine the VLAN
> - * support.
> - */
> -struct virtchnl_vlan_caps {
> - struct virtchnl_vlan_filtering_caps filtering;
> - struct virtchnl_vlan_offload_caps offloads;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_vlan_caps);
> -
> -struct virtchnl_vlan {
> - u16 tci; /* tci[15:13] = PCP and tci[11:0] = VID */
> - u16 tci_mask; /* only valid if VIRTCHNL_VLAN_FILTER_MASK set in
> - * filtering caps
> - */
> - u16 tpid; /* 0x8100, 0x88a8, etc. and only type(s) set in
> - * filtering caps. Note that tpid here does not refer to
> - * VIRTCHNL_VLAN_ETHERTYPE_*, but it refers to
> the
> - * actual 2-byte VLAN TPID
> - */
> - u8 pad[2];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_vlan);
> -
> -struct virtchnl_vlan_filter {
> - struct virtchnl_vlan inner;
> - struct virtchnl_vlan outer;
> - u8 pad[16];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(32, virtchnl_vlan_filter);
> -
> -/* VIRTCHNL_OP_ADD_VLAN_V2
> - * VIRTCHNL_OP_DEL_VLAN_V2
> - *
> - * VF sends these messages to add/del one or more VLAN tag filters for Rx
> - * traffic.
> - *
> - * The PF attempts to add the filters and returns status.
> - *
> - * The VF should only ever attempt to add/del virtchnl_vlan_filter(s) using
> the
> - * supported fields negotiated via
> VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS.
> - */
> -struct virtchnl_vlan_filter_list_v2 {
> - u16 vport_id;
> - u16 num_elements;
> - u8 pad[4];
> - struct virtchnl_vlan_filter filters[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_vlan_filter_list_v2);
> -
> -/* VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2
> - * VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2
> - * VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2
> - * VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2
> - *
> - * VF sends this message to enable or disable VLAN stripping or insertion. It
> - * also needs to specify an ethertype. The VF knows which VLAN ethertypes
> are
> - * allowed and whether or not it's allowed to enable/disable the specific
> - * offload via the VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS message.
> The VF needs to
> - * parse the virtchnl_vlan_caps.offloads fields to determine which offload
> - * messages are allowed.
> - *
> - * For example, if the PF populates the virtchnl_vlan_caps.offloads in the
> - * following manner the VF will be allowed to enable and/or disable 0x8100
> inner
> - * VLAN insertion and/or stripping via the opcodes listed above. Inner in this
> - * case means the outer most or single VLAN from the VF's perspective. This
> is
> - * because no outer offloads are supported. See the comments above the
> - * virtchnl_vlan_supported_caps structure for more details.
> - *
> - * virtchnl_vlan_caps.offloads.stripping_support.inner =
> - * VIRTCHNL_VLAN_TOGGLE |
> - * VIRTCHNL_VLAN_ETHERTYPE_8100;
> - *
> - * virtchnl_vlan_caps.offloads.insertion_support.inner =
> - * VIRTCHNL_VLAN_TOGGLE |
> - * VIRTCHNL_VLAN_ETHERTYPE_8100;
> - *
> - * In order to enable inner (again note that in this case inner is the outer
> - * most or single VLAN from the VF's perspective) VLAN stripping for 0x8100
> - * VLANs, the VF would populate the virtchnl_vlan_setting structure in the
> - * following manner and send the
> VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 message.
> - *
> - * virtchnl_vlan_setting.inner_ethertype_setting =
> - * VIRTCHNL_VLAN_ETHERTYPE_8100;
> - *
> - * virtchnl_vlan_setting.vport_id = vport_id or vsi_id assigned to the VF on
> - * initialization.
> - *
> - * The reason that VLAN TPID(s) are not being used for the
> - * outer_ethertype_setting and inner_ethertype_setting fields is because
> it's
> - * possible a device could support VLAN insertion and/or stripping offload
> on
> - * multiple ethertypes concurrently, so this method allows a VF to request
> - * multiple ethertypes in one message using the virtchnl_vlan_support
> - * enumeration.
> - *
> - * For example, if the PF populates the virtchnl_vlan_caps.offloads in the
> - * following manner the VF will be allowed to enable 0x8100 and 0x88a8
> outer
> - * VLAN insertion and stripping simultaneously. The
> - * virtchnl_vlan_caps.offloads.ethertype_match field will also have to be
> - * populated based on what the PF can support.
> - *
> - * virtchnl_vlan_caps.offloads.stripping_support.outer =
> - * VIRTCHNL_VLAN_TOGGLE |
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 |
> - * VIRTCHNL_VLAN_ETHERTYPE_88A8 |
> - * VIRTCHNL_VLAN_ETHERTYPE_AND;
> - *
> - * virtchnl_vlan_caps.offloads.insertion_support.outer =
> - * VIRTCHNL_VLAN_TOGGLE |
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 |
> - * VIRTCHNL_VLAN_ETHERTYPE_88A8 |
> - * VIRTCHNL_VLAN_ETHERTYPE_AND;
> - *
> - * In order to enable outer VLAN stripping for 0x8100 and 0x88a8 VLANs,
> the VF
> - * would populate the virthcnl_vlan_offload_structure in the following
> manner
> - * and send the VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 message.
> - *
> - * virtchnl_vlan_setting.outer_ethertype_setting =
> - * VIRTHCNL_VLAN_ETHERTYPE_8100 |
> - * VIRTHCNL_VLAN_ETHERTYPE_88A8;
> - *
> - * virtchnl_vlan_setting.vport_id = vport_id or vsi_id assigned to the VF on
> - * initialization.
> - *
> - * There is also the case where a PF and the underlying hardware can
> support
> - * VLAN offloads on multiple ethertypes, but not concurrently. For example,
> if
> - * the PF populates the virtchnl_vlan_caps.offloads in the following manner
> the
> - * VF will be allowed to enable and/or disable 0x8100 XOR 0x88a8 outer
> VLAN
> - * offloads. The ethertypes must match for stripping and insertion.
> - *
> - * virtchnl_vlan_caps.offloads.stripping_support.outer =
> - * VIRTCHNL_VLAN_TOGGLE |
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 |
> - * VIRTCHNL_VLAN_ETHERTYPE_88A8 |
> - * VIRTCHNL_VLAN_ETHERTYPE_XOR;
> - *
> - * virtchnl_vlan_caps.offloads.insertion_support.outer =
> - * VIRTCHNL_VLAN_TOGGLE |
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 |
> - * VIRTCHNL_VLAN_ETHERTYPE_88A8 |
> - * VIRTCHNL_VLAN_ETHERTYPE_XOR;
> - *
> - * virtchnl_vlan_caps.offloads.ethertype_match =
> - *
> VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION;
> - *
> - * In order to enable outer VLAN stripping for 0x88a8 VLANs, the VF would
> - * populate the virtchnl_vlan_setting structure in the following manner and
> send
> - * the VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2. Also, this will change
> the
> - * ethertype for VLAN insertion if it's enabled. So, for completeness, a
> - * VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2 with the same ethertype
> should be sent.
> - *
> - * virtchnl_vlan_setting.outer_ethertype_setting =
> VIRTHCNL_VLAN_ETHERTYPE_88A8;
> - *
> - * virtchnl_vlan_setting.vport_id = vport_id or vsi_id assigned to the VF on
> - * initialization.
> - *
> - * VIRTCHNL_OP_ENABLE_VLAN_FILTERING_V2
> - * VIRTCHNL_OP_DISABLE_VLAN_FILTERING_V2
> - *
> - * VF sends this message to enable or disable VLAN filtering. It also needs to
> - * specify an ethertype. The VF knows which VLAN ethertypes are allowed
> and
> - * whether or not it's allowed to enable/disable filtering via the
> - * VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS message. The VF needs to
> - * parse the virtchnl_vlan_caps.filtering fields to determine which, if any,
> - * filtering messages are allowed.
> - *
> - * For example, if the PF populates the virtchnl_vlan_caps.filtering in the
> - * following manner the VF will be allowed to enable/disable 0x8100 and
> 0x88a8
> - * outer VLAN filtering together. Note, that the
> VIRTCHNL_VLAN_ETHERTYPE_AND
> - * means that all filtering ethertypes will to be enabled and disabled
> together
> - * regardless of the request from the VF. This means that the underlying
> - * hardware only supports VLAN filtering for all VLAN the specified
> ethertypes
> - * or none of them.
> - *
> - * virtchnl_vlan_caps.filtering.filtering_support.outer =
> - * VIRTCHNL_VLAN_TOGGLE |
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 |
> - * VIRTHCNL_VLAN_ETHERTYPE_88A8 |
> - * VIRTCHNL_VLAN_ETHERTYPE_9100 |
> - * VIRTCHNL_VLAN_ETHERTYPE_AND;
> - *
> - * In order to enable outer VLAN filtering for 0x88a8 and 0x8100 VLANs
> (0x9100
> - * VLANs aren't supported by the VF driver), the VF would populate the
> - * virtchnl_vlan_setting structure in the following manner and send the
> - * VIRTCHNL_OP_ENABLE_VLAN_FILTERING_V2. The same message format
> would be used
> - * to disable outer VLAN filtering for 0x88a8 and 0x8100 VLANs, but the
> - * VIRTCHNL_OP_DISABLE_VLAN_FILTERING_V2 opcode is used.
> - *
> - * virtchnl_vlan_setting.outer_ethertype_setting =
> - * VIRTCHNL_VLAN_ETHERTYPE_8100 |
> - * VIRTCHNL_VLAN_ETHERTYPE_88A8;
> - *
> - */
> -struct virtchnl_vlan_setting {
> - u32 outer_ethertype_setting;
> - u32 inner_ethertype_setting;
> - u16 vport_id;
> - u8 pad[6];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vlan_setting);
> -
> -/* VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE
> - * VF sends VSI id and flags.
> - * PF returns status code in retval.
> - * Note: we assume that broadcast accept mode is always enabled.
> - */
> -struct virtchnl_promisc_info {
> - u16 vsi_id;
> - u16 flags;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(4, virtchnl_promisc_info);
> -
> -#define FLAG_VF_UNICAST_PROMISC 0x00000001
> -#define FLAG_VF_MULTICAST_PROMISC 0x00000002
> -
> -/* VIRTCHNL_OP_GET_STATS
> - * VF sends this message to request stats for the selected VSI. VF uses
> - * the virtchnl_queue_select struct to specify the VSI. The queue_id
> - * field is ignored by the PF.
> - *
> - * PF replies with struct virtchnl_eth_stats in an external buffer.
> - */
> -
> -struct virtchnl_eth_stats {
> - u64 rx_bytes; /* received bytes */
> - u64 rx_unicast; /* received unicast pkts */
> - u64 rx_multicast; /* received multicast pkts */
> - u64 rx_broadcast; /* received broadcast pkts */
> - u64 rx_discards;
> - u64 rx_unknown_protocol;
> - u64 tx_bytes; /* transmitted bytes */
> - u64 tx_unicast; /* transmitted unicast pkts */
> - u64 tx_multicast; /* transmitted multicast pkts */
> - u64 tx_broadcast; /* transmitted broadcast pkts */
> - u64 tx_discards;
> - u64 tx_errors;
> -};
> -
> -/* VIRTCHNL_OP_CONFIG_RSS_KEY
> - * VIRTCHNL_OP_CONFIG_RSS_LUT
> - * VF sends these messages to configure RSS. Only supported if both PF
> - * and VF drivers set the VIRTCHNL_VF_OFFLOAD_RSS_PF bit during
> - * configuration negotiation. If this is the case, then the RSS fields in
> - * the VF resource struct are valid.
> - * Both the key and LUT are initialized to 0 by the PF, meaning that
> - * RSS is effectively disabled until set up by the VF.
> - */
> -struct virtchnl_rss_key {
> - u16 vsi_id;
> - u16 key_len;
> - u8 key[1]; /* RSS hash key, packed bytes */
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_rss_key);
> -
> -struct virtchnl_rss_lut {
> - u16 vsi_id;
> - u16 lut_entries;
> - u8 lut[1]; /* RSS lookup table */
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_rss_lut);
> -
> -/* enum virthcnl_hash_filter
> - *
> - * Bits defining the hash filters in the hena field of the virtchnl_rss_hena
> - * structure. Each bit indicates a specific hash filter for RSS.
> - *
> - * Note that not all bits are supported on all hardware. The VF should use
> - * VIRTCHNL_OP_GET_RSS_HENA_CAPS to determine which bits the PF is
> capable of
> - * before using VIRTCHNL_OP_SET_RSS_HENA to enable specific filters.
> - */
> -enum virtchnl_hash_filter {
> - /* Bits 0 through 28 are reserved for future use */
> - /* Bit 29, 30, and 32 are not supported on XL710 a X710 */
> - VIRTCHNL_HASH_FILTER_UNICAST_IPV4_UDP = 29,
> - VIRTCHNL_HASH_FILTER_MULTICAST_IPV4_UDP = 30,
> - VIRTCHNL_HASH_FILTER_IPV4_UDP = 31,
> - VIRTCHNL_HASH_FILTER_IPV4_TCP_SYN_NO_ACK = 32,
> - VIRTCHNL_HASH_FILTER_IPV4_TCP = 33,
> - VIRTCHNL_HASH_FILTER_IPV4_SCTP = 34,
> - VIRTCHNL_HASH_FILTER_IPV4_OTHER = 35,
> - VIRTCHNL_HASH_FILTER_FRAG_IPV4 = 36,
> - /* Bits 37 and 38 are reserved for future use */
> - /* Bit 39, 40, and 42 are not supported on XL710 a X710 */
> - VIRTCHNL_HASH_FILTER_UNICAST_IPV6_UDP = 39,
> - VIRTCHNL_HASH_FILTER_MULTICAST_IPV6_UDP = 40,
> - VIRTCHNL_HASH_FILTER_IPV6_UDP = 41,
> - VIRTCHNL_HASH_FILTER_IPV6_TCP_SYN_NO_ACK = 42,
> - VIRTCHNL_HASH_FILTER_IPV6_TCP = 43,
> - VIRTCHNL_HASH_FILTER_IPV6_SCTP = 44,
> - VIRTCHNL_HASH_FILTER_IPV6_OTHER = 45,
> - VIRTCHNL_HASH_FILTER_FRAG_IPV6 = 46,
> - /* Bit 37 is reserved for future use */
> - VIRTCHNL_HASH_FILTER_FCOE_OX = 48,
> - VIRTCHNL_HASH_FILTER_FCOE_RX = 49,
> - VIRTCHNL_HASH_FILTER_FCOE_OTHER = 50,
> - /* Bits 51 through 62 are reserved for future use */
> - VIRTCHNL_HASH_FILTER_L2_PAYLOAD = 63,
> -};
> -
> -#define VIRTCHNL_HASH_FILTER_INVALID (0)
> -
> -/* VIRTCHNL_OP_GET_RSS_HENA_CAPS
> - * VIRTCHNL_OP_SET_RSS_HENA
> - * VF sends these messages to get and set the hash filter enable bits for RSS.
> - * By default, the PF sets these to all possible traffic types that the
> - * hardware supports. The VF can query this value if it wants to change the
> - * traffic types that are hashed by the hardware.
> - */
> -struct virtchnl_rss_hena {
> - /* see enum virtchnl_hash_filter */
> - u64 hena;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_rss_hena);
> -
> -/* Type of RSS algorithm */
> -enum virtchnl_rss_algorithm {
> - VIRTCHNL_RSS_ALG_TOEPLITZ_ASYMMETRIC = 0,
> - VIRTCHNL_RSS_ALG_R_ASYMMETRIC = 1,
> - VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC = 2,
> - VIRTCHNL_RSS_ALG_XOR_SYMMETRIC = 3,
> -};
> -
> -/* This is used by PF driver to enforce how many channels can be supported.
> - * When ADQ_V2 capability is negotiated, it will allow 16 channels
> otherwise
> - * PF driver will allow only max 4 channels
> - */
> -#define VIRTCHNL_MAX_ADQ_CHANNELS 4
> -#define VIRTCHNL_MAX_ADQ_V2_CHANNELS 16
> -
> -/* VIRTCHNL_OP_ENABLE_CHANNELS
> - * VIRTCHNL_OP_DISABLE_CHANNELS
> - * VF sends these messages to enable or disable channels based on
> - * the user specified queue count and queue offset for each traffic class.
> - * This struct encompasses all the information that the PF needs from
> - * VF to create a channel.
> - */
> -struct virtchnl_channel_info {
> - u16 count; /* number of queues in a channel */
> - u16 offset; /* queues in a channel start from 'offset' */
> - u32 pad;
> - u64 max_tx_rate;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_channel_info);
> -
> -struct virtchnl_tc_info {
> - u32 num_tc;
> - u32 pad;
> - struct virtchnl_channel_info list[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_tc_info);
> -
> -/* VIRTCHNL_ADD_CLOUD_FILTER
> - * VIRTCHNL_DEL_CLOUD_FILTER
> - * VF sends these messages to add or delete a cloud filter based on the
> - * user specified match and action filters. These structures encompass
> - * all the information that the PF needs from the VF to add/delete a
> - * cloud filter.
> - */
> -
> -struct virtchnl_l4_spec {
> - u8 src_mac[VIRTCHNL_ETH_LENGTH_OF_ADDRESS];
> - u8 dst_mac[VIRTCHNL_ETH_LENGTH_OF_ADDRESS];
> - /* vlan_prio is part of this 16 bit field even from OS perspective
> - * vlan_id:12 is actual vlan_id, then vlanid:bit14..12 is vlan_prio
> - * in future, when decided to offload vlan_prio, pass that
> information
> - * as part of the "vlan_id" field, Bit14..12
> - */
> - __be16 vlan_id;
> - __be16 pad; /* reserved for future use */
> - __be32 src_ip[4];
> - __be32 dst_ip[4];
> - __be16 src_port;
> - __be16 dst_port;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(52, virtchnl_l4_spec);
> -
> -union virtchnl_flow_spec {
> - struct virtchnl_l4_spec tcp_spec;
> - u8 buffer[128]; /* reserved for future use */
> -};
> -
> -VIRTCHNL_CHECK_UNION_LEN(128, virtchnl_flow_spec);
> -
> -enum virtchnl_action {
> - /* action types */
> - VIRTCHNL_ACTION_DROP = 0,
> - VIRTCHNL_ACTION_TC_REDIRECT,
> - VIRTCHNL_ACTION_PASSTHRU,
> - VIRTCHNL_ACTION_QUEUE,
> - VIRTCHNL_ACTION_Q_REGION,
> - VIRTCHNL_ACTION_MARK,
> - VIRTCHNL_ACTION_COUNT,
> -};
> -
> -enum virtchnl_flow_type {
> - /* flow types */
> - VIRTCHNL_TCP_V4_FLOW = 0,
> - VIRTCHNL_TCP_V6_FLOW,
> - VIRTCHNL_UDP_V4_FLOW,
> - VIRTCHNL_UDP_V6_FLOW,
> -};
> -
> -struct virtchnl_filter {
> - union virtchnl_flow_spec data;
> - union virtchnl_flow_spec mask;
> -
> - /* see enum virtchnl_flow_type */
> - s32 flow_type;
> -
> - /* see enum virtchnl_action */
> - s32 action;
> - u32 action_meta;
> - u8 field_flags;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(272, virtchnl_filter);
> -
> -struct virtchnl_shaper_bw {
> - /* Unit is Kbps */
> - u32 committed;
> - u32 peak;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_shaper_bw);
> -
> -
> -
> -/* VIRTCHNL_OP_EVENT
> - * PF sends this message to inform the VF driver of events that may affect it.
> - * No direct response is expected from the VF, though it may generate other
> - * messages in response to this one.
> - */
> -enum virtchnl_event_codes {
> - VIRTCHNL_EVENT_UNKNOWN = 0,
> - VIRTCHNL_EVENT_LINK_CHANGE,
> - VIRTCHNL_EVENT_RESET_IMPENDING,
> - VIRTCHNL_EVENT_PF_DRIVER_CLOSE,
> -};
> -
> -#define PF_EVENT_SEVERITY_INFO 0
> -#define PF_EVENT_SEVERITY_ATTENTION 1
> -#define PF_EVENT_SEVERITY_ACTION_REQUIRED 2
> -#define PF_EVENT_SEVERITY_CERTAIN_DOOM 255
> -
> -struct virtchnl_pf_event {
> - /* see enum virtchnl_event_codes */
> - s32 event;
> - union {
> - /* If the PF driver does not support the new speed reporting
> - * capabilities then use link_event else use link_event_adv to
> - * get the speed and link information. The ability to
> understand
> - * new speeds is indicated by setting the capability flag
> - * VIRTCHNL_VF_CAP_ADV_LINK_SPEED in vf_cap_flags
> parameter
> - * in virtchnl_vf_resource struct and can be used to
> determine
> - * which link event struct to use below.
> - */
> - struct {
> - enum virtchnl_link_speed link_speed;
> - bool link_status;
> - u8 pad[3];
> - } link_event;
> - struct {
> - /* link_speed provided in Mbps */
> - u32 link_speed;
> - u8 link_status;
> - u8 pad[3];
> - } link_event_adv;
> - } event_data;
> -
> - s32 severity;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_pf_event);
> -
> -
> -/* VF reset states - these are written into the RSTAT register:
> - * VFGEN_RSTAT on the VF
> - * When the PF initiates a reset, it writes 0
> - * When the reset is complete, it writes 1
> - * When the PF detects that the VF has recovered, it writes 2
> - * VF checks this register periodically to determine if a reset has occurred,
> - * then polls it to know when the reset is complete.
> - * If either the PF or VF reads the register while the hardware
> - * is in a reset state, it will return DEADBEEF, which, when masked
> - * will result in 3.
> - */
> -enum virtchnl_vfr_states {
> - VIRTCHNL_VFR_INPROGRESS = 0,
> - VIRTCHNL_VFR_COMPLETED,
> - VIRTCHNL_VFR_VFACTIVE,
> -};
> -
> -#define VIRTCHNL_MAX_NUM_PROTO_HDRS 32
> -#define VIRTCHNL_MAX_SIZE_RAW_PACKET 1024
> -#define PROTO_HDR_SHIFT 5
> -#define PROTO_HDR_FIELD_START(proto_hdr_type) \
> - (proto_hdr_type <<
> PROTO_HDR_SHIFT)
> -#define PROTO_HDR_FIELD_MASK ((1UL << PROTO_HDR_SHIFT) - 1)
> -
> -/* VF use these macros to configure each protocol header.
> - * Specify which protocol headers and protocol header fields base on
> - * virtchnl_proto_hdr_type and virtchnl_proto_hdr_field.
> - * @param hdr: a struct of virtchnl_proto_hdr
> - * @param hdr_type: ETH/IPV4/TCP, etc
> - * @param field: SRC/DST/TEID/SPI, etc
> - */
> -#define VIRTCHNL_ADD_PROTO_HDR_FIELD(hdr, field) \
> - ((hdr)->field_selector |= BIT((field) & PROTO_HDR_FIELD_MASK))
> -#define VIRTCHNL_DEL_PROTO_HDR_FIELD(hdr, field) \
> - ((hdr)->field_selector &= ~BIT((field) & PROTO_HDR_FIELD_MASK))
> -#define VIRTCHNL_TEST_PROTO_HDR_FIELD(hdr, val) \
> - ((hdr)->field_selector & BIT((val) & PROTO_HDR_FIELD_MASK))
> -#define VIRTCHNL_GET_PROTO_HDR_FIELD(hdr) ((hdr)->field_selector)
> -
> -#define VIRTCHNL_ADD_PROTO_HDR_FIELD_BIT(hdr, hdr_type, field) \
> - (VIRTCHNL_ADD_PROTO_HDR_FIELD(hdr, \
> - VIRTCHNL_PROTO_HDR_ ## hdr_type ## _ ## field))
> -#define VIRTCHNL_DEL_PROTO_HDR_FIELD_BIT(hdr, hdr_type, field) \
> - (VIRTCHNL_DEL_PROTO_HDR_FIELD(hdr, \
> - VIRTCHNL_PROTO_HDR_ ## hdr_type ## _ ## field))
> -
> -#define VIRTCHNL_SET_PROTO_HDR_TYPE(hdr, hdr_type) \
> - ((hdr)->type = VIRTCHNL_PROTO_HDR_ ## hdr_type)
> -#define VIRTCHNL_GET_PROTO_HDR_TYPE(hdr) \
> - (((hdr)->type) >> PROTO_HDR_SHIFT)
> -#define VIRTCHNL_TEST_PROTO_HDR_TYPE(hdr, val) \
> - ((hdr)->type == ((s32)((val) >> PROTO_HDR_SHIFT)))
> -#define VIRTCHNL_TEST_PROTO_HDR(hdr, val) \
> - (VIRTCHNL_TEST_PROTO_HDR_TYPE(hdr, val) && \
> - VIRTCHNL_TEST_PROTO_HDR_FIELD(hdr, val))
> -
> -/* Protocol header type within a packet segment. A segment consists of one
> or
> - * more protocol headers that make up a logical group of protocol headers.
> Each
> - * logical group of protocol headers encapsulates or is encapsulated
> using/by
> - * tunneling or encapsulation protocols for network virtualization.
> - */
> -enum virtchnl_proto_hdr_type {
> - VIRTCHNL_PROTO_HDR_NONE,
> - VIRTCHNL_PROTO_HDR_ETH,
> - VIRTCHNL_PROTO_HDR_S_VLAN,
> - VIRTCHNL_PROTO_HDR_C_VLAN,
> - VIRTCHNL_PROTO_HDR_IPV4,
> - VIRTCHNL_PROTO_HDR_IPV6,
> - VIRTCHNL_PROTO_HDR_TCP,
> - VIRTCHNL_PROTO_HDR_UDP,
> - VIRTCHNL_PROTO_HDR_SCTP,
> - VIRTCHNL_PROTO_HDR_GTPU_IP,
> - VIRTCHNL_PROTO_HDR_GTPU_EH,
> - VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_DWN,
> - VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_UP,
> - VIRTCHNL_PROTO_HDR_PPPOE,
> - VIRTCHNL_PROTO_HDR_L2TPV3,
> - VIRTCHNL_PROTO_HDR_ESP,
> - VIRTCHNL_PROTO_HDR_AH,
> - VIRTCHNL_PROTO_HDR_PFCP,
> - VIRTCHNL_PROTO_HDR_GTPC,
> - VIRTCHNL_PROTO_HDR_ECPRI,
> - VIRTCHNL_PROTO_HDR_L2TPV2,
> - VIRTCHNL_PROTO_HDR_PPP,
> - /* IPv4 and IPv6 Fragment header types are only associated to
> - * VIRTCHNL_PROTO_HDR_IPV4 and VIRTCHNL_PROTO_HDR_IPV6
> respectively,
> - * cannot be used independently.
> - */
> - VIRTCHNL_PROTO_HDR_IPV4_FRAG,
> - VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG,
> - VIRTCHNL_PROTO_HDR_GRE,
> -};
> -
> -/* Protocol header field within a protocol header. */
> -enum virtchnl_proto_hdr_field {
> - /* ETHER */
> - VIRTCHNL_PROTO_HDR_ETH_SRC =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_ETH),
> - VIRTCHNL_PROTO_HDR_ETH_DST,
> - VIRTCHNL_PROTO_HDR_ETH_ETHERTYPE,
> - /* S-VLAN */
> - VIRTCHNL_PROTO_HDR_S_VLAN_ID =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_S_VLAN),
> - /* C-VLAN */
> - VIRTCHNL_PROTO_HDR_C_VLAN_ID =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_C_VLAN),
> - /* IPV4 */
> - VIRTCHNL_PROTO_HDR_IPV4_SRC =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_IPV4),
> - VIRTCHNL_PROTO_HDR_IPV4_DST,
> - VIRTCHNL_PROTO_HDR_IPV4_DSCP,
> - VIRTCHNL_PROTO_HDR_IPV4_TTL,
> - VIRTCHNL_PROTO_HDR_IPV4_PROT,
> - VIRTCHNL_PROTO_HDR_IPV4_CHKSUM,
> - /* IPV6 */
> - VIRTCHNL_PROTO_HDR_IPV6_SRC =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_IPV6),
> - VIRTCHNL_PROTO_HDR_IPV6_DST,
> - VIRTCHNL_PROTO_HDR_IPV6_TC,
> - VIRTCHNL_PROTO_HDR_IPV6_HOP_LIMIT,
> - VIRTCHNL_PROTO_HDR_IPV6_PROT,
> - /* IPV6 Prefix */
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX32_SRC,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX32_DST,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX40_SRC,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX40_DST,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX48_SRC,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX48_DST,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX56_SRC,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX56_DST,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_SRC,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX64_DST,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX96_SRC,
> - VIRTCHNL_PROTO_HDR_IPV6_PREFIX96_DST,
> - /* TCP */
> - VIRTCHNL_PROTO_HDR_TCP_SRC_PORT =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_TCP),
> - VIRTCHNL_PROTO_HDR_TCP_DST_PORT,
> - VIRTCHNL_PROTO_HDR_TCP_CHKSUM,
> - /* UDP */
> - VIRTCHNL_PROTO_HDR_UDP_SRC_PORT =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_UDP),
> - VIRTCHNL_PROTO_HDR_UDP_DST_PORT,
> - VIRTCHNL_PROTO_HDR_UDP_CHKSUM,
> - /* SCTP */
> - VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_SCTP),
> - VIRTCHNL_PROTO_HDR_SCTP_DST_PORT,
> - VIRTCHNL_PROTO_HDR_SCTP_CHKSUM,
> - /* GTPU_IP */
> - VIRTCHNL_PROTO_HDR_GTPU_IP_TEID =
> -
> PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_GTPU_IP),
> - /* GTPU_EH */
> - VIRTCHNL_PROTO_HDR_GTPU_EH_PDU =
> -
> PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_GTPU_EH),
> - VIRTCHNL_PROTO_HDR_GTPU_EH_QFI,
> - /* PPPOE */
> - VIRTCHNL_PROTO_HDR_PPPOE_SESS_ID =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_PPPOE),
> - /* L2TPV3 */
> - VIRTCHNL_PROTO_HDR_L2TPV3_SESS_ID =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_L2TPV3),
> - /* ESP */
> - VIRTCHNL_PROTO_HDR_ESP_SPI =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_ESP),
> - /* AH */
> - VIRTCHNL_PROTO_HDR_AH_SPI =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_AH),
> - /* PFCP */
> - VIRTCHNL_PROTO_HDR_PFCP_S_FIELD =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_PFCP),
> - VIRTCHNL_PROTO_HDR_PFCP_SEID,
> - /* GTPC */
> - VIRTCHNL_PROTO_HDR_GTPC_TEID =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_GTPC),
> - /* ECPRI */
> - VIRTCHNL_PROTO_HDR_ECPRI_MSG_TYPE =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_ECPRI),
> - VIRTCHNL_PROTO_HDR_ECPRI_PC_RTC_ID,
> - /* IPv4 Dummy Fragment */
> - VIRTCHNL_PROTO_HDR_IPV4_FRAG_PKID =
> -
> PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_IPV4_FRAG),
> - /* IPv6 Extension Fragment */
> - VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG_PKID =
> -
> PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_IPV6_EH_FRAG),
> - /* GTPU_DWN/UP */
> - VIRTCHNL_PROTO_HDR_GTPU_DWN_QFI =
> -
> PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_
> DWN),
> - VIRTCHNL_PROTO_HDR_GTPU_UP_QFI =
> -
> PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_GTPU_EH_PDU_
> UP),
> - /* L2TPv2 */
> - VIRTCHNL_PROTO_HDR_L2TPV2_SESS_ID =
> - PROTO_HDR_FIELD_START(VIRTCHNL_PROTO_HDR_L2TPV2),
> - VIRTCHNL_PROTO_HDR_L2TPV2_LEN_SESS_ID,
> -};
> -
> -struct virtchnl_proto_hdr {
> - /* see enum virtchnl_proto_hdr_type */
> - s32 type;
> - u32 field_selector; /* a bit mask to select field for header type */
> - u8 buffer[64];
> - /**
> - * binary buffer in network order for specific header type.
> - * For example, if type = VIRTCHNL_PROTO_HDR_IPV4, a IPv4
> - * header is expected to be copied into the buffer.
> - */
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_proto_hdr);
> -
> -struct virtchnl_proto_hdrs {
> - u8 tunnel_level;
> - /**
> - * specify where protocol header start from.
> - * must be 0 when sending a raw packet request.
> - * 0 - from the outer layer
> - * 1 - from the first inner layer
> - * 2 - from the second inner layer
> - * ....
> - */
> - int count;
> - /**
> - * number of proto layers, must <
> VIRTCHNL_MAX_NUM_PROTO_HDRS
> - * must be 0 for a raw packet request.
> - */
> - union {
> - struct virtchnl_proto_hdr
> - proto_hdr[VIRTCHNL_MAX_NUM_PROTO_HDRS];
> - struct {
> - u16 pkt_len;
> - u8 spec[VIRTCHNL_MAX_SIZE_RAW_PACKET];
> - u8 mask[VIRTCHNL_MAX_SIZE_RAW_PACKET];
> - } raw;
> - };
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(2312, virtchnl_proto_hdrs);
> -
> -struct virtchnl_rss_cfg {
> - struct virtchnl_proto_hdrs proto_hdrs; /* protocol headers */
> -
> - /* see enum virtchnl_rss_algorithm; rss algorithm type */
> - s32 rss_algorithm;
> - u8 reserved[128]; /* reserve for future */
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(2444, virtchnl_rss_cfg);
> -
> -/* action configuration for FDIR */
> -struct virtchnl_filter_action {
> - /* see enum virtchnl_action type */
> - s32 type;
> - union {
> - /* used for queue and qgroup action */
> - struct {
> - u16 index;
> - u8 region;
> - } queue;
> - /* used for count action */
> - struct {
> - /* share counter ID with other flow rules */
> - u8 shared;
> - u32 id; /* counter ID */
> - } count;
> - /* used for mark action */
> - u32 mark_id;
> - u8 reserve[32];
> - } act_conf;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(36, virtchnl_filter_action);
> -
> -#define VIRTCHNL_MAX_NUM_ACTIONS 8
> -
> -struct virtchnl_filter_action_set {
> - /* action number must be less then VIRTCHNL_MAX_NUM_ACTIONS
> */
> - int count;
> - struct virtchnl_filter_action actions[VIRTCHNL_MAX_NUM_ACTIONS];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(292, virtchnl_filter_action_set);
> -
> -/* pattern and action for FDIR rule */
> -struct virtchnl_fdir_rule {
> - struct virtchnl_proto_hdrs proto_hdrs;
> - struct virtchnl_filter_action_set action_set;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(2604, virtchnl_fdir_rule);
> -
> -/* Status returned to VF after VF requests FDIR commands
> - * VIRTCHNL_FDIR_SUCCESS
> - * VF FDIR related request is successfully done by PF
> - * The request can be OP_ADD/DEL/QUERY_FDIR_FILTER.
> - *
> - * VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE
> - * OP_ADD_FDIR_FILTER request is failed due to no Hardware resource.
> - *
> - * VIRTCHNL_FDIR_FAILURE_RULE_EXIST
> - * OP_ADD_FDIR_FILTER request is failed due to the rule is already existed.
> - *
> - * VIRTCHNL_FDIR_FAILURE_RULE_CONFLICT
> - * OP_ADD_FDIR_FILTER request is failed due to conflict with existing rule.
> - *
> - * VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST
> - * OP_DEL_FDIR_FILTER request is failed due to this rule doesn't exist.
> - *
> - * VIRTCHNL_FDIR_FAILURE_RULE_INVALID
> - * OP_ADD_FDIR_FILTER request is failed due to parameters validation
> - * or HW doesn't support.
> - *
> - * VIRTCHNL_FDIR_FAILURE_RULE_TIMEOUT
> - * OP_ADD/DEL_FDIR_FILTER request is failed due to timing out
> - * for programming.
> - *
> - * VIRTCHNL_FDIR_FAILURE_QUERY_INVALID
> - * OP_QUERY_FDIR_FILTER request is failed due to parameters validation,
> - * for example, VF query counter of a rule who has no counter action.
> - */
> -enum virtchnl_fdir_prgm_status {
> - VIRTCHNL_FDIR_SUCCESS = 0,
> - VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE,
> - VIRTCHNL_FDIR_FAILURE_RULE_EXIST,
> - VIRTCHNL_FDIR_FAILURE_RULE_CONFLICT,
> - VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST,
> - VIRTCHNL_FDIR_FAILURE_RULE_INVALID,
> - VIRTCHNL_FDIR_FAILURE_RULE_TIMEOUT,
> - VIRTCHNL_FDIR_FAILURE_QUERY_INVALID,
> -};
> -
> -/* VIRTCHNL_OP_ADD_FDIR_FILTER
> - * VF sends this request to PF by filling out vsi_id,
> - * validate_only and rule_cfg. PF will return flow_id
> - * if the request is successfully done and return add_status to VF.
> - */
> -struct virtchnl_fdir_add {
> - u16 vsi_id; /* INPUT */
> - /*
> - * 1 for validating a fdir rule, 0 for creating a fdir rule.
> - * Validate and create share one ops:
> VIRTCHNL_OP_ADD_FDIR_FILTER.
> - */
> - u16 validate_only; /* INPUT */
> - u32 flow_id; /* OUTPUT */
> - struct virtchnl_fdir_rule rule_cfg; /* INPUT */
> -
> - /* see enum virtchnl_fdir_prgm_status; OUTPUT */
> - s32 status;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(2616, virtchnl_fdir_add);
> -
> -/* VIRTCHNL_OP_DEL_FDIR_FILTER
> - * VF sends this request to PF by filling out vsi_id
> - * and flow_id. PF will return del_status to VF.
> - */
> -struct virtchnl_fdir_del {
> - u16 vsi_id; /* INPUT */
> - u16 pad;
> - u32 flow_id; /* INPUT */
> -
> - /* see enum virtchnl_fdir_prgm_status; OUTPUT */
> - s32 status;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_fdir_del);
> -
> -/* VIRTCHNL_OP_GET_QOS_CAPS
> - * VF sends this message to get its QoS Caps, such as
> - * TC number, Arbiter and Bandwidth.
> - */
> -struct virtchnl_qos_cap_elem {
> - u8 tc_num;
> - u8 tc_prio;
> -#define VIRTCHNL_ABITER_STRICT 0
> -#define VIRTCHNL_ABITER_ETS 2
> - u8 arbiter;
> -#define VIRTCHNL_STRICT_WEIGHT 1
> - u8 weight;
> - enum virtchnl_bw_limit_type type;
> - union {
> - struct virtchnl_shaper_bw shaper;
> - u8 pad2[32];
> - };
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_qos_cap_elem);
> -
> -struct virtchnl_qos_cap_list {
> - u16 vsi_id;
> - u16 num_elem;
> - struct virtchnl_qos_cap_elem cap[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(44, virtchnl_qos_cap_list);
> -
> -/* VIRTCHNL_OP_CONFIG_QUEUE_TC_MAP
> - * VF sends message virtchnl_queue_tc_mapping to set queue to tc
> - * mapping for all the Tx and Rx queues with a specified VSI, and
> - * would get response about bitmap of valid user priorities
> - * associated with queues.
> - */
> -struct virtchnl_queue_tc_mapping {
> - u16 vsi_id;
> - u16 num_tc;
> - u16 num_queue_pairs;
> - u8 pad[2];
> - union {
> - struct {
> - u16 start_queue_id;
> - u16 queue_count;
> - } req;
> - struct {
> -#define VIRTCHNL_USER_PRIO_TYPE_UP 0
> -#define VIRTCHNL_USER_PRIO_TYPE_DSCP 1
> - u16 prio_type;
> - u16 valid_prio_bitmap;
> - } resp;
> - } tc[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_queue_tc_mapping);
> -
> -/* VIRTCHNL_OP_CONFIG_QUEUE_BW */
> -struct virtchnl_queue_bw {
> - u16 queue_id;
> - u8 tc;
> - u8 pad;
> - struct virtchnl_shaper_bw shaper;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_queue_bw);
> -
> -struct virtchnl_queues_bw_cfg {
> - u16 vsi_id;
> - u16 num_queues;
> - struct virtchnl_queue_bw cfg[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_queues_bw_cfg);
> -
> -/* queue types */
> -enum virtchnl_queue_type {
> - VIRTCHNL_QUEUE_TYPE_TX = 0,
> - VIRTCHNL_QUEUE_TYPE_RX = 1,
> -};
> -
> -/* structure to specify a chunk of contiguous queues */
> -struct virtchnl_queue_chunk {
> - /* see enum virtchnl_queue_type */
> - s32 type;
> - u16 start_queue_id;
> - u16 num_queues;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(8, virtchnl_queue_chunk);
> -
> -/* structure to specify several chunks of contiguous queues */
> -struct virtchnl_queue_chunks {
> - u16 num_chunks;
> - u16 rsvd;
> - struct virtchnl_queue_chunk chunks[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_queue_chunks);
> -
> -/* VIRTCHNL_OP_ENABLE_QUEUES_V2
> - * VIRTCHNL_OP_DISABLE_QUEUES_V2
> - *
> - * These opcodes can be used if VIRTCHNL_VF_LARGE_NUM_QPAIRS was
> negotiated in
> - * VIRTCHNL_OP_GET_VF_RESOURCES
> - *
> - * VF sends virtchnl_ena_dis_queues struct to specify the queues to be
> - * enabled/disabled in chunks. Also applicable to single queue RX or
> - * TX. PF performs requested action and returns status.
> - */
> -struct virtchnl_del_ena_dis_queues {
> - u16 vport_id;
> - u16 pad;
> - struct virtchnl_queue_chunks chunks;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_del_ena_dis_queues);
> -
> -/* Virtchannel interrupt throttling rate index */
> -enum virtchnl_itr_idx {
> - VIRTCHNL_ITR_IDX_0 = 0,
> - VIRTCHNL_ITR_IDX_1 = 1,
> - VIRTCHNL_ITR_IDX_NO_ITR = 3,
> -};
> -
> -/* Queue to vector mapping */
> -struct virtchnl_queue_vector {
> - u16 queue_id;
> - u16 vector_id;
> - u8 pad[4];
> -
> - /* see enum virtchnl_itr_idx */
> - s32 itr_idx;
> -
> - /* see enum virtchnl_queue_type */
> - s32 queue_type;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_queue_vector);
> -
> -/* VIRTCHNL_OP_MAP_QUEUE_VECTOR
> - *
> - * This opcode can be used only if VIRTCHNL_VF_LARGE_NUM_QPAIRS was
> negotiated
> - * in VIRTCHNL_OP_GET_VF_RESOURCES
> - *
> - * VF sends this message to map queues to vectors and ITR index registers.
> - * External data buffer contains virtchnl_queue_vector_maps structure
> - * that contains num_qv_maps of virtchnl_queue_vector structures.
> - * PF maps the requested queue vector maps after validating the queue and
> vector
> - * ids and returns a status code.
> - */
> -struct virtchnl_queue_vector_maps {
> - u16 vport_id;
> - u16 num_qv_maps;
> - u8 pad[4];
> - struct virtchnl_queue_vector qv_maps[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_queue_vector_maps);
> -
> -struct virtchnl_quanta_cfg {
> - u16 quanta_size;
> - struct virtchnl_queue_chunk queue_select;
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_quanta_cfg);
> -
> -/* VIRTCHNL_VF_CAP_PTP
> - * VIRTCHNL_OP_1588_PTP_GET_CAPS
> - * VIRTCHNL_OP_1588_PTP_GET_TIME
> - * VIRTCHNL_OP_1588_PTP_SET_TIME
> - * VIRTCHNL_OP_1588_PTP_ADJ_TIME
> - * VIRTCHNL_OP_1588_PTP_ADJ_FREQ
> - * VIRTCHNL_OP_1588_PTP_TX_TIMESTAMP
> - * VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS
> - * VIRTCHNL_OP_1588_PTP_SET_PIN_CFG
> - * VIRTCHNL_OP_1588_PTP_EXT_TIMESTAMP
> - *
> - * Support for offloading control of the device PTP hardware clock (PHC) is
> enabled
> - * by VIRTCHNL_VF_CAP_PTP. This capability allows a VF to request that PF
> - * enable Tx and Rx timestamps, and request access to read and/or write the
> - * PHC on the device, as well as query if the VF has direct access to the PHC
> - * time registers.
> - *
> - * The VF must set VIRTCHNL_VF_CAP_PTP in its capabilities when
> requesting
> - * resources. If the capability is set in reply, the VF must then send
> - * a VIRTCHNL_OP_1588_PTP_GET_CAPS request during initialization. The
> VF indicates
> - * what extended capabilities it wants by setting the appropriate flags in the
> - * caps field. The PF reply will indicate what features are enabled for
> - * that VF.
> - */
> -#define VIRTCHNL_1588_PTP_CAP_TX_TSTAMP BIT(0)
> -#define VIRTCHNL_1588_PTP_CAP_RX_TSTAMP BIT(1)
> -#define VIRTCHNL_1588_PTP_CAP_READ_PHC BIT(2)
> -#define VIRTCHNL_1588_PTP_CAP_WRITE_PHC BIT(3)
> -#define VIRTCHNL_1588_PTP_CAP_PHC_REGS BIT(4)
> -#define VIRTCHNL_1588_PTP_CAP_PIN_CFG BIT(5)
> -
> -/**
> - * virtchnl_phc_regs
> - *
> - * Structure defines how the VF should access PHC related registers. The VF
> - * must request VIRTCHNL_1588_PTP_CAP_PHC_REGS. If the VF has access
> to PHC
> - * registers, the PF will reply with the capability flag set, and with this
> - * structure detailing what PCIe region and what offsets to use. If direct
> - * access is not available, this entire structure is reserved and the fields
> - * will be zero.
> - *
> - * If necessary in a future extension, a separate capability mutually
> - * exclusive with VIRTCHNL_1588_PTP_CAP_PHC_REGS might be used to
> change the
> - * entire format of this structure within virtchnl_ptp_caps.
> - *
> - * @clock_hi: Register offset of the high 32 bits of clock time
> - * @clock_lo: Register offset of the low 32 bits of clock time
> - * @pcie_region: The PCIe region the registers are located in.
> - * @rsvd: Reserved bits for future extension
> - */
> -struct virtchnl_phc_regs {
> - u32 clock_hi;
> - u32 clock_lo;
> - u8 pcie_region;
> - u8 rsvd[15];
> -};
> -VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_phc_regs);
> -
> -/* timestamp format enumeration
> - *
> - * VIRTCHNL_1588_PTP_TSTAMP_40BIT
> - *
> - * This format indicates a timestamp that uses the 40bit format from the
> - * flexible Rx descriptors. It is also the default Tx timestamp format used
> - * today.
> - *
> - * Such a timestamp has the following 40bit format:
> - *
> - * *--------------------------------*-------------------------------*-----------*
> - * | 32 bits of time in nanoseconds | 7 bits of sub-nanosecond time | valid
> bit |
> - * *--------------------------------*-------------------------------*-----------*
> - *
> - * The timestamp is passed in a u64, with the upper 24bits of the field
> - * reserved as zero.
> - *
> - * With this format, in order to report a full 64bit timestamp to userspace
> - * applications, the VF is responsible for performing timestamp extension
> by
> - * carefully comparing the timestamp with the PHC time. This can correctly
> - * be achieved with a recent cached copy of the PHC time by doing delta
> - * comparison between the 32bits of nanoseconds in the timestamp with
> the
> - * lower 32 bits of the clock time. For this to work, the cached PHC time
> - * must be from within 2^31 nanoseconds (~2.1 seconds) of when the
> timestamp
> - * was captured.
> - *
> - * VIRTCHNL_1588_PTP_TSTAMP_64BIT_NS
> - *
> - * This format indicates a timestamp that is 64 bits of nanoseconds.
> - */
> -enum virtchnl_ptp_tstamp_format {
> - VIRTCHNL_1588_PTP_TSTAMP_40BIT = 0,
> - VIRTCHNL_1588_PTP_TSTAMP_64BIT_NS = 1,
> -};
> -
> -/**
> - * virtchnl_ptp_caps
> - *
> - * Structure that defines the PTP capabilities available to the VF. The VF
> - * sends VIRTCHNL_OP_1588_PTP_GET_CAPS, and must fill in the ptp_caps
> field
> - * indicating what capabilities it is requesting. The PF will respond with the
> - * same message with the virtchnl_ptp_caps structure indicating what is
> - * enabled for the VF.
> - *
> - * @phc_regs: If VIRTCHNL_1588_PTP_CAP_PHC_REGS is set, contains
> information
> - * on the PHC related registers available to the VF.
> - * @caps: On send, VF sets what capabilities it requests. On reply, PF
> - * indicates what has been enabled for this VF. The PF shall not set
> - * bits which were not requested by the VF.
> - * @max_adj: The maximum adjustment capable of being requested by
> - * VIRTCHNL_OP_1588_PTP_ADJ_FREQ, in parts per billion. Note that
> 1 ppb
> - * is approximately 65.5 scaled_ppm. The PF shall clamp any
> - * frequency adjustment in VIRTCHNL_op_1588_ADJ_FREQ to +/-
> max_adj.
> - * Use of ppb in this field allows fitting the value into 4 bytes
> - * instead of potentially requiring 8 if scaled_ppm units were used.
> - * @tx_tstamp_idx: The Tx timestamp index to set in the transmit descriptor
> - * when requesting a timestamp for an outgoing packet.
> - * Reserved if VIRTCHNL_1588_PTP_CAP_TX_TSTAMP is not
> enabled.
> - * @n_ext_ts: Number of external timestamp functions available. Reserved
> - * if VIRTCHNL_1588_PTP_CAP_PIN_CFG is not enabled.
> - * @n_per_out: Number of periodic output functions available. Reserved if
> - * VIRTCHNL_1588_PTP_CAP_PIN_CFG is not enabled.
> - * @n_pins: Number of physical programmable pins able to be controlled.
> - * Reserved if VIRTCHNL_1588_PTP_CAP_PIN_CFG is not enabled.
> - * @tx_tstamp_format: Format of the Tx timestamps. Valid formats are
> defined
> - * by the virtchnl_ptp_tstamp enumeration. Note that Rx
> - * timestamps are tied to the descriptor format, and do not
> - * have a separate format field.
> - * @rsvd: Reserved bits for future extension.
> - *
> - * PTP capabilities
> - *
> - * VIRTCHNL_1588_PTP_CAP_TX_TSTAMP indicates that the VF can request
> transmit
> - * timestamps for packets in its transmit descriptors. If this is unset,
> - * transmit timestamp requests are ignored. Note that only one outstanding
> Tx
> - * timestamp request will be honored at a time. The PF shall handle receipt
> of
> - * the timestamp from the hardware, and will forward this to the VF by
> sending
> - * a VIRTCHNL_OP_1588_TX_TIMESTAMP message.
> - *
> - * VIRTCHNL_1588_PTP_CAP_RX_TSTAMP indicates that the VF receive
> queues have
> - * receive timestamps enabled in the flexible descriptors. Note that this
> - * requires a VF to also negotiate to enable advanced flexible descriptors in
> - * the receive path instead of the default legacy descriptor format.
> - *
> - * For a detailed description of the current Tx and Rx timestamp format, see
> - * the section on virtchnl_phc_tx_tstamp. Future extensions may indicate
> - * timestamp format in the capability structure.
> - *
> - * VIRTCHNL_1588_PTP_CAP_READ_PHC indicates that the VF may read the
> PHC time
> - * via the VIRTCHNL_OP_1588_PTP_GET_TIME command, or by directly
> reading PHC
> - * registers if VIRTCHNL_1588_PTP_CAP_PHC_REGS is also set.
> - *
> - * VIRTCHNL_1588_PTP_CAP_WRITE_PHC indicates that the VF may request
> updates
> - * to the PHC time via VIRTCHNL_OP_1588_PTP_SET_TIME,
> - * VIRTCHNL_OP_1588_PTP_ADJ_TIME, and
> VIRTCHNL_OP_1588_PTP_ADJ_FREQ.
> - *
> - * VIRTCHNL_1588_PTP_CAP_PHC_REGS indicates that the VF has direct
> access to
> - * certain PHC related registers, primarily for lower latency access to the
> - * PHC time. If this is set, the VF shall read the virtchnl_phc_regs section
> - * of the capabilities to determine the location of the clock registers. If
> - * this capability is not set, the entire 24 bytes of virtchnl_phc_regs is
> - * reserved as zero. Future extensions define alternative formats for this
> - * data, in which case they will be mutually exclusive with this capability.
> - *
> - * VIRTCHNL_1588_PTP_CAP_PIN_CFG indicates that the VF has the
> capability to
> - * control software defined pins. These pins can be assigned either as an
> - * input to timestamp external events, or as an output to cause a periodic
> - * signal output.
> - *
> - * Note that in the future, additional capability flags may be added which
> - * indicate additional extended support. All fields marked as reserved by this
> - * header will be set to zero. VF implementations should verify this to
> ensure
> - * that future extensions do not break compatibility.
> - */
> -struct virtchnl_ptp_caps {
> - struct virtchnl_phc_regs phc_regs;
> - u32 caps;
> - s32 max_adj;
> - u8 tx_tstamp_idx;
> - u8 n_ext_ts;
> - u8 n_per_out;
> - u8 n_pins;
> - /* see enum virtchnl_ptp_tstamp_format */
> - u8 tx_tstamp_format;
> - u8 rsvd[11];
> -};
> -VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_ptp_caps);
> -
> -/**
> - * virtchnl_phc_time
> - * @time: PHC time in nanoseconds
> - * @rsvd: Reserved for future extension
> - *
> - * Structure sent with VIRTCHNL_OP_1588_PTP_SET_TIME and received
> with
> - * VIRTCHNL_OP_1588_PTP_GET_TIME. Contains the 64bits of PHC clock
> time in
> - * nanoseconds.
> - *
> - * VIRTCHNL_OP_1588_PTP_SET_TIME may be sent by the VF if
> - * VIRTCHNL_1588_PTP_CAP_WRITE_PHC is set. This will request that the
> PHC time
> - * be set to the requested value. This operation is non-atomic and thus does
> - * not adjust for the delay between request and completion. It is
> recommended
> - * that the VF use VIRTCHNL_OP_1588_PTP_ADJ_TIME and
> - * VIRTCHNL_OP_1588_PTP_ADJ_FREQ when possible to steer the PHC clock.
> - *
> - * VIRTCHNL_OP_1588_PTP_GET_TIME may be sent to request the current
> time of
> - * the PHC. This op is available in case direct access via the PHC registers
> - * is not available.
> - */
> -struct virtchnl_phc_time {
> - u64 time;
> - u8 rsvd[8];
> -};
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_phc_time);
> -
> -/**
> - * virtchnl_phc_adj_time
> - * @delta: offset requested to adjust clock by
> - * @rsvd: reserved for future extension
> - *
> - * Sent with VIRTCHNL_OP_1588_PTP_ADJ_TIME. Used to request an
> adjustment of
> - * the clock time by the provided delta, with negative values representing
> - * subtraction. VIRTCHNL_OP_1588_PTP_ADJ_TIME may not be sent unless
> - * VIRTCHNL_1588_PTP_CAP_WRITE_PHC is set.
> - *
> - * The atomicity of this operation is not guaranteed. The PF should perform
> an
> - * atomic update using appropriate mechanisms if possible. However, this is
> - * not guaranteed.
> - */
> -struct virtchnl_phc_adj_time {
> - s64 delta;
> - u8 rsvd[8];
> -};
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_phc_adj_time);
> -
> -/**
> - * virtchnl_phc_adj_freq
> - * @scaled_ppm: frequency adjustment represented in scaled parts per
> million
> - * @rsvd: Reserved for future extension
> - *
> - * Sent with the VIRTCHNL_OP_1588_PTP_ADJ_FREQ to request an
> adjustment to the
> - * clock frequency. The adjustment is in scaled_ppm, which is parts per
> - * million with a 16bit binary fractional portion. 1 part per billion is
> - * approximately 65.5 scaled_ppm.
> - *
> - * ppm = scaled_ppm / 2^16
> - *
> - * ppb = scaled_ppm * 1000 / 2^16 or
> - *
> - * ppb = scaled_ppm * 125 / 2^13
> - *
> - * The PF shall clamp any adjustment request to plus or minus the specified
> - * max_adj in the PTP capabilities.
> - *
> - * Requests for adjustment are always based off of nominal clock frequency
> and
> - * not compounding. To reset clock frequency, send a request with a
> scaled_ppm
> - * of 0.
> - */
> -struct virtchnl_phc_adj_freq {
> - s64 scaled_ppm;
> - u8 rsvd[8];
> -};
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_phc_adj_freq);
> -
> -/**
> - * virtchnl_phc_tx_stamp
> - * @tstamp: timestamp value
> - * @rsvd: Reserved for future extension
> - *
> - * Sent along with VIRTCHNL_OP_1588_PTP_TX_TIMESTAMP from the PF
> when a Tx
> - * timestamp for the index associated with this VF in the tx_tstamp_idx field
> - * is captured by hardware.
> - *
> - * If VIRTCHNL_1588_PTP_CAP_TX_TSTAMP is set, the VF may request a
> timestamp
> - * for a packet in its transmit context descriptor by setting the appropriate
> - * flag and setting the timestamp index provided by the PF. On transmission,
> - * the timestamp will be captured and sent to the PF. The PF will forward
> this
> - * timestamp to the VF via the VIRTCHNL_1588_PTP_CAP_TX_TSTAMP op.
> - *
> - * The timestamp format is defined by the tx_tstamp_format field of the
> - * virtchnl_ptp_caps structure.
> - */
> -struct virtchnl_phc_tx_tstamp {
> - u64 tstamp;
> - u8 rsvd[8];
> -};
> -VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_phc_tx_tstamp);
> -
> -enum virtchnl_phc_pin_func {
> - VIRTCHNL_PHC_PIN_FUNC_NONE = 0, /* Not assigned to any
> function */
> - VIRTCHNL_PHC_PIN_FUNC_EXT_TS = 1, /* Assigned to external
> timestamp */
> - VIRTCHNL_PHC_PIN_FUNC_PER_OUT = 2, /* Assigned to periodic
> output */
> -};
> -
> -/* Length of the pin configuration data. All pin configurations belong within
> - * the same union and *must* have this length in bytes.
> - */
> -#define VIRTCHNL_PIN_CFG_LEN 64
> -
> -/* virtchnl_phc_ext_ts_mode
> - *
> - * Mode of the external timestamp, indicating which edges of the input
> signal
> - * to timestamp.
> - */
> -enum virtchnl_phc_ext_ts_mode {
> - VIRTCHNL_PHC_EXT_TS_NONE = 0,
> - VIRTCHNL_PHC_EXT_TS_RISING_EDGE = 1,
> - VIRTCHNL_PHC_EXT_TS_FALLING_EDGE = 2,
> - VIRTCHNL_PHC_EXT_TS_BOTH_EDGES = 3,
> -};
> -
> -/**
> - * virtchnl_phc_ext_ts
> - * @mode: mode of external timestamp request
> - * @rsvd: reserved for future extension
> - *
> - * External timestamp configuration. Defines the configuration for this
> - * external timestamp function.
> - *
> - * If mode is VIRTCHNL_PHC_EXT_TS_NONE, the function is essentially
> disabled,
> - * timestamping nothing.
> - *
> - * If mode is VIRTCHNL_PHC_EXT_TS_RISING_EDGE, the function shall
> timestamp
> - * the rising edge of the input when it transitions from low to high signal.
> - *
> - * If mode is VIRTCHNL_PHC_EXT_TS_FALLING_EDGE, the function shall
> timestamp
> - * the falling edge of the input when it transitions from high to low signal.
> - *
> - * If mode is VIRTCHNL_PHC_EXT_TS_BOTH_EDGES, the function shall
> timestamp
> - * both the rising and falling edge of the signal whenever it changes.
> - *
> - * The PF shall return an error if the requested mode cannot be
> implemented on
> - * the function.
> - */
> -struct virtchnl_phc_ext_ts {
> - u8 mode; /* see virtchnl_phc_ext_ts_mode */
> - u8 rsvd[63];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(VIRTCHNL_PIN_CFG_LEN,
> virtchnl_phc_ext_ts);
> -
> -/* virtchnl_phc_per_out_flags
> - *
> - * Flags defining periodic output functionality.
> - */
> -enum virtchnl_phc_per_out_flags {
> - VIRTCHNL_PHC_PER_OUT_PHASE_START = BIT(0),
> -};
> -
> -/**
> - * virtchnl_phc_per_out
> - * @start: absolute start time (if VIRTCHNL_PHC_PER_OUT_PHASE_START
> unset)
> - * @phase: phase offset to start (if VIRTCHNL_PHC_PER_OUT_PHASE_START
> set)
> - * @period: time to complete a full clock cycle (low - > high -> low)
> - * @on: length of time the signal should stay high
> - * @flags: flags defining the periodic output operation.
> - * rsvd: reserved for future extension
> - *
> - * Configuration for a periodic output signal. Used to define the signal that
> - * should be generated on a given function.
> - *
> - * The period field determines the full length of the clock cycle, including
> - * both duration hold high transition and duration to hold low transition in
> - * nanoseconds.
> - *
> - * The on field determines how long the signal should remain high. For
> - * a traditional square wave clock that is on for some duration and off for
> - * the same duration, use an on length of precisely half the period. The duty
> - * cycle of the clock is period/on.
> - *
> - * If VIRTCHNL_PHC_PER_OUT_PHASE_START is unset, then the request is
> to start
> - * a clock an absolute time. This means that the clock should start precisely
> - * at the specified time in the start field. If the start time is in the past,
> - * then the periodic output should start at the next valid multiple of the
> - * period plus the start time:
> - *
> - * new_start = (n * period) + start
> - * (choose n such that new start is in the future)
> - *
> - * Note that the PF should not reject a start time in the past because it is
> - * possible that such a start time was valid when the request was made, but
> - * became invalid due to delay in programming the pin.
> - *
> - * If VIRTCHNL_PHC_PER_OUT_PHASE_START is set, then the request is to
> start
> - * the next multiple of the period plus the phase offset. The phase must be
> - * less than the period. In this case, the clock should start as soon possible
> - * at the next available multiple of the period. To calculate a start time
> - * when programming this mode, use:
> - *
> - * start = (n * period) + phase
> - * (choose n such that start is in the future)
> - *
> - * A period of zero should be treated as a request to disable the clock
> - * output.
> - */
> -struct virtchnl_phc_per_out {
> - union {
> - u64 start;
> - u64 phase;
> - };
> - u64 period;
> - u64 on;
> - u32 flags;
> - u8 rsvd[36];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(VIRTCHNL_PIN_CFG_LEN,
> virtchnl_phc_per_out);
> -
> -/* virtchnl_phc_pin_cfg_flags
> - *
> - * Definition of bits in the flags field of the virtchnl_phc_pin_cfg
> - * structure.
> - */
> -enum virtchnl_phc_pin_cfg_flags {
> - /* Valid for VIRTCHNL_OP_1588_PTP_SET_PIN_CFG. If set, indicates
> this
> - * is a request to verify if the function can be assigned to the
> - * provided pin. In this case, the ext_ts and per_out fields are
> - * ignored, and the PF response must be an error if the pin cannot be
> - * assigned to that function index.
> - */
> - VIRTCHNL_PHC_PIN_CFG_VERIFY = BIT(0),
> -};
> -
> -/**
> - * virtchnl_phc_set_pin
> - * @pin_index: The pin to get or set
> - * @func: the function type the pin is assigned to
> - * @func_index: the index of the function the pin is assigned to
> - * @ext_ts: external timestamp configuration
> - * @per_out: periodic output configuration
> - * @rsvd1: Reserved for future extension
> - * @rsvd2: Reserved for future extension
> - *
> - * Sent along with the VIRTCHNL_OP_1588_PTP_SET_PIN_CFG op.
> - *
> - * The VF issues a VIRTCHNL_OP_1588_PTP_SET_PIN_CFG to assign the pin
> to one
> - * of the functions. It must set the pin_index field, the func field, and
> - * the func_index field. The pin_index must be less than n_pins, and the
> - * func_index must be less than the n_ext_ts or n_per_out depending on
> which
> - * function type is selected. If func is for an external timestamp, the
> - * ext_ts field must be filled in with the desired configuration. Similarly,
> - * if the function is for a periodic output, the per_out field must be
> - * configured.
> - *
> - * If the VIRTCHNL_PHC_PIN_CFG_VERIFY bit of the flag field is set, this is
> - * a request only to verify the configuration, not to set it. In this case,
> - * the PF should simply report an error if the requested pin cannot be
> - * assigned to the requested function. This allows VF to determine whether
> or
> - * not a given function can be assigned to a specific pin. Other flag bits are
> - * currently reserved and must be verified as zero on both sides. They may
> be
> - * extended in the future.
> - */
> -struct virtchnl_phc_set_pin {
> - u32 flags; /* see virtchnl_phc_pin_cfg_flags */
> - u8 pin_index;
> - u8 func; /* see virtchnl_phc_pin_func */
> - u8 func_index;
> - u8 rsvd1;
> - union {
> - struct virtchnl_phc_ext_ts ext_ts;
> - struct virtchnl_phc_per_out per_out;
> - };
> - u8 rsvd2[8];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_phc_set_pin);
> -
> -/**
> - * virtchnl_phc_pin
> - * @pin_index: The pin to get or set
> - * @func: the function type the pin is assigned to
> - * @func_index: the index of the function the pin is assigned to
> - * @rsvd: Reserved for future extension
> - * @name: human readable pin name, supplied by PF on GET_PIN_CFGS
> - *
> - * Sent by the PF as part of the VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS
> response.
> - *
> - * The VF issues a VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS request to the
> PF in
> - * order to obtain the current pin configuration for all of the pins that were
> - * assigned to this VF.
> - *
> - * This structure details the pin configuration state, including a pin name
> - * and which function is assigned to the pin currently.
> - */
> -struct virtchnl_phc_pin {
> - u8 pin_index;
> - u8 func; /* see virtchnl_phc_pin_func */
> - u8 func_index;
> - u8 rsvd[5];
> - char name[64];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_phc_pin);
> -
> -/**
> - * virtchnl_phc_pin_cfg
> - * @len: length of the variable pin config array
> - * @pins: variable length pin configuration array
> - *
> - * Variable structure sent by the PF in reply to
> - * VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS. The VF does not send this
> structure with
> - * its request of the operation.
> - *
> - * It is possible that the PF may need to send more pin configuration data
> - * than can be sent in one virtchnl message. To handle this, the PF should
> - * issue multiple VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS responses. Each
> response
> - * will indicate the number of pins it covers. The VF should be ready to wait
> - * for multiple responses until it has received a total length equal to the
> - * number of n_pins negotiated during extended PTP capabilities exchange.
> - */
> -struct virtchnl_phc_get_pins {
> - u8 len;
> - u8 rsvd[7];
> - struct virtchnl_phc_pin pins[1];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_phc_get_pins);
> -
> -/**
> - * virtchnl_phc_ext_stamp
> - * @tstamp: timestamp value
> - * @tstamp_rsvd: Reserved for future extension of the timestamp value.
> - * @tstamp_format: format of the timstamp
> - * @func_index: external timestamp function this timestamp is for
> - * @rsvd2: Reserved for future extension
> - *
> - * Sent along with the VIRTCHNL_OP_1588_PTP_EXT_TIMESTAMP from the
> PF when an
> - * external timestamp function is triggered.
> - *
> - * This will be sent only if one of the external timestamp functions is
> - * configured by the VF, and is only valid if
> VIRTCHNL_1588_PTP_CAP_PIN_CFG is
> - * negotiated with the PF.
> - *
> - * The timestamp format is defined by the tstamp_format field using the
> - * virtchnl_ptp_tstamp_format enumeration. The tstamp_rsvd field is
> - * exclusively reserved for possible future variants of the timestamp format,
> - * and its access will be controlled by the tstamp_format field.
> - */
> -struct virtchnl_phc_ext_tstamp {
> - u64 tstamp;
> - u8 tstamp_rsvd[8];
> - u8 tstamp_format;
> - u8 func_index;
> - u8 rsvd2[6];
> -};
> -
> -VIRTCHNL_CHECK_STRUCT_LEN(24, virtchnl_phc_ext_tstamp);
> -
> -/* Since VF messages are limited by u16 size, precalculate the maximum
> possible
> - * values of nested elements in virtchnl structures that virtual channel can
> - * possibly handle in a single message.
> - */
> -enum virtchnl_vector_limits {
> - VIRTCHNL_OP_CONFIG_VSI_QUEUES_MAX =
> - ((u16)(~0) - sizeof(struct virtchnl_vsi_queue_config_info)) /
> - sizeof(struct virtchnl_queue_pair_info),
> -
> - VIRTCHNL_OP_CONFIG_IRQ_MAP_MAX =
> - ((u16)(~0) - sizeof(struct virtchnl_irq_map_info)) /
> - sizeof(struct virtchnl_vector_map),
> -
> - VIRTCHNL_OP_ADD_DEL_ETH_ADDR_MAX =
> - ((u16)(~0) - sizeof(struct virtchnl_ether_addr_list)) /
> - sizeof(struct virtchnl_ether_addr),
> -
> - VIRTCHNL_OP_ADD_DEL_VLAN_MAX =
> - ((u16)(~0) - sizeof(struct virtchnl_vlan_filter_list)) /
> - sizeof(u16),
> -
> -
> - VIRTCHNL_OP_ENABLE_CHANNELS_MAX =
> - ((u16)(~0) - sizeof(struct virtchnl_tc_info)) /
> - sizeof(struct virtchnl_channel_info),
> -
> - VIRTCHNL_OP_ENABLE_DISABLE_DEL_QUEUES_V2_MAX =
> - ((u16)(~0) - sizeof(struct virtchnl_del_ena_dis_queues)) /
> - sizeof(struct virtchnl_queue_chunk),
> -
> - VIRTCHNL_OP_MAP_UNMAP_QUEUE_VECTOR_MAX =
> - ((u16)(~0) - sizeof(struct virtchnl_queue_vector_maps)) /
> - sizeof(struct virtchnl_queue_vector),
> -
> - VIRTCHNL_OP_ADD_DEL_VLAN_V2_MAX =
> - ((u16)(~0) - sizeof(struct virtchnl_vlan_filter_list_v2)) /
> - sizeof(struct virtchnl_vlan_filter),
> -};
> -
> -/**
> - * virtchnl_vc_validate_vf_msg
> - * @ver: Virtchnl version info
> - * @v_opcode: Opcode for the message
> - * @msg: pointer to the msg buffer
> - * @msglen: msg length
> - *
> - * validate msg format against struct for each opcode
> - */
> -static inline int
> -virtchnl_vc_validate_vf_msg(struct virtchnl_version_info *ver, u32
> v_opcode,
> - u8 *msg, u16 msglen)
> -{
> - bool err_msg_format = false;
> - u32 valid_len = 0;
> -
> - /* Validate message length. */
> - switch (v_opcode) {
> - case VIRTCHNL_OP_VERSION:
> - valid_len = sizeof(struct virtchnl_version_info);
> - break;
> - case VIRTCHNL_OP_RESET_VF:
> - break;
> - case VIRTCHNL_OP_GET_VF_RESOURCES:
> - if (VF_IS_V11(ver))
> - valid_len = sizeof(u32);
> - break;
> - case VIRTCHNL_OP_CONFIG_TX_QUEUE:
> - valid_len = sizeof(struct virtchnl_txq_info);
> - break;
> - case VIRTCHNL_OP_CONFIG_RX_QUEUE:
> - valid_len = sizeof(struct virtchnl_rxq_info);
> - break;
> - case VIRTCHNL_OP_CONFIG_VSI_QUEUES:
> - valid_len = sizeof(struct virtchnl_vsi_queue_config_info);
> - if (msglen >= valid_len) {
> - struct virtchnl_vsi_queue_config_info *vqc =
> - (struct virtchnl_vsi_queue_config_info *)msg;
> -
> - if (vqc->num_queue_pairs == 0 || vqc-
> >num_queue_pairs >
> - VIRTCHNL_OP_CONFIG_VSI_QUEUES_MAX) {
> - err_msg_format = true;
> - break;
> - }
> -
> - valid_len += (vqc->num_queue_pairs *
> - sizeof(struct
> - virtchnl_queue_pair_info));
> - }
> - break;
> - case VIRTCHNL_OP_CONFIG_IRQ_MAP:
> - valid_len = sizeof(struct virtchnl_irq_map_info);
> - if (msglen >= valid_len) {
> - struct virtchnl_irq_map_info *vimi =
> - (struct virtchnl_irq_map_info *)msg;
> -
> - if (vimi->num_vectors == 0 || vimi->num_vectors >
> - VIRTCHNL_OP_CONFIG_IRQ_MAP_MAX) {
> - err_msg_format = true;
> - break;
> - }
> -
> - valid_len += (vimi->num_vectors *
> - sizeof(struct virtchnl_vector_map));
> - }
> - break;
> - case VIRTCHNL_OP_ENABLE_QUEUES:
> - case VIRTCHNL_OP_DISABLE_QUEUES:
> - valid_len = sizeof(struct virtchnl_queue_select);
> - break;
> - case VIRTCHNL_OP_GET_MAX_RSS_QREGION:
> - break;
> - case VIRTCHNL_OP_ADD_ETH_ADDR:
> - case VIRTCHNL_OP_DEL_ETH_ADDR:
> - valid_len = sizeof(struct virtchnl_ether_addr_list);
> - if (msglen >= valid_len) {
> - struct virtchnl_ether_addr_list *veal =
> - (struct virtchnl_ether_addr_list *)msg;
> -
> - if (veal->num_elements == 0 || veal->num_elements >
> - VIRTCHNL_OP_ADD_DEL_ETH_ADDR_MAX) {
> - err_msg_format = true;
> - break;
> - }
> -
> - valid_len += veal->num_elements *
> - sizeof(struct virtchnl_ether_addr);
> - }
> - break;
> - case VIRTCHNL_OP_ADD_VLAN:
> - case VIRTCHNL_OP_DEL_VLAN:
> - valid_len = sizeof(struct virtchnl_vlan_filter_list);
> - if (msglen >= valid_len) {
> - struct virtchnl_vlan_filter_list *vfl =
> - (struct virtchnl_vlan_filter_list *)msg;
> -
> - if (vfl->num_elements == 0 || vfl->num_elements >
> - VIRTCHNL_OP_ADD_DEL_VLAN_MAX) {
> - err_msg_format = true;
> - break;
> - }
> -
> - valid_len += vfl->num_elements * sizeof(u16);
> - }
> - break;
> - case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
> - valid_len = sizeof(struct virtchnl_promisc_info);
> - break;
> - case VIRTCHNL_OP_GET_STATS:
> - valid_len = sizeof(struct virtchnl_queue_select);
> - break;
> - case VIRTCHNL_OP_CONFIG_RSS_KEY:
> - valid_len = sizeof(struct virtchnl_rss_key);
> - if (msglen >= valid_len) {
> - struct virtchnl_rss_key *vrk =
> - (struct virtchnl_rss_key *)msg;
> -
> - if (vrk->key_len == 0) {
> - /* zero length is allowed as input */
> - break;
> - }
> -
> - valid_len += vrk->key_len - 1;
> - }
> - break;
> - case VIRTCHNL_OP_CONFIG_RSS_LUT:
> - valid_len = sizeof(struct virtchnl_rss_lut);
> - if (msglen >= valid_len) {
> - struct virtchnl_rss_lut *vrl =
> - (struct virtchnl_rss_lut *)msg;
> -
> - if (vrl->lut_entries == 0) {
> - /* zero entries is allowed as input */
> - break;
> - }
> -
> - valid_len += vrl->lut_entries - 1;
> - }
> - break;
> - case VIRTCHNL_OP_GET_RSS_HENA_CAPS:
> - break;
> - case VIRTCHNL_OP_SET_RSS_HENA:
> - valid_len = sizeof(struct virtchnl_rss_hena);
> - break;
> - case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING:
> - case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING:
> - break;
> - case VIRTCHNL_OP_REQUEST_QUEUES:
> - valid_len = sizeof(struct virtchnl_vf_res_request);
> - break;
> - case VIRTCHNL_OP_ENABLE_CHANNELS:
> - valid_len = sizeof(struct virtchnl_tc_info);
> - if (msglen >= valid_len) {
> - struct virtchnl_tc_info *vti =
> - (struct virtchnl_tc_info *)msg;
> -
> - if (vti->num_tc == 0 || vti->num_tc >
> - VIRTCHNL_OP_ENABLE_CHANNELS_MAX) {
> - err_msg_format = true;
> - break;
> - }
> -
> - valid_len += (vti->num_tc - 1) *
> - sizeof(struct virtchnl_channel_info);
> - }
> - break;
> - case VIRTCHNL_OP_DISABLE_CHANNELS:
> - break;
> - case VIRTCHNL_OP_ADD_CLOUD_FILTER:
> - case VIRTCHNL_OP_DEL_CLOUD_FILTER:
> - valid_len = sizeof(struct virtchnl_filter);
> - break;
> - case VIRTCHNL_OP_ADD_RSS_CFG:
> - case VIRTCHNL_OP_DEL_RSS_CFG:
> - valid_len = sizeof(struct virtchnl_rss_cfg);
> - break;
> - case VIRTCHNL_OP_ADD_FDIR_FILTER:
> - valid_len = sizeof(struct virtchnl_fdir_add);
> - break;
> - case VIRTCHNL_OP_DEL_FDIR_FILTER:
> - valid_len = sizeof(struct virtchnl_fdir_del);
> - break;
> - case VIRTCHNL_OP_GET_QOS_CAPS:
> - break;
> - case VIRTCHNL_OP_CONFIG_QUEUE_TC_MAP:
> - valid_len = sizeof(struct virtchnl_queue_tc_mapping);
> - if (msglen >= valid_len) {
> - struct virtchnl_queue_tc_mapping *q_tc =
> - (struct virtchnl_queue_tc_mapping *)msg;
> - if (q_tc->num_tc == 0) {
> - err_msg_format = true;
> - break;
> - }
> - valid_len += (q_tc->num_tc - 1) *
> - sizeof(q_tc->tc[0]);
> - }
> - break;
> - case VIRTCHNL_OP_CONFIG_QUEUE_BW:
> - valid_len = sizeof(struct virtchnl_queues_bw_cfg);
> - if (msglen >= valid_len) {
> - struct virtchnl_queues_bw_cfg *q_bw =
> - (struct virtchnl_queues_bw_cfg *)msg;
> - if (q_bw->num_queues == 0) {
> - err_msg_format = true;
> - break;
> - }
> - valid_len += (q_bw->num_queues - 1) *
> - sizeof(q_bw->cfg[0]);
> - }
> - break;
> - case VIRTCHNL_OP_CONFIG_QUANTA:
> - valid_len = sizeof(struct virtchnl_quanta_cfg);
> - if (msglen >= valid_len) {
> - struct virtchnl_quanta_cfg *q_quanta =
> - (struct virtchnl_quanta_cfg *)msg;
> - if (q_quanta->quanta_size == 0 ||
> - q_quanta->queue_select.num_queues == 0) {
> - err_msg_format = true;
> - break;
> - }
> - }
> - break;
> - case VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS:
> - break;
> - case VIRTCHNL_OP_ADD_VLAN_V2:
> - case VIRTCHNL_OP_DEL_VLAN_V2:
> - valid_len = sizeof(struct virtchnl_vlan_filter_list_v2);
> - if (msglen >= valid_len) {
> - struct virtchnl_vlan_filter_list_v2 *vfl =
> - (struct virtchnl_vlan_filter_list_v2 *)msg;
> -
> - if (vfl->num_elements == 0 || vfl->num_elements >
> - VIRTCHNL_OP_ADD_DEL_VLAN_V2_MAX) {
> - err_msg_format = true;
> - break;
> - }
> -
> - valid_len += (vfl->num_elements - 1) *
> - sizeof(struct virtchnl_vlan_filter);
> - }
> - break;
> - case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2:
> - case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2:
> - case VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2:
> - case VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2:
> - case VIRTCHNL_OP_ENABLE_VLAN_FILTERING_V2:
> - case VIRTCHNL_OP_DISABLE_VLAN_FILTERING_V2:
> - valid_len = sizeof(struct virtchnl_vlan_setting);
> - break;
> - case VIRTCHNL_OP_1588_PTP_GET_CAPS:
> - valid_len = sizeof(struct virtchnl_ptp_caps);
> - break;
> - case VIRTCHNL_OP_1588_PTP_GET_TIME:
> - case VIRTCHNL_OP_1588_PTP_SET_TIME:
> - valid_len = sizeof(struct virtchnl_phc_time);
> - break;
> - case VIRTCHNL_OP_1588_PTP_ADJ_TIME:
> - valid_len = sizeof(struct virtchnl_phc_adj_time);
> - break;
> - case VIRTCHNL_OP_1588_PTP_ADJ_FREQ:
> - valid_len = sizeof(struct virtchnl_phc_adj_freq);
> - break;
> - case VIRTCHNL_OP_1588_PTP_TX_TIMESTAMP:
> - valid_len = sizeof(struct virtchnl_phc_tx_tstamp);
> - break;
> - case VIRTCHNL_OP_1588_PTP_SET_PIN_CFG:
> - valid_len = sizeof(struct virtchnl_phc_set_pin);
> - break;
> - case VIRTCHNL_OP_1588_PTP_GET_PIN_CFGS:
> - break;
> - case VIRTCHNL_OP_1588_PTP_EXT_TIMESTAMP:
> - valid_len = sizeof(struct virtchnl_phc_ext_tstamp);
> - break;
> - case VIRTCHNL_OP_ENABLE_QUEUES_V2:
> - case VIRTCHNL_OP_DISABLE_QUEUES_V2:
> - valid_len = sizeof(struct virtchnl_del_ena_dis_queues);
> - if (msglen >= valid_len) {
> - struct virtchnl_del_ena_dis_queues *qs =
> - (struct virtchnl_del_ena_dis_queues *)msg;
> - if (qs->chunks.num_chunks == 0 ||
> - qs->chunks.num_chunks >
> VIRTCHNL_OP_ENABLE_DISABLE_DEL_QUEUES_V2_MAX) {
> - err_msg_format = true;
> - break;
> - }
> - valid_len += (qs->chunks.num_chunks - 1) *
> - sizeof(struct virtchnl_queue_chunk);
> - }
> - break;
> - case VIRTCHNL_OP_MAP_QUEUE_VECTOR:
> - valid_len = sizeof(struct virtchnl_queue_vector_maps);
> - if (msglen >= valid_len) {
> - struct virtchnl_queue_vector_maps *v_qp =
> - (struct virtchnl_queue_vector_maps *)msg;
> - if (v_qp->num_qv_maps == 0 ||
> - v_qp->num_qv_maps >
> VIRTCHNL_OP_MAP_UNMAP_QUEUE_VECTOR_MAX) {
> - err_msg_format = true;
> - break;
> - }
> - valid_len += (v_qp->num_qv_maps - 1) *
> - sizeof(struct virtchnl_queue_vector);
> - }
> - break;
> - /* These are always errors coming from the VF. */
> - case VIRTCHNL_OP_EVENT:
> - case VIRTCHNL_OP_UNKNOWN:
> - default:
> - return VIRTCHNL_STATUS_ERR_PARAM;
> - }
> - /* few more checks */
> - if (err_msg_format || valid_len != msglen)
> - return VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH;
> -
> - return 0;
> -}
> -#endif /* _VIRTCHNL_H_ */
> diff --git a/drivers/common/idpf/base/virtchnl_inline_ipsec.h
> b/drivers/common/idpf/base/virtchnl_inline_ipsec.h
> deleted file mode 100644
> index e19043ac47..0000000000
> --- a/drivers/common/idpf/base/virtchnl_inline_ipsec.h
> +++ /dev/null
> @@ -1,567 +0,0 @@
> -/* SPDX-License-Identifier: BSD-3-Clause
> - * Copyright(c) 2001-2022 Intel Corporation
> - */
> -
> -#ifndef _VIRTCHNL_INLINE_IPSEC_H_
> -#define _VIRTCHNL_INLINE_IPSEC_H_
> -
> -#define VIRTCHNL_IPSEC_MAX_CRYPTO_CAP_NUM 3
> -#define VIRTCHNL_IPSEC_MAX_ALGO_CAP_NUM 16
> -#define VIRTCHNL_IPSEC_MAX_TX_DESC_NUM 128
> -#define VIRTCHNL_IPSEC_MAX_CRYPTO_ITEM_NUMBER 2
> -#define VIRTCHNL_IPSEC_MAX_KEY_LEN 128
> -#define VIRTCHNL_IPSEC_MAX_SA_DESTROY_NUM 8
> -#define VIRTCHNL_IPSEC_SA_DESTROY 0
> -#define VIRTCHNL_IPSEC_BROADCAST_VFID 0xFFFFFFFF
> -#define VIRTCHNL_IPSEC_INVALID_REQ_ID 0xFFFF
> -#define VIRTCHNL_IPSEC_INVALID_SA_CFG_RESP 0xFFFFFFFF
> -#define VIRTCHNL_IPSEC_INVALID_SP_CFG_RESP 0xFFFFFFFF
> -
> -/* crypto type */
> -#define VIRTCHNL_AUTH 1
> -#define VIRTCHNL_CIPHER 2
> -#define VIRTCHNL_AEAD 3
> -
> -/* caps enabled */
> -#define VIRTCHNL_IPSEC_ESN_ENA BIT(0)
> -#define VIRTCHNL_IPSEC_UDP_ENCAP_ENA BIT(1)
> -#define VIRTCHNL_IPSEC_SA_INDEX_SW_ENA BIT(2)
> -#define VIRTCHNL_IPSEC_AUDIT_ENA BIT(3)
> -#define VIRTCHNL_IPSEC_BYTE_LIMIT_ENA BIT(4)
> -#define VIRTCHNL_IPSEC_DROP_ON_AUTH_FAIL_ENA BIT(5)
> -#define VIRTCHNL_IPSEC_ARW_CHECK_ENA BIT(6)
> -#define VIRTCHNL_IPSEC_24BIT_SPI_ENA BIT(7)
> -
> -/* algorithm type */
> -/* Hash Algorithm */
> -#define VIRTCHNL_HASH_NO_ALG 0 /* NULL algorithm */
> -#define VIRTCHNL_AES_CBC_MAC 1 /* AES-CBC-MAC algorithm */
> -#define VIRTCHNL_AES_CMAC 2 /* AES CMAC algorithm */
> -#define VIRTCHNL_AES_GMAC 3 /* AES GMAC algorithm */
> -#define VIRTCHNL_AES_XCBC_MAC 4 /* AES XCBC algorithm */
> -#define VIRTCHNL_MD5_HMAC 5 /* HMAC using MD5 algorithm */
> -#define VIRTCHNL_SHA1_HMAC 6 /* HMAC using 128 bit SHA
> algorithm */
> -#define VIRTCHNL_SHA224_HMAC 7 /* HMAC using 224 bit SHA
> algorithm */
> -#define VIRTCHNL_SHA256_HMAC 8 /* HMAC using 256 bit SHA
> algorithm */
> -#define VIRTCHNL_SHA384_HMAC 9 /* HMAC using 384 bit SHA
> algorithm */
> -#define VIRTCHNL_SHA512_HMAC 10 /* HMAC using 512 bit SHA
> algorithm */
> -#define VIRTCHNL_SHA3_224_HMAC 11 /* HMAC using 224 bit SHA3
> algorithm */
> -#define VIRTCHNL_SHA3_256_HMAC 12 /* HMAC using 256 bit SHA3
> algorithm */
> -#define VIRTCHNL_SHA3_384_HMAC 13 /* HMAC using 384 bit SHA3
> algorithm */
> -#define VIRTCHNL_SHA3_512_HMAC 14 /* HMAC using 512 bit SHA3
> algorithm */
> -/* Cipher Algorithm */
> -#define VIRTCHNL_CIPHER_NO_ALG 15 /* NULL algorithm */
> -#define VIRTCHNL_3DES_CBC 16 /* Triple DES algorithm in CBC mode */
> -#define VIRTCHNL_AES_CBC 17 /* AES algorithm in CBC mode */
> -#define VIRTCHNL_AES_CTR 18 /* AES algorithm in Counter mode */
> -/* AEAD Algorithm */
> -#define VIRTCHNL_AES_CCM 19 /* AES algorithm in CCM mode */
> -#define VIRTCHNL_AES_GCM 20 /* AES algorithm in GCM mode */
> -#define VIRTCHNL_CHACHA20_POLY1305 21 /* algorithm of ChaCha20-
> Poly1305 */
> -
> -/* protocol type */
> -#define VIRTCHNL_PROTO_ESP 1
> -#define VIRTCHNL_PROTO_AH 2
> -#define VIRTCHNL_PROTO_RSVD1 3
> -
> -/* sa mode */
> -#define VIRTCHNL_SA_MODE_TRANSPORT 1
> -#define VIRTCHNL_SA_MODE_TUNNEL 2
> -#define VIRTCHNL_SA_MODE_TRAN_TUN 3
> -#define VIRTCHNL_SA_MODE_UNKNOWN 4
> -
> -/* sa direction */
> -#define VIRTCHNL_DIR_INGRESS 1
> -#define VIRTCHNL_DIR_EGRESS 2
> -#define VIRTCHNL_DIR_INGRESS_EGRESS 3
> -
> -/* sa termination */
> -#define VIRTCHNL_TERM_SOFTWARE 1
> -#define VIRTCHNL_TERM_HARDWARE 2
> -
> -/* sa ip type */
> -#define VIRTCHNL_IPV4 1
> -#define VIRTCHNL_IPV6 2
> -
> -/* for virtchnl_ipsec_resp */
> -enum inline_ipsec_resp {
> - INLINE_IPSEC_SUCCESS = 0,
> - INLINE_IPSEC_FAIL = -1,
> - INLINE_IPSEC_ERR_FIFO_FULL = -2,
> - INLINE_IPSEC_ERR_NOT_READY = -3,
> - INLINE_IPSEC_ERR_VF_DOWN = -4,
> - INLINE_IPSEC_ERR_INVALID_PARAMS = -5,
> - INLINE_IPSEC_ERR_NO_MEM = -6,
> -};
> -
> -/* Detailed opcodes for DPDK and IPsec use */
> -enum inline_ipsec_ops {
> - INLINE_IPSEC_OP_GET_CAP = 0,
> - INLINE_IPSEC_OP_GET_STATUS = 1,
> - INLINE_IPSEC_OP_SA_CREATE = 2,
> - INLINE_IPSEC_OP_SA_UPDATE = 3,
> - INLINE_IPSEC_OP_SA_DESTROY = 4,
> - INLINE_IPSEC_OP_SP_CREATE = 5,
> - INLINE_IPSEC_OP_SP_DESTROY = 6,
> - INLINE_IPSEC_OP_SA_READ = 7,
> - INLINE_IPSEC_OP_EVENT = 8,
> - INLINE_IPSEC_OP_RESP = 9,
> -};
> -
> -#pragma pack(1)
> -/* Not all valid, if certain field is invalid, set 1 for all bits */
> -struct virtchnl_algo_cap {
> - u32 algo_type;
> -
> - u16 block_size;
> -
> - u16 min_key_size;
> - u16 max_key_size;
> - u16 inc_key_size;
> -
> - u16 min_iv_size;
> - u16 max_iv_size;
> - u16 inc_iv_size;
> -
> - u16 min_digest_size;
> - u16 max_digest_size;
> - u16 inc_digest_size;
> -
> - u16 min_aad_size;
> - u16 max_aad_size;
> - u16 inc_aad_size;
> -};
> -#pragma pack()
> -
> -/* vf record the capability of crypto from the virtchnl */
> -struct virtchnl_sym_crypto_cap {
> - u8 crypto_type;
> - u8 algo_cap_num;
> - struct virtchnl_algo_cap
> algo_cap_list[VIRTCHNL_IPSEC_MAX_ALGO_CAP_NUM];
> -};
> -
> -/* VIRTCHNL_OP_GET_IPSEC_CAP
> - * VF pass virtchnl_ipsec_cap to PF
> - * and PF return capability of ipsec from virtchnl.
> - */
> -#pragma pack(1)
> -struct virtchnl_ipsec_cap {
> - /* max number of SA per VF */
> - u16 max_sa_num;
> -
> - /* IPsec SA Protocol - value ref VIRTCHNL_PROTO_XXX */
> - u8 virtchnl_protocol_type;
> -
> - /* IPsec SA Mode - value ref VIRTCHNL_SA_MODE_XXX */
> - u8 virtchnl_sa_mode;
> -
> - /* IPSec SA Direction - value ref VIRTCHNL_DIR_XXX */
> - u8 virtchnl_direction;
> -
> - /* termination mode - value ref VIRTCHNL_TERM_XXX */
> - u8 termination_mode;
> -
> - /* number of supported crypto capability */
> - u8 crypto_cap_num;
> -
> - /* descriptor ID */
> - u16 desc_id;
> -
> - /* capabilities enabled - value ref VIRTCHNL_IPSEC_XXX_ENA */
> - u32 caps_enabled;
> -
> - /* crypto capabilities */
> - struct virtchnl_sym_crypto_cap
> cap[VIRTCHNL_IPSEC_MAX_CRYPTO_CAP_NUM];
> -};
> -
> -/* configuration of crypto function */
> -struct virtchnl_ipsec_crypto_cfg_item {
> - u8 crypto_type;
> -
> - u32 algo_type;
> -
> - /* Length of valid IV data. */
> - u16 iv_len;
> -
> - /* Length of digest */
> - u16 digest_len;
> -
> - /* SA salt */
> - u32 salt;
> -
> - /* The length of the symmetric key */
> - u16 key_len;
> -
> - /* key data buffer */
> - u8 key_data[VIRTCHNL_IPSEC_MAX_KEY_LEN];
> -};
> -#pragma pack()
> -
> -struct virtchnl_ipsec_sym_crypto_cfg {
> - struct virtchnl_ipsec_crypto_cfg_item
> - items[VIRTCHNL_IPSEC_MAX_CRYPTO_ITEM_NUMBER];
> -};
> -
> -#pragma pack(1)
> -/* VIRTCHNL_OP_IPSEC_SA_CREATE
> - * VF send this SA configuration to PF using virtchnl;
> - * PF create SA as configuration and PF driver will return
> - * an unique index (sa_idx) for the created SA.
> - */
> -struct virtchnl_ipsec_sa_cfg {
> - /* IPsec SA Protocol - AH/ESP */
> - u8 virtchnl_protocol_type;
> -
> - /* termination mode - value ref VIRTCHNL_TERM_XXX */
> - u8 virtchnl_termination;
> -
> - /* type of outer IP - IPv4/IPv6 */
> - u8 virtchnl_ip_type;
> -
> - /* type of esn - !0:enable/0:disable */
> - u8 esn_enabled;
> -
> - /* udp encap - !0:enable/0:disable */
> - u8 udp_encap_enabled;
> -
> - /* IPSec SA Direction - value ref VIRTCHNL_DIR_XXX */
> - u8 virtchnl_direction;
> -
> - /* reserved */
> - u8 reserved1;
> -
> - /* SA security parameter index */
> - u32 spi;
> -
> - /* outer src ip address */
> - u8 src_addr[16];
> -
> - /* outer dst ip address */
> - u8 dst_addr[16];
> -
> - /* SPD reference. Used to link an SA with its policy.
> - * PF drivers may ignore this field.
> - */
> - u16 spd_ref;
> -
> - /* high 32 bits of esn */
> - u32 esn_hi;
> -
> - /* low 32 bits of esn */
> - u32 esn_low;
> -
> - /* When enabled, sa_index must be valid */
> - u8 sa_index_en;
> -
> - /* SA index when sa_index_en is true */
> - u32 sa_index;
> -
> - /* auditing mode - enable/disable */
> - u8 audit_en;
> -
> - /* lifetime byte limit - enable/disable
> - * When enabled, byte_limit_hard and byte_limit_soft
> - * must be valid.
> - */
> - u8 byte_limit_en;
> -
> - /* hard byte limit count */
> - u64 byte_limit_hard;
> -
> - /* soft byte limit count */
> - u64 byte_limit_soft;
> -
> - /* drop on authentication failure - enable/disable */
> - u8 drop_on_auth_fail_en;
> -
> - /* anti-reply window check - enable/disable
> - * When enabled, arw_size must be valid.
> - */
> - u8 arw_check_en;
> -
> - /* size of arw window, offset by 1. Setting to 0
> - * represents ARW window size of 1. Setting to 127
> - * represents ARW window size of 128
> - */
> - u8 arw_size;
> -
> - /* no ip offload mode - enable/disable
> - * When enabled, ip type and address must not be valid.
> - */
> - u8 no_ip_offload_en;
> -
> - /* SA Domain. Used to logical separate an SADB into groups.
> - * PF drivers supporting a single group ignore this field.
> - */
> - u16 sa_domain;
> -
> - /* crypto configuration */
> - struct virtchnl_ipsec_sym_crypto_cfg crypto_cfg;
> -};
> -#pragma pack()
> -
> -/* VIRTCHNL_OP_IPSEC_SA_UPDATE
> - * VF send configuration of index of SA to PF
> - * PF will update SA according to configuration
> - */
> -struct virtchnl_ipsec_sa_update {
> - u32 sa_index; /* SA to update */
> - u32 esn_hi; /* high 32 bits of esn */
> - u32 esn_low; /* low 32 bits of esn */
> -};
> -
> -#pragma pack(1)
> -/* VIRTCHNL_OP_IPSEC_SA_DESTROY
> - * VF send configuration of index of SA to PF
> - * PF will destroy SA according to configuration
> - * flag bitmap indicate all SA or just selected SA will
> - * be destroyed
> - */
> -struct virtchnl_ipsec_sa_destroy {
> - /* All zero bitmap indicates all SA will be destroyed.
> - * Non-zero bitmap indicates the selected SA in
> - * array sa_index will be destroyed.
> - */
> - u8 flag;
> -
> - /* selected SA index */
> - u32 sa_index[VIRTCHNL_IPSEC_MAX_SA_DESTROY_NUM];
> -};
> -
> -/* VIRTCHNL_OP_IPSEC_SA_READ
> - * VF send this SA configuration to PF using virtchnl;
> - * PF read SA and will return configuration for the created SA.
> - */
> -struct virtchnl_ipsec_sa_read {
> - /* SA valid - invalid/valid */
> - u8 valid;
> -
> - /* SA active - inactive/active */
> - u8 active;
> -
> - /* SA SN rollover - not_rollover/rollover */
> - u8 sn_rollover;
> -
> - /* IPsec SA Protocol - AH/ESP */
> - u8 virtchnl_protocol_type;
> -
> - /* termination mode - value ref VIRTCHNL_TERM_XXX */
> - u8 virtchnl_termination;
> -
> - /* auditing mode - enable/disable */
> - u8 audit_en;
> -
> - /* lifetime byte limit - enable/disable
> - * When set to limit, byte_limit_hard and byte_limit_soft
> - * must be valid.
> - */
> - u8 byte_limit_en;
> -
> - /* hard byte limit count */
> - u64 byte_limit_hard;
> -
> - /* soft byte limit count */
> - u64 byte_limit_soft;
> -
> - /* drop on authentication failure - enable/disable */
> - u8 drop_on_auth_fail_en;
> -
> - /* anti-replay window check - enable/disable
> - * When set to check, arw_size, arw_top, and arw must be valid
> - */
> - u8 arw_check_en;
> -
> - /* size of arw window, offset by 1. Setting to 0
> - * represents ARW window size of 1. Setting to 127
> - * represents ARW window size of 128
> - */
> - u8 arw_size;
> -
> - /* reserved */
> - u8 reserved1;
> -
> - /* top of anti-replay-window */
> - u64 arw_top;
> -
> - /* anti-replay-window */
> - u8 arw[16];
> -
> - /* packets processed */
> - u64 packets_processed;
> -
> - /* bytes processed */
> - u64 bytes_processed;
> -
> - /* packets dropped */
> - u32 packets_dropped;
> -
> - /* authentication failures */
> - u32 auth_fails;
> -
> - /* ARW check failures */
> - u32 arw_fails;
> -
> - /* type of esn - enable/disable */
> - u8 esn;
> -
> - /* IPSec SA Direction - value ref VIRTCHNL_DIR_XXX */
> - u8 virtchnl_direction;
> -
> - /* SA security parameter index */
> - u32 spi;
> -
> - /* SA salt */
> - u32 salt;
> -
> - /* high 32 bits of esn */
> - u32 esn_hi;
> -
> - /* low 32 bits of esn */
> - u32 esn_low;
> -
> - /* SA Domain. Used to logical separate an SADB into groups.
> - * PF drivers supporting a single group ignore this field.
> - */
> - u16 sa_domain;
> -
> - /* SPD reference. Used to link an SA with its policy.
> - * PF drivers may ignore this field.
> - */
> - u16 spd_ref;
> -
> - /* crypto configuration. Salt and keys are set to 0 */
> - struct virtchnl_ipsec_sym_crypto_cfg crypto_cfg;
> -};
> -#pragma pack()
> -
> -/* Add allowlist entry in IES */
> -struct virtchnl_ipsec_sp_cfg {
> - u32 spi;
> - u32 dip[4];
> -
> - /* Drop frame if true or redirect to QAT if false. */
> - u8 drop;
> -
> - /* Congestion domain. For future use. */
> - u8 cgd;
> -
> - /* 0 for IPv4 table, 1 for IPv6 table. */
> - u8 table_id;
> -
> - /* Set TC (congestion domain) if true. For future use. */
> - u8 set_tc;
> -
> - /* 0 for NAT-T unsupported, 1 for NAT-T supported */
> - u8 is_udp;
> -
> - /* reserved */
> - u8 reserved;
> -
> - /* NAT-T UDP port number. Only valid in case NAT-T supported */
> - u16 udp_port;
> -};
> -
> -#pragma pack(1)
> -/* Delete allowlist entry in IES */
> -struct virtchnl_ipsec_sp_destroy {
> - /* 0 for IPv4 table, 1 for IPv6 table. */
> - u8 table_id;
> - u32 rule_id;
> -};
> -#pragma pack()
> -
> -/* Response from IES to allowlist operations */
> -struct virtchnl_ipsec_sp_cfg_resp {
> - u32 rule_id;
> -};
> -
> -struct virtchnl_ipsec_sa_cfg_resp {
> - u32 sa_handle;
> -};
> -
> -#define INLINE_IPSEC_EVENT_RESET 0x1
> -#define INLINE_IPSEC_EVENT_CRYPTO_ON 0x2
> -#define INLINE_IPSEC_EVENT_CRYPTO_OFF 0x4
> -
> -struct virtchnl_ipsec_event {
> - u32 ipsec_event_data;
> -};
> -
> -#define INLINE_IPSEC_STATUS_AVAILABLE 0x1
> -#define INLINE_IPSEC_STATUS_UNAVAILABLE 0x2
> -
> -struct virtchnl_ipsec_status {
> - u32 status;
> -};
> -
> -struct virtchnl_ipsec_resp {
> - u32 resp;
> -};
> -
> -/* Internal message descriptor for VF <-> IPsec communication */
> -struct inline_ipsec_msg {
> - u16 ipsec_opcode;
> - u16 req_id;
> -
> - union {
> - /* IPsec request */
> - struct virtchnl_ipsec_sa_cfg sa_cfg[0];
> - struct virtchnl_ipsec_sp_cfg sp_cfg[0];
> - struct virtchnl_ipsec_sa_update sa_update[0];
> - struct virtchnl_ipsec_sa_destroy sa_destroy[0];
> - struct virtchnl_ipsec_sp_destroy sp_destroy[0];
> -
> - /* IPsec response */
> - struct virtchnl_ipsec_sa_cfg_resp sa_cfg_resp[0];
> - struct virtchnl_ipsec_sp_cfg_resp sp_cfg_resp[0];
> - struct virtchnl_ipsec_cap ipsec_cap[0];
> - struct virtchnl_ipsec_status ipsec_status[0];
> - /* response to del_sa, del_sp, update_sa */
> - struct virtchnl_ipsec_resp ipsec_resp[0];
> -
> - /* IPsec event (no req_id is required) */
> - struct virtchnl_ipsec_event event[0];
> -
> - /* Reserved */
> - struct virtchnl_ipsec_sa_read sa_read[0];
> - } ipsec_data;
> -};
> -
> -static inline u16 virtchnl_inline_ipsec_val_msg_len(u16 opcode)
> -{
> - u16 valid_len = sizeof(struct inline_ipsec_msg);
> -
> - switch (opcode) {
> - case INLINE_IPSEC_OP_GET_CAP:
> - case INLINE_IPSEC_OP_GET_STATUS:
> - break;
> - case INLINE_IPSEC_OP_SA_CREATE:
> - valid_len += sizeof(struct virtchnl_ipsec_sa_cfg);
> - break;
> - case INLINE_IPSEC_OP_SP_CREATE:
> - valid_len += sizeof(struct virtchnl_ipsec_sp_cfg);
> - break;
> - case INLINE_IPSEC_OP_SA_UPDATE:
> - valid_len += sizeof(struct virtchnl_ipsec_sa_update);
> - break;
> - case INLINE_IPSEC_OP_SA_DESTROY:
> - valid_len += sizeof(struct virtchnl_ipsec_sa_destroy);
> - break;
> - case INLINE_IPSEC_OP_SP_DESTROY:
> - valid_len += sizeof(struct virtchnl_ipsec_sp_destroy);
> - break;
> - /* Only for msg length calculation of response to VF in case of
> - * inline ipsec failure.
> - */
> - case INLINE_IPSEC_OP_RESP:
> - valid_len += sizeof(struct virtchnl_ipsec_resp);
> - break;
> - default:
> - valid_len = 0;
> - break;
> - }
> -
> - return valid_len;
> -}
> -
> -#endif /* _VIRTCHNL_INLINE_IPSEC_H_ */
> diff --git a/drivers/common/idpf/meson.build
> b/drivers/common/idpf/meson.build
> index 63f60accd9..80c8906f80 100644
> --- a/drivers/common/idpf/meson.build
> +++ b/drivers/common/idpf/meson.build
> @@ -5,6 +5,8 @@ if dpdk_conf.get('RTE_IOVA_IN_MBUF') == 0
> subdir_done()
> endif
>
> +includes += include_directories('../iavf')
> +
> deps += ['mbuf']
>
> sources = files(
> --
> 2.25.1
next prev parent reply other threads:[~2023-04-24 11:52 UTC|newest]
Thread overview: 56+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-04-13 9:44 [PATCH 00/18] update idpf " Wenjing Qiao
2023-04-13 9:44 ` [PATCH 01/18] common/idpf: support flow subscription Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 00/15] update idpf shared code Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 01/15] common/idpf: remove virtchnl related " Wenjing Qiao
2023-04-24 11:52 ` Zhang, Qi Z [this message]
2023-04-26 10:22 ` [PATCH v3 00/15] update idpf base code Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 01/15] common/idpf/base: remove virtchnl related " Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 02/15] common/idpf/base: fix ctlq message send and receive Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 03/15] common/idpf/base: fix ITR register definitions for AVF Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 04/15] common/idpf/base: remove qregion struct variables Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 05/15] common/idpf/base: move OEM capability to the last bit Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 06/15] common/idpf/base: modify SSO/LSO and ITR fields Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 07/15] common/idpf/base: add virtchnl2 error codes Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 08/15] common/idpf/base: swap opcode and retval location in msg struct Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 09/15] common/idpf/base: fix idpf_send_msg_to_cp prototypes Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 10/15] common/idpf/base: fix memory leaks on ctrlq functions Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 11/15] common/idpf/base: allocate static buffer at initialization Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 12/15] common/idpf/base: replace MAKEMASK to IDPF_M Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 13/15] common/idpf/base: add/delete queue groups commands Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 14/15] common/idpf/base: add func to clean all DESCs on controlq Wenjing Qiao
2023-04-26 10:22 ` [PATCH v3 15/15] common/idpf/base: update license and README Wenjing Qiao
2023-04-26 11:56 ` Zhang, Qi Z
2023-06-12 10:18 ` Thomas Monjalon
2023-04-26 12:40 ` [PATCH v3 00/15] update idpf base code Zhang, Qi Z
2023-04-21 8:40 ` [PATCH v2 02/15] common/idpf: fix ctlq message send and receive Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 03/15] common/idpf: fix ITR register definitions for AVF Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 04/15] common/idpf: remove qregion struct variables Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 05/15] common/idpf: move OEM capability to the last bit Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 06/15] common/idpf: modify SSO/LSO and ITR fields Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 07/15] common/idpf: add virtchnl2 error codes Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 08/15] common/idpf: swap opcode and retval location in msg struct Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 09/15] common/idpf: fix idpf_send_msg_to_cp prototypes Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 10/15] common/idpf: fix memory leaks on ctrlq functions Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 11/15] common/idpf: allocate static buffer at initialization Wenjing Qiao
2023-04-24 12:15 ` Zhang, Qi Z
2023-04-21 8:40 ` [PATCH v2 12/15] common/idpf: replace MAKEMASK to IDPF_M Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 13/15] common/idpf: add/delete queue groups commands Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 14/15] common/idpf: add func to clean all DESCs on controlq Wenjing Qiao
2023-04-21 8:40 ` [PATCH v2 15/15] common/idpf: update license and README Wenjing Qiao
2023-04-13 9:44 ` [PATCH 02/18] common/idpf: fix ctlq message send and receive Wenjing Qiao
2023-04-13 9:44 ` [PATCH 03/18] common/idpf: fix ITR register definitions for AVF Wenjing Qiao
2023-04-13 9:44 ` [PATCH 04/18] common/idpf: remove qregion struct variables Wenjing Qiao
2023-04-13 9:44 ` [PATCH 05/18] common/idpf: move OEM capability to the last bit Wenjing Qiao
2023-04-13 9:44 ` [PATCH 06/18] common/idpf: modify SSO/LSO and ITR fields Wenjing Qiao
2023-04-13 9:44 ` [PATCH 07/18] common/idpf: add virtchnl2 error codes Wenjing Qiao
2023-04-13 9:44 ` [PATCH 08/18] common/idpf: swap opcode and retval location in msg struct Wenjing Qiao
2023-04-13 9:44 ` [PATCH 09/18] common/idpf: fix idpf_send_msg_to_cp prototypes Wenjing Qiao
2023-04-13 9:44 ` [PATCH 10/18] common/idpf: fix memory leaks on ctrlq functions Wenjing Qiao
2023-04-13 9:44 ` [PATCH 11/18] common/idpf: allocate static buffer at initialization Wenjing Qiao
2023-04-13 9:44 ` [PATCH 12/18] common/idpf: add SyncE support over VF Wenjing Qiao
2023-04-13 9:44 ` [PATCH 13/18] common/idpf: replace MAKEMASK to IDPF_M Wenjing Qiao
2023-04-13 9:44 ` [PATCH 14/18] common/idpf: add GNSS support over VF Wenjing Qiao
2023-04-13 9:44 ` [PATCH 15/18] common/idpf: add/delete queue groups commands Wenjing Qiao
2023-04-13 9:45 ` [PATCH 16/18] common/idpf: add func to clean all DESCs on controlq Wenjing Qiao
2023-04-13 9:45 ` [PATCH 17/18] common/idpf: fix cannot understand warnings Wenjing Qiao
2023-04-13 9:45 ` [PATCH 18/18] common/idpf: update license and README Wenjing Qiao
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=DM4PR11MB59949FD519EA20D891996C47D7679@DM4PR11MB5994.namprd11.prod.outlook.com \
--to=qi.z.zhang@intel.com \
--cc=beilei.xing@intel.com \
--cc=dev@dpdk.org \
--cc=jingjing.wu@intel.com \
--cc=wenjing.qiao@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).