1// SPDX-License-Identifier: GPL-2.0-only
 2/* Copyright(c) 2022 Intel Corporation. */
 3
 
 4#include <linux/module.h>
 5#include <linux/kdev_t.h>
 6#include <linux/semaphore.h>
 7#include <linux/slab.h>
 8
 9#include <asm/cpu_device_id.h>
10
11#include "ifs.h"
12
13#define X86_MATCH(model)				\
14	X86_MATCH_VENDOR_FAM_MODEL_FEATURE(INTEL, 6,	\
15		INTEL_FAM6_##model, X86_FEATURE_CORE_CAPABILITIES, NULL)
16
17static const struct x86_cpu_id ifs_cpu_ids[] __initconst = {
18	X86_MATCH(SAPPHIRERAPIDS_X),
 
 
 
 
19	{}
20};
21MODULE_DEVICE_TABLE(x86cpu, ifs_cpu_ids);
22
23static struct ifs_device ifs_device = {
24	.data = {
25		.integrity_cap_bit = MSR_INTEGRITY_CAPS_PERIODIC_BIST_BIT,
26		.test_num = 0,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
27	},
28	.misc = {
29		.name = "intel_ifs_0",
30		.nodename = "intel_ifs/0",
31		.minor = MISC_DYNAMIC_MINOR,
 
 
 
32	},
33};
34
 
 
 
 
 
 
 
 
 
 
 
 
 
35static int __init ifs_init(void)
36{
37	const struct x86_cpu_id *m;
38	u64 msrval;
39	int ret;
40
41	m = x86_match_cpu(ifs_cpu_ids);
42	if (!m)
43		return -ENODEV;
44
45	if (rdmsrl_safe(MSR_IA32_CORE_CAPS, &msrval))
46		return -ENODEV;
47
48	if (!(msrval & MSR_IA32_CORE_CAPS_INTEGRITY_CAPS))
49		return -ENODEV;
50
51	if (rdmsrl_safe(MSR_INTEGRITY_CAPS, &msrval))
52		return -ENODEV;
53
54	ifs_device.misc.groups = ifs_get_groups();
55
56	if (!(msrval & BIT(ifs_device.data.integrity_cap_bit)))
57		return -ENODEV;
58
59	ifs_device.data.pkg_auth = kmalloc_array(topology_max_packages(), sizeof(bool), GFP_KERNEL);
60	if (!ifs_device.data.pkg_auth)
61		return -ENOMEM;
62
63	ret = misc_register(&ifs_device.misc);
64	if (ret) {
65		kfree(ifs_device.data.pkg_auth);
66		return ret;
 
 
 
 
 
67	}
68
69	return 0;
 
 
 
 
70}
71
72static void __exit ifs_exit(void)
73{
74	misc_deregister(&ifs_device.misc);
75	kfree(ifs_device.data.pkg_auth);
76}
77
78module_init(ifs_init);
79module_exit(ifs_exit);
80
81MODULE_LICENSE("GPL");
82MODULE_DESCRIPTION("Intel In Field Scan (IFS) device");

  1// SPDX-License-Identifier: GPL-2.0-only
  2/* Copyright(c) 2022 Intel Corporation. */
  3
  4#include <linux/bitfield.h>
  5#include <linux/module.h>
  6#include <linux/kdev_t.h>
  7#include <linux/semaphore.h>
  8#include <linux/slab.h>
  9
 10#include <asm/cpu_device_id.h>
 11
 12#include "ifs.h"
 13
 14#define X86_MATCH(model, array_gen)				\
 15	X86_MATCH_VENDOR_FAM_MODEL_FEATURE(INTEL, 6,	\
 16		INTEL_FAM6_##model, X86_FEATURE_CORE_CAPABILITIES, array_gen)
 17
 18static const struct x86_cpu_id ifs_cpu_ids[] __initconst = {
 19	X86_MATCH(SAPPHIRERAPIDS_X, ARRAY_GEN0),
 20	X86_MATCH(EMERALDRAPIDS_X, ARRAY_GEN0),
 21	X86_MATCH(GRANITERAPIDS_X, ARRAY_GEN0),
 22	X86_MATCH(GRANITERAPIDS_D, ARRAY_GEN0),
 23	X86_MATCH(ATOM_CRESTMONT_X, ARRAY_GEN1),
 24	{}
 25};
 26MODULE_DEVICE_TABLE(x86cpu, ifs_cpu_ids);
 27
 28ATTRIBUTE_GROUPS(plat_ifs);
 29ATTRIBUTE_GROUPS(plat_ifs_array);
 30
 31bool *ifs_pkg_auth;
 32
 33static const struct ifs_test_caps scan_test = {
 34	.integrity_cap_bit = MSR_INTEGRITY_CAPS_PERIODIC_BIST_BIT,
 35	.test_num = IFS_TYPE_SAF,
 36};
 37
 38static const struct ifs_test_caps array_test = {
 39	.integrity_cap_bit = MSR_INTEGRITY_CAPS_ARRAY_BIST_BIT,
 40	.test_num = IFS_TYPE_ARRAY_BIST,
 41};
 42
 43static struct ifs_device ifs_devices[] = {
 44	[IFS_TYPE_SAF] = {
 45		.test_caps = &scan_test,
 46		.misc = {
 47			.name = "intel_ifs_0",
 48			.minor = MISC_DYNAMIC_MINOR,
 49			.groups = plat_ifs_groups,
 50		},
 51	},
 52	[IFS_TYPE_ARRAY_BIST] = {
 53		.test_caps = &array_test,
 54		.misc = {
 55			.name = "intel_ifs_1",
 56			.minor = MISC_DYNAMIC_MINOR,
 57			.groups = plat_ifs_array_groups,
 58		},
 59	},
 60};
 61
 62#define IFS_NUMTESTS ARRAY_SIZE(ifs_devices)
 63
 64static void ifs_cleanup(void)
 65{
 66	int i;
 67
 68	for (i = 0; i < IFS_NUMTESTS; i++) {
 69		if (ifs_devices[i].misc.this_device)
 70			misc_deregister(&ifs_devices[i].misc);
 71	}
 72	kfree(ifs_pkg_auth);
 73}
 74
 75static int __init ifs_init(void)
 76{
 77	const struct x86_cpu_id *m;
 78	u64 msrval;
 79	int i, ret;
 80
 81	m = x86_match_cpu(ifs_cpu_ids);
 82	if (!m)
 83		return -ENODEV;
 84
 85	if (rdmsrl_safe(MSR_IA32_CORE_CAPS, &msrval))
 86		return -ENODEV;
 87
 88	if (!(msrval & MSR_IA32_CORE_CAPS_INTEGRITY_CAPS))
 89		return -ENODEV;
 90
 91	if (rdmsrl_safe(MSR_INTEGRITY_CAPS, &msrval))
 92		return -ENODEV;
 93
 94	ifs_pkg_auth = kmalloc_array(topology_max_packages(), sizeof(bool), GFP_KERNEL);
 95	if (!ifs_pkg_auth)
 
 
 
 
 
 96		return -ENOMEM;
 97
 98	for (i = 0; i < IFS_NUMTESTS; i++) {
 99		if (!(msrval & BIT(ifs_devices[i].test_caps->integrity_cap_bit)))
100			continue;
101		ifs_devices[i].rw_data.generation = FIELD_GET(MSR_INTEGRITY_CAPS_SAF_GEN_MASK,
102							      msrval);
103		ifs_devices[i].rw_data.array_gen = (u32)m->driver_data;
104		ret = misc_register(&ifs_devices[i].misc);
105		if (ret)
106			goto err_exit;
107	}
 
108	return 0;
109
110err_exit:
111	ifs_cleanup();
112	return ret;
113}
114
115static void __exit ifs_exit(void)
116{
117	ifs_cleanup();
 
118}
119
120module_init(ifs_init);
121module_exit(ifs_exit);
122
123MODULE_LICENSE("GPL");
124MODULE_DESCRIPTION("Intel In Field Scan (IFS) device");