aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--arch/microblaze/include/asm/checksum.h98
-rw-r--r--arch/microblaze/lib/checksum.c163
2 files changed, 261 insertions, 0 deletions
diff --git a/arch/microblaze/include/asm/checksum.h b/arch/microblaze/include/asm/checksum.h
new file mode 100644
index 000000000000..92b30762ce59
--- /dev/null
+++ b/arch/microblaze/include/asm/checksum.h
@@ -0,0 +1,98 @@
1/*
2 * Copyright (C) 2008 Michal Simek <monstr@monstr.eu>
3 * Copyright (C) 2006 Atmark Techno, Inc.
4 *
5 * This file is subject to the terms and conditions of the GNU General Public
6 * License. See the file "COPYING" in the main directory of this archive
7 * for more details.
8 */
9
10#ifndef _ASM_MICROBLAZE_CHECKSUM_H
11#define _ASM_MICROBLAZE_CHECKSUM_H
12
13#include <linux/in6.h>
14
15/*
16 * computes the checksum of the TCP/UDP pseudo-header
17 * returns a 16-bit checksum, already complemented
18 */
19static inline __wsum
20csum_tcpudp_nofold(__be32 saddr, __be32 daddr, unsigned short len,
21 unsigned short proto, __wsum sum)
22{
23 __asm__("add %0, %0, %1\n\t"
24 "addc %0, %0, %2\n\t"
25 "addc %0, %0, %3\n\t"
26 "addc %0, %0, r0\n\t"
27 : "+&d" (sum)
28 : "d" (saddr), "d" (daddr), "d" (len + proto));
29
30 return sum;
31}
32
33/*
34 * computes the checksum of a memory block at buff, length len,
35 * and adds in "sum" (32-bit)
36 *
37 * returns a 32-bit number suitable for feeding into itself
38 * or csum_tcpudp_magic
39 *
40 * this function must be called with even lengths, except
41 * for the last fragment, which may be odd
42 *
43 * it's best to have buff aligned on a 32-bit boundary
44 */
45extern __wsum csum_partial(const void *buff, int len, __wsum sum);
46
47/*
48 * the same as csum_partial, but copies from src while it
49 * checksums
50 *
51 * here even more important to align src and dst on a 32-bit (or even
52 * better 64-bit) boundary
53 */
54extern __wsum csum_partial_copy(const char *src, char *dst, int len, int sum);
55
56/*
57 * the same as csum_partial_copy, but copies from user space.
58 *
59 * here even more important to align src and dst on a 32-bit (or even
60 * better 64-bit) boundary
61 */
62extern __wsum csum_partial_copy_from_user(const char *src, char *dst,
63 int len, int sum, int *csum_err);
64
65#define csum_partial_copy_nocheck(src, dst, len, sum) \
66 csum_partial_copy((src), (dst), (len), (sum))
67
68/*
69 * This is a version of ip_compute_csum() optimized for IP headers,
70 * which always checksum on 4 octet boundaries.
71 *
72 */
73extern __sum16 ip_fast_csum(const void *iph, unsigned int ihl);
74
75/*
76 * Fold a partial checksum
77 */
78static inline __sum16 csum_fold(unsigned int sum)
79{
80 sum = (sum & 0xffff) + (sum >> 16);
81 sum = (sum & 0xffff) + (sum >> 16);
82 return ~sum;
83}
84
85static inline __sum16
86csum_tcpudp_magic(__be32 saddr, __be32 daddr, unsigned short len,
87 unsigned short proto, __wsum sum)
88{
89 return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
90}
91
92/*
93 * this routine is used for miscellaneous IP-like checksums, mainly
94 * in icmp.c
95 */
96extern __sum16 ip_compute_csum(const unsigned char *buff, int len);
97
98#endif /* _ASM_MICROBLAZE_CHECKSUM_H */
diff --git a/arch/microblaze/lib/checksum.c b/arch/microblaze/lib/checksum.c
new file mode 100644
index 000000000000..809340070a13
--- /dev/null
+++ b/arch/microblaze/lib/checksum.c
@@ -0,0 +1,163 @@
1/*
2 *
3 * INET An implementation of the TCP/IP protocol suite for the LINUX
4 * operating system. INET is implemented using the BSD Socket
5 * interface as the means of communication with the user level.
6 *
7 * IP/TCP/UDP checksumming routines
8 *
9 * Authors: Jorge Cwik, <jorge@laser.satlink.net>
10 * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
11 * Tom May, <ftom@netcom.com>
12 * Andreas Schwab, <schwab@issan.informatik.uni-dortmund.de>
13 * Lots of code moved from tcp.c and ip.c; see those files
14 * for more names.
15 *
16 * 03/02/96 Jes Sorensen, Andreas Schwab, Roman Hodek:
17 * Fixed some nasty bugs, causing some horrible crashes.
18 * A: At some points, the sum (%0) was used as
19 * length-counter instead of the length counter
20 * (%1). Thanks to Roman Hodek for pointing this out.
21 * B: GCC seems to mess up if one uses too many
22 * data-registers to hold input values and one tries to
23 * specify d0 and d1 as scratch registers. Letting gcc
24 * choose these registers itself solves the problem.
25 *
26 * This program is free software; you can redistribute it and/or
27 * modify it under the terms of the GNU General Public License
28 * as published by the Free Software Foundation; either version
29 * 2 of the License, or (at your option) any later version.
30 */
31
32/* Revised by Kenneth Albanowski for m68knommu. Basic problem: unaligned access
33 kills, so most of the assembly has to go. */
34
35#include <net/checksum.h>
36#include <asm/checksum.h>
37#include <linux/module.h>
38
39static inline unsigned short from32to16(unsigned long x)
40{
41 /* add up 16-bit and 16-bit for 16+c bit */
42 x = (x & 0xffff) + (x >> 16);
43 /* add up carry.. */
44 x = (x & 0xffff) + (x >> 16);
45 return x;
46}
47
48static unsigned int do_csum(const unsigned char *buff, int len)
49{
50 int odd, count;
51 unsigned long result = 0;
52
53 if (len <= 0)
54 goto out;
55 odd = 1 & (unsigned long) buff;
56 if (odd) {
57 result = *buff;
58 len--;
59 buff++;
60 }
61 count = len >> 1; /* nr of 16-bit words.. */
62 if (count) {
63 if (2 & (unsigned long) buff) {
64 result += *(unsigned short *) buff;
65 count--;
66 len -= 2;
67 buff += 2;
68 }
69 count >>= 1; /* nr of 32-bit words.. */
70 if (count) {
71 unsigned long carry = 0;
72 do {
73 unsigned long w = *(unsigned long *) buff;
74 count--;
75 buff += 4;
76 result += carry;
77 result += w;
78 carry = (w > result);
79 } while (count);
80 result += carry;
81 result = (result & 0xffff) + (result >> 16);
82 }
83 if (len & 2) {
84 result += *(unsigned short *) buff;
85 buff += 2;
86 }
87 }
88 if (len & 1)
89 result += (*buff << 8);
90 result = from32to16(result);
91 if (odd)
92 result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
93out:
94 return result;
95}
96
97/*
98 * This is a version of ip_compute_csum() optimized for IP headers,
99 * which always checksum on 4 octet boundaries.
100 */
101__sum16 ip_fast_csum(const void *iph, unsigned int ihl)
102{
103 return (__force __sum16)~do_csum(iph, ihl*4);
104}
105
106/*
107 * computes the checksum of a memory block at buff, length len,
108 * and adds in "sum" (32-bit)
109 *
110 * returns a 32-bit number suitable for feeding into itself
111 * or csum_tcpudp_magic
112 *
113 * this function must be called with even lengths, except
114 * for the last fragment, which may be odd
115 *
116 * it's best to have buff aligned on a 32-bit boundary
117 */
118__wsum csum_partial(const void *buff, int len, __wsum sum)
119{
120 unsigned int result = do_csum(buff, len);
121
122 /* add in old sum, and carry.. */
123 result += sum;
124 if (sum > result)
125 result += 1;
126 return result;
127}
128EXPORT_SYMBOL(csum_partial);
129
130/*
131 * this routine is used for miscellaneous IP-like checksums, mainly
132 * in icmp.c
133 */
134__sum16 ip_compute_csum(const unsigned char *buff, int len)
135{
136 return ~do_csum(buff, len);
137}
138EXPORT_SYMBOL(ip_compute_csum);
139
140/*
141 * copy from fs while checksumming, otherwise like csum_partial
142 */
143__wsum
144csum_partial_copy_from_user(const char __user *src, char *dst, int len,
145 int sum, int *csum_err)
146{
147 if (csum_err)
148 *csum_err = 0;
149 memcpy(dst, src, len);
150 return csum_partial(dst, len, sum);
151}
152EXPORT_SYMBOL(csum_partial_copy_from_user);
153
154/*
155 * copy from ds while checksumming, otherwise like csum_partial
156 */
157__wsum
158csum_partial_copy(const char *src, char *dst, int len, int sum)
159{
160 memcpy(dst, src, len);
161 return csum_partial(dst, len, sum);
162}
163EXPORT_SYMBOL(csum_partial_copy);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-21 21:34:26 -0500