1 files changed, 56 insertions, 46 deletions

diff --git a/drivers/net/wireless/iwlwifi/mvm/nvm.c b/drivers/net/wireless/iwlwifi/mvm/nvm.c
index cf2d09f53782..808f78f6fbf9 100644
--- a/drivers/net/wireless/iwlwifi/mvm/nvm.c
+++ b/drivers/net/wireless/iwlwifi/mvm/nvm.c
@@ -74,6 +74,12 @@
 #define NVM_WRITE_OPCODE 1
 #define NVM_READ_OPCODE 0
 
+/* load nvm chunk response */
+enum {
+        READ_NVM_CHUNK_SUCCEED = 0,
+        READ_NVM_CHUNK_NOT_VALID_ADDRESS = 1
+};
+
 /*
  * prepare the NVM host command w/ the pointers to the nvm buffer
  * and send it to fw
@@ -90,7 +96,7 @@ static int iwl_nvm_write_chunk(struct iwl_mvm *mvm, u16 section,
         struct iwl_host_cmd cmd = {
                 .id = NVM_ACCESS_CMD,
                 .len = { sizeof(struct iwl_nvm_access_cmd), length },
-                .flags = CMD_SYNC | CMD_SEND_IN_RFKILL,
+                .flags = CMD_SEND_IN_RFKILL,
                 .data = { &nvm_access_cmd, data },
                 /* data may come from vmalloc, so use _DUP */
                 .dataflags = { 0, IWL_HCMD_DFL_DUP },
@@ -112,7 +118,7 @@ static int iwl_nvm_read_chunk(struct iwl_mvm *mvm, u16 section,
         struct iwl_rx_packet *pkt;
         struct iwl_host_cmd cmd = {
                 .id = NVM_ACCESS_CMD,
-                .flags = CMD_SYNC | CMD_WANT_SKB | CMD_SEND_IN_RFKILL,
+                .flags = CMD_WANT_SKB | CMD_SEND_IN_RFKILL,
                 .data = { &nvm_access_cmd, },
         };
         int ret, bytes_read, offset_read;
@@ -139,10 +145,26 @@ static int iwl_nvm_read_chunk(struct iwl_mvm *mvm, u16 section,
         offset_read = le16_to_cpu(nvm_resp->offset);
         resp_data = nvm_resp->data;
         if (ret) {
-                IWL_ERR(mvm,
-                        "NVM access command failed with status %d (device: %s)\n",
-                        ret, mvm->cfg->name);
-                ret = -EINVAL;
+                if ((offset != 0) &&
+                    (ret == READ_NVM_CHUNK_NOT_VALID_ADDRESS)) {
+                        /*
+                         * meaning of NOT_VALID_ADDRESS:
+                         * driver try to read chunk from address that is
+                         * multiple of 2K and got an error since addr is empty.
+                         * meaning of (offset != 0): driver already
+                         * read valid data from another chunk so this case
+                         * is not an error.
+                         */
+                        IWL_DEBUG_EEPROM(mvm->trans->dev,
+                                         "NVM access command failed on offset 0x%x since that section size is multiple 2K\n",
+                                         offset);
+                        ret = 0;
+                } else {
+                        IWL_DEBUG_EEPROM(mvm->trans->dev,
+                                         "NVM access command failed with status %d (device: %s)\n",
+                                         ret, mvm->cfg->name);
+                        ret = -EIO;
+                }
                 goto exit;
         }
 
@@ -211,9 +233,9 @@ static int iwl_nvm_read_section(struct iwl_mvm *mvm, u16 section,
         while (ret == length) {
                 ret = iwl_nvm_read_chunk(mvm, section, offset, length, data);
                 if (ret < 0) {
-                        IWL_ERR(mvm,
-                                "Cannot read NVM from section %d offset %d, length %d\n",
-                                section, offset, length);
+                        IWL_DEBUG_EEPROM(mvm->trans->dev,
+                                         "Cannot read NVM from section %d offset %d, length %d\n",
+                                         section, offset, length);
                         return ret;
                 }
                 offset += ret;
@@ -238,13 +260,20 @@ iwl_parse_nvm_sections(struct iwl_mvm *mvm)
                         return NULL;
                 }
         } else {
+                /* SW and REGULATORY sections are mandatory */
                 if (!mvm->nvm_sections[NVM_SECTION_TYPE_SW].data ||
-                    !mvm->nvm_sections[NVM_SECTION_TYPE_MAC_OVERRIDE].data ||
                     !mvm->nvm_sections[NVM_SECTION_TYPE_REGULATORY].data) {
                         IWL_ERR(mvm,
                                 "Can't parse empty family 8000 NVM sections\n");
                         return NULL;
                 }
+                /* MAC_OVERRIDE or at least HW section must exist */
+                if (!mvm->nvm_sections[mvm->cfg->nvm_hw_section_num].data &&
+                    !mvm->nvm_sections[NVM_SECTION_TYPE_MAC_OVERRIDE].data) {
+                        IWL_ERR(mvm,
+                                "Can't parse mac_address, empty sections\n");
+                        return NULL;
+                }
         }
 
         if (WARN_ON(!mvm->cfg))
@@ -311,16 +340,16 @@ static int iwl_mvm_read_external_nvm(struct iwl_mvm *mvm)
          * get here after that we assume the NVM request can be satisfied
          * synchronously.
          */
-        ret = request_firmware(&fw_entry, iwlwifi_mod_params.nvm_file,
+        ret = request_firmware(&fw_entry, mvm->nvm_file_name,
                                mvm->trans->dev);
         if (ret) {
                 IWL_ERR(mvm, "ERROR: %s isn't available %d\n",
-                        iwlwifi_mod_params.nvm_file, ret);
+                        mvm->nvm_file_name, ret);
                 return ret;
         }
 
         IWL_INFO(mvm, "Loaded NVM file %s (%zu bytes)\n",
-                 iwlwifi_mod_params.nvm_file, fw_entry->size);
+                 mvm->nvm_file_name, fw_entry->size);
 
         if (fw_entry->size < sizeof(*file_sec)) {
                 IWL_ERR(mvm, "NVM file too small\n");
@@ -427,53 +456,28 @@ int iwl_mvm_load_nvm_to_nic(struct iwl_mvm *mvm)
         return ret;
 }
 
-int iwl_nvm_init(struct iwl_mvm *mvm)
+int iwl_nvm_init(struct iwl_mvm *mvm, bool read_nvm_from_nic)
 {
-        int ret, i, section;
+        int ret, section;
         u8 *nvm_buffer, *temp;
-        int nvm_to_read[NVM_MAX_NUM_SECTIONS];
-        int num_of_sections_to_read;
 
         if (WARN_ON_ONCE(mvm->cfg->nvm_hw_section_num >= NVM_MAX_NUM_SECTIONS))
                 return -EINVAL;
 
-        /* load external NVM if configured */
-        if (iwlwifi_mod_params.nvm_file) {
-                /* move to External NVM flow */
-                ret = iwl_mvm_read_external_nvm(mvm);
-                if (ret)
-                        return ret;
-        } else {
-                /* list of NVM sections we are allowed/need to read */
-                if (mvm->trans->cfg->device_family != IWL_DEVICE_FAMILY_8000) {
-                        nvm_to_read[0] = mvm->cfg->nvm_hw_section_num;
-                        nvm_to_read[1] = NVM_SECTION_TYPE_SW;
-                        nvm_to_read[2] = NVM_SECTION_TYPE_CALIBRATION;
-                        nvm_to_read[3] = NVM_SECTION_TYPE_PRODUCTION;
-                        num_of_sections_to_read = 4;
-                } else {
-                        nvm_to_read[0] = NVM_SECTION_TYPE_SW;
-                        nvm_to_read[1] = NVM_SECTION_TYPE_CALIBRATION;
-                        nvm_to_read[2] = NVM_SECTION_TYPE_PRODUCTION;
-                        nvm_to_read[3] = NVM_SECTION_TYPE_REGULATORY;
-                        nvm_to_read[4] = NVM_SECTION_TYPE_MAC_OVERRIDE;
-                        num_of_sections_to_read = 5;
-                }
-
+        /* load NVM values from nic */
+        if (read_nvm_from_nic) {
                 /* Read From FW NVM */
                 IWL_DEBUG_EEPROM(mvm->trans->dev, "Read from NVM\n");
 
-                /* TODO: find correct NVM max size for a section */
                 nvm_buffer = kmalloc(mvm->cfg->base_params->eeprom_size,
                                      GFP_KERNEL);
                 if (!nvm_buffer)
                         return -ENOMEM;
-                for (i = 0; i < num_of_sections_to_read; i++) {
-                        section = nvm_to_read[i];
+                for (section = 0; section < NVM_MAX_NUM_SECTIONS; section++) {
                         /* we override the constness for initial read */
                         ret = iwl_nvm_read_section(mvm, section, nvm_buffer);
                         if (ret < 0)
-                                break;
+                                continue;
                         temp = kmemdup(nvm_buffer, ret, GFP_KERNEL);
                         if (!temp) {
                                 ret = -ENOMEM;
@@ -502,15 +506,21 @@ int iwl_nvm_init(struct iwl_mvm *mvm)
                                         mvm->nvm_hw_blob.size = ret;
                                         break;
                                 }
-                                WARN(1, "section: %d", section);
                         }
 #endif
                 }
                 kfree(nvm_buffer);
-                if (ret < 0)
+        }
+
+        /* load external NVM if configured */
+        if (mvm->nvm_file_name) {
+                /* move to External NVM flow */
+                ret = iwl_mvm_read_external_nvm(mvm);
+                if (ret)
                         return ret;
         }
 
+        /* parse the relevant nvm sections */
         mvm->nvm_data = iwl_parse_nvm_sections(mvm);
         if (!mvm->nvm_data)
                 return -ENODATA;