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