drivers/net/ethernet/intel/i40e/i40e_hmc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
   3
   4 #include "i40e_alloc.h"
   5 #include "i40e_debug.h"
   6 #include "i40e_hmc.h"
   7 #include "i40e_type.h"
   8
   9 /**
  10  * i40e_add_sd_table_entry - Adds a segment descriptor to the table
  11  * @hw: pointer to our hw struct
  12  * @hmc_info: pointer to the HMC configuration information struct
  13  * @sd_index: segment descriptor index to manipulate
  14  * @type: what type of segment descriptor we're manipulating
  15  * @direct_mode_sz: size to alloc in direct mode
  16  **/
  17 int i40e_add_sd_table_entry(struct i40e_hw *hw,
  18                             struct i40e_hmc_info *hmc_info,
  19                             u32 sd_index,
  20                             enum i40e_sd_entry_type type,
  21                             u64 direct_mode_sz)
  22 {
  23         struct i40e_hmc_sd_entry *sd_entry;
  24         bool dma_mem_alloc_done = false;
  25         struct i40e_dma_mem mem;
  26         int ret_code = 0;
  27         u64 alloc_len;
  28
  29         if (NULL == hmc_info->sd_table.sd_entry) {
  30                 ret_code = -EINVAL;
  31                 hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_entry\n");
  32                 goto exit;
  33         }
  34
  35         if (sd_index >= hmc_info->sd_table.sd_cnt) {
  36                 ret_code = -EINVAL;
  37                 hw_dbg(hw, "i40e_add_sd_table_entry: bad sd_index\n");
  38                 goto exit;
  39         }
  40
  41         sd_entry = &hmc_info->sd_table.sd_entry[sd_index];
  42         if (!sd_entry->valid) {
  43                 if (type == I40E_SD_TYPE_PAGED)
  44                         alloc_len = I40E_HMC_PAGED_BP_SIZE;
  45                 else
  46                         alloc_len = direct_mode_sz;
  47
  48                 /* allocate a 4K pd page or 2M backing page */
  49                 ret_code = i40e_allocate_dma_mem(hw, &mem, alloc_len,
  50                                                  I40E_HMC_PD_BP_BUF_ALIGNMENT);
  51                 if (ret_code)
  52                         goto exit;
  53                 dma_mem_alloc_done = true;
  54                 if (I40E_SD_TYPE_PAGED == type) {
  55                         ret_code = i40e_allocate_virt_mem(hw,
  56                                         &sd_entry->u.pd_table.pd_entry_virt_mem,
  57                                         sizeof(struct i40e_hmc_pd_entry) * 512);
  58                         if (ret_code)
  59                                 goto exit;
  60                         sd_entry->u.pd_table.pd_entry =
  61                                 (struct i40e_hmc_pd_entry *)
  62                                 sd_entry->u.pd_table.pd_entry_virt_mem.va;
  63                         sd_entry->u.pd_table.pd_page_addr = mem;
  64                 } else {
  65                         sd_entry->u.bp.addr = mem;
  66                         sd_entry->u.bp.sd_pd_index = sd_index;
  67                 }
  68                 /* initialize the sd entry */
  69                 hmc_info->sd_table.sd_entry[sd_index].entry_type = type;
  70
  71                 /* increment the ref count */
  72                 I40E_INC_SD_REFCNT(&hmc_info->sd_table);
  73         }
  74         /* Increment backing page reference count */
  75         if (I40E_SD_TYPE_DIRECT == sd_entry->entry_type)
  76                 I40E_INC_BP_REFCNT(&sd_entry->u.bp);
  77 exit:
  78         if (ret_code)
  79                 if (dma_mem_alloc_done)
  80                         i40e_free_dma_mem(hw, &mem);
  81
  82         return ret_code;
  83 }
  84
  85 /**
  86  * i40e_add_pd_table_entry - Adds page descriptor to the specified table
  87  * @hw: pointer to our HW structure
  88  * @hmc_info: pointer to the HMC configuration information structure
  89  * @pd_index: which page descriptor index to manipulate
  90  * @rsrc_pg: if not NULL, use preallocated page instead of allocating new one.
  91  *
  92  * This function:
  93  *      1. Initializes the pd entry
  94  *      2. Adds pd_entry in the pd_table
  95  *      3. Mark the entry valid in i40e_hmc_pd_entry structure
  96  *      4. Initializes the pd_entry's ref count to 1
  97  * assumptions:
  98  *      1. The memory for pd should be pinned down, physically contiguous and
  99  *         aligned on 4K boundary and zeroed memory.
 100  *      2. It should be 4K in size.
 101  **/
 102 int i40e_add_pd_table_entry(struct i40e_hw *hw,
 103                             struct i40e_hmc_info *hmc_info,
 104                             u32 pd_index,
 105                             struct i40e_dma_mem *rsrc_pg)
 106 {
 107         struct i40e_hmc_pd_table *pd_table;
 108         struct i40e_hmc_pd_entry *pd_entry;
 109         struct i40e_dma_mem mem;
 110         struct i40e_dma_mem *page = &mem;
 111         u32 sd_idx, rel_pd_idx;
 112         int ret_code = 0;
 113         u64 page_desc;
 114         u64 *pd_addr;
 115
 116         if (pd_index / I40E_HMC_PD_CNT_IN_SD >= hmc_info->sd_table.sd_cnt) {
 117                 ret_code = -EINVAL;
 118                 hw_dbg(hw, "i40e_add_pd_table_entry: bad pd_index\n");
 119                 goto exit;
 120         }
 121
 122         /* find corresponding sd */
 123         sd_idx = (pd_index / I40E_HMC_PD_CNT_IN_SD);
 124         if (I40E_SD_TYPE_PAGED !=
 125             hmc_info->sd_table.sd_entry[sd_idx].entry_type)
 126                 goto exit;
 127
 128         rel_pd_idx = (pd_index % I40E_HMC_PD_CNT_IN_SD);
 129         pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
 130         pd_entry = &pd_table->pd_entry[rel_pd_idx];
 131         if (!pd_entry->valid) {
 132                 if (rsrc_pg) {
 133                         pd_entry->rsrc_pg = true;
 134                         page = rsrc_pg;
 135                 } else {
 136                         /* allocate a 4K backing page */
 137                         ret_code = i40e_allocate_dma_mem(hw, page,
 138                                                 I40E_HMC_PAGED_BP_SIZE,
 139                                                 I40E_HMC_PD_BP_BUF_ALIGNMENT);
 140                         if (ret_code)
 141                                 goto exit;
 142                         pd_entry->rsrc_pg = false;
 143                 }
 144
 145                 pd_entry->bp.addr = *page;
 146                 pd_entry->bp.sd_pd_index = pd_index;
 147                 pd_entry->bp.entry_type = I40E_SD_TYPE_PAGED;
 148                 /* Set page address and valid bit */
 149                 page_desc = page->pa | 0x1;
 150
 151                 pd_addr = (u64 *)pd_table->pd_page_addr.va;
 152                 pd_addr += rel_pd_idx;
 153
 154                 /* Add the backing page physical address in the pd entry */
 155                 memcpy(pd_addr, &page_desc, sizeof(u64));
 156
 157                 pd_entry->sd_index = sd_idx;
 158                 pd_entry->valid = true;
 159                 I40E_INC_PD_REFCNT(pd_table);
 160         }
 161         I40E_INC_BP_REFCNT(&pd_entry->bp);
 162 exit:
 163         return ret_code;
 164 }
 165
 166 /**
 167  * i40e_remove_pd_bp - remove a backing page from a page descriptor
 168  * @hw: pointer to our HW structure
 169  * @hmc_info: pointer to the HMC configuration information structure
 170  * @idx: the page index
 171  *
 172  * This function:
 173  *      1. Marks the entry in pd tabe (for paged address mode) or in sd table
 174  *         (for direct address mode) invalid.
 175  *      2. Write to register PMPDINV to invalidate the backing page in FV cache
 176  *      3. Decrement the ref count for the pd _entry
 177  * assumptions:
 178  *      1. Caller can deallocate the memory used by backing storage after this
 179  *         function returns.
 180  **/
 181 int i40e_remove_pd_bp(struct i40e_hw *hw,
 182                       struct i40e_hmc_info *hmc_info,
 183                       u32 idx)
 184 {
 185         struct i40e_hmc_pd_entry *pd_entry;
 186         struct i40e_hmc_pd_table *pd_table;
 187         struct i40e_hmc_sd_entry *sd_entry;
 188         u32 sd_idx, rel_pd_idx;
 189         int ret_code = 0;
 190         u64 *pd_addr;
 191
 192         /* calculate index */
 193         sd_idx = idx / I40E_HMC_PD_CNT_IN_SD;
 194         rel_pd_idx = idx % I40E_HMC_PD_CNT_IN_SD;
 195         if (sd_idx >= hmc_info->sd_table.sd_cnt) {
 196                 ret_code = -EINVAL;
 197                 hw_dbg(hw, "i40e_remove_pd_bp: bad idx\n");
 198                 goto exit;
 199         }
 200         sd_entry = &hmc_info->sd_table.sd_entry[sd_idx];
 201         if (I40E_SD_TYPE_PAGED != sd_entry->entry_type) {
 202                 ret_code = -EINVAL;
 203                 hw_dbg(hw, "i40e_remove_pd_bp: wrong sd_entry type\n");
 204                 goto exit;
 205         }
 206         /* get the entry and decrease its ref counter */
 207         pd_table = &hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
 208         pd_entry = &pd_table->pd_entry[rel_pd_idx];
 209         I40E_DEC_BP_REFCNT(&pd_entry->bp);
 210         if (pd_entry->bp.ref_cnt)
 211                 goto exit;
 212
 213         /* mark the entry invalid */
 214         pd_entry->valid = false;
 215         I40E_DEC_PD_REFCNT(pd_table);
 216         pd_addr = (u64 *)pd_table->pd_page_addr.va;
 217         pd_addr += rel_pd_idx;
 218         memset(pd_addr, 0, sizeof(u64));
 219         I40E_INVALIDATE_PF_HMC_PD(hw, sd_idx, idx);
 220
 221         /* free memory here */
 222         if (!pd_entry->rsrc_pg)
 223                 ret_code = i40e_free_dma_mem(hw, &pd_entry->bp.addr);
 224         if (ret_code)
 225                 goto exit;
 226         if (!pd_table->ref_cnt)
 227                 i40e_free_virt_mem(hw, &pd_table->pd_entry_virt_mem);
 228 exit:
 229         return ret_code;
 230 }
 231
 232 /**
 233  * i40e_prep_remove_sd_bp - Prepares to remove a backing page from a sd entry
 234  * @hmc_info: pointer to the HMC configuration information structure
 235  * @idx: the page index
 236  **/
 237 int i40e_prep_remove_sd_bp(struct i40e_hmc_info *hmc_info,
 238                            u32 idx)
 239 {
 240         struct i40e_hmc_sd_entry *sd_entry;
 241         int ret_code = 0;
 242
 243         /* get the entry and decrease its ref counter */
 244         sd_entry = &hmc_info->sd_table.sd_entry[idx];
 245         I40E_DEC_BP_REFCNT(&sd_entry->u.bp);
 246         if (sd_entry->u.bp.ref_cnt) {
 247                 ret_code = -EBUSY;
 248                 goto exit;
 249         }
 250         I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
 251
 252         /* mark the entry invalid */
 253         sd_entry->valid = false;
 254 exit:
 255         return ret_code;
 256 }
 257
 258 /**
 259  * i40e_remove_sd_bp_new - Removes a backing page from a segment descriptor
 260  * @hw: pointer to our hw struct
 261  * @hmc_info: pointer to the HMC configuration information structure
 262  * @idx: the page index
 263  * @is_pf: used to distinguish between VF and PF
 264  **/
 265 int i40e_remove_sd_bp_new(struct i40e_hw *hw,
 266                           struct i40e_hmc_info *hmc_info,
 267                           u32 idx, bool is_pf)
 268 {
 269         struct i40e_hmc_sd_entry *sd_entry;
 270
 271         if (!is_pf)
 272                 return -EOPNOTSUPP;
 273
 274         /* get the entry and decrease its ref counter */
 275         sd_entry = &hmc_info->sd_table.sd_entry[idx];
 276         I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_DIRECT);
 277
 278         return i40e_free_dma_mem(hw, &sd_entry->u.bp.addr);
 279 }
 280
 281 /**
 282  * i40e_prep_remove_pd_page - Prepares to remove a PD page from sd entry.
 283  * @hmc_info: pointer to the HMC configuration information structure
 284  * @idx: segment descriptor index to find the relevant page descriptor
 285  **/
 286 int i40e_prep_remove_pd_page(struct i40e_hmc_info *hmc_info,
 287                              u32 idx)
 288 {
 289         struct i40e_hmc_sd_entry *sd_entry;
 290         int ret_code = 0;
 291
 292         sd_entry = &hmc_info->sd_table.sd_entry[idx];
 293
 294         if (sd_entry->u.pd_table.ref_cnt) {
 295                 ret_code = -EBUSY;
 296                 goto exit;
 297         }
 298
 299         /* mark the entry invalid */
 300         sd_entry->valid = false;
 301
 302         I40E_DEC_SD_REFCNT(&hmc_info->sd_table);
 303 exit:
 304         return ret_code;
 305 }
 306
 307 /**
 308  * i40e_remove_pd_page_new - Removes a PD page from sd entry.
 309  * @hw: pointer to our hw struct
 310  * @hmc_info: pointer to the HMC configuration information structure
 311  * @idx: segment descriptor index to find the relevant page descriptor
 312  * @is_pf: used to distinguish between VF and PF
 313  **/
 314 int i40e_remove_pd_page_new(struct i40e_hw *hw,
 315                             struct i40e_hmc_info *hmc_info,
 316                             u32 idx, bool is_pf)
 317 {
 318         struct i40e_hmc_sd_entry *sd_entry;
 319
 320         if (!is_pf)
 321                 return -EOPNOTSUPP;
 322
 323         sd_entry = &hmc_info->sd_table.sd_entry[idx];
 324         I40E_CLEAR_PF_SD_ENTRY(hw, idx, I40E_SD_TYPE_PAGED);
 325
 326         return  i40e_free_dma_mem(hw, &sd_entry->u.pd_table.pd_page_addr);
 327 }