forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-08 01573e231f18eb2d99162747186f59511f56b64d 
 kernel/drivers/net/wireless/intel/iwlwifi/iwl-drv.c
....@@ -5,7 +5,7 @@
55  *
66  * GPL LICENSE SUMMARY
77  *
8
- * Copyright(c) 2007 - 2014 Intel Corporation. All rights reserved.
8
+ * Copyright(c) 2007 - 2014, 2018 - 2020  Intel Corporation. All rights reserved.
99  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
1010  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
1111  *
....@@ -18,11 +18,6 @@
1818  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1919  * General Public License for more details.
2020  *
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
- *
2621  * The full GNU General Public License is included in this distribution
2722  * in the file called COPYING.
2823  *
....@@ -32,7 +27,7 @@
3227  *
3328  * BSD LICENSE
3429  *
35
- * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
30
+ * Copyright(c) 2005 - 2014, 2018 - 2020 Intel Corporation. All rights reserved.
3631  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
3732  * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
3833  * All rights reserved.
....@@ -77,8 +72,11 @@
7772 #include "iwl-op-mode.h"
7873 #include "iwl-agn-hw.h"
7974 #include "fw/img.h"
75
+#include "iwl-dbg-tlv.h"
8076 #include "iwl-config.h"
8177 #include "iwl-modparams.h"
78
+#include "fw/api/alive.h"
79
+#include "fw/api/mac.h"
8280 
8381 /******************************************************************************
8482  *
....@@ -88,7 +86,7 @@
8886 
8987 #define DRV_DESCRIPTION	"Intel(R) Wireless WiFi driver for Linux"
9088 MODULE_DESCRIPTION(DRV_DESCRIPTION);
91
-MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
89
+MODULE_AUTHOR(DRV_AUTHOR);
9290 MODULE_LICENSE("GPL");
9391 
9492 #ifdef CONFIG_IWLWIFI_DEBUGFS
....@@ -105,6 +103,9 @@
105103  * @fw_index: firmware revision to try loading
106104  * @firmware_name: composite filename of ucode file to load
107105  * @request_firmware_complete: the firmware has been obtained from user space
106
+ * @dbgfs_drv: debugfs root directory entry
107
+ * @dbgfs_trans: debugfs transport directory entry
108
+ * @dbgfs_op_mode: debugfs op_mode directory entry
108109  */
109110 struct iwl_drv {
110111 	struct list_head list;
....@@ -173,13 +174,14 @@
173174 {
174175 	int i;
175176 
176
-	kfree(drv->fw.dbg_dest_tlv);
177
-	for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_conf_tlv); i++)
178
-		kfree(drv->fw.dbg_conf_tlv[i]);
179
-	for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_trigger_tlv); i++)
180
-		kfree(drv->fw.dbg_trigger_tlv[i]);
181
-	kfree(drv->fw.dbg_mem_tlv);
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
+	kfree(drv->fw.dbg.mem_tlv);
182183 	kfree(drv->fw.iml);
184
+	kfree(drv->fw.ucode_capa.cmd_versions);
183185 
184186 	for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
185187 		iwl_free_fw_img(drv, drv->fw.img + i);
....@@ -217,18 +219,15 @@
217219 {
218220 	const struct iwl_cfg *cfg = drv->trans->cfg;
219221 	char tag[8];
220
-	const char *fw_pre_name;
221222 
222
-	if (drv->trans->cfg->device_family == IWL_DEVICE_FAMILY_9000 &&
223
-	    (CSR_HW_REV_STEP(drv->trans->hw_rev) == SILICON_B_STEP ||
224
-	     CSR_HW_REV_STEP(drv->trans->hw_rev) == SILICON_C_STEP))
225
-		fw_pre_name = cfg->fw_name_pre_b_or_c_step;
226
-	else if (drv->trans->cfg->integrated &&
227
-		 CSR_HW_RFID_STEP(drv->trans->hw_rf_id) == SILICON_B_STEP &&
228
-		 cfg->fw_name_pre_rf_next_step)
229
-		fw_pre_name = cfg->fw_name_pre_rf_next_step;
230
-	else
231
-		fw_pre_name = cfg->fw_name_pre;
223
+	if (drv->trans->trans_cfg->device_family == IWL_DEVICE_FAMILY_9000 &&
224
+	    (CSR_HW_REV_STEP(drv->trans->hw_rev) != SILICON_B_STEP &&
225
+	     CSR_HW_REV_STEP(drv->trans->hw_rev) != SILICON_C_STEP)) {
226
+		IWL_ERR(drv,
227
+			"Only HW steps B and C are currently supported (0x%0x)\n",
228
+			drv->trans->hw_rev);
229
+		return -EINVAL;
230
+	}
232231 
233232 	if (first) {
234233 		drv->fw_index = cfg->ucode_api_max;
....@@ -242,15 +241,13 @@
242241 		IWL_ERR(drv, "no suitable firmware found!\n");
243242 
244243 		if (cfg->ucode_api_min == cfg->ucode_api_max) {
245
-			IWL_ERR(drv, "%s%d is required\n", fw_pre_name,
244
+			IWL_ERR(drv, "%s%d is required\n", cfg->fw_name_pre,
246245 				cfg->ucode_api_max);
247246 		} else {
248247 			IWL_ERR(drv, "minimum version required: %s%d\n",
249
-				fw_pre_name,
250
-				cfg->ucode_api_min);
248
+				cfg->fw_name_pre, cfg->ucode_api_min);
251249 			IWL_ERR(drv, "maximum version supported: %s%d\n",
252
-				fw_pre_name,
253
-				cfg->ucode_api_max);
250
+				cfg->fw_name_pre, cfg->ucode_api_max);
254251 		}
255252 
256253 		IWL_ERR(drv,
....@@ -259,10 +256,10 @@
259256 	}
260257 
261258 	snprintf(drv->firmware_name, sizeof(drv->firmware_name), "%s%s.ucode",
262
-		 fw_pre_name, tag);
259
+		 cfg->fw_name_pre, tag);
263260 
264
-	IWL_DEBUG_INFO(drv, "attempting to load firmware '%s'\n",
265
-		       drv->firmware_name);
261
+	IWL_DEBUG_FW_INFO(drv, "attempting to load firmware '%s'\n",
262
+			  drv->firmware_name);
266263 
267264 	return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
268265 				       drv->trans->dev,
....@@ -311,7 +308,7 @@
311308 	struct iwl_fw_dbg_trigger_tlv *dbg_trigger_tlv[FW_DBG_TRIGGER_MAX];
312309 	size_t dbg_trigger_tlv_len[FW_DBG_TRIGGER_MAX];
313310 	struct iwl_fw_dbg_mem_seg_tlv *dbg_mem_tlv;
314
-	size_t n_dbg_mem_tlv;
311
+	size_t n_mem_tlv;
315312 };
316313 
317314 /*
....@@ -501,6 +498,16 @@
501498 	}
502499 }
503500 
501
+static const char *iwl_reduced_fw_name(struct iwl_drv *drv)
502
+{
503
+	const char *name = drv->firmware_name;
504
+
505
+	if (strncmp(name, "iwlwifi-", 8) == 0)
506
+		name += 8;
507
+
508
+	return name;
509
+}
510
+
504511 static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv,
505512 				    const struct firmware *ucode_raw,
506513 				    struct iwl_firmware_pieces *pieces)
....@@ -559,12 +566,12 @@
559566 
560567 	snprintf(drv->fw.fw_version,
561568 		 sizeof(drv->fw.fw_version),
562
-		 "%u.%u.%u.%u%s",
569
+		 "%u.%u.%u.%u%s %s",
563570 		 IWL_UCODE_MAJOR(drv->fw.ucode_ver),
564571 		 IWL_UCODE_MINOR(drv->fw.ucode_ver),
565572 		 IWL_UCODE_API(drv->fw.ucode_ver),
566573 		 IWL_UCODE_SERIAL(drv->fw.ucode_ver),
567
-		 buildstr);
574
+		 buildstr, iwl_reduced_fw_name(drv));
568575 
569576 	/* Verify size of file vs. image size info in file's header */
570577 
....@@ -599,6 +606,8 @@
599606 		       IWLAGN_RTC_DATA_LOWER_BOUND);
600607 	return 0;
601608 }
609
+
610
+#define FW_ADDR_CACHE_CONTROL 0xC0000000
602611 
603612 static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
604613 				const struct firmware *ucode_raw,
....@@ -642,12 +651,12 @@
642651 
643652 	snprintf(drv->fw.fw_version,
644653 		 sizeof(drv->fw.fw_version),
645
-		 "%u.%u.%u.%u%s",
654
+		 "%u.%u.%u.%u%s %s",
646655 		 IWL_UCODE_MAJOR(drv->fw.ucode_ver),
647656 		 IWL_UCODE_MINOR(drv->fw.ucode_ver),
648657 		 IWL_UCODE_API(drv->fw.ucode_ver),
649658 		 IWL_UCODE_SERIAL(drv->fw.ucode_ver),
650
-		 buildstr);
659
+		 buildstr, iwl_reduced_fw_name(drv));
651660 
652661 	data = ucode->data;
653662 
....@@ -901,11 +910,13 @@
901910 			if (major >= 35)
902911 				snprintf(drv->fw.fw_version,
903912 					 sizeof(drv->fw.fw_version),
904
-					"%u.%08x.%u", major, minor, local_comp);
913
+					"%u.%08x.%u %s", major, minor,
914
+					local_comp, iwl_reduced_fw_name(drv));
905915 			else
906916 				snprintf(drv->fw.fw_version,
907917 					 sizeof(drv->fw.fw_version),
908
-					"%u.%u.%u", major, minor, local_comp);
918
+					"%u.%u.%u %s", major, minor,
919
+					local_comp, iwl_reduced_fw_name(drv));
909920 			break;
910921 			}
911922 		case IWL_UCODE_TLV_FW_DBG_DEST: {
....@@ -944,7 +955,7 @@
944955 			IWL_INFO(drv, "Found debug destination: %s\n",
945956 				 get_fw_dbg_mode_string(mon_mode));
946957 
947
-			drv->fw.dbg_dest_reg_num = (dest_v1) ?
958
+			drv->fw.dbg.n_dest_reg = (dest_v1) ?
948959 				tlv_len -
949960 				offsetof(struct iwl_fw_dbg_dest_tlv_v1,
950961 					 reg_ops) :
....@@ -952,8 +963,8 @@
952963 				offsetof(struct iwl_fw_dbg_dest_tlv,
953964 					 reg_ops);
954965 
955
-			drv->fw.dbg_dest_reg_num /=
956
-				sizeof(drv->fw.dbg_dest_tlv->reg_ops[0]);
966
+			drv->fw.dbg.n_dest_reg /=
967
+				sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]);
957968 
958969 			break;
959970 			}
....@@ -967,7 +978,7 @@
967978 				break;
968979 			}
969980 
970
-			if (conf->id >= ARRAY_SIZE(drv->fw.dbg_conf_tlv)) {
981
+			if (conf->id >= ARRAY_SIZE(drv->fw.dbg.conf_tlv)) {
971982 				IWL_ERR(drv,
972983 					"Skip unknown configuration: %d\n",
973984 					conf->id);
....@@ -996,7 +1007,7 @@
9961007 				(void *)tlv_data;
9971008 			u32 trigger_id = le32_to_cpu(trigger->id);
9981009 
999
-			if (trigger_id >= ARRAY_SIZE(drv->fw.dbg_trigger_tlv)) {
1010
+			if (trigger_id >= ARRAY_SIZE(drv->fw.dbg.trigger_tlv)) {
10001011 				IWL_ERR(drv,
10011012 					"Skip unknown trigger: %u\n",
10021013 					trigger->id);
....@@ -1023,7 +1034,7 @@
10231034 				break;
10241035 			}
10251036 
1026
-			drv->fw.dbg_dump_mask =
1037
+			drv->fw.dbg.dump_mask =
10271038 				le32_to_cpup((__le32 *)tlv_data);
10281039 			break;
10291040 			}
....@@ -1068,38 +1079,23 @@
10681079 		case IWL_UCODE_TLV_FW_MEM_SEG: {
10691080 			struct iwl_fw_dbg_mem_seg_tlv *dbg_mem =
10701081 				(void *)tlv_data;
1071
-			u32 type;
10721082 			size_t size;
10731083 			struct iwl_fw_dbg_mem_seg_tlv *n;
10741084 
10751085 			if (tlv_len != (sizeof(*dbg_mem)))
10761086 				goto invalid_tlv_len;
10771087 
1078
-			type = le32_to_cpu(dbg_mem->data_type);
1079
-
10801088 			IWL_DEBUG_INFO(drv, "Found debug memory segment: %u\n",
10811089 				       dbg_mem->data_type);
10821090 
1083
-			switch (type & FW_DBG_MEM_TYPE_MASK) {
1084
-			case FW_DBG_MEM_TYPE_REGULAR:
1085
-			case FW_DBG_MEM_TYPE_PRPH:
1086
-				/* we know how to handle these */
1087
-				break;
1088
-			default:
1089
-				IWL_ERR(drv,
1090
-					"Found debug memory segment with invalid type: 0x%x\n",
1091
-					type);
1092
-				return -EINVAL;
1093
-			}
1094
-
10951091 			size = sizeof(*pieces->dbg_mem_tlv) *
1096
-			       (pieces->n_dbg_mem_tlv + 1);
1092
+			       (pieces->n_mem_tlv + 1);
10971093 			n = krealloc(pieces->dbg_mem_tlv, size, GFP_KERNEL);
10981094 			if (!n)
10991095 				return -ENOMEM;
11001096 			pieces->dbg_mem_tlv = n;
1101
-			pieces->dbg_mem_tlv[pieces->n_dbg_mem_tlv] = *dbg_mem;
1102
-			pieces->n_dbg_mem_tlv++;
1097
+			pieces->dbg_mem_tlv[pieces->n_mem_tlv] = *dbg_mem;
1098
+			pieces->n_mem_tlv++;
11031099 			break;
11041100 			}
11051101 		case IWL_UCODE_TLV_IML: {
....@@ -1109,6 +1105,102 @@
11091105 				return -ENOMEM;
11101106 			break;
11111107 			}
1108
+		case IWL_UCODE_TLV_FW_RECOVERY_INFO: {
1109
+			struct {
1110
+				__le32 buf_addr;
1111
+				__le32 buf_size;
1112
+			} *recov_info = (void *)tlv_data;
1113
+
1114
+			if (tlv_len != sizeof(*recov_info))
1115
+				goto invalid_tlv_len;
1116
+			capa->error_log_addr =
1117
+				le32_to_cpu(recov_info->buf_addr);
1118
+			capa->error_log_size =
1119
+				le32_to_cpu(recov_info->buf_size);
1120
+			}
1121
+			break;
1122
+		case IWL_UCODE_TLV_FW_FSEQ_VERSION: {
1123
+			struct {
1124
+				u8 version[32];
1125
+				u8 sha1[20];
1126
+			} *fseq_ver = (void *)tlv_data;
1127
+
1128
+			if (tlv_len != sizeof(*fseq_ver))
1129
+				goto invalid_tlv_len;
1130
+			IWL_INFO(drv, "TLV_FW_FSEQ_VERSION: %s\n",
1131
+				 fseq_ver->version);
1132
+			}
1133
+			break;
1134
+		case IWL_UCODE_TLV_FW_NUM_STATIONS:
1135
+			if (tlv_len != sizeof(u32))
1136
+				goto invalid_tlv_len;
1137
+			if (le32_to_cpup((__le32 *)tlv_data) >
1138
+			    IWL_MVM_STATION_COUNT_MAX) {
1139
+				IWL_ERR(drv,
1140
+					"%d is an invalid number of station\n",
1141
+					le32_to_cpup((__le32 *)tlv_data));
1142
+				goto tlv_error;
1143
+			}
1144
+			capa->num_stations =
1145
+				le32_to_cpup((__le32 *)tlv_data);
1146
+			break;
1147
+		case IWL_UCODE_TLV_UMAC_DEBUG_ADDRS: {
1148
+			struct iwl_umac_debug_addrs *dbg_ptrs =
1149
+				(void *)tlv_data;
1150
+
1151
+			if (tlv_len != sizeof(*dbg_ptrs))
1152
+				goto invalid_tlv_len;
1153
+			if (drv->trans->trans_cfg->device_family <
1154
+			    IWL_DEVICE_FAMILY_22000)
1155
+				break;
1156
+			drv->trans->dbg.umac_error_event_table =
1157
+				le32_to_cpu(dbg_ptrs->error_info_addr) &
1158
+				~FW_ADDR_CACHE_CONTROL;
1159
+			drv->trans->dbg.error_event_table_tlv_status |=
1160
+				IWL_ERROR_EVENT_TABLE_UMAC;
1161
+			break;
1162
+			}
1163
+		case IWL_UCODE_TLV_LMAC_DEBUG_ADDRS: {
1164
+			struct iwl_lmac_debug_addrs *dbg_ptrs =
1165
+				(void *)tlv_data;
1166
+
1167
+			if (tlv_len != sizeof(*dbg_ptrs))
1168
+				goto invalid_tlv_len;
1169
+			if (drv->trans->trans_cfg->device_family <
1170
+			    IWL_DEVICE_FAMILY_22000)
1171
+				break;
1172
+			drv->trans->dbg.lmac_error_event_table[0] =
1173
+				le32_to_cpu(dbg_ptrs->error_event_table_ptr) &
1174
+				~FW_ADDR_CACHE_CONTROL;
1175
+			drv->trans->dbg.error_event_table_tlv_status |=
1176
+				IWL_ERROR_EVENT_TABLE_LMAC1;
1177
+			break;
1178
+			}
1179
+		case IWL_UCODE_TLV_TYPE_DEBUG_INFO:
1180
+		case IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION:
1181
+		case IWL_UCODE_TLV_TYPE_HCMD:
1182
+		case IWL_UCODE_TLV_TYPE_REGIONS:
1183
+		case IWL_UCODE_TLV_TYPE_TRIGGERS:
1184
+			if (iwlwifi_mod_params.enable_ini)
1185
+				iwl_dbg_tlv_alloc(drv->trans, tlv, false);
1186
+			break;
1187
+		case IWL_UCODE_TLV_CMD_VERSIONS:
1188
+			if (tlv_len % sizeof(struct iwl_fw_cmd_version)) {
1189
+				IWL_ERR(drv,
1190
+					"Invalid length for command versions: %u\n",
1191
+					tlv_len);
1192
+				tlv_len /= sizeof(struct iwl_fw_cmd_version);
1193
+				tlv_len *= sizeof(struct iwl_fw_cmd_version);
1194
+			}
1195
+			if (WARN_ON(capa->cmd_versions))
1196
+				return -EINVAL;
1197
+			capa->cmd_versions = kmemdup(tlv_data, tlv_len,
1198
+						     GFP_KERNEL);
1199
+			if (!capa->cmd_versions)
1200
+				return -ENOMEM;
1201
+			capa->n_cmd_versions =
1202
+				tlv_len / sizeof(struct iwl_fw_cmd_version);
1203
+			break;
11121204 		default:
11131205 			IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type);
11141206 			break;
....@@ -1214,28 +1306,31 @@
12141306 	const struct iwl_op_mode_ops *ops = op->ops;
12151307 	struct dentry *dbgfs_dir = NULL;
12161308 	struct iwl_op_mode *op_mode = NULL;
1309
+	int retry, max_retry = !!iwlwifi_mod_params.fw_restart * IWL_MAX_INIT_RETRY;
1310
+
1311
+	for (retry = 0; retry <= max_retry; retry++) {
12171312 
12181313 #ifdef CONFIG_IWLWIFI_DEBUGFS
1219
-	drv->dbgfs_op_mode = debugfs_create_dir(op->name,
1220
-						drv->dbgfs_drv);
1221
-	if (!drv->dbgfs_op_mode) {
1222
-		IWL_ERR(drv,
1223
-			"failed to create opmode debugfs directory\n");
1224
-		return op_mode;
1225
-	}
1226
-	dbgfs_dir = drv->dbgfs_op_mode;
1314
+		drv->dbgfs_op_mode = debugfs_create_dir(op->name,
1315
+							drv->dbgfs_drv);
1316
+		dbgfs_dir = drv->dbgfs_op_mode;
12271317 #endif
12281318 
1229
-	op_mode = ops->start(drv->trans, drv->trans->cfg, &drv->fw, dbgfs_dir);
1319
+		op_mode = ops->start(drv->trans, drv->trans->cfg,
1320
+				     &drv->fw, dbgfs_dir);
1321
+
1322
+		if (op_mode)
1323
+			return op_mode;
1324
+
1325
+		IWL_ERR(drv, "retry init count %d\n", retry);
12301326 
12311327 #ifdef CONFIG_IWLWIFI_DEBUGFS
1232
-	if (!op_mode) {
12331328 		debugfs_remove_recursive(drv->dbgfs_op_mode);
12341329 		drv->dbgfs_op_mode = NULL;
1235
-	}
12361330 #endif
1331
+	}
12371332 
1238
-	return op_mode;
1333
+	return NULL;
12391334 }
12401335 
12411336 static void _iwl_op_mode_stop(struct iwl_drv *drv)
....@@ -1252,7 +1347,7 @@
12521347 	}
12531348 }
12541349 
1255
-/**
1350
+/*
12561351  * iwl_req_fw_callback - callback when firmware was loaded
12571352  *
12581353  * If loaded successfully, copies the firmware into buffers
....@@ -1279,8 +1374,9 @@
12791374 	fw->ucode_capa.standard_phy_calibration_size =
12801375 			IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
12811376 	fw->ucode_capa.n_scan_channels = IWL_DEFAULT_SCAN_CHANNELS;
1377
+	fw->ucode_capa.num_stations = IWL_MVM_STATION_COUNT_MAX;
12821378 	/* dump all fw memory areas by default */
1283
-	fw->dbg_dump_mask = 0xffffffff;
1379
+	fw->dbg.dump_mask = 0xffffffff;
12841380 
12851381 	pieces = kzalloc(sizeof(*pieces), GFP_KERNEL);
12861382 	if (!pieces)
....@@ -1289,8 +1385,8 @@
12891385 	if (!ucode_raw)
12901386 		goto try_again;
12911387 
1292
-	IWL_DEBUG_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
1293
-		       drv->firmware_name, ucode_raw->size);
1388
+	IWL_DEBUG_FW_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
1389
+			  drv->firmware_name, ucode_raw->size);
12941390 
12951391 	/* Make sure that we got at least the API version number */
12961392 	if (ucode_raw->size < 4) {
....@@ -1347,21 +1443,21 @@
13471443 			goto out_free_fw;
13481444 
13491445 	if (pieces->dbg_dest_tlv_init) {
1350
-		size_t dbg_dest_size = sizeof(*drv->fw.dbg_dest_tlv) +
1351
-			sizeof(drv->fw.dbg_dest_tlv->reg_ops[0]) *
1352
-			drv->fw.dbg_dest_reg_num;
1446
+		size_t dbg_dest_size = sizeof(*drv->fw.dbg.dest_tlv) +
1447
+			sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) *
1448
+			drv->fw.dbg.n_dest_reg;
13531449 
1354
-		drv->fw.dbg_dest_tlv = kmalloc(dbg_dest_size, GFP_KERNEL);
1450
+		drv->fw.dbg.dest_tlv = kmalloc(dbg_dest_size, GFP_KERNEL);
13551451 
1356
-		if (!drv->fw.dbg_dest_tlv)
1452
+		if (!drv->fw.dbg.dest_tlv)
13571453 			goto out_free_fw;
13581454 
13591455 		if (*pieces->dbg_dest_ver == 0) {
1360
-			memcpy(drv->fw.dbg_dest_tlv, pieces->dbg_dest_tlv_v1,
1456
+			memcpy(drv->fw.dbg.dest_tlv, pieces->dbg_dest_tlv_v1,
13611457 			       dbg_dest_size);
13621458 		} else {
13631459 			struct iwl_fw_dbg_dest_tlv_v1 *dest_tlv =
1364
-				drv->fw.dbg_dest_tlv;
1460
+				drv->fw.dbg.dest_tlv;
13651461 
13661462 			dest_tlv->version = pieces->dbg_dest_tlv->version;
13671463 			dest_tlv->monitor_mode =
....@@ -1376,8 +1472,8 @@
13761472 				pieces->dbg_dest_tlv->base_shift;
13771473 			memcpy(dest_tlv->reg_ops,
13781474 			       pieces->dbg_dest_tlv->reg_ops,
1379
-			       sizeof(drv->fw.dbg_dest_tlv->reg_ops[0]) *
1380
-			       drv->fw.dbg_dest_reg_num);
1475
+			       sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) *
1476
+			       drv->fw.dbg.n_dest_reg);
13811477 
13821478 			/* In version 1 of the destination tlv, which is
13831479 			 * relevant for internal buffer exclusively,
....@@ -1393,15 +1489,13 @@
13931489 		}
13941490 	}
13951491 
1396
-	for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_conf_tlv); i++) {
1492
+	for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++) {
13971493 		if (pieces->dbg_conf_tlv[i]) {
1398
-			drv->fw.dbg_conf_tlv_len[i] =
1399
-				pieces->dbg_conf_tlv_len[i];
1400
-			drv->fw.dbg_conf_tlv[i] =
1494
+			drv->fw.dbg.conf_tlv[i] =
14011495 				kmemdup(pieces->dbg_conf_tlv[i],
1402
-					drv->fw.dbg_conf_tlv_len[i],
1496
+					pieces->dbg_conf_tlv_len[i],
14031497 					GFP_KERNEL);
1404
-			if (!drv->fw.dbg_conf_tlv[i])
1498
+			if (!drv->fw.dbg.conf_tlv[i])
14051499 				goto out_free_fw;
14061500 		}
14071501 	}
....@@ -1428,7 +1522,7 @@
14281522 	trigger_tlv_sz[FW_DBG_TRIGGER_TDLS] =
14291523 		sizeof(struct iwl_fw_dbg_trigger_tdls);
14301524 
1431
-	for (i = 0; i < ARRAY_SIZE(drv->fw.dbg_trigger_tlv); i++) {
1525
+	for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++) {
14321526 		if (pieces->dbg_trigger_tlv[i]) {
14331527 			/*
14341528 			 * If the trigger isn't long enough, WARN and exit.
....@@ -1441,22 +1535,22 @@
14411535 				    (trigger_tlv_sz[i] +
14421536 				     sizeof(struct iwl_fw_dbg_trigger_tlv))))
14431537 				goto out_free_fw;
1444
-			drv->fw.dbg_trigger_tlv_len[i] =
1538
+			drv->fw.dbg.trigger_tlv_len[i] =
14451539 				pieces->dbg_trigger_tlv_len[i];
1446
-			drv->fw.dbg_trigger_tlv[i] =
1540
+			drv->fw.dbg.trigger_tlv[i] =
14471541 				kmemdup(pieces->dbg_trigger_tlv[i],
1448
-					drv->fw.dbg_trigger_tlv_len[i],
1542
+					drv->fw.dbg.trigger_tlv_len[i],
14491543 					GFP_KERNEL);
1450
-			if (!drv->fw.dbg_trigger_tlv[i])
1544
+			if (!drv->fw.dbg.trigger_tlv[i])
14511545 				goto out_free_fw;
14521546 		}
14531547 	}
14541548 
14551549 	/* Now that we can no longer fail, copy information */
14561550 
1457
-	drv->fw.dbg_mem_tlv = pieces->dbg_mem_tlv;
1551
+	drv->fw.dbg.mem_tlv = pieces->dbg_mem_tlv;
14581552 	pieces->dbg_mem_tlv = NULL;
1459
-	drv->fw.n_dbg_mem_tlv = pieces->n_dbg_mem_tlv;
1553
+	drv->fw.dbg.n_mem_tlv = pieces->n_mem_tlv;
14601554 
14611555 	/*
14621556 	 * The (size - 16) / 12 formula is based on the information recorded
....@@ -1468,14 +1562,14 @@
14681562 		fw->init_evtlog_size = (pieces->init_evtlog_size - 16)/12;
14691563 	else
14701564 		fw->init_evtlog_size =
1471
-			drv->trans->cfg->base_params->max_event_log_size;
1565
+			drv->trans->trans_cfg->base_params->max_event_log_size;
14721566 	fw->init_errlog_ptr = pieces->init_errlog_ptr;
14731567 	fw->inst_evtlog_ptr = pieces->inst_evtlog_ptr;
14741568 	if (pieces->inst_evtlog_size)
14751569 		fw->inst_evtlog_size = (pieces->inst_evtlog_size - 16)/12;
14761570 	else
14771571 		fw->inst_evtlog_size =
1478
-			drv->trans->cfg->base_params->max_event_log_size;
1572
+			drv->trans->trans_cfg->base_params->max_event_log_size;
14791573 	fw->inst_errlog_ptr = pieces->inst_errlog_ptr;
14801574 
14811575 	/*
....@@ -1497,6 +1591,7 @@
14971591 		break;
14981592 	default:
14991593 		WARN(1, "Invalid fw type %d\n", fw->type);
1594
+		/* fall through */
15001595 	case IWL_FW_MVM:
15011596 		op = &iwlwifi_opmode_table[MVM_OP_MODE];
15021597 		break;
....@@ -1504,6 +1599,8 @@
15041599 
15051600 	IWL_INFO(drv, "loaded firmware version %s op_mode %s\n",
15061601 		 drv->fw.fw_version, op->name);
1602
+
1603
+	iwl_dbg_tlv_load_bin(drv->trans->dev, drv->trans);
15071604 
15081605 	/* add this device to the list of devices using this op_mode */
15091606 	list_add_tail(&drv->list, &op->drv);
....@@ -1585,21 +1682,11 @@
15851682 	drv->dbgfs_drv = debugfs_create_dir(dev_name(trans->dev),
15861683 					    iwl_dbgfs_root);
15871684 
1588
-	if (!drv->dbgfs_drv) {
1589
-		IWL_ERR(drv, "failed to create debugfs directory\n");
1590
-		ret = -ENOMEM;
1591
-		goto err_free_drv;
1592
-	}
1593
-
15941685 	/* Create transport layer debugfs dir */
15951686 	drv->trans->dbgfs_dir = debugfs_create_dir("trans", drv->dbgfs_drv);
1596
-
1597
-	if (!drv->trans->dbgfs_dir) {
1598
-		IWL_ERR(drv, "failed to create transport debugfs directory\n");
1599
-		ret = -ENOMEM;
1600
-		goto err_free_dbgfs;
1601
-	}
16021687 #endif
1688
+
1689
+	drv->trans->dbg.domains_bitmap = IWL_TRANS_FW_DBG_DOMAIN(drv->trans);
16031690 
16041691 	ret = iwl_request_firmware(drv, true);
16051692 	if (ret) {
....@@ -1611,9 +1698,8 @@
16111698 
16121699 err_fw:
16131700 #ifdef CONFIG_IWLWIFI_DEBUGFS
1614
-err_free_dbgfs:
16151701 	debugfs_remove_recursive(drv->dbgfs_drv);
1616
-err_free_drv:
1702
+	iwl_dbg_tlv_free(drv->trans);
16171703 #endif
16181704 	kfree(drv);
16191705 err:
....@@ -1639,8 +1725,12 @@
16391725 	mutex_unlock(&iwlwifi_opmode_table_mtx);
16401726 
16411727 #ifdef CONFIG_IWLWIFI_DEBUGFS
1728
+	drv->trans->ops->debugfs_cleanup(drv->trans);
1729
+
16421730 	debugfs_remove_recursive(drv->dbgfs_drv);
16431731 #endif
1732
+
1733
+	iwl_dbg_tlv_free(drv->trans);
16441734 
16451735 	kfree(drv);
16461736 }
....@@ -1651,9 +1741,8 @@
16511741 	.fw_restart = true,
16521742 	.bt_coex_active = true,
16531743 	.power_level = IWL_POWER_INDEX_1,
1654
-	.d0i3_disable = true,
1655
-	.d0i3_timeout = 1000,
16561744 	.uapsd_disable = IWL_DISABLE_UAPSD_BSS | IWL_DISABLE_UAPSD_P2P_CLIENT,
1745
+	.enable_ini = true,
16571746 	/* the rest are 0 by default */
16581747 };
16591748 IWL_EXPORT_SYMBOL(iwlwifi_mod_params);
....@@ -1706,7 +1795,7 @@
17061795 
17071796 static int __init iwl_drv_init(void)
17081797 {
1709
-	int i;
1798
+	int i, err;
17101799 
17111800 	mutex_init(&iwlwifi_opmode_table_mtx);
17121801 
....@@ -1714,17 +1803,23 @@
17141803 		INIT_LIST_HEAD(&iwlwifi_opmode_table[i].drv);
17151804 
17161805 	pr_info(DRV_DESCRIPTION "\n");
1717
-	pr_info(DRV_COPYRIGHT "\n");
17181806 
17191807 #ifdef CONFIG_IWLWIFI_DEBUGFS
17201808 	/* Create the root of iwlwifi debugfs subsystem. */
17211809 	iwl_dbgfs_root = debugfs_create_dir(DRV_NAME, NULL);
1722
-
1723
-	if (!iwl_dbgfs_root)
1724
-		return -EFAULT;
17251810 #endif
17261811 
1727
-	return iwl_pci_register_driver();
1812
+	err = iwl_pci_register_driver();
1813
+	if (err)
1814
+		goto cleanup_debugfs;
1815
+
1816
+	return 0;
1817
+
1818
+cleanup_debugfs:
1819
+#ifdef CONFIG_IWLWIFI_DEBUGFS
1820
+	debugfs_remove_recursive(iwl_dbgfs_root);
1821
+#endif
1822
+	return err;
17281823 }
17291824 module_init(iwl_drv_init);
17301825 
....@@ -1750,28 +1845,21 @@
17501845 	"disable 11n functionality, bitmap: 1: full, 2: disable agg TX, 4: disable agg RX, 8 enable agg TX");
17511846 module_param_named(amsdu_size, iwlwifi_mod_params.amsdu_size, int, 0444);
17521847 MODULE_PARM_DESC(amsdu_size,
1753
-		 "amsdu size 0: 12K for multi Rx queue devices, 2K for 22560 devices, "
1848
+		 "amsdu size 0: 12K for multi Rx queue devices, 2K for AX210 devices, "
17541849 		 "4K for other devices 1:4K 2:8K 3:12K 4: 2K (default 0)");
17551850 module_param_named(fw_restart, iwlwifi_mod_params.fw_restart, bool, 0444);
17561851 MODULE_PARM_DESC(fw_restart, "restart firmware in case of error (default true)");
17571852 
1758
-module_param_named(antenna_coupling, iwlwifi_mod_params.antenna_coupling,
1759
-		   int, 0444);
1760
-MODULE_PARM_DESC(antenna_coupling,
1761
-		 "specify antenna coupling in dB (default: 0 dB)");
1762
-
17631853 module_param_named(nvm_file, iwlwifi_mod_params.nvm_file, charp, 0444);
17641854 MODULE_PARM_DESC(nvm_file, "NVM file name");
1765
-
1766
-module_param_named(d0i3_disable, iwlwifi_mod_params.d0i3_disable, bool, 0444);
1767
-MODULE_PARM_DESC(d0i3_disable, "disable d0i3 functionality (default: Y)");
1768
-
1769
-module_param_named(lar_disable, iwlwifi_mod_params.lar_disable, bool, 0444);
1770
-MODULE_PARM_DESC(lar_disable, "disable LAR functionality (default: N)");
17711855 
17721856 module_param_named(uapsd_disable, iwlwifi_mod_params.uapsd_disable, uint, 0644);
17731857 MODULE_PARM_DESC(uapsd_disable,
17741858 		 "disable U-APSD functionality bitmap 1: BSS 2: P2P Client (default: 3)");
1859
+module_param_named(enable_ini, iwlwifi_mod_params.enable_ini,
1860
+		   bool, S_IRUGO | S_IWUSR);
1861
+MODULE_PARM_DESC(enable_ini,
1862
+		 "Enable debug INI TLV FW debug infrastructure (default: true");
17751863 
17761864 /*
17771865  * set bt_coex_active to true, uCode will do kill/defer
....@@ -1804,13 +1892,6 @@
18041892 module_param_named(power_level, iwlwifi_mod_params.power_level, int, 0444);
18051893 MODULE_PARM_DESC(power_level,
18061894 		 "default power save level (range from 1 - 5, default: 1)");
1807
-
1808
-module_param_named(fw_monitor, iwlwifi_mod_params.fw_monitor, bool, 0444);
1809
-MODULE_PARM_DESC(fw_monitor,
1810
-		 "firmware monitor - to debug FW (default: false - needs lots of memory)");
1811
-
1812
-module_param_named(d0i3_timeout, iwlwifi_mod_params.d0i3_timeout, uint, 0444);
1813
-MODULE_PARM_DESC(d0i3_timeout, "Timeout to D0i3 entry when idle (ms)");
18141895 
18151896 module_param_named(disable_11ac, iwlwifi_mod_params.disable_11ac, bool, 0444);
18161897 MODULE_PARM_DESC(disable_11ac, "Disable VHT capabilities (default: false)");