[deliverable/linux.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

#include <linux/in6.h>

#include <asm/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);

/*
 *	Fold a partial checksum without adding pseudo headers
 */
static inline __sum16 csum_fold(__wsum sum)
{
	__asm__(
	"	.set	push		# csum_fold\n"
	"	.set	noat		\n"
	"	sll	$1, %0, 16	\n"
	"	addu	%0, $1		\n"
	"	sltu	$1, %0, $1	\n"
	"	srl	%0, %0, 16	\n"
	"	addu	%0, $1		\n"
	"	xori	%0, 0xffff	\n"
	"	.set	pop"
	: "=r" (sum)
	: "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.
 *
 *	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);
}

static inline __wsum csum_tcpudp_nofold(__be32 saddr,
	__be32 daddr, unsigned short len, unsigned short 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;
}

/*
 * 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)
{
	__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" (proto)
	: "r" (saddr), "r" (daddr),
	  "0" (htonl(len)), "1" (htonl(proto)), "r" (sum));

	return csum_fold(sum);
}

#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
1da177e4 LT	15	#include <linux/in6.h>
	16
	17	#include <asm/uaccess.h>
	18
	19	/*
	20	* computes the checksum of a memory block at buff, length len,
	21	* and adds in "sum" (32-bit)
	22	*
	23	* returns a 32-bit number suitable for feeding into itself
	24	* or csum_tcpudp_magic
	25	*
	26	* this function must be called with even lengths, except
	27	* for the last fragment, which may be odd
	28	*
	29	* it's best to have buff aligned on a 32-bit boundary
	30	*/
8e3d8433	31	__wsum csum_partial(const void *buff, int len, __wsum sum);
1da177e4	32
ac85227f MC	33	__wsum __csum_partial_copy_kernel(const void src, void dst,
	34	int len, __wsum sum, int *err_ptr);
	35
	36	__wsum __csum_partial_copy_from_user(const void src, void dst,
	37	int len, __wsum sum, int *err_ptr);
	38	__wsum __csum_partial_copy_to_user(const void src, void dst,
	39	int len, __wsum sum, int *err_ptr);
1da177e4 LT	40	/*
	41	* this is a new version of the above that records errors it finds in *errp,
	42	* but continues and zeros the rest of the buffer.
	43	*/
f860c90b AN	44	static inline
	45	__wsum csum_partial_copy_from_user(const void __user src, void dst, int len,
	46	__wsum sum, int *err_ptr)
	47	{
ef41f460	48	might_fault();
fb316913 LY	49	if (segment_eq(get_fs(), get_ds()))
	50	return __csum_partial_copy_kernel((__force void *)src, dst,
	51	len, sum, err_ptr);
	52	else
	53	return __csum_partial_copy_from_user((__force void *)src, dst,
	54	len, sum, err_ptr);
f860c90b	55	}
1da177e4	56
c2d85bc1 LY	57	#define _HAVE_ARCH_COPY_AND_CSUM_FROM_USER
	58	static inline
	59	__wsum csum_and_copy_from_user(const void __user src, void dst,
	60	int len, __wsum sum, int *err_ptr)
	61	{
	62	if (access_ok(VERIFY_READ, src, len))
	63	return csum_partial_copy_from_user(src, dst, len, sum,
	64	err_ptr);
	65	if (len)
	66	*err_ptr = -EFAULT;
	67
	68	return sum;
	69	}
	70
1da177e4 LT	71	/*
	72	* Copy and checksum to user
	73	*/
	74	#define HAVE_CSUM_COPY_USER
f860c90b AN	75	static inline
	76	__wsum csum_and_copy_to_user(const void src, void __user dst, int len,
	77	__wsum sum, int *err_ptr)
1da177e4	78	{
ef41f460	79	might_fault();
fb316913 LY	80	if (access_ok(VERIFY_WRITE, dst, len)) {
	81	if (segment_eq(get_fs(), get_ds()))
	82	return __csum_partial_copy_kernel(src,
	83	(__force void *)dst,
	84	len, sum, err_ptr);
	85	else
	86	return __csum_partial_copy_to_user(src,
	87	(__force void *)dst,
	88	len, sum, err_ptr);
	89	}
f860c90b	90	if (len)
1da177e4	91	*err_ptr = -EFAULT;
1da177e4	92
f860c90b	93	return (__force __wsum)-1; /* invalid checksum */
1da177e4 LT	94	}
	95
	96	/*
	97	* the same as csum_partial, but copies from user space (but on MIPS
	98	* we have just one address space, so this is identical to the above)
	99	*/
8e3d8433 AV	100	__wsum csum_partial_copy_nocheck(const void src, void dst,
8e3d8433 AV	101	int len, __wsum sum);
1da177e4 LT	102
	103	/*
	104	* Fold a partial checksum without adding pseudo headers
	105	*/
8e3d8433	106	static inline __sum16 csum_fold(__wsum sum)
1da177e4 LT	107	{
1da177e4 LT	108	__asm__(
04988d6f TS	109	" .set push # csum_fold\n"
	110	" .set noat \n"
	111	" sll $1, %0, 16 \n"
	112	" addu %0, $1 \n"
	113	" sltu $1, %0, $1 \n"
	114	" srl %0, %0, 16 \n"
	115	" addu %0, $1 \n"
	116	" xori %0, 0xffff \n"
	117	" .set pop"
1da177e4 LT	118	: "=r" (sum)
	119	: "0" (sum));
	120
8e3d8433	121	return (__force __sum16)sum;
1da177e4 LT	122	}
	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	}
	161
8e3d8433 AV	162	static inline __wsum csum_tcpudp_nofold(__be32 saddr,
	163	__be32 daddr, unsigned short len, unsigned short proto,
	164	__wsum sum)
1da177e4 LT	165	{
1da177e4 LT	166	__asm__(
04988d6f TS	167	" .set push # csum_tcpudp_nofold\n"
04988d6f TS	168	" .set noat \n"
875d43e7	169	#ifdef CONFIG_32BIT
04988d6f TS	170	" addu %0, %2 \n"
	171	" sltu $1, %0, %2 \n"
	172	" addu %0, $1 \n"
1da177e4	173
04988d6f TS	174	" addu %0, %3 \n"
	175	" sltu $1, %0, %3 \n"
	176	" addu %0, $1 \n"
1da177e4	177
04988d6f TS	178	" addu %0, %4 \n"
	179	" sltu $1, %0, %4 \n"
	180	" addu %0, $1 \n"
1da177e4	181	#endif
875d43e7	182	#ifdef CONFIG_64BIT
04988d6f TS	183	" daddu %0, %2 \n"
	184	" daddu %0, %3 \n"
	185	" daddu %0, %4 \n"
	186	" dsll32 $1, %0, 0 \n"
	187	" daddu %0, $1 \n"
e9728838	188	" dsra32 %0, %0, 0 \n"
1da177e4	189	#endif
04988d6f	190	" .set pop"
1da177e4	191	: "=r" (sum)
66218da2 AN	192	: "0" ((__force unsigned long)daddr),
66218da2 AN	193	"r" ((__force unsigned long)saddr),
1da177e4	194	#ifdef __MIPSEL__
8e3d8433	195	"r" ((proto + len) << 8),
1da177e4	196	#else
8e3d8433	197	"r" (proto + len),
1da177e4	198	#endif
1d464c26	199	"r" ((__force unsigned long)sum));
1da177e4 LT	200
	201	return sum;
	202	}
	203
	204	/*
	205	* computes the checksum of the TCP/UDP pseudo-header
	206	* returns a 16-bit checksum, already complemented
	207	*/
8e3d8433	208	static inline __sum16 csum_tcpudp_magic(__be32 saddr, __be32 daddr,
1da177e4 LT	209	unsigned short len,
1da177e4 LT	210	unsigned short proto,
8e3d8433	211	__wsum sum)
1da177e4 LT	212	{
	213	return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
	214	}
	215
	216	/*
	217	* this routine is used for miscellaneous IP-like checksums, mainly
	218	* in icmp.c
	219	*/
8e3d8433	220	static inline __sum16 ip_compute_csum(const void *buff, int len)
1da177e4 LT	221	{
	222	return csum_fold(csum_partial(buff, len, 0));
	223	}
	224
	225	#define _HAVE_ARCH_IPV6_CSUM
8e3d8433	226	static __inline__ __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
70342287	227	const struct in6_addr *daddr,
8e3d8433 AV	228	__u32 len, unsigned short proto,
8e3d8433 AV	229	__wsum sum)
1da177e4 LT	230	{
1da177e4 LT	231	__asm__(
04988d6f TS	232	" .set push # csum_ipv6_magic\n"
	233	" .set noreorder \n"
	234	" .set noat \n"
	235	" addu %0, %5 # proto (long in network byte order)\n"
	236	" sltu $1, %0, %5 \n"
	237	" addu %0, $1 \n"
	238
	239	" addu %0, %6 # csum\n"
	240	" sltu $1, %0, %6 \n"
	241	" lw %1, 0(%2) # four words source address\n"
	242	" addu %0, $1 \n"
	243	" addu %0, %1 \n"
	244	" sltu $1, %0, %1 \n"
	245
	246	" lw %1, 4(%2) \n"
	247	" addu %0, $1 \n"
	248	" addu %0, %1 \n"
	249	" sltu $1, %0, %1 \n"
	250
	251	" lw %1, 8(%2) \n"
	252	" addu %0, $1 \n"
	253	" addu %0, %1 \n"
	254	" sltu $1, %0, %1 \n"
	255
	256	" lw %1, 12(%2) \n"
	257	" addu %0, $1 \n"
	258	" addu %0, %1 \n"
	259	" sltu $1, %0, %1 \n"
	260
	261	" lw %1, 0(%3) \n"
	262	" addu %0, $1 \n"
	263	" addu %0, %1 \n"
	264	" sltu $1, %0, %1 \n"
	265
	266	" lw %1, 4(%3) \n"
	267	" addu %0, $1 \n"
	268	" addu %0, %1 \n"
	269	" sltu $1, %0, %1 \n"
	270
	271	" lw %1, 8(%3) \n"
	272	" addu %0, $1 \n"
	273	" addu %0, %1 \n"
	274	" sltu $1, %0, %1 \n"
	275
	276	" lw %1, 12(%3) \n"
	277	" addu %0, $1 \n"
	278	" addu %0, %1 \n"
	279	" sltu $1, %0, %1 \n"
	280
	281	" addu %0, $1 # Add final carry\n"
	282	" .set pop"
1da177e4 LT	283	: "=r" (sum), "=r" (proto)
	284	: "r" (saddr), "r" (daddr),
	285	"0" (htonl(len)), "1" (htonl(proto)), "r" (sum));
	286
	287	return csum_fold(sum);
	288	}
	289
	290	#endif /* _ASM_CHECKSUM_H */