ifs.h

  1/* SPDX-License-Identifier: GPL-2.0-only */
  2/* Copyright(c) 2022 Intel Corporation. */
  3
  4#ifndef _IFS_H_
  5#define _IFS_H_
  6
  7/**
  8 * DOC: In-Field Scan
  9 *
 10 * =============
 11 * In-Field Scan
 12 * =============
 13 *
 14 * Introduction
 15 * ------------
 16 *
 17 * In Field Scan (IFS) is a hardware feature to run circuit level tests on
 18 * a CPU core to detect problems that are not caught by parity or ECC checks.
 19 * Future CPUs will support more than one type of test which will show up
 20 * with a new platform-device instance-id.
 21 *
 22 *
 23 * IFS Image
 24 * ---------
 25 *
 26 * Intel provides firmware files containing the scan tests via the webpage [#f1]_.
 27 * Look under "In-Field Scan Test Images Download" section towards the
 28 * end of the page. Similar to microcode, there are separate files for each
 29 * family-model-stepping. IFS Images are not applicable for some test types.
 30 * Wherever applicable the sysfs directory would provide a "current_batch" file
 31 * (see below) for loading the image.
 32 *
 33 * .. [#f1] https://intel.com/InFieldScan
 34 *
 35 * IFS Image Loading
 36 * -----------------
 37 *
 38 * The driver loads the tests into memory reserved BIOS local to each CPU
 39 * socket in a two step process using writes to MSRs to first load the
 40 * SHA hashes for the test. Then the tests themselves. Status MSRs provide
 41 * feedback on the success/failure of these steps.
 42 *
 43 * The test files are kept in a fixed location: /lib/firmware/intel/ifs_<n>/
 44 * For e.g if there are 3 test files, they would be named in the following
 45 * fashion:
 46 * ff-mm-ss-01.scan
 47 * ff-mm-ss-02.scan
 48 * ff-mm-ss-03.scan
 49 * (where ff refers to family, mm indicates model and ss indicates stepping)
 50 *
 51 * A different test file can be loaded by writing the numerical portion
 52 * (e.g 1, 2 or 3 in the above scenario) into the curent_batch file.
 53 * To load ff-mm-ss-02.scan, the following command can be used::
 54 *
 55 *   # echo 2 > /sys/devices/virtual/misc/intel_ifs_<n>/current_batch
 56 *
 57 * The above file can also be read to know the currently loaded image.
 58 *
 59 * Running tests
 60 * -------------
 61 *
 62 * Tests are run by the driver synchronizing execution of all threads on a
 63 * core and then writing to the ACTIVATE_SCAN MSR on all threads. Instruction
 64 * execution continues when:
 65 *
 66 * 1) All tests have completed.
 67 * 2) Execution was interrupted.
 68 * 3) A test detected a problem.
 69 *
 70 * Note that ALL THREADS ON THE CORE ARE EFFECTIVELY OFFLINE FOR THE
 71 * DURATION OF THE TEST. This can be up to 200 milliseconds. If the system
 72 * is running latency sensitive applications that cannot tolerate an
 73 * interruption of this magnitude, the system administrator must arrange
 74 * to migrate those applications to other cores before running a core test.
 75 * It may also be necessary to redirect interrupts to other CPUs.
 76 *
 77 * In all cases reading the corresponding test's STATUS MSR provides details on what
 78 * happened. The driver makes the value of this MSR visible to applications
 79 * via the "details" file (see below). Interrupted tests may be restarted.
 80 *
 81 * The IFS driver provides sysfs interfaces via /sys/devices/virtual/misc/intel_ifs_<n>/
 82 * to control execution:
 83 *
 84 * Test a specific core::
 85 *
 86 *   # echo <cpu#> > /sys/devices/virtual/misc/intel_ifs_<n>/run_test
 87 *
 88 * when HT is enabled any of the sibling cpu# can be specified to test
 89 * its corresponding physical core. Since the tests are per physical core,
 90 * the result of testing any thread is same. All siblings must be online
 91 * to run a core test. It is only necessary to test one thread.
 92 *
 93 * For e.g. to test core corresponding to cpu5
 94 *
 95 *   # echo 5 > /sys/devices/virtual/misc/intel_ifs_<n>/run_test
 96 *
 97 * Results of the last test is provided in /sys::
 98 *
 99 *   $ cat /sys/devices/virtual/misc/intel_ifs_<n>/status
100 *   pass
101 *
102 * Status can be one of pass, fail, untested
103 *
104 * Additional details of the last test is provided by the details file::
105 *
106 *   $ cat /sys/devices/virtual/misc/intel_ifs_<n>/details
107 *   0x8081
108 *
109 * The details file reports the hex value of the test specific status MSR.
110 * Hardware defined error codes are documented in volume 4 of the Intel
111 * Software Developer's Manual but the error_code field may contain one of
112 * the following driver defined software codes:
113 *
114 * +------+--------------------+
115 * | 0xFD | Software timeout   |
116 * +------+--------------------+
117 * | 0xFE | Partial completion |
118 * +------+--------------------+
119 *
120 * Driver design choices
121 * ---------------------
122 *
123 * 1) The ACTIVATE_SCAN MSR allows for running any consecutive subrange of
124 * available tests. But the driver always tries to run all tests and only
125 * uses the subrange feature to restart an interrupted test.
126 *
127 * 2) Hardware allows for some number of cores to be tested in parallel.
128 * The driver does not make use of this, it only tests one core at a time.
129 *
130 * Structural Based Functional Test at Field (SBAF):
131 * -------------------------------------------------
132 *
133 * SBAF is a new type of testing that provides comprehensive core test
134 * coverage complementing Scan at Field (SAF) testing. SBAF mimics the
135 * manufacturing screening environment and leverages the same test suite.
136 * It makes use of Design For Test (DFT) observation sites and features
137 * to maximize coverage in minimum time.
138 *
139 * Similar to the SAF test, SBAF isolates the core under test from the
140 * rest of the system during execution. Upon completion, the core
141 * seamlessly resets to its pre-test state and resumes normal operation.
142 * Any machine checks or hangs encountered during the test are confined to
143 * the isolated core, preventing disruption to the overall system.
144 *
145 * Like the SAF test, the SBAF test is also divided into multiple batches,
146 * and each batch test can take hundreds of milliseconds (100-200 ms) to
147 * complete. If such a lengthy interruption is undesirable, it is
148 * recommended to relocate the time-sensitive applications to other cores.
149 */
150#include <linux/device.h>
151#include <linux/miscdevice.h>
152
153#define MSR_ARRAY_BIST				0x00000105
154
155#define MSR_COPY_SBAF_HASHES			0x000002b8
156#define MSR_SBAF_HASHES_STATUS			0x000002b9
157#define MSR_AUTHENTICATE_AND_COPY_SBAF_CHUNK	0x000002ba
158#define MSR_SBAF_CHUNKS_AUTHENTICATION_STATUS	0x000002bb
159#define MSR_ACTIVATE_SBAF			0x000002bc
160#define MSR_SBAF_STATUS				0x000002bd
161
162#define MSR_COPY_SCAN_HASHES			0x000002c2
163#define MSR_SCAN_HASHES_STATUS			0x000002c3
164#define MSR_AUTHENTICATE_AND_COPY_CHUNK		0x000002c4
165#define MSR_CHUNKS_AUTHENTICATION_STATUS	0x000002c5
166#define MSR_ACTIVATE_SCAN			0x000002c6
167#define MSR_SCAN_STATUS				0x000002c7
168#define MSR_ARRAY_TRIGGER			0x000002d6
169#define MSR_ARRAY_STATUS			0x000002d7
170#define MSR_SAF_CTRL				0x000004f0
171#define MSR_SBAF_CTRL				0x000004f8
172
173#define SCAN_NOT_TESTED				0
174#define SCAN_TEST_PASS				1
175#define SCAN_TEST_FAIL				2
176
177#define IFS_TYPE_SAF			0
178#define IFS_TYPE_ARRAY_BIST		1
179#define IFS_TYPE_SBAF			2
180
181#define ARRAY_GEN0			0
182#define ARRAY_GEN1			1
183
184/* MSR_SCAN_HASHES_STATUS bit fields */
185union ifs_scan_hashes_status {
186	u64	data;
187	struct {
188		u32	chunk_size	:16;
189		u32	num_chunks	:8;
190		u32	rsvd1		:8;
191		u32	error_code	:8;
192		u32	rsvd2		:11;
193		u32	max_core_limit	:12;
194		u32	valid		:1;
195	};
196};
197
198union ifs_scan_hashes_status_gen2 {
199	u64	data;
200	struct {
201		u16	chunk_size;
202		u16	num_chunks;
203		u32	error_code		:8;
204		u32	chunks_in_stride	:9;
205		u32	rsvd			:2;
206		u32	max_core_limit		:12;
207		u32	valid			:1;
208	};
209};
210
211/* MSR_CHUNKS_AUTH_STATUS bit fields */
212union ifs_chunks_auth_status {
213	u64	data;
214	struct {
215		u32	valid_chunks	:8;
216		u32	total_chunks	:8;
217		u32	rsvd1		:16;
218		u32	error_code	:8;
219		u32	rsvd2		:24;
220	};
221};
222
223union ifs_chunks_auth_status_gen2 {
224	u64	data;
225	struct {
226		u16	valid_chunks;
227		u16	total_chunks;
228		u32	error_code	:8;
229		u32	rsvd2		:8;
230		u32	max_bundle	:16;
231	};
232};
233
234/* MSR_ACTIVATE_SCAN bit fields */
235union ifs_scan {
236	u64	data;
237	struct {
238		union {
239			struct {
240				u8	start;
241				u8	stop;
242				u16	rsvd;
243			} gen0;
244			struct {
245				u16	start;
246				u16	stop;
247			} gen2;
248		};
249		u32	delay	:31;
250		u32	sigmce	:1;
251	};
252};
253
254/* MSR_SCAN_STATUS bit fields */
255union ifs_status {
256	u64	data;
257	struct {
258		union {
259			struct {
260				u8	chunk_num;
261				u8	chunk_stop_index;
262				u16	rsvd1;
263			} gen0;
264			struct {
265				u16	chunk_num;
266				u16	chunk_stop_index;
267			} gen2;
268		};
269		u32	error_code		:8;
270		u32	rsvd2			:22;
271		u32	control_error		:1;
272		u32	signature_error		:1;
273	};
274};
275
276/* MSR_ARRAY_BIST bit fields */
277union ifs_array {
278	u64	data;
279	struct {
280		u32	array_bitmask;
281		u16	array_bank;
282		u16	rsvd			:15;
283		u16	ctrl_result		:1;
284	};
285};
286
287/* MSR_ACTIVATE_SBAF bit fields */
288union ifs_sbaf {
289	u64	data;
290	struct {
291		u32	bundle_idx	:9;
292		u32	rsvd1		:5;
293		u32	pgm_idx		:2;
294		u32	rsvd2		:16;
295		u32	delay		:31;
296		u32	sigmce		:1;
297	};
298};
299
300/* MSR_SBAF_STATUS bit fields */
301union ifs_sbaf_status {
302	u64	data;
303	struct {
304		u32	bundle_idx	:9;
305		u32	rsvd1		:5;
306		u32	pgm_idx		:2;
307		u32	rsvd2		:16;
308		u32	error_code	:8;
309		u32	rsvd3		:21;
310		u32	test_fail	:1;
311		u32	sbaf_status	:2;
312	};
313};
314
315/*
316 * Driver populated error-codes
317 * 0xFD: Test timed out before completing all the chunks.
318 * 0xFE: not all scan chunks were executed. Maximum forward progress retries exceeded.
319 */
320#define IFS_SW_TIMEOUT				0xFD
321#define IFS_SW_PARTIAL_COMPLETION		0xFE
322
323#define IFS_SUFFIX_SZ		5
324
325struct ifs_test_caps {
326	int	integrity_cap_bit;
327	int	test_num;
328	char	image_suffix[IFS_SUFFIX_SZ];
329};
330
331/**
332 * struct ifs_test_msrs - MSRs used in IFS tests
333 * @copy_hashes: Copy test hash data
334 * @copy_hashes_status: Status of copied test hash data
335 * @copy_chunks: Copy chunks of the test data
336 * @copy_chunks_status: Status of the copied test data chunks
337 * @test_ctrl: Control the test attributes
338 */
339struct ifs_test_msrs {
340	u32	copy_hashes;
341	u32	copy_hashes_status;
342	u32	copy_chunks;
343	u32	copy_chunks_status;
344	u32	test_ctrl;
345};
346
347/**
348 * struct ifs_data - attributes related to intel IFS driver
349 * @loaded_version: stores the currently loaded ifs image version.
350 * @loaded: If a valid test binary has been loaded into the memory
351 * @loading_error: Error occurred on another CPU while loading image
352 * @valid_chunks: number of chunks which could be validated.
353 * @status: it holds simple status pass/fail/untested
354 * @scan_details: opaque scan status code from h/w
355 * @cur_batch: number indicating the currently loaded test file
356 * @generation: IFS test generation enumerated by hardware
357 * @chunk_size: size of a test chunk
358 * @array_gen: test generation of array test
359 * @max_bundle: maximum bundle index
360 */
361struct ifs_data {
362	int	loaded_version;
363	bool	loaded;
364	bool	loading_error;
365	int	valid_chunks;
366	int	status;
367	u64	scan_details;
368	u32	cur_batch;
369	u32	generation;
370	u32	chunk_size;
371	u32	array_gen;
372	u32	max_bundle;
373};
374
375struct ifs_work {
376	struct work_struct w;
377	struct device *dev;
378};
379
380struct ifs_device {
381	const struct ifs_test_caps *test_caps;
382	const struct ifs_test_msrs *test_msrs;
383	struct ifs_data rw_data;
384	struct miscdevice misc;
385};
386
387static inline struct ifs_data *ifs_get_data(struct device *dev)
388{
389	struct miscdevice *m = dev_get_drvdata(dev);
390	struct ifs_device *d = container_of(m, struct ifs_device, misc);
391
392	return &d->rw_data;
393}
394
395static inline const struct ifs_test_caps *ifs_get_test_caps(struct device *dev)
396{
397	struct miscdevice *m = dev_get_drvdata(dev);
398	struct ifs_device *d = container_of(m, struct ifs_device, misc);
399
400	return d->test_caps;
401}
402
403static inline const struct ifs_test_msrs *ifs_get_test_msrs(struct device *dev)
404{
405	struct miscdevice *m = dev_get_drvdata(dev);
406	struct ifs_device *d = container_of(m, struct ifs_device, misc);
407
408	return d->test_msrs;
409}
410
411extern bool *ifs_pkg_auth;
412int ifs_load_firmware(struct device *dev);
413int do_core_test(int cpu, struct device *dev);
414extern struct attribute *plat_ifs_attrs[];
415extern struct attribute *plat_ifs_array_attrs[];
416
417#endif