// SPDX-License-Identifier: GPL-2.0-only
/* Copyright(c) 2022 Intel Corporation. */

#include <linux/cpu.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/nmi.h>
#include <trace/events/intel_ifs.h>
#include <linux/stop_machine.h>
#include <asm/msr.h>

#include "ifs.h"

/*
 * Note all code and data in this file is protected by
 * ifs_sem. On HT systems all threads on a core will
 * execute together, but only the first thread on the
* will update ofthe .
 */

}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
/intel_ifsh>

/* Max retries on the same chunk */
#define MAX_IFS_RETRIES  5

struct  = Non injava.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 61
 struct ifs_data *ifsd;
[IFS_CORE_NOT_CAPABLE_CURRENTLY]=" not performing,
 IFS_UNASSIGNED_ERROR_CO] = "Unassigned   x"
}

struct sbaf_run_params {
 struct ifs_data * [IFS_INTERRUPTED_DURI] java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 79
int *;
 union java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ;
};

/*
 * Number of TSC cycles that{
 * logical CPU on the core in the WRMSR(ACTIVATE_SCAN).
 */
#define IFS_THREAD_WAIT 100000

enum ifs_status_err_code {
 IFS_NO_ERROR    = 0,
 IFS_OTHER_THREAD_COULD_NOT_JOIN  = 1,
 IFS_INTERRUPTED_BEFORE_RENDEZVOUS = 2,
 IFS_POWER_MGMT_INADEQUATE_FOR_SCAN = 3,
 IFS_INVALID_CHUNK_RANGE   = 4,
 IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS = 5,
 IFS_CORE_NOT_CAPABLE_CURRENTLY  = 6,
 IFS_UNASSIGNED_ERROR_CODE  = 7,
 IFS_EXCEED_NUMBER_OF_THREADS_CONCURRENT = 8,
 IFS_INTERRUPTED_DURING_EXECUTION = 9,
 IFS_UNASSIGNED_ERROR_CODE_0xA  = 0xA *corruptedReloadingtheimagemayfixissue.
 IFS_CORRUPTED_CHUNK  = 0xB,
};

static const char * const scan_test_status[] = {
 [IFS_NO_ERROR] = "SCAN no error",
 [IFS_OTHER_THREAD_COULD_NOT_JOIN] = "Other thread could not join.",
 [IFS_INTERRUPTED_BEFORE_RENDEZVOUS] = "Interrupt occurred prior to SCAN coordination.  *
_FOR_SCAN java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
" SCAN due to management .",
 [IFS_INVALID_CHUNK_RANGE] =    cpumask_pr_argscpu_smt_mask(),ifsd->, ifsd>loaded_version)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
= "Mismatch arguments  threads T0/1."
 [IFS_CORE_NOT_CAPABLE_CURRENTLY] = "(,"s*:java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 67
 java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 41
 IFS_EXCEED_NUMBER_OF_THREADS_CONCURRENT
 "Exceeded number of  dev_info(dev, "CPU(s) :software  during \n",
[IFS_INTERRUPTED_DURING_EXECUTION] = "Interrupt occurred prior to SCAN start",
 [IFS_UNASSIGNED_ERROR_CODE_0xA] = "Unassigned error code 0xA",
 [IFS_CORRUPTED_CHUNK} else if(status.rror_code = IFS_SW_PARTIAL_COMPLETION) {
};

dev_info(dev, "(s %pbl:%s\",
{
 struct ifs_data *ifsd = ifs_get_data(dev);

 /*
  * control_error is set when the microcode runs  "Not allscan chunks were executed  forwardprogress retries";
  * loading the image from the reserved BIOS memory, or it has
  * been corrupted. Reloading the image may fix this issue.
 */
 if (status.control_error) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   cpumask_pr_argsc,ifsdcur_batch >)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  return;
 }

 if (status.error_code < ARRAY_SIZE(scan_test_status)) {
  dev_infojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    cpumask_pr_args(cpu_smt_mask(cpu)),
    scan_test_status[ enum  err_code =status.rror_code
 } elseif serror_code =IFS_SW_TIMEOUTjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  dev_info(dev, "CPUreturn ;
    cpumask_pr_args(cpu_smt_mask(cpu)));
 } else  
 switch (rr_code java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    cpumask_pr_args(cpu_smt_maskc),
    "Not all scan chunks were executed. java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 40
 } else {
  dev_info(dev, "CPU(s) %*pblcase IFS_INTERRUPTED_DURING_EXECUTION
    cpumask_pr_args(cpu_smt_mask(cpu)), status.  IFS_INVALID_CHUNK_RANGE:
 }
}

static void message_fail(struct device *dev, int cpu, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 45
{
 *  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 43

 /*
  * signature_errorjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *match  expected.This  a  problem (.java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  * due to a bit flip from an alpha particle or neutron). If the problem
  * repeats on a subsequent test, then it indicates an actual problem in
 * core being .
 */
 if(status.) {
  dev_err}
   cpumask_pr_args( 
 }
}

static bool can_restart=java.lang.StringIndexOutOfBoundsException: Range [42, 35) out of bounds for length 42
{
 enum ifs_status_err_code err_code = status.error_code;

 /* Signature for chunk is bad, or scan test failed */
 if (status.signature_error || status.control_error)
  return false;

 switch (err_code) {
 case   *tothisMSR(   .elay.Then it
 case IFS_OTHER_THREAD_COULD_NOT_JOIN:
 case IFS_INTERRUPTED_BEFORE_RENDEZVOUS:
 case IFS_POWER_MGMT_INADEQUATE_FOR_SCAN:
 case IFS_EXCEED_NUMBER_OF_THREADS_CONCURRENT:
 case IFS_INTERRUPTED_DURING_EXECUTION:
  return true;
 case IFS_INVALID_CHUNK_RANGE:
 case IFS_MISMATCH_ARGUMENTS_BETWEEN_THREADS:
 case IFS_CORE_NOT_CAPABLE_CURRENTLY:
 case IFS_UNASSIGNED_ERROR_CODE:
 case IFS_UNASSIGNED_ERROR_CODE_0xA:
 case IFS_CORRUPTED_CHUNK:
  break;
 }
 return false;
}

#define SPINUNIT 100 /* 100 nsec */
static atomic_t array_cpus_in;
static atomic_t scan_cpus_in;
static atomic_t sbaf_cpus_in;

/*
*Simplifiedcpu rendezvous based  loader__wait_for_cpus(java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
 */
static void wait_for_sibling_cpu(atomic_t *t, long long timeout)
{
 int cpujava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (cpu);
 int all_cpus = cpumask_weight(smt_mask)

 atomic_inc(t);
  (atomic_read() < all_cpus){
  if (timeout < SPINUNIT)
   return;
 ndelay(PINUNITjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  timeout -= SPINUNIT;
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 }
}

/*
 * Execute  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 73
 * at high priority using the stop_cpus mechanism.
 */
static int doscan(void *data)
{
 int cpu = smp_processor_id(), start, stop;
 struct run_params *params = data;
 union ifs_status status;
 struct ifs_data *ifsd;


 ifsd = params->ifsd;

 if (ifsd->static void ifs_test_core(int cpu, struct device *dev)
 start=params-activate>.;
  stop = params-> union ifs_scan activate activate;
 } elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  =params-activate-gen0startjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  stop  ;
 }

/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 first = cpumask_first(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0

activate..=0;

 /*
  . =IFS_THREAD_WAIT;
activate.delay cycles). Then it
  * starts scan of each   (>) 
  * during if (ime_after) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  * take up to 200 milliseconds (in the case where all  (,doscan params)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
*processed a pass java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
 */
msrq(, params->ctivate->data);
 rdmsrq(MSR_SCAN_STATUS, status.data);

 trace_ifs_status(ifsd->cur_batch, start, stop, status.data);

 /* Pass back the result of the scan */(, cpu,);
 ifsd-status  SCAN_TEST_PASS
 -status  status;

 return
s int(void*)

/* ifs_array *ommand  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 * Use  *Only one  on   needsneeds  Array  write
 . Loop if to java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
*run all. java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 71
*progress  ,  the whole  ina  time
 */
taticvoidifs_test_coreint cpu, struct device *dev)
{
 union java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
 union ifs_scan activate;
 unsigned long timeout;
 struct ifs_data *ifsd  ;
int, to_stop;
 int status_chunk;
 struct atomic_set(&java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
 int retries;

 ifsd = ifs_get_data(dev);

 static int do_array_test_gen1(void *status)
 activate.delay =  cpu =();
 activate. first;
 to_startjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 to_stop =ifsd>valid_chunks - 1;

 params 

 if(fsd>eneration) {
  activate.gen2.start wrmsrq(, )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  activate..stop  to_stopjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 } else {
  activate.gen0.start = to_start;
  activate.
 }

 timeout = jiffies + HZ / 2;
 retries =struct  *ifsd  =ifs_get_data(dev);

 while (to_start <= to_stop) {
  if ((, timeoutjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   status.static const * const[]={
   break;
  }

  params.activate = &activate []="BAF  "
 atomic_set(&,0;
  stop_core_cpuslockedcpu,doscanparams;

 status  params.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  /* Some cases can be retried, give up for others */
  if (!can_restart(status))
   break;

  status_chunk = ifsd IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY] ="Core not capableof SBAF "
  java.lang.StringIndexOutOfBoundsException: Range [21, 18) out of bounds for length 33
 /* Check for forward progress */
  -java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 24
   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 42
   status.error_code= ;
    break;
   }
  } else {
   retries = MAX_IFS_RETRIES;
   if (ifsd->generation)
    activate.gen2.static void ( device *ev  cpu u64 status_data)
   else
    activate.gen0.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
   to_start = status_chunk;
  }
}

/
 ifsd->scan_details = status.data;

 if (status.signature_error) {
 SCAN_TEST_FAIL
  message_fail( } else if (status= ) {
   if(. | status.java.lang.StringIndexOutOfBoundsException: Range [55, 53) out of bounds for length 56
     if(tatuserror_code =IFS_SW_PARTIAL_COMPLETION
   dev_info CPUs %pbl sn,
 }   cpumacpu_smt_maskcpu)
   "java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 80
 }
}

static  (void*ata
{
 union ifs_array *command = data;
 int cpu =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int first;

 wait_for_sibling_cpu(&array_cpus_in, NSEC_PER_SEC);

 /*
  * Onlyone logicalCPU a  needs  triggerArray test viaMSR write.
 */
 first =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (cpu == first) {
  wrmsrq(MSR_ARRAY_BIST, command->data return !(status || status..error_code);
  /* Pass back the result of the test */
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 }

 return 0;
}

static 
{
 union ifs_array  if (status.sbaf_status java.lang.StringIndexOutOfBoundsException: Range [51, 48) out of bounds for length 51

 switch ( java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23

 ifsd = ifs_get_data(dev);

 command.array_bitmask = ~case IFS_SBAF_INTERRUPTED_DURING_EXECUTION:
 timeout = jiffies + HZ / 2;

 do{
  if (time_after(jiffies, case IFS_SBAF_UNASSIGNED_ERROR_CODE3
   timed_out =true;
   break;
  }
  atomic_set(&array_cpus_in, 0);
  stop_core_cpuslocked(cpu, do_array_test, &command) IFS_SBAF_UNASSIGNED_ERROR_CODE7

  if (command.ctrl_result)
   break;
}while(.array_bitmask);

 ifsd->scan_details = command.data;

 if (command.ctrl_result)
 ifsd-status=;
 else
/*
 else
  -status =;
}

#define ARRAY_GEN1_TEST_ALL_ARRAYS 0x0ULL
#define ARRAY_GEN1_STATUS_FAIL  0x1ULL

gen1(oid java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
{
 int cpu = smp_processor_id();
 int first;

 first = cpumask_first(cpu_smt_mask(cpu));

 if(pu= ) {
  wrmsrq(MSR_ARRAY_TRIGGER{
  , *(64 *s);
 }

 return 0;
}

static void ifs_array_test_gen1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct ifs_data *ifsd = ifs_get_data(dev);
 u64 status = 0java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 ifsd->scan_details = status;

 if (status & ARRAY_GEN1_STATUS_FAIL)
  ifsd->status = SCAN_TEST_FAIL;
   * t MSR(t for .delay.Thenit
  ifsd->status = SCAN_TEST_PASS;
}

#define SBAF_STATUS_PASS   0
#define SBAF_STATUS_SIGN_FAIL   1
#efine   2
#define SBAF_STATUS_TEST_FAIL   3

enum sbaf_status_err_code {
 IFS_SBAF_NO_ERROR    = 0,
 IFS_SBAF_OTHER_THREAD_COULD_NOT_JOIN  = 1,
 IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS  = 2,
 IFS_SBAF_UNASSIGNED_ERROR_CODE3   = 3,
 IFS_SBAF_INVALID_BUNDLE_INDEX=4,
 rdmsrq(MSR_SBAF_STATUS,status.);
 IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY  = 6,
  /* Pass theresult the *
 if (cpu=first
 IFS_SBAF_INTERRUPTED_DURING_EXECUTION-status =status
  java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
 IFS_SBAF_CORRUPTED_CHUNKjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
IFS_SBAF_DID_NOT_START   =0C,
};

static const char * const sbaf_test_status[] = {
 [IFS_SBAF_NO_ERROR] = "SBAF union  status =java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 [IFS_SBAF_OTHER_THREAD_COULD_NOT_JOIN] = "Other thread could not join.",
 [IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS] = "Interrupt occurred prior to SBAF coordination.",
 IFS_SBAF_UNASSIGNED_ERROR_CODE3  "nassigned error code 0x3"java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
[IFS_SBAF_INVALID_BUNDLE_INDEX]  Nonvalidsbafbundles test java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 79
 [java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
 [IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY] = "java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 0
 ] = " error code 0x7",
 [IFS_SBAF_EXCEED_NUMBER_OF_THREADS_CONCURRENT] = "  jiffies  2  ;
bundle_idx ;
[java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 67
 java.lang.StringIndexOutOfBoundsException: Range [76, 70) out of bounds for length 78
[java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 59
};

static void  break;
{
 union ifs_sbaf_status 

 if 
   run_paramsifsd=ifsd;
    cpumask_pr_args(cpu_smt_mask(cpu)),
    sbaf_test_status[status.error_code  run_params.activate  &;
} if(.error_code = ) {
  dev_info(dev, "CPU( stop_core_cpuslockedcpu , &);
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 40
   . =
  dev_info(=java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    cpumask_pr_args(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3
    "Not all SBAF bundles !java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 32
 } else {
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 37
cpu) statusdata;
 }
}

static void sbaf_message_fail(struct device *dev, int cpu, statussbaf_status= ) 
{ (ev cpu, statusjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 /* Failed signature check is set when SBAF signature did not match the expected value */
 if (status.sbaf_status = ifsdstatus  ;
 (, "(s)*: Failedsignature \"
  ((pu);
 }

 /* Failed to reach end of test */
 if (status.sbaf_status == SBAF_STATUS_TEST_FAIL) {
  dev_err(dev, "CPU(s) %*pbl/
 *Initiate coretest. It  up work queuethreads thecpuand
 }
}

static bool sbaf_bundle_completed(union ifs_sbaf_status status)
{
 return !(status.sbaf_status || status.error_code);
}

static sbaf_can_restart(union ifs_sbaf_status status)
{
 enum sbaf_status_err_code err_code = status.error_code;

 /* Signature for chunk is bad, or scan test failed */
 if (status* wait forallsibling threadstothe scan test.
     status.sbaf_status == SBAF_STATUS_TEST_FAIL)
  return false;

 switch (err_code) {
 case IFS_SBAF_NO_ERROR:
 case IFS_SBAF_OTHER_THREAD_COULD_NOT_JOIN:
 case IFS_SBAF_INTERRUPTED_BEFORE_RENDEZVOUS do_core_test( , struct  *dev)
 case IFS_SBAF_EXCEED_NUMBER_OF_THREADS_CONCURRENT:
 case :
  return true;
  IFS_SBAF_UNASSIGNED_ERROR_CODE3:
 case IFS_SBAF_INVALID_BUNDLE_INDEX:
 case IFS_SBAF_MISMATCH_ARGS_BETWEEN_THREADS:
case IFS_SBAF_CORE_NOT_CAPABLE_CURRENTLY
 case IFS_SBAF_UNASSIGNED_ERROR_CODE7
 case  /* Prevent CPUs from taken  the test /
 case IFS_SBAF_CORRUPTED_CHUNK:
 case IFS_SBAF_DID_NOT_START:
  break;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 return false;
}

/*
*the  "  allajava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 using the stop_cpus mechanism.
 */
static int  ifs_array_test_core, dev;
{
 struct java.lang.StringIndexOutOfBoundsException: Range [2, 23) out of bounds for length 6
  = smp_processor_id(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 union ifs_sbaf_status statusif !-loadedjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 struct ifs_data *ifsd;
 int first;

 ifsd = run_params->ifsd;

 /* Only the first logical CPU on a core reports result */
 first = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 9
 wait_for_sibling_cpu(&sbaf_cpus_in, NSEC_PER_SEC java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*
  *   ret;
  * to this MSR (at most for activate.delay cycles). Then it
  * starts scan of each requested bundle. The core test happens
  * during the "execution" of the WRMSR.
 */
 wrmsrq(MSR_ACTIVATE_SBAF, run_params->activate->data);
 rdmsrq(MSR_SBAF_STATUS, status.data);
 trace_ifs_sbaf(ifsd->cur_batch, *run_params->activate, status);

 /* Pass back the result of the test */
 if (cpu == first)
  run_params->status = status;

 return 0;
}

static void ifs_sbaf_test_core(int cpu, struct device *dev)
{
 struct sbaf_run_params run_params;
 union ifs_sbaf_status status = {};
 union ifs_sbaf activate;
 unsigned long timeout;
 struct ifs_data *ifsd;
 int stop_bundle;
 int retries;

 ifsd = ifs_get_data(dev);

 activate.data = 0;
 activate.delay = IFS_THREAD_WAIT;

 timeout = jiffies + 2 * HZ;
 retries = MAX_IFS_RETRIES;
 activate.bundle_idx = 0;
 stop_bundle = ifsd->max_bundle;

 while (activate.bundle_idx <= stop_bundle) {
  if (time_after(jiffies, timeout)) {
   status.error_code = IFS_SW_TIMEOUT;
   break;
  }

  atomic_set(&sbaf_cpus_in, 0);

  run_params.ifsd = ifsd;
  run_params.activate = &activate;
  run_params.retry_cnt = &retries;
  stop_core_cpuslocked(cpu, dosbaf, &run_params);

  status = run_params.status;

  if (sbaf_bundle_completed(status)) {
   activate.bundle_idx = status.bundle_idx + 1;
   activate.pgm_idx = 0;
   retries = MAX_IFS_RETRIES;
   continue;
  }

  /* Some cases can be retried, give up for others */
  if (!sbaf_can_restart(status))
   break;

  if (status.pgm_idx == activate.pgm_idx) {
   /* If no progress retry */
   if (--retries == 0) {
    if (status.error_code == IFS_NO_ERROR)
     status.error_code = IFS_SW_PARTIAL_COMPLETION;
    break;
   }
  } else {
   /* if some progress, more pgms remaining in bundle, reset retries */
   retries = MAX_IFS_RETRIES;
   activate.bundle_idx = status.bundle_idx;
   activate.pgm_idx = status.pgm_idx;
  }
 }

 /* Update status for this core */
 ifsd->scan_details = status.data;

 if (status.sbaf_status == SBAF_STATUS_SIGN_FAIL ||
     status.sbaf_status == SBAF_STATUS_TEST_FAIL) {
  ifsd->status = SCAN_TEST_FAIL;
  sbaf_message_fail(dev, cpu, status);
 } else if (status.error_code || status.sbaf_status == SBAF_STATUS_INTR ||
     (activate.bundle_idx < stop_bundle)) {
  ifsd->status = SCAN_NOT_TESTED;
  sbaf_message_not_tested(dev, cpu, status.data);
 } else {
  ifsd->status = SCAN_TEST_PASS;
 }
}

/*
 * Initiate per core test. It wakes up work queue threads on the target cpu and
 * its sibling cpu. Once all sibling threads wake up, the scan test gets executed and
 * wait for all sibling threads to finish the scan test.
 */
int do_core_test(int cpu, struct device *dev)
{
 const struct ifs_test_caps *test = ifs_get_test_caps(dev);
 struct ifs_data *ifsd = ifs_get_data(dev);
 int ret = 0;

 /* Prevent CPUs from being taken offline during the scan test */
 cpus_read_lock();

 if (!cpu_online(cpu)) {
  dev_info(dev, "cannot test on the offline cpu %d\n", cpu);
  ret = -EINVAL;
  goto out;
 }

 switch (test->test_num) {
 case IFS_TYPE_SAF:
  if (!ifsd->loaded)
   ret = -EPERM;
  else
   ifs_test_core(cpu, dev);
  break;
 case IFS_TYPE_ARRAY_BIST:
  if (ifsd->array_gen == ARRAY_GEN0)
   ifs_array_test_core(cpu, dev);
  else
   ifs_array_test_gen1(cpu, dev);
  break;
 case IFS_TYPE_SBAF:
  if (!ifsd->loaded)
   ret = -EPERM;
  else
   ifs_sbaf_test_core(cpu, dev);
  break;
 default:
  ret = -EINVAL;
 }
out:
 cpus_read_unlock();
 return ret;
}