| /* SPDX-License-Identifier: GPL-2.0+ |
| * |
| * $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 |
| */ |
| |
| #include <asm/errno.h> |
| #include <linux/linkage.h> |
| |
| /* |
| * computes a partial checksum, e.g. for TCP/UDP fragments |
| */ |
| |
| /* |
| * asmlinkage __wsum csum_partial(const void *buf, int len, __wsum 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 r4, r0 |
| tst #3, r0 ! Check alignment. |
| bt/s 2f ! Jump if alignment is ok. |
| mov r4, r7 ! Keep a copy to check for alignment |
| ! |
| tst #1, r0 ! Check alignment. |
| bt 21f ! Jump if alignment is boundary of 2bytes. |
| |
| ! buf is odd |
| tst r5, r5 |
| add #-1, r5 |
| bt 9f |
| mov.b @r4+, r0 |
| extu.b r0, r0 |
| addc r0, r6 ! t=0 from previous tst |
| mov r6, r0 |
| shll8 r6 |
| shlr16 r0 |
| shlr8 r0 |
| or r0, r6 |
| mov r4, r0 |
| tst #2, r0 |
| bt 2f |
| 21: |
| ! buf is 2 byte aligned (len could be 0) |
| 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.w @r4+, r0 |
| extu.w r0, r0 |
| addc r0, r6 |
| bf 2f |
| add #1, r6 |
| 2: |
| ! buf is 4 byte aligned (len could be 0) |
| mov r5, r1 |
| mov #-5, r0 |
| shld r0, r1 |
| tst r1, r1 |
| 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 r1 |
| bf/s 3b |
| cmp/eq #1, r0 |
| ! here, we know r1==0 |
| addc r1, r6 ! add carry to r6 |
| 4: |
| mov r5, r0 |
| and #0x1c, r0 |
| tst r0, r0 |
| bt 6f |
| ! 4 bytes or more remaining |
| mov r0, r1 |
| shlr2 r1 |
| mov #0, r2 |
| 5: |
| addc r2, r6 |
| mov.l @r4+, r2 |
| movt r0 |
| dt r1 |
| bf/s 5b |
| cmp/eq #1, r0 |
| addc r2, r6 |
| addc r1, r6 ! r1==0 here, so it means add carry-bit |
| 6: |
| ! 3 bytes or less remaining |
| 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: |
| ! Check if the buffer was misaligned, if so realign sum |
| mov r7, r0 |
| tst #1, r0 |
| bt 10f |
| mov r6, r0 |
| shll8 r6 |
| shlr16 r0 |
| shlr8 r0 |
| or r0, r6 |
| 10: |
| rts |
| mov r6, r0 |
| |
| /* |
| unsigned int csum_partial_copy_generic (const char *src, char *dst, int len) |
| */ |
| |
| /* |
| * Copy from ds while checksumming, otherwise like csum_partial with initial |
| * sum being ~0U |
| */ |
| |
| #define EXC(...) \ |
| 9999: __VA_ARGS__ ; \ |
| .section __ex_table, "a"; \ |
| .long 9999b, 6001f ; \ |
| .previous |
| |
| ! |
| ! r4: const char *SRC |
| ! r5: char *DST |
| ! r6: int LEN |
| ! |
| ENTRY(csum_partial_copy_generic) |
| mov #-1,r7 |
| 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 |
| add #2,r6 ! r6 was < 2. Deal with it. |
| bra 4f |
| mov r6,r2 |
| |
| 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: |
| EXC( mov.b @r4+,r1 ) |
| EXC( mov.b @r4+,r0 ) |
| extu.b r1,r1 |
| EXC( mov.b r1,@r5 ) |
| EXC( 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: |
| EXC( mov.w @r4+,r0 ) |
| EXC( 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: |
| EXC( mov.l @r4+,r0 ) |
| EXC( mov.l @r4+,r1 ) |
| addc r0,r7 |
| EXC( mov.l r0,@r5 ) |
| EXC( mov.l r1,@(4,r5) ) |
| addc r1,r7 |
| |
| EXC( mov.l @r4+,r0 ) |
| EXC( mov.l @r4+,r1 ) |
| addc r0,r7 |
| EXC( mov.l r0,@(8,r5) ) |
| EXC( mov.l r1,@(12,r5) ) |
| addc r1,r7 |
| |
| EXC( mov.l @r4+,r0 ) |
| EXC( mov.l @r4+,r1 ) |
| addc r0,r7 |
| EXC( mov.l r0,@(16,r5) ) |
| EXC( mov.l r1,@(20,r5) ) |
| addc r1,r7 |
| |
| EXC( mov.l @r4+,r0 ) |
| EXC( mov.l @r4+,r1 ) |
| addc r0,r7 |
| EXC( mov.l r0,@(24,r5) ) |
| EXC( 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: |
| EXC( mov.l @r4+,r0 ) |
| addc r0,r7 |
| EXC( 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 |
| EXC( mov.w @r4+,r0 ) |
| EXC( 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: |
| EXC( mov.b @r4+,r0 ) |
| EXC( 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: |
| |
| # Exception handler: |
| .section .fixup, "ax" |
| |
| 6001: |
| rts |
| mov #0,r0 |
| .previous |
| rts |
| mov r7,r0 |
