iwlwifi: mvm: MVM op_mode is supported on 7000 only
authorEmmanuel Grumbach <emmanuel.grumbach@intel.com>
Wed, 6 Mar 2013 09:34:44 +0000 (11:34 +0200)
committerJohannes Berg <johannes.berg@intel.com>
Wed, 20 Mar 2013 11:01:54 +0000 (12:01 +0100)
The code removed in this patch was used for bring up on
older NICs. No MVM capable fw will ever be released for
older NICs, so remove that code.

Signed-off-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
drivers/net/wireless/iwlwifi/mvm/fw-api.h
drivers/net/wireless/iwlwifi/mvm/fw.c
drivers/net/wireless/iwlwifi/mvm/mvm.h
drivers/net/wireless/iwlwifi/mvm/nvm.c
drivers/net/wireless/iwlwifi/mvm/ops.c

index f8d7e88..0e94d8b 100644 (file)
@@ -278,38 +278,7 @@ enum {
        NVM_ACCESS_TARGET_EEPROM = 2,
 };
 
-/**
- * struct iwl_nvm_access_cmd_ver1 - Request the device to send the NVM.
- * @op_code: 0 - read, 1 - write.
- * @target: NVM_ACCESS_TARGET_*. should be 0 for read.
- * @cache_refresh: 0 - None, 1- NVM.
- * @offset: offset in the nvm data.
- * @length: of the chunk.
- * @data: empty on read, the NVM chunk on write
- */
-struct iwl_nvm_access_cmd_ver1 {
-       u8 op_code;
-       u8 target;
-       u8 cache_refresh;
-       u8 reserved;
-       __le16 offset;
-       __le16 length;
-       u8 data[];
-} __packed; /* NVM_ACCESS_CMD_API_S_VER_1 */
-
-/**
- * struct iwl_nvm_access_resp_ver1 - response to NVM_ACCESS_CMD
- * @offset: the offset in the nvm data
- * @length: of the chunk
- * @data: the nvm chunk on when NVM_ACCESS_CMD was read, nothing on write
- */
-struct iwl_nvm_access_resp_ver1 {
-       __le16 offset;
-       __le16 length;
-       u8 data[];
-} __packed; /* NVM_ACCESS_CMD_RESP_API_S_VER_1 */
-
-/* Section types for NVM_ACCESS_CMD version 2 */
+/* Section types for NVM_ACCESS_CMD */
 enum {
        NVM_SECTION_TYPE_HW = 0,
        NVM_SECTION_TYPE_SW,
@@ -330,7 +299,7 @@ enum {
  * @length: in bytes, to read/write
  * @data: if write operation, the data to write. On read its empty
  */
-struct iwl_nvm_access_cmd_ver2 {
+struct iwl_nvm_access_cmd {
        u8 op_code;
        u8 target;
        __le16 type;
@@ -347,7 +316,7 @@ struct iwl_nvm_access_cmd_ver2 {
  * @status: 0 for success, fail otherwise
  * @data: if read operation, the data returned. Empty on write.
  */
-struct iwl_nvm_access_resp_ver2 {
+struct iwl_nvm_access_resp {
        __le16 offset;
        __le16 length;
        __le16 type;
index 1006b32..d43e2a5 100644 (file)
@@ -330,12 +330,10 @@ int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm)
        if (ret)
                goto error;
 
-       /* WkP doesn't have all calibrations, need to set default values */
-       if (mvm->cfg->device_family == IWL_DEVICE_FAMILY_7000) {
-               ret = iwl_set_default_calibrations(mvm);
-               if (ret)
-                       goto error;
-       }
+       /* need to set default values */
+       ret = iwl_set_default_calibrations(mvm);
+       if (ret)
+               goto error;
 
        /*
         * Send phy configurations command to init uCode
index 203eb85..d022e44 100644 (file)
@@ -281,10 +281,7 @@ struct iwl_mvm {
        atomic_t queue_stop_count[IWL_MAX_HW_QUEUES];
 
        struct iwl_nvm_data *nvm_data;
-       /* eeprom blob for debugfs/testmode */
-       u8 *eeprom_blob;
-       size_t eeprom_blob_size;
-       /* NVM sections for 7000 family */
+       /* NVM sections */
        struct iwl_nvm_section nvm_sections[NVM_NUM_OF_SECTIONS];
 
        /* EEPROM MAC addresses */
index 93e3d0f..b8ec02f 100644 (file)
@@ -77,26 +77,8 @@ static const int nvm_to_read[] = {
 /* Default NVM size to read */
 #define IWL_NVM_DEFAULT_CHUNK_SIZE (2*1024);
 
-/* used to simplify the shared operations on NCM_ACCESS_CMD versions */
-union iwl_nvm_access_cmd {
-       struct iwl_nvm_access_cmd_ver1 ver1;
-       struct iwl_nvm_access_cmd_ver2 ver2;
-};
-union iwl_nvm_access_resp {
-       struct iwl_nvm_access_resp_ver1 ver1;
-       struct iwl_nvm_access_resp_ver2 ver2;
-};
-
-static inline void iwl_nvm_fill_read_ver1(struct iwl_nvm_access_cmd_ver1 *cmd,
-                                         u16 offset, u16 length)
-{
-       cmd->offset = cpu_to_le16(offset);
-       cmd->length = cpu_to_le16(length);
-       cmd->cache_refresh = 1;
-}
-
-static inline void iwl_nvm_fill_read_ver2(struct iwl_nvm_access_cmd_ver2 *cmd,
-                                         u16 offset, u16 length, u16 section)
+static inline void iwl_nvm_fill_read(struct iwl_nvm_access_cmd *cmd,
+                                    u16 offset, u16 length, u16 section)
 {
        cmd->offset = cpu_to_le16(offset);
        cmd->length = cpu_to_le16(length);
@@ -106,8 +88,8 @@ static inline void iwl_nvm_fill_read_ver2(struct iwl_nvm_access_cmd_ver2 *cmd,
 static int iwl_nvm_read_chunk(struct iwl_mvm *mvm, u16 section,
                              u16 offset, u16 length, u8 *data)
 {
-       union iwl_nvm_access_cmd nvm_access_cmd;
-       union iwl_nvm_access_resp *nvm_resp;
+       struct iwl_nvm_access_cmd nvm_access_cmd = {};
+       struct iwl_nvm_access_resp *nvm_resp;
        struct iwl_rx_packet *pkt;
        struct iwl_host_cmd cmd = {
                .id = NVM_ACCESS_CMD,
@@ -117,18 +99,8 @@ static int iwl_nvm_read_chunk(struct iwl_mvm *mvm, u16 section,
        int ret, bytes_read, offset_read;
        u8 *resp_data;
 
-       memset(&nvm_access_cmd, 0, sizeof(nvm_access_cmd));
-
-       /* TODO: not sure family should be the decider, maybe FW version? */
-       if (mvm->cfg->device_family == IWL_DEVICE_FAMILY_7000) {
-               iwl_nvm_fill_read_ver2(&(nvm_access_cmd.ver2),
-                                      offset, length, section);
-               cmd.len[0] = sizeof(struct iwl_nvm_access_cmd_ver2);
-       } else {
-               iwl_nvm_fill_read_ver1(&(nvm_access_cmd.ver1),
-                                      offset, length);
-               cmd.len[0] = sizeof(struct iwl_nvm_access_cmd_ver1);
-       }
+       iwl_nvm_fill_read(&nvm_access_cmd, offset, length, section);
+       cmd.len[0] = sizeof(struct iwl_nvm_access_cmd);
 
        ret = iwl_mvm_send_cmd(mvm, &cmd);
        if (ret)
@@ -144,17 +116,10 @@ static int iwl_nvm_read_chunk(struct iwl_mvm *mvm, u16 section,
 
        /* Extract NVM response */
        nvm_resp = (void *)pkt->data;
-       if (mvm->cfg->device_family == IWL_DEVICE_FAMILY_7000) {
-               ret = le16_to_cpu(nvm_resp->ver2.status);
-               bytes_read = le16_to_cpu(nvm_resp->ver2.length);
-               offset_read = le16_to_cpu(nvm_resp->ver2.offset);
-               resp_data = nvm_resp->ver2.data;
-       } else {
-               ret = le16_to_cpu(nvm_resp->ver1.length) <= 0;
-               bytes_read = le16_to_cpu(nvm_resp->ver1.length);
-               offset_read = le16_to_cpu(nvm_resp->ver1.offset);
-               resp_data = nvm_resp->ver1.data;
-       }
+       ret = le16_to_cpu(nvm_resp->status);
+       bytes_read = le16_to_cpu(nvm_resp->length);
+       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",
@@ -194,17 +159,10 @@ static int iwl_nvm_read_section(struct iwl_mvm *mvm, u16 section,
 {
        u16 length, offset = 0;
        int ret;
-       bool old_eeprom = mvm->cfg->device_family != IWL_DEVICE_FAMILY_7000;
 
        /* Set nvm section read length */
        length = IWL_NVM_DEFAULT_CHUNK_SIZE;
 
-       /*
-        * if length is greater than EEPROM size, truncate it because uCode
-        * doesn't check it by itself, and exit the loop when reached.
-        */
-       if (old_eeprom && length > mvm->cfg->base_params->eeprom_size)
-               length = mvm->cfg->base_params->eeprom_size;
        ret = length;
 
        /* Read the NVM until exhausted (reading less than requested) */
@@ -217,8 +175,6 @@ static int iwl_nvm_read_section(struct iwl_mvm *mvm, u16 section,
                        return ret;
                }
                offset += ret;
-               if (old_eeprom && offset == mvm->cfg->base_params->eeprom_size)
-                       break;
        }
 
        IWL_INFO(mvm, "NVM section %d read completed\n", section);
@@ -252,63 +208,31 @@ int iwl_nvm_init(struct iwl_mvm *mvm)
        int ret, i, section;
        u8 *nvm_buffer, *temp;
 
-       if (mvm->cfg->device_family == IWL_DEVICE_FAMILY_7000) {
-               /* 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 < ARRAY_SIZE(nvm_to_read); i++) {
-                       section = nvm_to_read[i];
-                       /* we override the constness for initial read */
-                       ret = iwl_nvm_read_section(mvm, section, nvm_buffer);
-                       if (ret < 0)
-                               break;
-                       temp = kmemdup(nvm_buffer, ret, GFP_KERNEL);
-                       if (!temp) {
-                               ret = -ENOMEM;
-                               break;
-                       }
-                       mvm->nvm_sections[section].data = temp;
-                       mvm->nvm_sections[section].length = ret;
-               }
-               kfree(nvm_buffer);
+       /* 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 < ARRAY_SIZE(nvm_to_read); i++) {
+               section = nvm_to_read[i];
+               /* we override the constness for initial read */
+               ret = iwl_nvm_read_section(mvm, section, nvm_buffer);
                if (ret < 0)
-                       return ret;
-       } else {
-               /* allocate eeprom */
-               mvm->eeprom_blob_size = mvm->cfg->base_params->eeprom_size;
-               IWL_DEBUG_EEPROM(mvm->trans->dev, "NVM size = %zd\n",
-                                mvm->eeprom_blob_size);
-               mvm->eeprom_blob = kzalloc(mvm->eeprom_blob_size, GFP_KERNEL);
-               if (!mvm->eeprom_blob)
-                       return -ENOMEM;
-
-               ret = iwl_nvm_read_section(mvm, 0, mvm->eeprom_blob);
-               if (ret != mvm->eeprom_blob_size) {
-                       IWL_ERR(mvm, "Read partial NVM %d/%zd\n",
-                               ret, mvm->eeprom_blob_size);
-                       kfree(mvm->eeprom_blob);
-                       mvm->eeprom_blob = NULL;
-                       return -EINVAL;
+                       break;
+               temp = kmemdup(nvm_buffer, ret, GFP_KERNEL);
+               if (!temp) {
+                       ret = -ENOMEM;
+                       break;
                }
+               mvm->nvm_sections[section].data = temp;
+               mvm->nvm_sections[section].length = ret;
        }
+       kfree(nvm_buffer);
+       if (ret < 0)
+               return ret;
 
        ret = 0;
-       if (mvm->cfg->device_family == IWL_DEVICE_FAMILY_7000)
-               mvm->nvm_data = iwl_parse_nvm_sections(mvm);
-       else
-               mvm->nvm_data =
-                       iwl_parse_eeprom_data(mvm->trans->dev,
-                                             mvm->cfg,
-                                             mvm->eeprom_blob,
-                                             mvm->eeprom_blob_size);
-
-       if (!mvm->nvm_data) {
-               kfree(mvm->eeprom_blob);
-               mvm->eeprom_blob = NULL;
-               ret = -ENOMEM;
-       }
+       mvm->nvm_data = iwl_parse_nvm_sections(mvm);
 
        return ret;
 }
index 828bddd..b490426 100644 (file)
@@ -319,16 +319,6 @@ iwl_op_mode_mvm_start(struct iwl_trans *trans, const struct iwl_cfg *cfg,
        };
        int err, scan_size;
 
-       switch (cfg->device_family) {
-       case IWL_DEVICE_FAMILY_6030:
-       case IWL_DEVICE_FAMILY_6005:
-       case IWL_DEVICE_FAMILY_7000:
-               break;
-       default:
-               IWL_ERR(trans, "Trying to load mvm on an unsupported device\n");
-               return NULL;
-       }
-
        /********************************
         * 1. Allocating and configuring HW data
         ********************************/
@@ -444,7 +434,6 @@ iwl_op_mode_mvm_start(struct iwl_trans *trans, const struct iwl_cfg *cfg,
  out_free:
        iwl_phy_db_free(mvm->phy_db);
        kfree(mvm->scan_cmd);
-       kfree(mvm->eeprom_blob);
        iwl_trans_stop_hw(trans, true);
        ieee80211_free_hw(mvm->hw);
        return NULL;
@@ -466,7 +455,6 @@ static void iwl_op_mode_mvm_stop(struct iwl_op_mode *op_mode)
        iwl_phy_db_free(mvm->phy_db);
        mvm->phy_db = NULL;
 
-       kfree(mvm->eeprom_blob);
        iwl_free_nvm_data(mvm->nvm_data);
        for (i = 0; i < NVM_NUM_OF_SECTIONS; i++)
                kfree(mvm->nvm_sections[i].data);