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