drivers/net/ethernet/intel/ice/ice_nvm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2018, Intel Corporation. */
   3
   4 #include <linux/vmalloc.h>
   5
   6 #include "ice_common.h"
   7
   8 /**
   9  * ice_aq_read_nvm
  10  * @hw: pointer to the HW struct
  11  * @module_typeid: module pointer location in words from the NVM beginning
  12  * @offset: byte offset from the module beginning
  13  * @length: length of the section to be read (in bytes from the offset)
  14  * @data: command buffer (size [bytes] = length)
  15  * @last_command: tells if this is the last command in a series
  16  * @read_shadow_ram: tell if this is a shadow RAM read
  17  * @cd: pointer to command details structure or NULL
  18  *
  19  * Read the NVM using the admin queue commands (0x0701)
  20  */
  21 int ice_aq_read_nvm(struct ice_hw *hw, u16 module_typeid, u32 offset,
  22                     u16 length, void *data, bool last_command,
  23                     bool read_shadow_ram, struct ice_sq_cd *cd)
  24 {
  25         struct ice_aq_desc desc;
  26         struct ice_aqc_nvm *cmd;
  27
  28         cmd = &desc.params.nvm;
  29
  30         if (offset > ICE_AQC_NVM_MAX_OFFSET)
  31                 return -EINVAL;
  32
  33         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_nvm_read);
  34
  35         if (!read_shadow_ram && module_typeid == ICE_AQC_NVM_START_POINT)
  36                 cmd->cmd_flags |= ICE_AQC_NVM_FLASH_ONLY;
  37
  38         /* If this is the last command in a series, set the proper flag. */
  39         if (last_command)
  40                 cmd->cmd_flags |= ICE_AQC_NVM_LAST_CMD;
  41         cmd->module_typeid = cpu_to_le16(module_typeid);
  42         cmd->offset_low = cpu_to_le16(offset & 0xFFFF);
  43         cmd->offset_high = (offset >> 16) & 0xFF;
  44         cmd->length = cpu_to_le16(length);
  45
  46         return ice_aq_send_cmd(hw, &desc, data, length, cd);
  47 }
  48
  49 /**
  50  * ice_read_flat_nvm - Read portion of NVM by flat offset
  51  * @hw: pointer to the HW struct
  52  * @offset: offset from beginning of NVM
  53  * @length: (in) number of bytes to read; (out) number of bytes actually read
  54  * @data: buffer to return data in (sized to fit the specified length)
  55  * @read_shadow_ram: if true, read from shadow RAM instead of NVM
  56  *
  57  * Reads a portion of the NVM, as a flat memory space. This function correctly
  58  * breaks read requests across Shadow RAM sectors and ensures that no single
  59  * read request exceeds the maximum 4KB read for a single AdminQ command.
  60  *
  61  * Returns a status code on failure. Note that the data pointer may be
  62  * partially updated if some reads succeed before a failure.
  63  */
  64 int
  65 ice_read_flat_nvm(struct ice_hw *hw, u32 offset, u32 *length, u8 *data,
  66                   bool read_shadow_ram)
  67 {
  68         u32 inlen = *length;
  69         u32 bytes_read = 0;
  70         bool last_cmd;
  71         int status;
  72
  73         *length = 0;
  74
  75         /* Verify the length of the read if this is for the Shadow RAM */
  76         if (read_shadow_ram && ((offset + inlen) > (hw->flash.sr_words * 2u))) {
  77                 ice_debug(hw, ICE_DBG_NVM, "NVM error: requested offset is beyond Shadow RAM limit\n");
  78                 return -EINVAL;
  79         }
  80
  81         do {
  82                 u32 read_size, sector_offset;
  83
  84                 /* ice_aq_read_nvm cannot read more than 4KB at a time.
  85                  * Additionally, a read from the Shadow RAM may not cross over
  86                  * a sector boundary. Conveniently, the sector size is also
  87                  * 4KB.
  88                  */
  89                 sector_offset = offset % ICE_AQ_MAX_BUF_LEN;
  90                 read_size = min_t(u32, ICE_AQ_MAX_BUF_LEN - sector_offset,
  91                                   inlen - bytes_read);
  92
  93                 last_cmd = !(bytes_read + read_size < inlen);
  94
  95                 status = ice_aq_read_nvm(hw, ICE_AQC_NVM_START_POINT,
  96                                          offset, read_size,
  97                                          data + bytes_read, last_cmd,
  98                                          read_shadow_ram, NULL);
  99                 if (status)
 100                         break;
 101
 102                 bytes_read += read_size;
 103                 offset += read_size;
 104         } while (!last_cmd);
 105
 106         *length = bytes_read;
 107         return status;
 108 }
 109
 110 /**
 111  * ice_aq_update_nvm
 112  * @hw: pointer to the HW struct
 113  * @module_typeid: module pointer location in words from the NVM beginning
 114  * @offset: byte offset from the module beginning
 115  * @length: length of the section to be written (in bytes from the offset)
 116  * @data: command buffer (size [bytes] = length)
 117  * @last_command: tells if this is the last command in a series
 118  * @command_flags: command parameters
 119  * @cd: pointer to command details structure or NULL
 120  *
 121  * Update the NVM using the admin queue commands (0x0703)
 122  */
 123 int
 124 ice_aq_update_nvm(struct ice_hw *hw, u16 module_typeid, u32 offset,
 125                   u16 length, void *data, bool last_command, u8 command_flags,
 126                   struct ice_sq_cd *cd)
 127 {
 128         struct ice_aq_desc desc;
 129         struct ice_aqc_nvm *cmd;
 130
 131         cmd = &desc.params.nvm;
 132
 133         /* In offset the highest byte must be zeroed. */
 134         if (offset & 0xFF000000)
 135                 return -EINVAL;
 136
 137         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_nvm_write);
 138
 139         cmd->cmd_flags |= command_flags;
 140
 141         /* If this is the last command in a series, set the proper flag. */
 142         if (last_command)
 143                 cmd->cmd_flags |= ICE_AQC_NVM_LAST_CMD;
 144         cmd->module_typeid = cpu_to_le16(module_typeid);
 145         cmd->offset_low = cpu_to_le16(offset & 0xFFFF);
 146         cmd->offset_high = (offset >> 16) & 0xFF;
 147         cmd->length = cpu_to_le16(length);
 148
 149         desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
 150
 151         return ice_aq_send_cmd(hw, &desc, data, length, cd);
 152 }
 153
 154 /**
 155  * ice_aq_erase_nvm
 156  * @hw: pointer to the HW struct
 157  * @module_typeid: module pointer location in words from the NVM beginning
 158  * @cd: pointer to command details structure or NULL
 159  *
 160  * Erase the NVM sector using the admin queue commands (0x0702)
 161  */
 162 int ice_aq_erase_nvm(struct ice_hw *hw, u16 module_typeid, struct ice_sq_cd *cd)
 163 {
 164         struct ice_aq_desc desc;
 165         struct ice_aqc_nvm *cmd;
 166
 167         cmd = &desc.params.nvm;
 168
 169         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_nvm_erase);
 170
 171         cmd->module_typeid = cpu_to_le16(module_typeid);
 172         cmd->length = cpu_to_le16(ICE_AQC_NVM_ERASE_LEN);
 173         cmd->offset_low = 0;
 174         cmd->offset_high = 0;
 175
 176         return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
 177 }
 178
 179 /**
 180  * ice_read_sr_word_aq - Reads Shadow RAM via AQ
 181  * @hw: pointer to the HW structure
 182  * @offset: offset of the Shadow RAM word to read (0x000000 - 0x001FFF)
 183  * @data: word read from the Shadow RAM
 184  *
 185  * Reads one 16 bit word from the Shadow RAM using ice_read_flat_nvm.
 186  */
 187 static int ice_read_sr_word_aq(struct ice_hw *hw, u16 offset, u16 *data)
 188 {
 189         u32 bytes = sizeof(u16);
 190         __le16 data_local;
 191         int status;
 192
 193         /* Note that ice_read_flat_nvm takes into account the 4Kb AdminQ and
 194          * Shadow RAM sector restrictions necessary when reading from the NVM.
 195          */
 196         status = ice_read_flat_nvm(hw, offset * sizeof(u16), &bytes,
 197                                    (__force u8 *)&data_local, true);
 198         if (status)
 199                 return status;
 200
 201         *data = le16_to_cpu(data_local);
 202         return 0;
 203 }
 204
 205 /**
 206  * ice_acquire_nvm - Generic request for acquiring the NVM ownership
 207  * @hw: pointer to the HW structure
 208  * @access: NVM access type (read or write)
 209  *
 210  * This function will request NVM ownership.
 211  */
 212 int ice_acquire_nvm(struct ice_hw *hw, enum ice_aq_res_access_type access)
 213 {
 214         if (hw->flash.blank_nvm_mode)
 215                 return 0;
 216
 217         return ice_acquire_res(hw, ICE_NVM_RES_ID, access, ICE_NVM_TIMEOUT);
 218 }
 219
 220 /**
 221  * ice_release_nvm - Generic request for releasing the NVM ownership
 222  * @hw: pointer to the HW structure
 223  *
 224  * This function will release NVM ownership.
 225  */
 226 void ice_release_nvm(struct ice_hw *hw)
 227 {
 228         if (hw->flash.blank_nvm_mode)
 229                 return;
 230
 231         ice_release_res(hw, ICE_NVM_RES_ID);
 232 }
 233
 234 /**
 235  * ice_get_flash_bank_offset - Get offset into requested flash bank
 236  * @hw: pointer to the HW structure
 237  * @bank: whether to read from the active or inactive flash bank
 238  * @module: the module to read from
 239  *
 240  * Based on the module, lookup the module offset from the beginning of the
 241  * flash.
 242  *
 243  * Returns the flash offset. Note that a value of zero is invalid and must be
 244  * treated as an error.
 245  */
 246 static u32 ice_get_flash_bank_offset(struct ice_hw *hw, enum ice_bank_select bank, u16 module)
 247 {
 248         struct ice_bank_info *banks = &hw->flash.banks;
 249         enum ice_flash_bank active_bank;
 250         bool second_bank_active;
 251         u32 offset, size;
 252
 253         switch (module) {
 254         case ICE_SR_1ST_NVM_BANK_PTR:
 255                 offset = banks->nvm_ptr;
 256                 size = banks->nvm_size;
 257                 active_bank = banks->nvm_bank;
 258                 break;
 259         case ICE_SR_1ST_OROM_BANK_PTR:
 260                 offset = banks->orom_ptr;
 261                 size = banks->orom_size;
 262                 active_bank = banks->orom_bank;
 263                 break;
 264         case ICE_SR_NETLIST_BANK_PTR:
 265                 offset = banks->netlist_ptr;
 266                 size = banks->netlist_size;
 267                 active_bank = banks->netlist_bank;
 268                 break;
 269         default:
 270                 ice_debug(hw, ICE_DBG_NVM, "Unexpected value for flash module: 0x%04x\n", module);
 271                 return 0;
 272         }
 273
 274         switch (active_bank) {
 275         case ICE_1ST_FLASH_BANK:
 276                 second_bank_active = false;
 277                 break;
 278         case ICE_2ND_FLASH_BANK:
 279                 second_bank_active = true;
 280                 break;
 281         default:
 282                 ice_debug(hw, ICE_DBG_NVM, "Unexpected value for active flash bank: %u\n",
 283                           active_bank);
 284                 return 0;
 285         }
 286
 287         /* The second flash bank is stored immediately following the first
 288          * bank. Based on whether the 1st or 2nd bank is active, and whether
 289          * we want the active or inactive bank, calculate the desired offset.
 290          */
 291         switch (bank) {
 292         case ICE_ACTIVE_FLASH_BANK:
 293                 return offset + (second_bank_active ? size : 0);
 294         case ICE_INACTIVE_FLASH_BANK:
 295                 return offset + (second_bank_active ? 0 : size);
 296         }
 297
 298         ice_debug(hw, ICE_DBG_NVM, "Unexpected value for flash bank selection: %u\n", bank);
 299         return 0;
 300 }
 301
 302 /**
 303  * ice_read_flash_module - Read a word from one of the main NVM modules
 304  * @hw: pointer to the HW structure
 305  * @bank: which bank of the module to read
 306  * @module: the module to read
 307  * @offset: the offset into the module in bytes
 308  * @data: storage for the word read from the flash
 309  * @length: bytes of data to read
 310  *
 311  * Read data from the specified flash module. The bank parameter indicates
 312  * whether or not to read from the active bank or the inactive bank of that
 313  * module.
 314  *
 315  * The word will be read using flat NVM access, and relies on the
 316  * hw->flash.banks data being setup by ice_determine_active_flash_banks()
 317  * during initialization.
 318  */
 319 static int
 320 ice_read_flash_module(struct ice_hw *hw, enum ice_bank_select bank, u16 module,
 321                       u32 offset, u8 *data, u32 length)
 322 {
 323         int status;
 324         u32 start;
 325
 326         start = ice_get_flash_bank_offset(hw, bank, module);
 327         if (!start) {
 328                 ice_debug(hw, ICE_DBG_NVM, "Unable to calculate flash bank offset for module 0x%04x\n",
 329                           module);
 330                 return -EINVAL;
 331         }
 332
 333         status = ice_acquire_nvm(hw, ICE_RES_READ);
 334         if (status)
 335                 return status;
 336
 337         status = ice_read_flat_nvm(hw, start + offset, &length, data, false);
 338
 339         ice_release_nvm(hw);
 340
 341         return status;
 342 }
 343
 344 /**
 345  * ice_read_nvm_module - Read from the active main NVM module
 346  * @hw: pointer to the HW structure
 347  * @bank: whether to read from active or inactive NVM module
 348  * @offset: offset into the NVM module to read, in words
 349  * @data: storage for returned word value
 350  *
 351  * Read the specified word from the active NVM module. This includes the CSS
 352  * header at the start of the NVM module.
 353  */
 354 static int
 355 ice_read_nvm_module(struct ice_hw *hw, enum ice_bank_select bank, u32 offset, u16 *data)
 356 {
 357         __le16 data_local;
 358         int status;
 359
 360         status = ice_read_flash_module(hw, bank, ICE_SR_1ST_NVM_BANK_PTR, offset * sizeof(u16),
 361                                        (__force u8 *)&data_local, sizeof(u16));
 362         if (!status)
 363                 *data = le16_to_cpu(data_local);
 364
 365         return status;
 366 }
 367
 368 /**
 369  * ice_read_nvm_sr_copy - Read a word from the Shadow RAM copy in the NVM bank
 370  * @hw: pointer to the HW structure
 371  * @bank: whether to read from the active or inactive NVM module
 372  * @offset: offset into the Shadow RAM copy to read, in words
 373  * @data: storage for returned word value
 374  *
 375  * Read the specified word from the copy of the Shadow RAM found in the
 376  * specified NVM module.
 377  *
 378  * Note that the Shadow RAM copy is always located after the CSS header, and
 379  * is aligned to 64-byte (32-word) offsets.
 380  */
 381 static int
 382 ice_read_nvm_sr_copy(struct ice_hw *hw, enum ice_bank_select bank, u32 offset, u16 *data)
 383 {
 384         u32 sr_copy;
 385
 386         switch (bank) {
 387         case ICE_ACTIVE_FLASH_BANK:
 388                 sr_copy = roundup(hw->flash.banks.active_css_hdr_len, 32);
 389                 break;
 390         case ICE_INACTIVE_FLASH_BANK:
 391                 sr_copy = roundup(hw->flash.banks.inactive_css_hdr_len, 32);
 392                 break;
 393         }
 394
 395         return ice_read_nvm_module(hw, bank, sr_copy + offset, data);
 396 }
 397
 398 /**
 399  * ice_read_netlist_module - Read data from the netlist module area
 400  * @hw: pointer to the HW structure
 401  * @bank: whether to read from the active or inactive module
 402  * @offset: offset into the netlist to read from
 403  * @data: storage for returned word value
 404  *
 405  * Read a word from the specified netlist bank.
 406  */
 407 static int
 408 ice_read_netlist_module(struct ice_hw *hw, enum ice_bank_select bank, u32 offset, u16 *data)
 409 {
 410         __le16 data_local;
 411         int status;
 412
 413         status = ice_read_flash_module(hw, bank, ICE_SR_NETLIST_BANK_PTR, offset * sizeof(u16),
 414                                        (__force u8 *)&data_local, sizeof(u16));
 415         if (!status)
 416                 *data = le16_to_cpu(data_local);
 417
 418         return status;
 419 }
 420
 421 /**
 422  * ice_read_sr_word - Reads Shadow RAM word and acquire NVM if necessary
 423  * @hw: pointer to the HW structure
 424  * @offset: offset of the Shadow RAM word to read (0x000000 - 0x001FFF)
 425  * @data: word read from the Shadow RAM
 426  *
 427  * Reads one 16 bit word from the Shadow RAM using the ice_read_sr_word_aq.
 428  */
 429 int ice_read_sr_word(struct ice_hw *hw, u16 offset, u16 *data)
 430 {
 431         int status;
 432
 433         status = ice_acquire_nvm(hw, ICE_RES_READ);
 434         if (!status) {
 435                 status = ice_read_sr_word_aq(hw, offset, data);
 436                 ice_release_nvm(hw);
 437         }
 438
 439         return status;
 440 }
 441
 442 /**
 443  * ice_get_pfa_module_tlv - Reads sub module TLV from NVM PFA
 444  * @hw: pointer to hardware structure
 445  * @module_tlv: pointer to module TLV to return
 446  * @module_tlv_len: pointer to module TLV length to return
 447  * @module_type: module type requested
 448  *
 449  * Finds the requested sub module TLV type from the Preserved Field
 450  * Area (PFA) and returns the TLV pointer and length. The caller can
 451  * use these to read the variable length TLV value.
 452  */
 453 int
 454 ice_get_pfa_module_tlv(struct ice_hw *hw, u16 *module_tlv, u16 *module_tlv_len,
 455                        u16 module_type)
 456 {
 457         u16 pfa_len, pfa_ptr, next_tlv, max_tlv;
 458         int status;
 459
 460         status = ice_read_sr_word(hw, ICE_SR_PFA_PTR, &pfa_ptr);
 461         if (status) {
 462                 ice_debug(hw, ICE_DBG_INIT, "Preserved Field Array pointer.\n");
 463                 return status;
 464         }
 465         status = ice_read_sr_word(hw, pfa_ptr, &pfa_len);
 466         if (status) {
 467                 ice_debug(hw, ICE_DBG_INIT, "Failed to read PFA length.\n");
 468                 return status;
 469         }
 470
 471         /* The Preserved Fields Area contains a sequence of Type-Length-Value
 472          * structures which define its contents. The PFA length includes all
 473          * of the TLVs, plus the initial length word itself, *and* one final
 474          * word at the end after all of the TLVs.
 475          */
 476         if (check_add_overflow(pfa_ptr, pfa_len - 1, &max_tlv)) {
 477                 dev_warn(ice_hw_to_dev(hw), "PFA starts at offset %u. PFA length of %u caused 16-bit arithmetic overflow.\n",
 478                          pfa_ptr, pfa_len);
 479                 return -EINVAL;
 480         }
 481
 482         /* Starting with first TLV after PFA length, iterate through the list
 483          * of TLVs to find the requested one.
 484          */
 485         next_tlv = pfa_ptr + 1;
 486         while (next_tlv < max_tlv) {
 487                 u16 tlv_sub_module_type;
 488                 u16 tlv_len;
 489
 490                 /* Read TLV type */
 491                 status = ice_read_sr_word(hw, next_tlv, &tlv_sub_module_type);
 492                 if (status) {
 493                         ice_debug(hw, ICE_DBG_INIT, "Failed to read TLV type.\n");
 494                         break;
 495                 }
 496                 /* Read TLV length */
 497                 status = ice_read_sr_word(hw, next_tlv + 1, &tlv_len);
 498                 if (status) {
 499                         ice_debug(hw, ICE_DBG_INIT, "Failed to read TLV length.\n");
 500                         break;
 501                 }
 502                 if (tlv_sub_module_type == module_type) {
 503                         if (tlv_len) {
 504                                 *module_tlv = next_tlv;
 505                                 *module_tlv_len = tlv_len;
 506                                 return 0;
 507                         }
 508                         return -EINVAL;
 509                 }
 510
 511                 if (check_add_overflow(next_tlv, 2, &next_tlv) ||
 512                     check_add_overflow(next_tlv, tlv_len, &next_tlv)) {
 513                         dev_warn(ice_hw_to_dev(hw), "TLV of type %u and length 0x%04x caused 16-bit arithmetic overflow. The PFA starts at 0x%04x and has length of 0x%04x\n",
 514                                  tlv_sub_module_type, tlv_len, pfa_ptr, pfa_len);
 515                         return -EINVAL;
 516                 }
 517         }
 518         /* Module does not exist */
 519         return -ENOENT;
 520 }
 521
 522 /**
 523  * ice_read_pba_string - Reads part number string from NVM
 524  * @hw: pointer to hardware structure
 525  * @pba_num: stores the part number string from the NVM
 526  * @pba_num_size: part number string buffer length
 527  *
 528  * Reads the part number string from the NVM.
 529  */
 530 int ice_read_pba_string(struct ice_hw *hw, u8 *pba_num, u32 pba_num_size)
 531 {
 532         u16 pba_tlv, pba_tlv_len;
 533         u16 pba_word, pba_size;
 534         int status;
 535         u16 i;
 536
 537         status = ice_get_pfa_module_tlv(hw, &pba_tlv, &pba_tlv_len,
 538                                         ICE_SR_PBA_BLOCK_PTR);
 539         if (status) {
 540                 ice_debug(hw, ICE_DBG_INIT, "Failed to read PBA Block TLV.\n");
 541                 return status;
 542         }
 543
 544         /* pba_size is the next word */
 545         status = ice_read_sr_word(hw, (pba_tlv + 2), &pba_size);
 546         if (status) {
 547                 ice_debug(hw, ICE_DBG_INIT, "Failed to read PBA Section size.\n");
 548                 return status;
 549         }
 550
 551         if (pba_tlv_len < pba_size) {
 552                 ice_debug(hw, ICE_DBG_INIT, "Invalid PBA Block TLV size.\n");
 553                 return -EINVAL;
 554         }
 555
 556         /* Subtract one to get PBA word count (PBA Size word is included in
 557          * total size)
 558          */
 559         pba_size--;
 560         if (pba_num_size < (((u32)pba_size * 2) + 1)) {
 561                 ice_debug(hw, ICE_DBG_INIT, "Buffer too small for PBA data.\n");
 562                 return -EINVAL;
 563         }
 564
 565         for (i = 0; i < pba_size; i++) {
 566                 status = ice_read_sr_word(hw, (pba_tlv + 2 + 1) + i, &pba_word);
 567                 if (status) {
 568                         ice_debug(hw, ICE_DBG_INIT, "Failed to read PBA Block word %d.\n", i);
 569                         return status;
 570                 }
 571
 572                 pba_num[(i * 2)] = (pba_word >> 8) & 0xFF;
 573                 pba_num[(i * 2) + 1] = pba_word & 0xFF;
 574         }
 575         pba_num[(pba_size * 2)] = '\0';
 576
 577         return status;
 578 }
 579
 580 /**
 581  * ice_get_nvm_ver_info - Read NVM version information
 582  * @hw: pointer to the HW struct
 583  * @bank: whether to read from the active or inactive flash bank
 584  * @nvm: pointer to NVM info structure
 585  *
 586  * Read the NVM EETRACK ID and map version of the main NVM image bank, filling
 587  * in the NVM info structure.
 588  */
 589 static int
 590 ice_get_nvm_ver_info(struct ice_hw *hw, enum ice_bank_select bank, struct ice_nvm_info *nvm)
 591 {
 592         u16 eetrack_lo, eetrack_hi, ver;
 593         int status;
 594
 595         status = ice_read_nvm_sr_copy(hw, bank, ICE_SR_NVM_DEV_STARTER_VER, &ver);
 596         if (status) {
 597                 ice_debug(hw, ICE_DBG_NVM, "Failed to read DEV starter version.\n");
 598                 return status;
 599         }
 600
 601         nvm->major = FIELD_GET(ICE_NVM_VER_HI_MASK, ver);
 602         nvm->minor = FIELD_GET(ICE_NVM_VER_LO_MASK, ver);
 603
 604         status = ice_read_nvm_sr_copy(hw, bank, ICE_SR_NVM_EETRACK_LO, &eetrack_lo);
 605         if (status) {
 606                 ice_debug(hw, ICE_DBG_NVM, "Failed to read EETRACK lo.\n");
 607                 return status;
 608         }
 609         status = ice_read_nvm_sr_copy(hw, bank, ICE_SR_NVM_EETRACK_HI, &eetrack_hi);
 610         if (status) {
 611                 ice_debug(hw, ICE_DBG_NVM, "Failed to read EETRACK hi.\n");
 612                 return status;
 613         }
 614
 615         nvm->eetrack = (eetrack_hi << 16) | eetrack_lo;
 616
 617         return 0;
 618 }
 619
 620 /**
 621  * ice_get_inactive_nvm_ver - Read Option ROM version from the inactive bank
 622  * @hw: pointer to the HW structure
 623  * @nvm: storage for Option ROM version information
 624  *
 625  * Reads the NVM EETRACK ID, Map version, and security revision of the
 626  * inactive NVM bank. Used to access version data for a pending update that
 627  * has not yet been activated.
 628  */
 629 int ice_get_inactive_nvm_ver(struct ice_hw *hw, struct ice_nvm_info *nvm)
 630 {
 631         return ice_get_nvm_ver_info(hw, ICE_INACTIVE_FLASH_BANK, nvm);
 632 }
 633
 634 /**
 635  * ice_get_orom_civd_data - Get the combo version information from Option ROM
 636  * @hw: pointer to the HW struct
 637  * @bank: whether to read from the active or inactive flash module
 638  * @civd: storage for the Option ROM CIVD data.
 639  *
 640  * Searches through the Option ROM flash contents to locate the CIVD data for
 641  * the image.
 642  */
 643 static int
 644 ice_get_orom_civd_data(struct ice_hw *hw, enum ice_bank_select bank,
 645                        struct ice_orom_civd_info *civd)
 646 {
 647         u8 *orom_data;
 648         int status;
 649         u32 offset;
 650
 651         /* The CIVD section is located in the Option ROM aligned to 512 bytes.
 652          * The first 4 bytes must contain the ASCII characters "$CIV".
 653          * A simple modulo 256 sum of all of the bytes of the structure must
 654          * equal 0.
 655          *
 656          * The exact location is unknown and varies between images but is
 657          * usually somewhere in the middle of the bank. We need to scan the
 658          * Option ROM bank to locate it.
 659          *
 660          * It's significantly faster to read the entire Option ROM up front
 661          * using the maximum page size, than to read each possible location
 662          * with a separate firmware command.
 663          */
 664         orom_data = vzalloc(hw->flash.banks.orom_size);
 665         if (!orom_data)
 666                 return -ENOMEM;
 667
 668         status = ice_read_flash_module(hw, bank, ICE_SR_1ST_OROM_BANK_PTR, 0,
 669                                        orom_data, hw->flash.banks.orom_size);
 670         if (status) {
 671                 vfree(orom_data);
 672                 ice_debug(hw, ICE_DBG_NVM, "Unable to read Option ROM data\n");
 673                 return status;
 674         }
 675
 676         /* Scan the memory buffer to locate the CIVD data section */
 677         for (offset = 0; (offset + 512) <= hw->flash.banks.orom_size; offset += 512) {
 678                 struct ice_orom_civd_info *tmp;
 679                 u8 sum = 0, i;
 680
 681                 tmp = (struct ice_orom_civd_info *)&orom_data[offset];
 682
 683                 /* Skip forward until we find a matching signature */
 684                 if (memcmp("$CIV", tmp->signature, sizeof(tmp->signature)) != 0)
 685                         continue;
 686
 687                 ice_debug(hw, ICE_DBG_NVM, "Found CIVD section at offset %u\n",
 688                           offset);
 689
 690                 /* Verify that the simple checksum is zero */
 691                 for (i = 0; i < sizeof(*tmp); i++)
 692                         sum += ((u8 *)tmp)[i];
 693
 694                 if (sum) {
 695                         ice_debug(hw, ICE_DBG_NVM, "Found CIVD data with invalid checksum of %u\n",
 696                                   sum);
 697                         goto err_invalid_checksum;
 698                 }
 699
 700                 *civd = *tmp;
 701                 vfree(orom_data);
 702                 return 0;
 703         }
 704
 705         ice_debug(hw, ICE_DBG_NVM, "Unable to locate CIVD data within the Option ROM\n");
 706
 707 err_invalid_checksum:
 708         vfree(orom_data);
 709         return -EIO;
 710 }
 711
 712 /**
 713  * ice_get_orom_ver_info - Read Option ROM version information
 714  * @hw: pointer to the HW struct
 715  * @bank: whether to read from the active or inactive flash module
 716  * @orom: pointer to Option ROM info structure
 717  *
 718  * Read Option ROM version and security revision from the Option ROM flash
 719  * section.
 720  */
 721 static int
 722 ice_get_orom_ver_info(struct ice_hw *hw, enum ice_bank_select bank, struct ice_orom_info *orom)
 723 {
 724         struct ice_orom_civd_info civd;
 725         u32 combo_ver;
 726         int status;
 727
 728         status = ice_get_orom_civd_data(hw, bank, &civd);
 729         if (status) {
 730                 ice_debug(hw, ICE_DBG_NVM, "Failed to locate valid Option ROM CIVD data\n");
 731                 return status;
 732         }
 733
 734         combo_ver = le32_to_cpu(civd.combo_ver);
 735
 736         orom->major = FIELD_GET(ICE_OROM_VER_MASK, combo_ver);
 737         orom->patch = FIELD_GET(ICE_OROM_VER_PATCH_MASK, combo_ver);
 738         orom->build = FIELD_GET(ICE_OROM_VER_BUILD_MASK, combo_ver);
 739
 740         return 0;
 741 }
 742
 743 /**
 744  * ice_get_inactive_orom_ver - Read Option ROM version from the inactive bank
 745  * @hw: pointer to the HW structure
 746  * @orom: storage for Option ROM version information
 747  *
 748  * Reads the Option ROM version and security revision data for the inactive
 749  * section of flash. Used to access version data for a pending update that has
 750  * not yet been activated.
 751  */
 752 int ice_get_inactive_orom_ver(struct ice_hw *hw, struct ice_orom_info *orom)
 753 {
 754         return ice_get_orom_ver_info(hw, ICE_INACTIVE_FLASH_BANK, orom);
 755 }
 756
 757 /**
 758  * ice_get_netlist_info
 759  * @hw: pointer to the HW struct
 760  * @bank: whether to read from the active or inactive flash bank
 761  * @netlist: pointer to netlist version info structure
 762  *
 763  * Get the netlist version information from the requested bank. Reads the Link
 764  * Topology section to find the Netlist ID block and extract the relevant
 765  * information into the netlist version structure.
 766  */
 767 static int
 768 ice_get_netlist_info(struct ice_hw *hw, enum ice_bank_select bank,
 769                      struct ice_netlist_info *netlist)
 770 {
 771         u16 module_id, length, node_count, i;
 772         u16 *id_blk;
 773         int status;
 774
 775         status = ice_read_netlist_module(hw, bank, ICE_NETLIST_TYPE_OFFSET, &module_id);
 776         if (status)
 777                 return status;
 778
 779         if (module_id != ICE_NETLIST_LINK_TOPO_MOD_ID) {
 780                 ice_debug(hw, ICE_DBG_NVM, "Expected netlist module_id ID of 0x%04x, but got 0x%04x\n",
 781                           ICE_NETLIST_LINK_TOPO_MOD_ID, module_id);
 782                 return -EIO;
 783         }
 784
 785         status = ice_read_netlist_module(hw, bank, ICE_LINK_TOPO_MODULE_LEN, &length);
 786         if (status)
 787                 return status;
 788
 789         /* sanity check that we have at least enough words to store the netlist ID block */
 790         if (length < ICE_NETLIST_ID_BLK_SIZE) {
 791                 ice_debug(hw, ICE_DBG_NVM, "Netlist Link Topology module too small. Expected at least %u words, but got %u words.\n",
 792                           ICE_NETLIST_ID_BLK_SIZE, length);
 793                 return -EIO;
 794         }
 795
 796         status = ice_read_netlist_module(hw, bank, ICE_LINK_TOPO_NODE_COUNT, &node_count);
 797         if (status)
 798                 return status;
 799         node_count &= ICE_LINK_TOPO_NODE_COUNT_M;
 800
 801         id_blk = kcalloc(ICE_NETLIST_ID_BLK_SIZE, sizeof(*id_blk), GFP_KERNEL);
 802         if (!id_blk)
 803                 return -ENOMEM;
 804
 805         /* Read out the entire Netlist ID Block at once. */
 806         status = ice_read_flash_module(hw, bank, ICE_SR_NETLIST_BANK_PTR,
 807                                        ICE_NETLIST_ID_BLK_OFFSET(node_count) * sizeof(u16),
 808                                        (u8 *)id_blk, ICE_NETLIST_ID_BLK_SIZE * sizeof(u16));
 809         if (status)
 810                 goto exit_error;
 811
 812         for (i = 0; i < ICE_NETLIST_ID_BLK_SIZE; i++)
 813                 id_blk[i] = le16_to_cpu(((__force __le16 *)id_blk)[i]);
 814
 815         netlist->major = id_blk[ICE_NETLIST_ID_BLK_MAJOR_VER_HIGH] << 16 |
 816                          id_blk[ICE_NETLIST_ID_BLK_MAJOR_VER_LOW];
 817         netlist->minor = id_blk[ICE_NETLIST_ID_BLK_MINOR_VER_HIGH] << 16 |
 818                          id_blk[ICE_NETLIST_ID_BLK_MINOR_VER_LOW];
 819         netlist->type = id_blk[ICE_NETLIST_ID_BLK_TYPE_HIGH] << 16 |
 820                         id_blk[ICE_NETLIST_ID_BLK_TYPE_LOW];
 821         netlist->rev = id_blk[ICE_NETLIST_ID_BLK_REV_HIGH] << 16 |
 822                        id_blk[ICE_NETLIST_ID_BLK_REV_LOW];
 823         netlist->cust_ver = id_blk[ICE_NETLIST_ID_BLK_CUST_VER];
 824         /* Read the left most 4 bytes of SHA */
 825         netlist->hash = id_blk[ICE_NETLIST_ID_BLK_SHA_HASH_WORD(15)] << 16 |
 826                         id_blk[ICE_NETLIST_ID_BLK_SHA_HASH_WORD(14)];
 827
 828 exit_error:
 829         kfree(id_blk);
 830
 831         return status;
 832 }
 833
 834 /**
 835  * ice_get_inactive_netlist_ver
 836  * @hw: pointer to the HW struct
 837  * @netlist: pointer to netlist version info structure
 838  *
 839  * Read the netlist version data from the inactive netlist bank. Used to
 840  * extract version data of a pending flash update in order to display the
 841  * version data.
 842  */
 843 int ice_get_inactive_netlist_ver(struct ice_hw *hw, struct ice_netlist_info *netlist)
 844 {
 845         return ice_get_netlist_info(hw, ICE_INACTIVE_FLASH_BANK, netlist);
 846 }
 847
 848 /**
 849  * ice_discover_flash_size - Discover the available flash size.
 850  * @hw: pointer to the HW struct
 851  *
 852  * The device flash could be up to 16MB in size. However, it is possible that
 853  * the actual size is smaller. Use bisection to determine the accessible size
 854  * of flash memory.
 855  */
 856 static int ice_discover_flash_size(struct ice_hw *hw)
 857 {
 858         u32 min_size = 0, max_size = ICE_AQC_NVM_MAX_OFFSET + 1;
 859         int status;
 860
 861         status = ice_acquire_nvm(hw, ICE_RES_READ);
 862         if (status)
 863                 return status;
 864
 865         while ((max_size - min_size) > 1) {
 866                 u32 offset = (max_size + min_size) / 2;
 867                 u32 len = 1;
 868                 u8 data;
 869
 870                 status = ice_read_flat_nvm(hw, offset, &len, &data, false);
 871                 if (status == -EIO &&
 872                     hw->adminq.sq_last_status == ICE_AQ_RC_EINVAL) {
 873                         ice_debug(hw, ICE_DBG_NVM, "%s: New upper bound of %u bytes\n",
 874                                   __func__, offset);
 875                         status = 0;
 876                         max_size = offset;
 877                 } else if (!status) {
 878                         ice_debug(hw, ICE_DBG_NVM, "%s: New lower bound of %u bytes\n",
 879                                   __func__, offset);
 880                         min_size = offset;
 881                 } else {
 882                         /* an unexpected error occurred */
 883                         goto err_read_flat_nvm;
 884                 }
 885         }
 886
 887         ice_debug(hw, ICE_DBG_NVM, "Predicted flash size is %u bytes\n", max_size);
 888
 889         hw->flash.flash_size = max_size;
 890
 891 err_read_flat_nvm:
 892         ice_release_nvm(hw);
 893
 894         return status;
 895 }
 896
 897 /**
 898  * ice_read_sr_pointer - Read the value of a Shadow RAM pointer word
 899  * @hw: pointer to the HW structure
 900  * @offset: the word offset of the Shadow RAM word to read
 901  * @pointer: pointer value read from Shadow RAM
 902  *
 903  * Read the given Shadow RAM word, and convert it to a pointer value specified
 904  * in bytes. This function assumes the specified offset is a valid pointer
 905  * word.
 906  *
 907  * Each pointer word specifies whether it is stored in word size or 4KB
 908  * sector size by using the highest bit. The reported pointer value will be in
 909  * bytes, intended for flat NVM reads.
 910  */
 911 static int ice_read_sr_pointer(struct ice_hw *hw, u16 offset, u32 *pointer)
 912 {
 913         int status;
 914         u16 value;
 915
 916         status = ice_read_sr_word(hw, offset, &value);
 917         if (status)
 918                 return status;
 919
 920         /* Determine if the pointer is in 4KB or word units */
 921         if (value & ICE_SR_NVM_PTR_4KB_UNITS)
 922                 *pointer = (value & ~ICE_SR_NVM_PTR_4KB_UNITS) * 4 * 1024;
 923         else
 924                 *pointer = value * 2;
 925
 926         return 0;
 927 }
 928
 929 /**
 930  * ice_read_sr_area_size - Read an area size from a Shadow RAM word
 931  * @hw: pointer to the HW structure
 932  * @offset: the word offset of the Shadow RAM to read
 933  * @size: size value read from the Shadow RAM
 934  *
 935  * Read the given Shadow RAM word, and convert it to an area size value
 936  * specified in bytes. This function assumes the specified offset is a valid
 937  * area size word.
 938  *
 939  * Each area size word is specified in 4KB sector units. This function reports
 940  * the size in bytes, intended for flat NVM reads.
 941  */
 942 static int ice_read_sr_area_size(struct ice_hw *hw, u16 offset, u32 *size)
 943 {
 944         int status;
 945         u16 value;
 946
 947         status = ice_read_sr_word(hw, offset, &value);
 948         if (status)
 949                 return status;
 950
 951         /* Area sizes are always specified in 4KB units */
 952         *size = value * 4 * 1024;
 953
 954         return 0;
 955 }
 956
 957 /**
 958  * ice_determine_active_flash_banks - Discover active bank for each module
 959  * @hw: pointer to the HW struct
 960  *
 961  * Read the Shadow RAM control word and determine which banks are active for
 962  * the NVM, OROM, and Netlist modules. Also read and calculate the associated
 963  * pointer and size. These values are then cached into the ice_flash_info
 964  * structure for later use in order to calculate the correct offset to read
 965  * from the active module.
 966  */
 967 static int ice_determine_active_flash_banks(struct ice_hw *hw)
 968 {
 969         struct ice_bank_info *banks = &hw->flash.banks;
 970         u16 ctrl_word;
 971         int status;
 972
 973         status = ice_read_sr_word(hw, ICE_SR_NVM_CTRL_WORD, &ctrl_word);
 974         if (status) {
 975                 ice_debug(hw, ICE_DBG_NVM, "Failed to read the Shadow RAM control word\n");
 976                 return status;
 977         }
 978
 979         /* Check that the control word indicates validity */
 980         if (FIELD_GET(ICE_SR_CTRL_WORD_1_M, ctrl_word) !=
 981             ICE_SR_CTRL_WORD_VALID) {
 982                 ice_debug(hw, ICE_DBG_NVM, "Shadow RAM control word is invalid\n");
 983                 return -EIO;
 984         }
 985
 986         if (!(ctrl_word & ICE_SR_CTRL_WORD_NVM_BANK))
 987                 banks->nvm_bank = ICE_1ST_FLASH_BANK;
 988         else
 989                 banks->nvm_bank = ICE_2ND_FLASH_BANK;
 990
 991         if (!(ctrl_word & ICE_SR_CTRL_WORD_OROM_BANK))
 992                 banks->orom_bank = ICE_1ST_FLASH_BANK;
 993         else
 994                 banks->orom_bank = ICE_2ND_FLASH_BANK;
 995
 996         if (!(ctrl_word & ICE_SR_CTRL_WORD_NETLIST_BANK))
 997                 banks->netlist_bank = ICE_1ST_FLASH_BANK;
 998         else
 999                 banks->netlist_bank = ICE_2ND_FLASH_BANK;
1000
1001         status = ice_read_sr_pointer(hw, ICE_SR_1ST_NVM_BANK_PTR, &banks->nvm_ptr);
1002         if (status) {
1003                 ice_debug(hw, ICE_DBG_NVM, "Failed to read NVM bank pointer\n");
1004                 return status;
1005         }
1006
1007         status = ice_read_sr_area_size(hw, ICE_SR_NVM_BANK_SIZE, &banks->nvm_size);
1008         if (status) {
1009                 ice_debug(hw, ICE_DBG_NVM, "Failed to read NVM bank area size\n");
1010                 return status;
1011         }
1012
1013         status = ice_read_sr_pointer(hw, ICE_SR_1ST_OROM_BANK_PTR, &banks->orom_ptr);
1014         if (status) {
1015                 ice_debug(hw, ICE_DBG_NVM, "Failed to read OROM bank pointer\n");
1016                 return status;
1017         }
1018
1019         status = ice_read_sr_area_size(hw, ICE_SR_OROM_BANK_SIZE, &banks->orom_size);
1020         if (status) {
1021                 ice_debug(hw, ICE_DBG_NVM, "Failed to read OROM bank area size\n");
1022                 return status;
1023         }
1024
1025         status = ice_read_sr_pointer(hw, ICE_SR_NETLIST_BANK_PTR, &banks->netlist_ptr);
1026         if (status) {
1027                 ice_debug(hw, ICE_DBG_NVM, "Failed to read Netlist bank pointer\n");
1028                 return status;
1029         }
1030
1031         status = ice_read_sr_area_size(hw, ICE_SR_NETLIST_BANK_SIZE, &banks->netlist_size);
1032         if (status) {
1033                 ice_debug(hw, ICE_DBG_NVM, "Failed to read Netlist bank area size\n");
1034                 return status;
1035         }
1036
1037         return 0;
1038 }
1039
1040 /**
1041  * ice_get_nvm_css_hdr_len - Read the CSS header length from the NVM CSS header
1042  * @hw: pointer to the HW struct
1043  * @bank: whether to read from the active or inactive flash bank
1044  * @hdr_len: storage for header length in words
1045  *
1046  * Read the CSS header length from the NVM CSS header and add the Authentication
1047  * header size, and then convert to words.
1048  *
1049  * Return: zero on success, or a negative error code on failure.
1050  */
1051 static int
1052 ice_get_nvm_css_hdr_len(struct ice_hw *hw, enum ice_bank_select bank,
1053                         u32 *hdr_len)
1054 {
1055         u16 hdr_len_l, hdr_len_h;
1056         u32 hdr_len_dword;
1057         int status;
1058
1059         status = ice_read_nvm_module(hw, bank, ICE_NVM_CSS_HDR_LEN_L,
1060                                      &hdr_len_l);
1061         if (status)
1062                 return status;
1063
1064         status = ice_read_nvm_module(hw, bank, ICE_NVM_CSS_HDR_LEN_H,
1065                                      &hdr_len_h);
1066         if (status)
1067                 return status;
1068
1069         /* CSS header length is in DWORD, so convert to words and add
1070          * authentication header size
1071          */
1072         hdr_len_dword = hdr_len_h << 16 | hdr_len_l;
1073         *hdr_len = (hdr_len_dword * 2) + ICE_NVM_AUTH_HEADER_LEN;
1074
1075         return 0;
1076 }
1077
1078 /**
1079  * ice_determine_css_hdr_len - Discover CSS header length for the device
1080  * @hw: pointer to the HW struct
1081  *
1082  * Determine the size of the CSS header at the start of the NVM module. This
1083  * is useful for locating the Shadow RAM copy in the NVM, as the Shadow RAM is
1084  * always located just after the CSS header.
1085  *
1086  * Return: zero on success, or a negative error code on failure.
1087  */
1088 static int ice_determine_css_hdr_len(struct ice_hw *hw)
1089 {
1090         struct ice_bank_info *banks = &hw->flash.banks;
1091         int status;
1092
1093         status = ice_get_nvm_css_hdr_len(hw, ICE_ACTIVE_FLASH_BANK,
1094                                          &banks->active_css_hdr_len);
1095         if (status)
1096                 return status;
1097
1098         status = ice_get_nvm_css_hdr_len(hw, ICE_INACTIVE_FLASH_BANK,
1099                                          &banks->inactive_css_hdr_len);
1100         if (status)
1101                 return status;
1102
1103         return 0;
1104 }
1105
1106 /**
1107  * ice_init_nvm - initializes NVM setting
1108  * @hw: pointer to the HW struct
1109  *
1110  * This function reads and populates NVM settings such as Shadow RAM size,
1111  * max_timeout, and blank_nvm_mode
1112  */
1113 int ice_init_nvm(struct ice_hw *hw)
1114 {
1115         struct ice_flash_info *flash = &hw->flash;
1116         u32 fla, gens_stat;
1117         u8 sr_size;
1118         int status;
1119
1120         /* The SR size is stored regardless of the NVM programming mode
1121          * as the blank mode may be used in the factory line.
1122          */
1123         gens_stat = rd32(hw, GLNVM_GENS);
1124         sr_size = FIELD_GET(GLNVM_GENS_SR_SIZE_M, gens_stat);
1125
1126         /* Switching to words (sr_size contains power of 2) */
1127         flash->sr_words = BIT(sr_size) * ICE_SR_WORDS_IN_1KB;
1128
1129         /* Check if we are in the normal or blank NVM programming mode */
1130         fla = rd32(hw, GLNVM_FLA);
1131         if (fla & GLNVM_FLA_LOCKED_M) { /* Normal programming mode */
1132                 flash->blank_nvm_mode = false;
1133         } else {
1134                 /* Blank programming mode */
1135                 flash->blank_nvm_mode = true;
1136                 ice_debug(hw, ICE_DBG_NVM, "NVM init error: unsupported blank mode.\n");
1137                 return -EIO;
1138         }
1139
1140         status = ice_discover_flash_size(hw);
1141         if (status) {
1142                 ice_debug(hw, ICE_DBG_NVM, "NVM init error: failed to discover flash size.\n");
1143                 return status;
1144         }
1145
1146         status = ice_determine_active_flash_banks(hw);
1147         if (status) {
1148                 ice_debug(hw, ICE_DBG_NVM, "Failed to determine active flash banks.\n");
1149                 return status;
1150         }
1151
1152         status = ice_determine_css_hdr_len(hw);
1153         if (status) {
1154                 ice_debug(hw, ICE_DBG_NVM, "Failed to determine Shadow RAM copy offsets.\n");
1155                 return status;
1156         }
1157
1158         status = ice_get_nvm_ver_info(hw, ICE_ACTIVE_FLASH_BANK, &flash->nvm);
1159         if (status) {
1160                 ice_debug(hw, ICE_DBG_INIT, "Failed to read NVM info.\n");
1161                 return status;
1162         }
1163
1164         status = ice_get_orom_ver_info(hw, ICE_ACTIVE_FLASH_BANK, &flash->orom);
1165         if (status)
1166                 ice_debug(hw, ICE_DBG_INIT, "Failed to read Option ROM info.\n");
1167
1168         /* read the netlist version information */
1169         status = ice_get_netlist_info(hw, ICE_ACTIVE_FLASH_BANK, &flash->netlist);
1170         if (status)
1171                 ice_debug(hw, ICE_DBG_INIT, "Failed to read netlist info.\n");
1172
1173         return 0;
1174 }
1175
1176 /**
1177  * ice_nvm_validate_checksum
1178  * @hw: pointer to the HW struct
1179  *
1180  * Verify NVM PFA checksum validity (0x0706)
1181  */
1182 int ice_nvm_validate_checksum(struct ice_hw *hw)
1183 {
1184         struct ice_aqc_nvm_checksum *cmd;
1185         struct ice_aq_desc desc;
1186         int status;
1187
1188         status = ice_acquire_nvm(hw, ICE_RES_READ);
1189         if (status)
1190                 return status;
1191
1192         cmd = &desc.params.nvm_checksum;
1193
1194         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_nvm_checksum);
1195         cmd->flags = ICE_AQC_NVM_CHECKSUM_VERIFY;
1196
1197         status = ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
1198         ice_release_nvm(hw);
1199
1200         if (!status)
1201                 if (le16_to_cpu(cmd->checksum) != ICE_AQC_NVM_CHECKSUM_CORRECT)
1202                         status = -EIO;
1203
1204         return status;
1205 }
1206
1207 /**
1208  * ice_nvm_write_activate
1209  * @hw: pointer to the HW struct
1210  * @cmd_flags: flags for write activate command
1211  * @response_flags: response indicators from firmware
1212  *
1213  * Update the control word with the required banks' validity bits
1214  * and dumps the Shadow RAM to flash (0x0707)
1215  *
1216  * cmd_flags controls which banks to activate, the preservation level to use
1217  * when activating the NVM bank, and whether an EMP reset is required for
1218  * activation.
1219  *
1220  * Note that the 16bit cmd_flags value is split between two separate 1 byte
1221  * flag values in the descriptor.
1222  *
1223  * On successful return of the firmware command, the response_flags variable
1224  * is updated with the flags reported by firmware indicating certain status,
1225  * such as whether EMP reset is enabled.
1226  */
1227 int ice_nvm_write_activate(struct ice_hw *hw, u16 cmd_flags, u8 *response_flags)
1228 {
1229         struct ice_aqc_nvm *cmd;
1230         struct ice_aq_desc desc;
1231         int err;
1232
1233         cmd = &desc.params.nvm;
1234         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_nvm_write_activate);
1235
1236         cmd->cmd_flags = (u8)(cmd_flags & 0xFF);
1237         cmd->offset_high = (u8)((cmd_flags >> 8) & 0xFF);
1238
1239         err = ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
1240         if (!err && response_flags)
1241                 *response_flags = cmd->cmd_flags;
1242
1243         return err;
1244 }
1245
1246 /**
1247  * ice_aq_nvm_update_empr
1248  * @hw: pointer to the HW struct
1249  *
1250  * Update empr (0x0709). This command allows SW to
1251  * request an EMPR to activate new FW.
1252  */
1253 int ice_aq_nvm_update_empr(struct ice_hw *hw)
1254 {
1255         struct ice_aq_desc desc;
1256
1257         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_nvm_update_empr);
1258
1259         return ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
1260 }
1261
1262 /* ice_nvm_set_pkg_data
1263  * @hw: pointer to the HW struct
1264  * @del_pkg_data_flag: If is set then the current pkg_data store by FW
1265  *                     is deleted.
1266  *                     If bit is set to 1, then buffer should be size 0.
1267  * @data: pointer to buffer
1268  * @length: length of the buffer
1269  * @cd: pointer to command details structure or NULL
1270  *
1271  * Set package data (0x070A). This command is equivalent to the reception
1272  * of a PLDM FW Update GetPackageData cmd. This command should be sent
1273  * as part of the NVM update as the first cmd in the flow.
1274  */
1275
1276 int
1277 ice_nvm_set_pkg_data(struct ice_hw *hw, bool del_pkg_data_flag, u8 *data,
1278                      u16 length, struct ice_sq_cd *cd)
1279 {
1280         struct ice_aqc_nvm_pkg_data *cmd;
1281         struct ice_aq_desc desc;
1282
1283         if (length != 0 && !data)
1284                 return -EINVAL;
1285
1286         cmd = &desc.params.pkg_data;
1287
1288         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_nvm_pkg_data);
1289         desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
1290
1291         if (del_pkg_data_flag)
1292                 cmd->cmd_flags |= ICE_AQC_NVM_PKG_DELETE;
1293
1294         return ice_aq_send_cmd(hw, &desc, data, length, cd);
1295 }
1296
1297 /* ice_nvm_pass_component_tbl
1298  * @hw: pointer to the HW struct
1299  * @data: pointer to buffer
1300  * @length: length of the buffer
1301  * @transfer_flag: parameter for determining stage of the update
1302  * @comp_response: a pointer to the response from the 0x070B AQC.
1303  * @comp_response_code: a pointer to the response code from the 0x070B AQC.
1304  * @cd: pointer to command details structure or NULL
1305  *
1306  * Pass component table (0x070B). This command is equivalent to the reception
1307  * of a PLDM FW Update PassComponentTable cmd. This command should be sent once
1308  * per component. It can be only sent after Set Package Data cmd and before
1309  * actual update. FW will assume these commands are going to be sent until
1310  * the TransferFlag is set to End or StartAndEnd.
1311  */
1312
1313 int
1314 ice_nvm_pass_component_tbl(struct ice_hw *hw, u8 *data, u16 length,
1315                            u8 transfer_flag, u8 *comp_response,
1316                            u8 *comp_response_code, struct ice_sq_cd *cd)
1317 {
1318         struct ice_aqc_nvm_pass_comp_tbl *cmd;
1319         struct ice_aq_desc desc;
1320         int status;
1321
1322         if (!data || !comp_response || !comp_response_code)
1323                 return -EINVAL;
1324
1325         cmd = &desc.params.pass_comp_tbl;
1326
1327         ice_fill_dflt_direct_cmd_desc(&desc,
1328                                       ice_aqc_opc_nvm_pass_component_tbl);
1329         desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
1330
1331         cmd->transfer_flag = transfer_flag;
1332         status = ice_aq_send_cmd(hw, &desc, data, length, cd);
1333
1334         if (!status) {
1335                 *comp_response = cmd->component_response;
1336                 *comp_response_code = cmd->component_response_code;
1337         }
1338         return status;
1339 }