Similarly as for ice driver [1] there are also circular header
dependencies in i40e driver:
i40e.h -> i40e_virtchnl_pf.h -> i40e.h
Another issue is that i40e header files does not contain their own
dependencies on other header files (both private and standard) so their
inclusion in .c file require to add these deps in certain order to
that .c file to make it compilable.
Fix both issues by removal the mentioned circular dependency, by filling
i40e headers with their dependencies so they can be placed anywhere in
a source code. Additionally remove bunch of includes from i40e.h super
header file that are not necessary and include i40e.h only in .c files
that really require it.
[1] 649c87c6ff
("ice: remove circular header dependencies on ice.h")
Signed-off-by: Ivan Vecera <ivecera@redhat.com>
Reviewed-by: Przemek Kitszel <przemyslaw.kitszel@intel.com>
Reviewed-by: Jesse Brandeburg <jesse.brandeburg@intel.com>
Reviewed-by: Aleksandr Loktionov <aleksandr.loktionov@intel.com>
Tested-by: Pucha Himasekhar Reddy <himasekharx.reddy.pucha@intel.com> (A Contingent worker at Intel)
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
327 lines
9.1 KiB
C
327 lines
9.1 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Copyright(c) 2013 - 2018 Intel Corporation. */
|
|
|
|
#include "i40e_alloc.h"
|
|
#include "i40e_debug.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
|
|
**/
|
|
int 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)
|
|
{
|
|
struct i40e_hmc_sd_entry *sd_entry;
|
|
bool dma_mem_alloc_done = false;
|
|
struct i40e_dma_mem mem;
|
|
int ret_code = 0;
|
|
u64 alloc_len;
|
|
|
|
if (NULL == hmc_info->sd_table.sd_entry) {
|
|
ret_code = -EINVAL;
|
|
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 = -EINVAL;
|
|
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 (type == I40E_SD_TYPE_PAGED)
|
|
alloc_len = I40E_HMC_PAGED_BP_SIZE;
|
|
else
|
|
alloc_len = direct_mode_sz;
|
|
|
|
/* allocate a 4K pd page or 2M backing page */
|
|
ret_code = i40e_allocate_dma_mem(hw, &mem, 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
|
|
* @rsrc_pg: if not NULL, use preallocated page instead of allocating new one.
|
|
*
|
|
* 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.
|
|
**/
|
|
int i40e_add_pd_table_entry(struct i40e_hw *hw,
|
|
struct i40e_hmc_info *hmc_info,
|
|
u32 pd_index,
|
|
struct i40e_dma_mem *rsrc_pg)
|
|
{
|
|
struct i40e_hmc_pd_table *pd_table;
|
|
struct i40e_hmc_pd_entry *pd_entry;
|
|
struct i40e_dma_mem mem;
|
|
struct i40e_dma_mem *page = &mem;
|
|
u32 sd_idx, rel_pd_idx;
|
|
int ret_code = 0;
|
|
u64 page_desc;
|
|
u64 *pd_addr;
|
|
|
|
if (pd_index / I40E_HMC_PD_CNT_IN_SD >= hmc_info->sd_table.sd_cnt) {
|
|
ret_code = -EINVAL;
|
|
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) {
|
|
if (rsrc_pg) {
|
|
pd_entry->rsrc_pg = true;
|
|
page = rsrc_pg;
|
|
} else {
|
|
/* allocate a 4K backing page */
|
|
ret_code = i40e_allocate_dma_mem(hw, page,
|
|
I40E_HMC_PAGED_BP_SIZE,
|
|
I40E_HMC_PD_BP_BUF_ALIGNMENT);
|
|
if (ret_code)
|
|
goto exit;
|
|
pd_entry->rsrc_pg = false;
|
|
}
|
|
|
|
pd_entry->bp.addr = *page;
|
|
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 = page->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
|
|
*
|
|
* 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.
|
|
**/
|
|
int i40e_remove_pd_bp(struct i40e_hw *hw,
|
|
struct i40e_hmc_info *hmc_info,
|
|
u32 idx)
|
|
{
|
|
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;
|
|
int ret_code = 0;
|
|
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 = -EINVAL;
|
|
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 = -EINVAL;
|
|
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));
|
|
I40E_INVALIDATE_PF_HMC_PD(hw, sd_idx, idx);
|
|
|
|
/* free memory here */
|
|
if (!pd_entry->rsrc_pg)
|
|
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
|
|
**/
|
|
int i40e_prep_remove_sd_bp(struct i40e_hmc_info *hmc_info,
|
|
u32 idx)
|
|
{
|
|
struct i40e_hmc_sd_entry *sd_entry;
|
|
int ret_code = 0;
|
|
|
|
/* 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 = -EBUSY;
|
|
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
|
|
**/
|
|
int 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;
|
|
|
|
if (!is_pf)
|
|
return -EOPNOTSUPP;
|
|
|
|
/* get the entry and decrease its ref counter */
|
|
sd_entry = &hmc_info->sd_table.sd_entry[idx];
|
|
I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_DIRECT);
|
|
|
|
return i40e_free_dma_mem(hw, &sd_entry->u.bp.addr);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
**/
|
|
int i40e_prep_remove_pd_page(struct i40e_hmc_info *hmc_info,
|
|
u32 idx)
|
|
{
|
|
struct i40e_hmc_sd_entry *sd_entry;
|
|
int ret_code = 0;
|
|
|
|
sd_entry = &hmc_info->sd_table.sd_entry[idx];
|
|
|
|
if (sd_entry->u.pd_table.ref_cnt) {
|
|
ret_code = -EBUSY;
|
|
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
|
|
**/
|
|
int i40e_remove_pd_page_new(struct i40e_hw *hw,
|
|
struct i40e_hmc_info *hmc_info,
|
|
u32 idx, bool is_pf)
|
|
{
|
|
struct i40e_hmc_sd_entry *sd_entry;
|
|
|
|
if (!is_pf)
|
|
return -EOPNOTSUPP;
|
|
|
|
sd_entry = &hmc_info->sd_table.sd_entry[idx];
|
|
I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_PAGED);
|
|
|
|
return i40e_free_dma_mem(hw, &sd_entry->u.pd_table.pd_page_addr);
|
|
}
|