15e61cba0SAndrew Jones /*
25e61cba0SAndrew Jones * Test the framework itself. These tests confirm that setup works.
35e61cba0SAndrew Jones *
45e61cba0SAndrew Jones * Copyright (C) 2014, Red Hat Inc, Andrew Jones <drjones@redhat.com>
55e61cba0SAndrew Jones *
65e61cba0SAndrew Jones * This work is licensed under the terms of the GNU LGPL, version 2.
75e61cba0SAndrew Jones */
88cca5668SAndrew Jones #include <libcflat.h>
9e7c68b43SAndrew Jones #include <util.h>
100415feeaSAndrew Jones #include <devicetree.h>
112479ae50SAndrew Jones #include <memregions.h>
12cf251b71SAndrew Jones #include <vmalloc.h>
138cca5668SAndrew Jones #include <asm/setup.h>
148cca5668SAndrew Jones #include <asm/ptrace.h>
158cca5668SAndrew Jones #include <asm/asm-offsets.h>
168cca5668SAndrew Jones #include <asm/processor.h>
171693644dSAndrew Jones #include <asm/thread_info.h>
180415feeaSAndrew Jones #include <asm/psci.h>
190415feeaSAndrew Jones #include <asm/smp.h>
20cf251b71SAndrew Jones #include <asm/mmu.h>
210415feeaSAndrew Jones #include <asm/barrier.h>
225e61cba0SAndrew Jones
23ebd48a5cSAndre Przywara static cpumask_t ready, valid;
24ebd48a5cSAndre Przywara
__user_psci_system_off(void)25a99ccaecSAndrew Jones static void __user_psci_system_off(void)
26a99ccaecSAndrew Jones {
27a99ccaecSAndrew Jones psci_system_off();
28a99ccaecSAndrew Jones halt();
29a99ccaecSAndrew Jones __builtin_unreachable();
30a99ccaecSAndrew Jones }
31a99ccaecSAndrew Jones
check_setup(int argc,char ** argv)325e61cba0SAndrew Jones static void check_setup(int argc, char **argv)
335e61cba0SAndrew Jones {
34e7c68b43SAndrew Jones int nr_tests = 0, len, i;
355e61cba0SAndrew Jones long val;
365e61cba0SAndrew Jones
375e61cba0SAndrew Jones for (i = 0; i < argc; ++i) {
385e61cba0SAndrew Jones
39e7c68b43SAndrew Jones len = parse_keyval(argv[i], &val);
40e7c68b43SAndrew Jones if (len == -1)
415e61cba0SAndrew Jones continue;
425e61cba0SAndrew Jones
43e7c68b43SAndrew Jones argv[i][len] = '\0';
44e7c68b43SAndrew Jones report_prefix_push(argv[i]);
45a8568128SAndrew Jones
46e7c68b43SAndrew Jones if (strcmp(argv[i], "mem") == 0) {
475e61cba0SAndrew Jones
485e61cba0SAndrew Jones phys_addr_t memsize = PHYS_END - PHYS_OFFSET;
495e61cba0SAndrew Jones phys_addr_t expected = ((phys_addr_t)val)*1024*1024;
505e61cba0SAndrew Jones
51a299895bSThomas Huth report(memsize == expected,
52a299895bSThomas Huth "memory size matches expectation");
536c254675SAndre Przywara report_info("found %" PRIu64 " MB", memsize/1024/1024);
545e61cba0SAndrew Jones ++nr_tests;
555e61cba0SAndrew Jones
56e7c68b43SAndrew Jones } else if (strcmp(argv[i], "smp") == 0) {
575e61cba0SAndrew Jones
58a299895bSThomas Huth report(nr_cpus == (int)val,
59a299895bSThomas Huth "number of CPUs matches expectation");
606c254675SAndre Przywara report_info("found %d CPUs", nr_cpus);
615e61cba0SAndrew Jones ++nr_tests;
625e61cba0SAndrew Jones }
63a8568128SAndrew Jones
64a8568128SAndrew Jones report_prefix_pop();
655e61cba0SAndrew Jones }
665e61cba0SAndrew Jones
67e7c68b43SAndrew Jones if (nr_tests < 2)
68e7c68b43SAndrew Jones report_abort("missing input");
695e61cba0SAndrew Jones }
705e61cba0SAndrew Jones
71cf251b71SAndrew Jones unsigned long check_pabt_invalid_paddr;
check_pabt_init(void)72cf251b71SAndrew Jones static bool check_pabt_init(void)
73cf251b71SAndrew Jones {
74cf251b71SAndrew Jones phys_addr_t highest_end = 0;
75cf251b71SAndrew Jones unsigned long vaddr;
76cf251b71SAndrew Jones struct mem_region *r;
77cf251b71SAndrew Jones
78cf251b71SAndrew Jones /*
79cf251b71SAndrew Jones * We need a physical address that isn't backed by anything. Without
80cf251b71SAndrew Jones * fully parsing the device tree there's no way to be certain of any
81cf251b71SAndrew Jones * address, but an unknown address immediately following the highest
82cf251b71SAndrew Jones * memory region has a reasonable chance. This is because we can
83cf251b71SAndrew Jones * assume that that memory region could have been larger, if the user
84cf251b71SAndrew Jones * had configured more RAM, and therefore no MMIO region should be
85cf251b71SAndrew Jones * there.
86cf251b71SAndrew Jones */
87cf251b71SAndrew Jones for (r = mem_regions; r->end; ++r) {
88cf251b71SAndrew Jones if (r->flags & MR_F_IO)
89cf251b71SAndrew Jones continue;
90cf251b71SAndrew Jones if (r->end > highest_end)
91cf251b71SAndrew Jones highest_end = PAGE_ALIGN(r->end);
92cf251b71SAndrew Jones }
93cf251b71SAndrew Jones
942479ae50SAndrew Jones if (memregions_get_flags(highest_end) != MR_F_UNKNOWN)
95cf251b71SAndrew Jones return false;
96cf251b71SAndrew Jones
97cf251b71SAndrew Jones vaddr = (unsigned long)vmap(highest_end, PAGE_SIZE);
98cf251b71SAndrew Jones mmu_clear_user(current_thread_info()->pgtable, vaddr);
99cf251b71SAndrew Jones check_pabt_invalid_paddr = vaddr;
100cf251b71SAndrew Jones
101cf251b71SAndrew Jones return true;
102cf251b71SAndrew Jones }
103cf251b71SAndrew Jones
1042edfe428SAndrew Jones static struct pt_regs expected_regs;
1057ee966e9SAndrew Jones static bool und_works;
1067ee966e9SAndrew Jones static bool svc_works;
107cf251b71SAndrew Jones static bool pabt_works;
1087ee966e9SAndrew Jones #if defined(__arm__)
1092edfe428SAndrew Jones /*
1102edfe428SAndrew Jones * Capture the current register state and execute an instruction
1112edfe428SAndrew Jones * that causes an exception. The test handler will check that its
1122edfe428SAndrew Jones * capture of the current register state matches the capture done
1132edfe428SAndrew Jones * here.
1142edfe428SAndrew Jones */
115da54ab51SAndrew Jones #define test_exception(pre_insns, excptn_insn, post_insns, clobbers...) \
1162edfe428SAndrew Jones asm volatile( \
1172edfe428SAndrew Jones pre_insns "\n" \
1182edfe428SAndrew Jones "mov r0, %0\n" \
1192edfe428SAndrew Jones "stmia r0, { r0-lr }\n" \
1202edfe428SAndrew Jones "mrs r1, cpsr\n" \
1212edfe428SAndrew Jones "str r1, [r0, #" xstr(S_PSR) "]\n" \
1222edfe428SAndrew Jones "mov r1, #-1\n" \
1232edfe428SAndrew Jones "str r1, [r0, #" xstr(S_OLD_R0) "]\n" \
1242edfe428SAndrew Jones "add r1, pc, #8\n" \
1252edfe428SAndrew Jones "str r1, [r0, #" xstr(S_R1) "]\n" \
1262edfe428SAndrew Jones "str r1, [r0, #" xstr(S_PC) "]\n" \
1272edfe428SAndrew Jones excptn_insn "\n" \
1282edfe428SAndrew Jones post_insns "\n" \
129da54ab51SAndrew Jones :: "r" (&expected_regs) : "r0", "r1", ##clobbers)
1302edfe428SAndrew Jones
check_regs(struct pt_regs * regs)1312edfe428SAndrew Jones static bool check_regs(struct pt_regs *regs)
1322edfe428SAndrew Jones {
1332edfe428SAndrew Jones unsigned i;
1342edfe428SAndrew Jones
1352edfe428SAndrew Jones /* exception handlers should always run in svc mode */
1362edfe428SAndrew Jones if (current_mode() != SVC_MODE)
1372edfe428SAndrew Jones return false;
1382edfe428SAndrew Jones
1392edfe428SAndrew Jones for (i = 0; i < ARRAY_SIZE(regs->uregs); ++i) {
1402edfe428SAndrew Jones if (regs->uregs[i] != expected_regs.uregs[i])
1412edfe428SAndrew Jones return false;
1422edfe428SAndrew Jones }
1432edfe428SAndrew Jones
1442edfe428SAndrew Jones return true;
1452edfe428SAndrew Jones }
1462edfe428SAndrew Jones
und_handler(struct pt_regs * regs)1472edfe428SAndrew Jones static void und_handler(struct pt_regs *regs)
1482edfe428SAndrew Jones {
1492edfe428SAndrew Jones und_works = check_regs(regs);
1502edfe428SAndrew Jones }
1512edfe428SAndrew Jones
check_und(void)1522edfe428SAndrew Jones static bool check_und(void)
1532edfe428SAndrew Jones {
1542edfe428SAndrew Jones install_exception_handler(EXCPTN_UND, und_handler);
1552edfe428SAndrew Jones
1562edfe428SAndrew Jones /* issue an instruction to a coprocessor we don't have */
157da54ab51SAndrew Jones test_exception("", "mcr p2, 0, r0, c0, c0", "", "r0");
1582edfe428SAndrew Jones
1592edfe428SAndrew Jones install_exception_handler(EXCPTN_UND, NULL);
1602edfe428SAndrew Jones
1612edfe428SAndrew Jones return und_works;
1622edfe428SAndrew Jones }
1632edfe428SAndrew Jones
svc_handler(struct pt_regs * regs)1642edfe428SAndrew Jones static void svc_handler(struct pt_regs *regs)
1652edfe428SAndrew Jones {
1662edfe428SAndrew Jones u32 svc = *(u32 *)(regs->ARM_pc - 4) & 0xffffff;
1672edfe428SAndrew Jones
1682edfe428SAndrew Jones if (processor_mode(regs) == SVC_MODE) {
1692edfe428SAndrew Jones /*
1702edfe428SAndrew Jones * When issuing an svc from supervisor mode lr_svc will
1712edfe428SAndrew Jones * get corrupted. So before issuing the svc, callers must
1722edfe428SAndrew Jones * always push it on the stack. We pushed it to offset 4.
1732edfe428SAndrew Jones */
1742edfe428SAndrew Jones regs->ARM_lr = *(unsigned long *)(regs->ARM_sp + 4);
1752edfe428SAndrew Jones }
1762edfe428SAndrew Jones
1772edfe428SAndrew Jones svc_works = check_regs(regs) && svc == 123;
1782edfe428SAndrew Jones }
1792edfe428SAndrew Jones
check_svc(void)1802edfe428SAndrew Jones static bool check_svc(void)
1812edfe428SAndrew Jones {
1822edfe428SAndrew Jones install_exception_handler(EXCPTN_SVC, svc_handler);
1832edfe428SAndrew Jones
1842edfe428SAndrew Jones if (current_mode() == SVC_MODE) {
1852edfe428SAndrew Jones /*
1862edfe428SAndrew Jones * An svc from supervisor mode will corrupt lr_svc and
1872edfe428SAndrew Jones * spsr_svc. We need to save/restore them separately.
1882edfe428SAndrew Jones */
1892edfe428SAndrew Jones test_exception(
1902edfe428SAndrew Jones "mrs r0, spsr\n"
1912edfe428SAndrew Jones "push { r0,lr }\n",
1922edfe428SAndrew Jones "svc #123\n",
1932edfe428SAndrew Jones "pop { r0,lr }\n"
194da54ab51SAndrew Jones "msr spsr_cxsf, r0\n",
195da54ab51SAndrew Jones "r0", "lr"
1962edfe428SAndrew Jones );
1972edfe428SAndrew Jones } else {
1982edfe428SAndrew Jones test_exception("", "svc #123", "");
1992edfe428SAndrew Jones }
2002edfe428SAndrew Jones
2012edfe428SAndrew Jones install_exception_handler(EXCPTN_SVC, NULL);
2022edfe428SAndrew Jones
2032edfe428SAndrew Jones return svc_works;
2042edfe428SAndrew Jones }
205a99ccaecSAndrew Jones
pabt_handler(struct pt_regs * regs)206cf251b71SAndrew Jones static void pabt_handler(struct pt_regs *regs)
207cf251b71SAndrew Jones {
208cf251b71SAndrew Jones expected_regs.ARM_lr = expected_regs.ARM_pc;
209cf251b71SAndrew Jones expected_regs.ARM_pc = expected_regs.ARM_r9;
210cf251b71SAndrew Jones
211cf251b71SAndrew Jones pabt_works = check_regs(regs);
212cf251b71SAndrew Jones
213cf251b71SAndrew Jones regs->ARM_pc = regs->ARM_lr;
214cf251b71SAndrew Jones }
215cf251b71SAndrew Jones
check_pabt(void)216cf251b71SAndrew Jones static bool check_pabt(void)
217cf251b71SAndrew Jones {
218cf251b71SAndrew Jones install_exception_handler(EXCPTN_PABT, pabt_handler);
219cf251b71SAndrew Jones
220cf251b71SAndrew Jones test_exception("ldr r9, =check_pabt_invalid_paddr\n"
221cf251b71SAndrew Jones "ldr r9, [r9]\n",
222cf251b71SAndrew Jones "blx r9\n",
223cf251b71SAndrew Jones "", "r9", "lr");
224cf251b71SAndrew Jones
225cf251b71SAndrew Jones install_exception_handler(EXCPTN_PABT, NULL);
226cf251b71SAndrew Jones
227cf251b71SAndrew Jones return pabt_works;
228cf251b71SAndrew Jones }
229cf251b71SAndrew Jones
user_psci_system_off(struct pt_regs * regs)230a99ccaecSAndrew Jones static void user_psci_system_off(struct pt_regs *regs)
231a99ccaecSAndrew Jones {
232a99ccaecSAndrew Jones __user_psci_system_off();
233a99ccaecSAndrew Jones }
2347ee966e9SAndrew Jones #elif defined(__aarch64__)
2357ee966e9SAndrew Jones
2367ee966e9SAndrew Jones /*
2377ee966e9SAndrew Jones * Capture the current register state and execute an instruction
2387ee966e9SAndrew Jones * that causes an exception. The test handler will check that its
2397ee966e9SAndrew Jones * capture of the current register state matches the capture done
2407ee966e9SAndrew Jones * here.
2417ee966e9SAndrew Jones */
242da54ab51SAndrew Jones #define test_exception(pre_insns, excptn_insn, post_insns, clobbers...) \
2437ee966e9SAndrew Jones asm volatile( \
2447ee966e9SAndrew Jones pre_insns "\n" \
2457ee966e9SAndrew Jones "mov x1, %0\n" \
2467ee966e9SAndrew Jones "ldr x0, [x1, #" xstr(S_PSTATE) "]\n" \
2477ee966e9SAndrew Jones "mrs x1, nzcv\n" \
2487ee966e9SAndrew Jones "orr w0, w0, w1\n" \
2497ee966e9SAndrew Jones "mov x1, %0\n" \
2507ee966e9SAndrew Jones "str w0, [x1, #" xstr(S_PSTATE) "]\n" \
2517ee966e9SAndrew Jones "mov x0, sp\n" \
2527ee966e9SAndrew Jones "str x0, [x1, #" xstr(S_SP) "]\n" \
2537ee966e9SAndrew Jones "adr x0, 1f\n" \
2547ee966e9SAndrew Jones "str x0, [x1, #" xstr(S_PC) "]\n" \
2557ee966e9SAndrew Jones "stp x2, x3, [x1, #16]\n" \
2567ee966e9SAndrew Jones "stp x4, x5, [x1, #32]\n" \
2577ee966e9SAndrew Jones "stp x6, x7, [x1, #48]\n" \
2587ee966e9SAndrew Jones "stp x8, x9, [x1, #64]\n" \
2597ee966e9SAndrew Jones "stp x10, x11, [x1, #80]\n" \
2607ee966e9SAndrew Jones "stp x12, x13, [x1, #96]\n" \
2617ee966e9SAndrew Jones "stp x14, x15, [x1, #112]\n" \
2627ee966e9SAndrew Jones "stp x16, x17, [x1, #128]\n" \
2637ee966e9SAndrew Jones "stp x18, x19, [x1, #144]\n" \
2647ee966e9SAndrew Jones "stp x20, x21, [x1, #160]\n" \
2657ee966e9SAndrew Jones "stp x22, x23, [x1, #176]\n" \
2667ee966e9SAndrew Jones "stp x24, x25, [x1, #192]\n" \
2677ee966e9SAndrew Jones "stp x26, x27, [x1, #208]\n" \
2687ee966e9SAndrew Jones "stp x28, x29, [x1, #224]\n" \
2697ee966e9SAndrew Jones "str x30, [x1, #" xstr(S_LR) "]\n" \
2707ee966e9SAndrew Jones "stp x0, x1, [x1]\n" \
2717ee966e9SAndrew Jones "1:" excptn_insn "\n" \
2727ee966e9SAndrew Jones post_insns "\n" \
273da54ab51SAndrew Jones :: "r" (&expected_regs) : "x0", "x1", ##clobbers)
2747ee966e9SAndrew Jones
check_regs(struct pt_regs * regs)2757ee966e9SAndrew Jones static bool check_regs(struct pt_regs *regs)
2767ee966e9SAndrew Jones {
2777ee966e9SAndrew Jones unsigned i;
2787ee966e9SAndrew Jones
2797ee966e9SAndrew Jones /* exception handlers should always run in EL1 */
2807ee966e9SAndrew Jones if (current_level() != CurrentEL_EL1)
2817ee966e9SAndrew Jones return false;
2827ee966e9SAndrew Jones
2837ee966e9SAndrew Jones for (i = 0; i < ARRAY_SIZE(regs->regs); ++i) {
2847ee966e9SAndrew Jones if (regs->regs[i] != expected_regs.regs[i])
2857ee966e9SAndrew Jones return false;
2867ee966e9SAndrew Jones }
2877ee966e9SAndrew Jones
2887ee966e9SAndrew Jones regs->pstate &= 0xf0000000 /* NZCV */ | 0x3c0 /* DAIF */
2897ee966e9SAndrew Jones | PSR_MODE_MASK;
2907ee966e9SAndrew Jones
2917ee966e9SAndrew Jones return regs->sp == expected_regs.sp
2927ee966e9SAndrew Jones && regs->pc == expected_regs.pc
2937ee966e9SAndrew Jones && regs->pstate == expected_regs.pstate;
2947ee966e9SAndrew Jones }
2957ee966e9SAndrew Jones
check_vector_prep(void)2967ee966e9SAndrew Jones static enum vector check_vector_prep(void)
2977ee966e9SAndrew Jones {
2987ee966e9SAndrew Jones unsigned long daif;
2997ee966e9SAndrew Jones
300f6d10793SAndrew Jones if (is_user())
3017ee966e9SAndrew Jones return EL0_SYNC_64;
3027ee966e9SAndrew Jones
3037ee966e9SAndrew Jones asm volatile("mrs %0, daif" : "=r" (daif) ::);
3047ee966e9SAndrew Jones expected_regs.pstate = daif | PSR_MODE_EL1h;
3057ee966e9SAndrew Jones return EL1H_SYNC;
3067ee966e9SAndrew Jones }
3077ee966e9SAndrew Jones
unknown_handler(struct pt_regs * regs,unsigned int esr __unused)3087ee966e9SAndrew Jones static void unknown_handler(struct pt_regs *regs, unsigned int esr __unused)
3097ee966e9SAndrew Jones {
3107ee966e9SAndrew Jones und_works = check_regs(regs);
3117ee966e9SAndrew Jones regs->pc += 4;
3127ee966e9SAndrew Jones }
3137ee966e9SAndrew Jones
check_und(void)3147ee966e9SAndrew Jones static bool check_und(void)
3157ee966e9SAndrew Jones {
3167ee966e9SAndrew Jones enum vector v = check_vector_prep();
3177ee966e9SAndrew Jones
3187ee966e9SAndrew Jones install_exception_handler(v, ESR_EL1_EC_UNKNOWN, unknown_handler);
3197ee966e9SAndrew Jones
3207ee966e9SAndrew Jones /* try to read an el2 sysreg from el0/1 */
321da54ab51SAndrew Jones test_exception("", "mrs x0, sctlr_el2", "", "x0");
3227ee966e9SAndrew Jones
3237ee966e9SAndrew Jones install_exception_handler(v, ESR_EL1_EC_UNKNOWN, NULL);
3247ee966e9SAndrew Jones
3257ee966e9SAndrew Jones return und_works;
3267ee966e9SAndrew Jones }
3277ee966e9SAndrew Jones
svc_handler(struct pt_regs * regs,unsigned int esr)3287ee966e9SAndrew Jones static void svc_handler(struct pt_regs *regs, unsigned int esr)
3297ee966e9SAndrew Jones {
3307ee966e9SAndrew Jones u16 svc = esr & 0xffff;
3317ee966e9SAndrew Jones
3327ee966e9SAndrew Jones expected_regs.pc += 4;
3337ee966e9SAndrew Jones svc_works = check_regs(regs) && svc == 123;
3347ee966e9SAndrew Jones }
3357ee966e9SAndrew Jones
check_svc(void)3367ee966e9SAndrew Jones static bool check_svc(void)
3377ee966e9SAndrew Jones {
3387ee966e9SAndrew Jones enum vector v = check_vector_prep();
3397ee966e9SAndrew Jones
3407ee966e9SAndrew Jones install_exception_handler(v, ESR_EL1_EC_SVC64, svc_handler);
3417ee966e9SAndrew Jones
3427ee966e9SAndrew Jones test_exception("", "svc #123", "");
3437ee966e9SAndrew Jones
3447ee966e9SAndrew Jones install_exception_handler(v, ESR_EL1_EC_SVC64, NULL);
3457ee966e9SAndrew Jones
3467ee966e9SAndrew Jones return svc_works;
3477ee966e9SAndrew Jones }
348a99ccaecSAndrew Jones
pabt_handler(struct pt_regs * regs,unsigned int esr)349cf251b71SAndrew Jones static void pabt_handler(struct pt_regs *regs, unsigned int esr)
350cf251b71SAndrew Jones {
351cf251b71SAndrew Jones bool is_extabt = (esr & ESR_EL1_FSC_MASK) == ESR_EL1_FSC_EXTABT;
352cf251b71SAndrew Jones
353cf251b71SAndrew Jones expected_regs.regs[30] = expected_regs.pc + 4;
354cf251b71SAndrew Jones expected_regs.pc = expected_regs.regs[9];
355cf251b71SAndrew Jones
356cf251b71SAndrew Jones pabt_works = check_regs(regs) && is_extabt;
357cf251b71SAndrew Jones
358cf251b71SAndrew Jones regs->pc = regs->regs[30];
359cf251b71SAndrew Jones }
360cf251b71SAndrew Jones
check_pabt(void)361cf251b71SAndrew Jones static bool check_pabt(void)
362cf251b71SAndrew Jones {
363cf251b71SAndrew Jones enum vector v = check_vector_prep();
364cf251b71SAndrew Jones
365cf251b71SAndrew Jones install_exception_handler(v, ESR_EL1_EC_IABT_EL1, pabt_handler);
366cf251b71SAndrew Jones
367cf251b71SAndrew Jones test_exception("adrp x9, check_pabt_invalid_paddr\n"
368cf251b71SAndrew Jones "add x9, x9, :lo12:check_pabt_invalid_paddr\n"
369cf251b71SAndrew Jones "ldr x9, [x9]\n",
370cf251b71SAndrew Jones "blr x9\n",
371cf251b71SAndrew Jones "", "x9", "x30");
372cf251b71SAndrew Jones
373cf251b71SAndrew Jones install_exception_handler(v, ESR_EL1_EC_IABT_EL1, NULL);
374cf251b71SAndrew Jones
375cf251b71SAndrew Jones return pabt_works;
376cf251b71SAndrew Jones }
377cf251b71SAndrew Jones
user_psci_system_off(struct pt_regs * regs,unsigned int esr)378a99ccaecSAndrew Jones static void user_psci_system_off(struct pt_regs *regs, unsigned int esr)
379a99ccaecSAndrew Jones {
380a99ccaecSAndrew Jones __user_psci_system_off();
381a99ccaecSAndrew Jones }
3827ee966e9SAndrew Jones #endif
3832edfe428SAndrew Jones
check_vectors(void * arg __unused)3842edfe428SAndrew Jones static void check_vectors(void *arg __unused)
3852edfe428SAndrew Jones {
386a299895bSThomas Huth report(check_und(), "und");
387a299895bSThomas Huth report(check_svc(), "svc");
388a99ccaecSAndrew Jones if (is_user()) {
389a99ccaecSAndrew Jones #ifdef __arm__
390a99ccaecSAndrew Jones install_exception_handler(EXCPTN_UND, user_psci_system_off);
391a99ccaecSAndrew Jones #else
392a99ccaecSAndrew Jones install_exception_handler(EL0_SYNC_64, ESR_EL1_EC_UNKNOWN,
393a99ccaecSAndrew Jones user_psci_system_off);
394a99ccaecSAndrew Jones #endif
395cf251b71SAndrew Jones } else {
396cf251b71SAndrew Jones if (!check_pabt_init())
397cf251b71SAndrew Jones report_skip("Couldn't guess an invalid physical address");
398cf251b71SAndrew Jones else
399cf251b71SAndrew Jones report(check_pabt(), "pabt");
400a99ccaecSAndrew Jones }
4012edfe428SAndrew Jones exit(report_summary());
4022edfe428SAndrew Jones }
4032edfe428SAndrew Jones
psci_print(void)404bd5bd157SAndrew Jones static void psci_print(void)
4050415feeaSAndrew Jones {
406bd5bd157SAndrew Jones int ver = psci_invoke(PSCI_0_2_FN_PSCI_VERSION, 0, 0, 0);
407bd5bd157SAndrew Jones report_info("PSCI version: %d.%d", PSCI_VERSION_MAJOR(ver),
4080415feeaSAndrew Jones PSCI_VERSION_MINOR(ver));
409*cddb18bcSAlexandru Elisei report_info("PSCI method: %s", psci_invoke_fn == arm_smccc_hvc ?
410bd5bd157SAndrew Jones "hvc" : "smc");
4110415feeaSAndrew Jones }
4120415feeaSAndrew Jones
cpu_report(void * data __unused)41300b34f56SAndrew Jones static void cpu_report(void *data __unused)
4140415feeaSAndrew Jones {
415d9729025SAndrew Jones uint64_t mpidr = get_mpidr();
4160415feeaSAndrew Jones int cpu = smp_processor_id();
4170415feeaSAndrew Jones
418ebd48a5cSAndre Przywara if (mpidr_to_cpu(mpidr) == cpu)
419ebd48a5cSAndre Przywara cpumask_set_cpu(smp_processor_id(), &valid);
420ebd48a5cSAndre Przywara smp_wmb(); /* Paired with rmb in main(). */
421ebd48a5cSAndre Przywara cpumask_set_cpu(smp_processor_id(), &ready);
422ebd48a5cSAndre Przywara report_info("CPU%3d: MPIDR=%010" PRIx64, cpu, mpidr);
4230415feeaSAndrew Jones }
4240415feeaSAndrew Jones
main(int argc,char ** argv)4255e61cba0SAndrew Jones int main(int argc, char **argv)
4265e61cba0SAndrew Jones {
427a8568128SAndrew Jones report_prefix_push("selftest");
428e7c68b43SAndrew Jones
4296ffea954SAndrew Jones if (argc < 2)
430e7c68b43SAndrew Jones report_abort("no test specified");
431e7c68b43SAndrew Jones
4326ffea954SAndrew Jones report_prefix_push(argv[1]);
4335e61cba0SAndrew Jones
4346ffea954SAndrew Jones if (strcmp(argv[1], "setup") == 0) {
4352edfe428SAndrew Jones
4366ffea954SAndrew Jones check_setup(argc-2, &argv[2]);
4375e61cba0SAndrew Jones
4386ffea954SAndrew Jones } else if (strcmp(argv[1], "vectors-kernel") == 0) {
4392edfe428SAndrew Jones
4402edfe428SAndrew Jones check_vectors(NULL);
4412edfe428SAndrew Jones
4426ffea954SAndrew Jones } else if (strcmp(argv[1], "vectors-user") == 0) {
4432edfe428SAndrew Jones
4441693644dSAndrew Jones start_usr(check_vectors, NULL,
445632f935cSAndrew Jones (unsigned long)thread_stack_alloc());
4460415feeaSAndrew Jones
4476ffea954SAndrew Jones } else if (strcmp(argv[1], "smp") == 0) {
4480415feeaSAndrew Jones
449bd5bd157SAndrew Jones psci_print();
45000b34f56SAndrew Jones on_cpus(cpu_report, NULL);
451ebd48a5cSAndre Przywara while (!cpumask_full(&ready))
452ebd48a5cSAndre Przywara cpu_relax();
453ebd48a5cSAndre Przywara smp_rmb(); /* Paired with wmb in cpu_report(). */
454a299895bSThomas Huth report(cpumask_full(&valid), "MPIDR test on all CPUs");
455ebd48a5cSAndre Przywara report_info("%d CPUs reported back", nr_cpus);
4560415feeaSAndrew Jones
457b5a91881SChristopher Covington } else {
458b5a91881SChristopher Covington printf("Unknown subtest\n");
459b5a91881SChristopher Covington abort();
4602edfe428SAndrew Jones }
4612edfe428SAndrew Jones
4625e61cba0SAndrew Jones return report_summary();
4635e61cba0SAndrew Jones }
464