[linux-block.git] / include / asm-xtensa / checksum.h

/*
 * include/asm-xtensa/checksum.h
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2001 - 2005 Tensilica Inc.
 */

#ifndef _XTENSA_CHECKSUM_H
#define _XTENSA_CHECKSUM_H

#include <linux/in6.h>
#include <asm/variant/core.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
 */
asmlinkage __wsum csum_partial(const void *buff, int len, __wsum 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
 */

asmlinkage __wsum csum_partial_copy_generic(const void *src, void *dst, int len, __wsum sum,
						   int *src_err_ptr, int *dst_err_ptr);

/*
 *	Note: when you get a NULL pointer exception here this means someone
 *	passed in an incorrect kernel address to one of these functions.
 *
 *	If you use these functions directly please don't forget the access_ok().
 */
static inline
__wsum csum_partial_copy_nocheck(const void *src, void *dst,
					int len, __wsum sum)
{
	return csum_partial_copy_generic(src, dst, len, sum, NULL, NULL);
}

static inline
__wsum csum_partial_copy_from_user(const void __user *src, void *dst,
						int len, __wsum sum, int *err_ptr)
{
	return csum_partial_copy_generic((__force const void *)src, dst,
					len, sum, err_ptr, NULL);
}

/*
 *	Fold a partial checksum
 */

static __inline__ __sum16 csum_fold(__wsum sum)
{
	unsigned int __dummy;
	__asm__("extui	%1, %0, 16, 16\n\t"
		"extui	%0 ,%0, 0, 16\n\t"
		"add	%0, %0, %1\n\t"
		"slli	%1, %0, 16\n\t"
		"add	%0, %0, %1\n\t"
		"extui	%0, %0, 16, 16\n\t"
		"neg	%0, %0\n\t"
		"addi	%0, %0, -1\n\t"
		"extui	%0, %0, 0, 16\n\t"
		: "=r" (sum), "=&r" (__dummy)
		: "0" (sum));
	return (__force __sum16)sum;
}

/*
 *	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(const void *iph, unsigned int ihl)
{
	unsigned int sum, tmp, endaddr;

	__asm__ __volatile__(
		"sub		%0, %0, %0\n\t"
#if XCHAL_HAVE_LOOPS
		"loopgtz	%2, 2f\n\t"
#else
		"beqz		%2, 2f\n\t"
		"slli		%4, %2, 2\n\t"
		"add		%4, %4, %1\n\t"
		"0:\t"
#endif
		"l32i		%3, %1, 0\n\t"
		"add		%0, %0, %3\n\t"
		"bgeu		%0, %3, 1f\n\t"
		"addi		%0, %0, 1\n\t"
		"1:\t"
		"addi		%1, %1, 4\n\t"
#if !XCHAL_HAVE_LOOPS
		"blt		%1, %4, 0b\n\t"
#endif
		"2:\t"
	/* Since the input registers which are loaded with iph and ihl
	   are modified, we must also specify them as outputs, or gcc
	   will assume they contain their original values. */
		: "=r" (sum), "=r" (iph), "=r" (ihl), "=&r" (tmp), "=&r" (endaddr)
		: "1" (iph), "2" (ihl));

	return	csum_fold(sum);
}

static __inline__ __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
						   unsigned short len,
						   unsigned short proto,
						   __wsum sum)
{

#ifdef __XTENSA_EL__
	unsigned long len_proto = (len + proto) << 8;
#elif defined(__XTENSA_EB__)
	unsigned long len_proto = len + proto;
#else
# error processor byte order undefined!
#endif
	__asm__("add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"add	%0, %0, %2\n\t"
		"bgeu	%0, %2, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"add	%0, %0, %3\n\t"
		"bgeu	%0, %3, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		: "=r" (sum), "=r" (len_proto)
		: "r" (daddr), "r" (saddr), "1" (len_proto), "0" (sum));
	return sum;
}

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

/*
 * this routine is used for miscellaneous IP-like checksums, mainly
 * in icmp.c
 */

static __inline__ __sum16 ip_compute_csum(const void *buff, int len)
{
    return csum_fold (csum_partial(buff, len, 0));
}

#define _HAVE_ARCH_IPV6_CSUM
static __inline__ __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
					  const struct in6_addr *daddr,
					  __u32 len, unsigned short proto,
					  __wsum sum)
{
	unsigned int __dummy;
	__asm__("l32i	%1, %2, 0\n\t"
		"add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"l32i	%1, %2, 4\n\t"
		"add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"l32i	%1, %2, 8\n\t"
		"add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"l32i	%1, %2, 12\n\t"
		"add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"l32i	%1, %3, 0\n\t"
		"add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"l32i	%1, %3, 4\n\t"
		"add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"l32i	%1, %3, 8\n\t"
		"add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"l32i	%1, %3, 12\n\t"
		"add	%0, %0, %1\n\t"
		"bgeu	%0, %1, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"add	%0, %0, %4\n\t"
		"bgeu	%0, %4, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		"add	%0, %0, %5\n\t"
		"bgeu	%0, %5, 1f\n\t"
		"addi	%0, %0, 1\n\t"
		"1:\t"
		: "=r" (sum), "=&r" (__dummy)
		: "r" (saddr), "r" (daddr),
		  "r" (htonl(len)), "r" (htonl(proto)), "0" (sum));

	return csum_fold(sum);
}

/*
 *	Copy and checksum to user
 */
#define HAVE_CSUM_COPY_USER
static __inline__ __wsum csum_and_copy_to_user(const void *src, void __user *dst,
				    int len, __wsum sum, int *err_ptr)
{
	if (access_ok(VERIFY_WRITE, dst, len))
		return csum_partial_copy_generic(src, dst, len, sum, NULL, err_ptr);

	if (len)
		*err_ptr = -EFAULT;

	return (__force __wsum)-1; /* invalid checksum */
}
#endif
Commit	Line	Data
9a8fd558 CZ	1	/*
	2	* include/asm-xtensa/checksum.h
	3	*
	4	* This file is subject to the terms and conditions of the GNU General Public
	5	* License. See the file "COPYING" in the main directory of this archive
	6	* for more details.
	7	*
	8	* Copyright (C) 2001 - 2005 Tensilica Inc.
	9	*/
	10
	11	#ifndef _XTENSA_CHECKSUM_H
	12	#define _XTENSA_CHECKSUM_H
	13
9a8fd558	14	#include <linux/in6.h>
173d6681	15	#include <asm/variant/core.h>
9a8fd558 CZ	16
	17	/*
	18	* computes the checksum of a memory block at buff, length len,
	19	* and adds in "sum" (32-bit)
	20	*
	21	* returns a 32-bit number suitable for feeding into itself
	22	* or csum_tcpudp_magic
	23	*
	24	* this function must be called with even lengths, except
	25	* for the last fragment, which may be odd
	26	*
	27	* it's best to have buff aligned on a 32-bit boundary
	28	*/
b8e4e01d	29	asmlinkage __wsum csum_partial(const void *buff, int len, __wsum sum);
9a8fd558 CZ	30
	31	/*
	32	* the same as csum_partial, but copies from src while it
	33	* checksums, and handles user-space pointer exceptions correctly, when needed.
	34	*
	35	* here even more important to align src and dst on a 32-bit (or even
	36	* better 64-bit) boundary
	37	*/
	38
b8e4e01d	39	asmlinkage __wsum csum_partial_copy_generic(const void src, void dst, int len, __wsum sum,
9a8fd558 CZ	40	int src_err_ptr, int dst_err_ptr);
	41
	42	/*
	43	* Note: when you get a NULL pointer exception here this means someone
	44	* passed in an incorrect kernel address to one of these functions.
	45	*
b9e122c8	46	* If you use these functions directly please don't forget the access_ok().
9a8fd558	47	*/
d99cf715	48	static inline
b8e4e01d AV	49	__wsum csum_partial_copy_nocheck(const void src, void dst,
b8e4e01d AV	50	int len, __wsum sum)
9a8fd558	51	{
b8e4e01d	52	return csum_partial_copy_generic(src, dst, len, sum, NULL, NULL);
9a8fd558 CZ	53	}
9a8fd558 CZ	54
d99cf715	55	static inline
b8e4e01d AV	56	__wsum csum_partial_copy_from_user(const void __user src, void dst,
b8e4e01d AV	57	int len, __wsum sum, int *err_ptr)
9a8fd558	58	{
b8e4e01d AV	59	return csum_partial_copy_generic((__force const void *)src, dst,
b8e4e01d AV	60	len, sum, err_ptr, NULL);
9a8fd558 CZ	61	}
9a8fd558 CZ	62
9a8fd558 CZ	63	/*
	64	* Fold a partial checksum
	65	*/
	66
b8e4e01d	67	static __inline__ __sum16 csum_fold(__wsum sum)
9a8fd558 CZ	68	{
	69	unsigned int __dummy;
	70	__asm__("extui %1, %0, 16, 16\n\t"
	71	"extui %0 ,%0, 0, 16\n\t"
	72	"add %0, %0, %1\n\t"
	73	"slli %1, %0, 16\n\t"
	74	"add %0, %0, %1\n\t"
	75	"extui %0, %0, 16, 16\n\t"
	76	"neg %0, %0\n\t"
	77	"addi %0, %0, -1\n\t"
	78	"extui %0, %0, 0, 16\n\t"
	79	: "=r" (sum), "=&r" (__dummy)
	80	: "0" (sum));
b8e4e01d	81	return (__force __sum16)sum;
9a8fd558 CZ	82	}
	83
	84	/*
	85	* This is a version of ip_compute_csum() optimized for IP headers,
	86	* which always checksum on 4 octet boundaries.
	87	*/
b8e4e01d	88	static __inline__ __sum16 ip_fast_csum(const void *iph, unsigned int ihl)
9a8fd558 CZ	89	{
	90	unsigned int sum, tmp, endaddr;
	91
	92	__asm__ __volatile__(
	93	"sub %0, %0, %0\n\t"
	94	#if XCHAL_HAVE_LOOPS
	95	"loopgtz %2, 2f\n\t"
	96	#else
	97	"beqz %2, 2f\n\t"
	98	"slli %4, %2, 2\n\t"
	99	"add %4, %4, %1\n\t"
	100	"0:\t"
	101	#endif
	102	"l32i %3, %1, 0\n\t"
	103	"add %0, %0, %3\n\t"
	104	"bgeu %0, %3, 1f\n\t"
	105	"addi %0, %0, 1\n\t"
	106	"1:\t"
	107	"addi %1, %1, 4\n\t"
	108	#if !XCHAL_HAVE_LOOPS
	109	"blt %1, %4, 0b\n\t"
	110	#endif
	111	"2:\t"
	112	/* Since the input registers which are loaded with iph and ihl
	113	are modified, we must also specify them as outputs, or gcc
	114	will assume they contain their original values. */
	115	: "=r" (sum), "=r" (iph), "=r" (ihl), "=&r" (tmp), "=&r" (endaddr)
	116	: "1" (iph), "2" (ihl));
	117
	118	return csum_fold(sum);
	119	}
	120
b8e4e01d	121	static __inline__ __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
9a8fd558 CZ	122	unsigned short len,
9a8fd558 CZ	123	unsigned short proto,
b8e4e01d	124	__wsum sum)
9a8fd558 CZ	125	{
	126
	127	#ifdef __XTENSA_EL__
b8e4e01d	128	unsigned long len_proto = (len + proto) << 8;
9a8fd558	129	#elif defined(__XTENSA_EB__)
b8e4e01d	130	unsigned long len_proto = len + proto;
9a8fd558 CZ	131	#else
	132	# error processor byte order undefined!
	133	#endif
	134	__asm__("add %0, %0, %1\n\t"
	135	"bgeu %0, %1, 1f\n\t"
	136	"addi %0, %0, 1\n\t"
	137	"1:\t"
	138	"add %0, %0, %2\n\t"
	139	"bgeu %0, %2, 1f\n\t"
	140	"addi %0, %0, 1\n\t"
	141	"1:\t"
	142	"add %0, %0, %3\n\t"
	143	"bgeu %0, %3, 1f\n\t"
	144	"addi %0, %0, 1\n\t"
	145	"1:\t"
	146	: "=r" (sum), "=r" (len_proto)
	147	: "r" (daddr), "r" (saddr), "1" (len_proto), "0" (sum));
	148	return sum;
	149	}
	150
	151	/*
	152	* computes the checksum of the TCP/UDP pseudo-header
	153	* returns a 16-bit checksum, already complemented
	154	*/
b8e4e01d	155	static __inline__ __sum16 csum_tcpudp_magic(__be32 saddr, __be32 daddr,
9a8fd558 CZ	156	unsigned short len,
9a8fd558 CZ	157	unsigned short proto,
b8e4e01d	158	__wsum sum)
9a8fd558 CZ	159	{
	160	return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
	161	}
	162
	163	/*
	164	* this routine is used for miscellaneous IP-like checksums, mainly
	165	* in icmp.c
	166	*/
	167
b8e4e01d	168	static __inline__ __sum16 ip_compute_csum(const void *buff, int len)
9a8fd558 CZ	169	{
	170	return csum_fold (csum_partial(buff, len, 0));
	171	}
	172
	173	#define _HAVE_ARCH_IPV6_CSUM
b8e4e01d AV	174	static __inline__ __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
	175	const struct in6_addr *daddr,
	176	__u32 len, unsigned short proto,
	177	__wsum sum)
9a8fd558 CZ	178	{
	179	unsigned int __dummy;
	180	__asm__("l32i %1, %2, 0\n\t"
	181	"add %0, %0, %1\n\t"
	182	"bgeu %0, %1, 1f\n\t"
	183	"addi %0, %0, 1\n\t"
	184	"1:\t"
	185	"l32i %1, %2, 4\n\t"
	186	"add %0, %0, %1\n\t"
	187	"bgeu %0, %1, 1f\n\t"
	188	"addi %0, %0, 1\n\t"
	189	"1:\t"
	190	"l32i %1, %2, 8\n\t"
	191	"add %0, %0, %1\n\t"
	192	"bgeu %0, %1, 1f\n\t"
	193	"addi %0, %0, 1\n\t"
	194	"1:\t"
	195	"l32i %1, %2, 12\n\t"
	196	"add %0, %0, %1\n\t"
	197	"bgeu %0, %1, 1f\n\t"
	198	"addi %0, %0, 1\n\t"
	199	"1:\t"
	200	"l32i %1, %3, 0\n\t"
	201	"add %0, %0, %1\n\t"
	202	"bgeu %0, %1, 1f\n\t"
	203	"addi %0, %0, 1\n\t"
	204	"1:\t"
	205	"l32i %1, %3, 4\n\t"
	206	"add %0, %0, %1\n\t"
	207	"bgeu %0, %1, 1f\n\t"
	208	"addi %0, %0, 1\n\t"
	209	"1:\t"
	210	"l32i %1, %3, 8\n\t"
	211	"add %0, %0, %1\n\t"
	212	"bgeu %0, %1, 1f\n\t"
	213	"addi %0, %0, 1\n\t"
	214	"1:\t"
	215	"l32i %1, %3, 12\n\t"
	216	"add %0, %0, %1\n\t"
	217	"bgeu %0, %1, 1f\n\t"
	218	"addi %0, %0, 1\n\t"
	219	"1:\t"
	220	"add %0, %0, %4\n\t"
	221	"bgeu %0, %4, 1f\n\t"
	222	"addi %0, %0, 1\n\t"
	223	"1:\t"
	224	"add %0, %0, %5\n\t"
	225	"bgeu %0, %5, 1f\n\t"
	226	"addi %0, %0, 1\n\t"
	227	"1:\t"
	228	: "=r" (sum), "=&r" (__dummy)
	229	: "r" (saddr), "r" (daddr),
	230	"r" (htonl(len)), "r" (htonl(proto)), "0" (sum));
	231
	232	return csum_fold(sum);
	233	}
	234
	235	/*
	236	* Copy and checksum to user
	237	*/
	238	#define HAVE_CSUM_COPY_USER
b8e4e01d AV	239	static __inline__ __wsum csum_and_copy_to_user(const void src, void __user dst,
b8e4e01d AV	240	int len, __wsum sum, int *err_ptr)
9a8fd558 CZ	241	{
	242	if (access_ok(VERIFY_WRITE, dst, len))
	243	return csum_partial_copy_generic(src, dst, len, sum, NULL, err_ptr);
	244
	245	if (len)
	246	*err_ptr = -EFAULT;
	247
b8e4e01d	248	return (__force __wsum)-1; /* invalid checksum */
9a8fd558 CZ	249	}
9a8fd558 CZ	250	#endif