/* *  arch/xtensa/lib/usercopy.S * *  Copy to/from user space (derived from arch/xtensa/lib/hal/memcopy.S) * *  DO NOT COMBINE this function with <arch/xtensa/lib/hal/memcopy.S>. *  It needs to remain separate and distinct.  The hal files are part *  of the Xtensa link-time HAL, and those files may differ per *  processor configuration.  Patching the kernel for another *  processor configuration includes replacing the hal files, and we *  could lose the special functionality for accessing user-space *  memory during such a patch.  We sacrifice a little code space here *  in favor to simplify code maintenance. * *  This file is subject to the terms and conditions of the GNU General *  Public License.  See the file "COPYING" in the main directory of *  this archive for more details. * *  Copyright (C) 2002 Tensilica Inc. */  /* * size_t __xtensa_copy_user (void *dst, const void *src, size_t len); * * The returned value is the number of bytes not copied.  Implies zero * is success. * * The general case algorithm is as follows: *   If the destination and source are both aligned, *     do 16B chunks with a loop, and then finish up with *     8B, 4B, 2B, and 1B copies conditional on the length. *   If destination is aligned and source unaligned, *     do the same, but use SRC to align the source data. *   If destination is unaligned, align it by conditionally *     copying 1B and 2B and then retest. *   This code tries to use fall-through braches for the common *     case of aligned destinations (except for the branches to *     the alignment label). * * Register use: *	a0/ return address *	a1/ stack pointer *	a2/ return value *	a3/ src *	a4/ length *	a5/ dst *	a6/ tmp *	a7/ tmp *	a8/ tmp *	a9/ tmp *	a10/ tmp *	a11/ original length */ #include <linux/linkage.h>#include <asm/asmmacro.h>#include <asm/core.h> 	.textENTRY(__xtensa_copy_user) #if !XCHAL_HAVE_LOOPS && defined(__XTENSA_CALL0_ABI__)#define STACK_SIZE 4#else#define STACK_SIZE 0#endif	abi_entry(STACK_SIZE)	# a2/ dst, a3/ src, a4/ len	mov	a5, a2		# copy dst so that a2 is return value	mov	a11, a4		# preserve original len for error case.Lcommon:	bbsi.l	a2, 0, .Ldst1mod2 # if dst is 1 mod 2	bbsi.l	a2, 1, .Ldst2mod4 # if dst is 2 mod 4.Ldstaligned:	# return here from .Ldstunaligned when dst is aligned	srli	a7, a4, 4	# number of loop iterations with 16B				# per iteration	movi	a8, 3		  # if source is also aligned,	bnone	a3, a8, .Laligned # then use word copy	__ssa8	a3		# set shift amount from byte offset	bnez	a4, .Lsrcunaligned	movi	a2, 0		# return success for len==0	abi_ret(STACK_SIZE) /* * Destination is unaligned */ .Ldst1mod2:	# dst is only byte aligned	bltui	a4, 7, .Lbytecopy	# do short copies byte by byte 	# copy 1 byteEX(10f)	l8ui	a6, a3, 0	addi	a3, a3,  1EX(10f)	s8i	a6, a5,  0	addi	a5, a5,  1	addi	a4, a4, -1	bbci.l	a5, 1, .Ldstaligned	# if dst is now aligned, then					# return to main algorithm.Ldst2mod4:	# dst 16-bit aligned	# copy 2 bytes	bltui	a4, 6, .Lbytecopy	# do short copies byte by byteEX(10f)	l8ui	a6, a3, 0EX(10f)	l8ui	a7, a3, 1	addi	a3, a3,  2EX(10f)	s8i	a6, a5,  0EX(10f)	s8i	a7, a5,  1	addi	a5, a5,  2	addi	a4, a4, -2	j	.Ldstaligned	# dst is now aligned, return to main algorithm /* * Byte by byte copy */	.align	4	.byte	0		# 1 mod 4 alignment for LOOPNEZ				# (0 mod 4 alignment for LBEG).Lbytecopy:#if XCHAL_HAVE_LOOPS	loopnez	a4, .Lbytecopydone#else /* !XCHAL_HAVE_LOOPS */	beqz	a4, .Lbytecopydone	add	a7, a3, a4	# a7 = end address for source#endif /* !XCHAL_HAVE_LOOPS */.Lnextbyte:EX(10f)	l8ui	a6, a3, 0	addi	a3, a3, 1EX(10f)	s8i	a6, a5, 0	addi	a5, a5, 1#if !XCHAL_HAVE_LOOPS	blt	a3, a7, .Lnextbyte#endif /* !XCHAL_HAVE_LOOPS */.Lbytecopydone:	movi	a2, 0		# return success for len bytes copied	abi_ret(STACK_SIZE) /* * Destination and source are word-aligned. */	# copy 16 bytes per iteration for word-aligned dst and word-aligned src	.align	4		# 1 mod 4 alignment for LOOPNEZ	.byte	0		# (0 mod 4 alignment for LBEG).Laligned:#if XCHAL_HAVE_LOOPS	loopnez	a7, .Loop1done#else /* !XCHAL_HAVE_LOOPS */	beqz	a7, .Loop1done	slli	a8, a7, 4	add	a8, a8, a3	# a8 = end of last 16B source chunk#endif /* !XCHAL_HAVE_LOOPS */.Loop1:EX(10f)	l32i	a6, a3,  0EX(10f)	l32i	a7, a3,  4EX(10f)	s32i	a6, a5,  0EX(10f)	l32i	a6, a3,  8EX(10f)	s32i	a7, a5,  4EX(10f)	l32i	a7, a3, 12EX(10f)	s32i	a6, a5,  8	addi	a3, a3, 16EX(10f)	s32i	a7, a5, 12	addi	a5, a5, 16#if !XCHAL_HAVE_LOOPS	blt	a3, a8, .Loop1#endif /* !XCHAL_HAVE_LOOPS */.Loop1done:	bbci.l	a4, 3, .L2	# copy 8 bytesEX(10f)	l32i	a6, a3,  0EX(10f)	l32i	a7, a3,  4	addi	a3, a3,  8EX(10f)	s32i	a6, a5,  0EX(10f)	s32i	a7, a5,  4	addi	a5, a5,  8.L2:	bbci.l	a4, 2, .L3	# copy 4 bytesEX(10f)	l32i	a6, a3,  0	addi	a3, a3,  4EX(10f)	s32i	a6, a5,  0	addi	a5, a5,  4.L3:	bbci.l	a4, 1, .L4	# copy 2 bytesEX(10f)	l16ui	a6, a3,  0	addi	a3, a3,  2EX(10f)	s16i	a6, a5,  0	addi	a5, a5,  2.L4:	bbci.l	a4, 0, .L5	# copy 1 byteEX(10f)	l8ui	a6, a3,  0EX(10f)	s8i	a6, a5,  0.L5:	movi	a2, 0		# return success for len bytes copied	abi_ret(STACK_SIZE) /* * Destination is aligned, Source is unaligned */ 	.align	4	.byte	0		# 1 mod 4 alignement for LOOPNEZ				# (0 mod 4 alignment for LBEG).Lsrcunaligned:	# copy 16 bytes per iteration for word-aligned dst and unaligned src	and	a10, a3, a8	# save unalignment offset for below	sub	a3, a3, a10	# align a3 (to avoid sim warnings only; not needed for hardware)EX(10f)	l32i	a6, a3, 0	# load first word#if XCHAL_HAVE_LOOPS	loopnez	a7, .Loop2done#else /* !XCHAL_HAVE_LOOPS */	beqz	a7, .Loop2done#if defined(__XTENSA_CALL0_ABI__)	s32i	a10, a1, 0	slli	a10, a7, 4	add	a10, a10, a3	# a10 = end of last 16B source chunk#else	slli	a12, a7, 4	add	a12, a12, a3	# a12 = end of last 16B source chunk#endif#endif /* !XCHAL_HAVE_LOOPS */.Loop2:EX(10f)	l32i	a7, a3,  4EX(10f)	l32i	a8, a3,  8	__src_b	a6, a6, a7EX(10f)	s32i	a6, a5,  0EX(10f)	l32i	a9, a3, 12	__src_b	a7, a7, a8EX(10f)	s32i	a7, a5,  4EX(10f)	l32i	a6, a3, 16	__src_b	a8, a8, a9EX(10f)	s32i	a8, a5,  8	addi	a3, a3, 16	__src_b	a9, a9, a6EX(10f)	s32i	a9, a5, 12	addi	a5, a5, 16#if !XCHAL_HAVE_LOOPS#if defined(__XTENSA_CALL0_ABI__)	blt	a3, a10, .Loop2	l32i	a10, a1, 0#else	blt	a3, a12, .Loop2#endif#endif /* !XCHAL_HAVE_LOOPS */.Loop2done:	bbci.l	a4, 3, .L12	# copy 8 bytesEX(10f)	l32i	a7, a3,  4EX(10f)	l32i	a8, a3,  8	__src_b	a6, a6, a7EX(10f)	s32i	a6, a5,  0	addi	a3, a3,  8	__src_b	a7, a7, a8EX(10f)	s32i	a7, a5,  4	addi	a5, a5,  8	mov	a6, a8.L12:	bbci.l	a4, 2, .L13	# copy 4 bytesEX(10f)	l32i	a7, a3,  4	addi	a3, a3,  4	__src_b	a6, a6, a7EX(10f)	s32i	a6, a5,  0	addi	a5, a5,  4	mov	a6, a7.L13:	add	a3, a3, a10	# readjust a3 with correct misalignment	bbci.l	a4, 1, .L14	# copy 2 bytesEX(10f)	l8ui	a6, a3,  0EX(10f)	l8ui	a7, a3,  1	addi	a3, a3,  2EX(10f)	s8i	a6, a5,  0EX(10f)	s8i	a7, a5,  1	addi	a5, a5,  2.L14:	bbci.l	a4, 0, .L15	# copy 1 byteEX(10f)	l8ui	a6, a3,  0EX(10f)	s8i	a6, a5,  0.L15:	movi	a2, 0		# return success for len bytes copied	abi_ret(STACK_SIZE) ENDPROC(__xtensa_copy_user)EXPORT_SYMBOL(__xtensa_copy_user) 	.section .fixup, "ax"	.align	4 /* a2 = original dst; a5 = current dst; a11= original len * bytes_copied = a5 - a2 * retval = bytes_not_copied = original len - bytes_copied * retval = a11 - (a5 - a2) */  10:	sub	a2, a5, a2	/* a2 <-- bytes copied */	sub	a2, a11, a2	/* a2 <-- bytes not copied */	abi_ret(STACK_SIZE)