diff mbox series

[iwlwifi-next,04/15] wifi: iwlwifi: cfg: reduce configuration struct size

Message ID 20250511195137.38a805a7c96f.Ieece00476cea6054b0827cd075eb8ba5943373df@changeid
State New
Headers show
Series wifi: iwlwifi: updates - 2025-05-11 | expand

Commit Message

Miri Korenblit May 11, 2025, 4:53 p.m. UTC 
From: Johannes Berg <johannes.berg@intel.com>

We don't need the CORES() match nor jacket (which really doesn't
even make sense to match to the RF anyway), and since the subdevice
masks we care about are contiguous, we can encode them as highest
and lowest bit set (automatically.) By encoding whether to match or
not as separate flags and taking advantage of the limited range of
the RF type, step and ID we can reduce the amount of memory needed
for the table, while also making the logic (apart perhaps from the
subdevice mask) easier to understand.

This reduces the size of the module by about 1.5KiB on x86-64.

Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Miri Korenblit <miriam.rachel.korenblit@intel.com>
---
 .../net/wireless/intel/iwlwifi/iwl-config.h   | 26 ++++---
 drivers/net/wireless/intel/iwlwifi/pcie/drv.c | 69 ++++++++-----------
 .../wireless/intel/iwlwifi/tests/devinfo.c    | 69 +++++++++++++++----
 3 files changed, 97 insertions(+), 67 deletions(-)
diff mbox series

Patch

diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-config.h b/drivers/net/wireless/intel/iwlwifi/iwl-config.h
index 84befef470cb..91f22ce36d74 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-config.h
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-config.h
@@ -478,18 +478,22 @@  struct iwl_rf_cfg {
 #define IWL_SUBDEVICE_CORES(subdevice)	((u16)((subdevice) & 0x1C00) >> 10)
 
 struct iwl_dev_info {
-	u16 device;
-	u16 subdevice;
-	u16 subdevice_mask;
-	u16 rf_type;
-	u8 bw_limit;
-	u8 rf_step;
-	u8 rf_id;
-	u8 cores;
-	u8 cdb;
-	u8 jacket;
 	const struct iwl_rf_cfg *cfg;
 	const char *name;
+	u16 device;
+	u16 subdevice;
+	u32 subdevice_m_l:4,
+	    subdevice_m_h:4,
+	    match_rf_type:1,
+	    rf_type:9,
+	    match_bw_limit:1,
+	    bw_limit:1,
+	    match_rf_step:1,
+	    rf_step:4,
+	    match_rf_id:1,
+	    rf_id:4,
+	    match_cdb:1,
+	    cdb:1;
 };
 
 #if IS_ENABLED(CONFIG_IWLWIFI_KUNIT_TESTS)
@@ -497,7 +501,7 @@  extern const struct iwl_dev_info iwl_dev_info_table[];
 extern const unsigned int iwl_dev_info_table_size;
 const struct iwl_dev_info *
 iwl_pci_find_dev_info(u16 device, u16 subsystem_device, u16 rf_type, u8 cdb,
-		      u8 jacket, u8 rf_id, u8 bw_limit, u8 cores, u8 rf_step);
+		      u8 rf_id, u8 bw_limit, u8 rf_step);
 extern const struct pci_device_id iwl_hw_card_ids[];
 #endif
 
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
index 8ffc3a0e7862..52f98aa9a260 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
@@ -557,14 +557,7 @@  EXPORT_SYMBOL_IF_IWLWIFI_KUNIT(iwl_hw_card_ids);
 	.name = _name,				\
 	.device = IWL_CFG_ANY,			\
 	.subdevice = IWL_CFG_ANY,		\
-	.subdevice_mask = ~0,			\
-	.rf_type = IWL_CFG_ANY,			\
-	.rf_step = IWL_CFG_ANY,			\
-	.bw_limit = IWL_CFG_ANY,		\
-	.jacket = IWL_CFG_ANY,			\
-	.cores = IWL_CFG_ANY,			\
-	.rf_id = IWL_CFG_ANY,			\
-	.cdb = IWL_CFG_ANY,			\
+	.subdevice_m_h = 15,			\
 	__VA_ARGS__				\
 }
 #define IWL_DEV_INFO(_cfg, _name, ...)		\
@@ -572,17 +565,22 @@  EXPORT_SYMBOL_IF_IWLWIFI_KUNIT(iwl_hw_card_ids);
 
 #define DEVICE(n)	.device = (n)
 #define SUBDEV(n)	.subdevice = (n)
-#define SUBDEV_MASKED(v, m)			\
-			.subdevice = (v),	\
-			.subdevice_mask = (m)
-#define RF_TYPE(n)	.rf_type = IWL_CFG_RF_TYPE_##n
-#define RF_STEP(n)	.rf_step = SILICON_##n##_STEP
-#define CORES(n)	.cores = IWL_CFG_CORES_##n
-#define RF_ID(n)	.rf_id = IWL_CFG_RF_ID_##n
-#define NO_CDB		.cdb = IWL_CFG_NO_CDB
-#define CDB		.cdb = IWL_CFG_CDB
-#define BW_NOT_LIMITED	.bw_limit = 0
-#define BW_LIMITED	.bw_limit = 1
+#define _LOWEST_BIT(n)	(__builtin_ffs(n) - 1)
+#define _HIGHEST_BIT(n)	(__builtin_ffs((n) + 1) - 2)
+#define _IS_POW2(n)	(((n) & ((n) - 1)) == 0)
+#define _IS_CONTIG(n)	_IS_POW2((n) + (1 << _LOWEST_BIT(n)))
+#define _CHECK_MASK(m)	BUILD_BUG_ON_ZERO(!_IS_CONTIG(m))
+#define SUBDEV_MASKED(v, m) \
+			.subdevice = (v) + _CHECK_MASK(m),	\
+			.subdevice_m_l = _LOWEST_BIT(m),	\
+			.subdevice_m_h = _HIGHEST_BIT(m)
+#define RF_TYPE(n)	.match_rf_type = 1, .rf_type = IWL_CFG_RF_TYPE_##n
+#define RF_STEP(n)	.match_rf_step = 1, .rf_step = SILICON_##n##_STEP
+#define RF_ID(n)	.match_rf_id = 1, .rf_id = IWL_CFG_RF_ID_##n
+#define NO_CDB		.match_cdb = 1, .cdb = 0
+#define CDB		.match_cdb = 1, .cdb = 1
+#define BW_NOT_LIMITED	.match_bw_limit = 1, .bw_limit = 0
+#define BW_LIMITED	.match_bw_limit = 1, .bw_limit = 1
 
 VISIBLE_IF_IWLWIFI_KUNIT const struct iwl_dev_info iwl_dev_info_table[] = {
 #if IS_ENABLED(CONFIG_IWLDVM)
@@ -1214,7 +1212,7 @@  static int map_crf_id(struct iwl_trans *iwl_trans,
 
 VISIBLE_IF_IWLWIFI_KUNIT const struct iwl_dev_info *
 iwl_pci_find_dev_info(u16 device, u16 subsystem_device, u16 rf_type, u8 cdb,
-		      u8 jacket, u8 rf_id, u8 bw_limit, u8 cores, u8 rf_step)
+		      u8 rf_id, u8 bw_limit, u8 rf_step)
 {
 	int num_devices = ARRAY_SIZE(iwl_dev_info_table);
 	int i;
@@ -1224,41 +1222,32 @@  iwl_pci_find_dev_info(u16 device, u16 subsystem_device, u16 rf_type, u8 cdb,
 
 	for (i = num_devices - 1; i >= 0; i--) {
 		const struct iwl_dev_info *dev_info = &iwl_dev_info_table[i];
+		u16 subdevice_mask;
 
 		if (dev_info->device != (u16)IWL_CFG_ANY &&
 		    dev_info->device != device)
 			continue;
 
-		if (dev_info->subdevice != (u16)IWL_CFG_ANY &&
-		    dev_info->subdevice != (subsystem_device & dev_info->subdevice_mask))
-			continue;
+		subdevice_mask = GENMASK(dev_info->subdevice_m_h,
+					 dev_info->subdevice_m_l);
 
-		if (dev_info->rf_type != (u16)IWL_CFG_ANY &&
-		    dev_info->rf_type != rf_type)
-			continue;
-
-		if (dev_info->cdb != (u8)IWL_CFG_ANY &&
-		    dev_info->cdb != cdb)
+		if (dev_info->subdevice != (u16)IWL_CFG_ANY &&
+		    dev_info->subdevice != (subsystem_device & subdevice_mask))
 			continue;
 
-		if (dev_info->jacket != (u8)IWL_CFG_ANY &&
-		    dev_info->jacket != jacket)
+		if (dev_info->match_rf_type && dev_info->rf_type != rf_type)
 			continue;
 
-		if (dev_info->rf_id != (u8)IWL_CFG_ANY &&
-		    dev_info->rf_id != rf_id)
+		if (dev_info->match_cdb && dev_info->cdb != cdb)
 			continue;
 
-		if (dev_info->bw_limit != (u8)IWL_CFG_ANY &&
-		    dev_info->bw_limit != bw_limit)
+		if (dev_info->match_rf_id && dev_info->rf_id != rf_id)
 			continue;
 
-		if (dev_info->cores != (u8)IWL_CFG_ANY &&
-		    dev_info->cores != cores)
+		if (dev_info->match_bw_limit && dev_info->bw_limit != bw_limit)
 			continue;
 
-		if (dev_info->rf_step != (u8)IWL_CFG_ANY &&
-		    dev_info->rf_step != rf_step)
+		if (dev_info->match_rf_step && dev_info->rf_step != rf_step)
 			continue;
 
 		return dev_info;
@@ -1378,10 +1367,8 @@  static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 	dev_info = iwl_pci_find_dev_info(pdev->device, pdev->subsystem_device,
 					 CSR_HW_RFID_TYPE(info.hw_rf_id),
 					 CSR_HW_RFID_IS_CDB(info.hw_rf_id),
-					 CSR_HW_RFID_IS_JACKET(info.hw_rf_id),
 					 IWL_SUBDEVICE_RF_ID(pdev->subsystem_device),
 					 IWL_SUBDEVICE_BW_LIM(pdev->subsystem_device),
-					 IWL_SUBDEVICE_CORES(pdev->subsystem_device),
 					 CSR_HW_RFID_STEP(info.hw_rf_id));
 	if (dev_info) {
 		iwl_trans->cfg = dev_info->cfg;
diff --git a/drivers/net/wireless/intel/iwlwifi/tests/devinfo.c b/drivers/net/wireless/intel/iwlwifi/tests/devinfo.c
index 69b26de4aff8..784433bb246a 100644
--- a/drivers/net/wireless/intel/iwlwifi/tests/devinfo.c
+++ b/drivers/net/wireless/intel/iwlwifi/tests/devinfo.c
@@ -13,10 +13,50 @@  MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
 
 static void iwl_pci_print_dev_info(const char *pfx, const struct iwl_dev_info *di)
 {
-	printk(KERN_DEBUG "%sdev=%.4x subdev=%.4x rf_type=%.4x cdb=%d jacket=%d rf_id=%.2x bw_limit=%d cores=%.2x\n",
-	       pfx, di->device, di->subdevice,
-	       di->rf_type, di->cdb, di->jacket, di->rf_id, di->bw_limit,
-	       di->cores);
+	u16 subdevice_mask = GENMASK(di->subdevice_m_h, di->subdevice_m_l);
+	char buf[100] = {};
+	int pos = 0;
+
+	if (di->match_rf_type)
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " rf_type=%03x", di->rf_type);
+	else
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " rf_type=*");
+
+	if (di->match_bw_limit)
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " bw_limit=%d", di->bw_limit);
+	else
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " bw_limit=*");
+
+	if (di->match_rf_step)
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " rf_step=%c",
+				 di->rf_step == SILICON_Z_STEP ? 'Z' :
+				 	'A' + di->rf_step);
+	else
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " rf_step=*");
+
+	if (di->match_rf_id)
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " rf_id=0x%x", di->rf_id);
+	else
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " rf_id=*");
+
+	if (di->match_cdb)
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " cdb=%d", di->cdb);
+	else
+		pos += scnprintf(buf + pos, sizeof(buf) - pos,
+				 " cdb=*");
+
+
+	printk(KERN_DEBUG "%sdev=%04x subdev=%04x/%04x%s\n",
+	       pfx, di->device, di->subdevice, subdevice_mask, buf);
 }
 
 static void devinfo_table_order(struct kunit *test)
@@ -29,9 +69,8 @@  static void devinfo_table_order(struct kunit *test)
 
 		ret = iwl_pci_find_dev_info(di->device, di->subdevice,
 					    di->rf_type, di->cdb,
-					    di->jacket, di->rf_id,
-					    di->bw_limit,
-					    di->cores, di->rf_step);
+					    di->rf_id, di->bw_limit,
+					    di->rf_step);
 		if (!ret) {
 			iwl_pci_print_dev_info("No entry found for: ", di);
 			KUNIT_FAIL(test,
@@ -98,25 +137,25 @@  static void devinfo_check_subdev_match(struct kunit *test)
 {
 	for (int i = 0; i < iwl_dev_info_table_size; i++) {
 		const struct iwl_dev_info *di = &iwl_dev_info_table[i];
+		u16 subdevice_mask = GENMASK(di->subdevice_m_h,
+					     di->subdevice_m_l);
 
 		/* if BW limit bit is matched then must have a limit */
-		if (di->bw_limit == 1)
+		if (di->match_bw_limit == 1 && di->bw_limit == 1)
 			KUNIT_EXPECT_NE(test, di->cfg->bw_limit, 0);
 
-		/* if subdevice is ANY we can have RF ID/BW limit/cores */
+		/* if subdevice is ANY we can have RF ID/BW limit */
 		if (di->subdevice == (u16)IWL_CFG_ANY)
 			continue;
 
 		/* same if the subdevice mask doesn't overlap them */
-		if (IWL_SUBDEVICE_RF_ID(di->subdevice_mask) == 0 &&
-		    IWL_SUBDEVICE_BW_LIM(di->subdevice_mask) == 0 &&
-		    IWL_SUBDEVICE_CORES(di->subdevice_mask) == 0)
+		if (IWL_SUBDEVICE_RF_ID(subdevice_mask) == 0 &&
+		    IWL_SUBDEVICE_BW_LIM(subdevice_mask) == 0)
 			continue;
 
 		/* but otherwise they shouldn't be used */
-		KUNIT_EXPECT_EQ(test, di->rf_id, (u8)IWL_CFG_ANY);
-		KUNIT_EXPECT_EQ(test, di->bw_limit, (u8)IWL_CFG_ANY);
-		KUNIT_EXPECT_EQ(test, di->cores, (u8)IWL_CFG_ANY);
+		KUNIT_EXPECT_EQ(test, (int)di->match_rf_id, 0);
+		KUNIT_EXPECT_EQ(test, (int)di->match_bw_limit, 0);
 	}
 }