| // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause | |
| /* | |
| * KUnit tests for the iwlwifi device info table | |
| * | |
| * Copyright (C) 2023-2025 Intel Corporation | |
| */ | |
| #include <kunit/test.h> | |
| #include <linux/pci.h> | |
| #include "iwl-drv.h" | |
| #include "iwl-config.h" | |
| MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING"); | |
| static void iwl_pci_print_dev_info(const char *pfx, const struct iwl_dev_info *di) | |
| { | |
| 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_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=*"); | |
| if (di->match_discrete) | |
| pos += scnprintf(buf + pos, sizeof(buf) - pos, | |
| " discrete=%d", | |
| di->discrete); | |
| else | |
| pos += scnprintf(buf + pos, sizeof(buf) - pos, | |
| " discrete=*"); | |
| 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) | |
| { | |
| int idx; | |
| for (idx = 0; idx < iwl_dev_info_table_size; idx++) { | |
| const struct iwl_dev_info *di = &iwl_dev_info_table[idx]; | |
| const struct iwl_dev_info *ret; | |
| ret = iwl_pci_find_dev_info(di->device, di->subdevice, | |
| di->rf_type, di->cdb, | |
| di->rf_id, di->bw_limit, | |
| di->discrete); | |
| if (!ret) { | |
| iwl_pci_print_dev_info("No entry found for: ", di); | |
| KUNIT_FAIL(test, | |
| "No entry found for entry at index %d\n", idx); | |
| } else if (ret != di) { | |
| iwl_pci_print_dev_info("searched: ", di); | |
| iwl_pci_print_dev_info("found: ", ret); | |
| KUNIT_FAIL(test, | |
| "unusable entry at index %d (found index %d instead)\n", | |
| idx, (int)(ret - iwl_dev_info_table)); | |
| } | |
| } | |
| } | |
| static void devinfo_discrete_match(struct kunit *test) | |
| { | |
| /* | |
| * Validate that any entries with discrete/integrated match have | |
| * the same config with the value inverted (if they match at all.) | |
| */ | |
| for (int idx = 0; idx < iwl_dev_info_table_size; idx++) { | |
| const struct iwl_dev_info *di = &iwl_dev_info_table[idx]; | |
| const struct iwl_dev_info *ret; | |
| if (!di->match_discrete) | |
| continue; | |
| ret = iwl_pci_find_dev_info(di->device, di->subdevice, | |
| di->rf_type, di->cdb, | |
| di->rf_id, di->bw_limit, | |
| !di->discrete); | |
| if (!ret) | |
| continue; | |
| KUNIT_EXPECT_PTR_EQ(test, di->cfg, ret->cfg); | |
| /* and check the name is different, that'd be the point of it */ | |
| KUNIT_EXPECT_NE(test, strcmp(di->name, ret->name), 0); | |
| } | |
| } | |
| static void devinfo_names(struct kunit *test) | |
| { | |
| int idx; | |
| for (idx = 0; idx < iwl_dev_info_table_size; idx++) { | |
| const struct iwl_dev_info *di = &iwl_dev_info_table[idx]; | |
| KUNIT_ASSERT_TRUE(test, di->name); | |
| } | |
| } | |
| static void devinfo_no_cfg_dups(struct kunit *test) | |
| { | |
| for (int i = 0; i < iwl_dev_info_table_size; i++) { | |
| const struct iwl_rf_cfg *cfg_i = iwl_dev_info_table[i].cfg; | |
| for (int j = 0; j < i; j++) { | |
| const struct iwl_rf_cfg *cfg_j = iwl_dev_info_table[j].cfg; | |
| if (cfg_i == cfg_j) | |
| continue; | |
| KUNIT_EXPECT_NE_MSG(test, memcmp(cfg_i, cfg_j, | |
| sizeof(*cfg_i)), 0, | |
| "identical configs: %ps and %ps\n", | |
| cfg_i, cfg_j); | |
| } | |
| } | |
| } | |
| static void devinfo_no_name_dups(struct kunit *test) | |
| { | |
| for (int i = 0; i < iwl_dev_info_table_size; i++) { | |
| for (int j = 0; j < i; j++) { | |
| if (iwl_dev_info_table[i].name == iwl_dev_info_table[j].name) | |
| continue; | |
| KUNIT_EXPECT_NE_MSG(test, | |
| strcmp(iwl_dev_info_table[i].name, | |
| iwl_dev_info_table[j].name), | |
| 0, | |
| "name dup: %ps/%ps", | |
| iwl_dev_info_table[i].name, | |
| iwl_dev_info_table[j].name); | |
| } | |
| } | |
| } | |
| 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->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 */ | |
| if (di->subdevice == (u16)IWL_CFG_ANY) | |
| continue; | |
| /* same if the subdevice mask doesn't overlap them */ | |
| 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, (int)di->match_rf_id, 0); | |
| KUNIT_EXPECT_EQ(test, (int)di->match_bw_limit, 0); | |
| } | |
| } | |
| static void devinfo_check_killer_subdev(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]; | |
| if (!strstr(di->name, "Killer")) | |
| continue; | |
| KUNIT_EXPECT_NE(test, di->subdevice, (u16)IWL_CFG_ANY); | |
| } | |
| } | |
| static void devinfo_pci_ids(struct kunit *test) | |
| { | |
| struct pci_dev *dev; | |
| dev = kunit_kmalloc(test, sizeof(*dev), GFP_KERNEL); | |
| KUNIT_ASSERT_NOT_NULL(test, dev); | |
| for (int i = 0; iwl_hw_card_ids[i].vendor; i++) { | |
| const struct pci_device_id *s, *t; | |
| s = &iwl_hw_card_ids[i]; | |
| dev->vendor = s->vendor; | |
| dev->device = s->device; | |
| dev->subsystem_vendor = s->subvendor; | |
| dev->subsystem_device = s->subdevice; | |
| dev->class = s->class; | |
| t = pci_match_id(iwl_hw_card_ids, dev); | |
| KUNIT_EXPECT_PTR_EQ(test, t, s); | |
| } | |
| } | |
| static void devinfo_no_mac_cfg_dups(struct kunit *test) | |
| { | |
| for (int i = 0; iwl_hw_card_ids[i].vendor; i++) { | |
| const struct iwl_mac_cfg *cfg_i = | |
| (void *)iwl_hw_card_ids[i].driver_data; | |
| for (int j = 0; j < i; j++) { | |
| const struct iwl_mac_cfg *cfg_j = | |
| (void *)iwl_hw_card_ids[j].driver_data; | |
| if (cfg_i == cfg_j) | |
| continue; | |
| KUNIT_EXPECT_NE_MSG(test, memcmp(cfg_j, cfg_i, | |
| sizeof(*cfg_i)), 0, | |
| "identical configs: %ps and %ps\n", | |
| cfg_i, cfg_j); | |
| } | |
| } | |
| } | |
| static void devinfo_api_range(struct kunit *test) | |
| { | |
| /* Check that all iwl_mac_cfg's have either both min and max set, or neither */ | |
| for (int i = 0; iwl_hw_card_ids[i].vendor; i++) { | |
| const struct iwl_mac_cfg *mac_cfg = | |
| (void *)iwl_hw_card_ids[i].driver_data; | |
| const struct iwl_family_base_params *base = mac_cfg->base; | |
| KUNIT_EXPECT_EQ_MSG(test, !!base->ucode_api_min, | |
| !!base->ucode_api_max, | |
| "%ps: ucode_api_min (%u) and ucode_api_min (%u) should be both set or neither.\n", | |
| base, base->ucode_api_min, | |
| base->ucode_api_max); | |
| } | |
| /* Check the same for the iwl_rf_cfg's */ | |
| for (int i = 0; i < iwl_dev_info_table_size; i++) { | |
| const struct iwl_rf_cfg *rf_cfg = iwl_dev_info_table[i].cfg; | |
| KUNIT_EXPECT_EQ_MSG(test, !!rf_cfg->ucode_api_min, | |
| !!rf_cfg->ucode_api_max, | |
| "%ps: ucode_api_min (%u) and ucode_api_min (%u) should be both set or neither.\n", | |
| rf_cfg, rf_cfg->ucode_api_min, | |
| rf_cfg->ucode_api_max); | |
| } | |
| } | |
| static void devinfo_pci_ids_config(struct kunit *test) | |
| { | |
| for (int i = 0; iwl_hw_card_ids[i].vendor; i++) { | |
| const struct pci_device_id *s = &iwl_hw_card_ids[i]; | |
| const struct iwl_dev_info *di; | |
| if (s->device == PCI_ANY_ID || s->subdevice == PCI_ANY_ID) | |
| continue; | |
| #if IS_ENABLED(CONFIG_IWLMVM) || IS_ENABLED(CONFIG_IWLMLD) | |
| /* | |
| * The check below only works for old (pre-CNVI) devices. Most | |
| * new have subdevice==ANY, so are already skipped, but for some | |
| * Bz platform(s) we list all the RF PCI IDs. Skip those too. | |
| */ | |
| if (s->driver_data == (kernel_ulong_t)&iwl_bz_mac_cfg) | |
| continue; | |
| #endif | |
| di = iwl_pci_find_dev_info(s->device, s->subdevice, | |
| 0, 0, 0, 0, true); | |
| KUNIT_EXPECT_PTR_NE_MSG(test, di, NULL, | |
| "PCI ID %04x:%04x not found\n", | |
| s->device, s->subdevice); | |
| } | |
| } | |
| static struct kunit_case devinfo_test_cases[] = { | |
| KUNIT_CASE(devinfo_table_order), | |
| KUNIT_CASE(devinfo_discrete_match), | |
| KUNIT_CASE(devinfo_names), | |
| KUNIT_CASE(devinfo_no_cfg_dups), | |
| KUNIT_CASE(devinfo_no_name_dups), | |
| KUNIT_CASE(devinfo_check_subdev_match), | |
| KUNIT_CASE(devinfo_check_killer_subdev), | |
| KUNIT_CASE(devinfo_pci_ids), | |
| KUNIT_CASE(devinfo_no_mac_cfg_dups), | |
| KUNIT_CASE(devinfo_api_range), | |
| KUNIT_CASE(devinfo_pci_ids_config), | |
| {} | |
| }; | |
| static struct kunit_suite iwlwifi_devinfo = { | |
| .name = "iwlwifi-devinfo", | |
| .test_cases = devinfo_test_cases, | |
| }; | |
| kunit_test_suite(iwlwifi_devinfo); |