[mirror_ubuntu-hirsute-kernel.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 (uaccess_kernel())
		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(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(dst, len)) {
		if (uaccess_kernel())
			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)
 */
#define _HAVE_ARCH_CSUM_AND_COPY
__wsum __csum_partial_copy_nocheck(const void *src, void *dst, int len, __wsum sum);
static inline __wsum csum_partial_copy_nocheck(const void *src, void *dst, int len)
{
	return __csum_partial_copy_nocheck(src, dst, len, 0);
}

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

	sum += (sum << 16);
	csum = (__force __wsum)(sum < (__force u32)csum);
	sum >>= 16;
	sum += (__force u32)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"
	"	sltu	$1, %0, $1	\n"
	"	dsra32	%0, %0, 0	\n"
	"	addu	%0, $1		\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();
db68ce10	53	if (uaccess_kernel())
fb316913 LY	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	{
96d4f267	66	if (access_ok(src, len))
c2d85bc1 LY	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();
96d4f267	84	if (access_ok(dst, len)) {
db68ce10	85	if (uaccess_kernel())
fb316913 LY	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	*/
6e41c585	104	#define _HAVE_ARCH_CSUM_AND_COPY
cc44c17b AV	105	__wsum __csum_partial_copy_nocheck(const void src, void dst, int len, __wsum sum);
	106	static inline __wsum csum_partial_copy_nocheck(const void src, void dst, int len)
	107	{
	108	return __csum_partial_copy_nocheck(src, dst, len, 0);
	109	}
1da177e4 LT	110
	111	/*
	112	* Fold a partial checksum without adding pseudo headers
	113	*/
d0f0f63a	114	static inline __sum16 csum_fold(__wsum csum)
1da177e4	115	{
cc480444	116	u32 sum = (__force u32)csum;
1da177e4	117
d0f0f63a	118	sum += (sum << 16);
ff711d67	119	csum = (__force __wsum)(sum < (__force u32)csum);
d0f0f63a	120	sum >>= 16;
ff711d67	121	sum += (__force u32)csum;
d0f0f63a RB	122
d0f0f63a RB	123	return (__force __sum16)~sum;
1da177e4	124	}
b4b5015a	125	#define csum_fold csum_fold
1da177e4 LT	126
	127	/*
	128	* This is a version of ip_compute_csum() optimized for IP headers,
	129	* which always checksum on 4 octet boundaries.
	130	*
	131	* By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by
	132	* Arnt Gulbrandsen.
	133	*/
8e3d8433	134	static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl)
1da177e4	135	{
8e3d8433 AV	136	const unsigned int *word = iph;
8e3d8433 AV	137	const unsigned int *stop = word + ihl;
1da177e4 LT	138	unsigned int csum;
	139	int carry;
	140
	141	csum = word[0];
	142	csum += word[1];
	143	carry = (csum < word[1]);
	144	csum += carry;
	145
	146	csum += word[2];
	147	carry = (csum < word[2]);
	148	csum += carry;
	149
	150	csum += word[3];
	151	carry = (csum < word[3]);
	152	csum += carry;
	153
	154	word += 4;
	155	do {
	156	csum += *word;
	157	carry = (csum < *word);
	158	csum += carry;
	159	word++;
	160	} while (word != stop);
	161
	162	return csum_fold(csum);
	163	}
b4b5015a	164	#define ip_fast_csum ip_fast_csum
1da177e4	165
01cfbad7 AD	166	static inline __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
	167	__u32 len, __u8 proto,
	168	__wsum sum)
1da177e4 LT	169	{
1da177e4 LT	170	__asm__(
04988d6f TS	171	" .set push # csum_tcpudp_nofold\n"
04988d6f TS	172	" .set noat \n"
875d43e7	173	#ifdef CONFIG_32BIT
04988d6f TS	174	" addu %0, %2 \n"
	175	" sltu $1, %0, %2 \n"
	176	" addu %0, $1 \n"
1da177e4	177
04988d6f TS	178	" addu %0, %3 \n"
	179	" sltu $1, %0, %3 \n"
	180	" addu %0, $1 \n"
1da177e4	181
04988d6f TS	182	" addu %0, %4 \n"
	183	" sltu $1, %0, %4 \n"
	184	" addu %0, $1 \n"
1da177e4	185	#endif
875d43e7	186	#ifdef CONFIG_64BIT
04988d6f TS	187	" daddu %0, %2 \n"
	188	" daddu %0, %3 \n"
	189	" daddu %0, %4 \n"
	190	" dsll32 $1, %0, 0 \n"
	191	" daddu %0, $1 \n"
66fd848c	192	" sltu $1, %0, $1 \n"
e9728838	193	" dsra32 %0, %0, 0 \n"
66fd848c	194	" addu %0, $1 \n"
1da177e4	195	#endif
04988d6f	196	" .set pop"
1da177e4	197	: "=r" (sum)
66218da2 AN	198	: "0" ((__force unsigned long)daddr),
66218da2 AN	199	"r" ((__force unsigned long)saddr),
1da177e4	200	#ifdef __MIPSEL__
8e3d8433	201	"r" ((proto + len) << 8),
1da177e4	202	#else
8e3d8433	203	"r" (proto + len),
1da177e4	204	#endif
1d464c26	205	"r" ((__force unsigned long)sum));
1da177e4 LT	206
	207	return sum;
	208	}
b4b5015a	209	#define csum_tcpudp_nofold csum_tcpudp_nofold
1da177e4	210
1da177e4 LT	211	/*
	212	* this routine is used for miscellaneous IP-like checksums, mainly
	213	* in icmp.c
	214	*/
8e3d8433	215	static inline __sum16 ip_compute_csum(const void *buff, int len)
1da177e4 LT	216	{
	217	return csum_fold(csum_partial(buff, len, 0));
	218	}
	219
	220	#define _HAVE_ARCH_IPV6_CSUM
8e3d8433	221	static __inline__ __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
70342287	222	const struct in6_addr *daddr,
1e940829	223	__u32 len, __u8 proto,
8e3d8433	224	__wsum sum)
1da177e4	225	{
20c82d93 DS	226	__wsum tmp;
20c82d93 DS	227
1da177e4	228	__asm__(
04988d6f TS	229	" .set push # csum_ipv6_magic\n"
	230	" .set noreorder \n"
	231	" .set noat \n"
	232	" addu %0, %5 # proto (long in network byte order)\n"
	233	" sltu $1, %0, %5 \n"
	234	" addu %0, $1 \n"
	235
	236	" addu %0, %6 # csum\n"
	237	" sltu $1, %0, %6 \n"
	238	" lw %1, 0(%2) # four words source address\n"
	239	" addu %0, $1 \n"
	240	" addu %0, %1 \n"
	241	" sltu $1, %0, %1 \n"
	242
	243	" lw %1, 4(%2) \n"
	244	" addu %0, $1 \n"
	245	" addu %0, %1 \n"
	246	" sltu $1, %0, %1 \n"
	247
	248	" lw %1, 8(%2) \n"
	249	" addu %0, $1 \n"
	250	" addu %0, %1 \n"
	251	" sltu $1, %0, %1 \n"
	252
	253	" lw %1, 12(%2) \n"
	254	" addu %0, $1 \n"
	255	" addu %0, %1 \n"
	256	" sltu $1, %0, %1 \n"
	257
	258	" lw %1, 0(%3) \n"
	259	" addu %0, $1 \n"
	260	" addu %0, %1 \n"
	261	" sltu $1, %0, %1 \n"
	262
	263	" lw %1, 4(%3) \n"
	264	" addu %0, $1 \n"
	265	" addu %0, %1 \n"
	266	" sltu $1, %0, %1 \n"
	267
	268	" lw %1, 8(%3) \n"
	269	" addu %0, $1 \n"
	270	" addu %0, %1 \n"
	271	" sltu $1, %0, %1 \n"
	272
	273	" lw %1, 12(%3) \n"
	274	" addu %0, $1 \n"
	275	" addu %0, %1 \n"
	276	" sltu $1, %0, %1 \n"
	277
	278	" addu %0, $1 # Add final carry\n"
	279	" .set pop"
20c82d93	280	: "=&r" (sum), "=&r" (tmp)
1da177e4	281	: "r" (saddr), "r" (daddr),
20c82d93	282	"0" (htonl(len)), "r" (htonl(proto)), "r" (sum));
1da177e4 LT	283
	284	return csum_fold(sum);
	285	}
	286
b4b5015a	287	#include <asm-generic/checksum.h>
4e0748f5	288	#endif /* CONFIG_GENERIC_CSUM */
b4b5015a	289
1da177e4	290	#endif /* _ASM_CHECKSUM_H */