drivers/platform/x86/intel/ifs/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 */
 185 union 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
 198 union 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 */
 212 union 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
 223 union 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 */
 235 union 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 */
 255 union 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 */
 277 union 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 */
 288 union 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 */
 301 union 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
 325 struct 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  */
 339 struct 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  */
 361 struct 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
 375 struct ifs_work {
 376         struct work_struct w;
 377         struct device *dev;
 378 };
 379
 380 struct 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
 387 static 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
 395 static 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
 403 static 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
 411 extern bool *ifs_pkg_auth;
 412 int ifs_load_firmware(struct device *dev);
 413 int do_core_test(int cpu, struct device *dev);
 414 extern struct attribute *plat_ifs_attrs[];
 415 extern struct attribute *plat_ifs_array_attrs[];
 416
 417 #endif