Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/* Copyright(c) 2022 Intel Corporation. */
3
4#include <linux/cpu.h>
5#include <linux/delay.h>
6#include <linux/fs.h>
7#include <linux/nmi.h>
8#include <linux/slab.h>
9#include <linux/stop_machine.h>
10
11#include "ifs.h"
12
13/*
14 * Note all code and data in this file is protected by
15 * ifs_sem. On HT systems all threads on a core will
16 * execute together, but only the first thread on the
17 * core will update results of the test.
18 */
19
20#define CREATE_TRACE_POINTS
21#include <trace/events/intel_ifs.h>
22
23/* Max retries on the same chunk */
24#define MAX_IFS_RETRIES 5
25
26struct run_params {
27 struct ifs_data *ifsd;
28 union ifs_scan *activate;
29 union ifs_status status;
30};
31
32struct sbaf_run_params {
33 struct ifs_data *ifsd;
34 int *retry_cnt;
35 union ifs_sbaf *activate;
36 union ifs_sbaf_status status;
37};
38
39/*
40 * Number of TSC cycles that a logical CPU will wait for the other
41 * logical CPU on the core in the WRMSR(ACTIVATE_SCAN).
42 */
43#define IFS_THREAD_WAIT 100000
44
45enum ifs_status_err_code {
46 IFS_NO_ERROR = 0,
47 IFS_OTHER_THREAD_COULD_NOT_JOIN = 1,
48 IFS_INTERRUPTED_BEFORE_RENDEZVOUS = 2,
49 IFS_POWER_MGMT_INADEQUATE_FOR_SCAN = 3,
50 IFS_INVALID_CHUNK_RANGE = 4,
51 IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS = 5,
52 IFS_CORE_NOT_CAPABLE_CURRENTLY = 6,
53 IFS_UNASSIGNED_ERROR_CODE = 7,
54 IFS_EXCEED_NUMBER_OF_THREADS_CONCURRENT = 8,
55 IFS_INTERRUPTED_DURING_EXECUTION = 9,
56 IFS_UNASSIGNED_ERROR_CODE_0xA = 0xA,
57 IFS_CORRUPTED_CHUNK = 0xB,
58};
59
60static const char * const scan_test_status[] = {
61 [IFS_NO_ERROR] = "SCAN no error",
62 [IFS_OTHER_THREAD_COULD_NOT_JOIN] = "Other thread could not join.",
63 [IFS_INTERRUPTED_BEFORE_RENDEZVOUS] = "Interrupt occurred prior to SCAN coordination.",
64 [IFS_POWER_MGMT_INADEQUATE_FOR_SCAN] =
65 "Core Abort SCAN Response due to power management condition.",
66 [IFS_INVALID_CHUNK_RANGE] = "Non valid chunks in the range",
67 [IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS] = "Mismatch in arguments between threads T0/T1.",
68 [IFS_CORE_NOT_CAPABLE_CURRENTLY] = "Core not capable of performing SCAN currently",
69 [IFS_UNASSIGNED_ERROR_CODE] = "Unassigned error code 0x7",
70 [IFS_EXCEED_NUMBER_OF_THREADS_CONCURRENT] =
71 "Exceeded number of Logical Processors (LP) allowed to run Scan-At-Field concurrently",
72 [IFS_INTERRUPTED_DURING_EXECUTION] = "Interrupt occurred prior to SCAN start",
73 [IFS_UNASSIGNED_ERROR_CODE_0xA] = "Unassigned error code 0xA",
74 [IFS_CORRUPTED_CHUNK] = "Scan operation aborted due to corrupted image. Try reloading",
75};
76
77static void message_not_tested(struct device *dev, int cpu, union ifs_status status)
78{
79 struct ifs_data *ifsd = ifs_get_data(dev);
80
81 /*
82 * control_error is set when the microcode runs into a problem
83 * loading the image from the reserved BIOS memory, or it has
84 * been corrupted. Reloading the image may fix this issue.
85 */
86 if (status.control_error) {
87 dev_warn(dev, "CPU(s) %*pbl: Scan controller error. Batch: %02x version: 0x%x\n",
88 cpumask_pr_args(cpu_smt_mask(cpu)), ifsd->cur_batch, ifsd->loaded_version);
89 return;
90 }
91
92 if (status.error_code < ARRAY_SIZE(scan_test_status)) {
93 dev_info(dev, "CPU(s) %*pbl: SCAN operation did not start. %s\n",
94 cpumask_pr_args(cpu_smt_mask(cpu)),
95 scan_test_status[status.error_code]);
96 } else if (status.error_code == IFS_SW_TIMEOUT) {
97 dev_info(dev, "CPU(s) %*pbl: software timeout during scan\n",
98 cpumask_pr_args(cpu_smt_mask(cpu)));
99 } else if (status.error_code == IFS_SW_PARTIAL_COMPLETION) {
100 dev_info(dev, "CPU(s) %*pbl: %s\n",
101 cpumask_pr_args(cpu_smt_mask(cpu)),
102 "Not all scan chunks were executed. Maximum forward progress retries exceeded");
103 } else {
104 dev_info(dev, "CPU(s) %*pbl: SCAN unknown status %llx\n",
105 cpumask_pr_args(cpu_smt_mask(cpu)), status.data);
106 }
107}
108
109static void message_fail(struct device *dev, int cpu, union ifs_status status)
110{
111 struct ifs_data *ifsd = ifs_get_data(dev);
112
113 /*
114 * signature_error is set when the output from the scan chains does not
115 * match the expected signature. This might be a transient problem (e.g.
116 * due to a bit flip from an alpha particle or neutron). If the problem
117 * repeats on a subsequent test, then it indicates an actual problem in
118 * the core being tested.
119 */
120 if (status.signature_error) {
121 dev_err(dev, "CPU(s) %*pbl: test signature incorrect. Batch: %02x version: 0x%x\n",
122 cpumask_pr_args(cpu_smt_mask(cpu)), ifsd->cur_batch, ifsd->loaded_version);
123 }
124}
125
126static bool can_restart(union ifs_status status)
127{
128 enum ifs_status_err_code err_code = status.error_code;
129
130 /* Signature for chunk is bad, or scan test failed */
131 if (status.signature_error || status.control_error)
132 return false;
133
134 switch (err_code) {
135 case IFS_NO_ERROR:
136 case IFS_OTHER_THREAD_COULD_NOT_JOIN:
137 case IFS_INTERRUPTED_BEFORE_RENDEZVOUS:
138 case IFS_POWER_MGMT_INADEQUATE_FOR_SCAN:
139 case IFS_EXCEED_NUMBER_OF_THREADS_CONCURRENT:
140 case IFS_INTERRUPTED_DURING_EXECUTION:
141 return true;
142 case IFS_INVALID_CHUNK_RANGE:
143 case IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS:
144 case IFS_CORE_NOT_CAPABLE_CURRENTLY:
145 case IFS_UNASSIGNED_ERROR_CODE:
146 case IFS_UNASSIGNED_ERROR_CODE_0xA:
147 case IFS_CORRUPTED_CHUNK:
148 break;
149 }
150 return false;
151}
152
153#define SPINUNIT 100 /* 100 nsec */
154static atomic_t array_cpus_in;
155static atomic_t scan_cpus_in;
156static atomic_t sbaf_cpus_in;
157
158/*
159 * Simplified cpu sibling rendezvous loop based on microcode loader __wait_for_cpus()
160 */
161static void wait_for_sibling_cpu(atomic_t *t, long long timeout)
162{
163 int cpu = smp_processor_id();
164 const struct cpumask *smt_mask = cpu_smt_mask(cpu);
165 int all_cpus = cpumask_weight(smt_mask);
166
167 atomic_inc(t);
168 while (atomic_read(t) < all_cpus) {
169 if (timeout < SPINUNIT)
170 return;
171 ndelay(SPINUNIT);
172 timeout -= SPINUNIT;
173 touch_nmi_watchdog();
174 }
175}
176
177/*
178 * Execute the scan. Called "simultaneously" on all threads of a core
179 * at high priority using the stop_cpus mechanism.
180 */
181static int doscan(void *data)
182{
183 int cpu = smp_processor_id(), start, stop;
184 struct run_params *params = data;
185 union ifs_status status;
186 struct ifs_data *ifsd;
187 int first;
188
189 ifsd = params->ifsd;
190
191 if (ifsd->generation) {
192 start = params->activate->gen2.start;
193 stop = params->activate->gen2.stop;
194 } else {
195 start = params->activate->gen0.start;
196 stop = params->activate->gen0.stop;
197 }
198
199 /* Only the first logical CPU on a core reports result */
200 first = cpumask_first(cpu_smt_mask(cpu));
201
202 wait_for_sibling_cpu(&scan_cpus_in, NSEC_PER_SEC);
203
204 /*
205 * This WRMSR will wait for other HT threads to also write
206 * to this MSR (at most for activate.delay cycles). Then it
207 * starts scan of each requested chunk. The core scan happens
208 * during the "execution" of the WRMSR. This instruction can
209 * take up to 200 milliseconds (in the case where all chunks
210 * are processed in a single pass) before it retires.
211 */
212 wrmsrl(MSR_ACTIVATE_SCAN, params->activate->data);
213 rdmsrl(MSR_SCAN_STATUS, status.data);
214
215 trace_ifs_status(ifsd->cur_batch, start, stop, status.data);
216
217 /* Pass back the result of the scan */
218 if (cpu == first)
219 params->status = status;
220
221 return 0;
222}
223
224/*
225 * Use stop_core_cpuslocked() to synchronize writing to MSR_ACTIVATE_SCAN
226 * on all threads of the core to be tested. Loop if necessary to complete
227 * run of all chunks. Include some defensive tests to make sure forward
228 * progress is made, and that the whole test completes in a reasonable time.
229 */
230static void ifs_test_core(int cpu, struct device *dev)
231{
232 union ifs_status status = {};
233 union ifs_scan activate;
234 unsigned long timeout;
235 struct ifs_data *ifsd;
236 int to_start, to_stop;
237 int status_chunk;
238 struct run_params params;
239 int retries;
240
241 ifsd = ifs_get_data(dev);
242
243 activate.gen0.rsvd = 0;
244 activate.delay = IFS_THREAD_WAIT;
245 activate.sigmce = 0;
246 to_start = 0;
247 to_stop = ifsd->valid_chunks - 1;
248
249 params.ifsd = ifs_get_data(dev);
250
251 if (ifsd->generation) {
252 activate.gen2.start = to_start;
253 activate.gen2.stop = to_stop;
254 } else {
255 activate.gen0.start = to_start;
256 activate.gen0.stop = to_stop;
257 }
258
259 timeout = jiffies + HZ / 2;
260 retries = MAX_IFS_RETRIES;
261
262 while (to_start <= to_stop) {
263 if (time_after(jiffies, timeout)) {
264 status.error_code = IFS_SW_TIMEOUT;
265 break;
266 }
267
268 params.activate = &activate;
269 atomic_set(&scan_cpus_in, 0);
270 stop_core_cpuslocked(cpu, doscan, ¶ms);
271
272 status = params.status;
273
274 /* Some cases can be retried, give up for others */
275 if (!can_restart(status))
276 break;
277
278 status_chunk = ifsd->generation ? status.gen2.chunk_num : status.gen0.chunk_num;
279 if (status_chunk == to_start) {
280 /* Check for forward progress */
281 if (--retries == 0) {
282 if (status.error_code == IFS_NO_ERROR)
283 status.error_code = IFS_SW_PARTIAL_COMPLETION;
284 break;
285 }
286 } else {
287 retries = MAX_IFS_RETRIES;
288 if (ifsd->generation)
289 activate.gen2.start = status_chunk;
290 else
291 activate.gen0.start = status_chunk;
292 to_start = status_chunk;
293 }
294 }
295
296 /* Update status for this core */
297 ifsd->scan_details = status.data;
298
299 if (status.signature_error) {
300 ifsd->status = SCAN_TEST_FAIL;
301 message_fail(dev, cpu, status);
302 } else if (status.control_error || status.error_code) {
303 ifsd->status = SCAN_NOT_TESTED;
304 message_not_tested(dev, cpu, status);
305 } else {
306 ifsd->status = SCAN_TEST_PASS;
307 }
308}
309
310static int do_array_test(void *data)
311{
312 union ifs_array *command = data;
313 int cpu = smp_processor_id();
314 int first;
315
316 wait_for_sibling_cpu(&array_cpus_in, NSEC_PER_SEC);
317
318 /*
319 * Only one logical CPU on a core needs to trigger the Array test via MSR write.
320 */
321 first = cpumask_first(cpu_smt_mask(cpu));
322
323 if (cpu == first) {
324 wrmsrl(MSR_ARRAY_BIST, command->data);
325 /* Pass back the result of the test */
326 rdmsrl(MSR_ARRAY_BIST, command->data);
327 }
328
329 return 0;
330}
331
332static void ifs_array_test_core(int cpu, struct device *dev)
333{
334 union ifs_array command = {};
335 bool timed_out = false;
336 struct ifs_data *ifsd;
337 unsigned long timeout;
338
339 ifsd = ifs_get_data(dev);
340
341 command.array_bitmask = ~0U;
342 timeout = jiffies + HZ / 2;
343
344 do {
345 if (time_after(jiffies, timeout)) {
346 timed_out = true;
347 break;
348 }
349 atomic_set(&array_cpus_in, 0);
350 stop_core_cpuslocked(cpu, do_array_test, &command);
351
352 if (command.ctrl_result)
353 break;
354 } while (command.array_bitmask);
355
356 ifsd->scan_details = command.data;
357
358 if (command.ctrl_result)
359 ifsd->status = SCAN_TEST_FAIL;
360 else if (timed_out || command.array_bitmask)
361 ifsd->status = SCAN_NOT_TESTED;
362 else
363 ifsd->status = SCAN_TEST_PASS;
364}
365
366#define ARRAY_GEN1_TEST_ALL_ARRAYS 0x0ULL
367#define ARRAY_GEN1_STATUS_FAIL 0x1ULL
368
369static int do_array_test_gen1(void *status)
370{
371 int cpu = smp_processor_id();
372 int first;
373
374 first = cpumask_first(cpu_smt_mask(cpu));
375
376 if (cpu == first) {
377 wrmsrl(MSR_ARRAY_TRIGGER, ARRAY_GEN1_TEST_ALL_ARRAYS);
378 rdmsrl(MSR_ARRAY_STATUS, *((u64 *)status));
379 }
380
381 return 0;
382}
383
384static void ifs_array_test_gen1(int cpu, struct device *dev)
385{
386 struct ifs_data *ifsd = ifs_get_data(dev);
387 u64 status = 0;
388
389 stop_core_cpuslocked(cpu, do_array_test_gen1, &status);
390 ifsd->scan_details = status;
391
392 if (status & ARRAY_GEN1_STATUS_FAIL)
393 ifsd->status = SCAN_TEST_FAIL;
394 else
395 ifsd->status = SCAN_TEST_PASS;
396}
397
398#define SBAF_STATUS_PASS 0
399#define SBAF_STATUS_SIGN_FAIL 1
400#define SBAF_STATUS_INTR 2
401#define SBAF_STATUS_TEST_FAIL 3
402
403enum sbaf_status_err_code {
404 IFS_SBAF_NO_ERROR = 0,
405 IFS_SBAF_OTHER_THREAD_COULD_NOT_JOIN = 1,
406 IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS = 2,
407 IFS_SBAF_UNASSIGNED_ERROR_CODE3 = 3,
408 IFS_SBAF_INVALID_BUNDLE_INDEX = 4,
409 IFS_SBAF_MISMATCH_ARGS_BETWEEN_THREADS = 5,
410 IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY = 6,
411 IFS_SBAF_UNASSIGNED_ERROR_CODE7 = 7,
412 IFS_SBAF_EXCEED_NUMBER_OF_THREADS_CONCURRENT = 8,
413 IFS_SBAF_INTERRUPTED_DURING_EXECUTION = 9,
414 IFS_SBAF_INVALID_PROGRAM_INDEX = 0xA,
415 IFS_SBAF_CORRUPTED_CHUNK = 0xB,
416 IFS_SBAF_DID_NOT_START = 0xC,
417};
418
419static const char * const sbaf_test_status[] = {
420 [IFS_SBAF_NO_ERROR] = "SBAF no error",
421 [IFS_SBAF_OTHER_THREAD_COULD_NOT_JOIN] = "Other thread could not join.",
422 [IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS] = "Interrupt occurred prior to SBAF coordination.",
423 [IFS_SBAF_UNASSIGNED_ERROR_CODE3] = "Unassigned error code 0x3",
424 [IFS_SBAF_INVALID_BUNDLE_INDEX] = "Non-valid sbaf bundles. Reload test image",
425 [IFS_SBAF_MISMATCH_ARGS_BETWEEN_THREADS] = "Mismatch in arguments between threads T0/T1.",
426 [IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY] = "Core not capable of performing SBAF currently",
427 [IFS_SBAF_UNASSIGNED_ERROR_CODE7] = "Unassigned error code 0x7",
428 [IFS_SBAF_EXCEED_NUMBER_OF_THREADS_CONCURRENT] = "Exceeded number of Logical Processors (LP) allowed to run Scan-At-Field concurrently",
429 [IFS_SBAF_INTERRUPTED_DURING_EXECUTION] = "Interrupt occurred prior to SBAF start",
430 [IFS_SBAF_INVALID_PROGRAM_INDEX] = "SBAF program index not valid",
431 [IFS_SBAF_CORRUPTED_CHUNK] = "SBAF operation aborted due to corrupted chunk",
432 [IFS_SBAF_DID_NOT_START] = "SBAF operation did not start",
433};
434
435static void sbaf_message_not_tested(struct device *dev, int cpu, u64 status_data)
436{
437 union ifs_sbaf_status status = (union ifs_sbaf_status)status_data;
438
439 if (status.error_code < ARRAY_SIZE(sbaf_test_status)) {
440 dev_info(dev, "CPU(s) %*pbl: SBAF operation did not start. %s\n",
441 cpumask_pr_args(cpu_smt_mask(cpu)),
442 sbaf_test_status[status.error_code]);
443 } else if (status.error_code == IFS_SW_TIMEOUT) {
444 dev_info(dev, "CPU(s) %*pbl: software timeout during scan\n",
445 cpumask_pr_args(cpu_smt_mask(cpu)));
446 } else if (status.error_code == IFS_SW_PARTIAL_COMPLETION) {
447 dev_info(dev, "CPU(s) %*pbl: %s\n",
448 cpumask_pr_args(cpu_smt_mask(cpu)),
449 "Not all SBAF bundles executed. Maximum forward progress retries exceeded");
450 } else {
451 dev_info(dev, "CPU(s) %*pbl: SBAF unknown status %llx\n",
452 cpumask_pr_args(cpu_smt_mask(cpu)), status.data);
453 }
454}
455
456static void sbaf_message_fail(struct device *dev, int cpu, union ifs_sbaf_status status)
457{
458 /* Failed signature check is set when SBAF signature did not match the expected value */
459 if (status.sbaf_status == SBAF_STATUS_SIGN_FAIL) {
460 dev_err(dev, "CPU(s) %*pbl: Failed signature check\n",
461 cpumask_pr_args(cpu_smt_mask(cpu)));
462 }
463
464 /* Failed to reach end of test */
465 if (status.sbaf_status == SBAF_STATUS_TEST_FAIL) {
466 dev_err(dev, "CPU(s) %*pbl: Failed to complete test\n",
467 cpumask_pr_args(cpu_smt_mask(cpu)));
468 }
469}
470
471static bool sbaf_bundle_completed(union ifs_sbaf_status status)
472{
473 return !(status.sbaf_status || status.error_code);
474}
475
476static bool sbaf_can_restart(union ifs_sbaf_status status)
477{
478 enum sbaf_status_err_code err_code = status.error_code;
479
480 /* Signature for chunk is bad, or scan test failed */
481 if (status.sbaf_status == SBAF_STATUS_SIGN_FAIL ||
482 status.sbaf_status == SBAF_STATUS_TEST_FAIL)
483 return false;
484
485 switch (err_code) {
486 case IFS_SBAF_NO_ERROR:
487 case IFS_SBAF_OTHER_THREAD_COULD_NOT_JOIN:
488 case IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS:
489 case IFS_SBAF_EXCEED_NUMBER_OF_THREADS_CONCURRENT:
490 case IFS_SBAF_INTERRUPTED_DURING_EXECUTION:
491 return true;
492 case IFS_SBAF_UNASSIGNED_ERROR_CODE3:
493 case IFS_SBAF_INVALID_BUNDLE_INDEX:
494 case IFS_SBAF_MISMATCH_ARGS_BETWEEN_THREADS:
495 case IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY:
496 case IFS_SBAF_UNASSIGNED_ERROR_CODE7:
497 case IFS_SBAF_INVALID_PROGRAM_INDEX:
498 case IFS_SBAF_CORRUPTED_CHUNK:
499 case IFS_SBAF_DID_NOT_START:
500 break;
501 }
502 return false;
503}
504
505/*
506 * Execute the SBAF test. Called "simultaneously" on all threads of a core
507 * at high priority using the stop_cpus mechanism.
508 */
509static int dosbaf(void *data)
510{
511 struct sbaf_run_params *run_params = data;
512 int cpu = smp_processor_id();
513 union ifs_sbaf_status status;
514 struct ifs_data *ifsd;
515 int first;
516
517 ifsd = run_params->ifsd;
518
519 /* Only the first logical CPU on a core reports result */
520 first = cpumask_first(cpu_smt_mask(cpu));
521 wait_for_sibling_cpu(&sbaf_cpus_in, NSEC_PER_SEC);
522
523 /*
524 * This WRMSR will wait for other HT threads to also write
525 * to this MSR (at most for activate.delay cycles). Then it
526 * starts scan of each requested bundle. The core test happens
527 * during the "execution" of the WRMSR.
528 */
529 wrmsrl(MSR_ACTIVATE_SBAF, run_params->activate->data);
530 rdmsrl(MSR_SBAF_STATUS, status.data);
531 trace_ifs_sbaf(ifsd->cur_batch, *run_params->activate, status);
532
533 /* Pass back the result of the test */
534 if (cpu == first)
535 run_params->status = status;
536
537 return 0;
538}
539
540static void ifs_sbaf_test_core(int cpu, struct device *dev)
541{
542 struct sbaf_run_params run_params;
543 union ifs_sbaf_status status = {};
544 union ifs_sbaf activate;
545 unsigned long timeout;
546 struct ifs_data *ifsd;
547 int stop_bundle;
548 int retries;
549
550 ifsd = ifs_get_data(dev);
551
552 activate.data = 0;
553 activate.delay = IFS_THREAD_WAIT;
554
555 timeout = jiffies + 2 * HZ;
556 retries = MAX_IFS_RETRIES;
557 activate.bundle_idx = 0;
558 stop_bundle = ifsd->max_bundle;
559
560 while (activate.bundle_idx <= stop_bundle) {
561 if (time_after(jiffies, timeout)) {
562 status.error_code = IFS_SW_TIMEOUT;
563 break;
564 }
565
566 atomic_set(&sbaf_cpus_in, 0);
567
568 run_params.ifsd = ifsd;
569 run_params.activate = &activate;
570 run_params.retry_cnt = &retries;
571 stop_core_cpuslocked(cpu, dosbaf, &run_params);
572
573 status = run_params.status;
574
575 if (sbaf_bundle_completed(status)) {
576 activate.bundle_idx = status.bundle_idx + 1;
577 activate.pgm_idx = 0;
578 retries = MAX_IFS_RETRIES;
579 continue;
580 }
581
582 /* Some cases can be retried, give up for others */
583 if (!sbaf_can_restart(status))
584 break;
585
586 if (status.pgm_idx == activate.pgm_idx) {
587 /* If no progress retry */
588 if (--retries == 0) {
589 if (status.error_code == IFS_NO_ERROR)
590 status.error_code = IFS_SW_PARTIAL_COMPLETION;
591 break;
592 }
593 } else {
594 /* if some progress, more pgms remaining in bundle, reset retries */
595 retries = MAX_IFS_RETRIES;
596 activate.bundle_idx = status.bundle_idx;
597 activate.pgm_idx = status.pgm_idx;
598 }
599 }
600
601 /* Update status for this core */
602 ifsd->scan_details = status.data;
603
604 if (status.sbaf_status == SBAF_STATUS_SIGN_FAIL ||
605 status.sbaf_status == SBAF_STATUS_TEST_FAIL) {
606 ifsd->status = SCAN_TEST_FAIL;
607 sbaf_message_fail(dev, cpu, status);
608 } else if (status.error_code || status.sbaf_status == SBAF_STATUS_INTR ||
609 (activate.bundle_idx < stop_bundle)) {
610 ifsd->status = SCAN_NOT_TESTED;
611 sbaf_message_not_tested(dev, cpu, status.data);
612 } else {
613 ifsd->status = SCAN_TEST_PASS;
614 }
615}
616
617/*
618 * Initiate per core test. It wakes up work queue threads on the target cpu and
619 * its sibling cpu. Once all sibling threads wake up, the scan test gets executed and
620 * wait for all sibling threads to finish the scan test.
621 */
622int do_core_test(int cpu, struct device *dev)
623{
624 const struct ifs_test_caps *test = ifs_get_test_caps(dev);
625 struct ifs_data *ifsd = ifs_get_data(dev);
626 int ret = 0;
627
628 /* Prevent CPUs from being taken offline during the scan test */
629 cpus_read_lock();
630
631 if (!cpu_online(cpu)) {
632 dev_info(dev, "cannot test on the offline cpu %d\n", cpu);
633 ret = -EINVAL;
634 goto out;
635 }
636
637 switch (test->test_num) {
638 case IFS_TYPE_SAF:
639 if (!ifsd->loaded)
640 ret = -EPERM;
641 else
642 ifs_test_core(cpu, dev);
643 break;
644 case IFS_TYPE_ARRAY_BIST:
645 if (ifsd->array_gen == ARRAY_GEN0)
646 ifs_array_test_core(cpu, dev);
647 else
648 ifs_array_test_gen1(cpu, dev);
649 break;
650 case IFS_TYPE_SBAF:
651 if (!ifsd->loaded)
652 ret = -EPERM;
653 else
654 ifs_sbaf_test_core(cpu, dev);
655 break;
656 default:
657 ret = -EINVAL;
658 }
659out:
660 cpus_read_unlock();
661 return ret;
662}