| // 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); |
| } |
