- Get IP to compile.
[reactos.git] / reactos / drivers / lib / ip / network / i386 / 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 /*
29 * computes a partial checksum, e.g. for TCP/UDP fragments
30 */
31
32 /*
33 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
34 */
35
36 .text
37 .align 4
38 .globl _csum_partial
39
40 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
41
42 /*
43 * Experiments with Ethernet and SLIP connections show that buff
44 * is aligned on either a 2-byte or 4-byte boundary. We get at
45 * least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
46 * Fortunately, it is easy to convert 2-byte alignment to 4-byte
47 * alignment for the unrolled loop.
48 */
49 _csum_partial:
50 pushl %esi
51 pushl %ebx
52 movl 20(%esp),%eax # Function arg: unsigned int sum
53 movl 16(%esp),%ecx # Function arg: int len
54 movl 12(%esp),%esi # Function arg: unsigned char *buff
55 testl $3, %esi # Check alignment.
56 jz 2f # Jump if alignment is ok.
57 testl $1, %esi # Check alignment.
58 jz 10f # Jump if alignment is boundary of 2bytes.
59
60 // buf is odd
61 dec %ecx
62 jl 8f
63 movzbl (%esi), %ebx
64 adcl %ebx, %eax
65 roll $8, %eax
66 inc %esi
67 testl $2, %esi
68 jz 2f
69 10:
70 subl $2, %ecx # Alignment uses up two bytes.
71 jae 1f # Jump if we had at least two bytes.
72 addl $2, %ecx # ecx was < 2. Deal with it.
73 jmp 4f
74 1: movw (%esi), %bx
75 addl $2, %esi
76 addw %bx, %ax
77 adcl $0, %eax
78 2:
79 movl %ecx, %edx
80 shrl $5, %ecx
81 jz 2f
82 testl %esi, %esi
83 1: movl (%esi), %ebx
84 adcl %ebx, %eax
85 movl 4(%esi), %ebx
86 adcl %ebx, %eax
87 movl 8(%esi), %ebx
88 adcl %ebx, %eax
89 movl 12(%esi), %ebx
90 adcl %ebx, %eax
91 movl 16(%esi), %ebx
92 adcl %ebx, %eax
93 movl 20(%esi), %ebx
94 adcl %ebx, %eax
95 movl 24(%esi), %ebx
96 adcl %ebx, %eax
97 movl 28(%esi), %ebx
98 adcl %ebx, %eax
99 lea 32(%esi), %esi
100 dec %ecx
101 jne 1b
102 adcl $0, %eax
103 2: movl %edx, %ecx
104 andl $0x1c, %edx
105 je 4f
106 shrl $2, %edx # This clears CF
107 3: adcl (%esi), %eax
108 lea 4(%esi), %esi
109 dec %edx
110 jne 3b
111 adcl $0, %eax
112 4: andl $3, %ecx
113 jz 7f
114 cmpl $2, %ecx
115 jb 5f
116 movw (%esi),%cx
117 leal 2(%esi),%esi
118 je 6f
119 shll $16,%ecx
120 5: movb (%esi),%cl
121 6: addl %ecx,%eax
122 adcl $0, %eax
123 7:
124 testl $1, 12(%esp)
125 jz 8f
126 roll $8, %eax
127 8:
128 popl %ebx
129 popl %esi
130 ret
131
132 #else
133
134 /* Version for PentiumII/PPro */
135
136 csum_partial:
137 pushl %esi
138 pushl %ebx
139 movl 20(%esp),%eax # Function arg: unsigned int sum
140 movl 16(%esp),%ecx # Function arg: int len
141 movl 12(%esp),%esi # Function arg: const unsigned char *buf
142
143 testl $3, %esi
144 jnz 25f
145 10:
146 movl %ecx, %edx
147 movl %ecx, %ebx
148 andl $0x7c, %ebx
149 shrl $7, %ecx
150 addl %ebx,%esi
151 shrl $2, %ebx
152 negl %ebx
153 lea 45f(%ebx,%ebx,2), %ebx
154 testl %esi, %esi
155 jmp *%ebx
156
157 # Handle 2-byte-aligned regions
158 20: addw (%esi), %ax
159 lea 2(%esi), %esi
160 adcl $0, %eax
161 jmp 10b
162 25:
163 testl $1, %esi
164 jz 30f
165 # buf is odd
166 dec %ecx
167 jl 90f
168 movzbl (%esi), %ebx
169 addl %ebx, %eax
170 adcl $0, %eax
171 roll $8, %eax
172 inc %esi
173 testl $2, %esi
174 jz 10b
175
176 30: subl $2, %ecx
177 ja 20b
178 je 32f
179 addl $2, %ecx
180 jz 80f
181 movzbl (%esi),%ebx # csumming 1 byte, 2-aligned
182 addl %ebx, %eax
183 adcl $0, %eax
184 jmp 80f
185 32:
186 addw (%esi), %ax # csumming 2 bytes, 2-aligned
187 adcl $0, %eax
188 jmp 80f
189
190 40:
191 addl -128(%esi), %eax
192 adcl -124(%esi), %eax
193 adcl -120(%esi), %eax
194 adcl -116(%esi), %eax
195 adcl -112(%esi), %eax
196 adcl -108(%esi), %eax
197 adcl -104(%esi), %eax
198 adcl -100(%esi), %eax
199 adcl -96(%esi), %eax
200 adcl -92(%esi), %eax
201 adcl -88(%esi), %eax
202 adcl -84(%esi), %eax
203 adcl -80(%esi), %eax
204 adcl -76(%esi), %eax
205 adcl -72(%esi), %eax
206 adcl -68(%esi), %eax
207 adcl -64(%esi), %eax
208 adcl -60(%esi), %eax
209 adcl -56(%esi), %eax
210 adcl -52(%esi), %eax
211 adcl -48(%esi), %eax
212 adcl -44(%esi), %eax
213 adcl -40(%esi), %eax
214 adcl -36(%esi), %eax
215 adcl -32(%esi), %eax
216 adcl -28(%esi), %eax
217 adcl -24(%esi), %eax
218 adcl -20(%esi), %eax
219 adcl -16(%esi), %eax
220 adcl -12(%esi), %eax
221 adcl -8(%esi), %eax
222 adcl -4(%esi), %eax
223 45:
224 lea 128(%esi), %esi
225 adcl $0, %eax
226 dec %ecx
227 jge 40b
228 movl %edx, %ecx
229 50: andl $3, %ecx
230 jz 80f
231
232 # Handle the last 1-3 bytes without jumping
233 notl %ecx # 1->2, 2->1, 3->0, higher bits are masked
234 movl $0xffffff,%ebx # by the shll and shrl instructions
235 shll $3,%ecx
236 shrl %cl,%ebx
237 andl -128(%esi),%ebx # esi is 4-aligned so should be ok
238 addl %ebx,%eax
239 adcl $0,%eax
240 80:
241 testl $1, 12(%esp)
242 jz 90f
243 roll $8, %eax
244 90:
245 popl %ebx
246 popl %esi
247 ret
248
249 #endif