drivers/net/wireless/intel/iwlwifi/iwl-drv.c

   1 /******************************************************************************
   2  *
   3  * This file is provided under a dual BSD/GPLv2 license.  When using or
   4  * redistributing this file, you may do so under either license.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2007 - 2014 Intel Corporation. All rights reserved.
   9  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  10  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of version 2 of the GNU General Public License as
  14  * published by the Free Software Foundation.
  15  *
  16  * This program is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  24  * USA
  25  *
  26  * The full GNU General Public License is included in this distribution
  27  * in the file called COPYING.
  28  *
  29  * Contact Information:
  30  *  Intel Linux Wireless <linuxwifi@intel.com>
  31  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  32  *
  33  * BSD LICENSE
  34  *
  35  * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
  36  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  37  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
  38  * All rights reserved.
  39  *
  40  * Redistribution and use in source and binary forms, with or without
  41  * modification, are permitted provided that the following conditions
  42  * are met:
  43  *
  44  *  * Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  *  * Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in
  48  *    the documentation and/or other materials provided with the
  49  *    distribution.
  50  *  * Neither the name Intel Corporation nor the names of its
  51  *    contributors may be used to endorse or promote products derived
  52  *    from this software without specific prior written permission.
  53  *
  54  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  55  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  56  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  57  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  58  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  59  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  60  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  61  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  62  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  63  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  64  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  65  *
  66  *****************************************************************************/
  67 #include <linux/completion.h>
  68 #include <linux/dma-mapping.h>
  69 #include <linux/firmware.h>
  70 #include <linux/module.h>
  71 #include <linux/vmalloc.h>
  72
  73 #include "iwl-drv.h"
  74 #include "iwl-csr.h"
  75 #include "iwl-debug.h"
  76 #include "iwl-trans.h"
  77 #include "iwl-op-mode.h"
  78 #include "iwl-agn-hw.h"
  79 #include "fw/img.h"
  80 #include "iwl-config.h"
  81 #include "iwl-modparams.h"
  82
  83 /******************************************************************************
  84  *
  85  * module boiler plate
  86  *
  87  ******************************************************************************/
  88
  89 #define DRV_DESCRIPTION "Intel(R) Wireless WiFi driver for Linux"
  90 MODULE_DESCRIPTION(DRV_DESCRIPTION);
  91 MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
  92 MODULE_LICENSE("GPL");
  93
  94 #ifdef CONFIG_IWLWIFI_DEBUGFS
  95 static struct dentry *iwl_dbgfs_root;
  96 #endif
  97
  98 /**
  99  * struct iwl_drv - drv common data
 100  * @list: list of drv structures using this opmode
 101  * @fw: the iwl_fw structure
 102  * @op_mode: the running op_mode
 103  * @trans: transport layer
 104  * @dev: for debug prints only
 105  * @fw_index: firmware revision to try loading
 106  * @firmware_name: composite filename of ucode file to load
 107  * @request_firmware_complete: the firmware has been obtained from user space
 108  */
 109 struct iwl_drv {
 110         struct list_head list;
 111         struct iwl_fw fw;
 112
 113         struct iwl_op_mode *op_mode;
 114         struct iwl_trans *trans;
 115         struct device *dev;
 116
 117         int fw_index;                   /* firmware we're trying to load */
 118         char firmware_name[64];         /* name of firmware file to load */
 119
 120         struct completion request_firmware_complete;
 121
 122 #ifdef CONFIG_IWLWIFI_DEBUGFS
 123         struct dentry *dbgfs_drv;
 124         struct dentry *dbgfs_trans;
 125         struct dentry *dbgfs_op_mode;
 126 #endif
 127 };
 128
 129 enum {
 130         DVM_OP_MODE,
 131         MVM_OP_MODE,
 132 };
 133
 134 /* Protects the table contents, i.e. the ops pointer & drv list */
 135 static struct mutex iwlwifi_opmode_table_mtx;
 136 static struct iwlwifi_opmode_table {
 137         const char *name;                       /* name: iwldvm, iwlmvm, etc */
 138         const struct iwl_op_mode_ops *ops;      /* pointer to op_mode ops */
 139         struct list_head drv;           /* list of devices using this op_mode */
 140 } iwlwifi_opmode_table[] = {            /* ops set when driver is initialized */
 141         [DVM_OP_MODE] = { .name = "iwldvm", .ops = NULL },
 142         [MVM_OP_MODE] = { .name = "iwlmvm", .ops = NULL },
 143 };
 144
 145 #define IWL_DEFAULT_SCAN_CHANNELS 40
 146
 147 /*
 148  * struct fw_sec: Just for the image parsing process.
 149  * For the fw storage we are using struct fw_desc.
 150  */
 151 struct fw_sec {
 152         const void *data;               /* the sec data */
 153         size_t size;                    /* section size */
 154         u32 offset;                     /* offset of writing in the device */
 155 };
 156
 157 static void iwl_free_fw_desc(struct iwl_drv *drv, struct fw_desc *desc)
 158 {
 159         vfree(desc->data);
 160         desc->data = NULL;
 161         desc->len = 0;
 162 }
 163
 164 static void iwl_free_fw_img(struct iwl_drv *drv, struct fw_img *img)
 165 {
 166         int i;
 167         for (i = 0; i < img->num_sec; i++)
 168                 iwl_free_fw_desc(drv, &img->sec[i]);
 169         kfree(img->sec);
 170 }
 171
 172 static void iwl_dealloc_ucode(struct iwl_drv *drv)
 173 {
 174         int i;
 175
 176         kfree(drv->fw.dbg_dest_tlv);
 177         for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_conf_tlv); i++)
 178                 kfree(drv->fw.dbg_conf_tlv[i]);
 179         for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_trigger_tlv); i++)
 180                 kfree(drv->fw.dbg_trigger_tlv[i]);
 181         kfree(drv->fw.dbg_mem_tlv);
 182         kfree(drv->fw.iml);
 183
 184         for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
 185                 iwl_free_fw_img(drv, drv->fw.img + i);
 186 }
 187
 188 static int iwl_alloc_fw_desc(struct iwl_drv *drv, struct fw_desc *desc,
 189                              struct fw_sec *sec)
 190 {
 191         void *data;
 192
 193         desc->data = NULL;
 194
 195         if (!sec || !sec->size)
 196                 return -EINVAL;
 197
 198         data = vmalloc(sec->size);
 199         if (!data)
 200                 return -ENOMEM;
 201
 202         desc->len = sec->size;
 203         desc->offset = sec->offset;
 204         memcpy(data, sec->data, desc->len);
 205         desc->data = data;
 206
 207         return 0;
 208 }
 209
 210 static void iwl_req_fw_callback(const struct firmware *ucode_raw,
 211                                 void *context);
 212
 213 static int iwl_request_firmware(struct iwl_drv *drv, bool first)
 214 {
 215         const struct iwl_cfg *cfg = drv->trans->cfg;
 216         char tag[8];
 217         const char *fw_pre_name;
 218
 219         if (drv->trans->cfg->device_family == IWL_DEVICE_FAMILY_9000 &&
 220             (CSR_HW_REV_STEP(drv->trans->hw_rev) == SILICON_B_STEP ||
 221              CSR_HW_REV_STEP(drv->trans->hw_rev) == SILICON_C_STEP))
 222                 fw_pre_name = cfg->fw_name_pre_b_or_c_step;
 223         else if (drv->trans->cfg->integrated &&
 224                  CSR_HW_RFID_STEP(drv->trans->hw_rf_id) == SILICON_B_STEP &&
 225                  cfg->fw_name_pre_rf_next_step)
 226                 fw_pre_name = cfg->fw_name_pre_rf_next_step;
 227         else
 228                 fw_pre_name = cfg->fw_name_pre;
 229
 230         if (first) {
 231                 drv->fw_index = cfg->ucode_api_max;
 232                 sprintf(tag, "%d", drv->fw_index);
 233         } else {
 234                 drv->fw_index--;
 235                 sprintf(tag, "%d", drv->fw_index);
 236         }
 237
 238         if (drv->fw_index < cfg->ucode_api_min) {
 239                 IWL_ERR(drv, "no suitable firmware found!\n");
 240
 241                 if (cfg->ucode_api_min == cfg->ucode_api_max) {
 242                         IWL_ERR(drv, "%s%d is required\n", fw_pre_name,
 243                                 cfg->ucode_api_max);
 244                 } else {
 245                         IWL_ERR(drv, "minimum version required: %s%d\n",
 246                                 fw_pre_name,
 247                                 cfg->ucode_api_min);
 248                         IWL_ERR(drv, "maximum version supported: %s%d\n",
 249                                 fw_pre_name,
 250                                 cfg->ucode_api_max);
 251                 }
 252
 253                 IWL_ERR(drv,
 254                         "check /*(DEBLOBBED)*/\n");
 255                 return -ENOENT;
 256         }
 257
 258         snprintf(drv->firmware_name, sizeof(drv->firmware_name), "/*(DEBLOBBED)*/",
 259                  fw_pre_name, tag);
 260
 261         IWL_DEBUG_INFO(drv, "attempting to load firmware '%s'\n",
 262                        drv->firmware_name);
 263
 264         return reject_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
 265                                        drv->trans->dev,
 266                                        GFP_KERNEL, drv, iwl_req_fw_callback);
 267 }
 268
 269 struct fw_img_parsing {
 270         struct fw_sec *sec;
 271         int sec_counter;
 272 };
 273
 274 /*
 275  * struct fw_sec_parsing: to extract fw section and it's offset from tlv
 276  */
 277 struct fw_sec_parsing {
 278         __le32 offset;
 279         const u8 data[];
 280 } __packed;
 281
 282 /**
 283  * struct iwl_tlv_calib_data - parse the default calib data from TLV
 284  *
 285  * @ucode_type: the uCode to which the following default calib relates.
 286  * @calib: default calibrations.
 287  */
 288 struct iwl_tlv_calib_data {
 289         __le32 ucode_type;
 290         struct iwl_tlv_calib_ctrl calib;
 291 } __packed;
 292
 293 struct iwl_firmware_pieces {
 294         struct fw_img_parsing img[IWL_UCODE_TYPE_MAX];
 295
 296         u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
 297         u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
 298
 299         /* FW debug data parsed for driver usage */
 300         bool dbg_dest_tlv_init;
 301         u8 *dbg_dest_ver;
 302         union {
 303                 struct iwl_fw_dbg_dest_tlv *dbg_dest_tlv;
 304                 struct iwl_fw_dbg_dest_tlv_v1 *dbg_dest_tlv_v1;
 305         };
 306         struct iwl_fw_dbg_conf_tlv *dbg_conf_tlv[FW_DBG_CONF_MAX];
 307         size_t dbg_conf_tlv_len[FW_DBG_CONF_MAX];
 308         struct iwl_fw_dbg_trigger_tlv *dbg_trigger_tlv[FW_DBG_TRIGGER_MAX];
 309         size_t dbg_trigger_tlv_len[FW_DBG_TRIGGER_MAX];
 310         struct iwl_fw_dbg_mem_seg_tlv *dbg_mem_tlv;
 311         size_t n_dbg_mem_tlv;
 312 };
 313
 314 /*
 315  * These functions are just to extract uCode section data from the pieces
 316  * structure.
 317  */
 318 static struct fw_sec *get_sec(struct iwl_firmware_pieces *pieces,
 319                               enum iwl_ucode_type type,
 320                               int  sec)
 321 {
 322         return &pieces->img[type].sec[sec];
 323 }
 324
 325 static void alloc_sec_data(struct iwl_firmware_pieces *pieces,
 326                            enum iwl_ucode_type type,
 327                            int sec)
 328 {
 329         struct fw_img_parsing *img = &pieces->img[type];
 330         struct fw_sec *sec_memory;
 331         int size = sec + 1;
 332         size_t alloc_size = sizeof(*img->sec) * size;
 333
 334         if (img->sec && img->sec_counter >= size)
 335                 return;
 336
 337         sec_memory = krealloc(img->sec, alloc_size, GFP_KERNEL);
 338         if (!sec_memory)
 339                 return;
 340
 341         img->sec = sec_memory;
 342         img->sec_counter = size;
 343 }
 344
 345 static void set_sec_data(struct iwl_firmware_pieces *pieces,
 346                          enum iwl_ucode_type type,
 347                          int sec,
 348                          const void *data)
 349 {
 350         alloc_sec_data(pieces, type, sec);
 351
 352         pieces->img[type].sec[sec].data = data;
 353 }
 354
 355 static void set_sec_size(struct iwl_firmware_pieces *pieces,
 356                          enum iwl_ucode_type type,
 357                          int sec,
 358                          size_t size)
 359 {
 360         alloc_sec_data(pieces, type, sec);
 361
 362         pieces->img[type].sec[sec].size = size;
 363 }
 364
 365 static size_t get_sec_size(struct iwl_firmware_pieces *pieces,
 366                            enum iwl_ucode_type type,
 367                            int sec)
 368 {
 369         return pieces->img[type].sec[sec].size;
 370 }
 371
 372 static void set_sec_offset(struct iwl_firmware_pieces *pieces,
 373                            enum iwl_ucode_type type,
 374                            int sec,
 375                            u32 offset)
 376 {
 377         alloc_sec_data(pieces, type, sec);
 378
 379         pieces->img[type].sec[sec].offset = offset;
 380 }
 381
 382 static int iwl_store_cscheme(struct iwl_fw *fw, const u8 *data, const u32 len)
 383 {
 384         int i, j;
 385         struct iwl_fw_cscheme_list *l = (struct iwl_fw_cscheme_list *)data;
 386         struct iwl_fw_cipher_scheme *fwcs;
 387
 388         if (len < sizeof(*l) ||
 389             len < sizeof(l->size) + l->size * sizeof(l->cs[0]))
 390                 return -EINVAL;
 391
 392         for (i = 0, j = 0; i < IWL_UCODE_MAX_CS && i < l->size; i++) {
 393                 fwcs = &l->cs[j];
 394
 395                 /* we skip schemes with zero cipher suite selector */
 396                 if (!fwcs->cipher)
 397                         continue;
 398
 399                 fw->cs[j++] = *fwcs;
 400         }
 401
 402         return 0;
 403 }
 404
 405 /*
 406  * Gets uCode section from tlv.
 407  */
 408 static int iwl_store_ucode_sec(struct iwl_firmware_pieces *pieces,
 409                                const void *data, enum iwl_ucode_type type,
 410                                int size)
 411 {
 412         struct fw_img_parsing *img;
 413         struct fw_sec *sec;
 414         struct fw_sec_parsing *sec_parse;
 415         size_t alloc_size;
 416
 417         if (WARN_ON(!pieces || !data || type >= IWL_UCODE_TYPE_MAX))
 418                 return -1;
 419
 420         sec_parse = (struct fw_sec_parsing *)data;
 421
 422         img = &pieces->img[type];
 423
 424         alloc_size = sizeof(*img->sec) * (img->sec_counter + 1);
 425         sec = krealloc(img->sec, alloc_size, GFP_KERNEL);
 426         if (!sec)
 427                 return -ENOMEM;
 428         img->sec = sec;
 429
 430         sec = &img->sec[img->sec_counter];
 431
 432         sec->offset = le32_to_cpu(sec_parse->offset);
 433         sec->data = sec_parse->data;
 434         sec->size = size - sizeof(sec_parse->offset);
 435
 436         ++img->sec_counter;
 437
 438         return 0;
 439 }
 440
 441 static int iwl_set_default_calib(struct iwl_drv *drv, const u8 *data)
 442 {
 443         struct iwl_tlv_calib_data *def_calib =
 444                                         (struct iwl_tlv_calib_data *)data;
 445         u32 ucode_type = le32_to_cpu(def_calib->ucode_type);
 446         if (ucode_type >= IWL_UCODE_TYPE_MAX) {
 447                 IWL_ERR(drv, "Wrong ucode_type %u for default calibration.\n",
 448                         ucode_type);
 449                 return -EINVAL;
 450         }
 451         drv->fw.default_calib[ucode_type].flow_trigger =
 452                 def_calib->calib.flow_trigger;
 453         drv->fw.default_calib[ucode_type].event_trigger =
 454                 def_calib->calib.event_trigger;
 455
 456         return 0;
 457 }
 458
 459 static void iwl_set_ucode_api_flags(struct iwl_drv *drv, const u8 *data,
 460                                     struct iwl_ucode_capabilities *capa)
 461 {
 462         const struct iwl_ucode_api *ucode_api = (void *)data;
 463         u32 api_index = le32_to_cpu(ucode_api->api_index);
 464         u32 api_flags = le32_to_cpu(ucode_api->api_flags);
 465         int i;
 466
 467         if (api_index >= DIV_ROUND_UP(NUM_IWL_UCODE_TLV_API, 32)) {
 468                 IWL_WARN(drv,
 469                          "api flags index %d larger than supported by driver\n",
 470                          api_index);
 471                 return;
 472         }
 473
 474         for (i = 0; i < 32; i++) {
 475                 if (api_flags & BIT(i))
 476                         __set_bit(i + 32 * api_index, capa->_api);
 477         }
 478 }
 479
 480 static void iwl_set_ucode_capabilities(struct iwl_drv *drv, const u8 *data,
 481                                        struct iwl_ucode_capabilities *capa)
 482 {
 483         const struct iwl_ucode_capa *ucode_capa = (void *)data;
 484         u32 api_index = le32_to_cpu(ucode_capa->api_index);
 485         u32 api_flags = le32_to_cpu(ucode_capa->api_capa);
 486         int i;
 487
 488         if (api_index >= DIV_ROUND_UP(NUM_IWL_UCODE_TLV_CAPA, 32)) {
 489                 IWL_WARN(drv,
 490                          "capa flags index %d larger than supported by driver\n",
 491                          api_index);
 492                 return;
 493         }
 494
 495         for (i = 0; i < 32; i++) {
 496                 if (api_flags & BIT(i))
 497                         __set_bit(i + 32 * api_index, capa->_capa);
 498         }
 499 }
 500
 501 static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv,
 502                                     const struct firmware *ucode_raw,
 503                                     struct iwl_firmware_pieces *pieces)
 504 {
 505         struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
 506         u32 api_ver, hdr_size, build;
 507         char buildstr[25];
 508         const u8 *src;
 509
 510         drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
 511         api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
 512
 513         switch (api_ver) {
 514         default:
 515                 hdr_size = 28;
 516                 if (ucode_raw->size < hdr_size) {
 517                         IWL_ERR(drv, "File size too small!\n");
 518                         return -EINVAL;
 519                 }
 520                 build = le32_to_cpu(ucode->u.v2.build);
 521                 set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
 522                              le32_to_cpu(ucode->u.v2.inst_size));
 523                 set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
 524                              le32_to_cpu(ucode->u.v2.data_size));
 525                 set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
 526                              le32_to_cpu(ucode->u.v2.init_size));
 527                 set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
 528                              le32_to_cpu(ucode->u.v2.init_data_size));
 529                 src = ucode->u.v2.data;
 530                 break;
 531         case 0:
 532         case 1:
 533         case 2:
 534                 hdr_size = 24;
 535                 if (ucode_raw->size < hdr_size) {
 536                         IWL_ERR(drv, "File size too small!\n");
 537                         return -EINVAL;
 538                 }
 539                 build = 0;
 540                 set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
 541                              le32_to_cpu(ucode->u.v1.inst_size));
 542                 set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
 543                              le32_to_cpu(ucode->u.v1.data_size));
 544                 set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
 545                              le32_to_cpu(ucode->u.v1.init_size));
 546                 set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
 547                              le32_to_cpu(ucode->u.v1.init_data_size));
 548                 src = ucode->u.v1.data;
 549                 break;
 550         }
 551
 552         if (build)
 553                 sprintf(buildstr, " build %u", build);
 554         else
 555                 buildstr[0] = '\0';
 556
 557         snprintf(drv->fw.fw_version,
 558                  sizeof(drv->fw.fw_version),
 559                  "%u.%u.%u.%u%s",
 560                  IWL_UCODE_MAJOR(drv->fw.ucode_ver),
 561                  IWL_UCODE_MINOR(drv->fw.ucode_ver),
 562                  IWL_UCODE_API(drv->fw.ucode_ver),
 563                  IWL_UCODE_SERIAL(drv->fw.ucode_ver),
 564                  buildstr);
 565
 566         /* Verify size of file vs. image size info in file's header */
 567
 568         if (ucode_raw->size != hdr_size +
 569             get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) +
 570             get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) +
 571             get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST) +
 572             get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA)) {
 573
 574                 IWL_ERR(drv,
 575                         "uCode file size %d does not match expected size\n",
 576                         (int)ucode_raw->size);
 577                 return -EINVAL;
 578         }
 579
 580
 581         set_sec_data(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST, src);
 582         src += get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST);
 583         set_sec_offset(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
 584                        IWLAGN_RTC_INST_LOWER_BOUND);
 585         set_sec_data(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA, src);
 586         src += get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA);
 587         set_sec_offset(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
 588                        IWLAGN_RTC_DATA_LOWER_BOUND);
 589         set_sec_data(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST, src);
 590         src += get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST);
 591         set_sec_offset(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
 592                        IWLAGN_RTC_INST_LOWER_BOUND);
 593         set_sec_data(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA, src);
 594         src += get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA);
 595         set_sec_offset(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
 596                        IWLAGN_RTC_DATA_LOWER_BOUND);
 597         return 0;
 598 }
 599
 600 static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
 601                                 const struct firmware *ucode_raw,
 602                                 struct iwl_firmware_pieces *pieces,
 603                                 struct iwl_ucode_capabilities *capa,
 604                                 bool *usniffer_images)
 605 {
 606         struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
 607         struct iwl_ucode_tlv *tlv;
 608         size_t len = ucode_raw->size;
 609         const u8 *data;
 610         u32 tlv_len;
 611         u32 usniffer_img;
 612         enum iwl_ucode_tlv_type tlv_type;
 613         const u8 *tlv_data;
 614         char buildstr[25];
 615         u32 build, paging_mem_size;
 616         int num_of_cpus;
 617         bool usniffer_req = false;
 618
 619         if (len < sizeof(*ucode)) {
 620                 IWL_ERR(drv, "uCode has invalid length: %zd\n", len);
 621                 return -EINVAL;
 622         }
 623
 624         if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
 625                 IWL_ERR(drv, "invalid uCode magic: 0X%x\n",
 626                         le32_to_cpu(ucode->magic));
 627                 return -EINVAL;
 628         }
 629
 630         drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
 631         memcpy(drv->fw.human_readable, ucode->human_readable,
 632                sizeof(drv->fw.human_readable));
 633         build = le32_to_cpu(ucode->build);
 634
 635         if (build)
 636                 sprintf(buildstr, " build %u", build);
 637         else
 638                 buildstr[0] = '\0';
 639
 640         snprintf(drv->fw.fw_version,
 641                  sizeof(drv->fw.fw_version),
 642                  "%u.%u.%u.%u%s",
 643                  IWL_UCODE_MAJOR(drv->fw.ucode_ver),
 644                  IWL_UCODE_MINOR(drv->fw.ucode_ver),
 645                  IWL_UCODE_API(drv->fw.ucode_ver),
 646                  IWL_UCODE_SERIAL(drv->fw.ucode_ver),
 647                  buildstr);
 648
 649         data = ucode->data;
 650
 651         len -= sizeof(*ucode);
 652
 653         while (len >= sizeof(*tlv)) {
 654                 len -= sizeof(*tlv);
 655                 tlv = (void *)data;
 656
 657                 tlv_len = le32_to_cpu(tlv->length);
 658                 tlv_type = le32_to_cpu(tlv->type);
 659                 tlv_data = tlv->data;
 660
 661                 if (len < tlv_len) {
 662                         IWL_ERR(drv, "invalid TLV len: %zd/%u\n",
 663                                 len, tlv_len);
 664                         return -EINVAL;
 665                 }
 666                 len -= ALIGN(tlv_len, 4);
 667                 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
 668
 669                 switch (tlv_type) {
 670                 case IWL_UCODE_TLV_INST:
 671                         set_sec_data(pieces, IWL_UCODE_REGULAR,
 672                                      IWL_UCODE_SECTION_INST, tlv_data);
 673                         set_sec_size(pieces, IWL_UCODE_REGULAR,
 674                                      IWL_UCODE_SECTION_INST, tlv_len);
 675                         set_sec_offset(pieces, IWL_UCODE_REGULAR,
 676                                        IWL_UCODE_SECTION_INST,
 677                                        IWLAGN_RTC_INST_LOWER_BOUND);
 678                         break;
 679                 case IWL_UCODE_TLV_DATA:
 680                         set_sec_data(pieces, IWL_UCODE_REGULAR,
 681                                      IWL_UCODE_SECTION_DATA, tlv_data);
 682                         set_sec_size(pieces, IWL_UCODE_REGULAR,
 683                                      IWL_UCODE_SECTION_DATA, tlv_len);
 684                         set_sec_offset(pieces, IWL_UCODE_REGULAR,
 685                                        IWL_UCODE_SECTION_DATA,
 686                                        IWLAGN_RTC_DATA_LOWER_BOUND);
 687                         break;
 688                 case IWL_UCODE_TLV_INIT:
 689                         set_sec_data(pieces, IWL_UCODE_INIT,
 690                                      IWL_UCODE_SECTION_INST, tlv_data);
 691                         set_sec_size(pieces, IWL_UCODE_INIT,
 692                                      IWL_UCODE_SECTION_INST, tlv_len);
 693                         set_sec_offset(pieces, IWL_UCODE_INIT,
 694                                        IWL_UCODE_SECTION_INST,
 695                                        IWLAGN_RTC_INST_LOWER_BOUND);
 696                         break;
 697                 case IWL_UCODE_TLV_INIT_DATA:
 698                         set_sec_data(pieces, IWL_UCODE_INIT,
 699                                      IWL_UCODE_SECTION_DATA, tlv_data);
 700                         set_sec_size(pieces, IWL_UCODE_INIT,
 701                                      IWL_UCODE_SECTION_DATA, tlv_len);
 702                         set_sec_offset(pieces, IWL_UCODE_INIT,
 703                                        IWL_UCODE_SECTION_DATA,
 704                                        IWLAGN_RTC_DATA_LOWER_BOUND);
 705                         break;
 706                 case IWL_UCODE_TLV_BOOT:
 707                         IWL_ERR(drv, "Found unexpected BOOT ucode\n");
 708                         break;
 709                 case IWL_UCODE_TLV_PROBE_MAX_LEN:
 710                         if (tlv_len != sizeof(u32))
 711                                 goto invalid_tlv_len;
 712                         capa->max_probe_length =
 713                                         le32_to_cpup((__le32 *)tlv_data);
 714                         break;
 715                 case IWL_UCODE_TLV_PAN:
 716                         if (tlv_len)
 717                                 goto invalid_tlv_len;
 718                         capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
 719                         break;
 720                 case IWL_UCODE_TLV_FLAGS:
 721                         /* must be at least one u32 */
 722                         if (tlv_len < sizeof(u32))
 723                                 goto invalid_tlv_len;
 724                         /* and a proper number of u32s */
 725                         if (tlv_len % sizeof(u32))
 726                                 goto invalid_tlv_len;
 727                         /*
 728                          * This driver only reads the first u32 as
 729                          * right now no more features are defined,
 730                          * if that changes then either the driver
 731                          * will not work with the new firmware, or
 732                          * it'll not take advantage of new features.
 733                          */
 734                         capa->flags = le32_to_cpup((__le32 *)tlv_data);
 735                         break;
 736                 case IWL_UCODE_TLV_API_CHANGES_SET:
 737                         if (tlv_len != sizeof(struct iwl_ucode_api))
 738                                 goto invalid_tlv_len;
 739                         iwl_set_ucode_api_flags(drv, tlv_data, capa);
 740                         break;
 741                 case IWL_UCODE_TLV_ENABLED_CAPABILITIES:
 742                         if (tlv_len != sizeof(struct iwl_ucode_capa))
 743                                 goto invalid_tlv_len;
 744                         iwl_set_ucode_capabilities(drv, tlv_data, capa);
 745                         break;
 746                 case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
 747                         if (tlv_len != sizeof(u32))
 748                                 goto invalid_tlv_len;
 749                         pieces->init_evtlog_ptr =
 750                                         le32_to_cpup((__le32 *)tlv_data);
 751                         break;
 752                 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
 753                         if (tlv_len != sizeof(u32))
 754                                 goto invalid_tlv_len;
 755                         pieces->init_evtlog_size =
 756                                         le32_to_cpup((__le32 *)tlv_data);
 757                         break;
 758                 case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
 759                         if (tlv_len != sizeof(u32))
 760                                 goto invalid_tlv_len;
 761                         pieces->init_errlog_ptr =
 762                                         le32_to_cpup((__le32 *)tlv_data);
 763                         break;
 764                 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
 765                         if (tlv_len != sizeof(u32))
 766                                 goto invalid_tlv_len;
 767                         pieces->inst_evtlog_ptr =
 768                                         le32_to_cpup((__le32 *)tlv_data);
 769                         break;
 770                 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
 771                         if (tlv_len != sizeof(u32))
 772                                 goto invalid_tlv_len;
 773                         pieces->inst_evtlog_size =
 774                                         le32_to_cpup((__le32 *)tlv_data);
 775                         break;
 776                 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
 777                         if (tlv_len != sizeof(u32))
 778                                 goto invalid_tlv_len;
 779                         pieces->inst_errlog_ptr =
 780                                         le32_to_cpup((__le32 *)tlv_data);
 781                         break;
 782                 case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
 783                         if (tlv_len)
 784                                 goto invalid_tlv_len;
 785                         drv->fw.enhance_sensitivity_table = true;
 786                         break;
 787                 case IWL_UCODE_TLV_WOWLAN_INST:
 788                         set_sec_data(pieces, IWL_UCODE_WOWLAN,
 789                                      IWL_UCODE_SECTION_INST, tlv_data);
 790                         set_sec_size(pieces, IWL_UCODE_WOWLAN,
 791                                      IWL_UCODE_SECTION_INST, tlv_len);
 792                         set_sec_offset(pieces, IWL_UCODE_WOWLAN,
 793                                        IWL_UCODE_SECTION_INST,
 794                                        IWLAGN_RTC_INST_LOWER_BOUND);
 795                         break;
 796                 case IWL_UCODE_TLV_WOWLAN_DATA:
 797                         set_sec_data(pieces, IWL_UCODE_WOWLAN,
 798                                      IWL_UCODE_SECTION_DATA, tlv_data);
 799                         set_sec_size(pieces, IWL_UCODE_WOWLAN,
 800                                      IWL_UCODE_SECTION_DATA, tlv_len);
 801                         set_sec_offset(pieces, IWL_UCODE_WOWLAN,
 802                                        IWL_UCODE_SECTION_DATA,
 803                                        IWLAGN_RTC_DATA_LOWER_BOUND);
 804                         break;
 805                 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
 806                         if (tlv_len != sizeof(u32))
 807                                 goto invalid_tlv_len;
 808                         capa->standard_phy_calibration_size =
 809                                         le32_to_cpup((__le32 *)tlv_data);
 810                         break;
 811                 case IWL_UCODE_TLV_SEC_RT:
 812                         iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_REGULAR,
 813                                             tlv_len);
 814                         drv->fw.type = IWL_FW_MVM;
 815                         break;
 816                 case IWL_UCODE_TLV_SEC_INIT:
 817                         iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_INIT,
 818                                             tlv_len);
 819                         drv->fw.type = IWL_FW_MVM;
 820                         break;
 821                 case IWL_UCODE_TLV_SEC_WOWLAN:
 822                         iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_WOWLAN,
 823                                             tlv_len);
 824                         drv->fw.type = IWL_FW_MVM;
 825                         break;
 826                 case IWL_UCODE_TLV_DEF_CALIB:
 827                         if (tlv_len != sizeof(struct iwl_tlv_calib_data))
 828                                 goto invalid_tlv_len;
 829                         if (iwl_set_default_calib(drv, tlv_data))
 830                                 goto tlv_error;
 831                         break;
 832                 case IWL_UCODE_TLV_PHY_SKU:
 833                         if (tlv_len != sizeof(u32))
 834                                 goto invalid_tlv_len;
 835                         drv->fw.phy_config = le32_to_cpup((__le32 *)tlv_data);
 836                         drv->fw.valid_tx_ant = (drv->fw.phy_config &
 837                                                 FW_PHY_CFG_TX_CHAIN) >>
 838                                                 FW_PHY_CFG_TX_CHAIN_POS;
 839                         drv->fw.valid_rx_ant = (drv->fw.phy_config &
 840                                                 FW_PHY_CFG_RX_CHAIN) >>
 841                                                 FW_PHY_CFG_RX_CHAIN_POS;
 842                         break;
 843                 case IWL_UCODE_TLV_SECURE_SEC_RT:
 844                         iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_REGULAR,
 845                                             tlv_len);
 846                         drv->fw.type = IWL_FW_MVM;
 847                         break;
 848                 case IWL_UCODE_TLV_SECURE_SEC_INIT:
 849                         iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_INIT,
 850                                             tlv_len);
 851                         drv->fw.type = IWL_FW_MVM;
 852                         break;
 853                 case IWL_UCODE_TLV_SECURE_SEC_WOWLAN:
 854                         iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_WOWLAN,
 855                                             tlv_len);
 856                         drv->fw.type = IWL_FW_MVM;
 857                         break;
 858                 case IWL_UCODE_TLV_NUM_OF_CPU:
 859                         if (tlv_len != sizeof(u32))
 860                                 goto invalid_tlv_len;
 861                         num_of_cpus =
 862                                 le32_to_cpup((__le32 *)tlv_data);
 863
 864                         if (num_of_cpus == 2) {
 865                                 drv->fw.img[IWL_UCODE_REGULAR].is_dual_cpus =
 866                                         true;
 867                                 drv->fw.img[IWL_UCODE_INIT].is_dual_cpus =
 868                                         true;
 869                                 drv->fw.img[IWL_UCODE_WOWLAN].is_dual_cpus =
 870                                         true;
 871                         } else if ((num_of_cpus > 2) || (num_of_cpus < 1)) {
 872                                 IWL_ERR(drv, "Driver support upto 2 CPUs\n");
 873                                 return -EINVAL;
 874                         }
 875                         break;
 876                 case IWL_UCODE_TLV_CSCHEME:
 877                         if (iwl_store_cscheme(&drv->fw, tlv_data, tlv_len))
 878                                 goto invalid_tlv_len;
 879                         break;
 880                 case IWL_UCODE_TLV_N_SCAN_CHANNELS:
 881                         if (tlv_len != sizeof(u32))
 882                                 goto invalid_tlv_len;
 883                         capa->n_scan_channels =
 884                                 le32_to_cpup((__le32 *)tlv_data);
 885                         break;
 886                 case IWL_UCODE_TLV_FW_VERSION: {
 887                         __le32 *ptr = (void *)tlv_data;
 888                         u32 major, minor;
 889                         u8 local_comp;
 890
 891                         if (tlv_len != sizeof(u32) * 3)
 892                                 goto invalid_tlv_len;
 893
 894                         major = le32_to_cpup(ptr++);
 895                         minor = le32_to_cpup(ptr++);
 896                         local_comp = le32_to_cpup(ptr);
 897
 898                         if (major >= 35)
 899                                 snprintf(drv->fw.fw_version,
 900                                          sizeof(drv->fw.fw_version),
 901                                         "%u.%08x.%u", major, minor, local_comp);
 902                         else
 903                                 snprintf(drv->fw.fw_version,
 904                                          sizeof(drv->fw.fw_version),
 905                                         "%u.%u.%u", major, minor, local_comp);
 906                         break;
 907                         }
 908                 case IWL_UCODE_TLV_FW_DBG_DEST: {
 909                         struct iwl_fw_dbg_dest_tlv *dest = NULL;
 910                         struct iwl_fw_dbg_dest_tlv_v1 *dest_v1 = NULL;
 911                         u8 mon_mode;
 912
 913                         pieces->dbg_dest_ver = (u8 *)tlv_data;
 914                         if (*pieces->dbg_dest_ver == 1) {
 915                                 dest = (void *)tlv_data;
 916                         } else if (*pieces->dbg_dest_ver == 0) {
 917                                 dest_v1 = (void *)tlv_data;
 918                         } else {
 919                                 IWL_ERR(drv,
 920                                         "The version is %d, and it is invalid\n",
 921                                         *pieces->dbg_dest_ver);
 922                                 break;
 923                         }
 924
 925                         if (pieces->dbg_dest_tlv_init) {
 926                                 IWL_ERR(drv,
 927                                         "dbg destination ignored, already exists\n");
 928                                 break;
 929                         }
 930
 931                         pieces->dbg_dest_tlv_init = true;
 932
 933                         if (dest_v1) {
 934                                 pieces->dbg_dest_tlv_v1 = dest_v1;
 935                                 mon_mode = dest_v1->monitor_mode;
 936                         } else {
 937                                 pieces->dbg_dest_tlv = dest;
 938                                 mon_mode = dest->monitor_mode;
 939                         }
 940
 941                         IWL_INFO(drv, "Found debug destination: %s\n",
 942                                  get_fw_dbg_mode_string(mon_mode));
 943
 944                         drv->fw.dbg_dest_reg_num = (dest_v1) ?
 945                                 tlv_len -
 946                                 offsetof(struct iwl_fw_dbg_dest_tlv_v1,
 947                                          reg_ops) :
 948                                 tlv_len -
 949                                 offsetof(struct iwl_fw_dbg_dest_tlv,
 950                                          reg_ops);
 951
 952                         drv->fw.dbg_dest_reg_num /=
 953                                 sizeof(drv->fw.dbg_dest_tlv->reg_ops[0]);
 954
 955                         break;
 956                         }
 957                 case IWL_UCODE_TLV_FW_DBG_CONF: {
 958                         struct iwl_fw_dbg_conf_tlv *conf = (void *)tlv_data;
 959
 960                         if (!pieces->dbg_dest_tlv_init) {
 961                                 IWL_ERR(drv,
 962                                         "Ignore dbg config %d - no destination configured\n",
 963                                         conf->id);
 964                                 break;
 965                         }
 966
 967                         if (conf->id >= ARRAY_SIZE(drv->fw.dbg_conf_tlv)) {
 968                                 IWL_ERR(drv,
 969                                         "Skip unknown configuration: %d\n",
 970                                         conf->id);
 971                                 break;
 972                         }
 973
 974                         if (pieces->dbg_conf_tlv[conf->id]) {
 975                                 IWL_ERR(drv,
 976                                         "Ignore duplicate dbg config %d\n",
 977                                         conf->id);
 978                                 break;
 979                         }
 980
 981                         if (conf->usniffer)
 982                                 usniffer_req = true;
 983
 984                         IWL_INFO(drv, "Found debug configuration: %d\n",
 985                                  conf->id);
 986
 987                         pieces->dbg_conf_tlv[conf->id] = conf;
 988                         pieces->dbg_conf_tlv_len[conf->id] = tlv_len;
 989                         break;
 990                         }
 991                 case IWL_UCODE_TLV_FW_DBG_TRIGGER: {
 992                         struct iwl_fw_dbg_trigger_tlv *trigger =
 993                                 (void *)tlv_data;
 994                         u32 trigger_id = le32_to_cpu(trigger->id);
 995
 996                         if (trigger_id >= ARRAY_SIZE(drv->fw.dbg_trigger_tlv)) {
 997                                 IWL_ERR(drv,
 998                                         "Skip unknown trigger: %u\n",
 999                                         trigger->id);
1000                                 break;
1001                         }
1002
1003                         if (pieces->dbg_trigger_tlv[trigger_id]) {
1004                                 IWL_ERR(drv,
1005                                         "Ignore duplicate dbg trigger %u\n",
1006                                         trigger->id);
1007                                 break;
1008                         }
1009
1010                         IWL_INFO(drv, "Found debug trigger: %u\n", trigger->id);
1011
1012                         pieces->dbg_trigger_tlv[trigger_id] = trigger;
1013                         pieces->dbg_trigger_tlv_len[trigger_id] = tlv_len;
1014                         break;
1015                         }
1016                 case IWL_UCODE_TLV_FW_DBG_DUMP_LST: {
1017                         if (tlv_len != sizeof(u32)) {
1018                                 IWL_ERR(drv,
1019                                         "dbg lst mask size incorrect, skip\n");
1020                                 break;
1021                         }
1022
1023                         drv->fw.dbg_dump_mask =
1024                                 le32_to_cpup((__le32 *)tlv_data);
1025                         break;
1026                         }
1027                 case IWL_UCODE_TLV_SEC_RT_USNIFFER:
1028                         *usniffer_images = true;
1029                         iwl_store_ucode_sec(pieces, tlv_data,
1030                                             IWL_UCODE_REGULAR_USNIFFER,
1031                                             tlv_len);
1032                         break;
1033                 case IWL_UCODE_TLV_PAGING:
1034                         if (tlv_len != sizeof(u32))
1035                                 goto invalid_tlv_len;
1036                         paging_mem_size = le32_to_cpup((__le32 *)tlv_data);
1037
1038                         IWL_DEBUG_FW(drv,
1039                                      "Paging: paging enabled (size = %u bytes)\n",
1040                                      paging_mem_size);
1041
1042                         if (paging_mem_size > MAX_PAGING_IMAGE_SIZE) {
1043                                 IWL_ERR(drv,
1044                                         "Paging: driver supports up to %lu bytes for paging image\n",
1045                                         MAX_PAGING_IMAGE_SIZE);
1046                                 return -EINVAL;
1047                         }
1048
1049                         if (paging_mem_size & (FW_PAGING_SIZE - 1)) {
1050                                 IWL_ERR(drv,
1051                                         "Paging: image isn't multiple %lu\n",
1052                                         FW_PAGING_SIZE);
1053                                 return -EINVAL;
1054                         }
1055
1056                         drv->fw.img[IWL_UCODE_REGULAR].paging_mem_size =
1057                                 paging_mem_size;
1058                         usniffer_img = IWL_UCODE_REGULAR_USNIFFER;
1059                         drv->fw.img[usniffer_img].paging_mem_size =
1060                                 paging_mem_size;
1061                         break;
1062                 case IWL_UCODE_TLV_FW_GSCAN_CAPA:
1063                         /* ignored */
1064                         break;
1065                 case IWL_UCODE_TLV_FW_MEM_SEG: {
1066                         struct iwl_fw_dbg_mem_seg_tlv *dbg_mem =
1067                                 (void *)tlv_data;
1068                         u32 type;
1069                         size_t size;
1070                         struct iwl_fw_dbg_mem_seg_tlv *n;
1071
1072                         if (tlv_len != (sizeof(*dbg_mem)))
1073                                 goto invalid_tlv_len;
1074
1075                         type = le32_to_cpu(dbg_mem->data_type);
1076
1077                         IWL_DEBUG_INFO(drv, "Found debug memory segment: %u\n",
1078                                        dbg_mem->data_type);
1079
1080                         switch (type & FW_DBG_MEM_TYPE_MASK) {
1081                         case FW_DBG_MEM_TYPE_REGULAR:
1082                         case FW_DBG_MEM_TYPE_PRPH:
1083                                 /* we know how to handle these */
1084                                 break;
1085                         default:
1086                                 IWL_ERR(drv,
1087                                         "Found debug memory segment with invalid type: 0x%x\n",
1088                                         type);
1089                                 return -EINVAL;
1090                         }
1091
1092                         size = sizeof(*pieces->dbg_mem_tlv) *
1093                                (pieces->n_dbg_mem_tlv + 1);
1094                         n = krealloc(pieces->dbg_mem_tlv, size, GFP_KERNEL);
1095                         if (!n)
1096                                 return -ENOMEM;
1097                         pieces->dbg_mem_tlv = n;
1098                         pieces->dbg_mem_tlv[pieces->n_dbg_mem_tlv] = *dbg_mem;
1099                         pieces->n_dbg_mem_tlv++;
1100                         break;
1101                         }
1102                 case IWL_UCODE_TLV_IML: {
1103                         drv->fw.iml_len = tlv_len;
1104                         drv->fw.iml = kmemdup(tlv_data, tlv_len, GFP_KERNEL);
1105                         if (!drv->fw.iml)
1106                                 return -ENOMEM;
1107                         break;
1108                         }
1109                 default:
1110                         IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type);
1111                         break;
1112                 }
1113         }
1114
1115         if (!fw_has_capa(capa, IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED) &&
1116             usniffer_req && !*usniffer_images) {
1117                 IWL_ERR(drv,
1118                         "user selected to work with usniffer but usniffer image isn't available in ucode package\n");
1119                 return -EINVAL;
1120         }
1121
1122         if (len) {
1123                 IWL_ERR(drv, "invalid TLV after parsing: %zd\n", len);
1124                 iwl_print_hex_dump(drv, IWL_DL_FW, (u8 *)data, len);
1125                 return -EINVAL;
1126         }
1127
1128         return 0;
1129
1130  invalid_tlv_len:
1131         IWL_ERR(drv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
1132  tlv_error:
1133         iwl_print_hex_dump(drv, IWL_DL_FW, tlv_data, tlv_len);
1134
1135         return -EINVAL;
1136 }
1137
1138 static int iwl_alloc_ucode(struct iwl_drv *drv,
1139                            struct iwl_firmware_pieces *pieces,
1140                            enum iwl_ucode_type type)
1141 {
1142         int i;
1143         struct fw_desc *sec;
1144
1145         sec = kcalloc(pieces->img[type].sec_counter, sizeof(*sec), GFP_KERNEL);
1146         if (!sec)
1147                 return -ENOMEM;
1148         drv->fw.img[type].sec = sec;
1149         drv->fw.img[type].num_sec = pieces->img[type].sec_counter;
1150
1151         for (i = 0; i < pieces->img[type].sec_counter; i++)
1152                 if (iwl_alloc_fw_desc(drv, &sec[i], get_sec(pieces, type, i)))
1153                         return -ENOMEM;
1154
1155         return 0;
1156 }
1157
1158 static int validate_sec_sizes(struct iwl_drv *drv,
1159                               struct iwl_firmware_pieces *pieces,
1160                               const struct iwl_cfg *cfg)
1161 {
1162         IWL_DEBUG_INFO(drv, "f/w package hdr runtime inst size = %zd\n",
1163                 get_sec_size(pieces, IWL_UCODE_REGULAR,
1164                              IWL_UCODE_SECTION_INST));
1165         IWL_DEBUG_INFO(drv, "f/w package hdr runtime data size = %zd\n",
1166                 get_sec_size(pieces, IWL_UCODE_REGULAR,
1167                              IWL_UCODE_SECTION_DATA));
1168         IWL_DEBUG_INFO(drv, "f/w package hdr init inst size = %zd\n",
1169                 get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST));
1170         IWL_DEBUG_INFO(drv, "f/w package hdr init data size = %zd\n",
1171                 get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA));
1172
1173         /* Verify that uCode images will fit in card's SRAM. */
1174         if (get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) >
1175             cfg->max_inst_size) {
1176                 IWL_ERR(drv, "uCode instr len %zd too large to fit in\n",
1177                         get_sec_size(pieces, IWL_UCODE_REGULAR,
1178                                      IWL_UCODE_SECTION_INST));
1179                 return -1;
1180         }
1181
1182         if (get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) >
1183             cfg->max_data_size) {
1184                 IWL_ERR(drv, "uCode data len %zd too large to fit in\n",
1185                         get_sec_size(pieces, IWL_UCODE_REGULAR,
1186                                      IWL_UCODE_SECTION_DATA));
1187                 return -1;
1188         }
1189
1190         if (get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST) >
1191              cfg->max_inst_size) {
1192                 IWL_ERR(drv, "uCode init instr len %zd too large to fit in\n",
1193                         get_sec_size(pieces, IWL_UCODE_INIT,
1194                                      IWL_UCODE_SECTION_INST));
1195                 return -1;
1196         }
1197
1198         if (get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA) >
1199             cfg->max_data_size) {
1200                 IWL_ERR(drv, "uCode init data len %zd too large to fit in\n",
1201                         get_sec_size(pieces, IWL_UCODE_REGULAR,
1202                                      IWL_UCODE_SECTION_DATA));
1203                 return -1;
1204         }
1205         return 0;
1206 }
1207
1208 static struct iwl_op_mode *
1209 _iwl_op_mode_start(struct iwl_drv *drv, struct iwlwifi_opmode_table *op)
1210 {
1211         const struct iwl_op_mode_ops *ops = op->ops;
1212         struct dentry *dbgfs_dir = NULL;
1213         struct iwl_op_mode *op_mode = NULL;
1214
1215 #ifdef CONFIG_IWLWIFI_DEBUGFS
1216         drv->dbgfs_op_mode = debugfs_create_dir(op->name,
1217                                                 drv->dbgfs_drv);
1218         if (!drv->dbgfs_op_mode) {
1219                 IWL_ERR(drv,
1220                         "failed to create opmode debugfs directory\n");
1221                 return op_mode;
1222         }
1223         dbgfs_dir = drv->dbgfs_op_mode;
1224 #endif
1225
1226         op_mode = ops->start(drv->trans, drv->trans->cfg, &drv->fw, dbgfs_dir);
1227
1228 #ifdef CONFIG_IWLWIFI_DEBUGFS
1229         if (!op_mode) {
1230                 debugfs_remove_recursive(drv->dbgfs_op_mode);
1231                 drv->dbgfs_op_mode = NULL;
1232         }
1233 #endif
1234
1235         return op_mode;
1236 }
1237
1238 static void _iwl_op_mode_stop(struct iwl_drv *drv)
1239 {
1240         /* op_mode can be NULL if its start failed */
1241         if (drv->op_mode) {
1242                 iwl_op_mode_stop(drv->op_mode);
1243                 drv->op_mode = NULL;
1244
1245 #ifdef CONFIG_IWLWIFI_DEBUGFS
1246                 debugfs_remove_recursive(drv->dbgfs_op_mode);
1247                 drv->dbgfs_op_mode = NULL;
1248 #endif
1249         }
1250 }
1251
1252 /**
1253  * iwl_req_fw_callback - callback when firmware was loaded
1254  *
1255  * If loaded successfully, copies the firmware into buffers
1256  * for the card to fetch (via DMA).
1257  */
1258 static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
1259 {
1260         struct iwl_drv *drv = context;
1261         struct iwl_fw *fw = &drv->fw;
1262         struct iwl_ucode_header *ucode;
1263         struct iwlwifi_opmode_table *op;
1264         int err;
1265         struct iwl_firmware_pieces *pieces;
1266         const unsigned int api_max = drv->trans->cfg->ucode_api_max;
1267         const unsigned int api_min = drv->trans->cfg->ucode_api_min;
1268         size_t trigger_tlv_sz[FW_DBG_TRIGGER_MAX];
1269         u32 api_ver;
1270         int i;
1271         bool load_module = false;
1272         bool usniffer_images = false;
1273
1274         fw->ucode_capa.max_probe_length = IWL_DEFAULT_MAX_PROBE_LENGTH;
1275         fw->ucode_capa.standard_phy_calibration_size =
1276                         IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1277         fw->ucode_capa.n_scan_channels = IWL_DEFAULT_SCAN_CHANNELS;
1278         /* dump all fw memory areas by default */
1279         fw->dbg_dump_mask = 0xffffffff;
1280
1281         pieces = kzalloc(sizeof(*pieces), GFP_KERNEL);
1282         if (!pieces)
1283                 goto out_free_fw;
1284
1285         if (!ucode_raw)
1286                 goto try_again;
1287
1288         IWL_DEBUG_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
1289                        drv->firmware_name, ucode_raw->size);
1290
1291         /* Make sure that we got at least the API version number */
1292         if (ucode_raw->size < 4) {
1293                 IWL_ERR(drv, "File size way too small!\n");
1294                 goto try_again;
1295         }
1296
1297         /* Data from ucode file:  header followed by uCode images */
1298         ucode = (struct iwl_ucode_header *)ucode_raw->data;
1299
1300         if (ucode->ver)
1301                 err = iwl_parse_v1_v2_firmware(drv, ucode_raw, pieces);
1302         else
1303                 err = iwl_parse_tlv_firmware(drv, ucode_raw, pieces,
1304                                              &fw->ucode_capa, &usniffer_images);
1305
1306         if (err)
1307                 goto try_again;
1308
1309         if (fw_has_api(&drv->fw.ucode_capa, IWL_UCODE_TLV_API_NEW_VERSION))
1310                 api_ver = drv->fw.ucode_ver;
1311         else
1312                 api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
1313
1314         /*
1315          * api_ver should match the api version forming part of the
1316          * firmware filename ... but we don't check for that and only rely
1317          * on the API version read from firmware header from here on forward
1318          */
1319         if (api_ver < api_min || api_ver > api_max) {
1320                 IWL_ERR(drv,
1321                         "Driver unable to support your firmware API. "
1322                         "Driver supports v%u, firmware is v%u.\n",
1323                         api_max, api_ver);
1324                 goto try_again;
1325         }
1326
1327         /*
1328          * In mvm uCode there is no difference between data and instructions
1329          * sections.
1330          */
1331         if (fw->type == IWL_FW_DVM && validate_sec_sizes(drv, pieces,
1332                                                          drv->trans->cfg))
1333                 goto try_again;
1334
1335         /* Allocate ucode buffers for card's bus-master loading ... */
1336
1337         /* Runtime instructions and 2 copies of data:
1338          * 1) unmodified from disk
1339          * 2) backup cache for save/restore during power-downs
1340          */
1341         for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
1342                 if (iwl_alloc_ucode(drv, pieces, i))
1343                         goto out_free_fw;
1344
1345         if (pieces->dbg_dest_tlv_init) {
1346                 size_t dbg_dest_size = sizeof(*drv->fw.dbg_dest_tlv) +
1347                         sizeof(drv->fw.dbg_dest_tlv->reg_ops[0]) *
1348                         drv->fw.dbg_dest_reg_num;
1349
1350                 drv->fw.dbg_dest_tlv = kmalloc(dbg_dest_size, GFP_KERNEL);
1351
1352                 if (!drv->fw.dbg_dest_tlv)
1353                         goto out_free_fw;
1354
1355                 if (*pieces->dbg_dest_ver == 0) {
1356                         memcpy(drv->fw.dbg_dest_tlv, pieces->dbg_dest_tlv_v1,
1357                                dbg_dest_size);
1358                 } else {
1359                         struct iwl_fw_dbg_dest_tlv_v1 *dest_tlv =
1360                                 drv->fw.dbg_dest_tlv;
1361
1362                         dest_tlv->version = pieces->dbg_dest_tlv->version;
1363                         dest_tlv->monitor_mode =
1364                                 pieces->dbg_dest_tlv->monitor_mode;
1365                         dest_tlv->size_power =
1366                                 pieces->dbg_dest_tlv->size_power;
1367                         dest_tlv->wrap_count =
1368                                 pieces->dbg_dest_tlv->wrap_count;
1369                         dest_tlv->write_ptr_reg =
1370                                 pieces->dbg_dest_tlv->write_ptr_reg;
1371                         dest_tlv->base_shift =
1372                                 pieces->dbg_dest_tlv->base_shift;
1373                         memcpy(dest_tlv->reg_ops,
1374                                pieces->dbg_dest_tlv->reg_ops,
1375                                sizeof(drv->fw.dbg_dest_tlv->reg_ops[0]) *
1376                                drv->fw.dbg_dest_reg_num);
1377
1378                         /* In version 1 of the destination tlv, which is
1379                          * relevant for internal buffer exclusively,
1380                          * the base address is part of given with the length
1381                          * of the buffer, and the size shift is give instead of
1382                          * end shift. We now store these values in base_reg,
1383                          * and end shift, and when dumping the data we'll
1384                          * manipulate it for extracting both the length and
1385                          * base address */
1386                         dest_tlv->base_reg = pieces->dbg_dest_tlv->cfg_reg;
1387                         dest_tlv->end_shift =
1388                                 pieces->dbg_dest_tlv->size_shift;
1389                 }
1390         }
1391
1392         for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_conf_tlv); i++) {
1393                 if (pieces->dbg_conf_tlv[i]) {
1394                         drv->fw.dbg_conf_tlv_len[i] =
1395                                 pieces->dbg_conf_tlv_len[i];
1396                         drv->fw.dbg_conf_tlv[i] =
1397                                 kmemdup(pieces->dbg_conf_tlv[i],
1398                                         drv->fw.dbg_conf_tlv_len[i],
1399                                         GFP_KERNEL);
1400                         if (!drv->fw.dbg_conf_tlv[i])
1401                                 goto out_free_fw;
1402                 }
1403         }
1404
1405         memset(&trigger_tlv_sz, 0xff, sizeof(trigger_tlv_sz));
1406
1407         trigger_tlv_sz[FW_DBG_TRIGGER_MISSED_BEACONS] =
1408                 sizeof(struct iwl_fw_dbg_trigger_missed_bcon);
1409         trigger_tlv_sz[FW_DBG_TRIGGER_CHANNEL_SWITCH] = 0;
1410         trigger_tlv_sz[FW_DBG_TRIGGER_FW_NOTIF] =
1411                 sizeof(struct iwl_fw_dbg_trigger_cmd);
1412         trigger_tlv_sz[FW_DBG_TRIGGER_MLME] =
1413                 sizeof(struct iwl_fw_dbg_trigger_mlme);
1414         trigger_tlv_sz[FW_DBG_TRIGGER_STATS] =
1415                 sizeof(struct iwl_fw_dbg_trigger_stats);
1416         trigger_tlv_sz[FW_DBG_TRIGGER_RSSI] =
1417                 sizeof(struct iwl_fw_dbg_trigger_low_rssi);
1418         trigger_tlv_sz[FW_DBG_TRIGGER_TXQ_TIMERS] =
1419                 sizeof(struct iwl_fw_dbg_trigger_txq_timer);
1420         trigger_tlv_sz[FW_DBG_TRIGGER_TIME_EVENT] =
1421                 sizeof(struct iwl_fw_dbg_trigger_time_event);
1422         trigger_tlv_sz[FW_DBG_TRIGGER_BA] =
1423                 sizeof(struct iwl_fw_dbg_trigger_ba);
1424         trigger_tlv_sz[FW_DBG_TRIGGER_TDLS] =
1425                 sizeof(struct iwl_fw_dbg_trigger_tdls);
1426
1427         for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_trigger_tlv); i++) {
1428                 if (pieces->dbg_trigger_tlv[i]) {
1429                         /*
1430                          * If the trigger isn't long enough, WARN and exit.
1431                          * Someone is trying to debug something and he won't
1432                          * be able to catch the bug he is trying to chase.
1433                          * We'd better be noisy to be sure he knows what's
1434                          * going on.
1435                          */
1436                         if (WARN_ON(pieces->dbg_trigger_tlv_len[i] <
1437                                     (trigger_tlv_sz[i] +
1438                                      sizeof(struct iwl_fw_dbg_trigger_tlv))))
1439                                 goto out_free_fw;
1440                         drv->fw.dbg_trigger_tlv_len[i] =
1441                                 pieces->dbg_trigger_tlv_len[i];
1442                         drv->fw.dbg_trigger_tlv[i] =
1443                                 kmemdup(pieces->dbg_trigger_tlv[i],
1444                                         drv->fw.dbg_trigger_tlv_len[i],
1445                                         GFP_KERNEL);
1446                         if (!drv->fw.dbg_trigger_tlv[i])
1447                                 goto out_free_fw;
1448                 }
1449         }
1450
1451         /* Now that we can no longer fail, copy information */
1452
1453         drv->fw.dbg_mem_tlv = pieces->dbg_mem_tlv;
1454         pieces->dbg_mem_tlv = NULL;
1455         drv->fw.n_dbg_mem_tlv = pieces->n_dbg_mem_tlv;
1456
1457         /*
1458          * The (size - 16) / 12 formula is based on the information recorded
1459          * for each event, which is of mode 1 (including timestamp) for all
1460          * new microcodes that include this information.
1461          */
1462         fw->init_evtlog_ptr = pieces->init_evtlog_ptr;
1463         if (pieces->init_evtlog_size)
1464                 fw->init_evtlog_size = (pieces->init_evtlog_size - 16)/12;
1465         else
1466                 fw->init_evtlog_size =
1467                         drv->trans->cfg->base_params->max_event_log_size;
1468         fw->init_errlog_ptr = pieces->init_errlog_ptr;
1469         fw->inst_evtlog_ptr = pieces->inst_evtlog_ptr;
1470         if (pieces->inst_evtlog_size)
1471                 fw->inst_evtlog_size = (pieces->inst_evtlog_size - 16)/12;
1472         else
1473                 fw->inst_evtlog_size =
1474                         drv->trans->cfg->base_params->max_event_log_size;
1475         fw->inst_errlog_ptr = pieces->inst_errlog_ptr;
1476
1477         /*
1478          * figure out the offset of chain noise reset and gain commands
1479          * base on the size of standard phy calibration commands table size
1480          */
1481         if (fw->ucode_capa.standard_phy_calibration_size >
1482             IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
1483                 fw->ucode_capa.standard_phy_calibration_size =
1484                         IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1485
1486         /* We have our copies now, allow OS release its copies */
1487         release_firmware(ucode_raw);
1488
1489         mutex_lock(&iwlwifi_opmode_table_mtx);
1490         switch (fw->type) {
1491         case IWL_FW_DVM:
1492                 op = &iwlwifi_opmode_table[DVM_OP_MODE];
1493                 break;
1494         default:
1495                 WARN(1, "Invalid fw type %d\n", fw->type);
1496         case IWL_FW_MVM:
1497                 op = &iwlwifi_opmode_table[MVM_OP_MODE];
1498                 break;
1499         }
1500
1501         IWL_INFO(drv, "loaded firmware version %s op_mode %s\n",
1502                  drv->fw.fw_version, op->name);
1503
1504         /* add this device to the list of devices using this op_mode */
1505         list_add_tail(&drv->list, &op->drv);
1506
1507         if (op->ops) {
1508                 drv->op_mode = _iwl_op_mode_start(drv, op);
1509
1510                 if (!drv->op_mode) {
1511                         mutex_unlock(&iwlwifi_opmode_table_mtx);
1512                         goto out_unbind;
1513                 }
1514         } else {
1515                 load_module = true;
1516         }
1517         mutex_unlock(&iwlwifi_opmode_table_mtx);
1518
1519         /*
1520          * Complete the firmware request last so that
1521          * a driver unbind (stop) doesn't run while we
1522          * are doing the start() above.
1523          */
1524         complete(&drv->request_firmware_complete);
1525
1526         /*
1527          * Load the module last so we don't block anything
1528          * else from proceeding if the module fails to load
1529          * or hangs loading.
1530          */
1531         if (load_module) {
1532                 request_module("%s", op->name);
1533 #ifdef CONFIG_IWLWIFI_OPMODE_MODULAR
1534                 if (err)
1535                         IWL_ERR(drv,
1536                                 "failed to load module %s (error %d), is dynamic loading enabled?\n",
1537                                 op->name, err);
1538 #endif
1539         }
1540         goto free;
1541
1542  try_again:
1543         /* try next, if any */
1544         release_firmware(ucode_raw);
1545         if (iwl_request_firmware(drv, false))
1546                 goto out_unbind;
1547         goto free;
1548
1549  out_free_fw:
1550         release_firmware(ucode_raw);
1551  out_unbind:
1552         complete(&drv->request_firmware_complete);
1553         device_release_driver(drv->trans->dev);
1554  free:
1555         if (pieces) {
1556                 for (i = 0; i < ARRAY_SIZE(pieces->img); i++)
1557                         kfree(pieces->img[i].sec);
1558                 kfree(pieces->dbg_mem_tlv);
1559                 kfree(pieces);
1560         }
1561 }
1562
1563 struct iwl_drv *iwl_drv_start(struct iwl_trans *trans)
1564 {
1565         struct iwl_drv *drv;
1566         int ret;
1567
1568         drv = kzalloc(sizeof(*drv), GFP_KERNEL);
1569         if (!drv) {
1570                 ret = -ENOMEM;
1571                 goto err;
1572         }
1573
1574         drv->trans = trans;
1575         drv->dev = trans->dev;
1576
1577         init_completion(&drv->request_firmware_complete);
1578         INIT_LIST_HEAD(&drv->list);
1579
1580 #ifdef CONFIG_IWLWIFI_DEBUGFS
1581         /* Create the device debugfs entries. */
1582         drv->dbgfs_drv = debugfs_create_dir(dev_name(trans->dev),
1583                                             iwl_dbgfs_root);
1584
1585         if (!drv->dbgfs_drv) {
1586                 IWL_ERR(drv, "failed to create debugfs directory\n");
1587                 ret = -ENOMEM;
1588                 goto err_free_drv;
1589         }
1590
1591         /* Create transport layer debugfs dir */
1592         drv->trans->dbgfs_dir = debugfs_create_dir("trans", drv->dbgfs_drv);
1593
1594         if (!drv->trans->dbgfs_dir) {
1595                 IWL_ERR(drv, "failed to create transport debugfs directory\n");
1596                 ret = -ENOMEM;
1597                 goto err_free_dbgfs;
1598         }
1599 #endif
1600
1601         ret = iwl_request_firmware(drv, true);
1602         if (ret) {
1603                 IWL_ERR(trans, "Couldn't request the fw\n");
1604                 goto err_fw;
1605         }
1606
1607         return drv;
1608
1609 err_fw:
1610 #ifdef CONFIG_IWLWIFI_DEBUGFS
1611 err_free_dbgfs:
1612         debugfs_remove_recursive(drv->dbgfs_drv);
1613 err_free_drv:
1614 #endif
1615         kfree(drv);
1616 err:
1617         return ERR_PTR(ret);
1618 }
1619
1620 void iwl_drv_stop(struct iwl_drv *drv)
1621 {
1622         wait_for_completion(&drv->request_firmware_complete);
1623
1624         _iwl_op_mode_stop(drv);
1625
1626         iwl_dealloc_ucode(drv);
1627
1628         mutex_lock(&iwlwifi_opmode_table_mtx);
1629         /*
1630          * List is empty (this item wasn't added)
1631          * when firmware loading failed -- in that
1632          * case we can't remove it from any list.
1633          */
1634         if (!list_empty(&drv->list))
1635                 list_del(&drv->list);
1636         mutex_unlock(&iwlwifi_opmode_table_mtx);
1637
1638 #ifdef CONFIG_IWLWIFI_DEBUGFS
1639         debugfs_remove_recursive(drv->dbgfs_drv);
1640 #endif
1641
1642         kfree(drv);
1643 }
1644
1645
1646 /* shared module parameters */
1647 struct iwl_mod_params iwlwifi_mod_params = {
1648         .fw_restart = true,
1649         .bt_coex_active = true,
1650         .power_level = IWL_POWER_INDEX_1,
1651         .d0i3_disable = true,
1652         .d0i3_timeout = 1000,
1653         .uapsd_disable = IWL_DISABLE_UAPSD_BSS | IWL_DISABLE_UAPSD_P2P_CLIENT,
1654         /* the rest are 0 by default */
1655 };
1656 IWL_EXPORT_SYMBOL(iwlwifi_mod_params);
1657
1658 int iwl_opmode_register(const char *name, const struct iwl_op_mode_ops *ops)
1659 {
1660         int i;
1661         struct iwl_drv *drv;
1662         struct iwlwifi_opmode_table *op;
1663
1664         mutex_lock(&iwlwifi_opmode_table_mtx);
1665         for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++) {
1666                 op = &iwlwifi_opmode_table[i];
1667                 if (strcmp(op->name, name))
1668                         continue;
1669                 op->ops = ops;
1670                 /* TODO: need to handle exceptional case */
1671                 list_for_each_entry(drv, &op->drv, list)
1672                         drv->op_mode = _iwl_op_mode_start(drv, op);
1673
1674                 mutex_unlock(&iwlwifi_opmode_table_mtx);
1675                 return 0;
1676         }
1677         mutex_unlock(&iwlwifi_opmode_table_mtx);
1678         return -EIO;
1679 }
1680 IWL_EXPORT_SYMBOL(iwl_opmode_register);
1681
1682 void iwl_opmode_deregister(const char *name)
1683 {
1684         int i;
1685         struct iwl_drv *drv;
1686
1687         mutex_lock(&iwlwifi_opmode_table_mtx);
1688         for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++) {
1689                 if (strcmp(iwlwifi_opmode_table[i].name, name))
1690                         continue;
1691                 iwlwifi_opmode_table[i].ops = NULL;
1692
1693                 /* call the stop routine for all devices */
1694                 list_for_each_entry(drv, &iwlwifi_opmode_table[i].drv, list)
1695                         _iwl_op_mode_stop(drv);
1696
1697                 mutex_unlock(&iwlwifi_opmode_table_mtx);
1698                 return;
1699         }
1700         mutex_unlock(&iwlwifi_opmode_table_mtx);
1701 }
1702 IWL_EXPORT_SYMBOL(iwl_opmode_deregister);
1703
1704 static int __init iwl_drv_init(void)
1705 {
1706         int i;
1707
1708         mutex_init(&iwlwifi_opmode_table_mtx);
1709
1710         for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++)
1711                 INIT_LIST_HEAD(&iwlwifi_opmode_table[i].drv);
1712
1713         pr_info(DRV_DESCRIPTION "\n");
1714         pr_info(DRV_COPYRIGHT "\n");
1715
1716 #ifdef CONFIG_IWLWIFI_DEBUGFS
1717         /* Create the root of iwlwifi debugfs subsystem. */
1718         iwl_dbgfs_root = debugfs_create_dir(DRV_NAME, NULL);
1719
1720         if (!iwl_dbgfs_root)
1721                 return -EFAULT;
1722 #endif
1723
1724         return iwl_pci_register_driver();
1725 }
1726 module_init(iwl_drv_init);
1727
1728 static void __exit iwl_drv_exit(void)
1729 {
1730         iwl_pci_unregister_driver();
1731
1732 #ifdef CONFIG_IWLWIFI_DEBUGFS
1733         debugfs_remove_recursive(iwl_dbgfs_root);
1734 #endif
1735 }
1736 module_exit(iwl_drv_exit);
1737
1738 #ifdef CONFIG_IWLWIFI_DEBUG
1739 module_param_named(debug, iwlwifi_mod_params.debug_level, uint, 0644);
1740 MODULE_PARM_DESC(debug, "debug output mask");
1741 #endif
1742
1743 module_param_named(swcrypto, iwlwifi_mod_params.swcrypto, int, 0444);
1744 MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
1745 module_param_named(11n_disable, iwlwifi_mod_params.disable_11n, uint, 0444);
1746 MODULE_PARM_DESC(11n_disable,
1747         "disable 11n functionality, bitmap: 1: full, 2: disable agg TX, 4: disable agg RX, 8 enable agg TX");
1748 module_param_named(amsdu_size, iwlwifi_mod_params.amsdu_size, int, 0444);
1749 MODULE_PARM_DESC(amsdu_size,
1750                  "amsdu size 0: 12K for multi Rx queue devices, 2K for 22560 devices, "
1751                  "4K for other devices 1:4K 2:8K 3:12K 4: 2K (default 0)");
1752 module_param_named(fw_restart, iwlwifi_mod_params.fw_restart, bool, 0444);
1753 MODULE_PARM_DESC(fw_restart, "restart firmware in case of error (default true)");
1754
1755 module_param_named(antenna_coupling, iwlwifi_mod_params.antenna_coupling,
1756                    int, 0444);
1757 MODULE_PARM_DESC(antenna_coupling,
1758                  "specify antenna coupling in dB (default: 0 dB)");
1759
1760 module_param_named(nvm_file, iwlwifi_mod_params.nvm_file, charp, 0444);
1761 MODULE_PARM_DESC(nvm_file, "NVM file name");
1762
1763 module_param_named(d0i3_disable, iwlwifi_mod_params.d0i3_disable, bool, 0444);
1764 MODULE_PARM_DESC(d0i3_disable, "disable d0i3 functionality (default: Y)");
1765
1766 module_param_named(lar_disable, iwlwifi_mod_params.lar_disable, bool, 0444);
1767 MODULE_PARM_DESC(lar_disable, "disable LAR functionality (default: N)");
1768
1769 module_param_named(uapsd_disable, iwlwifi_mod_params.uapsd_disable, uint, 0644);
1770 MODULE_PARM_DESC(uapsd_disable,
1771                  "disable U-APSD functionality bitmap 1: BSS 2: P2P Client (default: 3)");
1772
1773 /*
1774  * set bt_coex_active to true, uCode will do kill/defer
1775  * every time the priority line is asserted (BT is sending signals on the
1776  * priority line in the PCIx).
1777  * set bt_coex_active to false, uCode will ignore the BT activity and
1778  * perform the normal operation
1779  *
1780  * User might experience transmit issue on some platform due to WiFi/BT
1781  * co-exist problem. The possible behaviors are:
1782  *   Able to scan and finding all the available AP
1783  *   Not able to associate with any AP
1784  * On those platforms, WiFi communication can be restored by set
1785  * "bt_coex_active" module parameter to "false"
1786  *
1787  * default: bt_coex_active = true (BT_COEX_ENABLE)
1788  */
1789 module_param_named(bt_coex_active, iwlwifi_mod_params.bt_coex_active,
1790                    bool, 0444);
1791 MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)");
1792
1793 module_param_named(led_mode, iwlwifi_mod_params.led_mode, int, 0444);
1794 MODULE_PARM_DESC(led_mode, "0=system default, "
1795                 "1=On(RF On)/Off(RF Off), 2=blinking, 3=Off (default: 0)");
1796
1797 module_param_named(power_save, iwlwifi_mod_params.power_save, bool, 0444);
1798 MODULE_PARM_DESC(power_save,
1799                  "enable WiFi power management (default: disable)");
1800
1801 module_param_named(power_level, iwlwifi_mod_params.power_level, int, 0444);
1802 MODULE_PARM_DESC(power_level,
1803                  "default power save level (range from 1 - 5, default: 1)");
1804
1805 module_param_named(fw_monitor, iwlwifi_mod_params.fw_monitor, bool, 0444);
1806 MODULE_PARM_DESC(fw_monitor,
1807                  "firmware monitor - to debug FW (default: false - needs lots of memory)");
1808
1809 module_param_named(d0i3_timeout, iwlwifi_mod_params.d0i3_timeout, uint, 0444);
1810 MODULE_PARM_DESC(d0i3_timeout, "Timeout to D0i3 entry when idle (ms)");
1811
1812 module_param_named(disable_11ac, iwlwifi_mod_params.disable_11ac, bool, 0444);
1813 MODULE_PARM_DESC(disable_11ac, "Disable VHT capabilities (default: false)");
1814
1815 module_param_named(remove_when_gone,
1816                    iwlwifi_mod_params.remove_when_gone, bool,
1817                    0444);
1818 MODULE_PARM_DESC(remove_when_gone,
1819                  "Remove dev from PCIe bus if it is deemed inaccessible (default: false)");
1820
1821 module_param_named(disable_11ax, iwlwifi_mod_params.disable_11ax, bool,
1822                    S_IRUGO);
1823 MODULE_PARM_DESC(disable_11ax, "Disable HE capabilities (default: false)");