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