[linux-2.6-block.git] / drivers / net / ethernet / intel / i40e / i40e_hmc.c

/*******************************************************************************
 *
 * Intel Ethernet Controller XL710 Family Linux Driver
 * Copyright(c) 2013 - 2014 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The full GNU General Public License is included in this distribution in
 * the file called "COPYING".
 *
 * Contact Information:
 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 ******************************************************************************/

#include "i40e_osdep.h"
#include "i40e_register.h"
#include "i40e_status.h"
#include "i40e_alloc.h"
#include "i40e_hmc.h"
#include "i40e_type.h"

/**
 * i40e_add_sd_table_entry - Adds a segment descriptor to the table
 * @hw: pointer to our hw struct
 * @hmc_info: pointer to the HMC configuration information struct
 * @sd_index: segment descriptor index to manipulate
 * @type: what type of segment descriptor we're manipulating
 * @direct_mode_sz: size to alloc in direct mode
 **/
i40e_status i40e_add_sd_table_entry(struct i40e_hw *hw,
					      struct i40e_hmc_info *hmc_info,
					      u32 sd_index,
					      enum i40e_sd_entry_type type,
					      u64 direct_mode_sz)
{
	enum i40e_memory_type mem_type __attribute__((unused));
	struct i40e_hmc_sd_entry *sd_entry;
	bool dma_mem_alloc_done = false;
	struct i40e_dma_mem mem;
	i40e_status ret_code;
	u64 alloc_len;

	if (NULL == hmc_info->sd_table.sd_entry) {
		ret_code = I40E_ERR_BAD_PTR;
		hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_entry\n");
		goto exit;
	}

	if (sd_index >= hmc_info->sd_table.sd_cnt) {
		ret_code = I40E_ERR_INVALID_SD_INDEX;
		hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_index\n");
		goto exit;
	}

	sd_entry = &hmc_info->sd_table.sd_entry[sd_index];
	if (!sd_entry->valid) {
		if (I40E_SD_TYPE_PAGED == type) {
			mem_type = i40e_mem_pd;
			alloc_len = I40E_HMC_PAGED_BP_SIZE;
		} else {
			mem_type = i40e_mem_bp_jumbo;
			alloc_len = direct_mode_sz;
		}

		/* allocate a 4K pd page or 2M backing page */
		ret_code = i40e_allocate_dma_mem(hw, &mem, mem_type, alloc_len,
						 I40E_HMC_PD_BP_BUF_ALIGNMENT);
		if (ret_code)
			goto exit;
		dma_mem_alloc_done = true;
		if (I40E_SD_TYPE_PAGED == type) {
			ret_code = i40e_allocate_virt_mem(hw,
					&sd_entry->u.pd_table.pd_entry_virt_mem,
					sizeof(struct i40e_hmc_pd_entry) * 512);
			if (ret_code)
				goto exit;
			sd_entry->u.pd_table.pd_entry =
				(struct i40e_hmc_pd_entry *)
				sd_entry->u.pd_table.pd_entry_virt_mem.va;
			sd_entry->u.pd_table.pd_page_addr = mem;
		} else {
			sd_entry->u.bp.addr = mem;
			sd_entry->u.bp.sd_pd_index = sd_index;
		}
		/* initialize the sd entry */
		hmc_info->sd_table.sd_entry[sd_index].entry_type = type;

		/* increment the ref count */
		I40E_INC_SD_REFCNT(&hmc_info->sd_table);
	}
	/* Increment backing page reference count */
	if (I40E_SD_TYPE_DIRECT == sd_entry->entry_type)
		I40E_INC_BP_REFCNT(&sd_entry->u.bp);
exit:
	if (ret_code)
		if (dma_mem_alloc_done)
			i40e_free_dma_mem(hw, &mem);

	return ret_code;
}

/**
 * i40e_add_pd_table_entry - Adds page descriptor to the specified table
 * @hw: pointer to our HW structure
 * @hmc_info: pointer to the HMC configuration information structure
 * @pd_index: which page descriptor index to manipulate
 *
 * This function:
 *	1. Initializes the pd entry
 *	2. Adds pd_entry in the pd_table
 *	3. Mark the entry valid in i40e_hmc_pd_entry structure
 *	4. Initializes the pd_entry's ref count to 1
 * assumptions:
 *	1. The memory for pd should be pinned down, physically contiguous and
 *	   aligned on 4K boundary and zeroed memory.
 *	2. It should be 4K in size.
 **/
i40e_status i40e_add_pd_table_entry(struct i40e_hw *hw,
					      struct i40e_hmc_info *hmc_info,
					      u32 pd_index)
{
	i40e_status ret_code = 0;
	struct i40e_hmc_pd_table *pd_table;
	struct i40e_hmc_pd_entry *pd_entry;
	struct i40e_dma_mem mem;
	u32 sd_idx, rel_pd_idx;
	u64 *pd_addr;
	u64 page_desc;

	if (pd_index / I40E_HMC_PD_CNT_IN_SD >= hmc_info->sd_table.sd_cnt) {
		ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
		hw_dbg(hw, "i40e_add_pd_table_entry: bad pd_index\n");
		goto exit;
	}

	/* find corresponding sd */
	sd_idx = (pd_index / I40E_HMC_PD_CNT_IN_SD);
	if (I40E_SD_TYPE_PAGED !=
	    hmc_info->sd_table.sd_entry[sd_idx].entry_type)
		goto exit;

	rel_pd_idx = (pd_index % I40E_HMC_PD_CNT_IN_SD);
	pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
	pd_entry = &pd_table->pd_entry[rel_pd_idx];
	if (!pd_entry->valid) {
		/* allocate a 4K backing page */
		ret_code = i40e_allocate_dma_mem(hw, &mem, i40e_mem_bp,
						 I40E_HMC_PAGED_BP_SIZE,
						 I40E_HMC_PD_BP_BUF_ALIGNMENT);
		if (ret_code)
			goto exit;

		pd_entry->bp.addr = mem;
		pd_entry->bp.sd_pd_index = pd_index;
		pd_entry->bp.entry_type = I40E_SD_TYPE_PAGED;
		/* Set page address and valid bit */
		page_desc = mem.pa | 0x1;

		pd_addr = (u64 *)pd_table->pd_page_addr.va;
		pd_addr += rel_pd_idx;

		/* Add the backing page physical address in the pd entry */
		memcpy(pd_addr, &page_desc, sizeof(u64));

		pd_entry->sd_index = sd_idx;
		pd_entry->valid = true;
		I40E_INC_PD_REFCNT(pd_table);
	}
	I40E_INC_BP_REFCNT(&pd_entry->bp);
exit:
	return ret_code;
}

/**
 * i40e_remove_pd_bp - remove a backing page from a page descriptor
 * @hw: pointer to our HW structure
 * @hmc_info: pointer to the HMC configuration information structure
 * @idx: the page index
 * @is_pf: distinguishes a VF from a PF
 *
 * This function:
 *	1. Marks the entry in pd tabe (for paged address mode) or in sd table
 *	   (for direct address mode) invalid.
 *	2. Write to register PMPDINV to invalidate the backing page in FV cache
 *	3. Decrement the ref count for the pd _entry
 * assumptions:
 *	1. Caller can deallocate the memory used by backing storage after this
 *	   function returns.
 **/
i40e_status i40e_remove_pd_bp(struct i40e_hw *hw,
					struct i40e_hmc_info *hmc_info,
					u32 idx, bool is_pf)
{
	i40e_status ret_code = 0;
	struct i40e_hmc_pd_entry *pd_entry;
	struct i40e_hmc_pd_table *pd_table;
	struct i40e_hmc_sd_entry *sd_entry;
	u32 sd_idx, rel_pd_idx;
	u64 *pd_addr;

	/* calculate index */
	sd_idx = idx / I40E_HMC_PD_CNT_IN_SD;
	rel_pd_idx = idx % I40E_HMC_PD_CNT_IN_SD;
	if (sd_idx >= hmc_info->sd_table.sd_cnt) {
		ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
		hw_dbg(hw, "i40e_remove_pd_bp: bad idx\n");
		goto exit;
	}
	sd_entry = &hmc_info->sd_table.sd_entry[sd_idx];
	if (I40E_SD_TYPE_PAGED != sd_entry->entry_type) {
		ret_code = I40E_ERR_INVALID_SD_TYPE;
		hw_dbg(hw, "i40e_remove_pd_bp: wrong sd_entry type\n");
		goto exit;
	}
	/* get the entry and decrease its ref counter */
	pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
	pd_entry = &pd_table->pd_entry[rel_pd_idx];
	I40E_DEC_BP_REFCNT(&pd_entry->bp);
	if (pd_entry->bp.ref_cnt)
		goto exit;

	/* mark the entry invalid */
	pd_entry->valid = false;
	I40E_DEC_PD_REFCNT(pd_table);
	pd_addr = (u64 *)pd_table->pd_page_addr.va;
	pd_addr += rel_pd_idx;
	memset(pd_addr, 0, sizeof(u64));
	if (is_pf)
		I40E_INVALIDATE_PF_HMC_PD(hw, sd_idx, idx);
	else
		I40E_INVALIDATE_VF_HMC_PD(hw, sd_idx, idx, hmc_info->hmc_fn_id);

	/* free memory here */
	ret_code = i40e_free_dma_mem(hw, &(pd_entry->bp.addr));
	if (ret_code)
		goto exit;
	if (!pd_table->ref_cnt)
		i40e_free_virt_mem(hw, &pd_table->pd_entry_virt_mem);
exit:
	return ret_code;
}

/**
 * i40e_prep_remove_sd_bp - Prepares to remove a backing page from a sd entry
 * @hmc_info: pointer to the HMC configuration information structure
 * @idx: the page index
 **/
i40e_status i40e_prep_remove_sd_bp(struct i40e_hmc_info *hmc_info,
					     u32 idx)
{
	i40e_status ret_code = 0;
	struct i40e_hmc_sd_entry *sd_entry;

	/* get the entry and decrease its ref counter */
	sd_entry = &hmc_info->sd_table.sd_entry[idx];
	I40E_DEC_BP_REFCNT(&sd_entry->u.bp);
	if (sd_entry->u.bp.ref_cnt) {
		ret_code = I40E_ERR_NOT_READY;
		goto exit;
	}
	I40E_DEC_SD_REFCNT(&hmc_info->sd_table);

	/* mark the entry invalid */
	sd_entry->valid = false;
exit:
	return ret_code;
}

/**
 * i40e_remove_sd_bp_new - Removes a backing page from a segment descriptor
 * @hw: pointer to our hw struct
 * @hmc_info: pointer to the HMC configuration information structure
 * @idx: the page index
 * @is_pf: used to distinguish between VF and PF
 **/
i40e_status i40e_remove_sd_bp_new(struct i40e_hw *hw,
					    struct i40e_hmc_info *hmc_info,
					    u32 idx, bool is_pf)
{
	struct i40e_hmc_sd_entry *sd_entry;
	i40e_status ret_code = 0;

	/* get the entry and decrease its ref counter */
	sd_entry = &hmc_info->sd_table.sd_entry[idx];
	if (is_pf) {
		I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_DIRECT);
	} else {
		ret_code = I40E_NOT_SUPPORTED;
		goto exit;
	}
	ret_code = i40e_free_dma_mem(hw, &(sd_entry->u.bp.addr));
	if (ret_code)
		goto exit;
exit:
	return ret_code;
}

/**
 * i40e_prep_remove_pd_page - Prepares to remove a PD page from sd entry.
 * @hmc_info: pointer to the HMC configuration information structure
 * @idx: segment descriptor index to find the relevant page descriptor
 **/
i40e_status i40e_prep_remove_pd_page(struct i40e_hmc_info *hmc_info,
					       u32 idx)
{
	i40e_status ret_code = 0;
	struct i40e_hmc_sd_entry *sd_entry;

	sd_entry = &hmc_info->sd_table.sd_entry[idx];

	if (sd_entry->u.pd_table.ref_cnt) {
		ret_code = I40E_ERR_NOT_READY;
		goto exit;
	}

	/* mark the entry invalid */
	sd_entry->valid = false;

	I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
exit:
	return ret_code;
}

/**
 * i40e_remove_pd_page_new - Removes a PD page from sd entry.
 * @hw: pointer to our hw struct
 * @hmc_info: pointer to the HMC configuration information structure
 * @idx: segment descriptor index to find the relevant page descriptor
 * @is_pf: used to distinguish between VF and PF
 **/
i40e_status i40e_remove_pd_page_new(struct i40e_hw *hw,
					      struct i40e_hmc_info *hmc_info,
					      u32 idx, bool is_pf)
{
	i40e_status ret_code = 0;
	struct i40e_hmc_sd_entry *sd_entry;

	sd_entry = &hmc_info->sd_table.sd_entry[idx];
	if (is_pf) {
		I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_PAGED);
	} else {
		ret_code = I40E_NOT_SUPPORTED;
		goto exit;
	}
	/* free memory here */
	ret_code = i40e_free_dma_mem(hw, &(sd_entry->u.pd_table.pd_page_addr));
	if (ret_code)
		goto exit;
exit:
	return ret_code;
}
Commit	Line	Data
56a62fc8 JB	1	/*******************************************************************************
	2	*
	3	* Intel Ethernet Controller XL710 Family Linux Driver
dc641b73	4	* Copyright(c) 2013 - 2014 Intel Corporation.
56a62fc8 JB	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms and conditions of the GNU General Public License,
	8	* version 2, as published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope it will be useful, but WITHOUT
	11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	* more details.
	14	*
dc641b73 GR	15	* You should have received a copy of the GNU General Public License along
dc641b73 GR	16	* with this program. If not, see <http://www.gnu.org/licenses/>.
56a62fc8 JB	17	*
	18	* The full GNU General Public License is included in this distribution in
	19	* the file called "COPYING".
	20	*
	21	* Contact Information:
	22	* e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
	23	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	24	*
	25	******************************************************************************/
	26
	27	#include "i40e_osdep.h"
	28	#include "i40e_register.h"
	29	#include "i40e_status.h"
	30	#include "i40e_alloc.h"
	31	#include "i40e_hmc.h"
	32	#include "i40e_type.h"
	33
	34	/**
	35	* i40e_add_sd_table_entry - Adds a segment descriptor to the table
	36	* @hw: pointer to our hw struct
	37	* @hmc_info: pointer to the HMC configuration information struct
	38	* @sd_index: segment descriptor index to manipulate
	39	* @type: what type of segment descriptor we're manipulating
	40	* @direct_mode_sz: size to alloc in direct mode
	41	**/
	42	i40e_status i40e_add_sd_table_entry(struct i40e_hw *hw,
	43	struct i40e_hmc_info *hmc_info,
	44	u32 sd_index,
	45	enum i40e_sd_entry_type type,
	46	u64 direct_mode_sz)
	47	{
	48	enum i40e_memory_type mem_type __attribute__((unused));
56a62fc8 JB	49	struct i40e_hmc_sd_entry *sd_entry;
	50	bool dma_mem_alloc_done = false;
	51	struct i40e_dma_mem mem;
895106a5	52	i40e_status ret_code;
56a62fc8 JB	53	u64 alloc_len;
	54
	55	if (NULL == hmc_info->sd_table.sd_entry) {
	56	ret_code = I40E_ERR_BAD_PTR;
	57	hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_entry\n");
	58	goto exit;
	59	}
	60
	61	if (sd_index >= hmc_info->sd_table.sd_cnt) {
	62	ret_code = I40E_ERR_INVALID_SD_INDEX;
	63	hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_index\n");
	64	goto exit;
	65	}
	66
	67	sd_entry = &hmc_info->sd_table.sd_entry[sd_index];
	68	if (!sd_entry->valid) {
	69	if (I40E_SD_TYPE_PAGED == type) {
	70	mem_type = i40e_mem_pd;
	71	alloc_len = I40E_HMC_PAGED_BP_SIZE;
	72	} else {
	73	mem_type = i40e_mem_bp_jumbo;
	74	alloc_len = direct_mode_sz;
	75	}
	76
	77	/* allocate a 4K pd page or 2M backing page */
	78	ret_code = i40e_allocate_dma_mem(hw, &mem, mem_type, alloc_len,
	79	I40E_HMC_PD_BP_BUF_ALIGNMENT);
	80	if (ret_code)
	81	goto exit;
	82	dma_mem_alloc_done = true;
	83	if (I40E_SD_TYPE_PAGED == type) {
	84	ret_code = i40e_allocate_virt_mem(hw,
	85	&sd_entry->u.pd_table.pd_entry_virt_mem,
	86	sizeof(struct i40e_hmc_pd_entry) * 512);
	87	if (ret_code)
	88	goto exit;
	89	sd_entry->u.pd_table.pd_entry =
	90	(struct i40e_hmc_pd_entry *)
	91	sd_entry->u.pd_table.pd_entry_virt_mem.va;
c36bd4a7	92	sd_entry->u.pd_table.pd_page_addr = mem;
56a62fc8	93	} else {
c36bd4a7	94	sd_entry->u.bp.addr = mem;
56a62fc8 JB	95	sd_entry->u.bp.sd_pd_index = sd_index;
	96	}
	97	/* initialize the sd entry */
	98	hmc_info->sd_table.sd_entry[sd_index].entry_type = type;
	99
	100	/* increment the ref count */
	101	I40E_INC_SD_REFCNT(&hmc_info->sd_table);
	102	}
	103	/* Increment backing page reference count */
	104	if (I40E_SD_TYPE_DIRECT == sd_entry->entry_type)
	105	I40E_INC_BP_REFCNT(&sd_entry->u.bp);
	106	exit:
	107	if (ret_code)
	108	if (dma_mem_alloc_done)
	109	i40e_free_dma_mem(hw, &mem);
	110
	111	return ret_code;
	112	}
	113
	114	/**
	115	* i40e_add_pd_table_entry - Adds page descriptor to the specified table
	116	* @hw: pointer to our HW structure
	117	* @hmc_info: pointer to the HMC configuration information structure
	118	* @pd_index: which page descriptor index to manipulate
	119	*
	120	* This function:
	121	* 1. Initializes the pd entry
	122	* 2. Adds pd_entry in the pd_table
	123	* 3. Mark the entry valid in i40e_hmc_pd_entry structure
	124	* 4. Initializes the pd_entry's ref count to 1
	125	* assumptions:
	126	* 1. The memory for pd should be pinned down, physically contiguous and
	127	* aligned on 4K boundary and zeroed memory.
	128	* 2. It should be 4K in size.
	129	**/
	130	i40e_status i40e_add_pd_table_entry(struct i40e_hw *hw,
	131	struct i40e_hmc_info *hmc_info,
	132	u32 pd_index)
	133	{
	134	i40e_status ret_code = 0;
	135	struct i40e_hmc_pd_table *pd_table;
	136	struct i40e_hmc_pd_entry *pd_entry;
	137	struct i40e_dma_mem mem;
	138	u32 sd_idx, rel_pd_idx;
	139	u64 *pd_addr;
	140	u64 page_desc;
	141
	142	if (pd_index / I40E_HMC_PD_CNT_IN_SD >= hmc_info->sd_table.sd_cnt) {
	143	ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
	144	hw_dbg(hw, "i40e_add_pd_table_entry: bad pd_index\n");
	145	goto exit;
	146	}
	147
	148	/* find corresponding sd */
	149	sd_idx = (pd_index / I40E_HMC_PD_CNT_IN_SD);
	150	if (I40E_SD_TYPE_PAGED !=
	151	hmc_info->sd_table.sd_entry[sd_idx].entry_type)
	152	goto exit;
	153
	154	rel_pd_idx = (pd_index % I40E_HMC_PD_CNT_IN_SD);
	155	pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
	156	pd_entry = &pd_table->pd_entry[rel_pd_idx];
	157	if (!pd_entry->valid) {
	158	/* allocate a 4K backing page */
159	ret_code = i40e_allocate_dma_mem(hw, &mem, i40e_mem_bp,
160	I40E_HMC_PAGED_BP_SIZE,
161	I40E_HMC_PD_BP_BUF_ALIGNMENT);
162	if (ret_code)
163	goto exit;
164
c36bd4a7	165	pd_entry->bp.addr = mem;
56a62fc8 JB	166	pd_entry->bp.sd_pd_index = pd_index;
	167	pd_entry->bp.entry_type = I40E_SD_TYPE_PAGED;
	168	/* Set page address and valid bit */
	169	page_desc = mem.pa \| 0x1;
	170
	171	pd_addr = (u64 *)pd_table->pd_page_addr.va;
	172	pd_addr += rel_pd_idx;
	173
	174	/* Add the backing page physical address in the pd entry */
	175	memcpy(pd_addr, &page_desc, sizeof(u64));
	176
	177	pd_entry->sd_index = sd_idx;
	178	pd_entry->valid = true;
	179	I40E_INC_PD_REFCNT(pd_table);
	180	}
	181	I40E_INC_BP_REFCNT(&pd_entry->bp);
	182	exit:
	183	return ret_code;
	184	}
	185
	186	/**
	187	* i40e_remove_pd_bp - remove a backing page from a page descriptor
	188	* @hw: pointer to our HW structure
	189	* @hmc_info: pointer to the HMC configuration information structure
	190	* @idx: the page index
	191	* @is_pf: distinguishes a VF from a PF
	192	*
	193	* This function:
	194	* 1. Marks the entry in pd tabe (for paged address mode) or in sd table
	195	* (for direct address mode) invalid.
	196	* 2. Write to register PMPDINV to invalidate the backing page in FV cache
	197	* 3. Decrement the ref count for the pd _entry
	198	* assumptions:
	199	* 1. Caller can deallocate the memory used by backing storage after this
	200	* function returns.
	201	**/
	202	i40e_status i40e_remove_pd_bp(struct i40e_hw *hw,
	203	struct i40e_hmc_info *hmc_info,
	204	u32 idx, bool is_pf)
	205	{
	206	i40e_status ret_code = 0;
	207	struct i40e_hmc_pd_entry *pd_entry;
	208	struct i40e_hmc_pd_table *pd_table;
	209	struct i40e_hmc_sd_entry *sd_entry;
	210	u32 sd_idx, rel_pd_idx;
	211	u64 *pd_addr;
	212
	213	/* calculate index */
	214	sd_idx = idx / I40E_HMC_PD_CNT_IN_SD;
	215	rel_pd_idx = idx % I40E_HMC_PD_CNT_IN_SD;
	216	if (sd_idx >= hmc_info->sd_table.sd_cnt) {
	217	ret_code = I40E_ERR_INVALID_PAGE_DESC_INDEX;
	218	hw_dbg(hw, "i40e_remove_pd_bp: bad idx\n");
	219	goto exit;
	220	}
	221	sd_entry = &hmc_info->sd_table.sd_entry[sd_idx];
	222	if (I40E_SD_TYPE_PAGED != sd_entry->entry_type) {
	223	ret_code = I40E_ERR_INVALID_SD_TYPE;
	224	hw_dbg(hw, "i40e_remove_pd_bp: wrong sd_entry type\n");
	225	goto exit;
	226	}
	227	/* get the entry and decrease its ref counter */
	228	pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
	229	pd_entry = &pd_table->pd_entry[rel_pd_idx];
230	I40E_DEC_BP_REFCNT(&pd_entry->bp);
231	if (pd_entry->bp.ref_cnt)
232	goto exit;
233
234	/* mark the entry invalid */
235	pd_entry->valid = false;
236	I40E_DEC_PD_REFCNT(pd_table);
237	pd_addr = (u64 *)pd_table->pd_page_addr.va;
238	pd_addr += rel_pd_idx;
239	memset(pd_addr, 0, sizeof(u64));
240	if (is_pf)
241	I40E_INVALIDATE_PF_HMC_PD(hw, sd_idx, idx);
242	else
243	I40E_INVALIDATE_VF_HMC_PD(hw, sd_idx, idx, hmc_info->hmc_fn_id);
244
245	/* free memory here */
246	ret_code = i40e_free_dma_mem(hw, &(pd_entry->bp.addr));
247	if (ret_code)
248	goto exit;
249	if (!pd_table->ref_cnt)
250	i40e_free_virt_mem(hw, &pd_table->pd_entry_virt_mem);
251	exit:
252	return ret_code;
253	}
254
255	/**
256	* i40e_prep_remove_sd_bp - Prepares to remove a backing page from a sd entry
257	* @hmc_info: pointer to the HMC configuration information structure
258	* @idx: the page index
259	**/
260	i40e_status i40e_prep_remove_sd_bp(struct i40e_hmc_info *hmc_info,
261	u32 idx)
262	{
263	i40e_status ret_code = 0;
264	struct i40e_hmc_sd_entry *sd_entry;
265
266	/* get the entry and decrease its ref counter */
267	sd_entry = &hmc_info->sd_table.sd_entry[idx];
268	I40E_DEC_BP_REFCNT(&sd_entry->u.bp);
269	if (sd_entry->u.bp.ref_cnt) {
270	ret_code = I40E_ERR_NOT_READY;
271	goto exit;
272	}
273	I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
274
275	/* mark the entry invalid */
276	sd_entry->valid = false;
277	exit:
278	return ret_code;
279	}
280
281	/**
282	* i40e_remove_sd_bp_new - Removes a backing page from a segment descriptor
283	* @hw: pointer to our hw struct
284	* @hmc_info: pointer to the HMC configuration information structure
285	* @idx: the page index
286	* @is_pf: used to distinguish between VF and PF
287	**/
288	i40e_status i40e_remove_sd_bp_new(struct i40e_hw *hw,
289	struct i40e_hmc_info *hmc_info,
290	u32 idx, bool is_pf)
291	{
292	struct i40e_hmc_sd_entry *sd_entry;
293	i40e_status ret_code = 0;
294
295	/* get the entry and decrease its ref counter */
296	sd_entry = &hmc_info->sd_table.sd_entry[idx];
297	if (is_pf) {
298	I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_DIRECT);
299	} else {
300	ret_code = I40E_NOT_SUPPORTED;
301	goto exit;
302	}
303	ret_code = i40e_free_dma_mem(hw, &(sd_entry->u.bp.addr));
304	if (ret_code)
305	goto exit;
306	exit:
307	return ret_code;
308	}
309
310	/**
311	* i40e_prep_remove_pd_page - Prepares to remove a PD page from sd entry.
312	* @hmc_info: pointer to the HMC configuration information structure
313	* @idx: segment descriptor index to find the relevant page descriptor
314	**/
315	i40e_status i40e_prep_remove_pd_page(struct i40e_hmc_info *hmc_info,
316	u32 idx)
317	{
318	i40e_status ret_code = 0;
319	struct i40e_hmc_sd_entry *sd_entry;
320
321	sd_entry = &hmc_info->sd_table.sd_entry[idx];
322
323	if (sd_entry->u.pd_table.ref_cnt) {
324	ret_code = I40E_ERR_NOT_READY;
325	goto exit;
326	}
327
328	/* mark the entry invalid */
329	sd_entry->valid = false;
330
331	I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
332	exit:
333	return ret_code;
334	}
335
336	/**
337	* i40e_remove_pd_page_new - Removes a PD page from sd entry.
338	* @hw: pointer to our hw struct
339	* @hmc_info: pointer to the HMC configuration information structure
340	* @idx: segment descriptor index to find the relevant page descriptor
341	* @is_pf: used to distinguish between VF and PF
342	**/
343	i40e_status i40e_remove_pd_page_new(struct i40e_hw *hw,
344	struct i40e_hmc_info *hmc_info,
345	u32 idx, bool is_pf)
346	{
347	i40e_status ret_code = 0;
348	struct i40e_hmc_sd_entry *sd_entry;
349
350	sd_entry = &hmc_info->sd_table.sd_entry[idx];
351	if (is_pf) {
352	I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_PAGED);
353	} else {
354	ret_code = I40E_NOT_SUPPORTED;
355	goto exit;
356	}
357	/* free memory here */
358	ret_code = i40e_free_dma_mem(hw, &(sd_entry->u.pd_table.pd_page_addr));
359	if (ret_code)
360	goto exit;
361	exit:
362	return ret_code;
363	}