[mirror_ubuntu-zesty-kernel.git] / arch / xtensa / include / asm / 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 <linux/uaccess.h>
#include <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)
		: "memory");

	return	csum_fold(sum);
}

static __inline__ __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
					    __u32 len, __u8 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,
					    __u32 len, __u8 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, __u8 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)
		: "memory");

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