Merge branch 'hwmon-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6
[sfrench/cifs-2.6.git] / arch / mips / lib / csum_partial.S
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Quick'n'dirty IP checksum ...
7  *
8  * Copyright (C) 1998, 1999 Ralf Baechle
9  * Copyright (C) 1999 Silicon Graphics, Inc.
10  * Copyright (C) 2007  Maciej W. Rozycki
11  */
12 #include <linux/errno.h>
13 #include <asm/asm.h>
14 #include <asm/asm-offsets.h>
15 #include <asm/regdef.h>
16
17 #ifdef CONFIG_64BIT
18 /*
19  * As we are sharing code base with the mips32 tree (which use the o32 ABI
20  * register definitions). We need to redefine the register definitions from
21  * the n64 ABI register naming to the o32 ABI register naming.
22  */
23 #undef t0
24 #undef t1
25 #undef t2
26 #undef t3
27 #define t0      $8
28 #define t1      $9
29 #define t2      $10
30 #define t3      $11
31 #define t4      $12
32 #define t5      $13
33 #define t6      $14
34 #define t7      $15
35
36 #define USE_DOUBLE
37 #endif
38
39 #ifdef USE_DOUBLE
40
41 #define LOAD   ld
42 #define LOAD32 lwu
43 #define ADD    daddu
44 #define NBYTES 8
45
46 #else
47
48 #define LOAD   lw
49 #define LOAD32 lw
50 #define ADD    addu
51 #define NBYTES 4
52
53 #endif /* USE_DOUBLE */
54
55 #define UNIT(unit)  ((unit)*NBYTES)
56
57 #define ADDC(sum,reg)                                           \
58         .set    push;                                           \
59         .set    noat;                                           \
60         ADD     sum, reg;                                       \
61         sltu    v1, sum, reg;                                   \
62         ADD     sum, v1;                                        \
63         .set    pop
64
65 #define ADDC32(sum,reg)                                         \
66         .set    push;                                           \
67         .set    noat;                                           \
68         addu    sum, reg;                                       \
69         sltu    v1, sum, reg;                                   \
70         addu    sum, v1;                                        \
71         .set    pop
72
73 #define CSUM_BIGCHUNK1(src, offset, sum, _t0, _t1, _t2, _t3)    \
74         LOAD    _t0, (offset + UNIT(0))(src);                   \
75         LOAD    _t1, (offset + UNIT(1))(src);                   \
76         LOAD    _t2, (offset + UNIT(2))(src);                   \
77         LOAD    _t3, (offset + UNIT(3))(src);                   \
78         ADDC(sum, _t0);                                         \
79         ADDC(sum, _t1);                                         \
80         ADDC(sum, _t2);                                         \
81         ADDC(sum, _t3)
82
83 #ifdef USE_DOUBLE
84 #define CSUM_BIGCHUNK(src, offset, sum, _t0, _t1, _t2, _t3)     \
85         CSUM_BIGCHUNK1(src, offset, sum, _t0, _t1, _t2, _t3)
86 #else
87 #define CSUM_BIGCHUNK(src, offset, sum, _t0, _t1, _t2, _t3)     \
88         CSUM_BIGCHUNK1(src, offset, sum, _t0, _t1, _t2, _t3);   \
89         CSUM_BIGCHUNK1(src, offset + 0x10, sum, _t0, _t1, _t2, _t3)
90 #endif
91
92 /*
93  * a0: source address
94  * a1: length of the area to checksum
95  * a2: partial checksum
96  */
97
98 #define src a0
99 #define sum v0
100
101         .text
102         .set    noreorder
103         .align  5
104 LEAF(csum_partial)
105         move    sum, zero
106         move    t7, zero
107
108         sltiu   t8, a1, 0x8
109         bnez    t8, .Lsmall_csumcpy             /* < 8 bytes to copy */
110          move   t2, a1
111
112         andi    t7, src, 0x1                    /* odd buffer? */
113
114 .Lhword_align:
115         beqz    t7, .Lword_align
116          andi   t8, src, 0x2
117
118         lbu     t0, (src)
119         LONG_SUBU       a1, a1, 0x1
120 #ifdef __MIPSEL__
121         sll     t0, t0, 8
122 #endif
123         ADDC(sum, t0)
124         PTR_ADDU        src, src, 0x1
125         andi    t8, src, 0x2
126
127 .Lword_align:
128         beqz    t8, .Ldword_align
129          sltiu  t8, a1, 56
130
131         lhu     t0, (src)
132         LONG_SUBU       a1, a1, 0x2
133         ADDC(sum, t0)
134         sltiu   t8, a1, 56
135         PTR_ADDU        src, src, 0x2
136
137 .Ldword_align:
138         bnez    t8, .Ldo_end_words
139          move   t8, a1
140
141         andi    t8, src, 0x4
142         beqz    t8, .Lqword_align
143          andi   t8, src, 0x8
144
145         LOAD32  t0, 0x00(src)
146         LONG_SUBU       a1, a1, 0x4
147         ADDC(sum, t0)
148         PTR_ADDU        src, src, 0x4
149         andi    t8, src, 0x8
150
151 .Lqword_align:
152         beqz    t8, .Loword_align
153          andi   t8, src, 0x10
154
155 #ifdef USE_DOUBLE
156         ld      t0, 0x00(src)
157         LONG_SUBU       a1, a1, 0x8
158         ADDC(sum, t0)
159 #else
160         lw      t0, 0x00(src)
161         lw      t1, 0x04(src)
162         LONG_SUBU       a1, a1, 0x8
163         ADDC(sum, t0)
164         ADDC(sum, t1)
165 #endif
166         PTR_ADDU        src, src, 0x8
167         andi    t8, src, 0x10
168
169 .Loword_align:
170         beqz    t8, .Lbegin_movement
171          LONG_SRL       t8, a1, 0x7
172
173 #ifdef USE_DOUBLE
174         ld      t0, 0x00(src)
175         ld      t1, 0x08(src)
176         ADDC(sum, t0)
177         ADDC(sum, t1)
178 #else
179         CSUM_BIGCHUNK1(src, 0x00, sum, t0, t1, t3, t4)
180 #endif
181         LONG_SUBU       a1, a1, 0x10
182         PTR_ADDU        src, src, 0x10
183         LONG_SRL        t8, a1, 0x7
184
185 .Lbegin_movement:
186         beqz    t8, 1f
187          andi   t2, a1, 0x40
188
189 .Lmove_128bytes:
190         CSUM_BIGCHUNK(src, 0x00, sum, t0, t1, t3, t4)
191         CSUM_BIGCHUNK(src, 0x20, sum, t0, t1, t3, t4)
192         CSUM_BIGCHUNK(src, 0x40, sum, t0, t1, t3, t4)
193         CSUM_BIGCHUNK(src, 0x60, sum, t0, t1, t3, t4)
194         LONG_SUBU       t8, t8, 0x01
195         .set    reorder                         /* DADDI_WAR */
196         PTR_ADDU        src, src, 0x80
197         bnez    t8, .Lmove_128bytes
198         .set    noreorder
199
200 1:
201         beqz    t2, 1f
202          andi   t2, a1, 0x20
203
204 .Lmove_64bytes:
205         CSUM_BIGCHUNK(src, 0x00, sum, t0, t1, t3, t4)
206         CSUM_BIGCHUNK(src, 0x20, sum, t0, t1, t3, t4)
207         PTR_ADDU        src, src, 0x40
208
209 1:
210         beqz    t2, .Ldo_end_words
211          andi   t8, a1, 0x1c
212
213 .Lmove_32bytes:
214         CSUM_BIGCHUNK(src, 0x00, sum, t0, t1, t3, t4)
215         andi    t8, a1, 0x1c
216         PTR_ADDU        src, src, 0x20
217
218 .Ldo_end_words:
219         beqz    t8, .Lsmall_csumcpy
220          andi   t2, a1, 0x3
221         LONG_SRL        t8, t8, 0x2
222
223 .Lend_words:
224         LOAD32  t0, (src)
225         LONG_SUBU       t8, t8, 0x1
226         ADDC(sum, t0)
227         .set    reorder                         /* DADDI_WAR */
228         PTR_ADDU        src, src, 0x4
229         bnez    t8, .Lend_words
230         .set    noreorder
231
232 /* unknown src alignment and < 8 bytes to go  */
233 .Lsmall_csumcpy:
234         move    a1, t2
235
236         andi    t0, a1, 4
237         beqz    t0, 1f
238          andi   t0, a1, 2
239
240         /* Still a full word to go  */
241         ulw     t1, (src)
242         PTR_ADDIU       src, 4
243 #ifdef USE_DOUBLE
244         dsll    t1, t1, 32                      /* clear lower 32bit */
245 #endif
246         ADDC(sum, t1)
247
248 1:      move    t1, zero
249         beqz    t0, 1f
250          andi   t0, a1, 1
251
252         /* Still a halfword to go  */
253         ulhu    t1, (src)
254         PTR_ADDIU       src, 2
255
256 1:      beqz    t0, 1f
257          sll    t1, t1, 16
258
259         lbu     t2, (src)
260          nop
261
262 #ifdef __MIPSEB__
263         sll     t2, t2, 8
264 #endif
265         or      t1, t2
266
267 1:      ADDC(sum, t1)
268
269         /* fold checksum */
270         .set    push
271         .set    noat
272 #ifdef USE_DOUBLE
273         dsll32  v1, sum, 0
274         daddu   sum, v1
275         sltu    v1, sum, v1
276         dsra32  sum, sum, 0
277         addu    sum, v1
278 #endif
279         sll     v1, sum, 16
280         addu    sum, v1
281         sltu    v1, sum, v1
282         srl     sum, sum, 16
283         addu    sum, v1
284
285         /* odd buffer alignment? */
286         beqz    t7, 1f
287          nop
288         sll     v1, sum, 8
289         srl     sum, sum, 8
290         or      sum, v1
291         andi    sum, 0xffff
292         .set    pop
293 1:
294         .set    reorder
295         /* Add the passed partial csum.  */
296         ADDC32(sum, a2)
297         jr      ra
298         .set    noreorder
299         END(csum_partial)
300
301
302 /*
303  * checksum and copy routines based on memcpy.S
304  *
305  *      csum_partial_copy_nocheck(src, dst, len, sum)
306  *      __csum_partial_copy_user(src, dst, len, sum, errp)
307  *
308  * See "Spec" in memcpy.S for details.  Unlike __copy_user, all
309  * function in this file use the standard calling convention.
310  */
311
312 #define src a0
313 #define dst a1
314 #define len a2
315 #define psum a3
316 #define sum v0
317 #define odd t8
318 #define errptr t9
319
320 /*
321  * The exception handler for loads requires that:
322  *  1- AT contain the address of the byte just past the end of the source
323  *     of the copy,
324  *  2- src_entry <= src < AT, and
325  *  3- (dst - src) == (dst_entry - src_entry),
326  * The _entry suffix denotes values when __copy_user was called.
327  *
328  * (1) is set up up by __csum_partial_copy_from_user and maintained by
329  *      not writing AT in __csum_partial_copy
330  * (2) is met by incrementing src by the number of bytes copied
331  * (3) is met by not doing loads between a pair of increments of dst and src
332  *
333  * The exception handlers for stores stores -EFAULT to errptr and return.
334  * These handlers do not need to overwrite any data.
335  */
336
337 #define EXC(inst_reg,addr,handler)              \
338 9:      inst_reg, addr;                         \
339         .section __ex_table,"a";                \
340         PTR     9b, handler;                    \
341         .previous
342
343 #ifdef USE_DOUBLE
344
345 #define LOAD   ld
346 #define LOADL  ldl
347 #define LOADR  ldr
348 #define STOREL sdl
349 #define STORER sdr
350 #define STORE  sd
351 #define ADD    daddu
352 #define SUB    dsubu
353 #define SRL    dsrl
354 #define SLL    dsll
355 #define SLLV   dsllv
356 #define SRLV   dsrlv
357 #define NBYTES 8
358 #define LOG_NBYTES 3
359
360 #else
361
362 #define LOAD   lw
363 #define LOADL  lwl
364 #define LOADR  lwr
365 #define STOREL swl
366 #define STORER swr
367 #define STORE  sw
368 #define ADD    addu
369 #define SUB    subu
370 #define SRL    srl
371 #define SLL    sll
372 #define SLLV   sllv
373 #define SRLV   srlv
374 #define NBYTES 4
375 #define LOG_NBYTES 2
376
377 #endif /* USE_DOUBLE */
378
379 #ifdef CONFIG_CPU_LITTLE_ENDIAN
380 #define LDFIRST LOADR
381 #define LDREST  LOADL
382 #define STFIRST STORER
383 #define STREST  STOREL
384 #define SHIFT_DISCARD SLLV
385 #define SHIFT_DISCARD_REVERT SRLV
386 #else
387 #define LDFIRST LOADL
388 #define LDREST  LOADR
389 #define STFIRST STOREL
390 #define STREST  STORER
391 #define SHIFT_DISCARD SRLV
392 #define SHIFT_DISCARD_REVERT SLLV
393 #endif
394
395 #define FIRST(unit) ((unit)*NBYTES)
396 #define REST(unit)  (FIRST(unit)+NBYTES-1)
397
398 #define ADDRMASK (NBYTES-1)
399
400 #ifndef CONFIG_CPU_DADDI_WORKAROUNDS
401         .set    noat
402 #else
403         .set    at=v1
404 #endif
405
406 LEAF(__csum_partial_copy_user)
407         PTR_ADDU        AT, src, len    /* See (1) above. */
408 #ifdef CONFIG_64BIT
409         move    errptr, a4
410 #else
411         lw      errptr, 16(sp)
412 #endif
413 FEXPORT(csum_partial_copy_nocheck)
414         move    sum, zero
415         move    odd, zero
416         /*
417          * Note: dst & src may be unaligned, len may be 0
418          * Temps
419          */
420         /*
421          * The "issue break"s below are very approximate.
422          * Issue delays for dcache fills will perturb the schedule, as will
423          * load queue full replay traps, etc.
424          *
425          * If len < NBYTES use byte operations.
426          */
427         sltu    t2, len, NBYTES
428         and     t1, dst, ADDRMASK
429         bnez    t2, .Lcopy_bytes_checklen
430          and    t0, src, ADDRMASK
431         andi    odd, dst, 0x1                   /* odd buffer? */
432         bnez    t1, .Ldst_unaligned
433          nop
434         bnez    t0, .Lsrc_unaligned_dst_aligned
435         /*
436          * use delay slot for fall-through
437          * src and dst are aligned; need to compute rem
438          */
439 .Lboth_aligned:
440          SRL    t0, len, LOG_NBYTES+3    # +3 for 8 units/iter
441         beqz    t0, .Lcleanup_both_aligned # len < 8*NBYTES
442          nop
443         SUB     len, 8*NBYTES           # subtract here for bgez loop
444         .align  4
445 1:
446 EXC(    LOAD    t0, UNIT(0)(src),       .Ll_exc)
447 EXC(    LOAD    t1, UNIT(1)(src),       .Ll_exc_copy)
448 EXC(    LOAD    t2, UNIT(2)(src),       .Ll_exc_copy)
449 EXC(    LOAD    t3, UNIT(3)(src),       .Ll_exc_copy)
450 EXC(    LOAD    t4, UNIT(4)(src),       .Ll_exc_copy)
451 EXC(    LOAD    t5, UNIT(5)(src),       .Ll_exc_copy)
452 EXC(    LOAD    t6, UNIT(6)(src),       .Ll_exc_copy)
453 EXC(    LOAD    t7, UNIT(7)(src),       .Ll_exc_copy)
454         SUB     len, len, 8*NBYTES
455         ADD     src, src, 8*NBYTES
456 EXC(    STORE   t0, UNIT(0)(dst),       .Ls_exc)
457         ADDC(sum, t0)
458 EXC(    STORE   t1, UNIT(1)(dst),       .Ls_exc)
459         ADDC(sum, t1)
460 EXC(    STORE   t2, UNIT(2)(dst),       .Ls_exc)
461         ADDC(sum, t2)
462 EXC(    STORE   t3, UNIT(3)(dst),       .Ls_exc)
463         ADDC(sum, t3)
464 EXC(    STORE   t4, UNIT(4)(dst),       .Ls_exc)
465         ADDC(sum, t4)
466 EXC(    STORE   t5, UNIT(5)(dst),       .Ls_exc)
467         ADDC(sum, t5)
468 EXC(    STORE   t6, UNIT(6)(dst),       .Ls_exc)
469         ADDC(sum, t6)
470 EXC(    STORE   t7, UNIT(7)(dst),       .Ls_exc)
471         ADDC(sum, t7)
472         .set    reorder                         /* DADDI_WAR */
473         ADD     dst, dst, 8*NBYTES
474         bgez    len, 1b
475         .set    noreorder
476         ADD     len, 8*NBYTES           # revert len (see above)
477
478         /*
479          * len == the number of bytes left to copy < 8*NBYTES
480          */
481 .Lcleanup_both_aligned:
482 #define rem t7
483         beqz    len, .Ldone
484          sltu   t0, len, 4*NBYTES
485         bnez    t0, .Lless_than_4units
486          and    rem, len, (NBYTES-1)    # rem = len % NBYTES
487         /*
488          * len >= 4*NBYTES
489          */
490 EXC(    LOAD    t0, UNIT(0)(src),       .Ll_exc)
491 EXC(    LOAD    t1, UNIT(1)(src),       .Ll_exc_copy)
492 EXC(    LOAD    t2, UNIT(2)(src),       .Ll_exc_copy)
493 EXC(    LOAD    t3, UNIT(3)(src),       .Ll_exc_copy)
494         SUB     len, len, 4*NBYTES
495         ADD     src, src, 4*NBYTES
496 EXC(    STORE   t0, UNIT(0)(dst),       .Ls_exc)
497         ADDC(sum, t0)
498 EXC(    STORE   t1, UNIT(1)(dst),       .Ls_exc)
499         ADDC(sum, t1)
500 EXC(    STORE   t2, UNIT(2)(dst),       .Ls_exc)
501         ADDC(sum, t2)
502 EXC(    STORE   t3, UNIT(3)(dst),       .Ls_exc)
503         ADDC(sum, t3)
504         .set    reorder                         /* DADDI_WAR */
505         ADD     dst, dst, 4*NBYTES
506         beqz    len, .Ldone
507         .set    noreorder
508 .Lless_than_4units:
509         /*
510          * rem = len % NBYTES
511          */
512         beq     rem, len, .Lcopy_bytes
513          nop
514 1:
515 EXC(    LOAD    t0, 0(src),             .Ll_exc)
516         ADD     src, src, NBYTES
517         SUB     len, len, NBYTES
518 EXC(    STORE   t0, 0(dst),             .Ls_exc)
519         ADDC(sum, t0)
520         .set    reorder                         /* DADDI_WAR */
521         ADD     dst, dst, NBYTES
522         bne     rem, len, 1b
523         .set    noreorder
524
525         /*
526          * src and dst are aligned, need to copy rem bytes (rem < NBYTES)
527          * A loop would do only a byte at a time with possible branch
528          * mispredicts.  Can't do an explicit LOAD dst,mask,or,STORE
529          * because can't assume read-access to dst.  Instead, use
530          * STREST dst, which doesn't require read access to dst.
531          *
532          * This code should perform better than a simple loop on modern,
533          * wide-issue mips processors because the code has fewer branches and
534          * more instruction-level parallelism.
535          */
536 #define bits t2
537         beqz    len, .Ldone
538          ADD    t1, dst, len    # t1 is just past last byte of dst
539         li      bits, 8*NBYTES
540         SLL     rem, len, 3     # rem = number of bits to keep
541 EXC(    LOAD    t0, 0(src),             .Ll_exc)
542         SUB     bits, bits, rem # bits = number of bits to discard
543         SHIFT_DISCARD t0, t0, bits
544 EXC(    STREST  t0, -1(t1),             .Ls_exc)
545         SHIFT_DISCARD_REVERT t0, t0, bits
546         .set reorder
547         ADDC(sum, t0)
548         b       .Ldone
549         .set noreorder
550 .Ldst_unaligned:
551         /*
552          * dst is unaligned
553          * t0 = src & ADDRMASK
554          * t1 = dst & ADDRMASK; T1 > 0
555          * len >= NBYTES
556          *
557          * Copy enough bytes to align dst
558          * Set match = (src and dst have same alignment)
559          */
560 #define match rem
561 EXC(    LDFIRST t3, FIRST(0)(src),      .Ll_exc)
562         ADD     t2, zero, NBYTES
563 EXC(    LDREST  t3, REST(0)(src),       .Ll_exc_copy)
564         SUB     t2, t2, t1      # t2 = number of bytes copied
565         xor     match, t0, t1
566 EXC(    STFIRST t3, FIRST(0)(dst),      .Ls_exc)
567         SLL     t4, t1, 3               # t4 = number of bits to discard
568         SHIFT_DISCARD t3, t3, t4
569         /* no SHIFT_DISCARD_REVERT to handle odd buffer properly */
570         ADDC(sum, t3)
571         beq     len, t2, .Ldone
572          SUB    len, len, t2
573         ADD     dst, dst, t2
574         beqz    match, .Lboth_aligned
575          ADD    src, src, t2
576
577 .Lsrc_unaligned_dst_aligned:
578         SRL     t0, len, LOG_NBYTES+2    # +2 for 4 units/iter
579         beqz    t0, .Lcleanup_src_unaligned
580          and    rem, len, (4*NBYTES-1)   # rem = len % 4*NBYTES
581 1:
582 /*
583  * Avoid consecutive LD*'s to the same register since some mips
584  * implementations can't issue them in the same cycle.
585  * It's OK to load FIRST(N+1) before REST(N) because the two addresses
586  * are to the same unit (unless src is aligned, but it's not).
587  */
588 EXC(    LDFIRST t0, FIRST(0)(src),      .Ll_exc)
589 EXC(    LDFIRST t1, FIRST(1)(src),      .Ll_exc_copy)
590         SUB     len, len, 4*NBYTES
591 EXC(    LDREST  t0, REST(0)(src),       .Ll_exc_copy)
592 EXC(    LDREST  t1, REST(1)(src),       .Ll_exc_copy)
593 EXC(    LDFIRST t2, FIRST(2)(src),      .Ll_exc_copy)
594 EXC(    LDFIRST t3, FIRST(3)(src),      .Ll_exc_copy)
595 EXC(    LDREST  t2, REST(2)(src),       .Ll_exc_copy)
596 EXC(    LDREST  t3, REST(3)(src),       .Ll_exc_copy)
597         ADD     src, src, 4*NBYTES
598 #ifdef CONFIG_CPU_SB1
599         nop                             # improves slotting
600 #endif
601 EXC(    STORE   t0, UNIT(0)(dst),       .Ls_exc)
602         ADDC(sum, t0)
603 EXC(    STORE   t1, UNIT(1)(dst),       .Ls_exc)
604         ADDC(sum, t1)
605 EXC(    STORE   t2, UNIT(2)(dst),       .Ls_exc)
606         ADDC(sum, t2)
607 EXC(    STORE   t3, UNIT(3)(dst),       .Ls_exc)
608         ADDC(sum, t3)
609         .set    reorder                         /* DADDI_WAR */
610         ADD     dst, dst, 4*NBYTES
611         bne     len, rem, 1b
612         .set    noreorder
613
614 .Lcleanup_src_unaligned:
615         beqz    len, .Ldone
616          and    rem, len, NBYTES-1  # rem = len % NBYTES
617         beq     rem, len, .Lcopy_bytes
618          nop
619 1:
620 EXC(    LDFIRST t0, FIRST(0)(src),      .Ll_exc)
621 EXC(    LDREST  t0, REST(0)(src),       .Ll_exc_copy)
622         ADD     src, src, NBYTES
623         SUB     len, len, NBYTES
624 EXC(    STORE   t0, 0(dst),             .Ls_exc)
625         ADDC(sum, t0)
626         .set    reorder                         /* DADDI_WAR */
627         ADD     dst, dst, NBYTES
628         bne     len, rem, 1b
629         .set    noreorder
630
631 .Lcopy_bytes_checklen:
632         beqz    len, .Ldone
633          nop
634 .Lcopy_bytes:
635         /* 0 < len < NBYTES  */
636 #ifdef CONFIG_CPU_LITTLE_ENDIAN
637 #define SHIFT_START 0
638 #define SHIFT_INC 8
639 #else
640 #define SHIFT_START 8*(NBYTES-1)
641 #define SHIFT_INC -8
642 #endif
643         move    t2, zero        # partial word
644         li      t3, SHIFT_START # shift
645 /* use .Ll_exc_copy here to return correct sum on fault */
646 #define COPY_BYTE(N)                    \
647 EXC(    lbu     t0, N(src), .Ll_exc_copy);      \
648         SUB     len, len, 1;            \
649 EXC(    sb      t0, N(dst), .Ls_exc);   \
650         SLLV    t0, t0, t3;             \
651         addu    t3, SHIFT_INC;          \
652         beqz    len, .Lcopy_bytes_done; \
653          or     t2, t0
654
655         COPY_BYTE(0)
656         COPY_BYTE(1)
657 #ifdef USE_DOUBLE
658         COPY_BYTE(2)
659         COPY_BYTE(3)
660         COPY_BYTE(4)
661         COPY_BYTE(5)
662 #endif
663 EXC(    lbu     t0, NBYTES-2(src), .Ll_exc_copy)
664         SUB     len, len, 1
665 EXC(    sb      t0, NBYTES-2(dst), .Ls_exc)
666         SLLV    t0, t0, t3
667         or      t2, t0
668 .Lcopy_bytes_done:
669         ADDC(sum, t2)
670 .Ldone:
671         /* fold checksum */
672         .set    push
673         .set    noat
674 #ifdef USE_DOUBLE
675         dsll32  v1, sum, 0
676         daddu   sum, v1
677         sltu    v1, sum, v1
678         dsra32  sum, sum, 0
679         addu    sum, v1
680 #endif
681         sll     v1, sum, 16
682         addu    sum, v1
683         sltu    v1, sum, v1
684         srl     sum, sum, 16
685         addu    sum, v1
686
687         /* odd buffer alignment? */
688         beqz    odd, 1f
689          nop
690         sll     v1, sum, 8
691         srl     sum, sum, 8
692         or      sum, v1
693         andi    sum, 0xffff
694         .set    pop
695 1:
696         .set reorder
697         ADDC32(sum, psum)
698         jr      ra
699         .set noreorder
700
701 .Ll_exc_copy:
702         /*
703          * Copy bytes from src until faulting load address (or until a
704          * lb faults)
705          *
706          * When reached by a faulting LDFIRST/LDREST, THREAD_BUADDR($28)
707          * may be more than a byte beyond the last address.
708          * Hence, the lb below may get an exception.
709          *
710          * Assumes src < THREAD_BUADDR($28)
711          */
712         LOAD    t0, TI_TASK($28)
713          li     t2, SHIFT_START
714         LOAD    t0, THREAD_BUADDR(t0)
715 1:
716 EXC(    lbu     t1, 0(src),     .Ll_exc)
717         ADD     src, src, 1
718         sb      t1, 0(dst)      # can't fault -- we're copy_from_user
719         SLLV    t1, t1, t2
720         addu    t2, SHIFT_INC
721         ADDC(sum, t1)
722         .set    reorder                         /* DADDI_WAR */
723         ADD     dst, dst, 1
724         bne     src, t0, 1b
725         .set    noreorder
726 .Ll_exc:
727         LOAD    t0, TI_TASK($28)
728          nop
729         LOAD    t0, THREAD_BUADDR(t0)   # t0 is just past last good address
730          nop
731         SUB     len, AT, t0             # len number of uncopied bytes
732         /*
733          * Here's where we rely on src and dst being incremented in tandem,
734          *   See (3) above.
735          * dst += (fault addr - src) to put dst at first byte to clear
736          */
737         ADD     dst, t0                 # compute start address in a1
738         SUB     dst, src
739         /*
740          * Clear len bytes starting at dst.  Can't call __bzero because it
741          * might modify len.  An inefficient loop for these rare times...
742          */
743         .set    reorder                         /* DADDI_WAR */
744         SUB     src, len, 1
745         beqz    len, .Ldone
746         .set    noreorder
747 1:      sb      zero, 0(dst)
748         ADD     dst, dst, 1
749         .set    push
750         .set    noat
751 #ifndef CONFIG_CPU_DADDI_WORKAROUNDS
752         bnez    src, 1b
753          SUB    src, src, 1
754 #else
755         li      v1, 1
756         bnez    src, 1b
757          SUB    src, src, v1
758 #endif
759         li      v1, -EFAULT
760         b       .Ldone
761          sw     v1, (errptr)
762
763 .Ls_exc:
764         li      v0, -1 /* invalid checksum */
765         li      v1, -EFAULT
766         jr      ra
767          sw     v1, (errptr)
768         .set    pop
769         END(__csum_partial_copy_user)