[linux-2.6-block.git] / arch / mips / include / asm / 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) 1995, 96, 97, 98, 99, 2001 by Ralf Baechle
 * Copyright (C) 1999 Silicon Graphics, Inc.
 * Copyright (C) 2001 Thiemo Seufer.
 * Copyright (C) 2002 Maciej W. Rozycki
 * Copyright (C) 2014 Imagination Technologies Ltd.
 */
#ifndef _ASM_CHECKSUM_H
#define _ASM_CHECKSUM_H

#ifdef CONFIG_GENERIC_CSUM
#include <asm-generic/checksum.h>
#else

#include <linux/in6.h>

#include <linux/uaccess.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
 */
__wsum csum_partial(const void *buff, int len, __wsum sum);

__wsum __csum_partial_copy_kernel(const void *src, void *dst,
				  int len, __wsum sum, int *err_ptr);

__wsum __csum_partial_copy_from_user(const void *src, void *dst,
				     int len, __wsum sum, int *err_ptr);
__wsum __csum_partial_copy_to_user(const void *src, void *dst,
				   int len, __wsum sum, int *err_ptr);
/*
 * this is a new version of the above that records errors it finds in *errp,
 * but continues and zeros the rest of the buffer.
 */
static inline
__wsum csum_partial_copy_from_user(const void __user *src, void *dst, int len,
				   __wsum sum, int *err_ptr)
{
	might_fault();
	if (segment_eq(get_fs(), get_ds()))
		return __csum_partial_copy_kernel((__force void *)src, dst,
						  len, sum, err_ptr);
	else
		return __csum_partial_copy_from_user((__force void *)src, dst,
						     len, sum, err_ptr);
}

#define _HAVE_ARCH_COPY_AND_CSUM_FROM_USER
static inline
__wsum csum_and_copy_from_user(const void __user *src, void *dst,
			       int len, __wsum sum, int *err_ptr)
{
	if (access_ok(VERIFY_READ, src, len))
		return csum_partial_copy_from_user(src, dst, len, sum,
						   err_ptr);
	if (len)
		*err_ptr = -EFAULT;

	return 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)
{
	might_fault();
	if (access_ok(VERIFY_WRITE, dst, len)) {
		if (segment_eq(get_fs(), get_ds()))
			return __csum_partial_copy_kernel(src,
							  (__force void *)dst,
							  len, sum, err_ptr);
		else
			return __csum_partial_copy_to_user(src,
							   (__force void *)dst,
							   len, sum, err_ptr);
	}
	if (len)
		*err_ptr = -EFAULT;

	return (__force __wsum)-1; /* invalid checksum */
}

/*
 * the same as csum_partial, but copies from user space (but on MIPS
 * we have just one address space, so this is identical to the above)
 */
__wsum csum_partial_copy_nocheck(const void *src, void *dst,
				       int len, __wsum sum);
#define csum_partial_copy_nocheck csum_partial_copy_nocheck

/*
 *	Fold a partial checksum without adding pseudo headers
 */
static inline __sum16 csum_fold(__wsum csum)
{
	u32 sum = (__force u32)csum;;

	sum += (sum << 16);
	csum = (sum < csum);
	sum >>= 16;
	sum += csum;

	return (__force __sum16)~sum;
}
#define csum_fold csum_fold

/*
 *	This is a version of ip_compute_csum() optimized for IP headers,
 *	which always checksum on 4 octet boundaries.
 *
 *	By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by
 *	Arnt Gulbrandsen.
 */
static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl)
{
	const unsigned int *word = iph;
	const unsigned int *stop = word + ihl;
	unsigned int csum;
	int carry;

	csum = word[0];
	csum += word[1];
	carry = (csum < word[1]);
	csum += carry;

	csum += word[2];
	carry = (csum < word[2]);
	csum += carry;

	csum += word[3];
	carry = (csum < word[3]);
	csum += carry;

	word += 4;
	do {
		csum += *word;
		carry = (csum < *word);
		csum += carry;
		word++;
	} while (word != stop);

	return csum_fold(csum);
}
#define ip_fast_csum ip_fast_csum

static inline __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
					__u32 len, __u8 proto,
					__wsum sum)
{
	__asm__(
	"	.set	push		# csum_tcpudp_nofold\n"
	"	.set	noat		\n"
#ifdef CONFIG_32BIT
	"	addu	%0, %2		\n"
	"	sltu	$1, %0, %2	\n"
	"	addu	%0, $1		\n"

	"	addu	%0, %3		\n"
	"	sltu	$1, %0, %3	\n"
	"	addu	%0, $1		\n"

	"	addu	%0, %4		\n"
	"	sltu	$1, %0, %4	\n"
	"	addu	%0, $1		\n"
#endif
#ifdef CONFIG_64BIT
	"	daddu	%0, %2		\n"
	"	daddu	%0, %3		\n"
	"	daddu	%0, %4		\n"
	"	dsll32	$1, %0, 0	\n"
	"	daddu	%0, $1		\n"
	"	dsra32	%0, %0, 0	\n"
#endif
	"	.set	pop"
	: "=r" (sum)
	: "0" ((__force unsigned long)daddr),
	  "r" ((__force unsigned long)saddr),
#ifdef __MIPSEL__
	  "r" ((proto + len) << 8),
#else
	  "r" (proto + len),
#endif
	  "r" ((__force unsigned long)sum));

	return sum;
}
#define csum_tcpudp_nofold csum_tcpudp_nofold

/*
 * 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, __u8 proto,
					  __wsum sum)
{
	__wsum tmp;

	__asm__(
	"	.set	push		# csum_ipv6_magic\n"
	"	.set	noreorder	\n"
	"	.set	noat		\n"
	"	addu	%0, %5		# proto (long in network byte order)\n"
	"	sltu	$1, %0, %5	\n"
	"	addu	%0, $1		\n"

	"	addu	%0, %6		# csum\n"
	"	sltu	$1, %0, %6	\n"
	"	lw	%1, 0(%2)	# four words source address\n"
	"	addu	%0, $1		\n"
	"	addu	%0, %1		\n"
	"	sltu	$1, %0, %1	\n"

	"	lw	%1, 4(%2)	\n"
	"	addu	%0, $1		\n"
	"	addu	%0, %1		\n"
	"	sltu	$1, %0, %1	\n"

	"	lw	%1, 8(%2)	\n"
	"	addu	%0, $1		\n"
	"	addu	%0, %1		\n"
	"	sltu	$1, %0, %1	\n"

	"	lw	%1, 12(%2)	\n"
	"	addu	%0, $1		\n"
	"	addu	%0, %1		\n"
	"	sltu	$1, %0, %1	\n"

	"	lw	%1, 0(%3)	\n"
	"	addu	%0, $1		\n"
	"	addu	%0, %1		\n"
	"	sltu	$1, %0, %1	\n"

	"	lw	%1, 4(%3)	\n"
	"	addu	%0, $1		\n"
	"	addu	%0, %1		\n"
	"	sltu	$1, %0, %1	\n"

	"	lw	%1, 8(%3)	\n"
	"	addu	%0, $1		\n"
	"	addu	%0, %1		\n"
	"	sltu	$1, %0, %1	\n"

	"	lw	%1, 12(%3)	\n"
	"	addu	%0, $1		\n"
	"	addu	%0, %1		\n"
	"	sltu	$1, %0, %1	\n"

	"	addu	%0, $1		# Add final carry\n"
	"	.set	pop"
	: "=&r" (sum), "=&r" (tmp)
	: "r" (saddr), "r" (daddr),
	  "0" (htonl(len)), "r" (htonl(proto)), "r" (sum));

	return csum_fold(sum);
}

#include <asm-generic/checksum.h>
#endif /* CONFIG_GENERIC_CSUM */

#endif /* _ASM_CHECKSUM_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
	6	* Copyright (C) 1995, 96, 97, 98, 99, 2001 by Ralf Baechle
	7	* Copyright (C) 1999 Silicon Graphics, Inc.
	8	* Copyright (C) 2001 Thiemo Seufer.
	9	* Copyright (C) 2002 Maciej W. Rozycki
ac85227f	10	* Copyright (C) 2014 Imagination Technologies Ltd.
1da177e4 LT	11	*/
	12	#ifndef _ASM_CHECKSUM_H
	13	#define _ASM_CHECKSUM_H
	14
4e0748f5 MC	15	#ifdef CONFIG_GENERIC_CSUM
	16	#include <asm-generic/checksum.h>
	17	#else
	18
1da177e4 LT	19	#include <linux/in6.h>
1da177e4 LT	20
7c0f6ba6	21	#include <linux/uaccess.h>
1da177e4 LT	22
	23	/*
	24	* computes the checksum of a memory block at buff, length len,
	25	* and adds in "sum" (32-bit)
	26	*
	27	* returns a 32-bit number suitable for feeding into itself
	28	* or csum_tcpudp_magic
	29	*
	30	* this function must be called with even lengths, except
	31	* for the last fragment, which may be odd
	32	*
	33	* it's best to have buff aligned on a 32-bit boundary
	34	*/
8e3d8433	35	__wsum csum_partial(const void *buff, int len, __wsum sum);
1da177e4	36
ac85227f MC	37	__wsum __csum_partial_copy_kernel(const void src, void dst,
	38	int len, __wsum sum, int *err_ptr);
	39
	40	__wsum __csum_partial_copy_from_user(const void src, void dst,
	41	int len, __wsum sum, int *err_ptr);
	42	__wsum __csum_partial_copy_to_user(const void src, void dst,
	43	int len, __wsum sum, int *err_ptr);
1da177e4 LT	44	/*
	45	* this is a new version of the above that records errors it finds in *errp,
	46	* but continues and zeros the rest of the buffer.
	47	*/
f860c90b AN	48	static inline
	49	__wsum csum_partial_copy_from_user(const void __user src, void dst, int len,
	50	__wsum sum, int *err_ptr)
	51	{
ef41f460	52	might_fault();
fb316913 LY	53	if (segment_eq(get_fs(), get_ds()))
	54	return __csum_partial_copy_kernel((__force void *)src, dst,
	55	len, sum, err_ptr);
	56	else
	57	return __csum_partial_copy_from_user((__force void *)src, dst,
	58	len, sum, err_ptr);
f860c90b	59	}
1da177e4	60
c2d85bc1 LY	61	#define _HAVE_ARCH_COPY_AND_CSUM_FROM_USER
	62	static inline
	63	__wsum csum_and_copy_from_user(const void __user src, void dst,
	64	int len, __wsum sum, int *err_ptr)
	65	{
	66	if (access_ok(VERIFY_READ, src, len))
	67	return csum_partial_copy_from_user(src, dst, len, sum,
	68	err_ptr);
	69	if (len)
	70	*err_ptr = -EFAULT;
	71
	72	return sum;
	73	}
	74
1da177e4 LT	75	/*
	76	* Copy and checksum to user
	77	*/
	78	#define HAVE_CSUM_COPY_USER
f860c90b AN	79	static inline
	80	__wsum csum_and_copy_to_user(const void src, void __user dst, int len,
	81	__wsum sum, int *err_ptr)
1da177e4	82	{
ef41f460	83	might_fault();
fb316913 LY	84	if (access_ok(VERIFY_WRITE, dst, len)) {
	85	if (segment_eq(get_fs(), get_ds()))
	86	return __csum_partial_copy_kernel(src,
	87	(__force void *)dst,
	88	len, sum, err_ptr);
	89	else
	90	return __csum_partial_copy_to_user(src,
	91	(__force void *)dst,
	92	len, sum, err_ptr);
	93	}
f860c90b	94	if (len)
1da177e4	95	*err_ptr = -EFAULT;
1da177e4	96
f860c90b	97	return (__force __wsum)-1; /* invalid checksum */
1da177e4 LT	98	}
	99
	100	/*
	101	* the same as csum_partial, but copies from user space (but on MIPS
	102	* we have just one address space, so this is identical to the above)
	103	*/
8e3d8433 AV	104	__wsum csum_partial_copy_nocheck(const void src, void dst,
8e3d8433 AV	105	int len, __wsum sum);
b4b5015a	106	#define csum_partial_copy_nocheck csum_partial_copy_nocheck
1da177e4 LT	107
	108	/*
	109	* Fold a partial checksum without adding pseudo headers
	110	*/
d0f0f63a	111	static inline __sum16 csum_fold(__wsum csum)
1da177e4	112	{
d0f0f63a	113	u32 sum = (__force u32)csum;;
1da177e4	114
d0f0f63a RB	115	sum += (sum << 16);
	116	csum = (sum < csum);
	117	sum >>= 16;
	118	sum += csum;
	119
	120	return (__force __sum16)~sum;
1da177e4	121	}
b4b5015a	122	#define csum_fold csum_fold
1da177e4 LT	123
	124	/*
	125	* This is a version of ip_compute_csum() optimized for IP headers,
	126	* which always checksum on 4 octet boundaries.
	127	*
	128	* By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by
	129	* Arnt Gulbrandsen.
	130	*/
8e3d8433	131	static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl)
1da177e4	132	{
8e3d8433 AV	133	const unsigned int *word = iph;
8e3d8433 AV	134	const unsigned int *stop = word + ihl;
1da177e4 LT	135	unsigned int csum;
	136	int carry;
	137
	138	csum = word[0];
	139	csum += word[1];
	140	carry = (csum < word[1]);
	141	csum += carry;
	142
	143	csum += word[2];
	144	carry = (csum < word[2]);
	145	csum += carry;
	146
	147	csum += word[3];
	148	carry = (csum < word[3]);
	149	csum += carry;
	150
	151	word += 4;
	152	do {
	153	csum += *word;
	154	carry = (csum < *word);
	155	csum += carry;
	156	word++;
	157	} while (word != stop);
	158
	159	return csum_fold(csum);
	160	}
b4b5015a	161	#define ip_fast_csum ip_fast_csum
1da177e4	162
01cfbad7 AD	163	static inline __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
	164	__u32 len, __u8 proto,
	165	__wsum sum)
1da177e4 LT	166	{
1da177e4 LT	167	__asm__(
04988d6f TS	168	" .set push # csum_tcpudp_nofold\n"
04988d6f TS	169	" .set noat \n"
875d43e7	170	#ifdef CONFIG_32BIT
04988d6f TS	171	" addu %0, %2 \n"
	172	" sltu $1, %0, %2 \n"
	173	" addu %0, $1 \n"
1da177e4	174
04988d6f TS	175	" addu %0, %3 \n"
	176	" sltu $1, %0, %3 \n"
	177	" addu %0, $1 \n"
1da177e4	178
04988d6f TS	179	" addu %0, %4 \n"
	180	" sltu $1, %0, %4 \n"
	181	" addu %0, $1 \n"
1da177e4	182	#endif
875d43e7	183	#ifdef CONFIG_64BIT
04988d6f TS	184	" daddu %0, %2 \n"
	185	" daddu %0, %3 \n"
	186	" daddu %0, %4 \n"
	187	" dsll32 $1, %0, 0 \n"
	188	" daddu %0, $1 \n"
e9728838	189	" dsra32 %0, %0, 0 \n"
1da177e4	190	#endif
04988d6f	191	" .set pop"
1da177e4	192	: "=r" (sum)
66218da2 AN	193	: "0" ((__force unsigned long)daddr),
66218da2 AN	194	"r" ((__force unsigned long)saddr),
1da177e4	195	#ifdef __MIPSEL__
8e3d8433	196	"r" ((proto + len) << 8),
1da177e4	197	#else
8e3d8433	198	"r" (proto + len),
1da177e4	199	#endif
1d464c26	200	"r" ((__force unsigned long)sum));
1da177e4 LT	201
	202	return sum;
	203	}
b4b5015a	204	#define csum_tcpudp_nofold csum_tcpudp_nofold
1da177e4	205
1da177e4 LT	206	/*
	207	* this routine is used for miscellaneous IP-like checksums, mainly
	208	* in icmp.c
	209	*/
8e3d8433	210	static inline __sum16 ip_compute_csum(const void *buff, int len)
1da177e4 LT	211	{
	212	return csum_fold(csum_partial(buff, len, 0));
	213	}
	214
	215	#define _HAVE_ARCH_IPV6_CSUM
8e3d8433	216	static __inline__ __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
70342287	217	const struct in6_addr *daddr,
1e940829	218	__u32 len, __u8 proto,
8e3d8433	219	__wsum sum)
1da177e4	220	{
20c82d93 DS	221	__wsum tmp;
20c82d93 DS	222
1da177e4	223	__asm__(
04988d6f TS	224	" .set push # csum_ipv6_magic\n"
	225	" .set noreorder \n"
	226	" .set noat \n"
	227	" addu %0, %5 # proto (long in network byte order)\n"
	228	" sltu $1, %0, %5 \n"
	229	" addu %0, $1 \n"
	230
	231	" addu %0, %6 # csum\n"
	232	" sltu $1, %0, %6 \n"
	233	" lw %1, 0(%2) # four words source address\n"
	234	" addu %0, $1 \n"
	235	" addu %0, %1 \n"
	236	" sltu $1, %0, %1 \n"
	237
	238	" lw %1, 4(%2) \n"
	239	" addu %0, $1 \n"
	240	" addu %0, %1 \n"
	241	" sltu $1, %0, %1 \n"
	242
	243	" lw %1, 8(%2) \n"
	244	" addu %0, $1 \n"
	245	" addu %0, %1 \n"
	246	" sltu $1, %0, %1 \n"
	247
	248	" lw %1, 12(%2) \n"
	249	" addu %0, $1 \n"
	250	" addu %0, %1 \n"
	251	" sltu $1, %0, %1 \n"
	252
	253	" lw %1, 0(%3) \n"
	254	" addu %0, $1 \n"
	255	" addu %0, %1 \n"
	256	" sltu $1, %0, %1 \n"
	257
	258	" lw %1, 4(%3) \n"
	259	" addu %0, $1 \n"
	260	" addu %0, %1 \n"
	261	" sltu $1, %0, %1 \n"
	262
	263	" lw %1, 8(%3) \n"
	264	" addu %0, $1 \n"
	265	" addu %0, %1 \n"
	266	" sltu $1, %0, %1 \n"
	267
	268	" lw %1, 12(%3) \n"
	269	" addu %0, $1 \n"
	270	" addu %0, %1 \n"
	271	" sltu $1, %0, %1 \n"
	272
	273	" addu %0, $1 # Add final carry\n"
	274	" .set pop"
20c82d93	275	: "=&r" (sum), "=&r" (tmp)
1da177e4	276	: "r" (saddr), "r" (daddr),
20c82d93	277	"0" (htonl(len)), "r" (htonl(proto)), "r" (sum));
1da177e4 LT	278
	279	return csum_fold(sum);
	280	}
	281
b4b5015a	282	#include <asm-generic/checksum.h>
4e0748f5	283	#endif /* CONFIG_GENERIC_CSUM */
b4b5015a	284
1da177e4	285	#endif /* _ASM_CHECKSUM_H */