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