drivers/platform/x86/intel/ifs/load.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright(c) 2022 Intel Corporation. */
   3
   4 #include <linux/firmware.h>
   5 #include <linux/sizes.h>
   6 #include <asm/cpu.h>
   7 #include <asm/microcode.h>
   8
   9 #include "ifs.h"
  10
  11 #define IFS_CHUNK_ALIGNMENT     256
  12 union meta_data {
  13         struct {
  14                 u32 meta_type;          // metadata type
  15                 u32 meta_size;          // size of this entire struct including hdrs.
  16                 u32 test_type;          // IFS test type
  17                 u32 fusa_info;          // Fusa info
  18                 u32 total_images;       // Total number of images
  19                 u32 current_image;      // Current Image #
  20                 u32 total_chunks;       // Total number of chunks in this image
  21                 u32 starting_chunk;     // Starting chunk number in this image
  22                 u32 size_per_chunk;     // size of each chunk
  23                 u32 chunks_per_stride;  // number of chunks in a stride
  24         };
  25         u8 padding[IFS_CHUNK_ALIGNMENT];
  26 };
  27
  28 #define IFS_HEADER_SIZE (sizeof(struct microcode_header_intel))
  29 #define META_TYPE_IFS   1
  30 #define INVALIDATE_STRIDE       0x1UL
  31 #define IFS_GEN_STRIDE_AWARE    2
  32 #define AUTH_INTERRUPTED_ERROR  5
  33 #define IFS_AUTH_RETRY_CT       10
  34
  35 static  struct microcode_header_intel *ifs_header_ptr;  /* pointer to the ifs image header */
  36 static u64 ifs_hash_ptr;                        /* Address of ifs metadata (hash) */
  37 static u64 ifs_test_image_ptr;                  /* 256B aligned address of test pattern */
  38 static DECLARE_COMPLETION(ifs_done);
  39
  40 static const char * const scan_hash_status[] = {
  41         [0] = "No error reported",
  42         [1] = "Attempt to copy scan hashes when copy already in progress",
  43         [2] = "Secure Memory not set up correctly",
  44         [3] = "FuSaInfo.ProgramID does not match or ff-mm-ss does not match",
  45         [4] = "Reserved",
  46         [5] = "Integrity check failed",
  47         [6] = "Scan reload or test is in progress"
  48 };
  49
  50 static const char * const scan_authentication_status[] = {
  51         [0] = "No error reported",
  52         [1] = "Attempt to authenticate a chunk which is already marked as authentic",
  53         [2] = "Chunk authentication error. The hash of chunk did not match expected value",
  54         [3] = "Reserved",
  55         [4] = "Chunk outside the current stride",
  56         [5] = "Authentication flow interrupted",
  57 };
  58
  59 #define MC_HEADER_META_TYPE_END         (0)
  60
  61 struct metadata_header {
  62         unsigned int            type;
  63         unsigned int            blk_size;
  64 };
  65
  66 static struct metadata_header *find_meta_data(void *ucode, unsigned int meta_type)
  67 {
  68         struct microcode_header_intel *hdr = &((struct microcode_intel *)ucode)->hdr;
  69         struct metadata_header *meta_header;
  70         unsigned long data_size, total_meta;
  71         unsigned long meta_size = 0;
  72
  73         data_size = intel_microcode_get_datasize(hdr);
  74         total_meta = hdr->metasize;
  75         if (!total_meta)
  76                 return NULL;
  77
  78         meta_header = (ucode + MC_HEADER_SIZE + data_size) - total_meta;
  79
  80         while (meta_header->type != MC_HEADER_META_TYPE_END &&
  81                meta_header->blk_size &&
  82                meta_size < total_meta) {
  83                 meta_size += meta_header->blk_size;
  84                 if (meta_header->type == meta_type)
  85                         return meta_header;
  86
  87                 meta_header = (void *)meta_header + meta_header->blk_size;
  88         }
  89         return NULL;
  90 }
  91
  92 static void hashcopy_err_message(struct device *dev, u32 err_code)
  93 {
  94         if (err_code >= ARRAY_SIZE(scan_hash_status))
  95                 dev_err(dev, "invalid error code 0x%x for hash copy\n", err_code);
  96         else
  97                 dev_err(dev, "Hash copy error : %s\n", scan_hash_status[err_code]);
  98 }
  99
 100 static void auth_err_message(struct device *dev, u32 err_code)
 101 {
 102         if (err_code >= ARRAY_SIZE(scan_authentication_status))
 103                 dev_err(dev, "invalid error code 0x%x for authentication\n", err_code);
 104         else
 105                 dev_err(dev, "Chunk authentication error : %s\n",
 106                         scan_authentication_status[err_code]);
 107 }
 108
 109 /*
 110  * To copy scan hashes and authenticate test chunks, the initiating cpu must point
 111  * to the EDX:EAX to the test image in linear address.
 112  * Run wrmsr(MSR_COPY_SCAN_HASHES) for scan hash copy and run wrmsr(MSR_AUTHENTICATE_AND_COPY_CHUNK)
 113  * for scan hash copy and test chunk authentication.
 114  */
 115 static void copy_hashes_authenticate_chunks(struct work_struct *work)
 116 {
 117         struct ifs_work *local_work = container_of(work, struct ifs_work, w);
 118         union ifs_scan_hashes_status hashes_status;
 119         union ifs_chunks_auth_status chunk_status;
 120         struct device *dev = local_work->dev;
 121         const struct ifs_test_msrs *msrs;
 122         int i, num_chunks, chunk_size;
 123         struct ifs_data *ifsd;
 124         u64 linear_addr, base;
 125         u32 err_code;
 126
 127         ifsd = ifs_get_data(dev);
 128         msrs = ifs_get_test_msrs(dev);
 129         /* run scan hash copy */
 130         wrmsrl(msrs->copy_hashes, ifs_hash_ptr);
 131         rdmsrl(msrs->copy_hashes_status, hashes_status.data);
 132
 133         /* enumerate the scan image information */
 134         num_chunks = hashes_status.num_chunks;
 135         chunk_size = hashes_status.chunk_size * 1024;
 136         err_code = hashes_status.error_code;
 137
 138         if (!hashes_status.valid) {
 139                 ifsd->loading_error = true;
 140                 hashcopy_err_message(dev, err_code);
 141                 goto done;
 142         }
 143
 144         /* base linear address to the scan data */
 145         base = ifs_test_image_ptr;
 146
 147         /* scan data authentication and copy chunks to secured memory */
 148         for (i = 0; i < num_chunks; i++) {
 149                 linear_addr = base + i * chunk_size;
 150                 linear_addr |= i;
 151
 152                 wrmsrl(msrs->copy_chunks, linear_addr);
 153                 rdmsrl(msrs->copy_chunks_status, chunk_status.data);
 154
 155                 ifsd->valid_chunks = chunk_status.valid_chunks;
 156                 err_code = chunk_status.error_code;
 157
 158                 if (err_code) {
 159                         ifsd->loading_error = true;
 160                         auth_err_message(dev, err_code);
 161                         goto done;
 162                 }
 163         }
 164 done:
 165         complete(&ifs_done);
 166 }
 167
 168 static int get_num_chunks(int gen, union ifs_scan_hashes_status_gen2 status)
 169 {
 170         return gen >= IFS_GEN_STRIDE_AWARE ? status.chunks_in_stride : status.num_chunks;
 171 }
 172
 173 static bool need_copy_scan_hashes(struct ifs_data *ifsd)
 174 {
 175         return !ifsd->loaded ||
 176                 ifsd->generation < IFS_GEN_STRIDE_AWARE ||
 177                 ifsd->loaded_version != ifs_header_ptr->rev;
 178 }
 179
 180 static int copy_hashes_authenticate_chunks_gen2(struct device *dev)
 181 {
 182         union ifs_scan_hashes_status_gen2 hashes_status;
 183         union ifs_chunks_auth_status_gen2 chunk_status;
 184         u32 err_code, valid_chunks, total_chunks;
 185         const struct ifs_test_msrs *msrs;
 186         int i, num_chunks, chunk_size;
 187         union meta_data *ifs_meta;
 188         int starting_chunk_nr;
 189         struct ifs_data *ifsd;
 190         u64 linear_addr, base;
 191         u64 chunk_table[2];
 192         int retry_count;
 193
 194         ifsd = ifs_get_data(dev);
 195         msrs = ifs_get_test_msrs(dev);
 196
 197         if (need_copy_scan_hashes(ifsd)) {
 198                 wrmsrl(msrs->copy_hashes, ifs_hash_ptr);
 199                 rdmsrl(msrs->copy_hashes_status, hashes_status.data);
 200
 201                 /* enumerate the scan image information */
 202                 chunk_size = hashes_status.chunk_size * SZ_1K;
 203                 err_code = hashes_status.error_code;
 204
 205                 num_chunks = get_num_chunks(ifsd->generation, hashes_status);
 206
 207                 if (!hashes_status.valid) {
 208                         hashcopy_err_message(dev, err_code);
 209                         return -EIO;
 210                 }
 211                 ifsd->loaded_version = ifs_header_ptr->rev;
 212                 ifsd->chunk_size = chunk_size;
 213         } else {
 214                 num_chunks = ifsd->valid_chunks;
 215                 chunk_size = ifsd->chunk_size;
 216         }
 217
 218         if (ifsd->generation >= IFS_GEN_STRIDE_AWARE) {
 219                 wrmsrl(msrs->test_ctrl, INVALIDATE_STRIDE);
 220                 rdmsrl(msrs->copy_chunks_status, chunk_status.data);
 221                 if (chunk_status.valid_chunks != 0) {
 222                         dev_err(dev, "Couldn't invalidate installed stride - %d\n",
 223                                 chunk_status.valid_chunks);
 224                         return -EIO;
 225                 }
 226         }
 227
 228         base = ifs_test_image_ptr;
 229         ifs_meta = (union meta_data *)find_meta_data(ifs_header_ptr, META_TYPE_IFS);
 230         starting_chunk_nr = ifs_meta->starting_chunk;
 231
 232         /* scan data authentication and copy chunks to secured memory */
 233         for (i = 0; i < num_chunks; i++) {
 234                 retry_count = IFS_AUTH_RETRY_CT;
 235                 linear_addr = base + i * chunk_size;
 236
 237                 chunk_table[0] = starting_chunk_nr + i;
 238                 chunk_table[1] = linear_addr;
 239                 do {
 240                         local_irq_disable();
 241                         wrmsrl(msrs->copy_chunks, (u64)chunk_table);
 242                         local_irq_enable();
 243                         rdmsrl(msrs->copy_chunks_status, chunk_status.data);
 244                         err_code = chunk_status.error_code;
 245                 } while (err_code == AUTH_INTERRUPTED_ERROR && --retry_count);
 246
 247                 if (err_code) {
 248                         ifsd->loading_error = true;
 249                         auth_err_message(dev, err_code);
 250                         return -EIO;
 251                 }
 252         }
 253
 254         valid_chunks = chunk_status.valid_chunks;
 255         total_chunks = chunk_status.total_chunks;
 256
 257         if (valid_chunks != total_chunks) {
 258                 ifsd->loading_error = true;
 259                 dev_err(dev, "Couldn't authenticate all the chunks. Authenticated %d total %d.\n",
 260                         valid_chunks, total_chunks);
 261                 return -EIO;
 262         }
 263         ifsd->valid_chunks = valid_chunks;
 264         ifsd->max_bundle = chunk_status.max_bundle;
 265
 266         return 0;
 267 }
 268
 269 static int validate_ifs_metadata(struct device *dev)
 270 {
 271         const struct ifs_test_caps *test = ifs_get_test_caps(dev);
 272         struct ifs_data *ifsd = ifs_get_data(dev);
 273         union meta_data *ifs_meta;
 274         char test_file[64];
 275         int ret = -EINVAL;
 276
 277         snprintf(test_file, sizeof(test_file), "%02x-%02x-%02x-%02x.%s",
 278                  boot_cpu_data.x86, boot_cpu_data.x86_model,
 279                  boot_cpu_data.x86_stepping, ifsd->cur_batch, test->image_suffix);
 280
 281         ifs_meta = (union meta_data *)find_meta_data(ifs_header_ptr, META_TYPE_IFS);
 282         if (!ifs_meta) {
 283                 dev_err(dev, "IFS Metadata missing in file %s\n", test_file);
 284                 return ret;
 285         }
 286
 287         ifs_test_image_ptr = (u64)ifs_meta + sizeof(union meta_data);
 288
 289         /* Scan chunk start must be 256 byte aligned */
 290         if (!IS_ALIGNED(ifs_test_image_ptr, IFS_CHUNK_ALIGNMENT)) {
 291                 dev_err(dev, "Scan pattern is not aligned on %d bytes aligned in %s\n",
 292                         IFS_CHUNK_ALIGNMENT, test_file);
 293                 return ret;
 294         }
 295
 296         if (ifs_meta->current_image != ifsd->cur_batch) {
 297                 dev_warn(dev, "Mismatch between filename %s and batch metadata 0x%02x\n",
 298                          test_file, ifs_meta->current_image);
 299                 return ret;
 300         }
 301
 302         if (ifs_meta->chunks_per_stride &&
 303             (ifs_meta->starting_chunk % ifs_meta->chunks_per_stride != 0)) {
 304                 dev_warn(dev, "Starting chunk num %u not a multiple of chunks_per_stride %u\n",
 305                          ifs_meta->starting_chunk, ifs_meta->chunks_per_stride);
 306                 return ret;
 307         }
 308
 309         if (ifs_meta->test_type != test->test_num) {
 310                 dev_warn(dev, "Metadata test_type %d mismatches with device type\n",
 311                          ifs_meta->test_type);
 312                 return ret;
 313         }
 314
 315         return 0;
 316 }
 317
 318 /*
 319  * IFS requires scan chunks authenticated per each socket in the platform.
 320  * Once the test chunk is authenticated, it is automatically copied to secured memory
 321  * and proceed the authentication for the next chunk.
 322  */
 323 static int scan_chunks_sanity_check(struct device *dev)
 324 {
 325         struct ifs_data *ifsd = ifs_get_data(dev);
 326         struct ifs_work local_work;
 327         int curr_pkg, cpu, ret;
 328
 329         memset(ifs_pkg_auth, 0, (topology_max_packages() * sizeof(bool)));
 330         ret = validate_ifs_metadata(dev);
 331         if (ret)
 332                 return ret;
 333
 334         ifsd->loading_error = false;
 335
 336         if (ifsd->generation > 0)
 337                 return copy_hashes_authenticate_chunks_gen2(dev);
 338
 339         /* copy the scan hash and authenticate per package */
 340         cpus_read_lock();
 341         for_each_online_cpu(cpu) {
 342                 curr_pkg = topology_physical_package_id(cpu);
 343                 if (ifs_pkg_auth[curr_pkg])
 344                         continue;
 345                 reinit_completion(&ifs_done);
 346                 local_work.dev = dev;
 347                 INIT_WORK_ONSTACK(&local_work.w, copy_hashes_authenticate_chunks);
 348                 schedule_work_on(cpu, &local_work.w);
 349                 wait_for_completion(&ifs_done);
 350                 if (ifsd->loading_error) {
 351                         ret = -EIO;
 352                         goto out;
 353                 }
 354                 ifs_pkg_auth[curr_pkg] = 1;
 355         }
 356         ret = 0;
 357         ifsd->loaded_version = ifs_header_ptr->rev;
 358 out:
 359         cpus_read_unlock();
 360
 361         return ret;
 362 }
 363
 364 static int image_sanity_check(struct device *dev, const struct microcode_header_intel *data)
 365 {
 366         struct cpu_signature sig;
 367
 368         /* Provide a specific error message when loading an older/unsupported image */
 369         if (data->hdrver != MC_HEADER_TYPE_IFS) {
 370                 dev_err(dev, "Header version %d not supported\n", data->hdrver);
 371                 return -EINVAL;
 372         }
 373
 374         if (intel_microcode_sanity_check((void *)data, true, MC_HEADER_TYPE_IFS)) {
 375                 dev_err(dev, "sanity check failed\n");
 376                 return -EINVAL;
 377         }
 378
 379         intel_collect_cpu_info(&sig);
 380
 381         if (!intel_find_matching_signature((void *)data, &sig)) {
 382                 dev_err(dev, "cpu signature, processor flags not matching\n");
 383                 return -EINVAL;
 384         }
 385
 386         return 0;
 387 }
 388
 389 /*
 390  * Load ifs image. Before loading ifs module, the ifs image must be located
 391  * in /lib/firmware/intel/ifs_x/ and named as family-model-stepping-02x.{testname}.
 392  */
 393 int ifs_load_firmware(struct device *dev)
 394 {
 395         const struct ifs_test_caps *test = ifs_get_test_caps(dev);
 396         struct ifs_data *ifsd = ifs_get_data(dev);
 397         unsigned int expected_size;
 398         const struct firmware *fw;
 399         char scan_path[64];
 400         int ret;
 401
 402         snprintf(scan_path, sizeof(scan_path), "intel/ifs_%d/%02x-%02x-%02x-%02x.%s",
 403                  test->test_num, boot_cpu_data.x86, boot_cpu_data.x86_model,
 404                  boot_cpu_data.x86_stepping, ifsd->cur_batch, test->image_suffix);
 405
 406         ret = request_firmware_direct(&fw, scan_path, dev);
 407         if (ret) {
 408                 dev_err(dev, "ifs file %s load failed\n", scan_path);
 409                 goto done;
 410         }
 411
 412         expected_size = ((struct microcode_header_intel *)fw->data)->totalsize;
 413         if (fw->size != expected_size) {
 414                 dev_err(dev, "File size mismatch (expected %u, actual %zu). Corrupted IFS image.\n",
 415                         expected_size, fw->size);
 416                 ret = -EINVAL;
 417                 goto release;
 418         }
 419
 420         ret = image_sanity_check(dev, (struct microcode_header_intel *)fw->data);
 421         if (ret)
 422                 goto release;
 423
 424         ifs_header_ptr = (struct microcode_header_intel *)fw->data;
 425         ifs_hash_ptr = (u64)(ifs_header_ptr + 1);
 426
 427         ret = scan_chunks_sanity_check(dev);
 428         if (ret)
 429                 dev_err(dev, "Load failure for batch: %02x\n", ifsd->cur_batch);
 430
 431 release:
 432         release_firmware(fw);
 433 done:
 434         ifsd->loaded = (ret == 0);
 435
 436         return ret;
 437 }