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