1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* 3 * Copyright (C) 2005-2014, 2018-2025 Intel Corporation 4 * Copyright (C) 2013-2015 Intel Mobile Communications GmbH 5 * Copyright (C) 2016-2017 Intel Deutschland GmbH 6 */ 7 #include <linux/completion.h> 8 #include <linux/dma-mapping.h> 9 #include <linux/firmware.h> 10 #include <linux/module.h> 11 #include <linux/vmalloc.h> 12 13 #include "iwl-drv.h" 14 #include "iwl-csr.h" 15 #include "iwl-debug.h" 16 #include "iwl-trans.h" 17 #include "iwl-op-mode.h" 18 #include "iwl-agn-hw.h" 19 #include "fw/img.h" 20 #include "iwl-dbg-tlv.h" 21 #include "iwl-config.h" 22 #include "iwl-modparams.h" 23 #include "fw/api/alive.h" 24 #include "fw/api/mac.h" 25 #include "fw/api/mac-cfg.h" 26 27 /****************************************************************************** 28 * 29 * module boiler plate 30 * 31 ******************************************************************************/ 32 33 #define DRV_DESCRIPTION "Intel(R) Wireless WiFi driver for Linux" 34 MODULE_DESCRIPTION(DRV_DESCRIPTION); 35 MODULE_LICENSE("GPL"); 36 37 #ifdef CONFIG_IWLWIFI_DEBUGFS 38 static struct dentry *iwl_dbgfs_root; 39 #endif 40 41 /** 42 * struct iwl_drv - drv common data 43 * @list: list of drv structures using this opmode 44 * @fw: the iwl_fw structure 45 * @op_mode: the running op_mode 46 * @trans: transport layer 47 * @dev: for debug prints only 48 * @fw_index: firmware revision to try loading 49 * @firmware_name: composite filename of ucode file to load 50 * @request_firmware_complete: the firmware has been obtained from user space 51 * @dbgfs_drv: debugfs root directory entry 52 * @dbgfs_trans: debugfs transport directory entry 53 * @dbgfs_op_mode: debugfs op_mode directory entry 54 */ 55 struct iwl_drv { 56 struct list_head list; 57 struct iwl_fw fw; 58 59 struct iwl_op_mode *op_mode; 60 struct iwl_trans *trans; 61 struct device *dev; 62 63 int fw_index; /* firmware we're trying to load */ 64 char firmware_name[64]; /* name of firmware file to load */ 65 66 struct completion request_firmware_complete; 67 68 #ifdef CONFIG_IWLWIFI_DEBUGFS 69 struct dentry *dbgfs_drv; 70 struct dentry *dbgfs_trans; 71 struct dentry *dbgfs_op_mode; 72 #endif 73 }; 74 75 enum { 76 DVM_OP_MODE, 77 MVM_OP_MODE, 78 #if IS_ENABLED(CONFIG_IWLMLD) 79 MLD_OP_MODE, 80 #endif 81 }; 82 83 /* Protects the table contents, i.e. the ops pointer & drv list */ 84 static DEFINE_MUTEX(iwlwifi_opmode_table_mtx); 85 static struct iwlwifi_opmode_table { 86 const char *name; /* name: iwldvm, iwlmvm, etc */ 87 const struct iwl_op_mode_ops *ops; /* pointer to op_mode ops */ 88 struct list_head drv; /* list of devices using this op_mode */ 89 } iwlwifi_opmode_table[] = { /* ops set when driver is initialized */ 90 [DVM_OP_MODE] = { .name = "iwldvm", .ops = NULL }, 91 [MVM_OP_MODE] = { .name = "iwlmvm", .ops = NULL }, 92 #if IS_ENABLED(CONFIG_IWLMLD) 93 [MLD_OP_MODE] = { .name = "iwlmld", .ops = NULL }, 94 #endif 95 }; 96 97 #define IWL_DEFAULT_SCAN_CHANNELS 40 98 99 /* 100 * struct fw_sec: Just for the image parsing process. 101 * For the fw storage we are using struct fw_desc. 102 */ 103 struct fw_sec { 104 const void *data; /* the sec data */ 105 size_t size; /* section size */ 106 u32 offset; /* offset of writing in the device */ 107 }; 108 109 static void iwl_free_fw_desc(struct iwl_drv *drv, struct fw_desc *desc) 110 { 111 vfree(desc->data); 112 desc->data = NULL; 113 desc->len = 0; 114 } 115 116 static void iwl_free_fw_img(struct iwl_drv *drv, struct fw_img *img) 117 { 118 int i; 119 for (i = 0; i < img->num_sec; i++) 120 iwl_free_fw_desc(drv, &img->sec[i]); 121 kfree(img->sec); 122 } 123 124 static void iwl_dealloc_ucode(struct iwl_drv *drv) 125 { 126 int i; 127 128 kfree(drv->fw.dbg.dest_tlv); 129 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++) 130 kfree(drv->fw.dbg.conf_tlv[i]); 131 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++) 132 kfree(drv->fw.dbg.trigger_tlv[i]); 133 kfree(drv->fw.dbg.mem_tlv); 134 kfree(drv->fw.iml); 135 kfree(drv->fw.ucode_capa.cmd_versions); 136 kfree(drv->fw.ucode_capa.cmd_bios_tables); 137 kfree(drv->fw.phy_integration_ver); 138 kfree(drv->trans->dbg.pc_data); 139 drv->trans->dbg.pc_data = NULL; 140 kvfree(drv->fw.pnvm_data); 141 drv->fw.pnvm_data = NULL; 142 drv->fw.pnvm_size = 0; 143 144 for (i = 0; i < IWL_UCODE_TYPE_MAX; i++) 145 iwl_free_fw_img(drv, drv->fw.img + i); 146 147 /* clear the data for the aborted load case */ 148 memset(&drv->fw, 0, sizeof(drv->fw)); 149 } 150 151 static int iwl_alloc_fw_desc(struct fw_desc *desc, struct fw_sec *sec) 152 { 153 void *data; 154 155 desc->data = NULL; 156 157 if (!sec || !sec->size) 158 return -EINVAL; 159 160 data = vmalloc(sec->size); 161 if (!data) 162 return -ENOMEM; 163 164 desc->len = sec->size; 165 desc->offset = sec->offset; 166 memcpy(data, sec->data, desc->len); 167 desc->data = data; 168 169 return 0; 170 } 171 172 static inline char iwl_drv_get_step(int step) 173 { 174 if (step == SILICON_Z_STEP) 175 return 'z'; 176 if (step == SILICON_TC_STEP) 177 return 'a'; 178 return 'a' + step; 179 } 180 181 bool iwl_drv_is_wifi7_supported(struct iwl_trans *trans) 182 { 183 return trans->mac_cfg->device_family >= IWL_DEVICE_FAMILY_BZ && 184 CSR_HW_RFID_TYPE(trans->info.hw_rf_id) >= IWL_CFG_RF_TYPE_FM; 185 } 186 187 const char *iwl_drv_get_fwname_pre(struct iwl_trans *trans, char *buf) 188 { 189 char mac_step, rf_step; 190 const char *mac, *rf, *cdb; 191 192 if (trans->cfg->fw_name_pre) 193 return trans->cfg->fw_name_pre; 194 195 mac_step = iwl_drv_get_step(trans->info.hw_rev_step); 196 197 switch (CSR_HW_REV_TYPE(trans->info.hw_rev)) { 198 case IWL_CFG_MAC_TYPE_PU: 199 mac = "9000-pu"; 200 mac_step = 'b'; 201 break; 202 case IWL_CFG_MAC_TYPE_TH: 203 mac = "9260-th"; 204 mac_step = 'b'; 205 break; 206 case IWL_CFG_MAC_TYPE_QU: 207 mac = "Qu"; 208 break; 209 case IWL_CFG_MAC_TYPE_CC: 210 /* special case - no RF since it's fixed (discrete) */ 211 scnprintf(buf, FW_NAME_PRE_BUFSIZE, "iwlwifi-cc-a0"); 212 return buf; 213 case IWL_CFG_MAC_TYPE_QUZ: 214 mac = "QuZ"; 215 /* all QuZ use A0 firmware */ 216 mac_step = 'a'; 217 break; 218 case IWL_CFG_MAC_TYPE_SO: 219 case IWL_CFG_MAC_TYPE_SOF: 220 mac = "so"; 221 mac_step = 'a'; 222 break; 223 case IWL_CFG_MAC_TYPE_TY: 224 mac = "ty"; 225 mac_step = 'a'; 226 break; 227 case IWL_CFG_MAC_TYPE_MA: 228 mac = "ma"; 229 break; 230 case IWL_CFG_MAC_TYPE_BZ: 231 case IWL_CFG_MAC_TYPE_BZ_W: 232 mac = "bz"; 233 break; 234 case IWL_CFG_MAC_TYPE_GL: 235 mac = "gl"; 236 break; 237 case IWL_CFG_MAC_TYPE_SC: 238 mac = "sc"; 239 break; 240 case IWL_CFG_MAC_TYPE_SC2: 241 /* Uses the same firmware as SC2 */ 242 case IWL_CFG_MAC_TYPE_SC2F: 243 mac = "sc2"; 244 break; 245 case IWL_CFG_MAC_TYPE_BR: 246 mac = "br"; 247 break; 248 case IWL_CFG_MAC_TYPE_DR: 249 mac = "dr"; 250 break; 251 default: 252 return "unknown-mac"; 253 } 254 255 rf_step = iwl_drv_get_step(CSR_HW_RFID_STEP(trans->info.hw_rf_id)); 256 257 switch (CSR_HW_RFID_TYPE(trans->info.hw_rf_id)) { 258 case IWL_CFG_RF_TYPE_JF1: 259 case IWL_CFG_RF_TYPE_JF2: 260 rf = "jf"; 261 rf_step = 'b'; 262 break; 263 case IWL_CFG_RF_TYPE_HR1: 264 case IWL_CFG_RF_TYPE_HR2: 265 rf = "hr"; 266 rf_step = 'b'; 267 break; 268 case IWL_CFG_RF_TYPE_GF: 269 rf = "gf"; 270 rf_step = 'a'; 271 break; 272 case IWL_CFG_RF_TYPE_FM: 273 rf = "fm"; 274 break; 275 case IWL_CFG_RF_TYPE_WH: 276 rf = "wh"; 277 break; 278 case IWL_CFG_RF_TYPE_PE: 279 rf = "pe"; 280 break; 281 default: 282 return "unknown-rf"; 283 } 284 285 cdb = CSR_HW_RFID_IS_CDB(trans->info.hw_rf_id) ? "4" : ""; 286 287 scnprintf(buf, FW_NAME_PRE_BUFSIZE, 288 "iwlwifi-%s-%c0-%s%s-%c0", 289 mac, mac_step, rf, cdb, rf_step); 290 291 return buf; 292 } 293 IWL_EXPORT_SYMBOL(iwl_drv_get_fwname_pre); 294 295 static void iwl_req_fw_callback(const struct firmware *ucode_raw, 296 void *context); 297 298 static void iwl_get_ucode_api_versions(struct iwl_trans *trans, 299 unsigned int *api_min, 300 unsigned int *api_max) 301 { 302 const struct iwl_family_base_params *base = trans->mac_cfg->base; 303 const struct iwl_rf_cfg *cfg = trans->cfg; 304 305 /* if the MAC doesn't have range or if its range it higher than the RF's */ 306 if (!base->ucode_api_max || 307 (cfg->ucode_api_max && base->ucode_api_min > cfg->ucode_api_max)) { 308 *api_min = cfg->ucode_api_min; 309 *api_max = cfg->ucode_api_max; 310 return; 311 } 312 313 /* if the RF doesn't have range or if its range it higher than the MAC's */ 314 if (!cfg->ucode_api_max || 315 (base->ucode_api_max && cfg->ucode_api_min > base->ucode_api_max)) { 316 *api_min = base->ucode_api_min; 317 *api_max = base->ucode_api_max; 318 return; 319 } 320 321 *api_min = max(cfg->ucode_api_min, base->ucode_api_min); 322 *api_max = min(cfg->ucode_api_max, base->ucode_api_max); 323 } 324 325 static int iwl_request_firmware(struct iwl_drv *drv, bool first) 326 { 327 char _fw_name_pre[FW_NAME_PRE_BUFSIZE]; 328 unsigned int ucode_api_max, ucode_api_min; 329 const char *fw_name_pre; 330 331 iwl_get_ucode_api_versions(drv->trans, &ucode_api_min, &ucode_api_max); 332 333 if (drv->trans->mac_cfg->device_family == IWL_DEVICE_FAMILY_9000 && 334 (drv->trans->info.hw_rev_step != SILICON_B_STEP && 335 drv->trans->info.hw_rev_step != SILICON_C_STEP)) { 336 IWL_ERR(drv, 337 "Only HW steps B and C are currently supported (0x%0x)\n", 338 drv->trans->info.hw_rev); 339 return -EINVAL; 340 } 341 342 if (CSR_HW_RFID_TYPE(drv->trans->info.hw_rf_id) == IWL_CFG_RF_TYPE_WH && 343 CSR_HW_RFID_STEP(drv->trans->info.hw_rf_id) == SILICON_A_STEP) { 344 IWL_ERR(drv, "WH A step is not supported\n"); 345 return -EINVAL; 346 } 347 348 fw_name_pre = iwl_drv_get_fwname_pre(drv->trans, _fw_name_pre); 349 350 if (first) 351 drv->fw_index = ucode_api_max; 352 else if (drv->fw_index == ENCODE_CORE_AS_API(100)) 353 drv->fw_index = 102; /* last API-scheme number below core 100 */ 354 else 355 drv->fw_index--; 356 357 if (drv->fw_index < ucode_api_min) { 358 IWL_ERR(drv, "no suitable firmware found!\n"); 359 360 if (ucode_api_min == ucode_api_max) { 361 IWL_ERR(drv, "%s-" FW_API_FMT " is required\n", 362 fw_name_pre, FW_API_ARG(ucode_api_max)); 363 } else { 364 IWL_ERR(drv, 365 "minimum version required: %s-" FW_API_FMT "\n", 366 fw_name_pre, FW_API_ARG(ucode_api_min)); 367 IWL_ERR(drv, 368 "maximum version supported: %s-" FW_API_FMT "\n", 369 fw_name_pre, FW_API_ARG(ucode_api_max)); 370 } 371 372 IWL_ERR(drv, 373 "check git://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git\n"); 374 return -ENOENT; 375 } 376 377 snprintf(drv->firmware_name, sizeof(drv->firmware_name), 378 "%s-" FW_API_FMT ".ucode", 379 fw_name_pre, FW_API_ARG(drv->fw_index)); 380 381 IWL_DEBUG_FW_INFO(drv, "attempting to load firmware '%s'\n", 382 drv->firmware_name); 383 384 return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name, 385 drv->trans->dev, 386 GFP_KERNEL, drv, iwl_req_fw_callback); 387 } 388 389 struct fw_img_parsing { 390 struct fw_sec *sec; 391 int sec_counter; 392 }; 393 394 /* 395 * struct fw_sec_parsing: to extract fw section and it's offset from tlv 396 */ 397 struct fw_sec_parsing { 398 __le32 offset; 399 const u8 data[]; 400 } __packed; 401 402 /** 403 * struct iwl_tlv_calib_data - parse the default calib data from TLV 404 * 405 * @ucode_type: the uCode to which the following default calib relates. 406 * @calib: default calibrations. 407 */ 408 struct iwl_tlv_calib_data { 409 __le32 ucode_type; 410 struct iwl_tlv_calib_ctrl calib; 411 } __packed; 412 413 struct iwl_firmware_pieces { 414 struct fw_img_parsing img[IWL_UCODE_TYPE_MAX]; 415 416 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr; 417 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr; 418 419 /* FW debug data parsed for driver usage */ 420 bool dbg_dest_tlv_init; 421 const u8 *dbg_dest_ver; 422 union { 423 const struct iwl_fw_dbg_dest_tlv *dbg_dest_tlv; 424 const struct iwl_fw_dbg_dest_tlv_v1 *dbg_dest_tlv_v1; 425 }; 426 const struct iwl_fw_dbg_conf_tlv *dbg_conf_tlv[FW_DBG_CONF_MAX]; 427 size_t dbg_conf_tlv_len[FW_DBG_CONF_MAX]; 428 const struct iwl_fw_dbg_trigger_tlv *dbg_trigger_tlv[FW_DBG_TRIGGER_MAX]; 429 size_t dbg_trigger_tlv_len[FW_DBG_TRIGGER_MAX]; 430 struct iwl_fw_dbg_mem_seg_tlv *dbg_mem_tlv; 431 size_t n_mem_tlv; 432 }; 433 434 static void alloc_sec_data(struct iwl_firmware_pieces *pieces, 435 enum iwl_ucode_type type, 436 int sec) 437 { 438 struct fw_img_parsing *img = &pieces->img[type]; 439 struct fw_sec *sec_memory; 440 int size = sec + 1; 441 size_t alloc_size = sizeof(*img->sec) * size; 442 443 if (img->sec && img->sec_counter >= size) 444 return; 445 446 sec_memory = krealloc(img->sec, alloc_size, GFP_KERNEL); 447 if (!sec_memory) 448 return; 449 450 img->sec = sec_memory; 451 img->sec_counter = size; 452 } 453 454 static void set_sec_data(struct iwl_firmware_pieces *pieces, 455 enum iwl_ucode_type type, 456 int sec, 457 const void *data) 458 { 459 alloc_sec_data(pieces, type, sec); 460 461 pieces->img[type].sec[sec].data = data; 462 } 463 464 static void set_sec_size(struct iwl_firmware_pieces *pieces, 465 enum iwl_ucode_type type, 466 int sec, 467 size_t size) 468 { 469 alloc_sec_data(pieces, type, sec); 470 471 pieces->img[type].sec[sec].size = size; 472 } 473 474 static size_t get_sec_size(struct iwl_firmware_pieces *pieces, 475 enum iwl_ucode_type type, 476 int sec) 477 { 478 return pieces->img[type].sec[sec].size; 479 } 480 481 static void set_sec_offset(struct iwl_firmware_pieces *pieces, 482 enum iwl_ucode_type type, 483 int sec, 484 u32 offset) 485 { 486 alloc_sec_data(pieces, type, sec); 487 488 pieces->img[type].sec[sec].offset = offset; 489 } 490 491 /* 492 * Gets uCode section from tlv. 493 */ 494 static int iwl_store_ucode_sec(struct fw_img_parsing *img, 495 const void *data, int size) 496 { 497 struct fw_sec *sec; 498 const struct fw_sec_parsing *sec_parse; 499 size_t alloc_size; 500 501 if (WARN_ON(!img || !data)) 502 return -EINVAL; 503 504 sec_parse = (const struct fw_sec_parsing *)data; 505 506 alloc_size = sizeof(*img->sec) * (img->sec_counter + 1); 507 sec = krealloc(img->sec, alloc_size, GFP_KERNEL); 508 if (!sec) 509 return -ENOMEM; 510 img->sec = sec; 511 512 sec = &img->sec[img->sec_counter]; 513 514 sec->offset = le32_to_cpu(sec_parse->offset); 515 sec->data = sec_parse->data; 516 sec->size = size - sizeof(sec_parse->offset); 517 518 ++img->sec_counter; 519 520 return 0; 521 } 522 523 static int iwl_set_default_calib(struct iwl_drv *drv, const u8 *data) 524 { 525 const struct iwl_tlv_calib_data *def_calib = 526 (const struct iwl_tlv_calib_data *)data; 527 u32 ucode_type = le32_to_cpu(def_calib->ucode_type); 528 if (ucode_type >= IWL_UCODE_TYPE_MAX) { 529 IWL_ERR(drv, "Wrong ucode_type %u for default calibration.\n", 530 ucode_type); 531 return -EINVAL; 532 } 533 drv->fw.default_calib[ucode_type].flow_trigger = 534 def_calib->calib.flow_trigger; 535 drv->fw.default_calib[ucode_type].event_trigger = 536 def_calib->calib.event_trigger; 537 538 return 0; 539 } 540 541 static void iwl_set_ucode_api_flags(struct iwl_drv *drv, const u8 *data, 542 struct iwl_ucode_capabilities *capa) 543 { 544 const struct iwl_ucode_api *ucode_api = (const void *)data; 545 u32 api_index = le32_to_cpu(ucode_api->api_index); 546 u32 api_flags = le32_to_cpu(ucode_api->api_flags); 547 int i; 548 549 if (api_index >= DIV_ROUND_UP(NUM_IWL_UCODE_TLV_API, 32)) { 550 IWL_WARN(drv, 551 "api flags index %d larger than supported by driver\n", 552 api_index); 553 return; 554 } 555 556 for (i = 0; i < 32; i++) { 557 if (api_flags & BIT(i)) 558 __set_bit(i + 32 * api_index, capa->_api); 559 } 560 } 561 562 static void iwl_set_ucode_capabilities(struct iwl_drv *drv, const u8 *data, 563 struct iwl_ucode_capabilities *capa) 564 { 565 const struct iwl_ucode_capa *ucode_capa = (const void *)data; 566 u32 api_index = le32_to_cpu(ucode_capa->api_index); 567 u32 api_flags = le32_to_cpu(ucode_capa->api_capa); 568 int i; 569 570 if (api_index >= DIV_ROUND_UP(NUM_IWL_UCODE_TLV_CAPA, 32)) { 571 IWL_WARN(drv, 572 "capa flags index %d larger than supported by driver\n", 573 api_index); 574 return; 575 } 576 577 for (i = 0; i < 32; i++) { 578 if (api_flags & BIT(i)) 579 __set_bit(i + 32 * api_index, capa->_capa); 580 } 581 } 582 583 static const char *iwl_reduced_fw_name(struct iwl_drv *drv) 584 { 585 const char *name = drv->firmware_name; 586 587 if (strncmp(name, "iwlwifi-", 8) == 0) 588 name += 8; 589 590 return name; 591 } 592 593 static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv, 594 const struct firmware *ucode_raw, 595 struct iwl_firmware_pieces *pieces) 596 { 597 const struct iwl_ucode_header *ucode = (const void *)ucode_raw->data; 598 u32 api_ver, hdr_size, build; 599 char buildstr[25]; 600 const u8 *src; 601 602 drv->fw.ucode_ver = le32_to_cpu(ucode->ver); 603 api_ver = IWL_UCODE_API(drv->fw.ucode_ver); 604 605 switch (api_ver) { 606 default: 607 hdr_size = 28; 608 if (ucode_raw->size < hdr_size) { 609 IWL_ERR(drv, "File size too small!\n"); 610 return -EINVAL; 611 } 612 build = le32_to_cpu(ucode->u.v2.build); 613 set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST, 614 le32_to_cpu(ucode->u.v2.inst_size)); 615 set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA, 616 le32_to_cpu(ucode->u.v2.data_size)); 617 set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST, 618 le32_to_cpu(ucode->u.v2.init_size)); 619 set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA, 620 le32_to_cpu(ucode->u.v2.init_data_size)); 621 src = ucode->u.v2.data; 622 break; 623 case 0: 624 case 1: 625 case 2: 626 hdr_size = 24; 627 if (ucode_raw->size < hdr_size) { 628 IWL_ERR(drv, "File size too small!\n"); 629 return -EINVAL; 630 } 631 build = 0; 632 set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST, 633 le32_to_cpu(ucode->u.v1.inst_size)); 634 set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA, 635 le32_to_cpu(ucode->u.v1.data_size)); 636 set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST, 637 le32_to_cpu(ucode->u.v1.init_size)); 638 set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA, 639 le32_to_cpu(ucode->u.v1.init_data_size)); 640 src = ucode->u.v1.data; 641 break; 642 } 643 644 if (build) 645 sprintf(buildstr, " build %u", build); 646 else 647 buildstr[0] = '\0'; 648 649 snprintf(drv->fw.fw_version, 650 sizeof(drv->fw.fw_version), 651 "%u.%u.%u.%u%s %s", 652 IWL_UCODE_MAJOR(drv->fw.ucode_ver), 653 IWL_UCODE_MINOR(drv->fw.ucode_ver), 654 IWL_UCODE_API(drv->fw.ucode_ver), 655 IWL_UCODE_SERIAL(drv->fw.ucode_ver), 656 buildstr, iwl_reduced_fw_name(drv)); 657 658 /* Verify size of file vs. image size info in file's header */ 659 660 if (ucode_raw->size != hdr_size + 661 get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) + 662 get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) + 663 get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST) + 664 get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA)) { 665 666 IWL_ERR(drv, 667 "uCode file size %d does not match expected size\n", 668 (int)ucode_raw->size); 669 return -EINVAL; 670 } 671 672 673 set_sec_data(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST, src); 674 src += get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST); 675 set_sec_offset(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST, 676 IWLAGN_RTC_INST_LOWER_BOUND); 677 set_sec_data(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA, src); 678 src += get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA); 679 set_sec_offset(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA, 680 IWLAGN_RTC_DATA_LOWER_BOUND); 681 set_sec_data(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST, src); 682 src += get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST); 683 set_sec_offset(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST, 684 IWLAGN_RTC_INST_LOWER_BOUND); 685 set_sec_data(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA, src); 686 src += get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA); 687 set_sec_offset(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA, 688 IWLAGN_RTC_DATA_LOWER_BOUND); 689 return 0; 690 } 691 692 static void iwl_drv_set_dump_exclude(struct iwl_drv *drv, 693 enum iwl_ucode_tlv_type tlv_type, 694 const void *tlv_data, u32 tlv_len) 695 { 696 const struct iwl_fw_dump_exclude *fw = tlv_data; 697 struct iwl_dump_exclude *excl; 698 699 if (tlv_len < sizeof(*fw)) 700 return; 701 702 if (tlv_type == IWL_UCODE_TLV_SEC_TABLE_ADDR) { 703 excl = &drv->fw.dump_excl[0]; 704 705 /* second time we find this, it's for WoWLAN */ 706 if (excl->addr) 707 excl = &drv->fw.dump_excl_wowlan[0]; 708 } else if (fw_has_capa(&drv->fw.ucode_capa, 709 IWL_UCODE_TLV_CAPA_CNSLDTD_D3_D0_IMG)) { 710 /* IWL_UCODE_TLV_D3_KEK_KCK_ADDR is regular image */ 711 excl = &drv->fw.dump_excl[0]; 712 } else { 713 /* IWL_UCODE_TLV_D3_KEK_KCK_ADDR is WoWLAN image */ 714 excl = &drv->fw.dump_excl_wowlan[0]; 715 } 716 717 if (excl->addr) 718 excl++; 719 720 if (excl->addr) { 721 IWL_DEBUG_FW_INFO(drv, "found too many excludes in fw file\n"); 722 return; 723 } 724 725 excl->addr = le32_to_cpu(fw->addr) & ~FW_ADDR_CACHE_CONTROL; 726 excl->size = le32_to_cpu(fw->size); 727 } 728 729 static void iwl_parse_dbg_tlv_assert_tables(struct iwl_drv *drv, 730 const struct iwl_ucode_tlv *tlv) 731 { 732 const struct iwl_fw_ini_region_tlv *region; 733 u32 length = le32_to_cpu(tlv->length); 734 u32 addr; 735 736 if (length < offsetof(typeof(*region), special_mem) + 737 sizeof(region->special_mem)) 738 return; 739 740 region = (const void *)tlv->data; 741 addr = le32_to_cpu(region->special_mem.base_addr); 742 addr += le32_to_cpu(region->special_mem.offset); 743 addr &= ~FW_ADDR_CACHE_CONTROL; 744 745 if (region->type != IWL_FW_INI_REGION_SPECIAL_DEVICE_MEMORY) 746 return; 747 748 switch (region->sub_type) { 749 case IWL_FW_INI_REGION_DEVICE_MEMORY_SUBTYPE_UMAC_ERROR_TABLE: 750 drv->trans->dbg.umac_error_event_table = addr; 751 drv->trans->dbg.error_event_table_tlv_status |= 752 IWL_ERROR_EVENT_TABLE_UMAC; 753 break; 754 case IWL_FW_INI_REGION_DEVICE_MEMORY_SUBTYPE_LMAC_1_ERROR_TABLE: 755 drv->trans->dbg.lmac_error_event_table[0] = addr; 756 drv->trans->dbg.error_event_table_tlv_status |= 757 IWL_ERROR_EVENT_TABLE_LMAC1; 758 break; 759 case IWL_FW_INI_REGION_DEVICE_MEMORY_SUBTYPE_LMAC_2_ERROR_TABLE: 760 drv->trans->dbg.lmac_error_event_table[1] = addr; 761 drv->trans->dbg.error_event_table_tlv_status |= 762 IWL_ERROR_EVENT_TABLE_LMAC2; 763 break; 764 case IWL_FW_INI_REGION_DEVICE_MEMORY_SUBTYPE_TCM_1_ERROR_TABLE: 765 drv->trans->dbg.tcm_error_event_table[0] = addr; 766 drv->trans->dbg.error_event_table_tlv_status |= 767 IWL_ERROR_EVENT_TABLE_TCM1; 768 break; 769 case IWL_FW_INI_REGION_DEVICE_MEMORY_SUBTYPE_TCM_2_ERROR_TABLE: 770 drv->trans->dbg.tcm_error_event_table[1] = addr; 771 drv->trans->dbg.error_event_table_tlv_status |= 772 IWL_ERROR_EVENT_TABLE_TCM2; 773 break; 774 case IWL_FW_INI_REGION_DEVICE_MEMORY_SUBTYPE_RCM_1_ERROR_TABLE: 775 drv->trans->dbg.rcm_error_event_table[0] = addr; 776 drv->trans->dbg.error_event_table_tlv_status |= 777 IWL_ERROR_EVENT_TABLE_RCM1; 778 break; 779 case IWL_FW_INI_REGION_DEVICE_MEMORY_SUBTYPE_RCM_2_ERROR_TABLE: 780 drv->trans->dbg.rcm_error_event_table[1] = addr; 781 drv->trans->dbg.error_event_table_tlv_status |= 782 IWL_ERROR_EVENT_TABLE_RCM2; 783 break; 784 default: 785 break; 786 } 787 } 788 789 static int iwl_parse_tlv_firmware(struct iwl_drv *drv, 790 const struct firmware *ucode_raw, 791 struct iwl_firmware_pieces *pieces, 792 struct iwl_ucode_capabilities *capa, 793 bool *usniffer_images) 794 { 795 const struct iwl_tlv_ucode_header *ucode = (const void *)ucode_raw->data; 796 const struct iwl_ucode_tlv *tlv; 797 size_t len = ucode_raw->size; 798 const u8 *data; 799 u32 tlv_len; 800 u32 usniffer_img; 801 enum iwl_ucode_tlv_type tlv_type; 802 const u8 *tlv_data; 803 char buildstr[25]; 804 u32 build, paging_mem_size; 805 int num_of_cpus; 806 bool usniffer_req = false; 807 808 if (len < sizeof(*ucode)) { 809 IWL_ERR(drv, "uCode has invalid length: %zd\n", len); 810 return -EINVAL; 811 } 812 813 if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) { 814 IWL_ERR(drv, "invalid uCode magic: 0X%x\n", 815 le32_to_cpu(ucode->magic)); 816 return -EINVAL; 817 } 818 819 drv->fw.ucode_ver = le32_to_cpu(ucode->ver); 820 memcpy(drv->fw.human_readable, ucode->human_readable, 821 sizeof(drv->fw.human_readable)); 822 build = le32_to_cpu(ucode->build); 823 824 if (build) 825 sprintf(buildstr, " build %u", build); 826 else 827 buildstr[0] = '\0'; 828 829 snprintf(drv->fw.fw_version, 830 sizeof(drv->fw.fw_version), 831 "%u.%u.%u.%u%s %s", 832 IWL_UCODE_MAJOR(drv->fw.ucode_ver), 833 IWL_UCODE_MINOR(drv->fw.ucode_ver), 834 IWL_UCODE_API(drv->fw.ucode_ver), 835 IWL_UCODE_SERIAL(drv->fw.ucode_ver), 836 buildstr, iwl_reduced_fw_name(drv)); 837 838 data = ucode->data; 839 840 len -= sizeof(*ucode); 841 842 while (len >= sizeof(*tlv)) { 843 len -= sizeof(*tlv); 844 845 tlv = (const void *)data; 846 tlv_len = le32_to_cpu(tlv->length); 847 tlv_type = le32_to_cpu(tlv->type); 848 tlv_data = tlv->data; 849 850 if (len < tlv_len) { 851 IWL_ERR(drv, "invalid TLV len: %zd/%u\n", 852 len, tlv_len); 853 return -EINVAL; 854 } 855 len -= ALIGN(tlv_len, 4); 856 data += sizeof(*tlv) + ALIGN(tlv_len, 4); 857 858 switch (tlv_type) { 859 case IWL_UCODE_TLV_INST: 860 set_sec_data(pieces, IWL_UCODE_REGULAR, 861 IWL_UCODE_SECTION_INST, tlv_data); 862 set_sec_size(pieces, IWL_UCODE_REGULAR, 863 IWL_UCODE_SECTION_INST, tlv_len); 864 set_sec_offset(pieces, IWL_UCODE_REGULAR, 865 IWL_UCODE_SECTION_INST, 866 IWLAGN_RTC_INST_LOWER_BOUND); 867 break; 868 case IWL_UCODE_TLV_DATA: 869 set_sec_data(pieces, IWL_UCODE_REGULAR, 870 IWL_UCODE_SECTION_DATA, tlv_data); 871 set_sec_size(pieces, IWL_UCODE_REGULAR, 872 IWL_UCODE_SECTION_DATA, tlv_len); 873 set_sec_offset(pieces, IWL_UCODE_REGULAR, 874 IWL_UCODE_SECTION_DATA, 875 IWLAGN_RTC_DATA_LOWER_BOUND); 876 break; 877 case IWL_UCODE_TLV_INIT: 878 set_sec_data(pieces, IWL_UCODE_INIT, 879 IWL_UCODE_SECTION_INST, tlv_data); 880 set_sec_size(pieces, IWL_UCODE_INIT, 881 IWL_UCODE_SECTION_INST, tlv_len); 882 set_sec_offset(pieces, IWL_UCODE_INIT, 883 IWL_UCODE_SECTION_INST, 884 IWLAGN_RTC_INST_LOWER_BOUND); 885 break; 886 case IWL_UCODE_TLV_INIT_DATA: 887 set_sec_data(pieces, IWL_UCODE_INIT, 888 IWL_UCODE_SECTION_DATA, tlv_data); 889 set_sec_size(pieces, IWL_UCODE_INIT, 890 IWL_UCODE_SECTION_DATA, tlv_len); 891 set_sec_offset(pieces, IWL_UCODE_INIT, 892 IWL_UCODE_SECTION_DATA, 893 IWLAGN_RTC_DATA_LOWER_BOUND); 894 break; 895 case IWL_UCODE_TLV_BOOT: 896 IWL_ERR(drv, "Found unexpected BOOT ucode\n"); 897 break; 898 case IWL_UCODE_TLV_PROBE_MAX_LEN: 899 if (tlv_len != sizeof(u32)) 900 goto invalid_tlv_len; 901 capa->max_probe_length = 902 le32_to_cpup((const __le32 *)tlv_data); 903 break; 904 case IWL_UCODE_TLV_PAN: 905 if (tlv_len) 906 goto invalid_tlv_len; 907 capa->flags |= IWL_UCODE_TLV_FLAGS_PAN; 908 break; 909 case IWL_UCODE_TLV_FLAGS: 910 /* must be at least one u32 */ 911 if (tlv_len < sizeof(u32)) 912 goto invalid_tlv_len; 913 /* and a proper number of u32s */ 914 if (tlv_len % sizeof(u32)) 915 goto invalid_tlv_len; 916 /* 917 * This driver only reads the first u32 as 918 * right now no more features are defined, 919 * if that changes then either the driver 920 * will not work with the new firmware, or 921 * it'll not take advantage of new features. 922 */ 923 capa->flags = le32_to_cpup((const __le32 *)tlv_data); 924 break; 925 case IWL_UCODE_TLV_API_CHANGES_SET: 926 if (tlv_len != sizeof(struct iwl_ucode_api)) 927 goto invalid_tlv_len; 928 iwl_set_ucode_api_flags(drv, tlv_data, capa); 929 break; 930 case IWL_UCODE_TLV_ENABLED_CAPABILITIES: 931 if (tlv_len != sizeof(struct iwl_ucode_capa)) 932 goto invalid_tlv_len; 933 iwl_set_ucode_capabilities(drv, tlv_data, capa); 934 break; 935 case IWL_UCODE_TLV_INIT_EVTLOG_PTR: 936 if (tlv_len != sizeof(u32)) 937 goto invalid_tlv_len; 938 pieces->init_evtlog_ptr = 939 le32_to_cpup((const __le32 *)tlv_data); 940 break; 941 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE: 942 if (tlv_len != sizeof(u32)) 943 goto invalid_tlv_len; 944 pieces->init_evtlog_size = 945 le32_to_cpup((const __le32 *)tlv_data); 946 break; 947 case IWL_UCODE_TLV_INIT_ERRLOG_PTR: 948 if (tlv_len != sizeof(u32)) 949 goto invalid_tlv_len; 950 pieces->init_errlog_ptr = 951 le32_to_cpup((const __le32 *)tlv_data); 952 break; 953 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR: 954 if (tlv_len != sizeof(u32)) 955 goto invalid_tlv_len; 956 pieces->inst_evtlog_ptr = 957 le32_to_cpup((const __le32 *)tlv_data); 958 break; 959 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE: 960 if (tlv_len != sizeof(u32)) 961 goto invalid_tlv_len; 962 pieces->inst_evtlog_size = 963 le32_to_cpup((const __le32 *)tlv_data); 964 break; 965 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR: 966 if (tlv_len != sizeof(u32)) 967 goto invalid_tlv_len; 968 pieces->inst_errlog_ptr = 969 le32_to_cpup((const __le32 *)tlv_data); 970 break; 971 case IWL_UCODE_TLV_ENHANCE_SENS_TBL: 972 if (tlv_len) 973 goto invalid_tlv_len; 974 drv->fw.enhance_sensitivity_table = true; 975 break; 976 case IWL_UCODE_TLV_WOWLAN_INST: 977 set_sec_data(pieces, IWL_UCODE_WOWLAN, 978 IWL_UCODE_SECTION_INST, tlv_data); 979 set_sec_size(pieces, IWL_UCODE_WOWLAN, 980 IWL_UCODE_SECTION_INST, tlv_len); 981 set_sec_offset(pieces, IWL_UCODE_WOWLAN, 982 IWL_UCODE_SECTION_INST, 983 IWLAGN_RTC_INST_LOWER_BOUND); 984 break; 985 case IWL_UCODE_TLV_WOWLAN_DATA: 986 set_sec_data(pieces, IWL_UCODE_WOWLAN, 987 IWL_UCODE_SECTION_DATA, tlv_data); 988 set_sec_size(pieces, IWL_UCODE_WOWLAN, 989 IWL_UCODE_SECTION_DATA, tlv_len); 990 set_sec_offset(pieces, IWL_UCODE_WOWLAN, 991 IWL_UCODE_SECTION_DATA, 992 IWLAGN_RTC_DATA_LOWER_BOUND); 993 break; 994 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE: 995 if (tlv_len != sizeof(u32)) 996 goto invalid_tlv_len; 997 capa->standard_phy_calibration_size = 998 le32_to_cpup((const __le32 *)tlv_data); 999 break; 1000 case IWL_UCODE_TLV_SEC_RT: 1001 iwl_store_ucode_sec(&pieces->img[IWL_UCODE_REGULAR], 1002 tlv_data, tlv_len); 1003 drv->fw.type = IWL_FW_MVM; 1004 break; 1005 case IWL_UCODE_TLV_SEC_INIT: 1006 iwl_store_ucode_sec(&pieces->img[IWL_UCODE_INIT], 1007 tlv_data, tlv_len); 1008 drv->fw.type = IWL_FW_MVM; 1009 break; 1010 case IWL_UCODE_TLV_SEC_WOWLAN: 1011 iwl_store_ucode_sec(&pieces->img[IWL_UCODE_WOWLAN], 1012 tlv_data, tlv_len); 1013 drv->fw.type = IWL_FW_MVM; 1014 break; 1015 case IWL_UCODE_TLV_DEF_CALIB: 1016 if (tlv_len != sizeof(struct iwl_tlv_calib_data)) 1017 goto invalid_tlv_len; 1018 if (iwl_set_default_calib(drv, tlv_data)) 1019 goto tlv_error; 1020 break; 1021 case IWL_UCODE_TLV_PHY_SKU: 1022 if (tlv_len != sizeof(u32)) 1023 goto invalid_tlv_len; 1024 drv->fw.phy_config = le32_to_cpup((const __le32 *)tlv_data); 1025 drv->fw.valid_tx_ant = (drv->fw.phy_config & 1026 FW_PHY_CFG_TX_CHAIN) >> 1027 FW_PHY_CFG_TX_CHAIN_POS; 1028 drv->fw.valid_rx_ant = (drv->fw.phy_config & 1029 FW_PHY_CFG_RX_CHAIN) >> 1030 FW_PHY_CFG_RX_CHAIN_POS; 1031 break; 1032 case IWL_UCODE_TLV_SECURE_SEC_RT: 1033 iwl_store_ucode_sec(&pieces->img[IWL_UCODE_REGULAR], 1034 tlv_data, tlv_len); 1035 drv->fw.type = IWL_FW_MVM; 1036 break; 1037 case IWL_UCODE_TLV_SECURE_SEC_INIT: 1038 iwl_store_ucode_sec(&pieces->img[IWL_UCODE_INIT], 1039 tlv_data, tlv_len); 1040 drv->fw.type = IWL_FW_MVM; 1041 break; 1042 case IWL_UCODE_TLV_SECURE_SEC_WOWLAN: 1043 iwl_store_ucode_sec(&pieces->img[IWL_UCODE_WOWLAN], 1044 tlv_data, tlv_len); 1045 drv->fw.type = IWL_FW_MVM; 1046 break; 1047 case IWL_UCODE_TLV_NUM_OF_CPU: 1048 if (tlv_len != sizeof(u32)) 1049 goto invalid_tlv_len; 1050 num_of_cpus = 1051 le32_to_cpup((const __le32 *)tlv_data); 1052 1053 if (num_of_cpus == 2) { 1054 drv->fw.img[IWL_UCODE_REGULAR].is_dual_cpus = 1055 true; 1056 drv->fw.img[IWL_UCODE_INIT].is_dual_cpus = 1057 true; 1058 drv->fw.img[IWL_UCODE_WOWLAN].is_dual_cpus = 1059 true; 1060 } else if ((num_of_cpus > 2) || (num_of_cpus < 1)) { 1061 IWL_ERR(drv, "Driver support up to 2 CPUs\n"); 1062 return -EINVAL; 1063 } 1064 break; 1065 case IWL_UCODE_TLV_N_SCAN_CHANNELS: 1066 if (tlv_len != sizeof(u32)) 1067 goto invalid_tlv_len; 1068 capa->n_scan_channels = 1069 le32_to_cpup((const __le32 *)tlv_data); 1070 break; 1071 case IWL_UCODE_TLV_FW_VERSION: { 1072 const __le32 *ptr = (const void *)tlv_data; 1073 u32 major, minor; 1074 u8 local_comp; 1075 1076 if (tlv_len != sizeof(u32) * 3) 1077 goto invalid_tlv_len; 1078 1079 major = le32_to_cpup(ptr++); 1080 minor = le32_to_cpup(ptr++); 1081 local_comp = le32_to_cpup(ptr); 1082 1083 snprintf(drv->fw.fw_version, 1084 sizeof(drv->fw.fw_version), 1085 "%u.%08x.%u %s", major, minor, 1086 local_comp, iwl_reduced_fw_name(drv)); 1087 break; 1088 } 1089 case IWL_UCODE_TLV_FW_DBG_DEST: { 1090 const struct iwl_fw_dbg_dest_tlv *dest = NULL; 1091 const struct iwl_fw_dbg_dest_tlv_v1 *dest_v1 = NULL; 1092 u8 mon_mode; 1093 1094 pieces->dbg_dest_ver = (const u8 *)tlv_data; 1095 if (*pieces->dbg_dest_ver == 1) { 1096 dest = (const void *)tlv_data; 1097 } else if (*pieces->dbg_dest_ver == 0) { 1098 dest_v1 = (const void *)tlv_data; 1099 } else { 1100 IWL_ERR(drv, 1101 "The version is %d, and it is invalid\n", 1102 *pieces->dbg_dest_ver); 1103 break; 1104 } 1105 1106 if (pieces->dbg_dest_tlv_init) { 1107 IWL_ERR(drv, 1108 "dbg destination ignored, already exists\n"); 1109 break; 1110 } 1111 1112 pieces->dbg_dest_tlv_init = true; 1113 1114 if (dest_v1) { 1115 pieces->dbg_dest_tlv_v1 = dest_v1; 1116 mon_mode = dest_v1->monitor_mode; 1117 } else { 1118 pieces->dbg_dest_tlv = dest; 1119 mon_mode = dest->monitor_mode; 1120 } 1121 1122 IWL_INFO(drv, "Found debug destination: %s\n", 1123 get_fw_dbg_mode_string(mon_mode)); 1124 1125 drv->fw.dbg.n_dest_reg = (dest_v1) ? 1126 tlv_len - 1127 offsetof(struct iwl_fw_dbg_dest_tlv_v1, 1128 reg_ops) : 1129 tlv_len - 1130 offsetof(struct iwl_fw_dbg_dest_tlv, 1131 reg_ops); 1132 1133 drv->fw.dbg.n_dest_reg /= 1134 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]); 1135 1136 break; 1137 } 1138 case IWL_UCODE_TLV_FW_DBG_CONF: { 1139 const struct iwl_fw_dbg_conf_tlv *conf = 1140 (const void *)tlv_data; 1141 1142 if (!pieces->dbg_dest_tlv_init) { 1143 IWL_ERR(drv, 1144 "Ignore dbg config %d - no destination configured\n", 1145 conf->id); 1146 break; 1147 } 1148 1149 if (conf->id >= ARRAY_SIZE(drv->fw.dbg.conf_tlv)) { 1150 IWL_ERR(drv, 1151 "Skip unknown configuration: %d\n", 1152 conf->id); 1153 break; 1154 } 1155 1156 if (pieces->dbg_conf_tlv[conf->id]) { 1157 IWL_ERR(drv, 1158 "Ignore duplicate dbg config %d\n", 1159 conf->id); 1160 break; 1161 } 1162 1163 if (conf->usniffer) 1164 usniffer_req = true; 1165 1166 IWL_INFO(drv, "Found debug configuration: %d\n", 1167 conf->id); 1168 1169 pieces->dbg_conf_tlv[conf->id] = conf; 1170 pieces->dbg_conf_tlv_len[conf->id] = tlv_len; 1171 break; 1172 } 1173 case IWL_UCODE_TLV_FW_DBG_TRIGGER: { 1174 const struct iwl_fw_dbg_trigger_tlv *trigger = 1175 (const void *)tlv_data; 1176 u32 trigger_id = le32_to_cpu(trigger->id); 1177 1178 if (trigger_id >= ARRAY_SIZE(drv->fw.dbg.trigger_tlv)) { 1179 IWL_ERR(drv, 1180 "Skip unknown trigger: %u\n", 1181 trigger->id); 1182 break; 1183 } 1184 1185 if (pieces->dbg_trigger_tlv[trigger_id]) { 1186 IWL_ERR(drv, 1187 "Ignore duplicate dbg trigger %u\n", 1188 trigger->id); 1189 break; 1190 } 1191 1192 IWL_INFO(drv, "Found debug trigger: %u\n", trigger->id); 1193 1194 pieces->dbg_trigger_tlv[trigger_id] = trigger; 1195 pieces->dbg_trigger_tlv_len[trigger_id] = tlv_len; 1196 break; 1197 } 1198 case IWL_UCODE_TLV_FW_DBG_DUMP_LST: { 1199 if (tlv_len != sizeof(u32)) { 1200 IWL_ERR(drv, 1201 "dbg lst mask size incorrect, skip\n"); 1202 break; 1203 } 1204 1205 drv->fw.dbg.dump_mask = 1206 le32_to_cpup((const __le32 *)tlv_data); 1207 break; 1208 } 1209 case IWL_UCODE_TLV_SEC_RT_USNIFFER: 1210 *usniffer_images = true; 1211 iwl_store_ucode_sec(&pieces->img[IWL_UCODE_REGULAR_USNIFFER], 1212 tlv_data, tlv_len); 1213 break; 1214 case IWL_UCODE_TLV_PAGING: 1215 if (tlv_len != sizeof(u32)) 1216 goto invalid_tlv_len; 1217 paging_mem_size = le32_to_cpup((const __le32 *)tlv_data); 1218 1219 IWL_DEBUG_FW(drv, 1220 "Paging: paging enabled (size = %u bytes)\n", 1221 paging_mem_size); 1222 1223 if (paging_mem_size > MAX_PAGING_IMAGE_SIZE) { 1224 IWL_ERR(drv, 1225 "Paging: driver supports up to %lu bytes for paging image\n", 1226 MAX_PAGING_IMAGE_SIZE); 1227 return -EINVAL; 1228 } 1229 1230 if (paging_mem_size & (FW_PAGING_SIZE - 1)) { 1231 IWL_ERR(drv, 1232 "Paging: image isn't multiple %lu\n", 1233 FW_PAGING_SIZE); 1234 return -EINVAL; 1235 } 1236 1237 drv->fw.img[IWL_UCODE_REGULAR].paging_mem_size = 1238 paging_mem_size; 1239 usniffer_img = IWL_UCODE_REGULAR_USNIFFER; 1240 drv->fw.img[usniffer_img].paging_mem_size = 1241 paging_mem_size; 1242 break; 1243 case IWL_UCODE_TLV_FW_GSCAN_CAPA: 1244 /* ignored */ 1245 break; 1246 case IWL_UCODE_TLV_FW_MEM_SEG: { 1247 const struct iwl_fw_dbg_mem_seg_tlv *dbg_mem = 1248 (const void *)tlv_data; 1249 size_t size; 1250 struct iwl_fw_dbg_mem_seg_tlv *n; 1251 1252 if (tlv_len != (sizeof(*dbg_mem))) 1253 goto invalid_tlv_len; 1254 1255 IWL_DEBUG_INFO(drv, "Found debug memory segment: %u\n", 1256 dbg_mem->data_type); 1257 1258 size = sizeof(*pieces->dbg_mem_tlv) * 1259 (pieces->n_mem_tlv + 1); 1260 n = krealloc(pieces->dbg_mem_tlv, size, GFP_KERNEL); 1261 if (!n) 1262 return -ENOMEM; 1263 pieces->dbg_mem_tlv = n; 1264 pieces->dbg_mem_tlv[pieces->n_mem_tlv] = *dbg_mem; 1265 pieces->n_mem_tlv++; 1266 break; 1267 } 1268 case IWL_UCODE_TLV_IML: { 1269 drv->fw.iml_len = tlv_len; 1270 drv->fw.iml = kmemdup(tlv_data, tlv_len, GFP_KERNEL); 1271 if (!drv->fw.iml) 1272 return -ENOMEM; 1273 break; 1274 } 1275 case IWL_UCODE_TLV_FW_RECOVERY_INFO: { 1276 const struct { 1277 __le32 buf_addr; 1278 __le32 buf_size; 1279 } *recov_info = (const void *)tlv_data; 1280 1281 if (tlv_len != sizeof(*recov_info)) 1282 goto invalid_tlv_len; 1283 capa->error_log_addr = 1284 le32_to_cpu(recov_info->buf_addr); 1285 capa->error_log_size = 1286 le32_to_cpu(recov_info->buf_size); 1287 } 1288 break; 1289 case IWL_UCODE_TLV_FW_FSEQ_VERSION: { 1290 const struct { 1291 u8 version[32]; 1292 u8 sha1[20]; 1293 } *fseq_ver = (const void *)tlv_data; 1294 1295 if (tlv_len != sizeof(*fseq_ver)) 1296 goto invalid_tlv_len; 1297 IWL_DEBUG_INFO(drv, "TLV_FW_FSEQ_VERSION: %.32s\n", 1298 fseq_ver->version); 1299 } 1300 break; 1301 case IWL_UCODE_TLV_FW_NUM_STATIONS: 1302 if (tlv_len != sizeof(u32)) 1303 goto invalid_tlv_len; 1304 if (le32_to_cpup((const __le32 *)tlv_data) > 1305 IWL_STATION_COUNT_MAX) { 1306 IWL_ERR(drv, 1307 "%d is an invalid number of station\n", 1308 le32_to_cpup((const __le32 *)tlv_data)); 1309 goto tlv_error; 1310 } 1311 capa->num_stations = 1312 le32_to_cpup((const __le32 *)tlv_data); 1313 break; 1314 case IWL_UCODE_TLV_FW_NUM_LINKS: 1315 if (tlv_len != sizeof(u32)) 1316 goto invalid_tlv_len; 1317 if (le32_to_cpup((const __le32 *)tlv_data) > 1318 IWL_FW_MAX_LINKS) { 1319 IWL_ERR(drv, 1320 "%d is an invalid number of links\n", 1321 le32_to_cpup((const __le32 *)tlv_data)); 1322 goto tlv_error; 1323 } 1324 capa->num_links = 1325 le32_to_cpup((const __le32 *)tlv_data); 1326 break; 1327 case IWL_UCODE_TLV_FW_NUM_BEACONS: 1328 if (tlv_len != sizeof(u32)) 1329 goto invalid_tlv_len; 1330 capa->num_beacons = 1331 le32_to_cpup((const __le32 *)tlv_data); 1332 break; 1333 case IWL_UCODE_TLV_UMAC_DEBUG_ADDRS: { 1334 const struct iwl_umac_debug_addrs *dbg_ptrs = 1335 (const void *)tlv_data; 1336 1337 if (tlv_len != sizeof(*dbg_ptrs)) 1338 goto invalid_tlv_len; 1339 if (drv->trans->mac_cfg->device_family < 1340 IWL_DEVICE_FAMILY_22000) 1341 break; 1342 drv->trans->dbg.umac_error_event_table = 1343 le32_to_cpu(dbg_ptrs->error_info_addr) & 1344 ~FW_ADDR_CACHE_CONTROL; 1345 drv->trans->dbg.error_event_table_tlv_status |= 1346 IWL_ERROR_EVENT_TABLE_UMAC; 1347 break; 1348 } 1349 case IWL_UCODE_TLV_LMAC_DEBUG_ADDRS: { 1350 const struct iwl_lmac_debug_addrs *dbg_ptrs = 1351 (const void *)tlv_data; 1352 1353 if (tlv_len != sizeof(*dbg_ptrs)) 1354 goto invalid_tlv_len; 1355 if (drv->trans->mac_cfg->device_family < 1356 IWL_DEVICE_FAMILY_22000) 1357 break; 1358 drv->trans->dbg.lmac_error_event_table[0] = 1359 le32_to_cpu(dbg_ptrs->error_event_table_ptr) & 1360 ~FW_ADDR_CACHE_CONTROL; 1361 drv->trans->dbg.error_event_table_tlv_status |= 1362 IWL_ERROR_EVENT_TABLE_LMAC1; 1363 break; 1364 } 1365 case IWL_UCODE_TLV_TYPE_REGIONS: 1366 iwl_parse_dbg_tlv_assert_tables(drv, tlv); 1367 fallthrough; 1368 case IWL_UCODE_TLV_TYPE_DEBUG_INFO: 1369 case IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION: 1370 case IWL_UCODE_TLV_TYPE_HCMD: 1371 case IWL_UCODE_TLV_TYPE_TRIGGERS: 1372 case IWL_UCODE_TLV_TYPE_CONF_SET: 1373 if (iwlwifi_mod_params.enable_ini) 1374 iwl_dbg_tlv_alloc(drv->trans, tlv, false); 1375 break; 1376 case IWL_UCODE_TLV_CMD_VERSIONS: 1377 if (tlv_len % sizeof(struct iwl_fw_cmd_version)) { 1378 IWL_ERR(drv, 1379 "Invalid length for command versions: %u\n", 1380 tlv_len); 1381 tlv_len /= sizeof(struct iwl_fw_cmd_version); 1382 tlv_len *= sizeof(struct iwl_fw_cmd_version); 1383 } 1384 if (WARN_ON(capa->cmd_versions)) 1385 return -EINVAL; 1386 capa->cmd_versions = kmemdup(tlv_data, tlv_len, 1387 GFP_KERNEL); 1388 if (!capa->cmd_versions) 1389 return -ENOMEM; 1390 capa->n_cmd_versions = 1391 tlv_len / sizeof(struct iwl_fw_cmd_version); 1392 break; 1393 case IWL_UCODE_TLV_PHY_INTEGRATION_VERSION: 1394 if (drv->fw.phy_integration_ver) { 1395 IWL_ERR(drv, 1396 "phy integration str ignored, already exists\n"); 1397 break; 1398 } 1399 1400 drv->fw.phy_integration_ver = 1401 kmemdup(tlv_data, tlv_len, GFP_KERNEL); 1402 if (!drv->fw.phy_integration_ver) 1403 return -ENOMEM; 1404 drv->fw.phy_integration_ver_len = tlv_len; 1405 break; 1406 case IWL_UCODE_TLV_SEC_TABLE_ADDR: 1407 case IWL_UCODE_TLV_D3_KEK_KCK_ADDR: 1408 iwl_drv_set_dump_exclude(drv, tlv_type, 1409 tlv_data, tlv_len); 1410 break; 1411 case IWL_UCODE_TLV_CURRENT_PC: 1412 if (tlv_len < sizeof(struct iwl_pc_data)) 1413 goto invalid_tlv_len; 1414 drv->trans->dbg.pc_data = 1415 kmemdup(tlv_data, tlv_len, GFP_KERNEL); 1416 if (!drv->trans->dbg.pc_data) 1417 return -ENOMEM; 1418 drv->trans->dbg.num_pc = 1419 tlv_len / sizeof(struct iwl_pc_data); 1420 break; 1421 case IWL_UCODE_TLV_PNVM_DATA: 1422 if (drv->fw.pnvm_data) 1423 break; 1424 drv->fw.pnvm_data = 1425 kvmemdup(tlv_data, tlv_len, GFP_KERNEL); 1426 if (!drv->fw.pnvm_data) 1427 return -ENOMEM; 1428 drv->fw.pnvm_size = tlv_len; 1429 break; 1430 case IWL_UCODE_TLV_CMD_BIOS_TABLE: 1431 if (tlv_len % sizeof(struct iwl_fw_cmd_bios_table)) { 1432 IWL_ERR(drv, 1433 "Invalid length for command bios table: %u\n", 1434 tlv_len); 1435 return -EINVAL; 1436 } 1437 1438 if (capa->cmd_bios_tables) { 1439 IWL_ERR(drv, "Duplicate TLV type 0x%02X detected\n", 1440 tlv_type); 1441 return -EINVAL; 1442 } 1443 capa->cmd_bios_tables = kmemdup(tlv_data, tlv_len, 1444 GFP_KERNEL); 1445 if (!capa->cmd_bios_tables) 1446 return -ENOMEM; 1447 capa->n_cmd_bios_tables = 1448 tlv_len / sizeof(struct iwl_fw_cmd_bios_table); 1449 break; 1450 default: 1451 IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type); 1452 break; 1453 } 1454 } 1455 1456 if (!fw_has_capa(capa, IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED) && 1457 usniffer_req && !*usniffer_images) { 1458 IWL_ERR(drv, 1459 "user selected to work with usniffer but usniffer image isn't available in ucode package\n"); 1460 return -EINVAL; 1461 } 1462 1463 if (len) { 1464 IWL_ERR(drv, "invalid TLV after parsing: %zd\n", len); 1465 iwl_print_hex_dump(drv, IWL_DL_FW, data, len); 1466 return -EINVAL; 1467 } 1468 1469 return 0; 1470 1471 invalid_tlv_len: 1472 IWL_ERR(drv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len); 1473 tlv_error: 1474 iwl_print_hex_dump(drv, IWL_DL_FW, tlv_data, tlv_len); 1475 1476 return -EINVAL; 1477 } 1478 1479 static int iwl_alloc_ucode_mem(struct fw_img *out, struct fw_img_parsing *img) 1480 { 1481 struct fw_desc *sec; 1482 1483 sec = kzalloc_objs(*sec, img->sec_counter); 1484 if (!sec) 1485 return -ENOMEM; 1486 1487 out->sec = sec; 1488 out->num_sec = img->sec_counter; 1489 1490 for (int i = 0; i < out->num_sec; i++) 1491 if (iwl_alloc_fw_desc(&sec[i], &img->sec[i])) 1492 return -ENOMEM; 1493 1494 return 0; 1495 } 1496 1497 static int iwl_alloc_ucode(struct iwl_drv *drv, 1498 struct iwl_firmware_pieces *pieces, 1499 enum iwl_ucode_type type) 1500 { 1501 return iwl_alloc_ucode_mem(&drv->fw.img[type], &pieces->img[type]); 1502 } 1503 1504 static int validate_sec_sizes(struct iwl_drv *drv, 1505 struct iwl_firmware_pieces *pieces, 1506 const struct iwl_rf_cfg *cfg) 1507 { 1508 IWL_DEBUG_INFO(drv, "f/w package hdr runtime inst size = %zd\n", 1509 get_sec_size(pieces, IWL_UCODE_REGULAR, 1510 IWL_UCODE_SECTION_INST)); 1511 IWL_DEBUG_INFO(drv, "f/w package hdr runtime data size = %zd\n", 1512 get_sec_size(pieces, IWL_UCODE_REGULAR, 1513 IWL_UCODE_SECTION_DATA)); 1514 IWL_DEBUG_INFO(drv, "f/w package hdr init inst size = %zd\n", 1515 get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST)); 1516 IWL_DEBUG_INFO(drv, "f/w package hdr init data size = %zd\n", 1517 get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA)); 1518 1519 /* Verify that uCode images will fit in card's SRAM. */ 1520 if (get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) > 1521 cfg->max_inst_size) { 1522 IWL_ERR(drv, "uCode instr len %zd too large to fit in\n", 1523 get_sec_size(pieces, IWL_UCODE_REGULAR, 1524 IWL_UCODE_SECTION_INST)); 1525 return -1; 1526 } 1527 1528 if (get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) > 1529 cfg->max_data_size) { 1530 IWL_ERR(drv, "uCode data len %zd too large to fit in\n", 1531 get_sec_size(pieces, IWL_UCODE_REGULAR, 1532 IWL_UCODE_SECTION_DATA)); 1533 return -1; 1534 } 1535 1536 if (get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST) > 1537 cfg->max_inst_size) { 1538 IWL_ERR(drv, "uCode init instr len %zd too large to fit in\n", 1539 get_sec_size(pieces, IWL_UCODE_INIT, 1540 IWL_UCODE_SECTION_INST)); 1541 return -1; 1542 } 1543 1544 if (get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA) > 1545 cfg->max_data_size) { 1546 IWL_ERR(drv, "uCode init data len %zd too large to fit in\n", 1547 get_sec_size(pieces, IWL_UCODE_REGULAR, 1548 IWL_UCODE_SECTION_DATA)); 1549 return -1; 1550 } 1551 return 0; 1552 } 1553 1554 static struct iwl_op_mode * 1555 _iwl_op_mode_start(struct iwl_drv *drv, struct iwlwifi_opmode_table *op) 1556 { 1557 const struct iwl_op_mode_ops *ops = op->ops; 1558 struct dentry *dbgfs_dir = NULL; 1559 struct iwl_op_mode *op_mode = NULL; 1560 int retry, max_retry = !!iwlwifi_mod_params.fw_restart * IWL_MAX_INIT_RETRY; 1561 1562 /* also protects start/stop from racing against each other */ 1563 lockdep_assert_held(&iwlwifi_opmode_table_mtx); 1564 1565 for (retry = 0; retry <= max_retry; retry++) { 1566 1567 #ifdef CONFIG_IWLWIFI_DEBUGFS 1568 drv->dbgfs_op_mode = debugfs_create_dir(op->name, 1569 drv->dbgfs_drv); 1570 dbgfs_dir = drv->dbgfs_op_mode; 1571 #endif 1572 1573 op_mode = ops->start(drv->trans, drv->trans->cfg, 1574 &drv->fw, dbgfs_dir); 1575 1576 if (!IS_ERR(op_mode)) 1577 return op_mode; 1578 1579 if (iwl_trans_is_dead(drv->trans)) 1580 break; 1581 1582 #ifdef CONFIG_IWLWIFI_DEBUGFS 1583 debugfs_remove_recursive(drv->dbgfs_op_mode); 1584 drv->dbgfs_op_mode = NULL; 1585 #endif 1586 1587 if (PTR_ERR(op_mode) != -ETIMEDOUT) 1588 break; 1589 1590 IWL_ERR(drv, "retry init count %d\n", retry); 1591 } 1592 1593 return NULL; 1594 } 1595 1596 static void _iwl_op_mode_stop(struct iwl_drv *drv) 1597 { 1598 /* also protects start/stop from racing against each other */ 1599 lockdep_assert_held(&iwlwifi_opmode_table_mtx); 1600 1601 /* op_mode can be NULL if its start failed */ 1602 if (drv->op_mode) { 1603 iwl_op_mode_stop(drv->op_mode); 1604 drv->op_mode = NULL; 1605 1606 #ifdef CONFIG_IWLWIFI_DEBUGFS 1607 debugfs_remove_recursive(drv->dbgfs_op_mode); 1608 drv->dbgfs_op_mode = NULL; 1609 #endif 1610 } 1611 } 1612 1613 /* 1614 * iwl_req_fw_callback - callback when firmware was loaded 1615 * 1616 * If loaded successfully, copies the firmware into buffers 1617 * for the card to fetch (via DMA). 1618 */ 1619 static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context) 1620 { 1621 int min_core, max_core, loaded_core; 1622 struct iwl_drv *drv = context; 1623 struct iwl_fw *fw = &drv->fw; 1624 const struct iwl_ucode_header *ucode; 1625 struct iwlwifi_opmode_table *op; 1626 int err; 1627 struct iwl_firmware_pieces *pieces; 1628 unsigned int api_min, api_max; 1629 size_t trigger_tlv_sz[FW_DBG_TRIGGER_MAX]; 1630 u32 api_ver; 1631 int i; 1632 bool usniffer_images = false; 1633 bool failure = true; 1634 1635 iwl_get_ucode_api_versions(drv->trans, &api_min, &api_max); 1636 1637 fw->ucode_capa.max_probe_length = IWL_DEFAULT_MAX_PROBE_LENGTH; 1638 fw->ucode_capa.standard_phy_calibration_size = 1639 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE; 1640 fw->ucode_capa.n_scan_channels = IWL_DEFAULT_SCAN_CHANNELS; 1641 fw->ucode_capa.num_stations = IWL_STATION_COUNT_MAX; 1642 fw->ucode_capa.num_beacons = 1; 1643 /* dump all fw memory areas by default */ 1644 fw->dbg.dump_mask = 0xffffffff; 1645 1646 pieces = kzalloc_obj(*pieces); 1647 if (!pieces) 1648 goto out_free_fw; 1649 1650 if (!ucode_raw) 1651 goto try_again; 1652 1653 IWL_DEBUG_FW_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n", 1654 drv->firmware_name, ucode_raw->size); 1655 1656 /* Make sure that we got at least the API version number */ 1657 if (ucode_raw->size < 4) { 1658 IWL_ERR(drv, "File size way too small!\n"); 1659 goto try_again; 1660 } 1661 1662 /* Data from ucode file: header followed by uCode images */ 1663 ucode = (const struct iwl_ucode_header *)ucode_raw->data; 1664 1665 if (ucode->ver) 1666 err = iwl_parse_v1_v2_firmware(drv, ucode_raw, pieces); 1667 else 1668 err = iwl_parse_tlv_firmware(drv, ucode_raw, pieces, 1669 &fw->ucode_capa, &usniffer_images); 1670 1671 if (err) 1672 goto try_again; 1673 1674 if (fw_has_api(&drv->fw.ucode_capa, IWL_UCODE_TLV_API_NEW_VERSION)) 1675 api_ver = drv->fw.ucode_ver; 1676 else 1677 api_ver = IWL_UCODE_API(drv->fw.ucode_ver); 1678 1679 /* 1680 * api_ver should match the api version forming part of the 1681 * firmware filename ... but we don't check for that and only rely 1682 * on the API version read from firmware header from here on forward 1683 */ 1684 1685 /* 1686 * if -cN.ucode file was loaded, core version == file version, 1687 * otherwise core version == file version (API version) - 3 1688 */ 1689 if (iwl_api_is_core_number(drv->fw_index)) 1690 loaded_core = api_ver; 1691 else 1692 loaded_core = api_ver - API_TO_CORE_OFFS; 1693 1694 min_core = iwl_api_to_core(api_min); 1695 max_core = iwl_api_to_core(api_max); 1696 1697 if (loaded_core < min_core || loaded_core > max_core) { 1698 IWL_ERR(drv, 1699 "Driver unable to support your firmware API. " 1700 "Driver supports FW core %d..%d, firmware is %d.\n", 1701 min_core, max_core, loaded_core); 1702 goto try_again; 1703 } 1704 1705 /* 1706 * In mvm uCode there is no difference between data and instructions 1707 * sections. 1708 */ 1709 if (fw->type == IWL_FW_DVM && validate_sec_sizes(drv, pieces, 1710 drv->trans->cfg)) 1711 goto try_again; 1712 1713 /* Allocate ucode buffers for card's bus-master loading ... */ 1714 1715 /* Runtime instructions and 2 copies of data: 1716 * 1) unmodified from disk 1717 * 2) backup cache for save/restore during power-downs 1718 */ 1719 for (i = 0; i < IWL_UCODE_TYPE_MAX; i++) 1720 if (iwl_alloc_ucode(drv, pieces, i)) 1721 goto out_free_fw; 1722 1723 if (pieces->dbg_dest_tlv_init) { 1724 size_t dbg_dest_size = sizeof(*drv->fw.dbg.dest_tlv) + 1725 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) * 1726 drv->fw.dbg.n_dest_reg; 1727 1728 drv->fw.dbg.dest_tlv = kmalloc(dbg_dest_size, GFP_KERNEL); 1729 1730 if (!drv->fw.dbg.dest_tlv) 1731 goto out_free_fw; 1732 1733 if (*pieces->dbg_dest_ver == 0) { 1734 memcpy(drv->fw.dbg.dest_tlv, pieces->dbg_dest_tlv_v1, 1735 dbg_dest_size); 1736 } else { 1737 struct iwl_fw_dbg_dest_tlv_v1 *dest_tlv = 1738 drv->fw.dbg.dest_tlv; 1739 1740 dest_tlv->version = pieces->dbg_dest_tlv->version; 1741 dest_tlv->monitor_mode = 1742 pieces->dbg_dest_tlv->monitor_mode; 1743 dest_tlv->size_power = 1744 pieces->dbg_dest_tlv->size_power; 1745 dest_tlv->wrap_count = 1746 pieces->dbg_dest_tlv->wrap_count; 1747 dest_tlv->write_ptr_reg = 1748 pieces->dbg_dest_tlv->write_ptr_reg; 1749 dest_tlv->base_shift = 1750 pieces->dbg_dest_tlv->base_shift; 1751 memcpy(dest_tlv->reg_ops, 1752 pieces->dbg_dest_tlv->reg_ops, 1753 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) * 1754 drv->fw.dbg.n_dest_reg); 1755 1756 /* In version 1 of the destination tlv, which is 1757 * relevant for internal buffer exclusively, 1758 * the base address is part of given with the length 1759 * of the buffer, and the size shift is give instead of 1760 * end shift. We now store these values in base_reg, 1761 * and end shift, and when dumping the data we'll 1762 * manipulate it for extracting both the length and 1763 * base address */ 1764 dest_tlv->base_reg = pieces->dbg_dest_tlv->cfg_reg; 1765 dest_tlv->end_shift = 1766 pieces->dbg_dest_tlv->size_shift; 1767 } 1768 } 1769 1770 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++) { 1771 if (pieces->dbg_conf_tlv[i]) { 1772 drv->fw.dbg.conf_tlv[i] = 1773 kmemdup(pieces->dbg_conf_tlv[i], 1774 pieces->dbg_conf_tlv_len[i], 1775 GFP_KERNEL); 1776 if (!drv->fw.dbg.conf_tlv[i]) 1777 goto out_free_fw; 1778 } 1779 } 1780 1781 memset(&trigger_tlv_sz, 0xff, sizeof(trigger_tlv_sz)); 1782 1783 trigger_tlv_sz[FW_DBG_TRIGGER_MISSED_BEACONS] = 1784 sizeof(struct iwl_fw_dbg_trigger_missed_bcon); 1785 trigger_tlv_sz[FW_DBG_TRIGGER_CHANNEL_SWITCH] = 0; 1786 trigger_tlv_sz[FW_DBG_TRIGGER_FW_NOTIF] = 1787 sizeof(struct iwl_fw_dbg_trigger_cmd); 1788 trigger_tlv_sz[FW_DBG_TRIGGER_MLME] = 1789 sizeof(struct iwl_fw_dbg_trigger_mlme); 1790 trigger_tlv_sz[FW_DBG_TRIGGER_STATS] = 1791 sizeof(struct iwl_fw_dbg_trigger_stats); 1792 trigger_tlv_sz[FW_DBG_TRIGGER_RSSI] = 1793 sizeof(struct iwl_fw_dbg_trigger_low_rssi); 1794 trigger_tlv_sz[FW_DBG_TRIGGER_TXQ_TIMERS] = 1795 sizeof(struct iwl_fw_dbg_trigger_txq_timer); 1796 trigger_tlv_sz[FW_DBG_TRIGGER_TIME_EVENT] = 1797 sizeof(struct iwl_fw_dbg_trigger_time_event); 1798 trigger_tlv_sz[FW_DBG_TRIGGER_BA] = 1799 sizeof(struct iwl_fw_dbg_trigger_ba); 1800 trigger_tlv_sz[FW_DBG_TRIGGER_TDLS] = 1801 sizeof(struct iwl_fw_dbg_trigger_tdls); 1802 1803 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++) { 1804 if (pieces->dbg_trigger_tlv[i]) { 1805 /* 1806 * If the trigger isn't long enough, WARN and exit. 1807 * Someone is trying to debug something and he won't 1808 * be able to catch the bug he is trying to chase. 1809 * We'd better be noisy to be sure he knows what's 1810 * going on. 1811 */ 1812 if (WARN_ON(pieces->dbg_trigger_tlv_len[i] < 1813 (trigger_tlv_sz[i] + 1814 sizeof(struct iwl_fw_dbg_trigger_tlv)))) 1815 goto out_free_fw; 1816 drv->fw.dbg.trigger_tlv_len[i] = 1817 pieces->dbg_trigger_tlv_len[i]; 1818 drv->fw.dbg.trigger_tlv[i] = 1819 kmemdup(pieces->dbg_trigger_tlv[i], 1820 drv->fw.dbg.trigger_tlv_len[i], 1821 GFP_KERNEL); 1822 if (!drv->fw.dbg.trigger_tlv[i]) 1823 goto out_free_fw; 1824 } 1825 } 1826 1827 /* Now that we can no longer fail, copy information */ 1828 1829 drv->fw.dbg.mem_tlv = pieces->dbg_mem_tlv; 1830 pieces->dbg_mem_tlv = NULL; 1831 drv->fw.dbg.n_mem_tlv = pieces->n_mem_tlv; 1832 1833 /* 1834 * The (size - 16) / 12 formula is based on the information recorded 1835 * for each event, which is of mode 1 (including timestamp) for all 1836 * new microcodes that include this information. 1837 */ 1838 fw->init_evtlog_ptr = pieces->init_evtlog_ptr; 1839 if (pieces->init_evtlog_size) 1840 fw->init_evtlog_size = (pieces->init_evtlog_size - 16)/12; 1841 else 1842 fw->init_evtlog_size = 1843 drv->trans->mac_cfg->base->max_event_log_size; 1844 fw->init_errlog_ptr = pieces->init_errlog_ptr; 1845 fw->inst_evtlog_ptr = pieces->inst_evtlog_ptr; 1846 if (pieces->inst_evtlog_size) 1847 fw->inst_evtlog_size = (pieces->inst_evtlog_size - 16)/12; 1848 else 1849 fw->inst_evtlog_size = 1850 drv->trans->mac_cfg->base->max_event_log_size; 1851 fw->inst_errlog_ptr = pieces->inst_errlog_ptr; 1852 1853 /* 1854 * figure out the offset of chain noise reset and gain commands 1855 * base on the size of standard phy calibration commands table size 1856 */ 1857 if (fw->ucode_capa.standard_phy_calibration_size > 1858 IWL_MAX_PHY_CALIBRATE_TBL_SIZE) 1859 fw->ucode_capa.standard_phy_calibration_size = 1860 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE; 1861 1862 /* We have our copies now, allow OS release its copies */ 1863 release_firmware(ucode_raw); 1864 1865 iwl_dbg_tlv_load_bin(drv->trans->dev, drv->trans); 1866 1867 mutex_lock(&iwlwifi_opmode_table_mtx); 1868 switch (fw->type) { 1869 case IWL_FW_DVM: 1870 op = &iwlwifi_opmode_table[DVM_OP_MODE]; 1871 break; 1872 default: 1873 WARN(1, "Invalid fw type %d\n", fw->type); 1874 fallthrough; 1875 case IWL_FW_MVM: 1876 op = &iwlwifi_opmode_table[MVM_OP_MODE]; 1877 break; 1878 } 1879 1880 #if IS_ENABLED(CONFIG_IWLMLD) 1881 if (iwl_drv_is_wifi7_supported(drv->trans)) 1882 op = &iwlwifi_opmode_table[MLD_OP_MODE]; 1883 #endif 1884 1885 IWL_INFO(drv, "loaded firmware version %s op_mode %s\n", 1886 drv->fw.fw_version, op->name); 1887 1888 /* add this device to the list of devices using this op_mode */ 1889 list_add_tail(&drv->list, &op->drv); 1890 1891 if (op->ops) { 1892 drv->op_mode = _iwl_op_mode_start(drv, op); 1893 1894 if (!drv->op_mode) { 1895 mutex_unlock(&iwlwifi_opmode_table_mtx); 1896 goto out_unbind; 1897 } 1898 } else { 1899 request_module_nowait("%s", op->name); 1900 } 1901 mutex_unlock(&iwlwifi_opmode_table_mtx); 1902 1903 complete(&drv->request_firmware_complete); 1904 1905 failure = false; 1906 goto free; 1907 1908 try_again: 1909 /* try next, if any */ 1910 release_firmware(ucode_raw); 1911 if (iwl_request_firmware(drv, false)) 1912 goto out_unbind; 1913 goto free; 1914 1915 out_free_fw: 1916 release_firmware(ucode_raw); 1917 out_unbind: 1918 complete(&drv->request_firmware_complete); 1919 device_release_driver(drv->trans->dev); 1920 /* drv has just been freed by the release */ 1921 failure = false; 1922 free: 1923 if (failure) 1924 iwl_dealloc_ucode(drv); 1925 1926 if (pieces) { 1927 for (i = 0; i < ARRAY_SIZE(pieces->img); i++) 1928 kfree(pieces->img[i].sec); 1929 kfree(pieces->dbg_mem_tlv); 1930 kfree(pieces); 1931 } 1932 } 1933 1934 struct iwl_drv *iwl_drv_start(struct iwl_trans *trans) 1935 { 1936 struct iwl_drv *drv; 1937 int ret; 1938 1939 drv = kzalloc_obj(*drv); 1940 if (!drv) { 1941 ret = -ENOMEM; 1942 goto err; 1943 } 1944 1945 drv->trans = trans; 1946 drv->dev = trans->dev; 1947 1948 init_completion(&drv->request_firmware_complete); 1949 INIT_LIST_HEAD(&drv->list); 1950 1951 #ifdef CONFIG_IWLWIFI_DEBUGFS 1952 /* Create the device debugfs entries. */ 1953 drv->dbgfs_drv = debugfs_create_dir(dev_name(trans->dev), 1954 iwl_dbgfs_root); 1955 1956 /* Create transport layer debugfs dir */ 1957 drv->trans->dbgfs_dir = debugfs_create_dir("trans", drv->dbgfs_drv); 1958 #endif 1959 1960 drv->trans->dbg.domains_bitmap = IWL_TRANS_FW_DBG_DOMAIN(drv->trans); 1961 if (iwlwifi_mod_params.enable_ini != ENABLE_INI) { 1962 /* We have a non-default value in the module parameter, 1963 * take its value 1964 */ 1965 drv->trans->dbg.domains_bitmap &= 0xffff; 1966 if (iwlwifi_mod_params.enable_ini != IWL_FW_INI_PRESET_DISABLE) { 1967 if (iwlwifi_mod_params.enable_ini > ENABLE_INI) { 1968 IWL_ERR(trans, 1969 "invalid enable_ini module parameter value: max = %d, using 0 instead\n", 1970 ENABLE_INI); 1971 iwlwifi_mod_params.enable_ini = 0; 1972 } 1973 drv->trans->dbg.domains_bitmap = 1974 BIT(IWL_FW_DBG_DOMAIN_POS + iwlwifi_mod_params.enable_ini); 1975 } 1976 } 1977 1978 ret = iwl_request_firmware(drv, true); 1979 if (ret) { 1980 IWL_ERR(trans, "Couldn't request the fw\n"); 1981 goto err_fw; 1982 } 1983 1984 return drv; 1985 1986 err_fw: 1987 #ifdef CONFIG_IWLWIFI_DEBUGFS 1988 debugfs_remove_recursive(drv->dbgfs_drv); 1989 #endif 1990 iwl_dbg_tlv_free(drv->trans); 1991 kfree(drv); 1992 err: 1993 return ERR_PTR(ret); 1994 } 1995 1996 void iwl_drv_stop(struct iwl_drv *drv) 1997 { 1998 wait_for_completion(&drv->request_firmware_complete); 1999 2000 mutex_lock(&iwlwifi_opmode_table_mtx); 2001 2002 _iwl_op_mode_stop(drv); 2003 2004 iwl_dealloc_ucode(drv); 2005 2006 /* 2007 * List is empty (this item wasn't added) 2008 * when firmware loading failed -- in that 2009 * case we can't remove it from any list. 2010 */ 2011 if (!list_empty(&drv->list)) 2012 list_del(&drv->list); 2013 mutex_unlock(&iwlwifi_opmode_table_mtx); 2014 2015 #ifdef CONFIG_IWLWIFI_DEBUGFS 2016 iwl_trans_debugfs_cleanup(drv->trans); 2017 2018 debugfs_remove_recursive(drv->dbgfs_drv); 2019 #endif 2020 2021 iwl_dbg_tlv_free(drv->trans); 2022 2023 kfree(drv); 2024 } 2025 2026 /* shared module parameters */ 2027 struct iwl_mod_params iwlwifi_mod_params = { 2028 .fw_restart = true, 2029 .bt_coex_active = true, 2030 .power_level = IWL_POWER_INDEX_1, 2031 .uapsd_disable = IWL_DISABLE_UAPSD_BSS | IWL_DISABLE_UAPSD_P2P_CLIENT, 2032 .enable_ini = ENABLE_INI, 2033 /* the rest are 0 by default */ 2034 }; 2035 IWL_EXPORT_SYMBOL(iwlwifi_mod_params); 2036 2037 int iwl_opmode_register(const char *name, const struct iwl_op_mode_ops *ops) 2038 { 2039 int i; 2040 struct iwl_drv *drv; 2041 struct iwlwifi_opmode_table *op; 2042 2043 mutex_lock(&iwlwifi_opmode_table_mtx); 2044 for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++) { 2045 op = &iwlwifi_opmode_table[i]; 2046 if (strcmp(op->name, name)) 2047 continue; 2048 op->ops = ops; 2049 /* TODO: need to handle exceptional case */ 2050 list_for_each_entry(drv, &op->drv, list) 2051 drv->op_mode = _iwl_op_mode_start(drv, op); 2052 2053 mutex_unlock(&iwlwifi_opmode_table_mtx); 2054 return 0; 2055 } 2056 mutex_unlock(&iwlwifi_opmode_table_mtx); 2057 return -EIO; 2058 } 2059 IWL_EXPORT_SYMBOL(iwl_opmode_register); 2060 2061 void iwl_opmode_deregister(const char *name) 2062 { 2063 int i; 2064 struct iwl_drv *drv; 2065 2066 mutex_lock(&iwlwifi_opmode_table_mtx); 2067 for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++) { 2068 if (strcmp(iwlwifi_opmode_table[i].name, name)) 2069 continue; 2070 iwlwifi_opmode_table[i].ops = NULL; 2071 2072 /* call the stop routine for all devices */ 2073 list_for_each_entry(drv, &iwlwifi_opmode_table[i].drv, list) 2074 _iwl_op_mode_stop(drv); 2075 2076 mutex_unlock(&iwlwifi_opmode_table_mtx); 2077 return; 2078 } 2079 mutex_unlock(&iwlwifi_opmode_table_mtx); 2080 } 2081 IWL_EXPORT_SYMBOL(iwl_opmode_deregister); 2082 2083 static int __init iwl_drv_init(void) 2084 { 2085 int i, err; 2086 2087 for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++) 2088 INIT_LIST_HEAD(&iwlwifi_opmode_table[i].drv); 2089 2090 #ifdef CONFIG_IWLWIFI_DEBUGFS 2091 /* Create the root of iwlwifi debugfs subsystem. */ 2092 iwl_dbgfs_root = debugfs_create_dir(DRV_NAME, NULL); 2093 #endif 2094 2095 err = iwl_pci_register_driver(); 2096 if (err) 2097 goto cleanup_debugfs; 2098 2099 return 0; 2100 2101 cleanup_debugfs: 2102 #ifdef CONFIG_IWLWIFI_DEBUGFS 2103 debugfs_remove_recursive(iwl_dbgfs_root); 2104 #endif 2105 return err; 2106 } 2107 module_init(iwl_drv_init); 2108 2109 static void __exit iwl_drv_exit(void) 2110 { 2111 iwl_pci_unregister_driver(); 2112 iwl_trans_free_restart_list(); 2113 2114 #ifdef CONFIG_IWLWIFI_DEBUGFS 2115 debugfs_remove_recursive(iwl_dbgfs_root); 2116 #endif 2117 } 2118 module_exit(iwl_drv_exit); 2119 2120 #ifdef CONFIG_IWLWIFI_DEBUG 2121 module_param_named(debug, iwlwifi_mod_params.debug_level, uint, 0644); 2122 MODULE_PARM_DESC(debug, "debug output mask"); 2123 #endif 2124 2125 module_param_named(swcrypto, iwlwifi_mod_params.swcrypto, int, 0444); 2126 MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])"); 2127 module_param_named(11n_disable, iwlwifi_mod_params.disable_11n, uint, 0444); 2128 MODULE_PARM_DESC(11n_disable, 2129 "disable 11n functionality, bitmap: 1: full, 2: disable agg TX, 4: disable agg RX, 8 enable agg TX"); 2130 module_param_named(amsdu_size, iwlwifi_mod_params.amsdu_size, int, 0444); 2131 MODULE_PARM_DESC(amsdu_size, 2132 "amsdu size 0: 12K for multi Rx queue devices, 2K for AX210 devices, " 2133 "4K for other devices 1:4K 2:8K 3:12K (16K buffers) 4: 2K (default 0)"); 2134 module_param_named(fw_restart, iwlwifi_mod_params.fw_restart, bool, 0444); 2135 MODULE_PARM_DESC(fw_restart, "restart firmware in case of error (default true)"); 2136 2137 module_param_named(nvm_file, iwlwifi_mod_params.nvm_file, charp, 0444); 2138 MODULE_PARM_DESC(nvm_file, "NVM file name"); 2139 2140 module_param_named(uapsd_disable, iwlwifi_mod_params.uapsd_disable, uint, 0644); 2141 MODULE_PARM_DESC(uapsd_disable, 2142 "disable U-APSD functionality bitmap 1: BSS 2: P2P Client (default: 3)"); 2143 2144 module_param_named(enable_ini, iwlwifi_mod_params.enable_ini, uint, 0444); 2145 MODULE_PARM_DESC(enable_ini, 2146 "0:disable, 1-15:FW_DBG_PRESET Values, 16:enabled without preset value defined," 2147 "Debug INI TLV FW debug infrastructure (default: 16)"); 2148 2149 /* 2150 * set bt_coex_active to true, uCode will do kill/defer 2151 * every time the priority line is asserted (BT is sending signals on the 2152 * priority line in the PCIx). 2153 * set bt_coex_active to false, uCode will ignore the BT activity and 2154 * perform the normal operation 2155 * 2156 * User might experience transmit issue on some platform due to WiFi/BT 2157 * co-exist problem. The possible behaviors are: 2158 * Able to scan and finding all the available AP 2159 * Not able to associate with any AP 2160 * On those platforms, WiFi communication can be restored by set 2161 * "bt_coex_active" module parameter to "false" 2162 * 2163 * default: bt_coex_active = true (BT_COEX_ENABLE) 2164 */ 2165 module_param_named(bt_coex_active, iwlwifi_mod_params.bt_coex_active, 2166 bool, 0444); 2167 MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)"); 2168 2169 module_param_named(led_mode, iwlwifi_mod_params.led_mode, int, 0444); 2170 MODULE_PARM_DESC(led_mode, "0=system default, " 2171 "1=On(RF On)/Off(RF Off), 2=blinking, 3=Off (default: 0)"); 2172 2173 module_param_named(power_save, iwlwifi_mod_params.power_save, bool, 0444); 2174 MODULE_PARM_DESC(power_save, 2175 "enable WiFi power management (default: disable)"); 2176 2177 module_param_named(power_level, iwlwifi_mod_params.power_level, int, 0444); 2178 MODULE_PARM_DESC(power_level, 2179 "default power save level (range from 1 - 5, default: 1)"); 2180 2181 module_param_named(disable_11ac, iwlwifi_mod_params.disable_11ac, bool, 0444); 2182 MODULE_PARM_DESC(disable_11ac, "Disable VHT capabilities (default: false)"); 2183 2184 module_param_named(remove_when_gone, 2185 iwlwifi_mod_params.remove_when_gone, bool, 2186 0444); 2187 MODULE_PARM_DESC(remove_when_gone, 2188 "Remove dev from PCIe bus if it is deemed inaccessible (default: false)"); 2189 2190 module_param_named(disable_11ax, iwlwifi_mod_params.disable_11ax, bool, 2191 S_IRUGO); 2192 MODULE_PARM_DESC(disable_11ax, "Disable HE capabilities (default: false)"); 2193 2194 module_param_named(disable_11be, iwlwifi_mod_params.disable_11be, bool, 0444); 2195 MODULE_PARM_DESC(disable_11be, "Disable EHT capabilities (default: false)"); 2196