From patchwork Wed Jan 20 03:15:41 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Wang, Haiyue" X-Patchwork-Id: 86944 X-Patchwork-Delegate: qi.z.zhang@intel.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 64890A0A05; Wed, 20 Jan 2021 04:31:37 +0100 (CET) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id DDA01140D26; Wed, 20 Jan 2021 04:31:36 +0100 (CET) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by mails.dpdk.org (Postfix) with ESMTP id 62975140D25 for ; Wed, 20 Jan 2021 04:31:34 +0100 (CET) IronPort-SDR: KmCPcNP5M+EPkT63H+OeryVypuh2QrK5kxuywX256JcEiUhVlHvG6bzqCBdcwU4JA0qLlq95QR iBbxnrl7s+YQ== X-IronPort-AV: E=McAfee;i="6000,8403,9869"; a="197760859" X-IronPort-AV: E=Sophos;i="5.79,360,1602572400"; d="scan'208";a="197760859" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 19 Jan 2021 19:31:33 -0800 IronPort-SDR: kglGtM03RVS5njDNDIo2NAmNYAeGykohEpt5po7D643EqgCDcT2DlKl4rPvDYilk5ZlA7pfkYn ufXRRrYOaw/Q== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.79,360,1602572400"; d="scan'208";a="384208759" Received: from npg-dpdk-haiyue-3.sh.intel.com ([10.67.118.189]) by orsmga008.jf.intel.com with ESMTP; 19 Jan 2021 19:31:30 -0800 From: Haiyue Wang To: dev@dpdk.org Cc: qiming.yang@intel.com, qi.z.zhang@intel.com, qi.fu@intel.com, Haiyue Wang , Brett Creeley , Jingjing Wu , Beilei Xing Date: Wed, 20 Jan 2021 11:15:41 +0800 Message-Id: <20210120031541.407097-1-haiyue.wang@intel.com> X-Mailer: git-send-email 2.30.0 In-Reply-To: <20210120011039.164462-1-haiyue.wang@intel.com> References: <20210120011039.164462-1-haiyue.wang@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2] common/iavf: support VLAN filtering X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" In order to support enable/disable VLAN filtering the VF has to negotiate the capability via VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2. If VIRTCHNL_VLAN_TOGGLE is allowed for the VLAN fitlering capabilities, then there needs to be a method to allow this. Make the necessary changes to support this. Also, since the virtchnl_vlan_offload message has the desired format, change the structure name to virtchnl_vlan_setting so it can be used for VIRTCHNL_OP_ENABLE_VLAN_FILTERING_V2 and VIRTCHNL_OP_DISABLE_VLAN_FILTERING_V2. Signed-off-by: Brett Creeley Signed-off-by: Haiyue Wang --- v2: update the commit title and message, main new feature, not just rename. --- drivers/common/iavf/virtchnl.h | 67 ++++++++++++++++++++++++++++------ drivers/net/iavf/iavf_vchnl.c | 36 +++++++++--------- 2 files changed, 74 insertions(+), 29 deletions(-) diff --git a/drivers/common/iavf/virtchnl.h b/drivers/common/iavf/virtchnl.h index 09e42f034c..6b99e170f0 100644 --- a/drivers/common/iavf/virtchnl.h +++ b/drivers/common/iavf/virtchnl.h @@ -149,6 +149,8 @@ enum virtchnl_ops { 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_ENABLE_QUEUES_V2 = 107, VIRTCHNL_OP_DISABLE_QUEUES_V2 = 108, VIRTCHNL_OP_MAP_QUEUE_VECTOR = 111, @@ -258,6 +260,10 @@ static inline const char *virtchnl_op_str(enum virtchnl_ops v_opcode) 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_MAX: return "VIRTCHNL_OP_MAX"; default: @@ -914,13 +920,13 @@ VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_vlan_filter_list_v2); * * 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_offload structure in the + * 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_offload.inner_ethertype_setting = + * virtchnl_vlan_setting.inner_ethertype_setting = * VIRTCHNL_VLAN_ETHERTYPE_8100; * - * virtchnl_vlan_offload.vport_id = vport_id or vsi_id assigned to the VF on + * 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 @@ -952,11 +958,11 @@ VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_vlan_filter_list_v2); * would populate the virthcnl_vlan_offload_structure in the following manner * and send the VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 message. * - * virtchnl_vlan_offload.outer_ethertype_setting = + * virtchnl_vlan_setting.outer_ethertype_setting = * VIRTHCNL_VLAN_ETHERTYPE_8100 | * VIRTHCNL_VLAN_ETHERTYPE_88A8; * - * virtchnl_vlan_offload.vport_id = vport_id or vsi_id assigned to the VF on + * 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 @@ -981,24 +987,61 @@ VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_vlan_filter_list_v2); * VIRTCHNL_ETHERTYPE_STRIPPING_MATCHES_INSERTION; * * In order to enable outer VLAN stripping for 0x88a8 VLANs, the VF would - * populate the virtchnl_vlan_offload_structure in the following manner and send + * 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_offload.outer_ethertype_setting = VIRTHCNL_VLAN_ETHERTYPE_88A8; + * virtchnl_vlan_setting.outer_ethertype_setting = VIRTHCNL_VLAN_ETHERTYPE_88A8; * - * virtchnl_vlan_offload.vport_id = vport_id or vsi_id assigned to the VF on + * 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_offload { +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_offload); +VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vlan_setting); /* VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE * VF sends VSI id and flags. @@ -2017,7 +2060,9 @@ virtchnl_vc_validate_vf_msg(struct virtchnl_version_info *ver, u32 v_opcode, case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2: case VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2: case VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2: - valid_len = sizeof(struct virtchnl_vlan_offload); + 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_ENABLE_QUEUES_V2: case VIRTCHNL_OP_DISABLE_QUEUES_V2: diff --git a/drivers/net/iavf/iavf_vchnl.c b/drivers/net/iavf/iavf_vchnl.c index 3ef29d509d..27eb59ad91 100644 --- a/drivers/net/iavf/iavf_vchnl.c +++ b/drivers/net/iavf/iavf_vchnl.c @@ -529,32 +529,32 @@ iavf_config_vlan_strip_v2(struct iavf_adapter *adapter, bool enable) { struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(adapter); struct virtchnl_vlan_supported_caps *supported_caps; - struct virtchnl_vlan_offload vlan_strip; + struct virtchnl_vlan_setting vlan_strip_setting; struct iavf_cmd_info args; uint32_t stripping_caps; - uint32_t *vlan_setting; + uint32_t *ethertype; int ret; supported_caps = &vf->vlan_v2_caps.offloads.stripping_support; if (supported_caps->outer) { stripping_caps = supported_caps->outer; - vlan_setting = &vlan_strip.outer_ethertype_setting; + ethertype = &vlan_strip_setting.outer_ethertype_setting; } else { stripping_caps = supported_caps->inner; - vlan_setting = &vlan_strip.inner_ethertype_setting; + ethertype = &vlan_strip_setting.inner_ethertype_setting; } if (!(stripping_caps & VIRTCHNL_VLAN_ETHERTYPE_8100)) return -ENOTSUP; - memset(&vlan_strip, 0, sizeof(vlan_strip)); - vlan_strip.vport_id = vf->vsi_res->vsi_id; - *vlan_setting = VIRTCHNL_VLAN_ETHERTYPE_8100; + memset(&vlan_strip_setting, 0, sizeof(vlan_strip_setting)); + vlan_strip_setting.vport_id = vf->vsi_res->vsi_id; + *ethertype = VIRTCHNL_VLAN_ETHERTYPE_8100; args.ops = enable ? VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2 : VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2; - args.in_args = (uint8_t *)&vlan_strip; - args.in_args_size = sizeof(vlan_strip); + args.in_args = (uint8_t *)&vlan_strip_setting; + args.in_args_size = sizeof(vlan_strip_setting); args.out_buffer = vf->aq_resp; args.out_size = IAVF_AQ_BUF_SZ; ret = iavf_execute_vf_cmd(adapter, &args); @@ -571,32 +571,32 @@ iavf_config_vlan_insert_v2(struct iavf_adapter *adapter, bool enable) { struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(adapter); struct virtchnl_vlan_supported_caps *supported_caps; - struct virtchnl_vlan_offload vlan_insert; + struct virtchnl_vlan_setting vlan_insert_setting; struct iavf_cmd_info args; uint32_t insertion_caps; - uint32_t *vlan_setting; + uint32_t *ethertype; int ret; supported_caps = &vf->vlan_v2_caps.offloads.insertion_support; if (supported_caps->outer) { insertion_caps = supported_caps->outer; - vlan_setting = &vlan_insert.outer_ethertype_setting; + ethertype = &vlan_insert_setting.outer_ethertype_setting; } else { insertion_caps = supported_caps->inner; - vlan_setting = &vlan_insert.inner_ethertype_setting; + ethertype = &vlan_insert_setting.inner_ethertype_setting; } if (!(insertion_caps & VIRTCHNL_VLAN_ETHERTYPE_8100)) return -ENOTSUP; - memset(&vlan_insert, 0, sizeof(vlan_insert)); - vlan_insert.vport_id = vf->vsi_res->vsi_id; - *vlan_setting = VIRTCHNL_VLAN_ETHERTYPE_8100; + memset(&vlan_insert_setting, 0, sizeof(vlan_insert_setting)); + vlan_insert_setting.vport_id = vf->vsi_res->vsi_id; + *ethertype = VIRTCHNL_VLAN_ETHERTYPE_8100; args.ops = enable ? VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2 : VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2; - args.in_args = (uint8_t *)&vlan_insert; - args.in_args_size = sizeof(vlan_insert); + args.in_args = (uint8_t *)&vlan_insert_setting; + args.in_args_size = sizeof(vlan_insert_setting); args.out_buffer = vf->aq_resp; args.out_size = IAVF_AQ_BUF_SZ; ret = iavf_execute_vf_cmd(adapter, &args);