ice: Add support Flex RXD

Add new VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC flag, opcode
VIRTCHNL_OP_GET_SUPPORTED_RXDIDS and add member rxdid
in struct virtchnl_rxq_info to support AVF Flex RXD
extension.

Add support to allow VF to query flexible descriptor RXDIDs supported
by DDP package and configure Rx queues with selected RXDID for IAVF.

Add code to allow VIRTCHNL_OP_GET_SUPPORTED_RXDIDS message to be
processed. Add necessary macros for registers.

Signed-off-by: Leyi Rong <leyi.rong@intel.com>
Signed-off-by: Xu Ting <ting.xu@intel.com>
Signed-off-by: Michal Jaron <michalx.jaron@intel.com>
Signed-off-by: Mateusz Palczewski <mateusz.palczewski@intel.com>
Tested-by: Maxime Coquelin <maxime.coquelin@redhat.com>
Tested-by: Konrad Jankowski <konrad0.jankowski@intel.com>
Signed-off-by: Jacob Keller <jacob.e.keller@intel.com>
Link: https://lore.kernel.org/r/20221025161252.1952939-1-jacob.e.keller@intel.com
Signed-off-by: Paolo Abeni <pabeni@redhat.com>

diff --git a/drivers/net/ethernet/intel/ice/ice.h b/drivers/net/ethernet/intel/ice/ice.h
index d75c8d11f867e1a71d538c177f71d5b8dc866235..f88ee051e71c48572b9403a6becb8b2337f54b1f 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice.h
+++ b/drivers/net/ethernet/intel/ice/ice.h
@@ -609,6 +609,8 @@ struct ice_pf {
        u16 num_dmac_chnl_fltrs;
        struct hlist_head tc_flower_fltr_list;
 
+       u64 supported_rxdids;
+
        __le64 nvm_phy_type_lo; /* NVM PHY type low */
        __le64 nvm_phy_type_hi; /* NVM PHY type high */
        struct ice_link_default_override_tlv link_dflt_override;

diff --git a/drivers/net/ethernet/intel/ice/ice_hw_autogen.h b/drivers/net/ethernet/intel/ice/ice_hw_autogen.h
index d16738a3d3a77c9814c764f148c7335827e65baa..a92dc9a16035833d9f6af09f76224ae99eaae4ea 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_hw_autogen.h
+++ b/drivers/net/ethernet/intel/ice/ice_hw_autogen.h
@@ -110,6 +110,9 @@
 #define PRTDCB_TUP2TC                          0x001D26C0
 #define GL_PREEXT_L2_PMASK0(_i)                        (0x0020F0FC + ((_i) * 4))
 #define GL_PREEXT_L2_PMASK1(_i)                        (0x0020F108 + ((_i) * 4))
+#define GLFLXP_RXDID_FLAGS(_i, _j)              (0x0045D000 + ((_i) * 4 + (_j) * 256))
+#define GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_S       0
+#define GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_M       ICE_M(0x3F, 0)
 #define GLFLXP_RXDID_FLX_WRD_0(_i)             (0x0045c800 + ((_i) * 4))
 #define GLFLXP_RXDID_FLX_WRD_0_PROT_MDID_S     0
 #define GLFLXP_RXDID_FLX_WRD_0_PROT_MDID_M     ICE_M(0xFF, 0)

diff --git a/drivers/net/ethernet/intel/ice/ice_virtchnl.c b/drivers/net/ethernet/intel/ice/ice_virtchnl.c
index 2b4c791b6cbad3aa9d801357abcf7593cc3d34fd..c1fa94381f4e889bac204eaafead1d797147943f 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_virtchnl.c
+++ b/drivers/net/ethernet/intel/ice/ice_virtchnl.c
@@ -462,6 +462,9 @@ static int ice_vc_get_vf_res_msg(struct ice_vf *vf, u8 *msg)
                        vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_REG;
        }
 
+       if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC)
+               vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC;
+
        if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_FDIR_PF)
                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_FDIR_PF;
 
@@ -1618,6 +1621,9 @@ static int ice_vc_cfg_qs_msg(struct ice_vf *vf, u8 *msg)
        }
 
        for (i = 0; i < qci->num_queue_pairs; i++) {
+               struct ice_hw *hw;
+               u32 rxdid;
+               u16 pf_q;
                qpi = &qci->qpair[i];
                if (qpi->txq.vsi_id != qci->vsi_id ||
                    qpi->rxq.vsi_id != qci->vsi_id ||
@@ -1686,6 +1692,25 @@ static int ice_vc_cfg_qs_msg(struct ice_vf *vf, u8 *msg)
                                goto error_param;
                        }
                }
+
+               /* VF Rx queue RXDID configuration */
+               pf_q = vsi->rxq_map[qpi->rxq.queue_id];
+               rxdid = qpi->rxq.rxdid;
+               hw = &vsi->back->hw;
+
+               /* If Rx flex desc is supported, select RXDID for Rx queues.
+                * Otherwise, use legacy 32byte descriptor format.
+                * Legacy 16byte descriptor is not supported. If this RXDID
+                * is selected, return error.
+                */
+               if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC) {
+                       if (!(BIT(rxdid) & pf->supported_rxdids))
+                               goto error_param;
+               } else {
+                       rxdid = ICE_RXDID_LEGACY_1;
+               }
+
+               ice_write_qrxflxp_cntxt(hw, pf_q, rxdid, 0x03, false);
        }
 
        /* send the response to the VF */
@@ -2456,6 +2481,62 @@ error_param:
                                     v_ret, NULL, 0);
 }
 
+/**
+ * ice_vc_query_rxdid - query RXDID supported by DDP package
+ * @vf: pointer to VF info
+ *
+ * Called from VF to query a bitmap of supported flexible
+ * descriptor RXDIDs of a DDP package.
+ */
+static int ice_vc_query_rxdid(struct ice_vf *vf)
+{
+       enum virtchnl_status_code v_ret = VIRTCHNL_STATUS_SUCCESS;
+       struct virtchnl_supported_rxdids *rxdid = NULL;
+       struct ice_hw *hw = &vf->pf->hw;
+       struct ice_pf *pf = vf->pf;
+       int len = 0;
+       int ret, i;
+       u32 regval;
+
+       if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+               v_ret = VIRTCHNL_STATUS_ERR_PARAM;
+               goto err;
+       }
+
+       if (!(vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC)) {
+               v_ret = VIRTCHNL_STATUS_ERR_PARAM;
+               goto err;
+       }
+
+       len = sizeof(struct virtchnl_supported_rxdids);
+       rxdid = kzalloc(len, GFP_KERNEL);
+       if (!rxdid) {
+               v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
+               len = 0;
+               goto err;
+       }
+
+       /* Read flexiflag registers to determine whether the
+        * corresponding RXDID is configured and supported or not.
+        * Since Legacy 16byte descriptor format is not supported,
+        * start from Legacy 32byte descriptor.
+        */
+       for (i = ICE_RXDID_LEGACY_1; i < ICE_FLEX_DESC_RXDID_MAX_NUM; i++) {
+               regval = rd32(hw, GLFLXP_RXDID_FLAGS(i, 0));
+               if ((regval >> GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_S)
+                       & GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_M)
+                       rxdid->supported_rxdids |= BIT(i);
+       }
+
+       pf->supported_rxdids = rxdid->supported_rxdids;
+
+err:
+       ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_SUPPORTED_RXDIDS,
+                                   v_ret, (u8 *)rxdid, len);
+       kfree(rxdid);
+       return ret;
+}
+
 /**
  * ice_vf_init_vlan_stripping - enable/disable VLAN stripping on initialization
  * @vf: VF to enable/disable VLAN stripping for on initialization
@@ -3490,6 +3571,7 @@ static const struct ice_virtchnl_ops ice_virtchnl_dflt_ops = {
        .cfg_promiscuous_mode_msg = ice_vc_cfg_promiscuous_mode_msg,
        .add_vlan_msg = ice_vc_add_vlan_msg,
        .remove_vlan_msg = ice_vc_remove_vlan_msg,
+       .query_rxdid = ice_vc_query_rxdid,
        .ena_vlan_stripping = ice_vc_ena_vlan_stripping,
        .dis_vlan_stripping = ice_vc_dis_vlan_stripping,
        .handle_rss_cfg_msg = ice_vc_handle_rss_cfg,
@@ -3624,6 +3706,7 @@ static const struct ice_virtchnl_ops ice_virtchnl_repr_ops = {
        .cfg_promiscuous_mode_msg = ice_vc_repr_cfg_promiscuous_mode,
        .add_vlan_msg = ice_vc_add_vlan_msg,
        .remove_vlan_msg = ice_vc_remove_vlan_msg,
+       .query_rxdid = ice_vc_query_rxdid,
        .ena_vlan_stripping = ice_vc_ena_vlan_stripping,
        .dis_vlan_stripping = ice_vc_dis_vlan_stripping,
        .handle_rss_cfg_msg = ice_vc_handle_rss_cfg,
@@ -3764,6 +3847,9 @@ error_handler:
        case VIRTCHNL_OP_DEL_VLAN:
                err = ops->remove_vlan_msg(vf, msg);
                break;
+       case VIRTCHNL_OP_GET_SUPPORTED_RXDIDS:
+               err = ops->query_rxdid(vf);
+               break;
        case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING:
                err = ops->ena_vlan_stripping(vf);
                break;

diff --git a/drivers/net/ethernet/intel/ice/ice_virtchnl.h b/drivers/net/ethernet/intel/ice/ice_virtchnl.h
index b5a3fd8adbb4e4123bc213fbc8ce398525d04881..4867a92ebefb393c90c4c072e10cbc83e8983507 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_virtchnl.h
+++ b/drivers/net/ethernet/intel/ice/ice_virtchnl.h
@@ -17,6 +17,7 @@
  * broadcast, and 16 for additional unicast/multicast filters
  */
 #define ICE_MAX_MACADDR_PER_VF         18
+#define ICE_FLEX_DESC_RXDID_MAX_NUM    64
 
 struct ice_virtchnl_ops {
        int (*get_ver_msg)(struct ice_vf *vf, u8 *msg);
@@ -35,6 +36,7 @@ struct ice_virtchnl_ops {
        int (*cfg_promiscuous_mode_msg)(struct ice_vf *vf, u8 *msg);
        int (*add_vlan_msg)(struct ice_vf *vf, u8 *msg);
        int (*remove_vlan_msg)(struct ice_vf *vf, u8 *msg);
+       int (*query_rxdid)(struct ice_vf *vf);
        int (*ena_vlan_stripping)(struct ice_vf *vf);
        int (*dis_vlan_stripping)(struct ice_vf *vf);
        int (*handle_rss_cfg_msg)(struct ice_vf *vf, u8 *msg, bool add);

diff --git a/drivers/net/ethernet/intel/ice/ice_virtchnl_allowlist.c b/drivers/net/ethernet/intel/ice/ice_virtchnl_allowlist.c
index 5a82216e7d034eb7020c104daeccc873ca50b446..7d547fa616fa69d699e319ef7665da38e22f84fd 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_virtchnl_allowlist.c
+++ b/drivers/net/ethernet/intel/ice/ice_virtchnl_allowlist.c
@@ -70,6 +70,11 @@ static const u32 rss_pf_allowlist_opcodes[] = {
        VIRTCHNL_OP_GET_RSS_HENA_CAPS, VIRTCHNL_OP_SET_RSS_HENA,
 };
 
+/* VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC */
+static const u32 rx_flex_desc_allowlist_opcodes[] = {
+       VIRTCHNL_OP_GET_SUPPORTED_RXDIDS,
+};
+
 /* VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF */
 static const u32 adv_rss_pf_allowlist_opcodes[] = {
        VIRTCHNL_OP_ADD_RSS_CFG, VIRTCHNL_OP_DEL_RSS_CFG,
@@ -96,6 +101,7 @@ static const struct allowlist_opcode_info allowlist_opcodes[] = {
        ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_REQ_QUEUES, req_queues_allowlist_opcodes),
        ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_VLAN, vlan_allowlist_opcodes),
        ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_RSS_PF, rss_pf_allowlist_opcodes),
+       ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC, rx_flex_desc_allowlist_opcodes),
        ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF, adv_rss_pf_allowlist_opcodes),
        ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_FDIR_PF, fdir_pf_allowlist_opcodes),
        ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_VLAN_V2, vlan_v2_allowlist_opcodes),

diff --git a/include/linux/avf/virtchnl.h b/include/linux/avf/virtchnl.h
index 2ce27e8e4f1954c0274a92a09ba5998ce7ebef8e..d91af50ac58d522c576d5382ce561e4c06b85ae8 100644 (file)
--- a/include/linux/avf/virtchnl.h
+++ b/include/linux/avf/virtchnl.h
@@ -136,7 +136,8 @@ enum virtchnl_ops {
        VIRTCHNL_OP_DISABLE_CHANNELS = 31,
        VIRTCHNL_OP_ADD_CLOUD_FILTER = 32,
        VIRTCHNL_OP_DEL_CLOUD_FILTER = 33,
-       /* opcode 34 - 44 are reserved */
+       /* opcode 34 - 43 are reserved */
+       VIRTCHNL_OP_GET_SUPPORTED_RXDIDS = 44,
        VIRTCHNL_OP_ADD_RSS_CFG = 45,
        VIRTCHNL_OP_DEL_RSS_CFG = 46,
        VIRTCHNL_OP_ADD_FDIR_FILTER = 47,
@@ -263,6 +264,7 @@ VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vsi_resource);
 #define VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM      BIT(22)
 #define VIRTCHNL_VF_OFFLOAD_ADQ                        BIT(23)
 #define VIRTCHNL_VF_OFFLOAD_USO                        BIT(25)
+#define VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC       BIT(26)
 #define VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF         BIT(27)
 #define VIRTCHNL_VF_OFFLOAD_FDIR_PF            BIT(28)
 
@@ -318,7 +320,9 @@ struct virtchnl_rxq_info {
        u16 splithdr_enabled; /* deprecated with AVF 1.0 */
        u32 databuffer_size;
        u32 max_pkt_size;
-       u32 pad1;
+       u8 pad0;
+       u8 rxdid;
+       u8 pad1[2];
        u64 dma_ring_addr;
        enum virtchnl_rx_hsplit rx_split_pos; /* deprecated with AVF 1.0 */
        u32 pad2;
@@ -970,6 +974,10 @@ struct virtchnl_filter {
 
 VIRTCHNL_CHECK_STRUCT_LEN(272, virtchnl_filter);
 
+struct virtchnl_supported_rxdids {
+       u64 supported_rxdids;
+};
+
 /* 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
@@ -1499,6 +1507,8 @@ virtchnl_vc_validate_vf_msg(struct virtchnl_version_info *ver, u32 v_opcode,
        case VIRTCHNL_OP_DEL_CLOUD_FILTER:
                valid_len = sizeof(struct virtchnl_filter);
                break;
+       case VIRTCHNL_OP_GET_SUPPORTED_RXDIDS:
+               break;
        case VIRTCHNL_OP_ADD_RSS_CFG:
        case VIRTCHNL_OP_DEL_RSS_CFG:
                valid_len = sizeof(struct virtchnl_rss_cfg);