patch-1.3.7 linux/arch/alpha/lib/checksum.c

• Lines: 169
• Date: Thu Jul 6 13:22:04 1995
• Orig file: v1.3.6/linux/arch/alpha/lib/checksum.c
• Orig date: Fri Jun 16 22:02:54 1995

diff -u --recursive --new-file v1.3.6/linux/arch/alpha/lib/checksum.c linux/arch/alpha/lib/checksum.c
@@ -4,15 +4,22 @@
  * This file contains network checksum routines that are better done
  * in an architecture-specific manner due to speed..
  */
+ 
+#include <linux/string.h>
 
-/*
- *	This is a version of ip_compute_csum() optimized for IP headers,
- *	which always checksum on 4 octet boundaries.
- */
-unsigned short ip_fast_csum(unsigned char * iph, unsigned int ihl)
+#include <asm/byteorder.h>
+
+static inline unsigned short from64to16(unsigned long x)
 {
-	/* not yet */
-	return 0;
+	/* add up 32-bit words for 33 bits */
+	x = (x & 0xffffffff) + (x >> 32);
+	/* add up 16-bit and 17-bit words for 17+c bits */
+	x = (x & 0xffff) + (x >> 16);
+	/* add up 16-bit and 2-bit for 16+c bit */
+	x = (x & 0xffff) + (x >> 16);
+	/* add up carry.. */
+	x = (x & 0xffff) + (x >> 16);
+	return x;
 }
 
 /*
@@ -25,8 +32,84 @@
 				   unsigned short proto,
 				   unsigned int sum)
 {
-	/* not yet */
-	return 0;
+	return ~from64to16(saddr + daddr + sum + (ntohs(len) << 16) + (proto << 8));
+}
+
+/*
+ * Do a 64-bit checksum on an arbitrary memory area..
+ *
+ * This isn't a great routine, but it's not _horrible_ either. The
+ * inner loop could be unrolled a bit further, and there are better
+ * ways to do the carry, but this is reasonable.
+ */
+static inline unsigned long do_csum(unsigned char * buff, int len)
+{
+	int odd, count;
+	unsigned long result = 0;
+
+	if (len <= 0)
+		goto out;
+	odd = 1 & (unsigned long) buff;
+	if (odd) {
+		result = *buff << 8;
+		len--;
+		buff++;
+	}
+	count = len >> 1;		/* nr of 16-bit words.. */
+	if (count) {
+		if (2 & (unsigned long) buff) {
+			result += *(unsigned short *) buff;
+			count--;
+			len -= 2;
+			buff += 2;
+		}
+		count >>= 1;		/* nr of 32-bit words.. */
+		if (count) {
+			if (4 & (unsigned long) buff) {
+				result += *(unsigned int *) buff;
+				count--;
+				len -= 4;
+				buff += 4;
+			}
+			count >>= 1;	/* nr of 64-bit words.. */
+			if (count) {
+				unsigned long carry = 0;
+				do {
+					unsigned long w = *(unsigned long *) buff;
+					count--;
+					buff += 8;
+					result += carry;
+					result += w;
+					carry = (w > result);
+				} while (count);
+				result += carry;
+			}
+			if (len & 4) {
+				result += *(unsigned int *) buff;
+				buff += 4;
+			}
+		}
+		if (len & 2) {
+			result += *(unsigned short *) buff;
+			buff += 2;
+		}
+	}
+	if (len & 1)
+		result += *buff;
+	result = from64to16(result);
+	if (odd)
+		result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
+out:
+	return result;
+}
+
+/*
+ *	This is a version of ip_compute_csum() optimized for IP headers,
+ *	which always checksum on 4 octet boundaries.
+ */
+unsigned short ip_fast_csum(unsigned char * iph, unsigned int ihl)
+{
+	return ~do_csum(iph,ihl*4);
 }
 
 /*
@@ -43,31 +126,42 @@
  */
 unsigned int csum_partial(unsigned char * buff, int len, unsigned int sum)
 {
-	/* not yet */
-	return 0;
+	unsigned long result = do_csum(buff, len);
+
+	/* add in old sum, and carry.. */
+	result += sum;
+	/* 32+c bits -> 32 bits */
+	result = (result & 0xffffffff) + (result >> 32);
+	return result;
 }
 
 /*
- * the same as csum_partial, but copies from fs:src while it
+ * the same as csum_partial, but copies from src while it
  * checksums
  *
  * here even more important to align src and dst on a 32-bit (or even
  * better 64-bit) boundary
  */
 
-unsigned int csum_partial_copyffs( char *src, char *dst, int len, int sum)
+unsigned int csum_partial_copy(char *src, char *dst, int len, int sum)
 {
-	/* not yet */
-	return 0;
+	/*
+	 * The whole idea is to do the copy and the checksum at
+	 * the same time, but we do it the easy way now.
+	 *
+	 * At least csum on the source, not destination, for cache
+	 * reasons..
+	 */
+	sum = csum_partial(src, len, sum);
+	memcpy(dst, src, len);
+	return sum;
 }
 
-
 /*
  * this routine is used for miscellaneous IP-like checksums, mainly
  * in icmp.c
  */
 unsigned short ip_compute_csum(unsigned char * buff, int len)
 {
-	/* not yet */
-	return 0;
+	return ~from64to16(do_csum(buff,len));
 }