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