/*

   * copy_page, __copy_user_page, __copy_user implementation of SuperH
   *
   * Copyright (C) 2001  Niibe Yutaka & Kaz Kojima
   * Copyright (C) 2002  Toshinobu Sugioka

   * Copyright (C) 2006  Paul Mundt

   */
  #include <linux/linkage.h>

  #include <asm/page.h>

  
  /*

   * copy_page

   * @to: P1 address
   * @from: P1 address
   *

   * void copy_page(void *to, void *from)

   */
  
  /*
   * r0, r1, r2, r3, r4, r5, r6, r7 --- scratch 

   * r8 --- from + PAGE_SIZE

   * r9 --- not used
   * r10 --- to
   * r11 --- from
   */

  ENTRY(copy_page)

  	mov.l	r8,@-r15
  	mov.l	r10,@-r15
  	mov.l	r11,@-r15
  	mov	r4,r10
  	mov	r5,r11
  	mov	r5,r8

  	mov	#(PAGE_SIZE >> 10), r0
  	shll8	r0
  	shll2	r0

  	add	r0,r8
  	!
  1:	mov.l	@r11+,r0
  	mov.l	@r11+,r1
  	mov.l	@r11+,r2
  	mov.l	@r11+,r3
  	mov.l	@r11+,r4
  	mov.l	@r11+,r5
  	mov.l	@r11+,r6
  	mov.l	@r11+,r7

  #if defined(CONFIG_CPU_SH4)

  	movca.l	r0,@r10

  #else
  	mov.l	r0,@r10

  #endif
  	add	#32,r10
  	mov.l	r7,@-r10
  	mov.l	r6,@-r10
  	mov.l	r5,@-r10
  	mov.l	r4,@-r10
  	mov.l	r3,@-r10
  	mov.l	r2,@-r10
  	mov.l	r1,@-r10

  	cmp/eq	r11,r8
  	bf/s	1b
  	 add	#28,r10
  	!
  	mov.l	@r15+,r11
  	mov.l	@r15+,r10
  	mov.l	@r15+,r8
  	rts
  	 nop

  /*
   * __kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);
   * Return the number of bytes NOT copied
   */
  #define EX(...)			\
  	9999: __VA_ARGS__ ;		\
  	.section __ex_table, "a";	\
  	.long 9999b, 6000f	;	\
  	.previous

  #define EX_NO_POP(...)			\
  	9999: __VA_ARGS__ ;		\
  	.section __ex_table, "a";	\
  	.long 9999b, 6005f	;	\
  	.previous

  ENTRY(__copy_user)

  	! Check if small number of bytes
  	mov	#11,r0

  	mov	r4,r3

  	cmp/gt	r0,r6		! r6 (len) > r0 (11)
  	bf/s	.L_cleanup_loop_no_pop
  	 add	r6,r3		! last destination address
  
  	! Calculate bytes needed to align to src
  	mov.l	r11,@-r15
  	neg	r5,r0
  	mov.l	r10,@-r15

  	add	#4,r0

  	mov.l	r9,@-r15

  	and	#3,r0

  	mov.l	r8,@-r15

  	tst	r0,r0

  	bt	2f

  1:
  	! Copy bytes to long word align src
  EX(	mov.b	@r5+,r1		)
  	dt	r0

  	add	#-1,r6

  EX(	mov.b	r1,@r4		)
  	bf/s	1b

  	 add	#1,r4

  	! Jump to appropriate routine depending on dest
  2:	mov	#3,r1
  	mov	r6, r2
  	and	r4,r1

  	shlr2	r2

  	shll2	r1
  	mova	.L_jump_tbl,r0
  	mov.l	@(r0,r1),r1
  	jmp	@r1
  	 nop
  
  	.align 2
  .L_jump_tbl:
  	.long	.L_dest00
  	.long	.L_dest01
  	.long	.L_dest10
  	.long	.L_dest11

  /*
   * Come here if there are less than 12 bytes to copy
   *
   * Keep the branch target close, so the bf/s callee doesn't overflow
   * and result in a more expensive branch being inserted. This is the
   * fast-path for small copies, the jump via the jump table will hit the
   * default slow-path cleanup. -PFM.
   */
  .L_cleanup_loop_no_pop:
  	tst	r6,r6		! Check explicitly for zero
  	bt	1f
  
  2:

  EX_NO_POP(	mov.b	@r5+,r0		)

  	dt	r6

  EX_NO_POP(	mov.b	r0,@r4		)

  	bf/s	2b
  	 add	#1,r4
  
  1:	mov	#0,r0		! normal return
  5000:
  
  # Exception handler:
  .section .fixup, "ax"

  6005:

  	mov.l	8000f,r1
  	mov	r3,r0
  	jmp	@r1
  	 sub	r4,r0
  	.align	2
  8000:	.long	5000b
  
  .previous
  	rts
  	 nop

  ! Destination = 00
  
  .L_dest00:

  	! Skip the large copy for small transfers
  	mov	#(32+32-4), r0
  	cmp/gt	r6, r0		! r0 (60) > r6 (len)
  	bt	1f
  
  	! Align dest to a 32 byte boundary
  	neg	r4,r0
  	add	#0x20, r0
  	and	#0x1f, r0
  	tst	r0, r0
  	bt	2f
  
  	sub	r0, r6
  	shlr2	r0
  3:
  EX(	mov.l	@r5+,r1		)
  	dt	r0
  EX(	mov.l	r1,@r4		)
  	bf/s	3b
  	 add	#4,r4

  2:
  EX(	mov.l	@r5+,r0		)

  EX(	mov.l	@r5+,r1		)
  EX(	mov.l	@r5+,r2		)
  EX(	mov.l	@r5+,r7		)

  EX(	mov.l	@r5+,r8		)
  EX(	mov.l	@r5+,r9		)
  EX(	mov.l	@r5+,r10	)

  EX(	mov.l	@r5+,r11	)

  #ifdef CONFIG_CPU_SH4

  EX(	movca.l	r0,@r4		)

  #else
  EX(	mov.l	r0,@r4		)
  #endif

  	add	#-32, r6
  EX(	mov.l	r1,@(4,r4)	)
  	mov	#32, r0
  EX(	mov.l	r2,@(8,r4)	)
  	cmp/gt	r6, r0		! r0 (32) > r6 (len)
  EX(	mov.l	r7,@(12,r4)	)
  EX(	mov.l	r8,@(16,r4)	)
  EX(	mov.l	r9,@(20,r4)	)
  EX(	mov.l	r10,@(24,r4)	)
  EX(	mov.l	r11,@(28,r4)	)

  	bf/s	2b
  	 add	#32,r4

  
  1:	mov	r6, r0
  	shlr2	r0
  	tst	r0, r0

  	bt	.L_cleanup
  1:

  EX(	mov.l	@r5+,r1		)
  	dt	r0
  EX(	mov.l	r1,@r4		)

  	bf/s	1b
  	 add	#4,r4
  
  	bra	.L_cleanup
  	 nop
  
  ! Destination = 10
  
  .L_dest10:
  	mov	r2,r7
  	shlr2	r7
  	shlr	r7
  	tst	r7,r7
  	mov	#7,r0
  	bt/s	1f
  	 and	r0,r2
  2:
  	dt	r7

  #ifdef CONFIG_CPU_LITTLE_ENDIAN

  EX(	mov.l	@r5+,r0		)
  EX(	mov.l	@r5+,r1		)
  EX(	mov.l	@r5+,r8		)
  EX(	mov.l	@r5+,r9		)
  EX(	mov.l	@r5+,r10	)
  EX(	mov.w	r0,@r4		)
  	add	#2,r4
  	xtrct	r1,r0
  	xtrct	r8,r1
  	xtrct	r9,r8
  	xtrct	r10,r9
  
  EX(	mov.l	r0,@r4		)
  EX(	mov.l	r1,@(4,r4)	)
  EX(	mov.l	r8,@(8,r4)	)
  EX(	mov.l	r9,@(12,r4)	)
  
  EX(	mov.l	@r5+,r1		)
  EX(	mov.l	@r5+,r8		)
  EX(	mov.l	@r5+,r0		)
  	xtrct	r1,r10
  	xtrct	r8,r1
  	xtrct	r0,r8
  	shlr16	r0
  EX(	mov.l	r10,@(16,r4)	)
  EX(	mov.l	r1,@(20,r4)	)
  EX(	mov.l	r8,@(24,r4)	)
  EX(	mov.w	r0,@(28,r4)	)
  	bf/s	2b
  	 add	#30,r4
  #else
  EX(	mov.l	@(28,r5),r0	)
  EX(	mov.l	@(24,r5),r8	)
  EX(	mov.l	@(20,r5),r9	)
  EX(	mov.l	@(16,r5),r10	)
  EX(	mov.w	r0,@(30,r4)	)
  	add	#-2,r4
  	xtrct	r8,r0
  	xtrct	r9,r8
  	xtrct	r10,r9
  EX(	mov.l	r0,@(28,r4)	)
  EX(	mov.l	r8,@(24,r4)	)
  EX(	mov.l	r9,@(20,r4)	)
  
  EX(	mov.l	@(12,r5),r0	)
  EX(	mov.l	@(8,r5),r8	)
  	xtrct	r0,r10
  EX(	mov.l	@(4,r5),r9	)
  	mov.l	r10,@(16,r4)
  EX(	mov.l	@r5,r10		)
  	xtrct	r8,r0
  	xtrct	r9,r8
  	xtrct	r10,r9
  EX(	mov.l	r0,@(12,r4)	)
  EX(	mov.l	r8,@(8,r4)	)
  	swap.w	r10,r0
  EX(	mov.l	r9,@(4,r4)	)
  EX(	mov.w	r0,@(2,r4)	)
  
  	add	#32,r5
  	bf/s	2b
  	 add	#34,r4
  #endif
  	tst	r2,r2
  	bt	.L_cleanup
  
  1:	! Read longword, write two words per iteration
  EX(	mov.l	@r5+,r0		)
  	dt	r2

  #ifdef CONFIG_CPU_LITTLE_ENDIAN

  EX(	mov.w	r0,@r4		)
  	shlr16	r0
  EX(	mov.w 	r0,@(2,r4)	)
  #else
  EX(	mov.w	r0,@(2,r4)	)
  	shlr16	r0
  EX(	mov.w	r0,@r4		)
  #endif
  	bf/s	1b
  	 add	#4,r4
  
  	bra	.L_cleanup
  	 nop
  
  ! Destination = 01 or 11
  
  .L_dest01:
  .L_dest11:
  	! Read longword, write byte, word, byte per iteration
  EX(	mov.l	@r5+,r0		)
  	dt	r2

  #ifdef CONFIG_CPU_LITTLE_ENDIAN

  EX(	mov.b	r0,@r4		)
  	shlr8	r0
  	add	#1,r4
  EX(	mov.w	r0,@r4		)
  	shlr16	r0
  EX(	mov.b	r0,@(2,r4)	)
  	bf/s	.L_dest01
  	 add	#3,r4
  #else
  EX(	mov.b	r0,@(3,r4)	)
  	shlr8	r0
  	swap.w	r0,r7
  EX(	mov.b	r7,@r4		)
  	add	#1,r4
  EX(	mov.w	r0,@r4		)
  	bf/s	.L_dest01
  	 add	#3,r4
  #endif
  
  ! Cleanup last few bytes
  .L_cleanup:
  	mov	r6,r0
  	and	#3,r0
  	tst	r0,r0
  	bt	.L_exit
  	mov	r0,r6
  
  .L_cleanup_loop:
  EX(	mov.b	@r5+,r0		)
  	dt	r6
  EX(	mov.b	r0,@r4		)
  	bf/s	.L_cleanup_loop
  	 add	#1,r4
  
  .L_exit:
  	mov	#0,r0		! normal return

  5000:
  
  # Exception handler:
  .section .fixup, "ax"
  6000:
  	mov.l	8000f,r1
  	mov	r3,r0
  	jmp	@r1
  	 sub	r4,r0
  	.align	2
  8000:	.long	5000b
  
  .previous
  	mov.l	@r15+,r8
  	mov.l	@r15+,r9

  	mov.l	@r15+,r10

  	rts

  	 mov.l	@r15+,r11