Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * arch/alpha/lib/checksum.c | |
4 | * | |
5 | * This file contains network checksum routines that are better done | |
6 | * in an architecture-specific manner due to speed.. | |
7 | * Comments in other versions indicate that the algorithms are from RFC1071 | |
8 | * | |
c3a2ddee | 9 | * accelerated versions (and 21264 assembly versions ) contributed by |
1da177e4 LT |
10 | * Rick Gorton <rick.gorton@alpha-processor.com> |
11 | */ | |
12 | ||
13 | #include <linux/module.h> | |
14 | #include <linux/string.h> | |
6e8d0237 | 15 | #include <net/checksum.h> |
1da177e4 LT |
16 | |
17 | #include <asm/byteorder.h> | |
0069455b | 18 | #include <asm/checksum.h> |
1da177e4 LT |
19 | |
20 | static inline unsigned short from64to16(unsigned long x) | |
21 | { | |
22 | /* Using extract instructions is a bit more efficient | |
23 | than the original shift/bitmask version. */ | |
24 | ||
25 | union { | |
26 | unsigned long ul; | |
27 | unsigned int ui[2]; | |
28 | unsigned short us[4]; | |
29 | } in_v, tmp_v, out_v; | |
30 | ||
31 | in_v.ul = x; | |
32 | tmp_v.ul = (unsigned long) in_v.ui[0] + (unsigned long) in_v.ui[1]; | |
33 | ||
34 | /* Since the bits of tmp_v.sh[3] are going to always be zero, | |
35 | we don't have to bother to add that in. */ | |
36 | out_v.ul = (unsigned long) tmp_v.us[0] + (unsigned long) tmp_v.us[1] | |
37 | + (unsigned long) tmp_v.us[2]; | |
38 | ||
39 | /* Similarly, out_v.us[2] is always zero for the final add. */ | |
40 | return out_v.us[0] + out_v.us[1]; | |
41 | } | |
42 | ||
43 | /* | |
44 | * computes the checksum of the TCP/UDP pseudo-header | |
45 | * returns a 16-bit checksum, already complemented. | |
46 | */ | |
9be259aa | 47 | __sum16 csum_tcpudp_magic(__be32 saddr, __be32 daddr, |
01cfbad7 | 48 | __u32 len, __u8 proto, __wsum sum) |
1da177e4 | 49 | { |
9be259aa AV |
50 | return (__force __sum16)~from64to16( |
51 | (__force u64)saddr + (__force u64)daddr + | |
52 | (__force u64)sum + ((len + proto) << 8)); | |
1da177e4 | 53 | } |
00fc0e0d | 54 | EXPORT_SYMBOL(csum_tcpudp_magic); |
1da177e4 | 55 | |
9be259aa | 56 | __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr, |
01cfbad7 | 57 | __u32 len, __u8 proto, __wsum sum) |
1da177e4 LT |
58 | { |
59 | unsigned long result; | |
60 | ||
9be259aa AV |
61 | result = (__force u64)saddr + (__force u64)daddr + |
62 | (__force u64)sum + ((len + proto) << 8); | |
1da177e4 LT |
63 | |
64 | /* Fold down to 32-bits so we don't lose in the typedef-less | |
65 | network stack. */ | |
66 | /* 64 to 33 */ | |
67 | result = (result & 0xffffffff) + (result >> 32); | |
68 | /* 33 to 32 */ | |
69 | result = (result & 0xffffffff) + (result >> 32); | |
9be259aa | 70 | return (__force __wsum)result; |
1da177e4 | 71 | } |
547c178b | 72 | EXPORT_SYMBOL(csum_tcpudp_nofold); |
1da177e4 LT |
73 | |
74 | /* | |
75 | * Do a 64-bit checksum on an arbitrary memory area.. | |
76 | * | |
77 | * This isn't a great routine, but it's not _horrible_ either. The | |
78 | * inner loop could be unrolled a bit further, and there are better | |
79 | * ways to do the carry, but this is reasonable. | |
80 | */ | |
81 | static inline unsigned long do_csum(const unsigned char * buff, int len) | |
82 | { | |
83 | int odd, count; | |
84 | unsigned long result = 0; | |
85 | ||
86 | if (len <= 0) | |
87 | goto out; | |
88 | odd = 1 & (unsigned long) buff; | |
89 | if (odd) { | |
90 | result = *buff << 8; | |
91 | len--; | |
92 | buff++; | |
93 | } | |
94 | count = len >> 1; /* nr of 16-bit words.. */ | |
95 | if (count) { | |
96 | if (2 & (unsigned long) buff) { | |
97 | result += *(unsigned short *) buff; | |
98 | count--; | |
99 | len -= 2; | |
100 | buff += 2; | |
101 | } | |
102 | count >>= 1; /* nr of 32-bit words.. */ | |
103 | if (count) { | |
104 | if (4 & (unsigned long) buff) { | |
105 | result += *(unsigned int *) buff; | |
106 | count--; | |
107 | len -= 4; | |
108 | buff += 4; | |
109 | } | |
110 | count >>= 1; /* nr of 64-bit words.. */ | |
111 | if (count) { | |
112 | unsigned long carry = 0; | |
113 | do { | |
114 | unsigned long w = *(unsigned long *) buff; | |
115 | count--; | |
116 | buff += 8; | |
117 | result += carry; | |
118 | result += w; | |
119 | carry = (w > result); | |
120 | } while (count); | |
121 | result += carry; | |
122 | result = (result & 0xffffffff) + (result >> 32); | |
123 | } | |
124 | if (len & 4) { | |
125 | result += *(unsigned int *) buff; | |
126 | buff += 4; | |
127 | } | |
128 | } | |
129 | if (len & 2) { | |
130 | result += *(unsigned short *) buff; | |
131 | buff += 2; | |
132 | } | |
133 | } | |
134 | if (len & 1) | |
135 | result += *buff; | |
136 | result = from64to16(result); | |
137 | if (odd) | |
138 | result = ((result >> 8) & 0xff) | ((result & 0xff) << 8); | |
139 | out: | |
140 | return result; | |
141 | } | |
142 | ||
143 | /* | |
144 | * This is a version of ip_compute_csum() optimized for IP headers, | |
145 | * which always checksum on 4 octet boundaries. | |
146 | */ | |
9be259aa | 147 | __sum16 ip_fast_csum(const void *iph, unsigned int ihl) |
1da177e4 | 148 | { |
9be259aa | 149 | return (__force __sum16)~do_csum(iph,ihl*4); |
1da177e4 | 150 | } |
00fc0e0d | 151 | EXPORT_SYMBOL(ip_fast_csum); |
1da177e4 LT |
152 | |
153 | /* | |
154 | * computes the checksum of a memory block at buff, length len, | |
155 | * and adds in "sum" (32-bit) | |
156 | * | |
157 | * returns a 32-bit number suitable for feeding into itself | |
158 | * or csum_tcpudp_magic | |
159 | * | |
160 | * this function must be called with even lengths, except | |
161 | * for the last fragment, which may be odd | |
162 | * | |
163 | * it's best to have buff aligned on a 32-bit boundary | |
164 | */ | |
9be259aa | 165 | __wsum csum_partial(const void *buff, int len, __wsum sum) |
1da177e4 LT |
166 | { |
167 | unsigned long result = do_csum(buff, len); | |
168 | ||
169 | /* add in old sum, and carry.. */ | |
9be259aa | 170 | result += (__force u32)sum; |
1da177e4 LT |
171 | /* 32+c bits -> 32 bits */ |
172 | result = (result & 0xffffffff) + (result >> 32); | |
9be259aa | 173 | return (__force __wsum)result; |
1da177e4 LT |
174 | } |
175 | ||
176 | EXPORT_SYMBOL(csum_partial); | |
177 | ||
178 | /* | |
179 | * this routine is used for miscellaneous IP-like checksums, mainly | |
180 | * in icmp.c | |
181 | */ | |
9be259aa | 182 | __sum16 ip_compute_csum(const void *buff, int len) |
1da177e4 | 183 | { |
9be259aa | 184 | return (__force __sum16)~from64to16(do_csum(buff,len)); |
1da177e4 | 185 | } |
00fc0e0d | 186 | EXPORT_SYMBOL(ip_compute_csum); |