1 files changed, 177 insertions, 18 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl-drv.c b/drivers/net/wireless/iwlwifi/iwl-drv.c
index d9fa8e034da2..38de1513e4de 100644
--- a/drivers/net/wireless/iwlwifi/iwl-drv.c
+++ b/drivers/net/wireless/iwlwifi/iwl-drv.c
@@ -78,9 +78,6 @@
 #include "iwl-config.h"
 #include "iwl-modparams.h"
 
-/* private includes */
-#include "iwl-fw-file.h"
-
 /******************************************************************************
  *
  * module boiler plate
@@ -187,6 +184,11 @@ static void iwl_free_fw_img(struct iwl_drv *drv, struct fw_img *img)
 static void iwl_dealloc_ucode(struct iwl_drv *drv)
 {
         int i;
+
+        kfree(drv->fw.dbg_dest_tlv);
+        for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_conf_tlv); i++)
+                kfree(drv->fw.dbg_conf_tlv[i]);
+
         for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
                 iwl_free_fw_img(drv, drv->fw.img + i);
 }
@@ -248,6 +250,9 @@ static int iwl_request_firmware(struct iwl_drv *drv, bool first)
         /*
          * Starting 8000B - FW name format has changed. This overwrites the
          * previous name and uses the new format.
+         *
+         * TODO:
+         * Once there is only one supported step for 8000 family - delete this!
          */
         if (drv->trans->cfg->device_family == IWL_DEVICE_FAMILY_8000) {
                 char rev_step[2] = {
@@ -258,6 +263,13 @@ static int iwl_request_firmware(struct iwl_drv *drv, bool first)
                 if (CSR_HW_REV_STEP(drv->trans->hw_rev) == SILICON_A_STEP)
                         rev_step[0] = 0;
 
+                /*
+                 * If hw_rev wasn't set yet - default as B-step. If it IS A-step
+                 * we'll reload that FW later instead.
+                 */
+                if (drv->trans->hw_rev == 0)
+                        rev_step[0] = 'B';
+
                 snprintf(drv->firmware_name, sizeof(drv->firmware_name),
                          "%s%s-%s.ucode", name_pre, rev_step, tag);
         }
@@ -301,6 +313,11 @@ struct iwl_firmware_pieces {
 
         u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
         u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
+
+        /* FW debug data parsed for driver usage */
+        struct iwl_fw_dbg_dest_tlv *dbg_dest_tlv;
+        struct iwl_fw_dbg_conf_tlv *dbg_conf_tlv[FW_DBG_MAX];
+        size_t dbg_conf_tlv_len[FW_DBG_MAX];
 };
 
 /*
@@ -574,6 +591,8 @@ static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
         char buildstr[25];
         u32 build;
         int num_of_cpus;
+        bool usniffer_images = false;
+        bool usniffer_req = false;
 
         if (len < sizeof(*ucode)) {
                 IWL_ERR(drv, "uCode has invalid length: %zd\n", len);
@@ -846,12 +865,79 @@ static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
                         capa->n_scan_channels =
                                 le32_to_cpup((__le32 *)tlv_data);
                         break;
+                case IWL_UCODE_TLV_FW_DBG_DEST: {
+                        struct iwl_fw_dbg_dest_tlv *dest = (void *)tlv_data;
+
+                        if (pieces->dbg_dest_tlv) {
+                                IWL_ERR(drv,
+                                        "dbg destination ignored, already exists\n");
+                                break;
+                        }
+
+                        pieces->dbg_dest_tlv = dest;
+                        IWL_INFO(drv, "Found debug destination: %s\n",
+                                 get_fw_dbg_mode_string(dest->monitor_mode));
+
+                        drv->fw.dbg_dest_reg_num =
+                                tlv_len - offsetof(struct iwl_fw_dbg_dest_tlv,
+                                                   reg_ops);
+                        drv->fw.dbg_dest_reg_num /=
+                                sizeof(drv->fw.dbg_dest_tlv->reg_ops[0]);
+
+                        break;
+                        }
+                case IWL_UCODE_TLV_FW_DBG_CONF: {
+                        struct iwl_fw_dbg_conf_tlv *conf = (void *)tlv_data;
+
+                        if (!pieces->dbg_dest_tlv) {
+                                IWL_ERR(drv,
+                                        "Ignore dbg config %d - no destination configured\n",
+                                        conf->id);
+                                break;
+                        }
+
+                        if (conf->id >= ARRAY_SIZE(drv->fw.dbg_conf_tlv)) {
+                                IWL_ERR(drv,
+                                        "Skip unknown configuration: %d\n",
+                                        conf->id);
+                                break;
+                        }
+
+                        if (pieces->dbg_conf_tlv[conf->id]) {
+                                IWL_ERR(drv,
+                                        "Ignore duplicate dbg config %d\n",
+                                        conf->id);
+                                break;
+                        }
+
+                        if (conf->usniffer)
+                                usniffer_req = true;
+
+                        IWL_INFO(drv, "Found debug configuration: %d\n",
+                                 conf->id);
+
+                        pieces->dbg_conf_tlv[conf->id] = conf;
+                        pieces->dbg_conf_tlv_len[conf->id] = tlv_len;
+                        break;
+                        }
+                case IWL_UCODE_TLV_SEC_RT_USNIFFER:
+                        usniffer_images = true;
+                        iwl_store_ucode_sec(pieces, tlv_data,
+                                            IWL_UCODE_REGULAR_USNIFFER,
+                                            tlv_len);
+                        break;
                 default:
                         IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type);
                         break;
                 }
         }
 
+        if (usniffer_req && !usniffer_images) {
+                IWL_ERR(drv,
+                        "user selected to work with usniffer but usniffer image isn't available in ucode package\n");
+                return -EINVAL;
+        }
+
         if (len) {
                 IWL_ERR(drv, "invalid TLV after parsing: %zd\n", len);
                 iwl_print_hex_dump(drv, IWL_DL_FW, (u8 *)data, len);
@@ -989,13 +1075,14 @@ static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
         struct iwl_ucode_header *ucode;
         struct iwlwifi_opmode_table *op;
         int err;
-        struct iwl_firmware_pieces pieces;
+        struct iwl_firmware_pieces *pieces;
         const unsigned int api_max = drv->cfg->ucode_api_max;
         unsigned int api_ok = drv->cfg->ucode_api_ok;
         const unsigned int api_min = drv->cfg->ucode_api_min;
         u32 api_ver;
         int i;
         bool load_module = false;
+        u32 hw_rev = drv->trans->hw_rev;
 
         fw->ucode_capa.max_probe_length = IWL_DEFAULT_MAX_PROBE_LENGTH;
         fw->ucode_capa.standard_phy_calibration_size =
@@ -1005,7 +1092,9 @@ static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
         if (!api_ok)
                 api_ok = api_max;
 
-        memset(&pieces, 0, sizeof(pieces));
+        pieces = kzalloc(sizeof(*pieces), GFP_KERNEL);
+        if (!pieces)
+                return;
 
         if (!ucode_raw) {
                 if (drv->fw_index <= api_ok)
@@ -1028,10 +1117,10 @@ static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
         ucode = (struct iwl_ucode_header *)ucode_raw->data;
 
         if (ucode->ver)
-                err = iwl_parse_v1_v2_firmware(drv, ucode_raw, &pieces);
+                err = iwl_parse_v1_v2_firmware(drv, ucode_raw, pieces);
         else
-                err = iwl_parse_tlv_firmware(drv, ucode_raw, &pieces,
-                                           &fw->ucode_capa);
+                err = iwl_parse_tlv_firmware(drv, ucode_raw, pieces,
+                                             &fw->ucode_capa);
 
         if (err)
                 goto try_again;
@@ -1071,7 +1160,7 @@ static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
          * In mvm uCode there is no difference between data and instructions
          * sections.
          */
-        if (!fw->mvm_fw && validate_sec_sizes(drv, &pieces, drv->cfg))
+        if (!fw->mvm_fw && validate_sec_sizes(drv, pieces, drv->cfg))
                 goto try_again;
 
         /* Allocate ucode buffers for card's bus-master loading ... */
@@ -1080,9 +1169,33 @@ static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
          * 1) unmodified from disk
          * 2) backup cache for save/restore during power-downs */
         for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
-                if (iwl_alloc_ucode(drv, &pieces, i))
+                if (iwl_alloc_ucode(drv, pieces, i))
                         goto out_free_fw;
 
+        if (pieces->dbg_dest_tlv) {
+                drv->fw.dbg_dest_tlv =
+                        kmemdup(pieces->dbg_dest_tlv,
+                                sizeof(*pieces->dbg_dest_tlv) +
+                                sizeof(pieces->dbg_dest_tlv->reg_ops[0]) *
+                                drv->fw.dbg_dest_reg_num, GFP_KERNEL);
+
+                if (!drv->fw.dbg_dest_tlv)
+                        goto out_free_fw;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_conf_tlv); i++) {
+                if (pieces->dbg_conf_tlv[i]) {
+                        drv->fw.dbg_conf_tlv_len[i] =
+                                pieces->dbg_conf_tlv_len[i];
+                        drv->fw.dbg_conf_tlv[i] =
+                                kmemdup(pieces->dbg_conf_tlv[i],
+                                        drv->fw.dbg_conf_tlv_len[i],
+                                        GFP_KERNEL);
+                        if (!drv->fw.dbg_conf_tlv[i])
+                                goto out_free_fw;
+                }
+        }
+
         /* Now that we can no longer fail, copy information */
 
         /*
@@ -1090,20 +1203,20 @@ static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
          * for each event, which is of mode 1 (including timestamp) for all
          * new microcodes that include this information.
          */
-        fw->init_evtlog_ptr = pieces.init_evtlog_ptr;
-        if (pieces.init_evtlog_size)
-                fw->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
+        fw->init_evtlog_ptr = pieces->init_evtlog_ptr;
+        if (pieces->init_evtlog_size)
+                fw->init_evtlog_size = (pieces->init_evtlog_size - 16)/12;
         else
                 fw->init_evtlog_size =
                         drv->cfg->base_params->max_event_log_size;
-        fw->init_errlog_ptr = pieces.init_errlog_ptr;
-        fw->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
-        if (pieces.inst_evtlog_size)
-                fw->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
+        fw->init_errlog_ptr = pieces->init_errlog_ptr;
+        fw->inst_evtlog_ptr = pieces->inst_evtlog_ptr;
+        if (pieces->inst_evtlog_size)
+                fw->inst_evtlog_size = (pieces->inst_evtlog_size - 16)/12;
         else
                 fw->inst_evtlog_size =
                         drv->cfg->base_params->max_event_log_size;
-        fw->inst_errlog_ptr = pieces.inst_errlog_ptr;
+        fw->inst_errlog_ptr = pieces->inst_errlog_ptr;
 
         /*
          * figure out the offset of chain noise reset and gain commands
@@ -1162,10 +1275,55 @@ static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
                                 op->name, err);
 #endif
         }
+
+        /*
+         * We may have loaded the wrong FW file in 8000 HW family if it is an
+         * A-step card, and if drv->trans->hw_rev wasn't properly read when
+         * the FW file had been loaded. (This might happen in SDIO.) In such a
+         * case - unload and reload the correct file.
+         *
+         * TODO:
+         * Once there is only one supported step for 8000 family - delete this!
+         */
+        if (drv->trans->cfg->device_family == IWL_DEVICE_FAMILY_8000 &&
+            CSR_HW_REV_STEP(drv->trans->hw_rev) == SILICON_A_STEP &&
+            drv->trans->hw_rev != hw_rev) {
+                char firmware_name[32];
+
+                /* Free previous FW resources */
+                if (drv->op_mode)
+                        _iwl_op_mode_stop(drv);
+                iwl_dealloc_ucode(drv);
+
+                /* Build name of correct-step FW */
+                snprintf(firmware_name, sizeof(firmware_name),
+                         strrchr(drv->firmware_name, '-'));
+                snprintf(drv->firmware_name, sizeof(drv->firmware_name),
+                         "%s%s", drv->cfg->fw_name_pre, firmware_name);
+
+                /* Clear data before loading correct FW */
+                list_del(&drv->list);
+
+                /* Request correct FW file this time */
+                IWL_DEBUG_INFO(drv, "attempting to load A-step FW %s\n",
+                               drv->firmware_name);
+                err = request_firmware(&ucode_raw, drv->firmware_name,
+                                       drv->trans->dev);
+                if (err) {
+                        IWL_ERR(drv, "Failed swapping FW!\n");
+                        goto out_unbind;
+                }
+
+                /* Redo callback function - this time with right FW */
+                iwl_req_fw_callback(ucode_raw, context);
+        }
+
+        kfree(pieces);
         return;
 
  try_again:
         /* try next, if any */
+        kfree(pieces);
         release_firmware(ucode_raw);
         if (iwl_request_firmware(drv, false))
                 goto out_unbind;
@@ -1176,6 +1334,7 @@ static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
         iwl_dealloc_ucode(drv);
         release_firmware(ucode_raw);
  out_unbind:
+        kfree(pieces);
         complete(&drv->request_firmware_complete);
         device_release_driver(drv->trans->dev);
 }