arch/score/lib/checksum.S

/*
 * arch/score/lib/csum_partial.S
 *
 * Score Processor version.
 *
 * Copyright (C) 2009 Sunplus Core Technology Co., Ltd.
 *  Lennox Wu <lennox.wu@sunplusct.com>
 *  Chen Liqin <liqin.chen@sunplusct.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see the file COPYING, or write
 * to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include <linux/linkage.h>

#define ADDC(sum,reg)			\
	add	sum, sum, reg;		\
	cmp.c	reg, sum;		\
	bleu	9f;			\
	addi	sum, 0x1;		\
9:

#define CSUM_BIGCHUNK(src, offset, sum)		\
	lw	r8, [src, offset + 0x00];	\
	lw	r9, [src, offset + 0x04];	\
	lw	r10, [src, offset + 0x08];	\
	lw	r11, [src, offset + 0x0c];	\
	ADDC(sum, r8);				\
	ADDC(sum, r9);				\
	ADDC(sum, r10);				\
	ADDC(sum, r11);				\
	lw	r8, [src, offset + 0x10];	\
	lw	r9, [src, offset + 0x14];	\
	lw	r10, [src, offset + 0x18]; 	\
	lw	r11, [src, offset + 0x1c]; 	\
	ADDC(sum, r8);				\
	ADDC(sum, r9);				\
	ADDC(sum, r10);				\
	ADDC(sum, r11);				\

#define src r4
#define dest r5
#define sum r27

	.text
/* unknown src alignment and < 8 bytes to go */
small_csumcpy:
	mv	r5, r10
	ldi	r9, 0x0
	cmpi.c	r25, 0x1
	beq pass_small_set_t7	/*already set, jump to pass_small_set_t7*/
	andri.c	r25,r4 , 0x1	/*Is src 2 bytes aligned?*/

pass_small_set_t7:
	beq	aligned
	cmpi.c	r5, 0x0
	beq	fold
	lbu	r9, [src]
	slli	r9,r9, 0x8	/*Little endian*/
	ADDC(sum, r9)
	addi	src, 0x1
	subi.c	r5, 0x1

	/*len still a full word */
aligned:
	andri.c r8, r5, 0x4	/*Len >= 4?*/
	beq	len_less_4bytes

	/* Still a full word (4byte) to go,and the src is word aligned.*/
	andri.c	r8, src, 0x3	/*src is 4bytes aligned, so use LW!!*/
	beq	four_byte_aligned
	lhu 	r9, [src]
	addi	src, 2
	ADDC(sum, r9)
	lhu 	r9, [src]
	addi	src, 2
	ADDC(sum, r9)
	b len_less_4bytes

four_byte_aligned:		/* Len >=4 and four byte aligned */
	lw	r9, [src]
	addi	src, 4
	ADDC(sum, r9)

len_less_4bytes:		/* 2 byte aligned aligned and length<4B */
	andri.c r8, r5, 0x2
	beq	len_less_2bytes
	lhu	r9, [src]
	addi	src, 0x2	/* src+=2 */
	ADDC(sum, r9)

len_less_2bytes:		/* len = 1 */
	andri.c r8, r5, 0x1
	beq 	fold		/* less than 2 and not equal 1--> len=0 -> fold */
	lbu	r9, [src]

fold_ADDC:
	ADDC(sum, r9)
fold:
	/* fold checksum */
	slli	r26, sum, 16
	add	sum, sum, r26
	cmp.c	r26, sum
	srli	sum, sum, 16
	bleu 	1f 		/* if r26<=sum */
	addi	sum, 0x1 	/* r26>sum */
1:
	/* odd buffer alignment? r25 was set in csum_partial */
	cmpi.c	r25, 0x0
	beq	1f
	slli	r26, sum, 8
	srli	sum, sum, 8
	or	sum, sum, r26
	andi	sum, 0xffff
1:
	.set	optimize
	/* Add the passed partial csum. */
	ADDC(sum, r6)
	mv	r4, sum
	br	r3
	.set	volatile

	.align	5
ENTRY(csum_partial)
	ldi sum, 0
	ldi r25, 0
	mv r10, r5
	cmpi.c	r5, 0x8
	blt	small_csumcpy		/* < 8(signed) bytes to copy */
	cmpi.c	r5, 0x0
	beq	out
	andri.c	r25, src, 0x1		/* odd buffer? */

	beq	word_align
hword_align:				/* 1 byte */
	lbu	r8, [src]
	subi	r5, 0x1
	slli	r8, r8, 8
	ADDC(sum, r8)
	addi	src, 0x1

word_align:				/* 2 bytes */
	andri.c r8, src, 0x2		/* 4bytes(dword)_aligned? */
	beq	dword_align		/* not, maybe dword_align */
	lhu	r8, [src]
	subi	r5, 0x2
	ADDC(sum, r8)
	addi	src, 0x2

dword_align:				/* 4bytes */
	mv 	r26, r5			/* maybe useless when len >=56 */
	ldi 	r8, 56
	cmp.c	r8, r5
	bgtu	do_end_words		/* if a1(len)<t0(56) ,unsigned */
	andri.c	r26, src, 0x4
	beq	qword_align
	lw	r8, [src]
	subi	r5, 0x4
	ADDC(sum, r8)
	addi	src, 0x4

qword_align:				/* 8 bytes */
	andri.c r26, src, 0x8
	beq	oword_align
	lw	r8, [src, 0x0]
	lw	r9, [src, 0x4]
	subi	r5, 0x8			/* len-=0x8 */
	ADDC(sum, r8)
	ADDC(sum, r9)
	addi	src, 0x8

oword_align:				/* 16bytes */
	andri.c	r26, src, 0x10
	beq	begin_movement
	lw	r10, [src, 0x08]
	lw	r11, [src, 0x0c]
	lw	r8, [src, 0x00]
	lw	r9, [src, 0x04]
	ADDC(sum, r10)
	ADDC(sum, r11)
	ADDC(sum, r8)
	ADDC(sum, r9)
	subi	r5, 0x10
	addi	src, 0x10

begin_movement:
	srli.c	r26, r5, 0x7		/* len>=128? */
	beq	1f			/* len<128 */

/* r26 is the result that computed in oword_align */
move_128bytes:
	CSUM_BIGCHUNK(src, 0x00, sum)
	CSUM_BIGCHUNK(src, 0x20, sum)
	CSUM_BIGCHUNK(src, 0x40, sum)
	CSUM_BIGCHUNK(src, 0x60, sum)
	subi.c	r26, 0x01		/* r26 equals len/128 */
	addi	src, 0x80
	bne	move_128bytes

1:	/* len<128,we process 64byte here */
	andri.c	r10, r5, 0x40
	beq	1f

move_64bytes:
	CSUM_BIGCHUNK(src, 0x00, sum)
	CSUM_BIGCHUNK(src, 0x20, sum)
	addi	src, 0x40

1:					/* len<64 */
	andri	r26, r5, 0x1c		/* 0x1c=28 */
	andri.c	r10, r5, 0x20
	beq	do_end_words		/* decided by andri */

move_32bytes:
	CSUM_BIGCHUNK(src, 0x00, sum)
	andri	r26, r5, 0x1c
	addri	src, src, 0x20

do_end_words:				/* len<32 */
	/* r26 was set already in dword_align */
	cmpi.c	r26, 0x0
	beq	maybe_end_cruft		/* len<28 or len<56 */
	srli	r26, r26, 0x2

end_words:
	lw	r8, [src]
	subi.c	r26, 0x1		/* unit is 4 byte */
	ADDC(sum, r8)
	addi	src, 0x4
	cmpi.c	r26, 0x0
	bne	end_words		/* r26!=0 */

maybe_end_cruft:			/* len<4 */
	andri	r10, r5, 0x3

small_memcpy:
	mv	r5, r10
	j	small_csumcpy

out:
	mv	r4, sum
	br	r3

END(csum_partial)