1 /*
2 * arch/sh/lib/csum_parial.c
3 *
4 * This file contains network checksum routines that are better done
5 * in an architecture-specific manner due to speed..
6 */
7
8 #include <linux/config.h>
9 #include <linux/string.h>
10 #include <linux/errno.h>
11 #include <asm/byteorder.h>
12 #include <asm/uaccess.h>
13
14 #if 1
15 #define dprintk(x...)
16 #else
17 #define dprintk(x...) printk(x)
18 #endif
19
from64to16(unsigned long long x)20 static inline unsigned short from64to16(unsigned long long x)
21 {
22 /* add up 32-bit words for 33 bits */
23 x = (x & 0xffffffff) + (x >> 32);
24 /* add up 16-bit and 17-bit words for 17+c bits */
25 x = (x & 0xffff) + (x >> 16);
26 /* add up 16-bit and 2-bit for 16+c bit */
27 x = (x & 0xffff) + (x >> 16);
28 /* add up carry.. */
29 x = (x & 0xffff) + (x >> 16);
30 return x;
31 }
32
foldto16(unsigned long x)33 static inline unsigned short foldto16(unsigned long x)
34 {
35 /* add up 16-bit for 17 bits */
36 x = (x & 0xffff) + (x >> 16);
37 /* add up carry.. */
38 x = (x & 0xffff) + (x >> 16);
39 return x;
40 }
41
myfoldto16(unsigned long long x)42 static inline unsigned short myfoldto16(unsigned long long x)
43 {
44 /* Fold down to 32-bits so we don't loose in the typedef-less
45 network stack. */
46 /* 64 to 33 */
47 x = (x & 0xffffffff) + (x >> 32);
48 /* 33 to 32 */
49 x = (x & 0xffffffff) + (x >> 32);
50
51 /* add up 16-bit for 17 bits */
52 x = (x & 0xffff) + (x >> 16);
53 /* add up carry.. */
54 x = (x & 0xffff) + (x >> 16);
55 return x;
56 }
57
58 #define odd(x) ((x)&1)
59 /*
60 typedef unsigned short u16;
61 typedef unsigned u32;
62 */
63 #define U16(x) ntohs(x)
64
do_moronic_csum(const unsigned char * a16p,int cnt)65 static unsigned long do_moronic_csum(const unsigned char *a16p, int cnt)
66 {
67 u32 sum;
68 int oddb;
69
70 /* This algorithm is correct only for those values of cnt < 65536 */
71
72 oddb = odd(cnt);
73 cnt >>= 1; /* convert to a word count */
74 sum = 0; /* do a straight two's complement sum */
75 while (cnt--)
76 sum += U16(*a16p++);
77 if (oddb) /* pick up the odd byte */
78 sum += U16(*a16p++) & (u16) 0xFF00;
79 /* add in the sum of the `carry' bits, making this one's complement */
80 sum = (sum & (u32) 0xFFFF) + ((sum >> 16) & (u32) 0xFFFF);
81 if (sum & (u32) 0x10000) /* one last possible carry */
82 sum = (sum + 1) & (u32) 0xFFFF;
83 if (sum == (u32) 0xFFFF) /* remove the -0 ambiguity */
84 sum = (u32) 0;
85 return sum;
86
87 }
88
89 #if 0
90 static inline unsigned long do_csum(const unsigned char *buff, int len)
91 {
92 int odd, count;
93 unsigned long long result = 0;
94
95 if (len <= 0)
96 goto out;
97 odd = 1 & (unsigned long) buff;
98 if (odd) {
99 result = *buff << 8;
100 len--;
101 buff++;
102 }
103 count = len >> 1; /* nr of 16-bit words.. */
104 if (count) {
105 if (2 & (unsigned long) buff) {
106 result += *(unsigned short *) buff;
107 count--;
108 len -= 2;
109 buff += 2;
110 }
111 count >>= 1; /* nr of 32-bit words.. */
112 if (count) {
113 if (4 & (unsigned long) buff) {
114 result += *(unsigned int *) buff;
115 count--;
116 len -= 4;
117 buff += 4;
118 }
119 count >>= 1; /* nr of 64-bit words.. */
120 if (count) {
121 unsigned long carry = 0;
122 do {
123 unsigned long w =
124 *(unsigned long *) buff;
125 count--;
126 buff += 8;
127 result += carry;
128 result += w;
129 carry = (w > result);
130 } while (count);
131 result += carry;
132 result = (result & 0xffffffff) + (result >> 32);
133 }
134 if (len & 4) {
135 result += *(unsigned int *) buff;
136 buff += 4;
137 }
138 }
139 if (len & 2) {
140 result += *(unsigned short *) buff;
141 buff += 2;
142 }
143 }
144 if (len & 1)
145 result += *buff;
146 result = from64to16(result);
147 if (odd)
148 result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
149 out:
150 return result;
151 }
152
153 #else
154
do_csum(const unsigned char * buff,int len)155 static unsigned long do_csum(const unsigned char *buff, int len)
156 {
157 int odd, count;
158 unsigned long result = 0;
159
160 dprintk("do_csum buff %p, len %d (0x%x)\n", buff, len, len);
161 #ifdef DEBUG
162 for (i = 0; i < len; i++) {
163 if ((i % 26) == 0)
164 printk("\n");
165 printk("%02X ", buff[i]);
166 }
167 #endif
168
169 if (len <= 0)
170 goto out;
171
172 odd = 1 & (unsigned long) buff;
173 if (odd) {
174 result = *buff << 8;
175 len--;
176 buff++;
177 }
178 count = len >> 1; /* nr of 16-bit words.. */
179 if (count) {
180 if (2 & (unsigned long) buff) {
181 result += *(unsigned short *) buff;
182 count--;
183 len -= 2;
184 buff += 2;
185 }
186 count >>= 1; /* nr of 32-bit words.. */
187 if (count) {
188 unsigned long carry = 0;
189 do {
190 unsigned long w = *(unsigned long *) buff;
191 buff += 4;
192 count--;
193 result += carry;
194 result += w;
195 carry = (w > result);
196 } while (count);
197 result += carry;
198 result = (result & 0xffff) + (result >> 16);
199 }
200 if (len & 2) {
201 result += *(unsigned short *) buff;
202 buff += 2;
203 }
204 }
205 if (len & 1)
206 result += *buff;
207 result = foldto16(result);
208 if (odd)
209 result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
210
211 dprintk("\nCHECKSUM is 0x%x\n", result);
212
213 out:
214 return result;
215 }
216
217 #endif
218
219 /* computes the checksum of a memory block at buff, length len,
220 and adds in "sum" (32-bit) */
csum_partial(const unsigned char * buff,int len,unsigned int sum)221 unsigned int csum_partial(const unsigned char *buff, int len, unsigned int sum)
222 {
223 unsigned long long result = do_csum(buff, len);
224
225 /* add in old sum, and carry.. */
226 result += sum;
227 /* 32+c bits -> 32 bits */
228 result = (result & 0xffffffff) + (result >> 32);
229
230 dprintk("csum_partial, buff %p len %d sum 0x%x result=0x%016Lx\n",
231 buff, len, sum, result);
232
233 return result;
234 }
235
236 /* Copy while checksumming, otherwise like csum_partial. */
237 unsigned int
csum_partial_copy(const char * src,char * dst,int len,unsigned int sum)238 csum_partial_copy(const char *src, char *dst, int len, unsigned int sum)
239 {
240 sum = csum_partial(src, len, sum);
241 memcpy(dst, src, len);
242
243 return sum;
244 }
245
246 /* Copy from userspace and compute checksum. If we catch an exception
247 then zero the rest of the buffer. */
248 unsigned int
csum_partial_copy_from_user(const char * src,char * dst,int len,unsigned int sum,int * err_ptr)249 csum_partial_copy_from_user(const char *src, char *dst, int len,
250 unsigned int sum, int *err_ptr)
251 {
252 int missing;
253
254 dprintk
255 ("csum_partial_copy_from_user src %p, dest %p, len %d, sum %08x, err_ptr %p\n",
256 src, dst, len, sum, err_ptr);
257 missing = copy_from_user(dst, src, len);
258 dprintk(" access_ok %d\n", __access_ok((unsigned long) src, len));
259 dprintk(" missing %d\n", missing);
260 if (missing) {
261 memset(dst + len - missing, 0, missing);
262 *err_ptr = -EFAULT;
263 }
264
265 return csum_partial(dst, len, sum);
266 }
267
268 /* Copy to userspace and compute checksum. */
269 unsigned int
csum_partial_copy_to_user(const char * src,char * dst,int len,unsigned int sum,int * err_ptr)270 csum_partial_copy_to_user(const char *src, char *dst, int len,
271 unsigned int sum, int *err_ptr)
272 {
273 sum = csum_partial(src, len, sum);
274
275 if (copy_to_user(dst, src, len))
276 *err_ptr = -EFAULT;
277
278 return sum;
279 }
280
281 /*
282 * This is a version of ip_compute_csum() optimized for IP headers,
283 * which always checksum on 4 octet boundaries.
284 */
ip_fast_csum(unsigned char * iph,unsigned int ihl)285 unsigned short ip_fast_csum(unsigned char *iph, unsigned int ihl)
286 {
287 dprintk("ip_fast_csum %p,%d\n", iph, ihl);
288
289 return ~do_csum(iph, ihl * 4);
290 }
291
csum_tcpudp_nofold(unsigned long saddr,unsigned long daddr,unsigned short len,unsigned short proto,unsigned int sum)292 unsigned int csum_tcpudp_nofold(unsigned long saddr,
293 unsigned long daddr,
294 unsigned short len,
295 unsigned short proto, unsigned int sum)
296 {
297 unsigned long long result;
298
299 dprintk("ntohs(0x%x)=0x%x\n", 0xdead, ntohs(0xdead));
300 dprintk("htons(0x%x)=0x%x\n", 0xdead, htons(0xdead));
301
302 result = ((unsigned long long) saddr +
303 (unsigned long long) daddr +
304 (unsigned long long) sum +
305 ((unsigned long long) ntohs(len) << 16) +
306 ((unsigned long long) proto << 8));
307
308 /* Fold down to 32-bits so we don't loose in the typedef-less
309 network stack. */
310 /* 64 to 33 */
311 result = (result & 0xffffffff) + (result >> 32);
312 /* 33 to 32 */
313 result = (result & 0xffffffff) + (result >> 32);
314
315 dprintk("%s saddr %x daddr %x len %x proto %x sum %x result %08Lx\n",
316 __FUNCTION__, saddr, daddr, len, proto, sum, result);
317
318 return result;
319 }
320
321 // Post SIM:
322 unsigned int
csum_partial_copy_nocheck(const char * src,char * dst,int len,unsigned int sum)323 csum_partial_copy_nocheck(const char *src, char *dst, int len, unsigned int sum)
324 {
325 // unsigned dummy;
326 dprintk("csum_partial_copy_nocheck src %p dst %p len %d\n", src, dst,
327 len);
328
329 return csum_partial_copy(src, dst, len, sum);
330 }
331