lib/librte_pmd_i40e/i40e/i40e_lan_hmc.c

   1 /*******************************************************************************
   2
   3 Copyright (c) 2013 - 2015, Intel Corporation
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions are met:
   8
   9  1. Redistributions of source code must retain the above copyright notice,
  10     this list of conditions and the following disclaimer.
  11
  12  2. Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in the
  14     documentation and/or other materials provided with the distribution.
  15
  16  3. Neither the name of the Intel Corporation nor the names of its
  17     contributors may be used to endorse or promote products derived from
  18     this software without specific prior written permission.
  19
  20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 ***************************************************************************/
  33
  34 #include "i40e_osdep.h"
  35 #include "i40e_register.h"
  36 #include "i40e_type.h"
  37 #include "i40e_hmc.h"
  38 #include "i40e_lan_hmc.h"
  39 #include "i40e_prototype.h"
  40
  41 /* lan specific interface functions */
  42
  43 /**
  44  * i40e_align_l2obj_base - aligns base object pointer to 512 bytes
  45  * @offset: base address offset needing alignment
  46  *
  47  * Aligns the layer 2 function private memory so it's 512-byte aligned.
  48  **/
  49 STATIC u64 i40e_align_l2obj_base(u64 offset)
  50 {
  51         u64 aligned_offset = offset;
  52
  53         if ((offset % I40E_HMC_L2OBJ_BASE_ALIGNMENT) > 0)
  54                 aligned_offset += (I40E_HMC_L2OBJ_BASE_ALIGNMENT -
  55                                    (offset % I40E_HMC_L2OBJ_BASE_ALIGNMENT));
  56
  57         return aligned_offset;
  58 }
  59
  60 /**
  61  * i40e_calculate_l2fpm_size - calculates layer 2 FPM memory size
  62  * @txq_num: number of Tx queues needing backing context
  63  * @rxq_num: number of Rx queues needing backing context
  64  * @fcoe_cntx_num: amount of FCoE statefull contexts needing backing context
  65  * @fcoe_filt_num: number of FCoE filters needing backing context
  66  *
  67  * Calculates the maximum amount of memory for the function required, based
  68  * on the number of resources it must provide context for.
  69  **/
  70 u64 i40e_calculate_l2fpm_size(u32 txq_num, u32 rxq_num,
  71                               u32 fcoe_cntx_num, u32 fcoe_filt_num)
  72 {
  73         u64 fpm_size = 0;
  74
  75         fpm_size = txq_num * I40E_HMC_OBJ_SIZE_TXQ;
  76         fpm_size = i40e_align_l2obj_base(fpm_size);
  77
  78         fpm_size += (rxq_num * I40E_HMC_OBJ_SIZE_RXQ);
  79         fpm_size = i40e_align_l2obj_base(fpm_size);
  80
  81         fpm_size += (fcoe_cntx_num * I40E_HMC_OBJ_SIZE_FCOE_CNTX);
  82         fpm_size = i40e_align_l2obj_base(fpm_size);
  83
  84         fpm_size += (fcoe_filt_num * I40E_HMC_OBJ_SIZE_FCOE_FILT);
  85         fpm_size = i40e_align_l2obj_base(fpm_size);
  86
  87         return fpm_size;
  88 }
  89
  90 /**
  91  * i40e_init_lan_hmc - initialize i40e_hmc_info struct
  92  * @hw: pointer to the HW structure
  93  * @txq_num: number of Tx queues needing backing context
  94  * @rxq_num: number of Rx queues needing backing context
  95  * @fcoe_cntx_num: amount of FCoE statefull contexts needing backing context
  96  * @fcoe_filt_num: number of FCoE filters needing backing context
  97  *
  98  * This function will be called once per physical function initialization.
  99  * It will fill out the i40e_hmc_obj_info structure for LAN objects based on
 100  * the driver's provided input, as well as information from the HMC itself
 101  * loaded from NVRAM.
 102  *
 103  * Assumptions:
 104  *   - HMC Resource Profile has been selected before calling this function.
 105  **/
 106 enum i40e_status_code i40e_init_lan_hmc(struct i40e_hw *hw, u32 txq_num,
 107                                         u32 rxq_num, u32 fcoe_cntx_num,
 108                                         u32 fcoe_filt_num)
 109 {
 110         struct i40e_hmc_obj_info *obj, *full_obj;
 111         enum i40e_status_code ret_code = I40E_SUCCESS;
 112         u64 l2fpm_size;
 113         u32 size_exp;
 114
 115         hw->hmc.signature = I40E_HMC_INFO_SIGNATURE;
 116         hw->hmc.hmc_fn_id = hw->pf_id;
 117
 118         /* allocate memory for hmc_obj */
 119         ret_code = i40e_allocate_virt_mem(hw, &hw->hmc.hmc_obj_virt_mem,
 120                         sizeof(struct i40e_hmc_obj_info) * I40E_HMC_LAN_MAX);
 121         if (ret_code)
 122                 goto init_lan_hmc_out;
 123         hw->hmc.hmc_obj = (struct i40e_hmc_obj_info *)
 124                           hw->hmc.hmc_obj_virt_mem.va;
 125
 126         /* The full object will be used to create the LAN HMC SD */
 127         full_obj = &hw->hmc.hmc_obj[I40E_HMC_LAN_FULL];
 128         full_obj->max_cnt = 0;
 129         full_obj->cnt = 0;
 130         full_obj->base = 0;
 131         full_obj->size = 0;
 132
 133         /* Tx queue context information */
 134         obj = &hw->hmc.hmc_obj[I40E_HMC_LAN_TX];
 135         obj->max_cnt = rd32(hw, I40E_GLHMC_LANQMAX);
 136         obj->cnt = txq_num;
 137         obj->base = 0;
 138         size_exp = rd32(hw, I40E_GLHMC_LANTXOBJSZ);
 139         obj->size = (u64)1 << size_exp;
 140
 141         /* validate values requested by driver don't exceed HMC capacity */
 142         if (txq_num > obj->max_cnt) {
 143                 ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 144                 DEBUGOUT3("i40e_init_lan_hmc: Tx context: asks for 0x%x but max allowed is 0x%x, returns error %d\n",
 145                           txq_num, obj->max_cnt, ret_code);
 146                 goto init_lan_hmc_out;
 147         }
 148
 149         /* aggregate values into the full LAN object for later */
 150         full_obj->max_cnt += obj->max_cnt;
 151         full_obj->cnt += obj->cnt;
 152
 153         /* Rx queue context information */
 154         obj = &hw->hmc.hmc_obj[I40E_HMC_LAN_RX];
 155         obj->max_cnt = rd32(hw, I40E_GLHMC_LANQMAX);
 156         obj->cnt = rxq_num;
 157         obj->base = hw->hmc.hmc_obj[I40E_HMC_LAN_TX].base +
 158                     (hw->hmc.hmc_obj[I40E_HMC_LAN_TX].cnt *
 159                      hw->hmc.hmc_obj[I40E_HMC_LAN_TX].size);
 160         obj->base = i40e_align_l2obj_base(obj->base);
 161         size_exp = rd32(hw, I40E_GLHMC_LANRXOBJSZ);
 162         obj->size = (u64)1 << size_exp;
 163
 164         /* validate values requested by driver don't exceed HMC capacity */
 165         if (rxq_num > obj->max_cnt) {
 166                 ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 167                 DEBUGOUT3("i40e_init_lan_hmc: Rx context: asks for 0x%x but max allowed is 0x%x, returns error %d\n",
 168                           rxq_num, obj->max_cnt, ret_code);
 169                 goto init_lan_hmc_out;
 170         }
 171
 172         /* aggregate values into the full LAN object for later */
 173         full_obj->max_cnt += obj->max_cnt;
 174         full_obj->cnt += obj->cnt;
 175
 176         /* FCoE context information */
 177         obj = &hw->hmc.hmc_obj[I40E_HMC_FCOE_CTX];
 178         obj->max_cnt = rd32(hw, I40E_GLHMC_FCOEMAX);
 179         obj->cnt = fcoe_cntx_num;
 180         obj->base = hw->hmc.hmc_obj[I40E_HMC_LAN_RX].base +
 181                     (hw->hmc.hmc_obj[I40E_HMC_LAN_RX].cnt *
 182                      hw->hmc.hmc_obj[I40E_HMC_LAN_RX].size);
 183         obj->base = i40e_align_l2obj_base(obj->base);
 184         size_exp = rd32(hw, I40E_GLHMC_FCOEDDPOBJSZ);
 185         obj->size = (u64)1 << size_exp;
 186
 187         /* validate values requested by driver don't exceed HMC capacity */
 188         if (fcoe_cntx_num > obj->max_cnt) {
 189                 ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 190                 DEBUGOUT3("i40e_init_lan_hmc: FCoE context: asks for 0x%x but max allowed is 0x%x, returns error %d\n",
 191                           fcoe_cntx_num, obj->max_cnt, ret_code);
 192                 goto init_lan_hmc_out;
 193         }
 194
 195         /* aggregate values into the full LAN object for later */
 196         full_obj->max_cnt += obj->max_cnt;
 197         full_obj->cnt += obj->cnt;
 198
 199         /* FCoE filter information */
 200         obj = &hw->hmc.hmc_obj[I40E_HMC_FCOE_FILT];
 201         obj->max_cnt = rd32(hw, I40E_GLHMC_FCOEFMAX);
 202         obj->cnt = fcoe_filt_num;
 203         obj->base = hw->hmc.hmc_obj[I40E_HMC_FCOE_CTX].base +
 204                     (hw->hmc.hmc_obj[I40E_HMC_FCOE_CTX].cnt *
 205                      hw->hmc.hmc_obj[I40E_HMC_FCOE_CTX].size);
 206         obj->base = i40e_align_l2obj_base(obj->base);
 207         size_exp = rd32(hw, I40E_GLHMC_FCOEFOBJSZ);
 208         obj->size = (u64)1 << size_exp;
 209
 210         /* validate values requested by driver don't exceed HMC capacity */
 211         if (fcoe_filt_num > obj->max_cnt) {
 212                 ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 213                 DEBUGOUT3("i40e_init_lan_hmc: FCoE filter: asks for 0x%x but max allowed is 0x%x, returns error %d\n",
 214                           fcoe_filt_num, obj->max_cnt, ret_code);
 215                 goto init_lan_hmc_out;
 216         }
 217
 218         /* aggregate values into the full LAN object for later */
 219         full_obj->max_cnt += obj->max_cnt;
 220         full_obj->cnt += obj->cnt;
 221
 222         hw->hmc.first_sd_index = 0;
 223         hw->hmc.sd_table.ref_cnt = 0;
 224         l2fpm_size = i40e_calculate_l2fpm_size(txq_num, rxq_num, fcoe_cntx_num,
 225                                                fcoe_filt_num);
 226         if (NULL == hw->hmc.sd_table.sd_entry) {
 227                 hw->hmc.sd_table.sd_cnt = (u32)
 228                                    (l2fpm_size + I40E_HMC_DIRECT_BP_SIZE - 1) /
 229                                    I40E_HMC_DIRECT_BP_SIZE;
 230
 231                 /* allocate the sd_entry members in the sd_table */
 232                 ret_code = i40e_allocate_virt_mem(hw, &hw->hmc.sd_table.addr,
 233                                           (sizeof(struct i40e_hmc_sd_entry) *
 234                                           hw->hmc.sd_table.sd_cnt));
 235                 if (ret_code)
 236                         goto init_lan_hmc_out;
 237                 hw->hmc.sd_table.sd_entry =
 238                         (struct i40e_hmc_sd_entry *)hw->hmc.sd_table.addr.va;
 239         }
 240         /* store in the LAN full object for later */
 241         full_obj->size = l2fpm_size;
 242
 243 init_lan_hmc_out:
 244         return ret_code;
 245 }
 246
 247 /**
 248  * i40e_remove_pd_page - Remove a page from the page descriptor table
 249  * @hw: pointer to the HW structure
 250  * @hmc_info: pointer to the HMC configuration information structure
 251  * @idx: segment descriptor index to find the relevant page descriptor
 252  *
 253  * This function:
 254  *      1. Marks the entry in pd table (for paged address mode) invalid
 255  *      2. write to register PMPDINV to invalidate the backing page in FV cache
 256  *      3. Decrement the ref count for  pd_entry
 257  * assumptions:
 258  *      1. caller can deallocate the memory used by pd after this function
 259  *         returns.
 260  **/
 261 STATIC enum i40e_status_code i40e_remove_pd_page(struct i40e_hw *hw,
 262                                                  struct i40e_hmc_info *hmc_info,
 263                                                  u32 idx)
 264 {
 265         enum i40e_status_code ret_code = I40E_SUCCESS;
 266
 267         if (i40e_prep_remove_pd_page(hmc_info, idx) == I40E_SUCCESS)
 268                 ret_code = i40e_remove_pd_page_new(hw, hmc_info, idx, true);
 269
 270         return ret_code;
 271 }
 272
 273 /**
 274  * i40e_remove_sd_bp - remove a backing page from a segment descriptor
 275  * @hw: pointer to our HW structure
 276  * @hmc_info: pointer to the HMC configuration information structure
 277  * @idx: the page index
 278  *
 279  * This function:
 280  *      1. Marks the entry in sd table (for direct address mode) invalid
 281  *      2. write to register PMSDCMD, PMSDDATALOW(PMSDDATALOW.PMSDVALID set
 282  *         to 0) and PMSDDATAHIGH to invalidate the sd page
 283  *      3. Decrement the ref count for the sd_entry
 284  * assumptions:
 285  *      1. caller can deallocate the memory used by backing storage after this
 286  *         function returns.
 287  **/
 288 STATIC enum i40e_status_code i40e_remove_sd_bp(struct i40e_hw *hw,
 289                                                struct i40e_hmc_info *hmc_info,
 290                                                u32 idx)
 291 {
 292         enum i40e_status_code ret_code = I40E_SUCCESS;
 293
 294         if (i40e_prep_remove_sd_bp(hmc_info, idx) == I40E_SUCCESS)
 295                 ret_code = i40e_remove_sd_bp_new(hw, hmc_info, idx, true);
 296
 297         return ret_code;
 298 }
 299
 300 /**
 301  * i40e_create_lan_hmc_object - allocate backing store for hmc objects
 302  * @hw: pointer to the HW structure
 303  * @info: pointer to i40e_hmc_create_obj_info struct
 304  *
 305  * This will allocate memory for PDs and backing pages and populate
 306  * the sd and pd entries.
 307  **/
 308 enum i40e_status_code i40e_create_lan_hmc_object(struct i40e_hw *hw,
 309                                 struct i40e_hmc_lan_create_obj_info *info)
 310 {
 311         enum i40e_status_code ret_code = I40E_SUCCESS;
 312         struct i40e_hmc_sd_entry *sd_entry;
 313         u32 pd_idx1 = 0, pd_lmt1 = 0;
 314         u32 pd_idx = 0, pd_lmt = 0;
 315         bool pd_error = false;
 316         u32 sd_idx, sd_lmt;
 317         u64 sd_size;
 318         u32 i, j;
 319
 320         if (NULL == info) {
 321                 ret_code = I40E_ERR_BAD_PTR;
 322                 DEBUGOUT("i40e_create_lan_hmc_object: bad info ptr\n");
 323                 goto exit;
 324         }
 325         if (NULL == info->hmc_info) {
 326                 ret_code = I40E_ERR_BAD_PTR;
 327                 DEBUGOUT("i40e_create_lan_hmc_object: bad hmc_info ptr\n");
 328                 goto exit;
 329         }
 330         if (I40E_HMC_INFO_SIGNATURE != info->hmc_info->signature) {
 331                 ret_code = I40E_ERR_BAD_PTR;
 332                 DEBUGOUT("i40e_create_lan_hmc_object: bad signature\n");
 333                 goto exit;
 334         }
 335
 336         if (info->start_idx >= info->hmc_info->hmc_obj[info->rsrc_type].cnt) {
 337                 ret_code = I40E_ERR_INVALID_HMC_OBJ_INDEX;
 338                 DEBUGOUT1("i40e_create_lan_hmc_object: returns error %d\n",
 339                           ret_code);
 340                 goto exit;
 341         }
 342         if ((info->start_idx + info->count) >
 343             info->hmc_info->hmc_obj[info->rsrc_type].cnt) {
 344                 ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 345                 DEBUGOUT1("i40e_create_lan_hmc_object: returns error %d\n",
 346                           ret_code);
 347                 goto exit;
 348         }
 349
 350         /* find sd index and limit */
 351         I40E_FIND_SD_INDEX_LIMIT(info->hmc_info, info->rsrc_type,
 352                                  info->start_idx, info->count,
 353                                  &sd_idx, &sd_lmt);
 354         if (sd_idx >= info->hmc_info->sd_table.sd_cnt ||
 355             sd_lmt > info->hmc_info->sd_table.sd_cnt) {
 356                         ret_code = I40E_ERR_INVALID_SD_INDEX;
 357                         goto exit;
 358         }
 359         /* find pd index */
 360         I40E_FIND_PD_INDEX_LIMIT(info->hmc_info, info->rsrc_type,
 361                                  info->start_idx, info->count, &pd_idx,
 362                                  &pd_lmt);
 363
 364         /* This is to cover for cases where you may not want to have an SD with
 365          * the full 2M memory but something smaller. By not filling out any
 366          * size, the function will default the SD size to be 2M.
 367          */
 368         if (info->direct_mode_sz == 0)
 369                 sd_size = I40E_HMC_DIRECT_BP_SIZE;
 370         else
 371                 sd_size = info->direct_mode_sz;
 372
 373         /* check if all the sds are valid. If not, allocate a page and
 374          * initialize it.
 375          */
 376         for (j = sd_idx; j < sd_lmt; j++) {
 377                 /* update the sd table entry */
 378                 ret_code = i40e_add_sd_table_entry(hw, info->hmc_info, j,
 379                                                    info->entry_type,
 380                                                    sd_size);
 381                 if (I40E_SUCCESS != ret_code)
 382                         goto exit_sd_error;
 383                 sd_entry = &info->hmc_info->sd_table.sd_entry[j];
 384                 if (I40E_SD_TYPE_PAGED == sd_entry->entry_type) {
 385                         /* check if all the pds in this sd are valid. If not,
 386                          * allocate a page and initialize it.
 387                          */
 388
 389                         /* find pd_idx and pd_lmt in this sd */
 390                         pd_idx1 = max(pd_idx, (j * I40E_HMC_MAX_BP_COUNT));
 391                         pd_lmt1 = min(pd_lmt,
 392                                       ((j + 1) * I40E_HMC_MAX_BP_COUNT));
 393                         for (i = pd_idx1; i < pd_lmt1; i++) {
 394                                 /* update the pd table entry */
 395                                 ret_code = i40e_add_pd_table_entry(hw,
 396                                                                 info->hmc_info,
 397                                                                 i);
 398                                 if (I40E_SUCCESS != ret_code) {
 399                                         pd_error = true;
 400                                         break;
 401                                 }
 402                         }
 403                         if (pd_error) {
 404                                 /* remove the backing pages from pd_idx1 to i */
 405                                 while (i && (i > pd_idx1)) {
 406                                         i40e_remove_pd_bp(hw, info->hmc_info,
 407                                                           (i - 1));
 408                                         i--;
 409                                 }
 410                         }
 411                 }
 412                 if (!sd_entry->valid) {
 413                         sd_entry->valid = true;
 414                         switch (sd_entry->entry_type) {
 415                         case I40E_SD_TYPE_PAGED:
 416                                 I40E_SET_PF_SD_ENTRY(hw,
 417                                         sd_entry->u.pd_table.pd_page_addr.pa,
 418                                         j, sd_entry->entry_type);
 419                                 break;
 420                         case I40E_SD_TYPE_DIRECT:
 421                                 I40E_SET_PF_SD_ENTRY(hw, sd_entry->u.bp.addr.pa,
 422                                                      j, sd_entry->entry_type);
 423                                 break;
 424                         default:
 425                                 ret_code = I40E_ERR_INVALID_SD_TYPE;
 426                                 goto exit;
 427                         }
 428                 }
 429         }
 430         goto exit;
 431
 432 exit_sd_error:
 433         /* cleanup for sd entries from j to sd_idx */
 434         while (j && (j > sd_idx)) {
 435                 sd_entry = &info->hmc_info->sd_table.sd_entry[j - 1];
 436                 switch (sd_entry->entry_type) {
 437                 case I40E_SD_TYPE_PAGED:
 438                         pd_idx1 = max(pd_idx,
 439                                       ((j - 1) * I40E_HMC_MAX_BP_COUNT));
 440                         pd_lmt1 = min(pd_lmt, (j * I40E_HMC_MAX_BP_COUNT));
 441                         for (i = pd_idx1; i < pd_lmt1; i++) {
 442                                 i40e_remove_pd_bp(hw, info->hmc_info, i);
 443                         }
 444                         i40e_remove_pd_page(hw, info->hmc_info, (j - 1));
 445                         break;
 446                 case I40E_SD_TYPE_DIRECT:
 447                         i40e_remove_sd_bp(hw, info->hmc_info, (j - 1));
 448                         break;
 449                 default:
 450                         ret_code = I40E_ERR_INVALID_SD_TYPE;
 451                         break;
 452                 }
 453                 j--;
 454         }
 455 exit:
 456         return ret_code;
 457 }
 458
 459 /**
 460  * i40e_configure_lan_hmc - prepare the HMC backing store
 461  * @hw: pointer to the hw structure
 462  * @model: the model for the layout of the SD/PD tables
 463  *
 464  * - This function will be called once per physical function initialization.
 465  * - This function will be called after i40e_init_lan_hmc() and before
 466  *   any LAN/FCoE HMC objects can be created.
 467  **/
 468 enum i40e_status_code i40e_configure_lan_hmc(struct i40e_hw *hw,
 469                                              enum i40e_hmc_model model)
 470 {
 471         struct i40e_hmc_lan_create_obj_info info;
 472         u8 hmc_fn_id = hw->hmc.hmc_fn_id;
 473         struct i40e_hmc_obj_info *obj;
 474         enum i40e_status_code ret_code = I40E_SUCCESS;
 475
 476         /* Initialize part of the create object info struct */
 477         info.hmc_info = &hw->hmc;
 478         info.rsrc_type = I40E_HMC_LAN_FULL;
 479         info.start_idx = 0;
 480         info.direct_mode_sz = hw->hmc.hmc_obj[I40E_HMC_LAN_FULL].size;
 481
 482         /* Build the SD entry for the LAN objects */
 483         switch (model) {
 484         case I40E_HMC_MODEL_DIRECT_PREFERRED:
 485         case I40E_HMC_MODEL_DIRECT_ONLY:
 486                 info.entry_type = I40E_SD_TYPE_DIRECT;
 487                 /* Make one big object, a single SD */
 488                 info.count = 1;
 489                 ret_code = i40e_create_lan_hmc_object(hw, &info);
 490                 if ((ret_code != I40E_SUCCESS) && (model == I40E_HMC_MODEL_DIRECT_PREFERRED))
 491                         goto try_type_paged;
 492                 else if (ret_code != I40E_SUCCESS)
 493                         goto configure_lan_hmc_out;
 494                 /* else clause falls through the break */
 495                 break;
 496         case I40E_HMC_MODEL_PAGED_ONLY:
 497 try_type_paged:
 498                 info.entry_type = I40E_SD_TYPE_PAGED;
 499                 /* Make one big object in the PD table */
 500                 info.count = 1;
 501                 ret_code = i40e_create_lan_hmc_object(hw, &info);
 502                 if (ret_code != I40E_SUCCESS)
 503                         goto configure_lan_hmc_out;
 504                 break;
 505         default:
 506                 /* unsupported type */
 507                 ret_code = I40E_ERR_INVALID_SD_TYPE;
 508                 DEBUGOUT1("i40e_configure_lan_hmc: Unknown SD type: %d\n",
 509                           ret_code);
 510                 goto configure_lan_hmc_out;
 511         }
 512
 513         /* Configure and program the FPM registers so objects can be created */
 514
 515         /* Tx contexts */
 516         obj = &hw->hmc.hmc_obj[I40E_HMC_LAN_TX];
 517         wr32(hw, I40E_GLHMC_LANTXBASE(hmc_fn_id),
 518              (u32)((obj->base & I40E_GLHMC_LANTXBASE_FPMLANTXBASE_MASK) / 512));
 519         wr32(hw, I40E_GLHMC_LANTXCNT(hmc_fn_id), obj->cnt);
 520
 521         /* Rx contexts */
 522         obj = &hw->hmc.hmc_obj[I40E_HMC_LAN_RX];
 523         wr32(hw, I40E_GLHMC_LANRXBASE(hmc_fn_id),
 524              (u32)((obj->base & I40E_GLHMC_LANRXBASE_FPMLANRXBASE_MASK) / 512));
 525         wr32(hw, I40E_GLHMC_LANRXCNT(hmc_fn_id), obj->cnt);
 526
 527         /* FCoE contexts */
 528         obj = &hw->hmc.hmc_obj[I40E_HMC_FCOE_CTX];
 529         wr32(hw, I40E_GLHMC_FCOEDDPBASE(hmc_fn_id),
 530          (u32)((obj->base & I40E_GLHMC_FCOEDDPBASE_FPMFCOEDDPBASE_MASK) / 512));
 531         wr32(hw, I40E_GLHMC_FCOEDDPCNT(hmc_fn_id), obj->cnt);
 532
 533         /* FCoE filters */
 534         obj = &hw->hmc.hmc_obj[I40E_HMC_FCOE_FILT];
 535         wr32(hw, I40E_GLHMC_FCOEFBASE(hmc_fn_id),
 536              (u32)((obj->base & I40E_GLHMC_FCOEFBASE_FPMFCOEFBASE_MASK) / 512));
 537         wr32(hw, I40E_GLHMC_FCOEFCNT(hmc_fn_id), obj->cnt);
 538
 539 configure_lan_hmc_out:
 540         return ret_code;
 541 }
 542
 543 /**
 544  * i40e_delete_hmc_object - remove hmc objects
 545  * @hw: pointer to the HW structure
 546  * @info: pointer to i40e_hmc_delete_obj_info struct
 547  *
 548  * This will de-populate the SDs and PDs.  It frees
 549  * the memory for PDS and backing storage.  After this function is returned,
 550  * caller should deallocate memory allocated previously for
 551  * book-keeping information about PDs and backing storage.
 552  **/
 553 enum i40e_status_code i40e_delete_lan_hmc_object(struct i40e_hw *hw,
 554                                 struct i40e_hmc_lan_delete_obj_info *info)
 555 {
 556         enum i40e_status_code ret_code = I40E_SUCCESS;
 557         struct i40e_hmc_pd_table *pd_table;
 558         u32 pd_idx, pd_lmt, rel_pd_idx;
 559         u32 sd_idx, sd_lmt;
 560         u32 i, j;
 561
 562         if (NULL == info) {
 563                 ret_code = I40E_ERR_BAD_PTR;
 564                 DEBUGOUT("i40e_delete_hmc_object: bad info ptr\n");
 565                 goto exit;
 566         }
 567         if (NULL == info->hmc_info) {
 568                 ret_code = I40E_ERR_BAD_PTR;
 569                 DEBUGOUT("i40e_delete_hmc_object: bad info->hmc_info ptr\n");
 570                 goto exit;
 571         }
 572         if (I40E_HMC_INFO_SIGNATURE != info->hmc_info->signature) {
 573                 ret_code = I40E_ERR_BAD_PTR;
 574                 DEBUGOUT("i40e_delete_hmc_object: bad hmc_info->signature\n");
 575                 goto exit;
 576         }
 577
 578         if (NULL == info->hmc_info->sd_table.sd_entry) {
 579                 ret_code = I40E_ERR_BAD_PTR;
 580                 DEBUGOUT("i40e_delete_hmc_object: bad sd_entry\n");
 581                 goto exit;
 582         }
 583
 584         if (NULL == info->hmc_info->hmc_obj) {
 585                 ret_code = I40E_ERR_BAD_PTR;
 586                 DEBUGOUT("i40e_delete_hmc_object: bad hmc_info->hmc_obj\n");
 587                 goto exit;
 588         }
 589         if (info->start_idx >= info->hmc_info->hmc_obj[info->rsrc_type].cnt) {
 590                 ret_code = I40E_ERR_INVALID_HMC_OBJ_INDEX;
 591                 DEBUGOUT1("i40e_delete_hmc_object: returns error %d\n",
 592                           ret_code);
 593                 goto exit;
 594         }
 595
 596         if ((info->start_idx + info->count) >
 597             info->hmc_info->hmc_obj[info->rsrc_type].cnt) {
 598                 ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 599                 DEBUGOUT1("i40e_delete_hmc_object: returns error %d\n",
 600                           ret_code);
 601                 goto exit;
 602         }
 603
 604         I40E_FIND_PD_INDEX_LIMIT(info->hmc_info, info->rsrc_type,
 605                                  info->start_idx, info->count, &pd_idx,
 606                                  &pd_lmt);
 607
 608         for (j = pd_idx; j < pd_lmt; j++) {
 609                 sd_idx = j / I40E_HMC_PD_CNT_IN_SD;
 610
 611                 if (I40E_SD_TYPE_PAGED !=
 612                     info->hmc_info->sd_table.sd_entry[sd_idx].entry_type)
 613                         continue;
 614
 615                 rel_pd_idx = j % I40E_HMC_PD_CNT_IN_SD;
 616
 617                 pd_table =
 618                         &info->hmc_info->sd_table.sd_entry[sd_idx].u.pd_table;
 619                 if (pd_table->pd_entry[rel_pd_idx].valid) {
 620                         ret_code = i40e_remove_pd_bp(hw, info->hmc_info, j);
 621                         if (I40E_SUCCESS != ret_code)
 622                                 goto exit;
 623                 }
 624         }
 625
 626         /* find sd index and limit */
 627         I40E_FIND_SD_INDEX_LIMIT(info->hmc_info, info->rsrc_type,
 628                                  info->start_idx, info->count,
 629                                  &sd_idx, &sd_lmt);
 630         if (sd_idx >= info->hmc_info->sd_table.sd_cnt ||
 631             sd_lmt > info->hmc_info->sd_table.sd_cnt) {
 632                 ret_code = I40E_ERR_INVALID_SD_INDEX;
 633                 goto exit;
 634         }
 635
 636         for (i = sd_idx; i < sd_lmt; i++) {
 637                 if (!info->hmc_info->sd_table.sd_entry[i].valid)
 638                         continue;
 639                 switch (info->hmc_info->sd_table.sd_entry[i].entry_type) {
 640                 case I40E_SD_TYPE_DIRECT:
 641                         ret_code = i40e_remove_sd_bp(hw, info->hmc_info, i);
 642                         if (I40E_SUCCESS != ret_code)
 643                                 goto exit;
 644                         break;
 645                 case I40E_SD_TYPE_PAGED:
 646                         ret_code = i40e_remove_pd_page(hw, info->hmc_info, i);
 647                         if (I40E_SUCCESS != ret_code)
 648                                 goto exit;
 649                         break;
 650                 default:
 651                         break;
 652                 }
 653         }
 654 exit:
 655         return ret_code;
 656 }
 657
 658 /**
 659  * i40e_shutdown_lan_hmc - Remove HMC backing store, free allocated memory
 660  * @hw: pointer to the hw structure
 661  *
 662  * This must be called by drivers as they are shutting down and being
 663  * removed from the OS.
 664  **/
 665 enum i40e_status_code i40e_shutdown_lan_hmc(struct i40e_hw *hw)
 666 {
 667         struct i40e_hmc_lan_delete_obj_info info;
 668         enum i40e_status_code ret_code;
 669
 670         info.hmc_info = &hw->hmc;
 671         info.rsrc_type = I40E_HMC_LAN_FULL;
 672         info.start_idx = 0;
 673         info.count = 1;
 674
 675         /* delete the object */
 676         ret_code = i40e_delete_lan_hmc_object(hw, &info);
 677
 678         /* free the SD table entry for LAN */
 679         i40e_free_virt_mem(hw, &hw->hmc.sd_table.addr);
 680         hw->hmc.sd_table.sd_cnt = 0;
 681         hw->hmc.sd_table.sd_entry = NULL;
 682
 683         /* free memory used for hmc_obj */
 684         i40e_free_virt_mem(hw, &hw->hmc.hmc_obj_virt_mem);
 685         hw->hmc.hmc_obj = NULL;
 686
 687         return ret_code;
 688 }
 689
 690 #define I40E_HMC_STORE(_struct, _ele)           \
 691         offsetof(struct _struct, _ele),         \
 692         FIELD_SIZEOF(struct _struct, _ele)
 693
 694 struct i40e_context_ele {
 695         u16 offset;
 696         u16 size_of;
 697         u16 width;
 698         u16 lsb;
 699 };
 700
 701 /* LAN Tx Queue Context */
 702 static struct i40e_context_ele i40e_hmc_txq_ce_info[] = {
 703                                              /* Field      Width    LSB */
 704         {I40E_HMC_STORE(i40e_hmc_obj_txq, head),           13,      0 },
 705         {I40E_HMC_STORE(i40e_hmc_obj_txq, new_context),     1,     30 },
 706         {I40E_HMC_STORE(i40e_hmc_obj_txq, base),           57,     32 },
 707         {I40E_HMC_STORE(i40e_hmc_obj_txq, fc_ena),          1,     89 },
 708         {I40E_HMC_STORE(i40e_hmc_obj_txq, timesync_ena),    1,     90 },
 709         {I40E_HMC_STORE(i40e_hmc_obj_txq, fd_ena),          1,     91 },
 710         {I40E_HMC_STORE(i40e_hmc_obj_txq, alt_vlan_ena),    1,     92 },
 711         {I40E_HMC_STORE(i40e_hmc_obj_txq, cpuid),           8,     96 },
 712 /* line 1 */
 713         {I40E_HMC_STORE(i40e_hmc_obj_txq, thead_wb),       13,  0 + 128 },
 714         {I40E_HMC_STORE(i40e_hmc_obj_txq, head_wb_ena),     1, 32 + 128 },
 715         {I40E_HMC_STORE(i40e_hmc_obj_txq, qlen),           13, 33 + 128 },
 716         {I40E_HMC_STORE(i40e_hmc_obj_txq, tphrdesc_ena),    1, 46 + 128 },
 717         {I40E_HMC_STORE(i40e_hmc_obj_txq, tphrpacket_ena),  1, 47 + 128 },
 718         {I40E_HMC_STORE(i40e_hmc_obj_txq, tphwdesc_ena),    1, 48 + 128 },
 719         {I40E_HMC_STORE(i40e_hmc_obj_txq, head_wb_addr),   64, 64 + 128 },
 720 /* line 7 */
 721         {I40E_HMC_STORE(i40e_hmc_obj_txq, crc),            32,  0 + (7 * 128) },
 722         {I40E_HMC_STORE(i40e_hmc_obj_txq, rdylist),        10, 84 + (7 * 128) },
 723         {I40E_HMC_STORE(i40e_hmc_obj_txq, rdylist_act),     1, 94 + (7 * 128) },
 724         { 0 }
 725 };
 726
 727 /* LAN Rx Queue Context */
 728 static struct i40e_context_ele i40e_hmc_rxq_ce_info[] = {
 729                                          /* Field      Width    LSB */
 730         { I40E_HMC_STORE(i40e_hmc_obj_rxq, head),        13,    0   },
 731         { I40E_HMC_STORE(i40e_hmc_obj_rxq, cpuid),        8,    13  },
 732         { I40E_HMC_STORE(i40e_hmc_obj_rxq, base),        57,    32  },
 733         { I40E_HMC_STORE(i40e_hmc_obj_rxq, qlen),        13,    89  },
 734         { I40E_HMC_STORE(i40e_hmc_obj_rxq, dbuff),        7,    102 },
 735         { I40E_HMC_STORE(i40e_hmc_obj_rxq, hbuff),        5,    109 },
 736         { I40E_HMC_STORE(i40e_hmc_obj_rxq, dtype),        2,    114 },
 737         { I40E_HMC_STORE(i40e_hmc_obj_rxq, dsize),        1,    116 },
 738         { I40E_HMC_STORE(i40e_hmc_obj_rxq, crcstrip),     1,    117 },
 739         { I40E_HMC_STORE(i40e_hmc_obj_rxq, fc_ena),       1,    118 },
 740         { I40E_HMC_STORE(i40e_hmc_obj_rxq, l2tsel),       1,    119 },
 741         { I40E_HMC_STORE(i40e_hmc_obj_rxq, hsplit_0),     4,    120 },
 742         { I40E_HMC_STORE(i40e_hmc_obj_rxq, hsplit_1),     2,    124 },
 743         { I40E_HMC_STORE(i40e_hmc_obj_rxq, showiv),       1,    127 },
 744         { I40E_HMC_STORE(i40e_hmc_obj_rxq, rxmax),       14,    174 },
 745         { I40E_HMC_STORE(i40e_hmc_obj_rxq, tphrdesc_ena), 1,    193 },
 746         { I40E_HMC_STORE(i40e_hmc_obj_rxq, tphwdesc_ena), 1,    194 },
 747         { I40E_HMC_STORE(i40e_hmc_obj_rxq, tphdata_ena),  1,    195 },
 748         { I40E_HMC_STORE(i40e_hmc_obj_rxq, tphhead_ena),  1,    196 },
 749         { I40E_HMC_STORE(i40e_hmc_obj_rxq, lrxqthresh),   3,    198 },
 750         { I40E_HMC_STORE(i40e_hmc_obj_rxq, prefena),      1,    201 },
 751         { 0 }
 752 };
 753
 754 /**
 755  * i40e_write_byte - replace HMC context byte
 756  * @hmc_bits: pointer to the HMC memory
 757  * @ce_info: a description of the struct to be read from
 758  * @src: the struct to be read from
 759  **/
 760 static void i40e_write_byte(u8 *hmc_bits,
 761                             struct i40e_context_ele *ce_info,
 762                             u8 *src)
 763 {
 764         u8 src_byte, dest_byte, mask;
 765         u8 *from, *dest;
 766         u16 shift_width;
 767
 768         /* copy from the next struct field */
 769         from = src + ce_info->offset;
 770
 771         /* prepare the bits and mask */
 772         shift_width = ce_info->lsb % 8;
 773         mask = ((u8)1 << ce_info->width) - 1;
 774
 775         src_byte = *from;
 776         src_byte &= mask;
 777
 778         /* shift to correct alignment */
 779         mask <<= shift_width;
 780         src_byte <<= shift_width;
 781
 782         /* get the current bits from the target bit string */
 783         dest = hmc_bits + (ce_info->lsb / 8);
 784
 785         i40e_memcpy(&dest_byte, dest, sizeof(dest_byte), I40E_DMA_TO_NONDMA);
 786
 787         dest_byte &= ~mask;     /* get the bits not changing */
 788         dest_byte |= src_byte;  /* add in the new bits */
 789
 790         /* put it all back */
 791         i40e_memcpy(dest, &dest_byte, sizeof(dest_byte), I40E_NONDMA_TO_DMA);
 792 }
 793
 794 /**
 795  * i40e_write_word - replace HMC context word
 796  * @hmc_bits: pointer to the HMC memory
 797  * @ce_info: a description of the struct to be read from
 798  * @src: the struct to be read from
 799  **/
 800 static void i40e_write_word(u8 *hmc_bits,
 801                             struct i40e_context_ele *ce_info,
 802                             u8 *src)
 803 {
 804         u16 src_word, mask;
 805         u8 *from, *dest;
 806         u16 shift_width;
 807         __le16 dest_word;
 808
 809         /* copy from the next struct field */
 810         from = src + ce_info->offset;
 811
 812         /* prepare the bits and mask */
 813         shift_width = ce_info->lsb % 8;
 814         mask = ((u16)1 << ce_info->width) - 1;
 815
 816         /* don't swizzle the bits until after the mask because the mask bits
 817          * will be in a different bit position on big endian machines
 818          */
 819         src_word = *(u16 *)from;
 820         src_word &= mask;
 821
 822         /* shift to correct alignment */
 823         mask <<= shift_width;
 824         src_word <<= shift_width;
 825
 826         /* get the current bits from the target bit string */
 827         dest = hmc_bits + (ce_info->lsb / 8);
 828
 829         i40e_memcpy(&dest_word, dest, sizeof(dest_word), I40E_DMA_TO_NONDMA);
 830
 831         dest_word &= ~(CPU_TO_LE16(mask));      /* get the bits not changing */
 832         dest_word |= CPU_TO_LE16(src_word);     /* add in the new bits */
 833
 834         /* put it all back */
 835         i40e_memcpy(dest, &dest_word, sizeof(dest_word), I40E_NONDMA_TO_DMA);
 836 }
 837
 838 /**
 839  * i40e_write_dword - replace HMC context dword
 840  * @hmc_bits: pointer to the HMC memory
 841  * @ce_info: a description of the struct to be read from
 842  * @src: the struct to be read from
 843  **/
 844 static void i40e_write_dword(u8 *hmc_bits,
 845                              struct i40e_context_ele *ce_info,
 846                              u8 *src)
 847 {
 848         u32 src_dword, mask;
 849         u8 *from, *dest;
 850         u16 shift_width;
 851         __le32 dest_dword;
 852
 853         /* copy from the next struct field */
 854         from = src + ce_info->offset;
 855
 856         /* prepare the bits and mask */
 857         shift_width = ce_info->lsb % 8;
 858
 859         /* if the field width is exactly 32 on an x86 machine, then the shift
 860          * operation will not work because the SHL instructions count is masked
 861          * to 5 bits so the shift will do nothing
 862          */
 863         if (ce_info->width < 32)
 864                 mask = ((u32)1 << ce_info->width) - 1;
 865         else
 866                 mask = ~(u32)0;
 867
 868         /* don't swizzle the bits until after the mask because the mask bits
 869          * will be in a different bit position on big endian machines
 870          */
 871         src_dword = *(u32 *)from;
 872         src_dword &= mask;
 873
 874         /* shift to correct alignment */
 875         mask <<= shift_width;
 876         src_dword <<= shift_width;
 877
 878         /* get the current bits from the target bit string */
 879         dest = hmc_bits + (ce_info->lsb / 8);
 880
 881         i40e_memcpy(&dest_dword, dest, sizeof(dest_dword), I40E_DMA_TO_NONDMA);
 882
 883         dest_dword &= ~(CPU_TO_LE32(mask));     /* get the bits not changing */
 884         dest_dword |= CPU_TO_LE32(src_dword);   /* add in the new bits */
 885
 886         /* put it all back */
 887         i40e_memcpy(dest, &dest_dword, sizeof(dest_dword), I40E_NONDMA_TO_DMA);
 888 }
 889
 890 /**
 891  * i40e_write_qword - replace HMC context qword
 892  * @hmc_bits: pointer to the HMC memory
 893  * @ce_info: a description of the struct to be read from
 894  * @src: the struct to be read from
 895  **/
 896 static void i40e_write_qword(u8 *hmc_bits,
 897                              struct i40e_context_ele *ce_info,
 898                              u8 *src)
 899 {
 900         u64 src_qword, mask;
 901         u8 *from, *dest;
 902         u16 shift_width;
 903         __le64 dest_qword;
 904
 905         /* copy from the next struct field */
 906         from = src + ce_info->offset;
 907
 908         /* prepare the bits and mask */
 909         shift_width = ce_info->lsb % 8;
 910
 911         /* if the field width is exactly 64 on an x86 machine, then the shift
 912          * operation will not work because the SHL instructions count is masked
 913          * to 6 bits so the shift will do nothing
 914          */
 915         if (ce_info->width < 64)
 916                 mask = ((u64)1 << ce_info->width) - 1;
 917         else
 918                 mask = ~(u64)0;
 919
 920         /* don't swizzle the bits until after the mask because the mask bits
 921          * will be in a different bit position on big endian machines
 922          */
 923         src_qword = *(u64 *)from;
 924         src_qword &= mask;
 925
 926         /* shift to correct alignment */
 927         mask <<= shift_width;
 928         src_qword <<= shift_width;
 929
 930         /* get the current bits from the target bit string */
 931         dest = hmc_bits + (ce_info->lsb / 8);
 932
 933         i40e_memcpy(&dest_qword, dest, sizeof(dest_qword), I40E_DMA_TO_NONDMA);
 934
 935         dest_qword &= ~(CPU_TO_LE64(mask));     /* get the bits not changing */
 936         dest_qword |= CPU_TO_LE64(src_qword);   /* add in the new bits */
 937
 938         /* put it all back */
 939         i40e_memcpy(dest, &dest_qword, sizeof(dest_qword), I40E_NONDMA_TO_DMA);
 940 }
 941
 942 /**
 943  * i40e_read_byte - read HMC context byte into struct
 944  * @hmc_bits: pointer to the HMC memory
 945  * @ce_info: a description of the struct to be filled
 946  * @dest: the struct to be filled
 947  **/
 948 static void i40e_read_byte(u8 *hmc_bits,
 949                            struct i40e_context_ele *ce_info,
 950                            u8 *dest)
 951 {
 952         u8 dest_byte, mask;
 953         u8 *src, *target;
 954         u16 shift_width;
 955
 956         /* prepare the bits and mask */
 957         shift_width = ce_info->lsb % 8;
 958         mask = ((u8)1 << ce_info->width) - 1;
 959
 960         /* shift to correct alignment */
 961         mask <<= shift_width;
 962
 963         /* get the current bits from the src bit string */
 964         src = hmc_bits + (ce_info->lsb / 8);
 965
 966         i40e_memcpy(&dest_byte, src, sizeof(dest_byte), I40E_DMA_TO_NONDMA);
 967
 968         dest_byte &= ~(mask);
 969
 970         dest_byte >>= shift_width;
 971
 972         /* get the address from the struct field */
 973         target = dest + ce_info->offset;
 974
 975         /* put it back in the struct */
 976         i40e_memcpy(target, &dest_byte, sizeof(dest_byte), I40E_NONDMA_TO_DMA);
 977 }
 978
 979 /**
 980  * i40e_read_word - read HMC context word into struct
 981  * @hmc_bits: pointer to the HMC memory
 982  * @ce_info: a description of the struct to be filled
 983  * @dest: the struct to be filled
 984  **/
 985 static void i40e_read_word(u8 *hmc_bits,
 986                            struct i40e_context_ele *ce_info,
 987                            u8 *dest)
 988 {
 989         u16 dest_word, mask;
 990         u8 *src, *target;
 991         u16 shift_width;
 992         __le16 src_word;
 993
 994         /* prepare the bits and mask */
 995         shift_width = ce_info->lsb % 8;
 996         mask = ((u16)1 << ce_info->width) - 1;
 997
 998         /* shift to correct alignment */
 999         mask <<= shift_width;
1000
1001         /* get the current bits from the src bit string */
1002         src = hmc_bits + (ce_info->lsb / 8);
1003
1004         i40e_memcpy(&src_word, src, sizeof(src_word), I40E_DMA_TO_NONDMA);
1005
1006         /* the data in the memory is stored as little endian so mask it
1007          * correctly
1008          */
1009         src_word &= ~(CPU_TO_LE16(mask));
1010
1011         /* get the data back into host order before shifting */
1012         dest_word = LE16_TO_CPU(src_word);
1013
1014         dest_word >>= shift_width;
1015
1016         /* get the address from the struct field */
1017         target = dest + ce_info->offset;
1018
1019         /* put it back in the struct */
1020         i40e_memcpy(target, &dest_word, sizeof(dest_word), I40E_NONDMA_TO_DMA);
1021 }
1022
1023 /**
1024  * i40e_read_dword - read HMC context dword into struct
1025  * @hmc_bits: pointer to the HMC memory
1026  * @ce_info: a description of the struct to be filled
1027  * @dest: the struct to be filled
1028  **/
1029 static void i40e_read_dword(u8 *hmc_bits,
1030                             struct i40e_context_ele *ce_info,
1031                             u8 *dest)
1032 {
1033         u32 dest_dword, mask;
1034         u8 *src, *target;
1035         u16 shift_width;
1036         __le32 src_dword;
1037
1038         /* prepare the bits and mask */
1039         shift_width = ce_info->lsb % 8;
1040
1041         /* if the field width is exactly 32 on an x86 machine, then the shift
1042          * operation will not work because the SHL instructions count is masked
1043          * to 5 bits so the shift will do nothing
1044          */
1045         if (ce_info->width < 32)
1046                 mask = ((u32)1 << ce_info->width) - 1;
1047         else
1048                 mask = ~(u32)0;
1049
1050         /* shift to correct alignment */
1051         mask <<= shift_width;
1052
1053         /* get the current bits from the src bit string */
1054         src = hmc_bits + (ce_info->lsb / 8);
1055
1056         i40e_memcpy(&src_dword, src, sizeof(src_dword), I40E_DMA_TO_NONDMA);
1057
1058         /* the data in the memory is stored as little endian so mask it
1059          * correctly
1060          */
1061         src_dword &= ~(CPU_TO_LE32(mask));
1062
1063         /* get the data back into host order before shifting */
1064         dest_dword = LE32_TO_CPU(src_dword);
1065
1066         dest_dword >>= shift_width;
1067
1068         /* get the address from the struct field */
1069         target = dest + ce_info->offset;
1070
1071         /* put it back in the struct */
1072         i40e_memcpy(target, &dest_dword, sizeof(dest_dword),
1073                     I40E_NONDMA_TO_DMA);
1074 }
1075
1076 /**
1077  * i40e_read_qword - read HMC context qword into struct
1078  * @hmc_bits: pointer to the HMC memory
1079  * @ce_info: a description of the struct to be filled
1080  * @dest: the struct to be filled
1081  **/
1082 static void i40e_read_qword(u8 *hmc_bits,
1083                             struct i40e_context_ele *ce_info,
1084                             u8 *dest)
1085 {
1086         u64 dest_qword, mask;
1087         u8 *src, *target;
1088         u16 shift_width;
1089         __le64 src_qword;
1090
1091         /* prepare the bits and mask */
1092         shift_width = ce_info->lsb % 8;
1093
1094         /* if the field width is exactly 64 on an x86 machine, then the shift
1095          * operation will not work because the SHL instructions count is masked
1096          * to 6 bits so the shift will do nothing
1097          */
1098         if (ce_info->width < 64)
1099                 mask = ((u64)1 << ce_info->width) - 1;
1100         else
1101                 mask = ~(u64)0;
1102
1103         /* shift to correct alignment */
1104         mask <<= shift_width;
1105
1106         /* get the current bits from the src bit string */
1107         src = hmc_bits + (ce_info->lsb / 8);
1108
1109         i40e_memcpy(&src_qword, src, sizeof(src_qword), I40E_DMA_TO_NONDMA);
1110
1111         /* the data in the memory is stored as little endian so mask it
1112          * correctly
1113          */
1114         src_qword &= ~(CPU_TO_LE64(mask));
1115
1116         /* get the data back into host order before shifting */
1117         dest_qword = LE64_TO_CPU(src_qword);
1118
1119         dest_qword >>= shift_width;
1120
1121         /* get the address from the struct field */
1122         target = dest + ce_info->offset;
1123
1124         /* put it back in the struct */
1125         i40e_memcpy(target, &dest_qword, sizeof(dest_qword),
1126                     I40E_NONDMA_TO_DMA);
1127 }
1128
1129 /**
1130  * i40e_get_hmc_context - extract HMC context bits
1131  * @context_bytes: pointer to the context bit array
1132  * @ce_info: a description of the struct to be filled
1133  * @dest: the struct to be filled
1134  **/
1135 static enum i40e_status_code i40e_get_hmc_context(u8 *context_bytes,
1136                                         struct i40e_context_ele *ce_info,
1137                                         u8 *dest)
1138 {
1139         int f;
1140
1141         for (f = 0; ce_info[f].width != 0; f++) {
1142                 switch (ce_info[f].size_of) {
1143                 case 1:
1144                         i40e_read_byte(context_bytes, &ce_info[f], dest);
1145                         break;
1146                 case 2:
1147                         i40e_read_word(context_bytes, &ce_info[f], dest);
1148                         break;
1149                 case 4:
1150                         i40e_read_dword(context_bytes, &ce_info[f], dest);
1151                         break;
1152                 case 8:
1153                         i40e_read_qword(context_bytes, &ce_info[f], dest);
1154                         break;
1155                 default:
1156                         /* nothing to do, just keep going */
1157                         break;
1158                 }
1159         }
1160
1161         return I40E_SUCCESS;
1162 }
1163
1164 /**
1165  * i40e_clear_hmc_context - zero out the HMC context bits
1166  * @hw:       the hardware struct
1167  * @context_bytes: pointer to the context bit array (DMA memory)
1168  * @hmc_type: the type of HMC resource
1169  **/
1170 static enum i40e_status_code i40e_clear_hmc_context(struct i40e_hw *hw,
1171                                         u8 *context_bytes,
1172                                         enum i40e_hmc_lan_rsrc_type hmc_type)
1173 {
1174         /* clean the bit array */
1175         i40e_memset(context_bytes, 0, (u32)hw->hmc.hmc_obj[hmc_type].size,
1176                     I40E_DMA_MEM);
1177
1178         return I40E_SUCCESS;
1179 }
1180
1181 /**
1182  * i40e_set_hmc_context - replace HMC context bits
1183  * @context_bytes: pointer to the context bit array
1184  * @ce_info:  a description of the struct to be filled
1185  * @dest:     the struct to be filled
1186  **/
1187 static enum i40e_status_code i40e_set_hmc_context(u8 *context_bytes,
1188                                         struct i40e_context_ele *ce_info,
1189                                         u8 *dest)
1190 {
1191         int f;
1192
1193         for (f = 0; ce_info[f].width != 0; f++) {
1194
1195                 /* we have to deal with each element of the HMC using the
1196                  * correct size so that we are correct regardless of the
1197                  * endianness of the machine
1198                  */
1199                 switch (ce_info[f].size_of) {
1200                 case 1:
1201                         i40e_write_byte(context_bytes, &ce_info[f], dest);
1202                         break;
1203                 case 2:
1204                         i40e_write_word(context_bytes, &ce_info[f], dest);
1205                         break;
1206                 case 4:
1207                         i40e_write_dword(context_bytes, &ce_info[f], dest);
1208                         break;
1209                 case 8:
1210                         i40e_write_qword(context_bytes, &ce_info[f], dest);
1211                         break;
1212                 }
1213         }
1214
1215         return I40E_SUCCESS;
1216 }
1217
1218 /**
1219  * i40e_hmc_get_object_va - retrieves an object's virtual address
1220  * @hw: pointer to the hw structure
1221  * @object_base: pointer to u64 to get the va
1222  * @rsrc_type: the hmc resource type
1223  * @obj_idx: hmc object index
1224  *
1225  * This function retrieves the object's virtual address from the object
1226  * base pointer.  This function is used for LAN Queue contexts.
1227  **/
1228 STATIC
1229 enum i40e_status_code i40e_hmc_get_object_va(struct i40e_hw *hw,
1230                                         u8 **object_base,
1231                                         enum i40e_hmc_lan_rsrc_type rsrc_type,
1232                                         u32 obj_idx)
1233 {
1234         u32 obj_offset_in_sd, obj_offset_in_pd;
1235         struct i40e_hmc_info     *hmc_info = &hw->hmc;
1236         struct i40e_hmc_sd_entry *sd_entry;
1237         struct i40e_hmc_pd_entry *pd_entry;
1238         u32 pd_idx, pd_lmt, rel_pd_idx;
1239         enum i40e_status_code ret_code = I40E_SUCCESS;
1240         u64 obj_offset_in_fpm;
1241         u32 sd_idx, sd_lmt;
1242
1243         if (NULL == hmc_info) {
1244                 ret_code = I40E_ERR_BAD_PTR;
1245                 DEBUGOUT("i40e_hmc_get_object_va: bad hmc_info ptr\n");
1246                 goto exit;
1247         }
1248         if (NULL == hmc_info->hmc_obj) {
1249                 ret_code = I40E_ERR_BAD_PTR;
1250                 DEBUGOUT("i40e_hmc_get_object_va: bad hmc_info->hmc_obj ptr\n");
1251                 goto exit;
1252         }
1253         if (NULL == object_base) {
1254                 ret_code = I40E_ERR_BAD_PTR;
1255                 DEBUGOUT("i40e_hmc_get_object_va: bad object_base ptr\n");
1256                 goto exit;
1257         }
1258         if (I40E_HMC_INFO_SIGNATURE != hmc_info->signature) {
1259                 ret_code = I40E_ERR_BAD_PTR;
1260                 DEBUGOUT("i40e_hmc_get_object_va: bad hmc_info->signature\n");
1261                 goto exit;
1262         }
1263         if (obj_idx >= hmc_info->hmc_obj[rsrc_type].cnt) {
1264                 DEBUGOUT1("i40e_hmc_get_object_va: returns error %d\n",
1265                           ret_code);
1266                 ret_code = I40E_ERR_INVALID_HMC_OBJ_INDEX;
1267                 goto exit;
1268         }
1269         /* find sd index and limit */
1270         I40E_FIND_SD_INDEX_LIMIT(hmc_info, rsrc_type, obj_idx, 1,
1271                                  &sd_idx, &sd_lmt);
1272
1273         sd_entry = &hmc_info->sd_table.sd_entry[sd_idx];
1274         obj_offset_in_fpm = hmc_info->hmc_obj[rsrc_type].base +
1275                             hmc_info->hmc_obj[rsrc_type].size * obj_idx;
1276
1277         if (I40E_SD_TYPE_PAGED == sd_entry->entry_type) {
1278                 I40E_FIND_PD_INDEX_LIMIT(hmc_info, rsrc_type, obj_idx, 1,
1279                                          &pd_idx, &pd_lmt);
1280                 rel_pd_idx = pd_idx % I40E_HMC_PD_CNT_IN_SD;
1281                 pd_entry = &sd_entry->u.pd_table.pd_entry[rel_pd_idx];
1282                 obj_offset_in_pd = (u32)(obj_offset_in_fpm %
1283                                          I40E_HMC_PAGED_BP_SIZE);
1284                 *object_base = (u8 *)pd_entry->bp.addr.va + obj_offset_in_pd;
1285         } else {
1286                 obj_offset_in_sd = (u32)(obj_offset_in_fpm %
1287                                          I40E_HMC_DIRECT_BP_SIZE);
1288                 *object_base = (u8 *)sd_entry->u.bp.addr.va + obj_offset_in_sd;
1289         }
1290 exit:
1291         return ret_code;
1292 }
1293
1294 /**
1295  * i40e_get_lan_tx_queue_context - return the HMC context for the queue
1296  * @hw:    the hardware struct
1297  * @queue: the queue we care about
1298  * @s:     the struct to be filled
1299  **/
1300 enum i40e_status_code i40e_get_lan_tx_queue_context(struct i40e_hw *hw,
1301                                                     u16 queue,
1302                                                     struct i40e_hmc_obj_txq *s)
1303 {
1304         enum i40e_status_code err;
1305         u8 *context_bytes;
1306
1307         err = i40e_hmc_get_object_va(hw, &context_bytes, I40E_HMC_LAN_TX, queue);
1308         if (err < 0)
1309                 return err;
1310
1311         return i40e_get_hmc_context(context_bytes,
1312                                     i40e_hmc_txq_ce_info, (u8 *)s);
1313 }
1314
1315 /**
1316  * i40e_clear_lan_tx_queue_context - clear the HMC context for the queue
1317  * @hw:    the hardware struct
1318  * @queue: the queue we care about
1319  **/
1320 enum i40e_status_code i40e_clear_lan_tx_queue_context(struct i40e_hw *hw,
1321                                                       u16 queue)
1322 {
1323         enum i40e_status_code err;
1324         u8 *context_bytes;
1325
1326         err = i40e_hmc_get_object_va(hw, &context_bytes, I40E_HMC_LAN_TX, queue);
1327         if (err < 0)
1328                 return err;
1329
1330         return i40e_clear_hmc_context(hw, context_bytes, I40E_HMC_LAN_TX);
1331 }
1332
1333 /**
1334  * i40e_set_lan_tx_queue_context - set the HMC context for the queue
1335  * @hw:    the hardware struct
1336  * @queue: the queue we care about
1337  * @s:     the struct to be filled
1338  **/
1339 enum i40e_status_code i40e_set_lan_tx_queue_context(struct i40e_hw *hw,
1340                                                     u16 queue,
1341                                                     struct i40e_hmc_obj_txq *s)
1342 {
1343         enum i40e_status_code err;
1344         u8 *context_bytes;
1345
1346         err = i40e_hmc_get_object_va(hw, &context_bytes, I40E_HMC_LAN_TX, queue);
1347         if (err < 0)
1348                 return err;
1349
1350         return i40e_set_hmc_context(context_bytes,
1351                                     i40e_hmc_txq_ce_info, (u8 *)s);
1352 }
1353
1354 /**
1355  * i40e_get_lan_rx_queue_context - return the HMC context for the queue
1356  * @hw:    the hardware struct
1357  * @queue: the queue we care about
1358  * @s:     the struct to be filled
1359  **/
1360 enum i40e_status_code i40e_get_lan_rx_queue_context(struct i40e_hw *hw,
1361                                                     u16 queue,
1362                                                     struct i40e_hmc_obj_rxq *s)
1363 {
1364         enum i40e_status_code err;
1365         u8 *context_bytes;
1366
1367         err = i40e_hmc_get_object_va(hw, &context_bytes, I40E_HMC_LAN_RX, queue);
1368         if (err < 0)
1369                 return err;
1370
1371         return i40e_get_hmc_context(context_bytes,
1372                                     i40e_hmc_rxq_ce_info, (u8 *)s);
1373 }
1374
1375 /**
1376  * i40e_clear_lan_rx_queue_context - clear the HMC context for the queue
1377  * @hw:    the hardware struct
1378  * @queue: the queue we care about
1379  **/
1380 enum i40e_status_code i40e_clear_lan_rx_queue_context(struct i40e_hw *hw,
1381                                                       u16 queue)
1382 {
1383         enum i40e_status_code err;
1384         u8 *context_bytes;
1385
1386         err = i40e_hmc_get_object_va(hw, &context_bytes, I40E_HMC_LAN_RX, queue);
1387         if (err < 0)
1388                 return err;
1389
1390         return i40e_clear_hmc_context(hw, context_bytes, I40E_HMC_LAN_RX);
1391 }
1392
1393 /**
1394  * i40e_set_lan_rx_queue_context - set the HMC context for the queue
1395  * @hw:    the hardware struct
1396  * @queue: the queue we care about
1397  * @s:     the struct to be filled
1398  **/
1399 enum i40e_status_code i40e_set_lan_rx_queue_context(struct i40e_hw *hw,
1400                                                     u16 queue,
1401                                                     struct i40e_hmc_obj_rxq *s)
1402 {
1403         enum i40e_status_code err;
1404         u8 *context_bytes;
1405
1406         err = i40e_hmc_get_object_va(hw, &context_bytes, I40E_HMC_LAN_RX, queue);
1407         if (err < 0)
1408                 return err;
1409
1410         return i40e_set_hmc_context(context_bytes,
1411                                     i40e_hmc_rxq_ce_info, (u8 *)s);
1412 }