Remove obsolete #include <linux/config.h>
[linux-3.10.git] / arch / i386 / lib / checksum.S
1 /*
2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
3  *              operating system.  INET is implemented using the  BSD Socket
4  *              interface as the means of communication with the user level.
5  *
6  *              IP/TCP/UDP checksumming routines
7  *
8  * Authors:     Jorge Cwik, <jorge@laser.satlink.net>
9  *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
10  *              Tom May, <ftom@netcom.com>
11  *              Pentium Pro/II routines:
12  *              Alexander Kjeldaas <astor@guardian.no>
13  *              Finn Arne Gangstad <finnag@guardian.no>
14  *              Lots of code moved from tcp.c and ip.c; see those files
15  *              for more names.
16  *
17  * Changes:     Ingo Molnar, converted csum_partial_copy() to 2.1 exception
18  *                           handling.
19  *              Andi Kleen,  add zeroing on error
20  *                   converted to pure assembler
21  *
22  *              This program is free software; you can redistribute it and/or
23  *              modify it under the terms of the GNU General Public License
24  *              as published by the Free Software Foundation; either version
25  *              2 of the License, or (at your option) any later version.
26  */
27
28 #include <asm/errno.h>
29                                 
30 /*
31  * computes a partial checksum, e.g. for TCP/UDP fragments
32  */
33
34 /*      
35 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
36  */
37                 
38 .text
39 .align 4
40 .globl csum_partial                                                             
41                 
42 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
43
44           /*            
45            * Experiments with Ethernet and SLIP connections show that buff
46            * is aligned on either a 2-byte or 4-byte boundary.  We get at
47            * least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
48            * Fortunately, it is easy to convert 2-byte alignment to 4-byte
49            * alignment for the unrolled loop.
50            */           
51 csum_partial:   
52         pushl %esi
53         pushl %ebx
54         movl 20(%esp),%eax      # Function arg: unsigned int sum
55         movl 16(%esp),%ecx      # Function arg: int len
56         movl 12(%esp),%esi      # Function arg: unsigned char *buff
57         testl $3, %esi          # Check alignment.
58         jz 2f                   # Jump if alignment is ok.
59         testl $1, %esi          # Check alignment.
60         jz 10f                  # Jump if alignment is boundary of 2bytes.
61
62         # buf is odd
63         dec %ecx
64         jl 8f
65         movzbl (%esi), %ebx
66         adcl %ebx, %eax
67         roll $8, %eax
68         inc %esi
69         testl $2, %esi
70         jz 2f
71 10:
72         subl $2, %ecx           # Alignment uses up two bytes.
73         jae 1f                  # Jump if we had at least two bytes.
74         addl $2, %ecx           # ecx was < 2.  Deal with it.
75         jmp 4f
76 1:      movw (%esi), %bx
77         addl $2, %esi
78         addw %bx, %ax
79         adcl $0, %eax
80 2:
81         movl %ecx, %edx
82         shrl $5, %ecx
83         jz 2f
84         testl %esi, %esi
85 1:      movl (%esi), %ebx
86         adcl %ebx, %eax
87         movl 4(%esi), %ebx
88         adcl %ebx, %eax
89         movl 8(%esi), %ebx
90         adcl %ebx, %eax
91         movl 12(%esi), %ebx
92         adcl %ebx, %eax
93         movl 16(%esi), %ebx
94         adcl %ebx, %eax
95         movl 20(%esi), %ebx
96         adcl %ebx, %eax
97         movl 24(%esi), %ebx
98         adcl %ebx, %eax
99         movl 28(%esi), %ebx
100         adcl %ebx, %eax
101         lea 32(%esi), %esi
102         dec %ecx
103         jne 1b
104         adcl $0, %eax
105 2:      movl %edx, %ecx
106         andl $0x1c, %edx
107         je 4f
108         shrl $2, %edx           # This clears CF
109 3:      adcl (%esi), %eax
110         lea 4(%esi), %esi
111         dec %edx
112         jne 3b
113         adcl $0, %eax
114 4:      andl $3, %ecx
115         jz 7f
116         cmpl $2, %ecx
117         jb 5f
118         movw (%esi),%cx
119         leal 2(%esi),%esi
120         je 6f
121         shll $16,%ecx
122 5:      movb (%esi),%cl
123 6:      addl %ecx,%eax
124         adcl $0, %eax 
125 7:      
126         testl $1, 12(%esp)
127         jz 8f
128         roll $8, %eax
129 8:
130         popl %ebx
131         popl %esi
132         ret
133
134 #else
135
136 /* Version for PentiumII/PPro */
137
138 csum_partial:
139         pushl %esi
140         pushl %ebx
141         movl 20(%esp),%eax      # Function arg: unsigned int sum
142         movl 16(%esp),%ecx      # Function arg: int len
143         movl 12(%esp),%esi      # Function arg: const unsigned char *buf
144
145         testl $3, %esi         
146         jnz 25f                 
147 10:
148         movl %ecx, %edx
149         movl %ecx, %ebx
150         andl $0x7c, %ebx
151         shrl $7, %ecx
152         addl %ebx,%esi
153         shrl $2, %ebx  
154         negl %ebx
155         lea 45f(%ebx,%ebx,2), %ebx
156         testl %esi, %esi
157         jmp *%ebx
158
159         # Handle 2-byte-aligned regions
160 20:     addw (%esi), %ax
161         lea 2(%esi), %esi
162         adcl $0, %eax
163         jmp 10b
164 25:
165         testl $1, %esi         
166         jz 30f                 
167         # buf is odd
168         dec %ecx
169         jl 90f
170         movzbl (%esi), %ebx
171         addl %ebx, %eax
172         adcl $0, %eax
173         roll $8, %eax
174         inc %esi
175         testl $2, %esi
176         jz 10b
177
178 30:     subl $2, %ecx          
179         ja 20b                 
180         je 32f
181         addl $2, %ecx
182         jz 80f
183         movzbl (%esi),%ebx      # csumming 1 byte, 2-aligned
184         addl %ebx, %eax
185         adcl $0, %eax
186         jmp 80f
187 32:
188         addw (%esi), %ax        # csumming 2 bytes, 2-aligned
189         adcl $0, %eax
190         jmp 80f
191
192 40: 
193         addl -128(%esi), %eax
194         adcl -124(%esi), %eax
195         adcl -120(%esi), %eax
196         adcl -116(%esi), %eax   
197         adcl -112(%esi), %eax   
198         adcl -108(%esi), %eax
199         adcl -104(%esi), %eax
200         adcl -100(%esi), %eax
201         adcl -96(%esi), %eax
202         adcl -92(%esi), %eax
203         adcl -88(%esi), %eax
204         adcl -84(%esi), %eax
205         adcl -80(%esi), %eax
206         adcl -76(%esi), %eax
207         adcl -72(%esi), %eax
208         adcl -68(%esi), %eax
209         adcl -64(%esi), %eax     
210         adcl -60(%esi), %eax     
211         adcl -56(%esi), %eax     
212         adcl -52(%esi), %eax   
213         adcl -48(%esi), %eax   
214         adcl -44(%esi), %eax
215         adcl -40(%esi), %eax
216         adcl -36(%esi), %eax
217         adcl -32(%esi), %eax
218         adcl -28(%esi), %eax
219         adcl -24(%esi), %eax
220         adcl -20(%esi), %eax
221         adcl -16(%esi), %eax
222         adcl -12(%esi), %eax
223         adcl -8(%esi), %eax
224         adcl -4(%esi), %eax
225 45:
226         lea 128(%esi), %esi
227         adcl $0, %eax
228         dec %ecx
229         jge 40b
230         movl %edx, %ecx
231 50:     andl $3, %ecx
232         jz 80f
233
234         # Handle the last 1-3 bytes without jumping
235         notl %ecx               # 1->2, 2->1, 3->0, higher bits are masked
236         movl $0xffffff,%ebx     # by the shll and shrl instructions
237         shll $3,%ecx
238         shrl %cl,%ebx
239         andl -128(%esi),%ebx    # esi is 4-aligned so should be ok
240         addl %ebx,%eax
241         adcl $0,%eax
242 80: 
243         testl $1, 12(%esp)
244         jz 90f
245         roll $8, %eax
246 90: 
247         popl %ebx
248         popl %esi
249         ret
250                                 
251 #endif
252
253 /*
254 unsigned int csum_partial_copy_generic (const char *src, char *dst,
255                                   int len, int sum, int *src_err_ptr, int *dst_err_ptr)
256  */ 
257
258 /*
259  * Copy from ds while checksumming, otherwise like csum_partial
260  *
261  * The macros SRC and DST specify the type of access for the instruction.
262  * thus we can call a custom exception handler for all access types.
263  *
264  * FIXME: could someone double-check whether I haven't mixed up some SRC and
265  *        DST definitions? It's damn hard to trigger all cases.  I hope I got
266  *        them all but there's no guarantee.
267  */
268
269 #define SRC(y...)                       \
270         9999: y;                        \
271         .section __ex_table, "a";       \
272         .long 9999b, 6001f      ;       \
273         .previous
274
275 #define DST(y...)                       \
276         9999: y;                        \
277         .section __ex_table, "a";       \
278         .long 9999b, 6002f      ;       \
279         .previous
280
281 .align 4
282 .globl csum_partial_copy_generic
283                                 
284 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
285
286 #define ARGBASE 16              
287 #define FP              12
288                 
289 csum_partial_copy_generic:
290         subl  $4,%esp   
291         pushl %edi
292         pushl %esi
293         pushl %ebx
294         movl ARGBASE+16(%esp),%eax      # sum
295         movl ARGBASE+12(%esp),%ecx      # len
296         movl ARGBASE+4(%esp),%esi       # src
297         movl ARGBASE+8(%esp),%edi       # dst
298
299         testl $2, %edi                  # Check alignment. 
300         jz 2f                           # Jump if alignment is ok.
301         subl $2, %ecx                   # Alignment uses up two bytes.
302         jae 1f                          # Jump if we had at least two bytes.
303         addl $2, %ecx                   # ecx was < 2.  Deal with it.
304         jmp 4f
305 SRC(1:  movw (%esi), %bx        )
306         addl $2, %esi
307 DST(    movw %bx, (%edi)        )
308         addl $2, %edi
309         addw %bx, %ax   
310         adcl $0, %eax
311 2:
312         movl %ecx, FP(%esp)
313         shrl $5, %ecx
314         jz 2f
315         testl %esi, %esi
316 SRC(1:  movl (%esi), %ebx       )
317 SRC(    movl 4(%esi), %edx      )
318         adcl %ebx, %eax
319 DST(    movl %ebx, (%edi)       )
320         adcl %edx, %eax
321 DST(    movl %edx, 4(%edi)      )
322
323 SRC(    movl 8(%esi), %ebx      )
324 SRC(    movl 12(%esi), %edx     )
325         adcl %ebx, %eax
326 DST(    movl %ebx, 8(%edi)      )
327         adcl %edx, %eax
328 DST(    movl %edx, 12(%edi)     )
329
330 SRC(    movl 16(%esi), %ebx     )
331 SRC(    movl 20(%esi), %edx     )
332         adcl %ebx, %eax
333 DST(    movl %ebx, 16(%edi)     )
334         adcl %edx, %eax
335 DST(    movl %edx, 20(%edi)     )
336
337 SRC(    movl 24(%esi), %ebx     )
338 SRC(    movl 28(%esi), %edx     )
339         adcl %ebx, %eax
340 DST(    movl %ebx, 24(%edi)     )
341         adcl %edx, %eax
342 DST(    movl %edx, 28(%edi)     )
343
344         lea 32(%esi), %esi
345         lea 32(%edi), %edi
346         dec %ecx
347         jne 1b
348         adcl $0, %eax
349 2:      movl FP(%esp), %edx
350         movl %edx, %ecx
351         andl $0x1c, %edx
352         je 4f
353         shrl $2, %edx                   # This clears CF
354 SRC(3:  movl (%esi), %ebx       )
355         adcl %ebx, %eax
356 DST(    movl %ebx, (%edi)       )
357         lea 4(%esi), %esi
358         lea 4(%edi), %edi
359         dec %edx
360         jne 3b
361         adcl $0, %eax
362 4:      andl $3, %ecx
363         jz 7f
364         cmpl $2, %ecx
365         jb 5f
366 SRC(    movw (%esi), %cx        )
367         leal 2(%esi), %esi
368 DST(    movw %cx, (%edi)        )
369         leal 2(%edi), %edi
370         je 6f
371         shll $16,%ecx
372 SRC(5:  movb (%esi), %cl        )
373 DST(    movb %cl, (%edi)        )
374 6:      addl %ecx, %eax
375         adcl $0, %eax
376 7:
377 5000:
378
379 # Exception handler:
380 .section .fixup, "ax"                                                   
381
382 6001:
383         movl ARGBASE+20(%esp), %ebx     # src_err_ptr
384         movl $-EFAULT, (%ebx)
385
386         # zero the complete destination - computing the rest
387         # is too much work 
388         movl ARGBASE+8(%esp), %edi      # dst
389         movl ARGBASE+12(%esp), %ecx     # len
390         xorl %eax,%eax
391         rep ; stosb
392
393         jmp 5000b
394
395 6002:
396         movl ARGBASE+24(%esp), %ebx     # dst_err_ptr
397         movl $-EFAULT,(%ebx)
398         jmp 5000b
399
400 .previous
401
402         popl %ebx
403         popl %esi
404         popl %edi
405         popl %ecx                       # equivalent to addl $4,%esp
406         ret     
407
408 #else
409
410 /* Version for PentiumII/PPro */
411
412 #define ROUND1(x) \
413         SRC(movl x(%esi), %ebx  )       ;       \
414         addl %ebx, %eax                 ;       \
415         DST(movl %ebx, x(%edi)  )       ; 
416
417 #define ROUND(x) \
418         SRC(movl x(%esi), %ebx  )       ;       \
419         adcl %ebx, %eax                 ;       \
420         DST(movl %ebx, x(%edi)  )       ;
421
422 #define ARGBASE 12
423                 
424 csum_partial_copy_generic:
425         pushl %ebx
426         pushl %edi
427         pushl %esi
428         movl ARGBASE+4(%esp),%esi       #src
429         movl ARGBASE+8(%esp),%edi       #dst    
430         movl ARGBASE+12(%esp),%ecx      #len
431         movl ARGBASE+16(%esp),%eax      #sum
432 #       movl %ecx, %edx  
433         movl %ecx, %ebx  
434         movl %esi, %edx
435         shrl $6, %ecx     
436         andl $0x3c, %ebx  
437         negl %ebx
438         subl %ebx, %esi  
439         subl %ebx, %edi  
440         lea  -1(%esi),%edx
441         andl $-32,%edx
442         lea 3f(%ebx,%ebx), %ebx
443         testl %esi, %esi 
444         jmp *%ebx
445 1:      addl $64,%esi
446         addl $64,%edi 
447         SRC(movb -32(%edx),%bl) ; SRC(movb (%edx),%bl)
448         ROUND1(-64) ROUND(-60) ROUND(-56) ROUND(-52)    
449         ROUND (-48) ROUND(-44) ROUND(-40) ROUND(-36)    
450         ROUND (-32) ROUND(-28) ROUND(-24) ROUND(-20)    
451         ROUND (-16) ROUND(-12) ROUND(-8)  ROUND(-4)     
452 3:      adcl $0,%eax
453         addl $64, %edx
454         dec %ecx
455         jge 1b
456 4:      movl ARGBASE+12(%esp),%edx      #len
457         andl $3, %edx
458         jz 7f
459         cmpl $2, %edx
460         jb 5f
461 SRC(    movw (%esi), %dx         )
462         leal 2(%esi), %esi
463 DST(    movw %dx, (%edi)         )
464         leal 2(%edi), %edi
465         je 6f
466         shll $16,%edx
467 5:
468 SRC(    movb (%esi), %dl         )
469 DST(    movb %dl, (%edi)         )
470 6:      addl %edx, %eax
471         adcl $0, %eax
472 7:
473 .section .fixup, "ax"
474 6001:   movl    ARGBASE+20(%esp), %ebx  # src_err_ptr   
475         movl $-EFAULT, (%ebx)
476         # zero the complete destination (computing the rest is too much work)
477         movl ARGBASE+8(%esp),%edi       # dst
478         movl ARGBASE+12(%esp),%ecx      # len
479         xorl %eax,%eax
480         rep; stosb
481         jmp 7b
482 6002:   movl ARGBASE+24(%esp), %ebx     # dst_err_ptr
483         movl $-EFAULT, (%ebx)
484         jmp  7b                 
485 .previous                               
486
487         popl %esi
488         popl %edi
489         popl %ebx
490         ret
491                                 
492 #undef ROUND
493 #undef ROUND1           
494                 
495 #endif