drivers/net/wireless/iwlwifi/iwl-ucode.c

   1 /******************************************************************************
   2  *
   3  * GPL LICENSE SUMMARY
   4  *
   5  * Copyright(c) 2008 - 2012 Intel Corporation. All rights reserved.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of version 2 of the GNU General Public License as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  19  * USA
  20  *
  21  * The full GNU General Public License is included in this distribution
  22  * in the file called LICENSE.GPL.
  23  *
  24  * Contact Information:
  25  *  Intel Linux Wireless <ilw@linux.intel.com>
  26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27  *
  28  *****************************************************************************/
  29
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32 #include <linux/init.h>
  33 #include <linux/sched.h>
  34 #include <linux/dma-mapping.h>
  35 #include <linux/firmware.h>
  36
  37 #include "iwl-ucode.h"
  38 #include "iwl-wifi.h"
  39 #include "iwl-dev.h"
  40 #include "iwl-core.h"
  41 #include "iwl-io.h"
  42 #include "iwl-agn-hw.h"
  43 #include "iwl-agn.h"
  44 #include "iwl-agn-calib.h"
  45 #include "iwl-trans.h"
  46 #include "iwl-fh.h"
  47 #include "iwl-op-mode.h"
  48
  49 static struct iwl_wimax_coex_event_entry cu_priorities[COEX_NUM_OF_EVENTS] = {
  50         {COEX_CU_UNASSOC_IDLE_RP, COEX_CU_UNASSOC_IDLE_WP,
  51          0, COEX_UNASSOC_IDLE_FLAGS},
  52         {COEX_CU_UNASSOC_MANUAL_SCAN_RP, COEX_CU_UNASSOC_MANUAL_SCAN_WP,
  53          0, COEX_UNASSOC_MANUAL_SCAN_FLAGS},
  54         {COEX_CU_UNASSOC_AUTO_SCAN_RP, COEX_CU_UNASSOC_AUTO_SCAN_WP,
  55          0, COEX_UNASSOC_AUTO_SCAN_FLAGS},
  56         {COEX_CU_CALIBRATION_RP, COEX_CU_CALIBRATION_WP,
  57          0, COEX_CALIBRATION_FLAGS},
  58         {COEX_CU_PERIODIC_CALIBRATION_RP, COEX_CU_PERIODIC_CALIBRATION_WP,
  59          0, COEX_PERIODIC_CALIBRATION_FLAGS},
  60         {COEX_CU_CONNECTION_ESTAB_RP, COEX_CU_CONNECTION_ESTAB_WP,
  61          0, COEX_CONNECTION_ESTAB_FLAGS},
  62         {COEX_CU_ASSOCIATED_IDLE_RP, COEX_CU_ASSOCIATED_IDLE_WP,
  63          0, COEX_ASSOCIATED_IDLE_FLAGS},
  64         {COEX_CU_ASSOC_MANUAL_SCAN_RP, COEX_CU_ASSOC_MANUAL_SCAN_WP,
  65          0, COEX_ASSOC_MANUAL_SCAN_FLAGS},
  66         {COEX_CU_ASSOC_AUTO_SCAN_RP, COEX_CU_ASSOC_AUTO_SCAN_WP,
  67          0, COEX_ASSOC_AUTO_SCAN_FLAGS},
  68         {COEX_CU_ASSOC_ACTIVE_LEVEL_RP, COEX_CU_ASSOC_ACTIVE_LEVEL_WP,
  69          0, COEX_ASSOC_ACTIVE_LEVEL_FLAGS},
  70         {COEX_CU_RF_ON_RP, COEX_CU_RF_ON_WP, 0, COEX_CU_RF_ON_FLAGS},
  71         {COEX_CU_RF_OFF_RP, COEX_CU_RF_OFF_WP, 0, COEX_RF_OFF_FLAGS},
  72         {COEX_CU_STAND_ALONE_DEBUG_RP, COEX_CU_STAND_ALONE_DEBUG_WP,
  73          0, COEX_STAND_ALONE_DEBUG_FLAGS},
  74         {COEX_CU_IPAN_ASSOC_LEVEL_RP, COEX_CU_IPAN_ASSOC_LEVEL_WP,
  75          0, COEX_IPAN_ASSOC_LEVEL_FLAGS},
  76         {COEX_CU_RSRVD1_RP, COEX_CU_RSRVD1_WP, 0, COEX_RSRVD1_FLAGS},
  77         {COEX_CU_RSRVD2_RP, COEX_CU_RSRVD2_WP, 0, COEX_RSRVD2_FLAGS}
  78 };
  79
  80 /******************************************************************************
  81  *
  82  * uCode download functions
  83  *
  84  ******************************************************************************/
  85
  86 static void iwl_free_fw_desc(struct iwl_nic *nic, struct fw_desc *desc)
  87 {
  88         if (desc->v_addr)
  89                 dma_free_coherent(trans(nic)->dev, desc->len,
  90                                   desc->v_addr, desc->p_addr);
  91         desc->v_addr = NULL;
  92         desc->len = 0;
  93 }
  94
  95 static void iwl_free_fw_img(struct iwl_nic *nic, struct fw_img *img)
  96 {
  97         iwl_free_fw_desc(nic, &img->code);
  98         iwl_free_fw_desc(nic, &img->data);
  99 }
 100
 101 void iwl_dealloc_ucode(struct iwl_nic *nic)
 102 {
 103         iwl_free_fw_img(nic, &nic->fw.ucode_rt);
 104         iwl_free_fw_img(nic, &nic->fw.ucode_init);
 105         iwl_free_fw_img(nic, &nic->fw.ucode_wowlan);
 106 }
 107
 108 static int iwl_alloc_fw_desc(struct iwl_nic *nic, struct fw_desc *desc,
 109                       const void *data, size_t len)
 110 {
 111         if (!len) {
 112                 desc->v_addr = NULL;
 113                 return -EINVAL;
 114         }
 115
 116         desc->v_addr = dma_alloc_coherent(trans(nic)->dev, len,
 117                                           &desc->p_addr, GFP_KERNEL);
 118         if (!desc->v_addr)
 119                 return -ENOMEM;
 120
 121         desc->len = len;
 122         memcpy(desc->v_addr, data, len);
 123         return 0;
 124 }
 125
 126 static inline struct fw_img *iwl_get_ucode_image(struct iwl_nic *nic,
 127                                         enum iwl_ucode_type ucode_type)
 128 {
 129         switch (ucode_type) {
 130         case IWL_UCODE_INIT:
 131                 return &nic->fw.ucode_init;
 132         case IWL_UCODE_WOWLAN:
 133                 return &nic->fw.ucode_wowlan;
 134         case IWL_UCODE_REGULAR:
 135                 return &nic->fw.ucode_rt;
 136         case IWL_UCODE_NONE:
 137                 break;
 138         }
 139         return NULL;
 140 }
 141
 142 /*
 143  *  Calibration
 144  */
 145 static int iwl_set_Xtal_calib(struct iwl_trans *trans)
 146 {
 147         struct iwl_calib_xtal_freq_cmd cmd;
 148         __le16 *xtal_calib =
 149                 (__le16 *)iwl_eeprom_query_addr(trans->shrd, EEPROM_XTAL);
 150
 151         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD);
 152         cmd.cap_pin1 = le16_to_cpu(xtal_calib[0]);
 153         cmd.cap_pin2 = le16_to_cpu(xtal_calib[1]);
 154         return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
 155 }
 156
 157 static int iwl_set_temperature_offset_calib(struct iwl_trans *trans)
 158 {
 159         struct iwl_calib_temperature_offset_cmd cmd;
 160         __le16 *offset_calib =
 161                 (__le16 *)iwl_eeprom_query_addr(trans->shrd,
 162                                                 EEPROM_RAW_TEMPERATURE);
 163
 164         memset(&cmd, 0, sizeof(cmd));
 165         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
 166         memcpy(&cmd.radio_sensor_offset, offset_calib, sizeof(*offset_calib));
 167         if (!(cmd.radio_sensor_offset))
 168                 cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET;
 169
 170         IWL_DEBUG_CALIB(trans, "Radio sensor offset: %d\n",
 171                         le16_to_cpu(cmd.radio_sensor_offset));
 172         return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
 173 }
 174
 175 static int iwl_set_temperature_offset_calib_v2(struct iwl_trans *trans)
 176 {
 177         struct iwl_calib_temperature_offset_v2_cmd cmd;
 178         __le16 *offset_calib_high = (__le16 *)iwl_eeprom_query_addr(trans->shrd,
 179                                      EEPROM_KELVIN_TEMPERATURE);
 180         __le16 *offset_calib_low =
 181                 (__le16 *)iwl_eeprom_query_addr(trans->shrd,
 182                                                 EEPROM_RAW_TEMPERATURE);
 183         struct iwl_eeprom_calib_hdr *hdr;
 184
 185         memset(&cmd, 0, sizeof(cmd));
 186         iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
 187         hdr = (struct iwl_eeprom_calib_hdr *)iwl_eeprom_query_addr(trans->shrd,
 188                                                         EEPROM_CALIB_ALL);
 189         memcpy(&cmd.radio_sensor_offset_high, offset_calib_high,
 190                 sizeof(*offset_calib_high));
 191         memcpy(&cmd.radio_sensor_offset_low, offset_calib_low,
 192                 sizeof(*offset_calib_low));
 193         if (!(cmd.radio_sensor_offset_low)) {
 194                 IWL_DEBUG_CALIB(trans, "no info in EEPROM, use default\n");
 195                 cmd.radio_sensor_offset_low = DEFAULT_RADIO_SENSOR_OFFSET;
 196                 cmd.radio_sensor_offset_high = DEFAULT_RADIO_SENSOR_OFFSET;
 197         }
 198         memcpy(&cmd.burntVoltageRef, &hdr->voltage,
 199                 sizeof(hdr->voltage));
 200
 201         IWL_DEBUG_CALIB(trans, "Radio sensor offset high: %d\n",
 202                         le16_to_cpu(cmd.radio_sensor_offset_high));
 203         IWL_DEBUG_CALIB(trans, "Radio sensor offset low: %d\n",
 204                         le16_to_cpu(cmd.radio_sensor_offset_low));
 205         IWL_DEBUG_CALIB(trans, "Voltage Ref: %d\n",
 206                         le16_to_cpu(cmd.burntVoltageRef));
 207
 208         return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
 209 }
 210
 211 static int iwl_send_calib_cfg(struct iwl_trans *trans)
 212 {
 213         struct iwl_calib_cfg_cmd calib_cfg_cmd;
 214         struct iwl_host_cmd cmd = {
 215                 .id = CALIBRATION_CFG_CMD,
 216                 .len = { sizeof(struct iwl_calib_cfg_cmd), },
 217                 .data = { &calib_cfg_cmd, },
 218         };
 219
 220         memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
 221         calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL;
 222         calib_cfg_cmd.ucd_calib_cfg.once.start = IWL_CALIB_INIT_CFG_ALL;
 223         calib_cfg_cmd.ucd_calib_cfg.once.send_res = IWL_CALIB_INIT_CFG_ALL;
 224         calib_cfg_cmd.ucd_calib_cfg.flags =
 225                 IWL_CALIB_CFG_FLAG_SEND_COMPLETE_NTFY_MSK;
 226
 227         return iwl_trans_send_cmd(trans, &cmd);
 228 }
 229
 230 int iwlagn_rx_calib_result(struct iwl_priv *priv,
 231                             struct iwl_rx_mem_buffer *rxb,
 232                             struct iwl_device_cmd *cmd)
 233 {
 234         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 235         struct iwl_calib_hdr *hdr = (struct iwl_calib_hdr *)pkt->u.raw;
 236         int len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
 237
 238         /* reduce the size of the length field itself */
 239         len -= 4;
 240
 241         if (iwl_calib_set(trans(priv), hdr, len))
 242                 IWL_ERR(priv, "Failed to record calibration data %d\n",
 243                         hdr->op_code);
 244
 245         return 0;
 246 }
 247
 248 int iwl_init_alive_start(struct iwl_trans *trans)
 249 {
 250         int ret;
 251
 252         if (cfg(trans)->bt_params &&
 253             cfg(trans)->bt_params->advanced_bt_coexist) {
 254                 /*
 255                  * Tell uCode we are ready to perform calibration
 256                  * need to perform this before any calibration
 257                  * no need to close the envlope since we are going
 258                  * to load the runtime uCode later.
 259                  */
 260                 ret = iwl_send_bt_env(trans, IWL_BT_COEX_ENV_OPEN,
 261                         BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 262                 if (ret)
 263                         return ret;
 264
 265         }
 266
 267         ret = iwl_send_calib_cfg(trans);
 268         if (ret)
 269                 return ret;
 270
 271         /**
 272          * temperature offset calibration is only needed for runtime ucode,
 273          * so prepare the value now.
 274          */
 275         if (cfg(trans)->need_temp_offset_calib) {
 276                 if (cfg(trans)->temp_offset_v2)
 277                         return iwl_set_temperature_offset_calib_v2(trans);
 278                 else
 279                         return iwl_set_temperature_offset_calib(trans);
 280         }
 281
 282         return 0;
 283 }
 284
 285 static int iwl_send_wimax_coex(struct iwl_trans *trans)
 286 {
 287         struct iwl_wimax_coex_cmd coex_cmd;
 288
 289         if (cfg(trans)->base_params->support_wimax_coexist) {
 290                 /* UnMask wake up src at associated sleep */
 291                 coex_cmd.flags = COEX_FLAGS_ASSOC_WA_UNMASK_MSK;
 292
 293                 /* UnMask wake up src at unassociated sleep */
 294                 coex_cmd.flags |= COEX_FLAGS_UNASSOC_WA_UNMASK_MSK;
 295                 memcpy(coex_cmd.sta_prio, cu_priorities,
 296                         sizeof(struct iwl_wimax_coex_event_entry) *
 297                          COEX_NUM_OF_EVENTS);
 298
 299                 /* enabling the coexistence feature */
 300                 coex_cmd.flags |= COEX_FLAGS_COEX_ENABLE_MSK;
 301
 302                 /* enabling the priorities tables */
 303                 coex_cmd.flags |= COEX_FLAGS_STA_TABLE_VALID_MSK;
 304         } else {
 305                 /* coexistence is disabled */
 306                 memset(&coex_cmd, 0, sizeof(coex_cmd));
 307         }
 308         return iwl_trans_send_cmd_pdu(trans,
 309                                 COEX_PRIORITY_TABLE_CMD, CMD_SYNC,
 310                                 sizeof(coex_cmd), &coex_cmd);
 311 }
 312
 313 static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
 314         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 315                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 316         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 317                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 318         ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 319                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 320         ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 321                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 322         ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 323                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 324         ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 325                 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 326         ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 327                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 328         ((BT_COEX_PRIO_TBL_PRIO_COEX_OFF << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 329                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 330         ((BT_COEX_PRIO_TBL_PRIO_COEX_ON << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
 331                 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
 332         0, 0, 0, 0, 0, 0, 0
 333 };
 334
 335 void iwl_send_prio_tbl(struct iwl_trans *trans)
 336 {
 337         struct iwl_bt_coex_prio_table_cmd prio_tbl_cmd;
 338
 339         memcpy(prio_tbl_cmd.prio_tbl, iwl_bt_prio_tbl,
 340                 sizeof(iwl_bt_prio_tbl));
 341         if (iwl_trans_send_cmd_pdu(trans,
 342                                 REPLY_BT_COEX_PRIO_TABLE, CMD_SYNC,
 343                                 sizeof(prio_tbl_cmd), &prio_tbl_cmd))
 344                 IWL_ERR(trans, "failed to send BT prio tbl command\n");
 345 }
 346
 347 int iwl_send_bt_env(struct iwl_trans *trans, u8 action, u8 type)
 348 {
 349         struct iwl_bt_coex_prot_env_cmd env_cmd;
 350         int ret;
 351
 352         env_cmd.action = action;
 353         env_cmd.type = type;
 354         ret = iwl_trans_send_cmd_pdu(trans,
 355                                REPLY_BT_COEX_PROT_ENV, CMD_SYNC,
 356                                sizeof(env_cmd), &env_cmd);
 357         if (ret)
 358                 IWL_ERR(trans, "failed to send BT env command\n");
 359         return ret;
 360 }
 361
 362
 363 static int iwl_alive_notify(struct iwl_trans *trans)
 364 {
 365         struct iwl_priv *priv = priv(trans);
 366         struct iwl_rxon_context *ctx;
 367         int ret;
 368
 369         if (!priv->tx_cmd_pool)
 370                 priv->tx_cmd_pool =
 371                         kmem_cache_create("iwl_dev_cmd",
 372                                           sizeof(struct iwl_device_cmd),
 373                                           sizeof(void *), 0, NULL);
 374
 375         if (!priv->tx_cmd_pool)
 376                 return -ENOMEM;
 377
 378         iwl_trans_fw_alive(trans);
 379         for_each_context(priv, ctx)
 380                 ctx->last_tx_rejected = false;
 381
 382         ret = iwl_send_wimax_coex(trans);
 383         if (ret)
 384                 return ret;
 385
 386         if (!cfg(priv)->no_xtal_calib) {
 387                 ret = iwl_set_Xtal_calib(trans);
 388                 if (ret)
 389                         return ret;
 390         }
 391
 392         return iwl_send_calib_results(trans);
 393 }
 394
 395
 396 /**
 397  * iwl_verify_inst_sparse - verify runtime uCode image in card vs. host,
 398  *   using sample data 100 bytes apart.  If these sample points are good,
 399  *   it's a pretty good bet that everything between them is good, too.
 400  */
 401 static int iwl_verify_inst_sparse(struct iwl_nic *nic,
 402                                       struct fw_desc *fw_desc)
 403 {
 404         struct iwl_trans *trans = trans(nic);
 405         __le32 *image = (__le32 *)fw_desc->v_addr;
 406         u32 len = fw_desc->len;
 407         u32 val;
 408         u32 i;
 409
 410         IWL_DEBUG_FW(nic, "ucode inst image size is %u\n", len);
 411
 412         for (i = 0; i < len; i += 100, image += 100/sizeof(u32)) {
 413                 /* read data comes through single port, auto-incr addr */
 414                 /* NOTE: Use the debugless read so we don't flood kernel log
 415                  * if IWL_DL_IO is set */
 416                 iwl_write_direct32(trans, HBUS_TARG_MEM_RADDR,
 417                         i + IWLAGN_RTC_INST_LOWER_BOUND);
 418                 val = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
 419                 if (val != le32_to_cpu(*image))
 420                         return -EIO;
 421         }
 422
 423         return 0;
 424 }
 425
 426 static void iwl_print_mismatch_inst(struct iwl_nic *nic,
 427                                     struct fw_desc *fw_desc)
 428 {
 429         struct iwl_trans *trans = trans(nic);
 430         __le32 *image = (__le32 *)fw_desc->v_addr;
 431         u32 len = fw_desc->len;
 432         u32 val;
 433         u32 offs;
 434         int errors = 0;
 435
 436         IWL_DEBUG_FW(nic, "ucode inst image size is %u\n", len);
 437
 438         iwl_write_direct32(trans, HBUS_TARG_MEM_RADDR,
 439                            IWLAGN_RTC_INST_LOWER_BOUND);
 440
 441         for (offs = 0;
 442              offs < len && errors < 20;
 443              offs += sizeof(u32), image++) {
 444                 /* read data comes through single port, auto-incr addr */
 445                 val = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
 446                 if (val != le32_to_cpu(*image)) {
 447                         IWL_ERR(nic, "uCode INST section at "
 448                                 "offset 0x%x, is 0x%x, s/b 0x%x\n",
 449                                 offs, val, le32_to_cpu(*image));
 450                         errors++;
 451                 }
 452         }
 453 }
 454
 455 /**
 456  * iwl_verify_ucode - determine which instruction image is in SRAM,
 457  *    and verify its contents
 458  */
 459 static int iwl_verify_ucode(struct iwl_nic *nic,
 460                             enum iwl_ucode_type ucode_type)
 461 {
 462         struct fw_img *img = iwl_get_ucode_image(nic, ucode_type);
 463
 464         if (!img) {
 465                 IWL_ERR(nic, "Invalid ucode requested (%d)\n", ucode_type);
 466                 return -EINVAL;
 467         }
 468
 469         if (!iwl_verify_inst_sparse(nic, &img->code)) {
 470                 IWL_DEBUG_FW(nic, "uCode is good in inst SRAM\n");
 471                 return 0;
 472         }
 473
 474         IWL_ERR(nic, "UCODE IMAGE IN INSTRUCTION SRAM NOT VALID!!\n");
 475
 476         iwl_print_mismatch_inst(nic, &img->code);
 477         return -EIO;
 478 }
 479
 480 struct iwl_alive_data {
 481         bool valid;
 482         u8 subtype;
 483 };
 484
 485 static void iwl_alive_fn(struct iwl_trans *trans,
 486                             struct iwl_rx_packet *pkt,
 487                             void *data)
 488 {
 489         struct iwl_alive_data *alive_data = data;
 490         struct iwl_alive_resp *palive;
 491
 492         palive = &pkt->u.alive_frame;
 493
 494         IWL_DEBUG_FW(trans, "Alive ucode status 0x%08X revision "
 495                        "0x%01X 0x%01X\n",
 496                        palive->is_valid, palive->ver_type,
 497                        palive->ver_subtype);
 498
 499         trans->shrd->device_pointers.error_event_table =
 500                 le32_to_cpu(palive->error_event_table_ptr);
 501         trans->shrd->device_pointers.log_event_table =
 502                 le32_to_cpu(palive->log_event_table_ptr);
 503
 504         alive_data->subtype = palive->ver_subtype;
 505         alive_data->valid = palive->is_valid == UCODE_VALID_OK;
 506 }
 507
 508 /* notification wait support */
 509 void iwl_init_notification_wait(struct iwl_shared *shrd,
 510                                    struct iwl_notification_wait *wait_entry,
 511                                    u8 cmd,
 512                                    void (*fn)(struct iwl_trans *trans,
 513                                               struct iwl_rx_packet *pkt,
 514                                               void *data),
 515                                    void *fn_data)
 516 {
 517         wait_entry->fn = fn;
 518         wait_entry->fn_data = fn_data;
 519         wait_entry->cmd = cmd;
 520         wait_entry->triggered = false;
 521         wait_entry->aborted = false;
 522
 523         spin_lock_bh(&shrd->notif_wait_lock);
 524         list_add(&wait_entry->list, &shrd->notif_waits);
 525         spin_unlock_bh(&shrd->notif_wait_lock);
 526 }
 527
 528 int iwl_wait_notification(struct iwl_shared *shrd,
 529                              struct iwl_notification_wait *wait_entry,
 530                              unsigned long timeout)
 531 {
 532         int ret;
 533
 534         ret = wait_event_timeout(shrd->notif_waitq,
 535                                  wait_entry->triggered || wait_entry->aborted,
 536                                  timeout);
 537
 538         spin_lock_bh(&shrd->notif_wait_lock);
 539         list_del(&wait_entry->list);
 540         spin_unlock_bh(&shrd->notif_wait_lock);
 541
 542         if (wait_entry->aborted)
 543                 return -EIO;
 544
 545         /* return value is always >= 0 */
 546         if (ret <= 0)
 547                 return -ETIMEDOUT;
 548         return 0;
 549 }
 550
 551 void iwl_remove_notification(struct iwl_shared *shrd,
 552                                 struct iwl_notification_wait *wait_entry)
 553 {
 554         spin_lock_bh(&shrd->notif_wait_lock);
 555         list_del(&wait_entry->list);
 556         spin_unlock_bh(&shrd->notif_wait_lock);
 557 }
 558
 559 void iwl_abort_notification_waits(struct iwl_shared *shrd)
 560 {
 561         unsigned long flags;
 562         struct iwl_notification_wait *wait_entry;
 563
 564         spin_lock_irqsave(&shrd->notif_wait_lock, flags);
 565         list_for_each_entry(wait_entry, &shrd->notif_waits, list)
 566                 wait_entry->aborted = true;
 567         spin_unlock_irqrestore(&shrd->notif_wait_lock, flags);
 568
 569         wake_up_all(&shrd->notif_waitq);
 570 }
 571
 572 #define UCODE_ALIVE_TIMEOUT     HZ
 573 #define UCODE_CALIB_TIMEOUT     (2*HZ)
 574
 575 int iwl_load_ucode_wait_alive(struct iwl_trans *trans,
 576                                  enum iwl_ucode_type ucode_type)
 577 {
 578         struct iwl_notification_wait alive_wait;
 579         struct iwl_alive_data alive_data;
 580         struct fw_img *fw;
 581         int ret;
 582         enum iwl_ucode_type old_type;
 583
 584         iwl_init_notification_wait(trans->shrd, &alive_wait, REPLY_ALIVE,
 585                                       iwl_alive_fn, &alive_data);
 586
 587         old_type = trans->shrd->ucode_type;
 588         trans->shrd->ucode_type = ucode_type;
 589         fw = iwl_get_ucode_image(nic(trans), ucode_type);
 590
 591         if (!fw)
 592                 return -EINVAL;
 593
 594         ret = iwl_trans_start_fw(trans, fw);
 595         if (ret) {
 596                 trans->shrd->ucode_type = old_type;
 597                 iwl_remove_notification(trans->shrd, &alive_wait);
 598                 return ret;
 599         }
 600
 601         /*
 602          * Some things may run in the background now, but we
 603          * just wait for the ALIVE notification here.
 604          */
 605         ret = iwl_wait_notification(trans->shrd, &alive_wait,
 606                                         UCODE_ALIVE_TIMEOUT);
 607         if (ret) {
 608                 trans->shrd->ucode_type = old_type;
 609                 return ret;
 610         }
 611
 612         if (!alive_data.valid) {
 613                 IWL_ERR(trans, "Loaded ucode is not valid!\n");
 614                 trans->shrd->ucode_type = old_type;
 615                 return -EIO;
 616         }
 617
 618         /*
 619          * This step takes a long time (60-80ms!!) and
 620          * WoWLAN image should be loaded quickly, so
 621          * skip it for WoWLAN.
 622          */
 623         if (ucode_type != IWL_UCODE_WOWLAN) {
 624                 ret = iwl_verify_ucode(nic(trans), ucode_type);
 625                 if (ret) {
 626                         trans->shrd->ucode_type = old_type;
 627                         return ret;
 628                 }
 629
 630                 /* delay a bit to give rfkill time to run */
 631                 msleep(5);
 632         }
 633
 634         ret = iwl_alive_notify(trans);
 635         if (ret) {
 636                 IWL_WARN(trans,
 637                         "Could not complete ALIVE transition: %d\n", ret);
 638                 trans->shrd->ucode_type = old_type;
 639                 return ret;
 640         }
 641
 642         return 0;
 643 }
 644
 645 int iwl_run_init_ucode(struct iwl_trans *trans)
 646 {
 647         struct iwl_notification_wait calib_wait;
 648         int ret;
 649
 650         lockdep_assert_held(&trans->shrd->mutex);
 651
 652         /* No init ucode required? Curious, but maybe ok */
 653         if (!nic(trans)->fw.ucode_init.code.len)
 654                 return 0;
 655
 656         if (trans->shrd->ucode_type != IWL_UCODE_NONE)
 657                 return 0;
 658
 659         iwl_init_notification_wait(trans->shrd, &calib_wait,
 660                                       CALIBRATION_COMPLETE_NOTIFICATION,
 661                                       NULL, NULL);
 662
 663         /* Will also start the device */
 664         ret = iwl_load_ucode_wait_alive(trans, IWL_UCODE_INIT);
 665         if (ret)
 666                 goto error;
 667
 668         ret = iwl_init_alive_start(trans);
 669         if (ret)
 670                 goto error;
 671
 672         /*
 673          * Some things may run in the background now, but we
 674          * just wait for the calibration complete notification.
 675          */
 676         ret = iwl_wait_notification(trans->shrd, &calib_wait,
 677                                         UCODE_CALIB_TIMEOUT);
 678
 679         goto out;
 680
 681  error:
 682         iwl_remove_notification(trans->shrd, &calib_wait);
 683  out:
 684         /* Whatever happened, stop the device */
 685         iwl_trans_stop_device(trans);
 686         return ret;
 687 }
 688
 689 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
 690
 691 #define UCODE_EXPERIMENTAL_TAG          "exp"
 692
 693 int __must_check iwl_request_firmware(struct iwl_nic *nic, bool first)
 694 {
 695         const struct iwl_cfg *cfg = cfg(nic);
 696         const char *name_pre = cfg->fw_name_pre;
 697         char tag[8];
 698
 699         if (first) {
 700 #ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
 701                 nic->fw_index = UCODE_EXPERIMENTAL_INDEX;
 702                 strcpy(tag, UCODE_EXPERIMENTAL_TAG);
 703         } else if (nic->fw_index == UCODE_EXPERIMENTAL_INDEX) {
 704 #endif
 705                 nic->fw_index = cfg->ucode_api_max;
 706                 sprintf(tag, "%d", nic->fw_index);
 707         } else {
 708                 nic->fw_index--;
 709                 sprintf(tag, "%d", nic->fw_index);
 710         }
 711
 712         if (nic->fw_index < cfg->ucode_api_min) {
 713                 IWL_ERR(nic, "no suitable firmware found!\n");
 714                 return -ENOENT;
 715         }
 716
 717         sprintf(nic->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
 718
 719         IWL_DEBUG_INFO(nic, "attempting to load firmware %s'%s'\n",
 720                        (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
 721                                 ? "EXPERIMENTAL " : "",
 722                        nic->firmware_name);
 723
 724         return request_firmware_nowait(THIS_MODULE, 1, nic->firmware_name,
 725                                        trans(nic)->dev,
 726                                        GFP_KERNEL, nic, iwl_ucode_callback);
 727 }
 728
 729 struct iwlagn_firmware_pieces {
 730         const void *inst, *data, *init, *init_data, *wowlan_inst, *wowlan_data;
 731         size_t inst_size, data_size, init_size, init_data_size,
 732                wowlan_inst_size, wowlan_data_size;
 733
 734         u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
 735         u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
 736 };
 737
 738 static int iwl_parse_v1_v2_firmware(struct iwl_nic *nic,
 739                                        const struct firmware *ucode_raw,
 740                                        struct iwlagn_firmware_pieces *pieces)
 741 {
 742         struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
 743         u32 api_ver, hdr_size, build;
 744         char buildstr[25];
 745         const u8 *src;
 746
 747         nic->fw.ucode_ver = le32_to_cpu(ucode->ver);
 748         api_ver = IWL_UCODE_API(nic->fw.ucode_ver);
 749
 750         switch (api_ver) {
 751         default:
 752                 hdr_size = 28;
 753                 if (ucode_raw->size < hdr_size) {
 754                         IWL_ERR(nic, "File size too small!\n");
 755                         return -EINVAL;
 756                 }
 757                 build = le32_to_cpu(ucode->u.v2.build);
 758                 pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size);
 759                 pieces->data_size = le32_to_cpu(ucode->u.v2.data_size);
 760                 pieces->init_size = le32_to_cpu(ucode->u.v2.init_size);
 761                 pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size);
 762                 src = ucode->u.v2.data;
 763                 break;
 764         case 0:
 765         case 1:
 766         case 2:
 767                 hdr_size = 24;
 768                 if (ucode_raw->size < hdr_size) {
 769                         IWL_ERR(nic, "File size too small!\n");
 770                         return -EINVAL;
 771                 }
 772                 build = 0;
 773                 pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size);
 774                 pieces->data_size = le32_to_cpu(ucode->u.v1.data_size);
 775                 pieces->init_size = le32_to_cpu(ucode->u.v1.init_size);
 776                 pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size);
 777                 src = ucode->u.v1.data;
 778                 break;
 779         }
 780
 781         if (build)
 782                 sprintf(buildstr, " build %u%s", build,
 783                        (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
 784                                 ? " (EXP)" : "");
 785         else
 786                 buildstr[0] = '\0';
 787
 788         snprintf(nic->fw.fw_version,
 789                  sizeof(nic->fw.fw_version),
 790                  "%u.%u.%u.%u%s",
 791                  IWL_UCODE_MAJOR(nic->fw.ucode_ver),
 792                  IWL_UCODE_MINOR(nic->fw.ucode_ver),
 793                  IWL_UCODE_API(nic->fw.ucode_ver),
 794                  IWL_UCODE_SERIAL(nic->fw.ucode_ver),
 795                  buildstr);
 796
 797         /* Verify size of file vs. image size info in file's header */
 798         if (ucode_raw->size != hdr_size + pieces->inst_size +
 799                                 pieces->data_size + pieces->init_size +
 800                                 pieces->init_data_size) {
 801
 802                 IWL_ERR(nic,
 803                         "uCode file size %d does not match expected size\n",
 804                         (int)ucode_raw->size);
 805                 return -EINVAL;
 806         }
 807
 808         pieces->inst = src;
 809         src += pieces->inst_size;
 810         pieces->data = src;
 811         src += pieces->data_size;
 812         pieces->init = src;
 813         src += pieces->init_size;
 814         pieces->init_data = src;
 815         src += pieces->init_data_size;
 816
 817         return 0;
 818 }
 819
 820 static int iwl_parse_tlv_firmware(struct iwl_nic *nic,
 821                                 const struct firmware *ucode_raw,
 822                                 struct iwlagn_firmware_pieces *pieces,
 823                                 struct iwl_ucode_capabilities *capa)
 824 {
 825         struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
 826         struct iwl_ucode_tlv *tlv;
 827         size_t len = ucode_raw->size;
 828         const u8 *data;
 829         int wanted_alternative = iwlagn_mod_params.wanted_ucode_alternative;
 830         int tmp;
 831         u64 alternatives;
 832         u32 tlv_len;
 833         enum iwl_ucode_tlv_type tlv_type;
 834         const u8 *tlv_data;
 835         char buildstr[25];
 836         u32 build;
 837
 838         if (len < sizeof(*ucode)) {
 839                 IWL_ERR(nic, "uCode has invalid length: %zd\n", len);
 840                 return -EINVAL;
 841         }
 842
 843         if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
 844                 IWL_ERR(nic, "invalid uCode magic: 0X%x\n",
 845                         le32_to_cpu(ucode->magic));
 846                 return -EINVAL;
 847         }
 848
 849         /*
 850          * Check which alternatives are present, and "downgrade"
 851          * when the chosen alternative is not present, warning
 852          * the user when that happens. Some files may not have
 853          * any alternatives, so don't warn in that case.
 854          */
 855         alternatives = le64_to_cpu(ucode->alternatives);
 856         tmp = wanted_alternative;
 857         if (wanted_alternative > 63)
 858                 wanted_alternative = 63;
 859         while (wanted_alternative && !(alternatives & BIT(wanted_alternative)))
 860                 wanted_alternative--;
 861         if (wanted_alternative && wanted_alternative != tmp)
 862                 IWL_WARN(nic,
 863                          "uCode alternative %d not available, choosing %d\n",
 864                          tmp, wanted_alternative);
 865
 866         nic->fw.ucode_ver = le32_to_cpu(ucode->ver);
 867         build = le32_to_cpu(ucode->build);
 868
 869         if (build)
 870                 sprintf(buildstr, " build %u%s", build,
 871                        (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
 872                                 ? " (EXP)" : "");
 873         else
 874                 buildstr[0] = '\0';
 875
 876         snprintf(nic->fw.fw_version,
 877                  sizeof(nic->fw.fw_version),
 878                  "%u.%u.%u.%u%s",
 879                  IWL_UCODE_MAJOR(nic->fw.ucode_ver),
 880                  IWL_UCODE_MINOR(nic->fw.ucode_ver),
 881                  IWL_UCODE_API(nic->fw.ucode_ver),
 882                  IWL_UCODE_SERIAL(nic->fw.ucode_ver),
 883                  buildstr);
 884
 885         data = ucode->data;
 886
 887         len -= sizeof(*ucode);
 888
 889         while (len >= sizeof(*tlv)) {
 890                 u16 tlv_alt;
 891
 892                 len -= sizeof(*tlv);
 893                 tlv = (void *)data;
 894
 895                 tlv_len = le32_to_cpu(tlv->length);
 896                 tlv_type = le16_to_cpu(tlv->type);
 897                 tlv_alt = le16_to_cpu(tlv->alternative);
 898                 tlv_data = tlv->data;
 899
 900                 if (len < tlv_len) {
 901                         IWL_ERR(nic, "invalid TLV len: %zd/%u\n",
 902                                 len, tlv_len);
 903                         return -EINVAL;
 904                 }
 905                 len -= ALIGN(tlv_len, 4);
 906                 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
 907
 908                 /*
 909                  * Alternative 0 is always valid.
 910                  *
 911                  * Skip alternative TLVs that are not selected.
 912                  */
 913                 if (tlv_alt != 0 && tlv_alt != wanted_alternative)
 914                         continue;
 915
 916                 switch (tlv_type) {
 917                 case IWL_UCODE_TLV_INST:
 918                         pieces->inst = tlv_data;
 919                         pieces->inst_size = tlv_len;
 920                         break;
 921                 case IWL_UCODE_TLV_DATA:
 922                         pieces->data = tlv_data;
 923                         pieces->data_size = tlv_len;
 924                         break;
 925                 case IWL_UCODE_TLV_INIT:
 926                         pieces->init = tlv_data;
 927                         pieces->init_size = tlv_len;
 928                         break;
 929                 case IWL_UCODE_TLV_INIT_DATA:
 930                         pieces->init_data = tlv_data;
 931                         pieces->init_data_size = tlv_len;
 932                         break;
 933                 case IWL_UCODE_TLV_BOOT:
 934                         IWL_ERR(nic, "Found unexpected BOOT ucode\n");
 935                         break;
 936                 case IWL_UCODE_TLV_PROBE_MAX_LEN:
 937                         if (tlv_len != sizeof(u32))
 938                                 goto invalid_tlv_len;
 939                         capa->max_probe_length =
 940                                         le32_to_cpup((__le32 *)tlv_data);
 941                         break;
 942                 case IWL_UCODE_TLV_PAN:
 943                         if (tlv_len)
 944                                 goto invalid_tlv_len;
 945                         capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
 946                         break;
 947                 case IWL_UCODE_TLV_FLAGS:
 948                         /* must be at least one u32 */
 949                         if (tlv_len < sizeof(u32))
 950                                 goto invalid_tlv_len;
 951                         /* and a proper number of u32s */
 952                         if (tlv_len % sizeof(u32))
 953                                 goto invalid_tlv_len;
 954                         /*
 955                          * This driver only reads the first u32 as
 956                          * right now no more features are defined,
 957                          * if that changes then either the driver
 958                          * will not work with the new firmware, or
 959                          * it'll not take advantage of new features.
 960                          */
 961                         capa->flags = le32_to_cpup((__le32 *)tlv_data);
 962                         break;
 963                 case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
 964                         if (tlv_len != sizeof(u32))
 965                                 goto invalid_tlv_len;
 966                         pieces->init_evtlog_ptr =
 967                                         le32_to_cpup((__le32 *)tlv_data);
 968                         break;
 969                 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
 970                         if (tlv_len != sizeof(u32))
 971                                 goto invalid_tlv_len;
 972                         pieces->init_evtlog_size =
 973                                         le32_to_cpup((__le32 *)tlv_data);
 974                         break;
 975                 case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
 976                         if (tlv_len != sizeof(u32))
 977                                 goto invalid_tlv_len;
 978                         pieces->init_errlog_ptr =
 979                                         le32_to_cpup((__le32 *)tlv_data);
 980                         break;
 981                 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
 982                         if (tlv_len != sizeof(u32))
 983                                 goto invalid_tlv_len;
 984                         pieces->inst_evtlog_ptr =
 985                                         le32_to_cpup((__le32 *)tlv_data);
 986                         break;
 987                 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
 988                         if (tlv_len != sizeof(u32))
 989                                 goto invalid_tlv_len;
 990                         pieces->inst_evtlog_size =
 991                                         le32_to_cpup((__le32 *)tlv_data);
 992                         break;
 993                 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
 994                         if (tlv_len != sizeof(u32))
 995                                 goto invalid_tlv_len;
 996                         pieces->inst_errlog_ptr =
 997                                         le32_to_cpup((__le32 *)tlv_data);
 998                         break;
 999                 case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
1000                         if (tlv_len)
1001                                 goto invalid_tlv_len;
1002                         nic->fw.enhance_sensitivity_table = true;
1003                         break;
1004                 case IWL_UCODE_TLV_WOWLAN_INST:
1005                         pieces->wowlan_inst = tlv_data;
1006                         pieces->wowlan_inst_size = tlv_len;
1007                         break;
1008                 case IWL_UCODE_TLV_WOWLAN_DATA:
1009                         pieces->wowlan_data = tlv_data;
1010                         pieces->wowlan_data_size = tlv_len;
1011                         break;
1012                 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
1013                         if (tlv_len != sizeof(u32))
1014                                 goto invalid_tlv_len;
1015                         capa->standard_phy_calibration_size =
1016                                         le32_to_cpup((__le32 *)tlv_data);
1017                         break;
1018                 default:
1019                         IWL_DEBUG_INFO(nic, "unknown TLV: %d\n", tlv_type);
1020                         break;
1021                 }
1022         }
1023
1024         if (len) {
1025                 IWL_ERR(nic, "invalid TLV after parsing: %zd\n", len);
1026                 iwl_print_hex_dump(nic, IWL_DL_FW, (u8 *)data, len);
1027                 return -EINVAL;
1028         }
1029
1030         return 0;
1031
1032  invalid_tlv_len:
1033         IWL_ERR(nic, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
1034         iwl_print_hex_dump(nic, IWL_DL_FW, tlv_data, tlv_len);
1035
1036         return -EINVAL;
1037 }
1038
1039 /**
1040  * iwl_ucode_callback - callback when firmware was loaded
1041  *
1042  * If loaded successfully, copies the firmware into buffers
1043  * for the card to fetch (via DMA).
1044  */
1045 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
1046 {
1047         struct iwl_nic *nic = context;
1048         const struct iwl_cfg *cfg = cfg(nic);
1049         struct iwl_fw *fw = &nic->fw;
1050         struct iwl_ucode_header *ucode;
1051         int err;
1052         struct iwlagn_firmware_pieces pieces;
1053         const unsigned int api_max = cfg->ucode_api_max;
1054         unsigned int api_ok = cfg->ucode_api_ok;
1055         const unsigned int api_min = cfg->ucode_api_min;
1056         u32 api_ver;
1057
1058         fw->ucode_capa.max_probe_length = 200;
1059         fw->ucode_capa.standard_phy_calibration_size =
1060                         IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1061
1062         if (!api_ok)
1063                 api_ok = api_max;
1064
1065         memset(&pieces, 0, sizeof(pieces));
1066
1067         if (!ucode_raw) {
1068                 if (nic->fw_index <= api_ok)
1069                         IWL_ERR(nic,
1070                                 "request for firmware file '%s' failed.\n",
1071                                 nic->firmware_name);
1072                 goto try_again;
1073         }
1074
1075         IWL_DEBUG_INFO(nic, "Loaded firmware file '%s' (%zd bytes).\n",
1076                        nic->firmware_name, ucode_raw->size);
1077
1078         /* Make sure that we got at least the API version number */
1079         if (ucode_raw->size < 4) {
1080                 IWL_ERR(nic, "File size way too small!\n");
1081                 goto try_again;
1082         }
1083
1084         /* Data from ucode file:  header followed by uCode images */
1085         ucode = (struct iwl_ucode_header *)ucode_raw->data;
1086
1087         if (ucode->ver)
1088                 err = iwl_parse_v1_v2_firmware(nic, ucode_raw, &pieces);
1089         else
1090                 err = iwl_parse_tlv_firmware(nic, ucode_raw, &pieces,
1091                                            &fw->ucode_capa);
1092
1093         if (err)
1094                 goto try_again;
1095
1096         api_ver = IWL_UCODE_API(nic->fw.ucode_ver);
1097
1098         /*
1099          * api_ver should match the api version forming part of the
1100          * firmware filename ... but we don't check for that and only rely
1101          * on the API version read from firmware header from here on forward
1102          */
1103         /* no api version check required for experimental uCode */
1104         if (nic->fw_index != UCODE_EXPERIMENTAL_INDEX) {
1105                 if (api_ver < api_min || api_ver > api_max) {
1106                         IWL_ERR(nic,
1107                                 "Driver unable to support your firmware API. "
1108                                 "Driver supports v%u, firmware is v%u.\n",
1109                                 api_max, api_ver);
1110                         goto try_again;
1111                 }
1112
1113                 if (api_ver < api_ok) {
1114                         if (api_ok != api_max)
1115                                 IWL_ERR(nic, "Firmware has old API version, "
1116                                         "expected v%u through v%u, got v%u.\n",
1117                                         api_ok, api_max, api_ver);
1118                         else
1119                                 IWL_ERR(nic, "Firmware has old API version, "
1120                                         "expected v%u, got v%u.\n",
1121                                         api_max, api_ver);
1122                         IWL_ERR(nic, "New firmware can be obtained from "
1123                                       "http://www.intellinuxwireless.org/.\n");
1124                 }
1125         }
1126
1127         IWL_INFO(nic, "loaded firmware version %s", nic->fw.fw_version);
1128
1129         /*
1130          * For any of the failures below (before allocating pci memory)
1131          * we will try to load a version with a smaller API -- maybe the
1132          * user just got a corrupted version of the latest API.
1133          */
1134
1135         IWL_DEBUG_INFO(nic, "f/w package hdr ucode version raw = 0x%x\n",
1136                        nic->fw.ucode_ver);
1137         IWL_DEBUG_INFO(nic, "f/w package hdr runtime inst size = %Zd\n",
1138                        pieces.inst_size);
1139         IWL_DEBUG_INFO(nic, "f/w package hdr runtime data size = %Zd\n",
1140                        pieces.data_size);
1141         IWL_DEBUG_INFO(nic, "f/w package hdr init inst size = %Zd\n",
1142                        pieces.init_size);
1143         IWL_DEBUG_INFO(nic, "f/w package hdr init data size = %Zd\n",
1144                        pieces.init_data_size);
1145
1146         /* Verify that uCode images will fit in card's SRAM */
1147         if (pieces.inst_size > cfg->max_inst_size) {
1148                 IWL_ERR(nic, "uCode instr len %Zd too large to fit in\n",
1149                         pieces.inst_size);
1150                 goto try_again;
1151         }
1152
1153         if (pieces.data_size > cfg->max_data_size) {
1154                 IWL_ERR(nic, "uCode data len %Zd too large to fit in\n",
1155                         pieces.data_size);
1156                 goto try_again;
1157         }
1158
1159         if (pieces.init_size > cfg->max_inst_size) {
1160                 IWL_ERR(nic, "uCode init instr len %Zd too large to fit in\n",
1161                         pieces.init_size);
1162                 goto try_again;
1163         }
1164
1165         if (pieces.init_data_size > cfg->max_data_size) {
1166                 IWL_ERR(nic, "uCode init data len %Zd too large to fit in\n",
1167                         pieces.init_data_size);
1168                 goto try_again;
1169         }
1170
1171         /* Allocate ucode buffers for card's bus-master loading ... */
1172
1173         /* Runtime instructions and 2 copies of data:
1174          * 1) unmodified from disk
1175          * 2) backup cache for save/restore during power-downs */
1176         if (iwl_alloc_fw_desc(nic, &nic->fw.ucode_rt.code,
1177                               pieces.inst, pieces.inst_size))
1178                 goto err_pci_alloc;
1179         if (iwl_alloc_fw_desc(nic, &nic->fw.ucode_rt.data,
1180                               pieces.data, pieces.data_size))
1181                 goto err_pci_alloc;
1182
1183         /* Initialization instructions and data */
1184         if (pieces.init_size && pieces.init_data_size) {
1185                 if (iwl_alloc_fw_desc(nic,
1186                                       &nic->fw.ucode_init.code,
1187                                       pieces.init, pieces.init_size))
1188                         goto err_pci_alloc;
1189                 if (iwl_alloc_fw_desc(nic,
1190                                       &nic->fw.ucode_init.data,
1191                                       pieces.init_data, pieces.init_data_size))
1192                         goto err_pci_alloc;
1193         }
1194
1195         /* WoWLAN instructions and data */
1196         if (pieces.wowlan_inst_size && pieces.wowlan_data_size) {
1197                 if (iwl_alloc_fw_desc(nic,
1198                                       &nic->fw.ucode_wowlan.code,
1199                                       pieces.wowlan_inst,
1200                                       pieces.wowlan_inst_size))
1201                         goto err_pci_alloc;
1202                 if (iwl_alloc_fw_desc(nic,
1203                                       &nic->fw.ucode_wowlan.data,
1204                                       pieces.wowlan_data,
1205                                       pieces.wowlan_data_size))
1206                         goto err_pci_alloc;
1207         }
1208
1209         /* Now that we can no longer fail, copy information */
1210
1211         /*
1212          * The (size - 16) / 12 formula is based on the information recorded
1213          * for each event, which is of mode 1 (including timestamp) for all
1214          * new microcodes that include this information.
1215          */
1216         nic->init_evtlog_ptr = pieces.init_evtlog_ptr;
1217         if (pieces.init_evtlog_size)
1218                 nic->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
1219         else
1220                 nic->init_evtlog_size =
1221                         cfg->base_params->max_event_log_size;
1222         nic->init_errlog_ptr = pieces.init_errlog_ptr;
1223         nic->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
1224         if (pieces.inst_evtlog_size)
1225                 nic->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
1226         else
1227                 nic->inst_evtlog_size =
1228                         cfg->base_params->max_event_log_size;
1229         nic->inst_errlog_ptr = pieces.inst_errlog_ptr;
1230
1231         /*
1232          * figure out the offset of chain noise reset and gain commands
1233          * base on the size of standard phy calibration commands table size
1234          */
1235         if (fw->ucode_capa.standard_phy_calibration_size >
1236             IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
1237                 fw->ucode_capa.standard_phy_calibration_size =
1238                         IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1239
1240         /* We have our copies now, allow OS release its copies */
1241         release_firmware(ucode_raw);
1242         complete(&nic->request_firmware_complete);
1243
1244         nic->op_mode = iwl_dvm_ops.start(nic->shrd->trans);
1245
1246         if (!nic->op_mode)
1247                 goto out_unbind;
1248
1249         return;
1250
1251  try_again:
1252         /* try next, if any */
1253         release_firmware(ucode_raw);
1254         if (iwl_request_firmware(nic, false))
1255                 goto out_unbind;
1256         return;
1257
1258  err_pci_alloc:
1259         IWL_ERR(nic, "failed to allocate pci memory\n");
1260         iwl_dealloc_ucode(nic);
1261         release_firmware(ucode_raw);
1262  out_unbind:
1263         complete(&nic->request_firmware_complete);
1264         device_release_driver(trans(nic)->dev);
1265 }
1266