xref: /kvm-unit-tests/arm/selftest.c (revision 201b9e8bdc84c6436dd53b45d93a60c681b92719)
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