Merge tag 'arm64-upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux

#endif

	.endm

	/*

	 * frame_push - Push @regcount callee saved registers to the stack,

	 *              starting at x19, as well as x29/x30, and set x29 to

	 *              the new value of sp. Add @extra bytes of stack space

	 *              for locals.

	 */

	.macro		frame_push, regcount:req, extra

	__frame		st, \regcount, \extra

	.endm

	/*

	 * frame_pop  - Pop the callee saved registers from the stack that were

	 *              pushed in the most recent call to frame_push, as well

	 *              as x29/x30 and any extra stack space that may have been

	 *              allocated.

	 */

	.macro		frame_pop

	__frame		ld

	.endm

	.macro		__frame_regs, reg1, reg2, op, num

	.if		.Lframe_regcount == \num

	\op\()r		\reg1, [sp, #(\num + 1) * 8]

	.elseif		.Lframe_regcount > \num

	\op\()p		\reg1, \reg2, [sp, #(\num + 1) * 8]

	.endif

	.endm

	.macro		__frame, op, regcount, extra=0

	.ifc		\op, st

	.if		(\regcount) < 0 || (\regcount) > 10

	.error		"regcount should be in the range [0 ... 10]"

	.endif

	.if		((\extra) % 16) != 0

	.error		"extra should be a multiple of 16 bytes"

	.endif

	.ifdef		.Lframe_regcount

	.if		.Lframe_regcount != -1

	.error		"frame_push/frame_pop may not be nested"

	.endif

	.endif

	.set		.Lframe_regcount, \regcount

	.set		.Lframe_extra, \extra

	.set		.Lframe_local_offset, ((\regcount + 3) / 2) * 16

	stp		x29, x30, [sp, #-.Lframe_local_offset - .Lframe_extra]!

	mov		x29, sp

	.endif

	__frame_regs	x19, x20, \op, 1

	__frame_regs	x21, x22, \op, 3

	__frame_regs	x23, x24, \op, 5

	__frame_regs	x25, x26, \op, 7

	__frame_regs	x27, x28, \op, 9

	.ifc		\op, ld

	.if		.Lframe_regcount == -1

	.error		"frame_push/frame_pop may not be nested"

	.endif

	ldp		x29, x30, [sp], #.Lframe_local_offset + .Lframe_extra

	.set		.Lframe_regcount, -1

	.endif

	.endm

/*

 * Check whether to yield to another runnable task from kernel mode NEON code

 * (which runs with preemption disabled).

 *

 * if_will_cond_yield_neon

 *        // pre-yield patchup code

 * do_cond_yield_neon

 *        // post-yield patchup code

 * endif_yield_neon    <label>

 *

 * where <label> is optional, and marks the point where execution will resume

 * after a yield has been performed. If omitted, execution resumes right after

 * the endif_yield_neon invocation. Note that the entire sequence, including

 * the provided patchup code, will be omitted from the image if CONFIG_PREEMPT

 * is not defined.

 *

 * As a convenience, in the case where no patchup code is required, the above

 * sequence may be abbreviated to

 *

 * cond_yield_neon <label>

 *

 * Note that the patchup code does not support assembler directives that change

 * the output section, any use of such directives is undefined.

 *

 * The yield itself consists of the following:

 * - Check whether the preempt count is exactly 1, in which case disabling

 *   preemption once will make the task preemptible. If this is not the case,

 *   yielding is pointless.

 * - Check whether TIF_NEED_RESCHED is set, and if so, disable and re-enable

 *   kernel mode NEON (which will trigger a reschedule), and branch to the

 *   yield fixup code.

 *

 * This macro sequence may clobber all CPU state that is not guaranteed by the

 * AAPCS to be preserved across an ordinary function call.

 */

	.macro		cond_yield_neon, lbl

	if_will_cond_yield_neon

	do_cond_yield_neon

	endif_yield_neon	\lbl

	.endm

	.macro		if_will_cond_yield_neon

#ifdef CONFIG_PREEMPT

	get_thread_info	x0

	ldr		w1, [x0, #TSK_TI_PREEMPT]

	ldr		x0, [x0, #TSK_TI_FLAGS]

	cmp		w1, #PREEMPT_DISABLE_OFFSET

	csel		x0, x0, xzr, eq

	tbnz		x0, #TIF_NEED_RESCHED, .Lyield_\@	// needs rescheduling?

	/* fall through to endif_yield_neon */

	.subsection	1

.Lyield_\@ :

#else

	.section	".discard.cond_yield_neon", "ax"

#endif

	.endm

	.macro		do_cond_yield_neon

	bl		kernel_neon_end

	bl		kernel_neon_begin

	.endm

	.macro		endif_yield_neon, lbl

	.ifnb		\lbl

	b		\lbl

	.else

	b		.Lyield_out_\@

	.endif

	.previous

.Lyield_out_\@ :

	.endm

#endif	/* __ASM_ASSEMBLER_H */

#define ARM64_SVE				22

#define ARM64_UNMAP_KERNEL_AT_EL0		23

#define ARM64_HARDEN_BRANCH_PREDICTOR		24

#define ARM64_HARDEN_BP_POST_GUEST_EXIT		25

#define ARM64_HAS_RAS_EXTN			26

#define ARM64_WORKAROUND_843419			27

#define ARM64_HAS_CACHE_IDC			28

#define ARM64_HAS_CACHE_DIC			29

#define ARM64_HW_DBM				30

#define ARM64_HAS_RAS_EXTN			25

#define ARM64_WORKAROUND_843419			26

#define ARM64_HAS_CACHE_IDC			27

#define ARM64_HAS_CACHE_DIC			28

#define ARM64_HW_DBM				29

#define ARM64_NCAPS				31

#define ARM64_NCAPS				30

#endif /* __ASM_CPUCAPS_H */

extern u32 __init_stage2_translation(void);

extern void __qcom_hyp_sanitize_btac_predictors(void);

#else /* __ASSEMBLY__ */

.macro get_host_ctxt reg, tmp

arm64-obj-$(CONFIG_CRASH_DUMP)		+= crash_dump.o

arm64-obj-$(CONFIG_ARM_SDE_INTERFACE)	+= sdei.o

arm64-obj-$(CONFIG_KVM_INDIRECT_VECTORS)+= bpi.o

obj-y					+= $(arm64-obj-y) vdso/ probes/

obj-m					+= $(arm64-obj-m)

head-y					:= head.o

#include <linux/mm.h>

#include <linux/dma-mapping.h>

#include <linux/kvm_host.h>

#include <linux/preempt.h>

#include <linux/suspend.h>

#include <asm/cpufeature.h>

#include <asm/fixmap.h>

  DEFINE(DMA_TO_DEVICE,		DMA_TO_DEVICE);

  DEFINE(DMA_FROM_DEVICE,	DMA_FROM_DEVICE);

  BLANK();

  DEFINE(PREEMPT_DISABLE_OFFSET, PREEMPT_DISABLE_OFFSET);

  BLANK();

  DEFINE(CLOCK_REALTIME,	CLOCK_REALTIME);

  DEFINE(CLOCK_MONOTONIC,	CLOCK_MONOTONIC);

  DEFINE(CLOCK_MONOTONIC_RAW,	CLOCK_MONOTONIC_RAW);