diff options
Diffstat (limited to 'ANDROID_3.4.5/arch/xtensa/lib/checksum.S')
| -rw-r--r-- | ANDROID_3.4.5/arch/xtensa/lib/checksum.S | 409 |
1 files changed, 0 insertions, 409 deletions
diff --git a/ANDROID_3.4.5/arch/xtensa/lib/checksum.S b/ANDROID_3.4.5/arch/xtensa/lib/checksum.S deleted file mode 100644 index df397f93..00000000 --- a/ANDROID_3.4.5/arch/xtensa/lib/checksum.S +++ /dev/null @@ -1,409 +0,0 @@ -/* - * 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 - * - * Xtensa version: Copyright (C) 2001 Tensilica, Inc. by Kevin Chea - * Optimized by Joe Taylor - * - * 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> -#include <variant/core.h> - -/* - * computes a partial checksum, e.g. for TCP/UDP fragments - */ - -/* - * unsigned int csum_partial(const unsigned char *buf, int len, - * unsigned int sum); - * a2 = buf - * a3 = len - * a4 = sum - * - * This function assumes 2- or 4-byte alignment. Other alignments will fail! - */ - -/* ONES_ADD converts twos-complement math to ones-complement. */ -#define ONES_ADD(sum, val) \ - add sum, sum, val ; \ - bgeu sum, val, 99f ; \ - addi sum, sum, 1 ; \ -99: ; - -.text -ENTRY(csum_partial) - /* - * Experiments with Ethernet and SLIP connections show that buf - * is aligned on either a 2-byte or 4-byte boundary. - */ - entry sp, 32 - extui a5, a2, 0, 2 - bnez a5, 8f /* branch if 2-byte aligned */ - /* Fall-through on common case, 4-byte alignment */ -1: - srli a5, a3, 5 /* 32-byte chunks */ -#if XCHAL_HAVE_LOOPS - loopgtz a5, 2f -#else - beqz a5, 2f - slli a5, a5, 5 - add a5, a5, a2 /* a5 = end of last 32-byte chunk */ -.Loop1: -#endif - l32i a6, a2, 0 - l32i a7, a2, 4 - ONES_ADD(a4, a6) - ONES_ADD(a4, a7) - l32i a6, a2, 8 - l32i a7, a2, 12 - ONES_ADD(a4, a6) - ONES_ADD(a4, a7) - l32i a6, a2, 16 - l32i a7, a2, 20 - ONES_ADD(a4, a6) - ONES_ADD(a4, a7) - l32i a6, a2, 24 - l32i a7, a2, 28 - ONES_ADD(a4, a6) - ONES_ADD(a4, a7) - addi a2, a2, 4*8 -#if !XCHAL_HAVE_LOOPS - blt a2, a5, .Loop1 -#endif -2: - extui a5, a3, 2, 3 /* remaining 4-byte chunks */ -#if XCHAL_HAVE_LOOPS - loopgtz a5, 3f -#else - beqz a5, 3f - slli a5, a5, 2 - add a5, a5, a2 /* a5 = end of last 4-byte chunk */ -.Loop2: -#endif - l32i a6, a2, 0 - ONES_ADD(a4, a6) - addi a2, a2, 4 -#if !XCHAL_HAVE_LOOPS - blt a2, a5, .Loop2 -#endif -3: - _bbci.l a3, 1, 5f /* remaining 2-byte chunk */ - l16ui a6, a2, 0 - ONES_ADD(a4, a6) - addi a2, a2, 2 -5: - _bbci.l a3, 0, 7f /* remaining 1-byte chunk */ -6: l8ui a6, a2, 0 -#ifdef __XTENSA_EB__ - slli a6, a6, 8 /* load byte into bits 8..15 */ -#endif - ONES_ADD(a4, a6) -7: - mov a2, a4 - retw - - /* uncommon case, buf is 2-byte aligned */ -8: - beqz a3, 7b /* branch if len == 0 */ - beqi a3, 1, 6b /* branch if len == 1 */ - - extui a5, a2, 0, 1 - bnez a5, 8f /* branch if 1-byte aligned */ - - l16ui a6, a2, 0 /* common case, len >= 2 */ - ONES_ADD(a4, a6) - addi a2, a2, 2 /* adjust buf */ - addi a3, a3, -2 /* adjust len */ - j 1b /* now buf is 4-byte aligned */ - - /* case: odd-byte aligned, len > 1 - * This case is dog slow, so don't give us an odd address. - * (I don't think this ever happens, but just in case.) - */ -8: - srli a5, a3, 2 /* 4-byte chunks */ -#if XCHAL_HAVE_LOOPS - loopgtz a5, 2f -#else - beqz a5, 2f - slli a5, a5, 2 - add a5, a5, a2 /* a5 = end of last 4-byte chunk */ -.Loop3: -#endif - l8ui a6, a2, 0 /* bits 24..31 */ - l16ui a7, a2, 1 /* bits 8..23 */ - l8ui a8, a2, 3 /* bits 0.. 8 */ -#ifdef __XTENSA_EB__ - slli a6, a6, 24 -#else - slli a8, a8, 24 -#endif - slli a7, a7, 8 - or a7, a7, a6 - or a7, a7, a8 - ONES_ADD(a4, a7) - addi a2, a2, 4 -#if !XCHAL_HAVE_LOOPS - blt a2, a5, .Loop3 -#endif -2: - _bbci.l a3, 1, 3f /* remaining 2-byte chunk, still odd addr */ - l8ui a6, a2, 0 - l8ui a7, a2, 1 -#ifdef __XTENSA_EB__ - slli a6, a6, 8 -#else - slli a7, a7, 8 -#endif - or a7, a7, a6 - ONES_ADD(a4, a7) - addi a2, a2, 2 -3: - j 5b /* branch to handle the remaining byte */ - - - -/* - * 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 each access type. - */ - -#define SRC(y...) \ - 9999: y; \ - .section __ex_table, "a"; \ - .long 9999b, 6001f ; \ - .previous - -#define DST(y...) \ - 9999: y; \ - .section __ex_table, "a"; \ - .long 9999b, 6002f ; \ - .previous - -/* -unsigned int csum_partial_copy_generic (const char *src, char *dst, int len, - int sum, int *src_err_ptr, int *dst_err_ptr) - a2 = src - a3 = dst - a4 = len - a5 = sum - a6 = src_err_ptr - a7 = dst_err_ptr - a8 = temp - a9 = temp - a10 = temp - a11 = original len for exception handling - a12 = original dst for exception handling - - This function is optimized for 4-byte aligned addresses. Other - alignments work, but not nearly as efficiently. - */ - -ENTRY(csum_partial_copy_generic) - entry sp, 32 - mov a12, a3 - mov a11, a4 - or a10, a2, a3 - - /* We optimize the following alignment tests for the 4-byte - aligned case. Two bbsi.l instructions might seem more optimal - (commented out below). However, both labels 5: and 3: are out - of the imm8 range, so the assembler relaxes them into - equivalent bbci.l, j combinations, which is actually - slower. */ - - extui a9, a10, 0, 2 - beqz a9, 1f /* branch if both are 4-byte aligned */ - bbsi.l a10, 0, 5f /* branch if one address is odd */ - j 3f /* one address is 2-byte aligned */ - -/* _bbsi.l a10, 0, 5f */ /* branch if odd address */ -/* _bbsi.l a10, 1, 3f */ /* branch if 2-byte-aligned address */ - -1: - /* src and dst are both 4-byte aligned */ - srli a10, a4, 5 /* 32-byte chunks */ -#if XCHAL_HAVE_LOOPS - loopgtz a10, 2f -#else - beqz a10, 2f - slli a10, a10, 5 - add a10, a10, a2 /* a10 = end of last 32-byte src chunk */ -.Loop5: -#endif -SRC( l32i a9, a2, 0 ) -SRC( l32i a8, a2, 4 ) -DST( s32i a9, a3, 0 ) -DST( s32i a8, a3, 4 ) - ONES_ADD(a5, a9) - ONES_ADD(a5, a8) -SRC( l32i a9, a2, 8 ) -SRC( l32i a8, a2, 12 ) -DST( s32i a9, a3, 8 ) -DST( s32i a8, a3, 12 ) - ONES_ADD(a5, a9) - ONES_ADD(a5, a8) -SRC( l32i a9, a2, 16 ) -SRC( l32i a8, a2, 20 ) -DST( s32i a9, a3, 16 ) -DST( s32i a8, a3, 20 ) - ONES_ADD(a5, a9) - ONES_ADD(a5, a8) -SRC( l32i a9, a2, 24 ) -SRC( l32i a8, a2, 28 ) -DST( s32i a9, a3, 24 ) -DST( s32i a8, a3, 28 ) - ONES_ADD(a5, a9) - ONES_ADD(a5, a8) - addi a2, a2, 32 - addi a3, a3, 32 -#if !XCHAL_HAVE_LOOPS - blt a2, a10, .Loop5 -#endif -2: - extui a10, a4, 2, 3 /* remaining 4-byte chunks */ - extui a4, a4, 0, 2 /* reset len for general-case, 2-byte chunks */ -#if XCHAL_HAVE_LOOPS - loopgtz a10, 3f -#else - beqz a10, 3f - slli a10, a10, 2 - add a10, a10, a2 /* a10 = end of last 4-byte src chunk */ -.Loop6: -#endif -SRC( l32i a9, a2, 0 ) -DST( s32i a9, a3, 0 ) - ONES_ADD(a5, a9) - addi a2, a2, 4 - addi a3, a3, 4 -#if !XCHAL_HAVE_LOOPS - blt a2, a10, .Loop6 -#endif -3: - /* - Control comes to here in two cases: (1) It may fall through - to here from the 4-byte alignment case to process, at most, - one 2-byte chunk. (2) It branches to here from above if - either src or dst is 2-byte aligned, and we process all bytes - here, except for perhaps a trailing odd byte. It's - inefficient, so align your addresses to 4-byte boundaries. - - a2 = src - a3 = dst - a4 = len - a5 = sum - */ - srli a10, a4, 1 /* 2-byte chunks */ -#if XCHAL_HAVE_LOOPS - loopgtz a10, 4f -#else - beqz a10, 4f - slli a10, a10, 1 - add a10, a10, a2 /* a10 = end of last 2-byte src chunk */ -.Loop7: -#endif -SRC( l16ui a9, a2, 0 ) -DST( s16i a9, a3, 0 ) - ONES_ADD(a5, a9) - addi a2, a2, 2 - addi a3, a3, 2 -#if !XCHAL_HAVE_LOOPS - blt a2, a10, .Loop7 -#endif -4: - /* This section processes a possible trailing odd byte. */ - _bbci.l a4, 0, 8f /* 1-byte chunk */ -SRC( l8ui a9, a2, 0 ) -DST( s8i a9, a3, 0 ) -#ifdef __XTENSA_EB__ - slli a9, a9, 8 /* shift byte to bits 8..15 */ -#endif - ONES_ADD(a5, a9) -8: - mov a2, a5 - retw - -5: - /* Control branch to here when either src or dst is odd. We - process all bytes using 8-bit accesses. Grossly inefficient, - so don't feed us an odd address. */ - - srli a10, a4, 1 /* handle in pairs for 16-bit csum */ -#if XCHAL_HAVE_LOOPS - loopgtz a10, 6f -#else - beqz a10, 6f - slli a10, a10, 1 - add a10, a10, a2 /* a10 = end of last odd-aligned, 2-byte src chunk */ -.Loop8: -#endif -SRC( l8ui a9, a2, 0 ) -SRC( l8ui a8, a2, 1 ) -DST( s8i a9, a3, 0 ) -DST( s8i a8, a3, 1 ) -#ifdef __XTENSA_EB__ - slli a9, a9, 8 /* combine into a single 16-bit value */ -#else /* for checksum computation */ - slli a8, a8, 8 -#endif - or a9, a9, a8 - ONES_ADD(a5, a9) - addi a2, a2, 2 - addi a3, a3, 2 -#if !XCHAL_HAVE_LOOPS - blt a2, a10, .Loop8 -#endif -6: - j 4b /* process the possible trailing odd byte */ - - -# Exception handler: -.section .fixup, "ax" -/* - a6 = src_err_ptr - a7 = dst_err_ptr - a11 = original len for exception handling - a12 = original dst for exception handling -*/ - -6001: - _movi a2, -EFAULT - s32i a2, a6, 0 /* src_err_ptr */ - - # clear the complete destination - computing the rest - # is too much work - movi a2, 0 -#if XCHAL_HAVE_LOOPS - loopgtz a11, 2f -#else - beqz a11, 2f - add a11, a11, a12 /* a11 = ending address */ -.Leloop: -#endif - s8i a2, a12, 0 - addi a12, a12, 1 -#if !XCHAL_HAVE_LOOPS - blt a12, a11, .Leloop -#endif -2: - retw - -6002: - movi a2, -EFAULT - s32i a2, a7, 0 /* dst_err_ptr */ - movi a2, 0 - retw - -.previous - |