[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / s390 / include / asm / checksum.h

/*
 *    S390 fast network checksum routines
 *
 *  S390 version
 *    Copyright IBM Corp. 1999
 *    Author(s): Ulrich Hild        (first version)
 *               Martin Schwidefsky (heavily optimized CKSM version)
 *               D.J. Barrow        (third attempt) 
 */

#ifndef _S390_CHECKSUM_H
#define _S390_CHECKSUM_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
 */
static inline __wsum
csum_partial(const void *buff, int len, __wsum sum)
{
	register unsigned long reg2 asm("2") = (unsigned long) buff;
	register unsigned long reg3 asm("3") = (unsigned long) len;

	asm volatile(
		"0:	cksm	%0,%1\n"	/* do checksum on longs */
		"	jo	0b\n"
		: "+d" (sum), "+d" (reg2), "+d" (reg3) : : "cc", "memory");
	return sum;
}

/*
 * the same as csum_partial_copy, but copies from user space.
 *
 * here even more important to align src and dst on a 32-bit (or even
 * better 64-bit) boundary
 *
 * Copy from userspace and compute checksum.  If we catch an exception
 * then zero 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)
{
	int missing;

	missing = copy_from_user(dst, src, len);
	if (missing) {
		memset(dst + len - missing, 0, missing);
		*err_ptr = -EFAULT;
	}
		
	return csum_partial(dst, len, sum);
}


static inline __wsum
csum_partial_copy_nocheck (const void *src, void *dst, int len, __wsum sum)
{
        memcpy(dst,src,len);
	return csum_partial(dst, len, sum);
}

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

	csum += (csum >> 16) + (csum << 16);
	csum >>= 16;
	return (__force __sum16) ~csum;
}

/*
 *	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)
{
	return csum_fold(csum_partial(iph, ihl*4, 0));
}

/*
 * computes the checksum of the TCP/UDP pseudo-header
 * returns a 32-bit checksum
 */
static inline __wsum
csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
                   unsigned short len, unsigned short proto,
                   __wsum sum)
{
	__u32 csum = (__force __u32)sum;

	csum += (__force __u32)saddr;
	if (csum < (__force __u32)saddr)
		csum++;

	csum += (__force __u32)daddr;
	if (csum < (__force __u32)daddr)
		csum++;

	csum += len + proto;
	if (csum < len + proto)
		csum++;

	return (__force __wsum)csum;
}

/*
 * 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));
}

#endif /* _S390_CHECKSUM_H */
Commit	Line	Data
1da177e4	1	/*
1da177e4	2	* S390 fast network checksum routines
1da177e4 LT	3	*
1da177e4 LT	4	* S390 version
a53c8fab	5	* Copyright IBM Corp. 1999
1da177e4 LT	6	* Author(s): Ulrich Hild (first version)
	7	* Martin Schwidefsky (heavily optimized CKSM version)
	8	* D.J. Barrow (third attempt)
	9	*/
	10
a53c8fab HC	11	#ifndef _S390_CHECKSUM_H
	12	#define _S390_CHECKSUM_H
	13
1da177e4 LT	14	#include <asm/uaccess.h>
	15
	16	/*
	17	* computes the checksum of a memory block at buff, length len,
	18	* and adds in "sum" (32-bit)
	19	*
	20	* returns a 32-bit number suitable for feeding into itself
	21	* or csum_tcpudp_magic
	22	*
	23	* this function must be called with even lengths, except
	24	* for the last fragment, which may be odd
	25	*
	26	* it's best to have buff aligned on a 32-bit boundary
	27	*/
f994aae1 AV	28	static inline __wsum
f994aae1 AV	29	csum_partial(const void *buff, int len, __wsum sum)
1da177e4	30	{
94c12cc7 MS	31	register unsigned long reg2 asm("2") = (unsigned long) buff;
94c12cc7 MS	32	register unsigned long reg3 asm("3") = (unsigned long) len;
1da177e4	33
94c12cc7 MS	34	asm volatile(
	35	"0: cksm %0,%1\n" /* do checksum on longs */
	36	" jo 0b\n"
	37	: "+d" (sum), "+d" (reg2), "+d" (reg3) : : "cc", "memory");
1da177e4 LT	38	return sum;
	39	}
	40
	41	/*
	42	* the same as csum_partial_copy, but copies from user space.
	43	*
	44	* here even more important to align src and dst on a 32-bit (or even
	45	* better 64-bit) boundary
	46	*
	47	* Copy from userspace and compute checksum. If we catch an exception
	48	* then zero the rest of the buffer.
	49	*/
f994aae1 AV	50	static inline __wsum
	51	csum_partial_copy_from_user(const void __user src, void dst,
	52	int len, __wsum sum,
1da177e4 LT	53	int *err_ptr)
	54	{
	55	int missing;
	56
	57	missing = copy_from_user(dst, src, len);
	58	if (missing) {
	59	memset(dst + len - missing, 0, missing);
	60	*err_ptr = -EFAULT;
	61	}
	62
	63	return csum_partial(dst, len, sum);
	64	}
	65
	66
f994aae1 AV	67	static inline __wsum
f994aae1 AV	68	csum_partial_copy_nocheck (const void src, void dst, int len, __wsum sum)
1da177e4 LT	69	{
1da177e4 LT	70	memcpy(dst,src,len);
94c12cc7	71	return csum_partial(dst, len, sum);
1da177e4 LT	72	}
	73
	74	/*
	75	* Fold a partial checksum without adding pseudo headers
	76	*/
f994aae1	77	static inline __sum16 csum_fold(__wsum sum)
1da177e4	78	{
04efc3be	79	u32 csum = (__force u32) sum;
1da177e4	80
04efc3be HC	81	csum += (csum >> 16) + (csum << 16);
	82	csum >>= 16;
	83	return (__force __sum16) ~csum;
1da177e4 LT	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	*
	90	*/
f994aae1	91	static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl)
1da177e4	92	{
94c12cc7	93	return csum_fold(csum_partial(iph, ihl*4, 0));
1da177e4 LT	94	}
	95
	96	/*
	97	* computes the checksum of the TCP/UDP pseudo-header
	98	* returns a 32-bit checksum
	99	*/
f994aae1 AV	100	static inline __wsum
f994aae1 AV	101	csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
1da177e4	102	unsigned short len, unsigned short proto,
f994aae1	103	__wsum sum)
1da177e4	104	{
afbc1e99 HC	105	__u32 csum = (__force __u32)sum;
	106
	107	csum += (__force __u32)saddr;
	108	if (csum < (__force __u32)saddr)
	109	csum++;
	110
	111	csum += (__force __u32)daddr;
	112	if (csum < (__force __u32)daddr)
	113	csum++;
	114
	115	csum += len + proto;
	116	if (csum < len + proto)
	117	csum++;
	118
	119	return (__force __wsum)csum;
1da177e4 LT	120	}
	121
	122	/*
	123	* computes the checksum of the TCP/UDP pseudo-header
	124	* returns a 16-bit checksum, already complemented
	125	*/
	126
f994aae1 AV	127	static inline __sum16
f994aae1 AV	128	csum_tcpudp_magic(__be32 saddr, __be32 daddr,
1da177e4	129	unsigned short len, unsigned short proto,
f994aae1	130	__wsum sum)
1da177e4 LT	131	{
	132	return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
	133	}
	134
	135	/*
	136	* this routine is used for miscellaneous IP-like checksums, mainly
	137	* in icmp.c
	138	*/
	139
f994aae1	140	static inline __sum16 ip_compute_csum(const void *buff, int len)
1da177e4 LT	141	{
	142	return csum_fold(csum_partial(buff, len, 0));
	143	}
	144
	145	#endif /* _S390_CHECKSUM_H */
	146
	147