arc-linux-uclibc/usr/include/asm/checksum.h - toolchains/skids - Git at Google

 /*
  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * vineetg: May 2010
  *  -Rewrote ip_fast_cscum( ) and csum_fold( ) with fast inline asm
  */

 #ifndef _ASM_ARC_CHECKSUM_H
 #define _ASM_ARC_CHECKSUM_H

 #include <linux/in6.h>
 /*
  * computes the checksum of a memory block at buff, length len,
  * and adds in "sum" (32-bit)
  *
  * returns a 32-bit number suitable for feeding into itself
  * or csum_tcpudp_magic
  *
  * this function must be called with even lengths, except
  * for the last fragment, which may be odd
  *
  * it's best to have buff aligned on a 32-bit boundary
  */
 unsigned int csum_partial(const void * buff, int len, unsigned int sum);

 /*
  * the same as csum_partial, but copies from src while it
  * checksums, and handles user-space pointer exceptions correctly, when needed.
  *
  * here even more important to align src and dst on a 32-bit (or even
  * better 64-bit) boundary
  */

 unsigned int csum_partial_copy(const char *src, char *dst, int len, int sum);

 /*
  * the same as csum_partial_copy, but copies from user space.
  *
  * here even more important to align src and dst on a 32-bit (or even
  * better 64-bit) boundary
  */

 extern unsigned int csum_partial_copy_from_user(const char *src, char *dst,
 						int len, int sum, int *csum_err);

 #define csum_partial_copy_nocheck(src, dst, len, sum)	\
 	csum_partial_copy((src), (dst), (len), (sum))

 /*
  *	Fold a partial checksum
  */
 static inline __sum16 csum_fold(__wsum sum)
 {
     unsigned int lower, upper;
     __sum16 folded;

     /* The 32 bit sum is broken into two 16 bit halves which are then added
      * We test if this results in a carry (bit 16 set), in which case it is
      * added back. This is slightly optimal than unconditionally adding the
      * upper bits of 16 bit sum (in anticipation of carry) back to sum
      *
      * Also as per the csum algorithm, after adding the carry back to sum,
      * the carry portion needs to be discarded before doing the invert.
      * However we leave the discard to end, when gcc for the purpose of
      * returning a sword, anyways downconverts the word to s-word, discarding
      * that portion
      */
     __asm__ __volatile__(
         "bmsk   %0, %3, 15  \n"  // break 32 bit @sum into two 16 bit words
         "lsr    %1, %3, 16  \n"
         "add    %0, %0, %1  \n"  // add them together
         "btst   %0, 16      \n"  // was there a carry in 16 bit sum
         "add.nz %0, %0, 1   \n"  // if yes, add it back to sum
                                  // extw needed - deferred (see below)
         "not    %2, %0      \n"  // csum req a final invert of sum
         :"=&r"(lower), "=&r" (upper), "=r" (folded)
         :"r" (sum)
         :"cc"
     );

    /* This implies extw insn, which down-conv 32-bit word to 16 bit word,
     * for the 16 bit return semantics. It also takes care of discarding
     * the carry portion of 16 bit sum, which we avoided purposefully
     * in the inline asm above
     */
     return folded;
 }

 /*
  *	This is a version of ip_compute_csum() optimized for IP headers,
  *	which always checksum on 4 octet boundaries.
  */
 static inline __sum16 ip_fast_csum(void *iph, unsigned int ihl)
 {
     void *ptr = iph;
     unsigned int sum, tmp;

     __asm__ __volatile__(
         "ld.ab   %0, [%2, 4]        \n\t"
         "sub.f   lp_count, %3, 1    \n\t"
         "lpnz  1f                   \n\t"
         "ld.ab   %1, [%2, 4]        \n\t"
         "adc.f   %0, %0, %1         \n\t"
         "1:                         \n\t"
         "adc     %0, %0, 0          \n\t"
         :"=&r"(sum), "=r"(tmp), "+r"(ptr)
         :"r"(ihl)
         :"cc"
     );

     return csum_fold(sum);
 }

 static inline unsigned long csum_tcpudp_nofold(unsigned long saddr,
 						   unsigned long daddr,
 						   unsigned short len,
 						   unsigned short proto,
 						   unsigned int sum)
 {
 	__asm__ __volatile__(
 		"add.f %0, %0, %1   \n"
 		"adc.f %0, %0, %2   \n"
 		"adc.f %0, %0, %3   \n"
 		"adc.f %0, %0, %4   \n"
 		"adc   %0, %0, 0    \n"
 		: "=r" (sum)
 		: "r" (saddr), "r" (daddr), "r" (ntohs(len) << 16),
 		  "r" (proto << 8), "0" (sum)
         : "cc"
 	);

     return sum;
 }

 /*
  * computes the checksum of the TCP/UDP pseudo-header
  * returns a 16-bit checksum, already complemented
  */
 static inline unsigned short int csum_tcpudp_magic(unsigned long saddr,
 						   unsigned long daddr,
 						   unsigned short len,
 						   unsigned short proto,
 						   unsigned int sum)
 {
 	return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
 }

 unsigned short ip_compute_csum(const unsigned char * buff, int len);

 #if 0
 /* AmitS - This is done in arch/arcnommu/lib/checksum.c */
 /*
  * this routine is used for miscellaneous IP-like checksums, mainly
  * in icmp.c
  */

 static inline unsigned short ip_compute_csum(unsigned char * buff, int len)
 {
     return csum_fold (csum_partial(buff, len, 0));
 }
 #endif

 //#define _HAVE_ARCH_IPV6_CSUM
 #if 0
 static inline unsigned short int csum_ipv6_magic(struct in6_addr *saddr,
 						     struct in6_addr *daddr,
 						     __u32 len,
 						     unsigned short proto,
 						     unsigned int sum)
 {
 	__asm__ (
 		/* just clear the flags for the adc.f inst. in the loop */
 		"sub.f 0, r0, r0      \n"
 		/* Loop 4 times for the {sd}addr fields */
 		"mov   lp_count, 0x04 \n"
 		/* There have to be atleast 3 cycles betn loop count
 		 * setup and last inst. in the loop
 		 */
 		"nop                  \n"
 		"lp    1f             \n"
 		"adc.f %0, %0, [%1]   \n"
 		"add   %1, %1, 4      \n"
 		"1:                   \n"
 		"mov   lp_count, 0x04 \n"
 		"nop                  \n"
 		"lp    2f             \n"
 		"adc.f %0, %0, [%2]   \n"
 		"add   %2, %2, 4      \n"
 		"2:                   \n"
 		"adc.f %0, %0, %3     \n"
 		"nop                  \n"
 		"adc.f %0, %0, %4     \n"
 		"nop                  \n"
 		"adc.f %0, %0, 0x0    \n"
 		: "=&r" (sum), "=r" (saddr), "=r" (daddr)
 		: "r" (htonl(len)), "r" (htonl(proto)),
 		  "0" (sum), "1" (saddr), "2" (daddr)
 		);
 	return csum_fold(sum);
 }

 #endif

 #if 0
 /*
  *	Copy and checksum to user
  */
 #define HAVE_CSUM_COPY_USER
 static inline unsigned int csum_and_copy_to_user(const char *src, char *dst,
 				    int len, int sum, int *err_ptr)
 {
 	if (access_ok(VERIFY_WRITE, dst, len))
 		return csum_partial_copy(src, dst, len, sum);

 	if (len)
 		*err_ptr = -EFAULT;

 	return -1; /* invalid checksum */
 }
 #endif

 extern unsigned short ip_compute_csum(const unsigned char * buff, int len);
 #endif /* _ASM_ARC_CHECKSUM_H */
	/*
	* Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*
	* vineetg: May 2010
	* -Rewrote ip_fast_cscum( ) and csum_fold( ) with fast inline asm
	*/

	#ifndef _ASM_ARC_CHECKSUM_H
	#define _ASM_ARC_CHECKSUM_H

	#include <linux/in6.h>
	/*
	* computes the checksum of a memory block at buff, length len,
	* and adds in "sum" (32-bit)
	*
	* returns a 32-bit number suitable for feeding into itself
	* or csum_tcpudp_magic
	*
	* this function must be called with even lengths, except
	* for the last fragment, which may be odd
	*
	* it's best to have buff aligned on a 32-bit boundary
	*/
	unsigned int csum_partial(const void * buff, int len, unsigned int sum);

	/*
	* the same as csum_partial, but copies from src while it
	* checksums, and handles user-space pointer exceptions correctly, when needed.
	*
	* here even more important to align src and dst on a 32-bit (or even
	* better 64-bit) boundary
	*/

	unsigned int csum_partial_copy(const char src, char dst, int len, int sum);

	/*
	* the same as csum_partial_copy, but copies from user space.
	*
	* here even more important to align src and dst on a 32-bit (or even
	* better 64-bit) boundary
	*/

	extern unsigned int csum_partial_copy_from_user(const char src, char dst,
	int len, int sum, int *csum_err);

	#define csum_partial_copy_nocheck(src, dst, len, sum) \
	csum_partial_copy((src), (dst), (len), (sum))

	/*
	* Fold a partial checksum
	*/
	static inline __sum16 csum_fold(__wsum sum)
	{
	unsigned int lower, upper;
	__sum16 folded;

	/* The 32 bit sum is broken into two 16 bit halves which are then added
	* We test if this results in a carry (bit 16 set), in which case it is
	* added back. This is slightly optimal than unconditionally adding the
	* upper bits of 16 bit sum (in anticipation of carry) back to sum
	*
	* Also as per the csum algorithm, after adding the carry back to sum,
	* the carry portion needs to be discarded before doing the invert.
	* However we leave the discard to end, when gcc for the purpose of
	* returning a sword, anyways downconverts the word to s-word, discarding
	* that portion
	*/
	__asm__ __volatile__(
	"bmsk %0, %3, 15 \n" // break 32 bit @sum into two 16 bit words
	"lsr %1, %3, 16 \n"
	"add %0, %0, %1 \n" // add them together
	"btst %0, 16 \n" // was there a carry in 16 bit sum
	"add.nz %0, %0, 1 \n" // if yes, add it back to sum
	// extw needed - deferred (see below)
	"not %2, %0 \n" // csum req a final invert of sum
	:"=&r"(lower), "=&r" (upper), "=r" (folded)
	:"r" (sum)
	:"cc"
	);

	/* This implies extw insn, which down-conv 32-bit word to 16 bit word,
	* for the 16 bit return semantics. It also takes care of discarding
	* the carry portion of 16 bit sum, which we avoided purposefully
	* in the inline asm above
	*/
	return folded;
	}

	/*
	* This is a version of ip_compute_csum() optimized for IP headers,
	* which always checksum on 4 octet boundaries.
	*/
	static inline __sum16 ip_fast_csum(void *iph, unsigned int ihl)
	{
	void *ptr = iph;
	unsigned int sum, tmp;

	__asm__ __volatile__(
	"ld.ab %0, [%2, 4] \n\t"
	"sub.f lp_count, %3, 1 \n\t"
	"lpnz 1f \n\t"
	"ld.ab %1, [%2, 4] \n\t"
	"adc.f %0, %0, %1 \n\t"
	"1: \n\t"
	"adc %0, %0, 0 \n\t"
	:"=&r"(sum), "=r"(tmp), "+r"(ptr)
	:"r"(ihl)
	:"cc"
	);

	return csum_fold(sum);
	}

	static inline unsigned long csum_tcpudp_nofold(unsigned long saddr,
	unsigned long daddr,
	unsigned short len,
	unsigned short proto,
	unsigned int sum)
	{
	__asm__ __volatile__(
	"add.f %0, %0, %1 \n"
	"adc.f %0, %0, %2 \n"
	"adc.f %0, %0, %3 \n"
	"adc.f %0, %0, %4 \n"
	"adc %0, %0, 0 \n"
	: "=r" (sum)
	: "r" (saddr), "r" (daddr), "r" (ntohs(len) << 16),
	"r" (proto << 8), "0" (sum)
	: "cc"
	);

	return sum;
	}

	/*
	* computes the checksum of the TCP/UDP pseudo-header
	* returns a 16-bit checksum, already complemented
	*/
	static inline unsigned short int csum_tcpudp_magic(unsigned long saddr,
	unsigned long daddr,
	unsigned short len,
	unsigned short proto,
	unsigned int sum)
	{
	return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
	}

	unsigned short ip_compute_csum(const unsigned char * buff, int len);

	#if 0
	/* AmitS - This is done in arch/arcnommu/lib/checksum.c */
	/*
	* this routine is used for miscellaneous IP-like checksums, mainly
	* in icmp.c
	*/

	static inline unsigned short ip_compute_csum(unsigned char * buff, int len)
	{
	return csum_fold (csum_partial(buff, len, 0));
	}
	#endif

	//#define _HAVE_ARCH_IPV6_CSUM
	#if 0
	static inline unsigned short int csum_ipv6_magic(struct in6_addr *saddr,
	struct in6_addr *daddr,
	__u32 len,
	unsigned short proto,
	unsigned int sum)
	{
	__asm__ (
	/* just clear the flags for the adc.f inst. in the loop */
	"sub.f 0, r0, r0 \n"
	/* Loop 4 times for the {sd}addr fields */
	"mov lp_count, 0x04 \n"
	/* There have to be atleast 3 cycles betn loop count
	* setup and last inst. in the loop
	*/
	"nop \n"
	"lp 1f \n"
	"adc.f %0, %0, [%1] \n"
	"add %1, %1, 4 \n"
	"1: \n"
	"mov lp_count, 0x04 \n"
	"nop \n"
	"lp 2f \n"
	"adc.f %0, %0, [%2] \n"
	"add %2, %2, 4 \n"
	"2: \n"
	"adc.f %0, %0, %3 \n"
	"nop \n"
	"adc.f %0, %0, %4 \n"
	"nop \n"
	"adc.f %0, %0, 0x0 \n"
	: "=&r" (sum), "=r" (saddr), "=r" (daddr)
	: "r" (htonl(len)), "r" (htonl(proto)),
	"0" (sum), "1" (saddr), "2" (daddr)
	);
	return csum_fold(sum);
	}

	#endif

	#if 0
	/*
	* Copy and checksum to user
	*/
	#define HAVE_CSUM_COPY_USER
	static inline unsigned int csum_and_copy_to_user(const char src, char dst,
	int len, int sum, int *err_ptr)
	{
	if (access_ok(VERIFY_WRITE, dst, len))
	return csum_partial_copy(src, dst, len, sum);

	if (len)
	*err_ptr = -EFAULT;

	return -1; /* invalid checksum */
	}
	#endif

	extern unsigned short ip_compute_csum(const unsigned char * buff, int len);
	#endif /* _ASM_ARC_CHECKSUM_H */