386 lines
6.8 KiB
ArmAsm
386 lines
6.8 KiB
ArmAsm
|
/* $Id: checksum.S,v 1.10 2001/07/06 13:11:32 gniibe Exp $
|
||
|
|
*
|
||
|
|
* INET An implementation of the TCP/IP protocol suite for the LINUX
|
||
|
|
* operating system. INET is implemented using the BSD Socket
|
||
|
|
* interface as the means of communication with the user level.
|
||
|
|
*
|
||
|
|
* IP/TCP/UDP checksumming routines
|
||
|
|
*
|
||
|
|
* Authors: Jorge Cwik, <jorge@laser.satlink.net>
|
||
|
|
* Arnt Gulbrandsen, <agulbra@nvg.unit.no>
|
||
|
|
* Tom May, <ftom@netcom.com>
|
||
|
|
* Pentium Pro/II routines:
|
||
|
|
* Alexander Kjeldaas <astor@guardian.no>
|
||
|
|
* Finn Arne Gangstad <finnag@guardian.no>
|
||
|
|
* Lots of code moved from tcp.c and ip.c; see those files
|
||
|
|
* for more names.
|
||
|
|
*
|
||
|
|
* Changes: Ingo Molnar, converted csum_partial_copy() to 2.1 exception
|
||
|
|
* handling.
|
||
|
|
* Andi Kleen, add zeroing on error
|
||
|
|
* converted to pure assembler
|
||
|
|
*
|
||
|
|
* SuperH version: Copyright (C) 1999 Niibe Yutaka
|
||
|
|
*
|
||
|
|
* 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.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <asm/errno.h>
|
||
|
|
#include <linux/linkage.h>
|
||
|
|
|
||
|
|
/*
|
||
|
|
* computes a partial checksum, e.g. for TCP/UDP fragments
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
* unsigned int csum_partial(const unsigned char *buf, int len,
|
||
|
|
* unsigned int sum);
|
||
|
|
*/
|
||
|
|
|
||
|
|
.text
|
||
|
|
ENTRY(csum_partial)
|
||
|
|
/*
|
||
|
|
* Experiments with Ethernet and SLIP connections show that buff
|
||
|
|
* is aligned on either a 2-byte or 4-byte boundary. We get at
|
||
|
|
* least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
|
||
|
|
* Fortunately, it is easy to convert 2-byte alignment to 4-byte
|
||
|
|
* alignment for the unrolled loop.
|
||
|
|
*/
|
||
|
|
mov r5, r1
|
||
|
|
mov r4, r0
|
||
|
|
tst #2, r0 ! Check alignment.
|
||
|
|
bt 2f ! Jump if alignment is ok.
|
||
|
|
!
|
||
|
|
add #-2, r5 ! Alignment uses up two bytes.
|
||
|
|
cmp/pz r5 !
|
||
|
|
bt/s 1f ! Jump if we had at least two bytes.
|
||
|
|
clrt
|
||
|
|
bra 6f
|
||
|
|
add #2, r5 ! r5 was < 2. Deal with it.
|
||
|
|
1:
|
||
|
|
mov r5, r1 ! Save new len for later use.
|
||
|
|
mov.w @r4+, r0
|
||
|
|
extu.w r0, r0
|
||
|
|
addc r0, r6
|
||
|
|
bf 2f
|
||
|
|
add #1, r6
|
||
|
|
2:
|
||
|
|
mov #-5, r0
|
||
|
|
shld r0, r5
|
||
|
|
tst r5, r5
|
||
|
|
bt/s 4f ! if it's =0, go to 4f
|
||
|
|
clrt
|
||
|
|
.align 2
|
||
|
|
3:
|
||
|
|
mov.l @r4+, r0
|
||
|
|
mov.l @r4+, r2
|
||
|
|
mov.l @r4+, r3
|
||
|
|
addc r0, r6
|
||
|
|
mov.l @r4+, r0
|
||
|
|
addc r2, r6
|
||
|
|
mov.l @r4+, r2
|
||
|
|
addc r3, r6
|
||
|
|
mov.l @r4+, r3
|
||
|
|
addc r0, r6
|
||
|
|
mov.l @r4+, r0
|
||
|
|
addc r2, r6
|
||
|
|
mov.l @r4+, r2
|
||
|
|
addc r3, r6
|
||
|
|
addc r0, r6
|
||
|
|
addc r2, r6
|
||
|
|
movt r0
|
||
|
|
dt r5
|
||
|
|
bf/s 3b
|
||
|
|
cmp/eq #1, r0
|
||
|
|
! here, we know r5==0
|
||
|
|
addc r5, r6 ! add carry to r6
|
||
|
|
4:
|
||
|
|
mov r1, r0
|
||
|
|
and #0x1c, r0
|
||
|
|
tst r0, r0
|
||
|
|
bt/s 6f
|
||
|
|
mov r0, r5
|
||
|
|
shlr2 r5
|
||
|
|
mov #0, r2
|
||
|
|
5:
|
||
|
|
addc r2, r6
|
||
|
|
mov.l @r4+, r2
|
||
|
|
movt r0
|
||
|
|
dt r5
|
||
|
|
bf/s 5b
|
||
|
|
cmp/eq #1, r0
|
||
|
|
addc r2, r6
|
||
|
|
addc r5, r6 ! r5==0 here, so it means add carry-bit
|
||
|
|
6:
|
||
|
|
mov r1, r5
|
||
|
|
mov #3, r0
|
||
|
|
and r0, r5
|
||
|
|
tst r5, r5
|
||
|
|
bt 9f ! if it's =0 go to 9f
|
||
|
|
mov #2, r1
|
||
|
|
cmp/hs r1, r5
|
||
|
|
bf 7f
|
||
|
|
mov.w @r4+, r0
|
||
|
|
extu.w r0, r0
|
||
|
|
cmp/eq r1, r5
|
||
|
|
bt/s 8f
|
||
|
|
clrt
|
||
|
|
shll16 r0
|
||
|
|
addc r0, r6
|
||
|
|
7:
|
||
|
|
mov.b @r4+, r0
|
||
|
|
extu.b r0, r0
|
||
|
|
#ifndef __LITTLE_ENDIAN__
|
||
|
|
shll8 r0
|
||
|
|
#endif
|
||
|
|
8:
|
||
|
|
addc r0, r6
|
||
|
|
mov #0, r0
|
||
|
|
addc r0, r6
|
||
|
|
9:
|
||
|
|
rts
|
||
|
|
mov r6, r0
|
||
|
|
|
||
|
|
/*
|
||
|
|
unsigned int csum_partial_copy_generic (const char *src, char *dst, int len,
|
||
|
|
int sum, int *src_err_ptr, int *dst_err_ptr)
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Copy from ds while checksumming, otherwise like csum_partial
|
||
|
|
*
|
||
|
|
* The macros SRC and DST specify the type of access for the instruction.
|
||
|
|
* thus we can call a custom exception handler for all access types.
|
||
|
|
*
|
||
|
|
* FIXME: could someone double-check whether I haven't mixed up some SRC and
|
||
|
|
* DST definitions? It's damn hard to trigger all cases. I hope I got
|
||
|
|
* them all but there's no guarantee.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define SRC(...) \
|
||
|
|
9999: __VA_ARGS__ ; \
|
||
|
|
.section __ex_table, "a"; \
|
||
|
|
.long 9999b, 6001f ; \
|
||
|
|
.previous
|
||
|
|
|
||
|
|
#define DST(...) \
|
||
|
|
9999: __VA_ARGS__ ; \
|
||
|
|
.section __ex_table, "a"; \
|
||
|
|
.long 9999b, 6002f ; \
|
||
|
|
.previous
|
||
|
|
|
||
|
|
!
|
||
|
|
! r4: const char *SRC
|
||
|
|
! r5: char *DST
|
||
|
|
! r6: int LEN
|
||
|
|
! r7: int SUM
|
||
|
|
!
|
||
|
|
! on stack:
|
||
|
|
! int *SRC_ERR_PTR
|
||
|
|
! int *DST_ERR_PTR
|
||
|
|
!
|
||
|
|
ENTRY(csum_partial_copy_generic)
|
||
|
|
mov.l r5,@-r15
|
||
|
|
mov.l r6,@-r15
|
||
|
|
|
||
|
|
mov #3,r0 ! Check src and dest are equally aligned
|
||
|
|
mov r4,r1
|
||
|
|
and r0,r1
|
||
|
|
and r5,r0
|
||
|
|
cmp/eq r1,r0
|
||
|
|
bf 3f ! Different alignments, use slow version
|
||
|
|
tst #1,r0 ! Check dest word aligned
|
||
|
|
bf 3f ! If not, do it the slow way
|
||
|
|
|
||
|
|
mov #2,r0
|
||
|
|
tst r0,r5 ! Check dest alignment.
|
||
|
|
bt 2f ! Jump if alignment is ok.
|
||
|
|
add #-2,r6 ! Alignment uses up two bytes.
|
||
|
|
cmp/pz r6 ! Jump if we had at least two bytes.
|
||
|
|
bt/s 1f
|
||
|
|
clrt
|
||
|
|
bra 4f
|
||
|
|
add #2,r6 ! r6 was < 2. Deal with it.
|
||
|
|
|
||
|
|
3: ! Handle different src and dest alignments.
|
||
|
|
! This is not common, so simple byte by byte copy will do.
|
||
|
|
mov r6,r2
|
||
|
|
shlr r6
|
||
|
|
tst r6,r6
|
||
|
|
bt 4f
|
||
|
|
clrt
|
||
|
|
.align 2
|
||
|
|
5:
|
||
|
|
SRC( mov.b @r4+,r1 )
|
||
|
|
SRC( mov.b @r4+,r0 )
|
||
|
|
extu.b r1,r1
|
||
|
|
DST( mov.b r1,@r5 )
|
||
|
|
DST( mov.b r0,@(1,r5) )
|
||
|
|
extu.b r0,r0
|
||
|
|
add #2,r5
|
||
|
|
|
||
|
|
#ifdef __LITTLE_ENDIAN__
|
||
|
|
shll8 r0
|
||
|
|
#else
|
||
|
|
shll8 r1
|
||
|
|
#endif
|
||
|
|
or r1,r0
|
||
|
|
|
||
|
|
addc r0,r7
|
||
|
|
movt r0
|
||
|
|
dt r6
|
||
|
|
bf/s 5b
|
||
|
|
cmp/eq #1,r0
|
||
|
|
mov #0,r0
|
||
|
|
addc r0, r7
|
||
|
|
|
||
|
|
mov r2, r0
|
||
|
|
tst #1, r0
|
||
|
|
bt 7f
|
||
|
|
bra 5f
|
||
|
|
clrt
|
||
|
|
|
||
|
|
! src and dest equally aligned, but to a two byte boundary.
|
||
|
|
! Handle first two bytes as a special case
|
||
|
|
.align 2
|
||
|
|
1:
|
||
|
|
SRC( mov.w @r4+,r0 )
|
||
|
|
DST( mov.w r0,@r5 )
|
||
|
|
add #2,r5
|
||
|
|
extu.w r0,r0
|
||
|
|
addc r0,r7
|
||
|
|
mov #0,r0
|
||
|
|
addc r0,r7
|
||
|
|
2:
|
||
|
|
mov r6,r2
|
||
|
|
mov #-5,r0
|
||
|
|
shld r0,r6
|
||
|
|
tst r6,r6
|
||
|
|
bt/s 2f
|
||
|
|
clrt
|
||
|
|
.align 2
|
||
|
|
1:
|
||
|
|
SRC( mov.l @r4+,r0 )
|
||
|
|
SRC( mov.l @r4+,r1 )
|
||
|
|
addc r0,r7
|
||
|
|
DST( mov.l r0,@r5 )
|
||
|
|
DST( mov.l r1,@(4,r5) )
|
||
|
|
addc r1,r7
|
||
|
|
|
||
|
|
SRC( mov.l @r4+,r0 )
|
||
|
|
SRC( mov.l @r4+,r1 )
|
||
|
|
addc r0,r7
|
||
|
|
DST( mov.l r0,@(8,r5) )
|
||
|
|
DST( mov.l r1,@(12,r5) )
|
||
|
|
addc r1,r7
|
||
|
|
|
||
|
|
SRC( mov.l @r4+,r0 )
|
||
|
|
SRC( mov.l @r4+,r1 )
|
||
|
|
addc r0,r7
|
||
|
|
DST( mov.l r0,@(16,r5) )
|
||
|
|
DST( mov.l r1,@(20,r5) )
|
||
|
|
addc r1,r7
|
||
|
|
|
||
|
|
SRC( mov.l @r4+,r0 )
|
||
|
|
SRC( mov.l @r4+,r1 )
|
||
|
|
addc r0,r7
|
||
|
|
DST( mov.l r0,@(24,r5) )
|
||
|
|
DST( mov.l r1,@(28,r5) )
|
||
|
|
addc r1,r7
|
||
|
|
add #32,r5
|
||
|
|
movt r0
|
||
|
|
dt r6
|
||
|
|
bf/s 1b
|
||
|
|
cmp/eq #1,r0
|
||
|
|
mov #0,r0
|
||
|
|
addc r0,r7
|
||
|
|
|
||
|
|
2: mov r2,r6
|
||
|
|
mov #0x1c,r0
|
||
|
|
and r0,r6
|
||
|
|
cmp/pl r6
|
||
|
|
bf/s 4f
|
||
|
|
clrt
|
||
|
|
shlr2 r6
|
||
|
|
3:
|
||
|
|
SRC( mov.l @r4+,r0 )
|
||
|
|
addc r0,r7
|
||
|
|
DST( mov.l r0,@r5 )
|
||
|
|
add #4,r5
|
||
|
|
movt r0
|
||
|
|
dt r6
|
||
|
|
bf/s 3b
|
||
|
|
cmp/eq #1,r0
|
||
|
|
mov #0,r0
|
||
|
|
addc r0,r7
|
||
|
|
4: mov r2,r6
|
||
|
|
mov #3,r0
|
||
|
|
and r0,r6
|
||
|
|
cmp/pl r6
|
||
|
|
bf 7f
|
||
|
|
mov #2,r1
|
||
|
|
cmp/hs r1,r6
|
||
|
|
bf 5f
|
||
|
|
SRC( mov.w @r4+,r0 )
|
||
|
|
DST( mov.w r0,@r5 )
|
||
|
|
extu.w r0,r0
|
||
|
|
add #2,r5
|
||
|
|
cmp/eq r1,r6
|
||
|
|
bt/s 6f
|
||
|
|
clrt
|
||
|
|
shll16 r0
|
||
|
|
addc r0,r7
|
||
|
|
5:
|
||
|
|
SRC( mov.b @r4+,r0 )
|
||
|
|
DST( mov.b r0,@r5 )
|
||
|
|
extu.b r0,r0
|
||
|
|
#ifndef __LITTLE_ENDIAN__
|
||
|
|
shll8 r0
|
||
|
|
#endif
|
||
|
|
6: addc r0,r7
|
||
|
|
mov #0,r0
|
||
|
|
addc r0,r7
|
||
|
|
7:
|
||
|
|
5000:
|
||
|
|
|
||
|
|
# Exception handler:
|
||
|
|
.section .fixup, "ax"
|
||
|
|
|
||
|
|
6001:
|
||
|
|
mov.l @(8,r15),r0 ! src_err_ptr
|
||
|
|
mov #-EFAULT,r1
|
||
|
|
mov.l r1,@r0
|
||
|
|
|
||
|
|
! zero the complete destination - computing the rest
|
||
|
|
! is too much work
|
||
|
|
mov.l @(4,r15),r5 ! dst
|
||
|
|
mov.l @r15,r6 ! len
|
||
|
|
mov #0,r7
|
||
|
|
1: mov.b r7,@r5
|
||
|
|
dt r6
|
||
|
|
bf/s 1b
|
||
|
|
add #1,r5
|
||
|
|
mov.l 8000f,r0
|
||
|
|
jmp @r0
|
||
|
|
nop
|
||
|
|
.align 2
|
||
|
|
8000: .long 5000b
|
||
|
|
|
||
|
|
6002:
|
||
|
|
mov.l @(12,r15),r0 ! dst_err_ptr
|
||
|
|
mov #-EFAULT,r1
|
||
|
|
mov.l r1,@r0
|
||
|
|
mov.l 8001f,r0
|
||
|
|
jmp @r0
|
||
|
|
nop
|
||
|
|
.align 2
|
||
|
|
8001: .long 5000b
|
||
|
|
|
||
|
|
.previous
|
||
|
|
add #8,r15
|
||
|
|
rts
|
||
|
|
mov r7,r0
|