ice: Support configuring the device to Double VLAN Mode (a1ffafb0) · Commits · EulixOS / Software / Kernel

drivers/net/ethernet/intel/ice/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@ ice-y := ice_main.o \
		ice_vsi_vlan_lib.o \
		ice_fdir.o \
		ice_ethtool_fdir.o \
		ice_vlan_mode.o \
		ice_flex_pipe.o \
		ice_flow.o \
		ice_idc.o \

drivers/net/ethernet/intel/ice/ice_adminq_cmd.h

+63 −1

Original line number	Diff line number	Diff line
		@@ -226,6 +226,15 @@ struct ice_aqc_get_sw_cfg_resp_elem {
		#define ICE_AQC_GET_SW_CONF_RESP_IS_VF BIT(15)
		};

		/* Set Port parameters, (direct, 0x0203) */
		struct ice_aqc_set_port_params {
		__le16 cmd_flags;
		#define ICE_AQC_SET_P_PARAMS_DOUBLE_VLAN_ENA BIT(2)
		__le16 bad_frame_vsi;
		__le16 swid;
		u8 reserved[10];
		};

		/* These resource type defines are used for all switch resource
		* commands where a resource type is required, such as:
		* Get Resource Allocation command (indirect 0x0204)
		@@ -283,6 +292,40 @@ struct ice_aqc_alloc_free_res_elem {
		struct ice_aqc_res_elem elem[];
		};

		/* Request buffer for Set VLAN Mode AQ command (indirect 0x020C) */
		struct ice_aqc_set_vlan_mode {
		u8 reserved;
		u8 l2tag_prio_tagging;
		#define ICE_AQ_VLAN_PRIO_TAG_S 0
		#define ICE_AQ_VLAN_PRIO_TAG_M (0x7 << ICE_AQ_VLAN_PRIO_TAG_S)
		#define ICE_AQ_VLAN_PRIO_TAG_NOT_SUPPORTED 0x0
		#define ICE_AQ_VLAN_PRIO_TAG_STAG 0x1
		#define ICE_AQ_VLAN_PRIO_TAG_OUTER_CTAG 0x2
		#define ICE_AQ_VLAN_PRIO_TAG_OUTER_VLAN 0x3
		#define ICE_AQ_VLAN_PRIO_TAG_INNER_CTAG 0x4
		#define ICE_AQ_VLAN_PRIO_TAG_MAX 0x4
		#define ICE_AQ_VLAN_PRIO_TAG_ERROR 0x7
		u8 l2tag_reserved[64];
		u8 rdma_packet;
		#define ICE_AQ_VLAN_RDMA_TAG_S 0
		#define ICE_AQ_VLAN_RDMA_TAG_M (0x3F << ICE_AQ_VLAN_RDMA_TAG_S)
		#define ICE_AQ_SVM_VLAN_RDMA_PKT_FLAG_SETTING 0x10
		#define ICE_AQ_DVM_VLAN_RDMA_PKT_FLAG_SETTING 0x1A
		u8 rdma_reserved[2];
		u8 mng_vlan_prot_id;
		#define ICE_AQ_VLAN_MNG_PROTOCOL_ID_OUTER 0x10
		#define ICE_AQ_VLAN_MNG_PROTOCOL_ID_INNER 0x11
		u8 prot_id_reserved[30];
		};

		/* Response buffer for Get VLAN Mode AQ command (indirect 0x020D) */
		struct ice_aqc_get_vlan_mode {
		u8 vlan_mode;
		#define ICE_AQ_VLAN_MODE_DVM_ENA BIT(0)
		u8 l2tag_prio_tagging;
		u8 reserved[98];
		};

		/* Add VSI (indirect 0x0210)
		* Update VSI (indirect 0x0211)
		* Get VSI (indirect 0x0212)
		@@ -494,9 +537,13 @@ struct ice_aqc_add_get_recipe {

		struct ice_aqc_recipe_content {
		u8 rid;
		#define ICE_AQ_RECIPE_ID_S 0
		#define ICE_AQ_RECIPE_ID_M (0x3F << ICE_AQ_RECIPE_ID_S)
		#define ICE_AQ_RECIPE_ID_IS_ROOT BIT(7)
		#define ICE_AQ_SW_ID_LKUP_IDX 0
		u8 lkup_indx[5];
		#define ICE_AQ_RECIPE_LKUP_DATA_S 0
		#define ICE_AQ_RECIPE_LKUP_DATA_M (0x3F << ICE_AQ_RECIPE_LKUP_DATA_S)
		#define ICE_AQ_RECIPE_LKUP_IGNORE BIT(7)
		#define ICE_AQ_SW_ID_LKUP_MASK 0x00FF
		__le16 mask[5];
		@@ -507,15 +554,25 @@ struct ice_aqc_recipe_content {
		u8 rsvd0[3];
		u8 act_ctrl_join_priority;
		u8 act_ctrl_fwd_priority;
		#define ICE_AQ_RECIPE_FWD_PRIORITY_S 0
		#define ICE_AQ_RECIPE_FWD_PRIORITY_M (0xF << ICE_AQ_RECIPE_FWD_PRIORITY_S)
		u8 act_ctrl;
		#define ICE_AQ_RECIPE_ACT_NEED_PASS_L2 BIT(0)
		#define ICE_AQ_RECIPE_ACT_ALLOW_PASS_L2 BIT(1)
		#define ICE_AQ_RECIPE_ACT_INV_ACT BIT(2)
		#define ICE_AQ_RECIPE_ACT_PRUNE_INDX_S 4
		#define ICE_AQ_RECIPE_ACT_PRUNE_INDX_M (0x3 << ICE_AQ_RECIPE_ACT_PRUNE_INDX_S)
		u8 rsvd1;
		__le32 dflt_act;
		#define ICE_AQ_RECIPE_DFLT_ACT_S 0
		#define ICE_AQ_RECIPE_DFLT_ACT_M (0x7FFFF << ICE_AQ_RECIPE_DFLT_ACT_S)
		#define ICE_AQ_RECIPE_DFLT_ACT_VALID BIT(31)
		};

		struct ice_aqc_recipe_data_elem {
		u8 recipe_indx;
		u8 resp_bits;
		#define ICE_AQ_RECIPE_WAS_UPDATED BIT(0)
		u8 rsvd0[2];
		u8 recipe_bitmap[8];
		u8 rsvd1[4];
		@@ -1888,7 +1945,7 @@ struct ice_aqc_get_clear_fw_log {
		};

		/* Download Package (indirect 0x0C40) */
		/* Also used for Update Package (indirect 0x0C42) */
		/* Also used for Update Package (indirect 0x0C41 and 0x0C42) */
		struct ice_aqc_download_pkg {
		u8 flags;
		#define ICE_AQC_DOWNLOAD_PKG_LAST_BUF 0x01
		@@ -2014,6 +2071,7 @@ struct ice_aq_desc {
		struct ice_aqc_sff_eeprom read_write_sff_param;
		struct ice_aqc_set_port_id_led set_port_id_led;
		struct ice_aqc_get_sw_cfg get_sw_conf;
		struct ice_aqc_set_port_params set_port_params;
		struct ice_aqc_sw_rules sw_rules;
		struct ice_aqc_add_get_recipe add_get_recipe;
		struct ice_aqc_recipe_to_profile recipe_to_profile;
		@@ -2115,10 +2173,13 @@ enum ice_adminq_opc {

		/* internal switch commands */
		ice_aqc_opc_get_sw_cfg = 0x0200,
		ice_aqc_opc_set_port_params = 0x0203,

		/* Alloc/Free/Get Resources */
		ice_aqc_opc_alloc_res = 0x0208,
		ice_aqc_opc_free_res = 0x0209,
		ice_aqc_opc_set_vlan_mode_parameters = 0x020C,
		ice_aqc_opc_get_vlan_mode_parameters = 0x020D,

		/* VSI commands */
		ice_aqc_opc_add_vsi = 0x0210,
		@@ -2209,6 +2270,7 @@ enum ice_adminq_opc {

		/* package commands */
		ice_aqc_opc_download_pkg = 0x0C40,
		ice_aqc_opc_upload_section = 0x0C41,
		ice_aqc_opc_update_pkg = 0x0C42,
		ice_aqc_opc_get_pkg_info_list = 0x0C43,

drivers/net/ethernet/intel/ice/ice_common.c

+44 −5

Original line number	Diff line number	Diff line
		@@ -1518,16 +1518,27 @@ ice_aq_send_cmd(struct ice_hw hw, struct ice_aq_desc desc, void *buf,

		/* When a package download is in process (i.e. when the firmware's
		* Global Configuration Lock resource is held), only the Download
		* Package, Get Version, Get Package Info List and Release Resource
		* (with resource ID set to Global Config Lock) AdminQ commands are
		* allowed; all others must block until the package download completes
		* and the Global Config Lock is released. See also
		* ice_acquire_global_cfg_lock().
		* Package, Get Version, Get Package Info List, Upload Section,
		* Update Package, Set Port Parameters, Get/Set VLAN Mode Parameters,
		* Add Recipe, Set Recipes to Profile Association, Get Recipe, and Get
		* Recipes to Profile Association, and Release Resource (with resource
		* ID set to Global Config Lock) AdminQ commands are allowed; all others
		* must block until the package download completes and the Global Config
		* Lock is released. See also ice_acquire_global_cfg_lock().
		*/
		switch (le16_to_cpu(desc->opcode)) {
		case ice_aqc_opc_download_pkg:
		case ice_aqc_opc_get_pkg_info_list:
		case ice_aqc_opc_get_ver:
		case ice_aqc_opc_upload_section:
		case ice_aqc_opc_update_pkg:
		case ice_aqc_opc_set_port_params:
		case ice_aqc_opc_get_vlan_mode_parameters:
		case ice_aqc_opc_set_vlan_mode_parameters:
		case ice_aqc_opc_add_recipe:
		case ice_aqc_opc_recipe_to_profile:
		case ice_aqc_opc_get_recipe:
		case ice_aqc_opc_get_recipe_to_profile:
		break;
		case ice_aqc_opc_release_res:
		if (le16_to_cpu(cmd->res_id) == ICE_AQC_RES_ID_GLBL_LOCK)
		@@ -2736,6 +2747,34 @@ void ice_clear_pxe_mode(struct ice_hw *hw)
		ice_aq_clear_pxe_mode(hw);
		}

		/**
		* ice_aq_set_port_params - set physical port parameters.
		* @pi: pointer to the port info struct
		* @double_vlan: if set double VLAN is enabled
		* @cd: pointer to command details structure or NULL
		*
		* Set Physical port parameters (0x0203)
		*/
		int
		ice_aq_set_port_params(struct ice_port_info *pi, bool double_vlan,
		struct ice_sq_cd *cd)

		{
		struct ice_aqc_set_port_params *cmd;
		struct ice_hw *hw = pi->hw;
		struct ice_aq_desc desc;
		u16 cmd_flags = 0;

		cmd = &desc.params.set_port_params;

		ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_port_params);
		if (double_vlan)
		cmd_flags \|= ICE_AQC_SET_P_PARAMS_DOUBLE_VLAN_ENA;
		cmd->cmd_flags = cpu_to_le16(cmd_flags);

		return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
		}

		/**
		* ice_get_link_speed_based_on_phy_type - returns link speed
		* @phy_type_low: lower part of phy_type

drivers/net/ethernet/intel/ice/ice_common.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -85,6 +85,9 @@ int
		ice_aq_send_driver_ver(struct ice_hw hw, struct ice_driver_ver dv,
		struct ice_sq_cd *cd);
		int
		ice_aq_set_port_params(struct ice_port_info *pi, bool double_vlan,
		struct ice_sq_cd *cd);
		int
		ice_aq_get_phy_caps(struct ice_port_info *pi, bool qual_mods, u8 report_mode,
		struct ice_aqc_get_phy_caps_data *caps,
		struct ice_sq_cd *cd);

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

+257 −34

Original line number	Diff line number	Diff line
		@@ -5,9 +5,17 @@
		#include "ice_flex_pipe.h"
		#include "ice_flow.h"

		/* For supporting double VLAN mode, it is necessary to enable or disable certain
		* boost tcam entries. The metadata labels names that match the following
		* prefixes will be saved to allow enabling double VLAN mode.
		*/
		#define ICE_DVM_PRE "BOOST_MAC_VLAN_DVM" /* enable these entries */
		#define ICE_SVM_PRE "BOOST_MAC_VLAN_SVM" /* disable these entries */

		/* To support tunneling entries by PF, the package will append the PF number to
		* the label; for example TNL_VXLAN_PF0, TNL_VXLAN_PF1, TNL_VXLAN_PF2, etc.
		*/
		#define ICE_TNL_PRE "TNL_"
		static const struct ice_tunnel_type_scan tnls[] = {
		{ TNL_VXLAN, "TNL_VXLAN_PF" },
		{ TNL_GENEVE, "TNL_GENEVE_PF" },
		@@ -522,6 +530,55 @@ ice_enum_labels(struct ice_seg ice_seg, u32 type, struct ice_pkg_enum state,
		return label->name;
		}

		/**
		* ice_add_tunnel_hint
		* @hw: pointer to the HW structure
		* @label_name: label text
		* @val: value of the tunnel port boost entry
		*/
		static void ice_add_tunnel_hint(struct ice_hw hw, char label_name, u16 val)
		{
		if (hw->tnl.count < ICE_TUNNEL_MAX_ENTRIES) {
		u16 i;

		for (i = 0; tnls[i].type != TNL_LAST; i++) {
		size_t len = strlen(tnls[i].label_prefix);

		/* Look for matching label start, before continuing */
		if (strncmp(label_name, tnls[i].label_prefix, len))
		continue;

		/* Make sure this label matches our PF. Note that the PF
		* character ('0' - '7') will be located where our
		* prefix string's null terminator is located.
		*/
		if ((label_name[len] - '0') == hw->pf_id) {
		hw->tnl.tbl[hw->tnl.count].type = tnls[i].type;
		hw->tnl.tbl[hw->tnl.count].valid = false;
		hw->tnl.tbl[hw->tnl.count].boost_addr = val;
		hw->tnl.tbl[hw->tnl.count].port = 0;
		hw->tnl.count++;
		break;
		}
		}
		}
		}

		/**
		* ice_add_dvm_hint
		* @hw: pointer to the HW structure
		* @val: value of the boost entry
		* @enable: true if entry needs to be enabled, or false if needs to be disabled
		*/
		static void ice_add_dvm_hint(struct ice_hw *hw, u16 val, bool enable)
		{
		if (hw->dvm_upd.count < ICE_DVM_MAX_ENTRIES) {
		hw->dvm_upd.tbl[hw->dvm_upd.count].boost_addr = val;
		hw->dvm_upd.tbl[hw->dvm_upd.count].enable = enable;
		hw->dvm_upd.count++;
		}
		}

		/**
		* ice_init_pkg_hints
		* @hw: pointer to the HW structure
		@@ -548,32 +605,23 @@ static void ice_init_pkg_hints(struct ice_hw hw, struct ice_seg ice_seg)
		label_name = ice_enum_labels(ice_seg, ICE_SID_LBL_RXPARSER_TMEM, &state,
		&val);

		while (label_name && hw->tnl.count < ICE_TUNNEL_MAX_ENTRIES) {
		for (i = 0; tnls[i].type != TNL_LAST; i++) {
		size_t len = strlen(tnls[i].label_prefix);
		while (label_name) {
		if (!strncmp(label_name, ICE_TNL_PRE, strlen(ICE_TNL_PRE)))
		/* check for a tunnel entry */
		ice_add_tunnel_hint(hw, label_name, val);

		/* Look for matching label start, before continuing */
		if (strncmp(label_name, tnls[i].label_prefix, len))
		continue;
		/* check for a dvm mode entry */
		else if (!strncmp(label_name, ICE_DVM_PRE, strlen(ICE_DVM_PRE)))
		ice_add_dvm_hint(hw, val, true);

		/* Make sure this label matches our PF. Note that the PF
		* character ('0' - '7') will be located where our
		* prefix string's null terminator is located.
		*/
		if ((label_name[len] - '0') == hw->pf_id) {
		hw->tnl.tbl[hw->tnl.count].type = tnls[i].type;
		hw->tnl.tbl[hw->tnl.count].valid = false;
		hw->tnl.tbl[hw->tnl.count].boost_addr = val;
		hw->tnl.tbl[hw->tnl.count].port = 0;
		hw->tnl.count++;
		break;
		}
		}
		/* check for a svm mode entry */
		else if (!strncmp(label_name, ICE_SVM_PRE, strlen(ICE_SVM_PRE)))
		ice_add_dvm_hint(hw, val, false);

		label_name = ice_enum_labels(NULL, 0, &state, &val);
		}

		/* Cache the appropriate boost TCAM entry pointers */
		/* Cache the appropriate boost TCAM entry pointers for tunnels */
		for (i = 0; i < hw->tnl.count; i++) {
		ice_find_boost_entry(ice_seg, hw->tnl.tbl[i].boost_addr,
		&hw->tnl.tbl[i].boost_entry);
		@@ -583,6 +631,11 @@ static void ice_init_pkg_hints(struct ice_hw hw, struct ice_seg ice_seg)
		hw->tnl.valid_count[hw->tnl.tbl[i].type]++;
		}
		}

		/* Cache the appropriate boost TCAM entry pointers for DVM and SVM */
		for (i = 0; i < hw->dvm_upd.count; i++)
		ice_find_boost_entry(ice_seg, hw->dvm_upd.tbl[i].boost_addr,
		&hw->dvm_upd.tbl[i].boost_entry);
		}

		/* Key creation */
		@@ -873,6 +926,27 @@ ice_aq_download_pkg(struct ice_hw hw, struct ice_buf_hdr pkg_buf,
		return status;
		}

		/**
		* ice_aq_upload_section
		* @hw: pointer to the hardware structure
		* @pkg_buf: the package buffer which will receive the section
		* @buf_size: the size of the package buffer
		* @cd: pointer to command details structure or NULL
		*
		* Upload Section (0x0C41)
		*/
		int
		ice_aq_upload_section(struct ice_hw hw, struct ice_buf_hdr pkg_buf,
		u16 buf_size, struct ice_sq_cd *cd)
		{
		struct ice_aq_desc desc;

		ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_upload_section);
		desc.flags \|= cpu_to_le16(ICE_AQ_FLAG_RD);

		return ice_aq_send_cmd(hw, &desc, pkg_buf, buf_size, cd);
		}

		/**
		* ice_aq_update_pkg
		* @hw: pointer to the hardware structure
		@@ -957,25 +1031,21 @@ ice_find_seg_in_pkg(struct ice_hw *hw, u32 seg_type,
		}

		/**
		* ice_update_pkg
		* ice_update_pkg_no_lock
		* @hw: pointer to the hardware structure
		* @bufs: pointer to an array of buffers
		* @count: the number of buffers in the array
		*
		* Obtains change lock and updates package.
		*/
		static int ice_update_pkg(struct ice_hw hw, struct ice_buf bufs, u32 count)
		static int
		ice_update_pkg_no_lock(struct ice_hw hw, struct ice_buf bufs, u32 count)
		{
		u32 offset, info, i;
		int status;

		status = ice_acquire_change_lock(hw, ICE_RES_WRITE);
		if (status)
		return status;
		int status = 0;
		u32 i;

		for (i = 0; i < count; i++) {
		struct ice_buf_hdr bh = (struct ice_buf_hdr )(bufs + i);
		bool last = ((i + 1) == count);
		u32 offset, info;

		status = ice_aq_update_pkg(hw, bh, le16_to_cpu(bh->data_end),
		last, &offset, &info, NULL);
		@@ -987,6 +1057,27 @@ static int ice_update_pkg(struct ice_hw hw, struct ice_buf bufs, u32 count)
		}
		}

		return status;
		}

		/**
		* ice_update_pkg
		* @hw: pointer to the hardware structure
		* @bufs: pointer to an array of buffers
		* @count: the number of buffers in the array
		*
		* Obtains change lock and updates package.
		*/
		static int ice_update_pkg(struct ice_hw hw, struct ice_buf bufs, u32 count)
		{
		int status;

		status = ice_acquire_change_lock(hw, ICE_RES_WRITE);
		if (status)
		return status;

		status = ice_update_pkg_no_lock(hw, bufs, count);

		ice_release_change_lock(hw);

		return status;
		@@ -1080,6 +1171,13 @@ ice_dwnld_cfg_bufs(struct ice_hw hw, struct ice_buf bufs, u32 count)
		break;
		}

		if (!status) {
		status = ice_set_vlan_mode(hw);
		if (status)
		ice_debug(hw, ICE_DBG_PKG, "Failed to set VLAN mode: err %d\n",
		status);
		}

		ice_release_global_cfg_lock(hw);

		return state;
		@@ -1117,6 +1215,7 @@ static enum ice_ddp_state
		ice_download_pkg(struct ice_hw hw, struct ice_seg ice_seg)
		{
		struct ice_buf_table *ice_buf_tbl;
		int status;

		ice_debug(hw, ICE_DBG_PKG, "Segment format version: %d.%d.%d.%d\n",
		ice_seg->hdr.seg_format_ver.major,
		@@ -1133,8 +1232,12 @@ ice_download_pkg(struct ice_hw hw, struct ice_seg ice_seg)
		ice_debug(hw, ICE_DBG_PKG, "Seg buf count: %d\n",
		le32_to_cpu(ice_buf_tbl->buf_count));

		return ice_dwnld_cfg_bufs(hw, ice_buf_tbl->buf_array,
		status = ice_dwnld_cfg_bufs(hw, ice_buf_tbl->buf_array,
		le32_to_cpu(ice_buf_tbl->buf_count));

		ice_post_pkg_dwnld_vlan_mode_cfg(hw);

		return status;
		}

		/**
		@@ -1897,7 +2000,7 @@ void ice_init_prof_result_bm(struct ice_hw *hw)
		*
		* Frees a package buffer
		*/
		static void ice_pkg_buf_free(struct ice_hw hw, struct ice_buf_build bld)
		void ice_pkg_buf_free(struct ice_hw hw, struct ice_buf_build bld)
		{
		devm_kfree(ice_hw_to_dev(hw), bld);
		}
		@@ -1996,6 +2099,43 @@ ice_pkg_buf_alloc_section(struct ice_buf_build *bld, u32 type, u16 size)
		return NULL;
		}

		/**
		* ice_pkg_buf_alloc_single_section
		* @hw: pointer to the HW structure
		* @type: the section type value
		* @size: the size of the section to reserve (in bytes)
		* @section: returns pointer to the section
		*
		* Allocates a package buffer with a single section.
		* Note: all package contents must be in Little Endian form.
		*/
		struct ice_buf_build *
		ice_pkg_buf_alloc_single_section(struct ice_hw *hw, u32 type, u16 size,
		void **section)
		{
		struct ice_buf_build *buf;

		if (!section)
		return NULL;

		buf = ice_pkg_buf_alloc(hw);
		if (!buf)
		return NULL;

		if (ice_pkg_buf_reserve_section(buf, 1))
		goto ice_pkg_buf_alloc_single_section_err;

		*section = ice_pkg_buf_alloc_section(buf, type, size);
		if (!*section)
		goto ice_pkg_buf_alloc_single_section_err;

		return buf;

		ice_pkg_buf_alloc_single_section_err:
		ice_pkg_buf_free(hw, buf);
		return NULL;
		}

		/**
		* ice_pkg_buf_get_active_sections
		* @bld: pointer to pkg build (allocated by ice_pkg_buf_alloc())
		@@ -2023,7 +2163,7 @@ static u16 ice_pkg_buf_get_active_sections(struct ice_buf_build *bld)
		*
		* Return a pointer to the buffer's header
		*/
		static struct ice_buf ice_pkg_buf(struct ice_buf_build bld)
		struct ice_buf ice_pkg_buf(struct ice_buf_build bld)
		{
		if (!bld)
		return NULL;
		@@ -2059,6 +2199,89 @@ ice_get_open_tunnel_port(struct ice_hw hw, u16 port,
		return res;
		}

		/**
		* ice_upd_dvm_boost_entry
		* @hw: pointer to the HW structure
		* @entry: pointer to double vlan boost entry info
		*/
		static int
		ice_upd_dvm_boost_entry(struct ice_hw hw, struct ice_dvm_entry entry)
		{
		struct ice_boost_tcam_section sect_rx, sect_tx;
		int status = -ENOSPC;
		struct ice_buf_build *bld;
		u8 val, dc, nm;

		bld = ice_pkg_buf_alloc(hw);
		if (!bld)
		return -ENOMEM;

		/* allocate 2 sections, one for Rx parser, one for Tx parser */
		if (ice_pkg_buf_reserve_section(bld, 2))
		goto ice_upd_dvm_boost_entry_err;

		sect_rx = ice_pkg_buf_alloc_section(bld, ICE_SID_RXPARSER_BOOST_TCAM,
		struct_size(sect_rx, tcam, 1));
		if (!sect_rx)
		goto ice_upd_dvm_boost_entry_err;
		sect_rx->count = cpu_to_le16(1);

		sect_tx = ice_pkg_buf_alloc_section(bld, ICE_SID_TXPARSER_BOOST_TCAM,
		struct_size(sect_tx, tcam, 1));
		if (!sect_tx)
		goto ice_upd_dvm_boost_entry_err;
		sect_tx->count = cpu_to_le16(1);

		/* copy original boost entry to update package buffer */
		memcpy(sect_rx->tcam, entry->boost_entry, sizeof(*sect_rx->tcam));

		/* re-write the don't care and never match bits accordingly */
		if (entry->enable) {
		/* all bits are don't care */
		val = 0x00;
		dc = 0xFF;
		nm = 0x00;
		} else {
		/* disable, one never match bit, the rest are don't care */
		val = 0x00;
		dc = 0xF7;
		nm = 0x08;
		}

		ice_set_key((u8 *)&sect_rx->tcam[0].key, sizeof(sect_rx->tcam[0].key),
		&val, NULL, &dc, &nm, 0, sizeof(u8));

		/* exact copy of entry to Tx section entry */
		memcpy(sect_tx->tcam, sect_rx->tcam, sizeof(*sect_tx->tcam));

		status = ice_update_pkg_no_lock(hw, ice_pkg_buf(bld), 1);

		ice_upd_dvm_boost_entry_err:
		ice_pkg_buf_free(hw, bld);

		return status;
		}

		/**
		* ice_set_dvm_boost_entries
		* @hw: pointer to the HW structure
		*
		* Enable double vlan by updating the appropriate boost tcam entries.
		*/
		int ice_set_dvm_boost_entries(struct ice_hw *hw)
		{
		int status;
		u16 i;

		for (i = 0; i < hw->dvm_upd.count; i++) {
		status = ice_upd_dvm_boost_entry(hw, &hw->dvm_upd.tbl[i]);
		if (status)
		return status;
		}

		return 0;
		}

		/**
		* ice_tunnel_idx_to_entry - convert linear index to the sparse one
		* @hw: pointer to the HW structure