m32r: export __ndelay
[linux-2.6.git] / arch / m32r / 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  *              Hirokazu Takata,Hiroyuki Kondo rewrite for the m32r architecture.
22  *
23  *              This program is free software; you can redistribute it and/or
24  *              modify it under the terms of the GNU General Public License
25  *              as published by the Free Software Foundation; either version
26  *              2 of the License, or (at your option) any later version.
27  */
28
29 #include <linux/linkage.h>
30 #include <asm/assembler.h>
31 #include <asm/errno.h>
32
33 /*
34  * computes a partial checksum, e.g. for TCP/UDP fragments
35  */
36
37 /*
38 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
39  */
40
41
42 #ifdef CONFIG_ISA_DUAL_ISSUE
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
52         .text
53 ENTRY(csum_partial)
54         ; Function args
55         ;  r0: unsigned char *buff
56         ;  r1: int len
57         ;  r2: unsigned int sum
58
59         push    r2                  ||  ldi     r2, #0
60         and3    r7, r0, #1              ; Check alignment.
61         beqz    r7, 1f                  ; Jump if alignment is ok.
62         ; 1-byte mis aligned
63         ldub    r4, @r0             ||  addi    r0, #1
64         ; clear c-bit || Alignment uses up bytes.
65         cmp     r0, r0              ||  addi    r1, #-1
66         ldi     r3, #0              ||  addx    r2, r4
67         addx    r2, r3
68         .fillinsn
69 1:
70         and3    r4, r0, #2              ; Check alignment.
71         beqz    r4, 2f                  ; Jump if alignment is ok.
72         ; clear c-bit || Alignment uses up two bytes.
73         cmp     r0, r0              ||  addi    r1, #-2
74         bgtz    r1, 1f                  ; Jump if we had at least two bytes.
75         bra     4f                  ||  addi    r1, #2
76         .fillinsn                       ; len(r1) was < 2.  Deal with it.
77 1:
78         ; 2-byte aligned
79         lduh    r4, @r0             ||  ldi     r3, #0
80         addx    r2, r4              ||  addi    r0, #2
81         addx    r2, r3
82         .fillinsn
83 2:
84         ; 4-byte aligned
85         cmp     r0, r0                  ; clear c-bit
86         srl3    r6, r1, #5
87         beqz    r6, 2f
88         .fillinsn
89
90 1:      ld      r3, @r0+
91         ld      r4, @r0+                                        ; +4
92         ld      r5, @r0+                                        ; +8
93         ld      r3, @r0+            ||  addx    r2, r3          ; +12
94         ld      r4, @r0+            ||  addx    r2, r4          ; +16
95         ld      r5, @r0+            ||  addx    r2, r5          ; +20
96         ld      r3, @r0+            ||  addx    r2, r3          ; +24
97         ld      r4, @r0+            ||  addx    r2, r4          ; +28
98         addx    r2, r5              ||  addi    r6, #-1
99         addx    r2, r3
100         addx    r2, r4
101         bnez    r6, 1b
102
103         addx    r2, r6                  ; r6=0
104         cmp     r0, r0                  ; This clears c-bit
105         .fillinsn
106 2:      and3    r6, r1, #0x1c           ; withdraw len
107         beqz    r6, 4f
108         srli    r6, #2
109         .fillinsn
110
111 3:      ld      r4, @r0+            ||  addi    r6, #-1
112         addx    r2, r4
113         bnez    r6, 3b
114
115         addx    r2, r6                  ; r6=0
116         cmp     r0, r0                  ; This clears c-bit
117         .fillinsn
118 4:      and3    r1, r1, #3
119         beqz    r1, 7f                  ; if len == 0 goto end
120         and3    r6, r1, #2
121         beqz    r6, 5f                  ; if len < 2  goto 5f(1byte)
122         lduh    r4, @r0             ||  addi    r0, #2
123         addi    r1, #-2             ||  slli    r4, #16
124         addx    r2, r4
125         beqz    r1, 6f
126         .fillinsn
127 5:      ldub    r4, @r0             ||  ldi     r1, #0
128 #ifndef __LITTLE_ENDIAN__
129         slli    r4, #8
130 #endif
131         addx    r2, r4
132         .fillinsn
133 6:      addx    r2, r1
134         .fillinsn
135 7:
136         and3    r0, r2, #0xffff
137         srli    r2, #16
138         add     r0, r2
139         srl3    r2, r0, #16
140         beqz    r2, 1f
141         addi    r0, #1
142         and3    r0, r0, #0xffff
143         .fillinsn
144 1:
145         beqz    r7, 1f                  ; swap the upper byte for the lower
146         and3    r2, r0, #0xff
147         srl3    r0, r0, #8
148         slli    r2, #8
149         or      r0, r2
150         .fillinsn
151 1:
152         pop     r2                  ||  cmp     r0, r0
153         addx    r0, r2              ||  ldi     r2, #0
154         addx    r0, r2
155         jmp     r14
156
157 #else /* not CONFIG_ISA_DUAL_ISSUE */
158
159         /*
160          * Experiments with Ethernet and SLIP connections show that buff
161          * is aligned on either a 2-byte or 4-byte boundary.  We get at
162          * least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
163          * Fortunately, it is easy to convert 2-byte alignment to 4-byte
164          * alignment for the unrolled loop.
165          */
166
167         .text
168 ENTRY(csum_partial)
169         ; Function args
170         ;  r0: unsigned char *buff
171         ;  r1: int len
172         ;  r2: unsigned int sum
173
174         push    r2
175         ldi     r2, #0
176         and3    r7, r0, #1              ; Check alignment.
177         beqz    r7, 1f                  ; Jump if alignment is ok.
178         ; 1-byte mis aligned
179         ldub    r4, @r0
180         addi    r0, #1
181         addi    r1, #-1                 ; Alignment uses up bytes.
182         cmp     r0, r0                  ; clear c-bit
183         ldi     r3, #0
184         addx    r2, r4
185         addx    r2, r3
186         .fillinsn
187 1:
188         and3    r4, r0, #2              ; Check alignment.
189         beqz    r4, 2f                  ; Jump if alignment is ok.
190         addi    r1, #-2                 ; Alignment uses up two bytes.
191         cmp             r0, r0                  ; clear c-bit
192         bgtz    r1, 1f                  ; Jump if we had at least two bytes.
193         addi    r1, #2                  ; len(r1) was < 2.  Deal with it.
194         bra     4f
195         .fillinsn
196 1:
197         ; 2-byte aligned
198         lduh    r4, @r0
199         addi    r0, #2
200         ldi             r3, #0
201         addx    r2, r4
202         addx    r2, r3
203         .fillinsn
204 2:
205         ; 4-byte aligned
206         cmp     r0, r0                  ; clear c-bit
207         srl3    r6, r1, #5
208         beqz    r6, 2f
209         .fillinsn
210
211 1:      ld      r3, @r0+
212         ld      r4, @r0+                ; +4
213         ld      r5, @r0+                ; +8
214         addx    r2, r3
215         addx    r2, r4
216         addx    r2, r5
217         ld      r3, @r0+                ; +12
218         ld      r4, @r0+                ; +16
219         ld      r5, @r0+                ; +20
220         addx    r2, r3
221         addx    r2, r4
222         addx    r2, r5
223         ld      r3, @r0+                ; +24
224         ld      r4, @r0+                ; +28
225         addi    r6, #-1
226         addx    r2, r3
227         addx    r2, r4
228         bnez    r6, 1b
229         addx    r2, r6                  ; r6=0
230         cmp     r0, r0                  ; This clears c-bit
231         .fillinsn
232
233 2:      and3    r6, r1, #0x1c           ; withdraw len
234         beqz    r6, 4f
235         srli    r6, #2
236         .fillinsn
237
238 3:      ld      r4, @r0+
239         addi    r6, #-1
240         addx    r2, r4
241         bnez    r6, 3b
242         addx    r2, r6                  ; r6=0
243         cmp     r0, r0                  ; This clears c-bit
244         .fillinsn
245
246 4:      and3    r1, r1, #3
247         beqz    r1, 7f                  ; if len == 0 goto end
248         and3    r6, r1, #2
249         beqz    r6, 5f                  ; if len < 2  goto 5f(1byte)
250
251         lduh    r4, @r0
252         addi    r0, #2
253         addi    r1, #-2
254         slli    r4, #16
255         addx    r2, r4
256         beqz    r1, 6f
257         .fillinsn
258 5:      ldub    r4, @r0
259 #ifndef __LITTLE_ENDIAN__
260         slli    r4, #8
261 #endif
262         addx    r2, r4
263         .fillinsn
264 6:      ldi     r5, #0
265         addx    r2, r5
266         .fillinsn
267 7:
268         and3    r0, r2, #0xffff
269         srli    r2, #16
270         add     r0, r2
271         srl3    r2, r0, #16
272         beqz    r2, 1f
273         addi    r0, #1
274         and3    r0, r0, #0xffff
275         .fillinsn
276 1:
277         beqz    r7, 1f
278         mv      r2, r0
279         srl3    r0, r2, #8
280         and3    r2, r2, #0xff
281         slli    r2, #8
282         or      r0, r2
283         .fillinsn
284 1:
285         pop     r2
286         cmp     r0, r0
287         addx    r0, r2
288         ldi     r2, #0
289         addx    r0, r2
290         jmp     r14
291
292 #endif /* not CONFIG_ISA_DUAL_ISSUE */
293
294 /*
295 unsigned int csum_partial_copy_generic (const char *src, char *dst,
296                                   int len, int sum, int *src_err_ptr, int *dst_err_ptr)
297  */
298
299 /*
300  * Copy from ds while checksumming, otherwise like csum_partial
301  *
302  * The macros SRC and DST specify the type of access for the instruction.
303  * thus we can call a custom exception handler for all access types.
304  *
305  * FIXME: could someone double-check whether I haven't mixed up some SRC and
306  *        DST definitions? It's damn hard to trigger all cases.  I hope I got
307  *        them all but there's no guarantee.
308  */
309
310 ENTRY(csum_partial_copy_generic)
311         nop
312         nop
313         nop
314         nop
315         jmp r14
316         nop
317         nop
318         nop
319
320         .end