| /* SPDX-License-Identifier: GPL-2.0-or-later */ |
| /* |
| * Memory copy functions for 32-bit PowerPC. |
| * |
| * Copyright (C) 1996-2005 Paul Mackerras. |
| */ |
| #include <linux/export.h> |
| #include <asm/processor.h> |
| #include <asm/cache.h> |
| #include <asm/errno.h> |
| #include <asm/ppc_asm.h> |
| #include <asm/code-patching-asm.h> |
| #include <asm/kasan.h> |
| |
| #define COPY_16_BYTES \ |
| lwz r7,4(r4); \ |
| lwz r8,8(r4); \ |
| lwz r9,12(r4); \ |
| lwzu r10,16(r4); \ |
| stw r7,4(r6); \ |
| stw r8,8(r6); \ |
| stw r9,12(r6); \ |
| stwu r10,16(r6) |
| |
| #define COPY_16_BYTES_WITHEX(n) \ |
| 8 ## n ## 0: \ |
| lwz r7,4(r4); \ |
| 8 ## n ## 1: \ |
| lwz r8,8(r4); \ |
| 8 ## n ## 2: \ |
| lwz r9,12(r4); \ |
| 8 ## n ## 3: \ |
| lwzu r10,16(r4); \ |
| 8 ## n ## 4: \ |
| stw r7,4(r6); \ |
| 8 ## n ## 5: \ |
| stw r8,8(r6); \ |
| 8 ## n ## 6: \ |
| stw r9,12(r6); \ |
| 8 ## n ## 7: \ |
| stwu r10,16(r6) |
| |
| #define COPY_16_BYTES_EXCODE(n) \ |
| 9 ## n ## 0: \ |
| addi r5,r5,-(16 * n); \ |
| b 104f; \ |
| 9 ## n ## 1: \ |
| addi r5,r5,-(16 * n); \ |
| b 105f; \ |
| EX_TABLE(8 ## n ## 0b,9 ## n ## 0b); \ |
| EX_TABLE(8 ## n ## 1b,9 ## n ## 0b); \ |
| EX_TABLE(8 ## n ## 2b,9 ## n ## 0b); \ |
| EX_TABLE(8 ## n ## 3b,9 ## n ## 0b); \ |
| EX_TABLE(8 ## n ## 4b,9 ## n ## 1b); \ |
| EX_TABLE(8 ## n ## 5b,9 ## n ## 1b); \ |
| EX_TABLE(8 ## n ## 6b,9 ## n ## 1b); \ |
| EX_TABLE(8 ## n ## 7b,9 ## n ## 1b) |
| |
| .text |
| |
| CACHELINE_BYTES = L1_CACHE_BYTES |
| LG_CACHELINE_BYTES = L1_CACHE_SHIFT |
| CACHELINE_MASK = (L1_CACHE_BYTES-1) |
| |
| #ifndef CONFIG_KASAN |
| _GLOBAL(memset16) |
| rlwinm. r0 ,r5, 31, 1, 31 |
| addi r6, r3, -4 |
| beq- 2f |
| rlwimi r4 ,r4 ,16 ,0 ,15 |
| mtctr r0 |
| 1: stwu r4, 4(r6) |
| bdnz 1b |
| 2: andi. r0, r5, 1 |
| beqlr |
| sth r4, 4(r6) |
| blr |
| EXPORT_SYMBOL(memset16) |
| #endif |
| |
| /* |
| * Use dcbz on the complete cache lines in the destination |
| * to set them to zero. This requires that the destination |
| * area is cacheable. -- paulus |
| * |
| * During early init, cache might not be active yet, so dcbz cannot be used. |
| * We therefore skip the optimised bloc that uses dcbz. This jump is |
| * replaced by a nop once cache is active. This is done in machine_init() |
| */ |
| _GLOBAL_KASAN(memset) |
| cmplwi 0,r5,4 |
| blt 7f |
| |
| rlwimi r4,r4,8,16,23 |
| rlwimi r4,r4,16,0,15 |
| |
| stw r4,0(r3) |
| beqlr |
| andi. r0,r3,3 |
| add r5,r0,r5 |
| subf r6,r0,r3 |
| cmplwi 0,r4,0 |
| /* |
| * Skip optimised bloc until cache is enabled. Will be replaced |
| * by 'bne' during boot to use normal procedure if r4 is not zero |
| */ |
| 5: b 2f |
| patch_site 5b, patch__memset_nocache |
| |
| clrlwi r7,r6,32-LG_CACHELINE_BYTES |
| add r8,r7,r5 |
| srwi r9,r8,LG_CACHELINE_BYTES |
| addic. r9,r9,-1 /* total number of complete cachelines */ |
| ble 2f |
| xori r0,r7,CACHELINE_MASK & ~3 |
| srwi. r0,r0,2 |
| beq 3f |
| mtctr r0 |
| 4: stwu r4,4(r6) |
| bdnz 4b |
| 3: mtctr r9 |
| li r7,4 |
| 10: dcbz r7,r6 |
| addi r6,r6,CACHELINE_BYTES |
| bdnz 10b |
| clrlwi r5,r8,32-LG_CACHELINE_BYTES |
| addi r5,r5,4 |
| |
| 2: srwi r0,r5,2 |
| mtctr r0 |
| bdz 6f |
| 1: stwu r4,4(r6) |
| bdnz 1b |
| 6: andi. r5,r5,3 |
| beqlr |
| mtctr r5 |
| addi r6,r6,3 |
| 8: stbu r4,1(r6) |
| bdnz 8b |
| blr |
| |
| 7: cmpwi 0,r5,0 |
| beqlr |
| mtctr r5 |
| addi r6,r3,-1 |
| 9: stbu r4,1(r6) |
| bdnz 9b |
| blr |
| EXPORT_SYMBOL(memset) |
| EXPORT_SYMBOL_KASAN(memset) |
| |
| /* |
| * This version uses dcbz on the complete cache lines in the |
| * destination area to reduce memory traffic. This requires that |
| * the destination area is cacheable. |
| * We only use this version if the source and dest don't overlap. |
| * -- paulus. |
| * |
| * During early init, cache might not be active yet, so dcbz cannot be used. |
| * We therefore jump to generic_memcpy which doesn't use dcbz. This jump is |
| * replaced by a nop once cache is active. This is done in machine_init() |
| */ |
| _GLOBAL_KASAN(memmove) |
| cmplw 0,r3,r4 |
| bgt backwards_memcpy |
| /* fall through */ |
| |
| _GLOBAL_KASAN(memcpy) |
| 1: b generic_memcpy |
| patch_site 1b, patch__memcpy_nocache |
| |
| add r7,r3,r5 /* test if the src & dst overlap */ |
| add r8,r4,r5 |
| cmplw 0,r4,r7 |
| cmplw 1,r3,r8 |
| crand 0,0,4 /* cr0.lt &= cr1.lt */ |
| blt generic_memcpy /* if regions overlap */ |
| |
| addi r4,r4,-4 |
| addi r6,r3,-4 |
| neg r0,r3 |
| andi. r0,r0,CACHELINE_MASK /* # bytes to start of cache line */ |
| beq 58f |
| |
| cmplw 0,r5,r0 /* is this more than total to do? */ |
| blt 63f /* if not much to do */ |
| andi. r8,r0,3 /* get it word-aligned first */ |
| subf r5,r0,r5 |
| mtctr r8 |
| beq+ 61f |
| 70: lbz r9,4(r4) /* do some bytes */ |
| addi r4,r4,1 |
| addi r6,r6,1 |
| stb r9,3(r6) |
| bdnz 70b |
| 61: srwi. r0,r0,2 |
| mtctr r0 |
| beq 58f |
| 72: lwzu r9,4(r4) /* do some words */ |
| stwu r9,4(r6) |
| bdnz 72b |
| |
| 58: srwi. r0,r5,LG_CACHELINE_BYTES /* # complete cachelines */ |
| clrlwi r5,r5,32-LG_CACHELINE_BYTES |
| li r11,4 |
| mtctr r0 |
| beq 63f |
| 53: |
| dcbz r11,r6 |
| COPY_16_BYTES |
| #if L1_CACHE_BYTES >= 32 |
| COPY_16_BYTES |
| #if L1_CACHE_BYTES >= 64 |
| COPY_16_BYTES |
| COPY_16_BYTES |
| #if L1_CACHE_BYTES >= 128 |
| COPY_16_BYTES |
| COPY_16_BYTES |
| COPY_16_BYTES |
| COPY_16_BYTES |
| #endif |
| #endif |
| #endif |
| bdnz 53b |
| |
| 63: srwi. r0,r5,2 |
| mtctr r0 |
| beq 64f |
| 30: lwzu r0,4(r4) |
| stwu r0,4(r6) |
| bdnz 30b |
| |
| 64: andi. r0,r5,3 |
| mtctr r0 |
| beq+ 65f |
| addi r4,r4,3 |
| addi r6,r6,3 |
| 40: lbzu r0,1(r4) |
| stbu r0,1(r6) |
| bdnz 40b |
| 65: blr |
| EXPORT_SYMBOL(memcpy) |
| EXPORT_SYMBOL(memmove) |
| EXPORT_SYMBOL_KASAN(memcpy) |
| EXPORT_SYMBOL_KASAN(memmove) |
| |
| generic_memcpy: |
| srwi. r7,r5,3 |
| addi r6,r3,-4 |
| addi r4,r4,-4 |
| beq 2f /* if less than 8 bytes to do */ |
| andi. r0,r6,3 /* get dest word aligned */ |
| mtctr r7 |
| bne 5f |
| 1: lwz r7,4(r4) |
| lwzu r8,8(r4) |
| stw r7,4(r6) |
| stwu r8,8(r6) |
| bdnz 1b |
| andi. r5,r5,7 |
| 2: cmplwi 0,r5,4 |
| blt 3f |
| lwzu r0,4(r4) |
| addi r5,r5,-4 |
| stwu r0,4(r6) |
| 3: cmpwi 0,r5,0 |
| beqlr |
| mtctr r5 |
| addi r4,r4,3 |
| addi r6,r6,3 |
| 4: lbzu r0,1(r4) |
| stbu r0,1(r6) |
| bdnz 4b |
| blr |
| 5: subfic r0,r0,4 |
| mtctr r0 |
| 6: lbz r7,4(r4) |
| addi r4,r4,1 |
| stb r7,4(r6) |
| addi r6,r6,1 |
| bdnz 6b |
| subf r5,r0,r5 |
| rlwinm. r7,r5,32-3,3,31 |
| beq 2b |
| mtctr r7 |
| b 1b |
| |
| _GLOBAL(backwards_memcpy) |
| rlwinm. r7,r5,32-3,3,31 /* r0 = r5 >> 3 */ |
| add r6,r3,r5 |
| add r4,r4,r5 |
| beq 2f |
| andi. r0,r6,3 |
| mtctr r7 |
| bne 5f |
| 1: lwz r7,-4(r4) |
| lwzu r8,-8(r4) |
| stw r7,-4(r6) |
| stwu r8,-8(r6) |
| bdnz 1b |
| andi. r5,r5,7 |
| 2: cmplwi 0,r5,4 |
| blt 3f |
| lwzu r0,-4(r4) |
| subi r5,r5,4 |
| stwu r0,-4(r6) |
| 3: cmpwi 0,r5,0 |
| beqlr |
| mtctr r5 |
| 4: lbzu r0,-1(r4) |
| stbu r0,-1(r6) |
| bdnz 4b |
| blr |
| 5: mtctr r0 |
| 6: lbzu r7,-1(r4) |
| stbu r7,-1(r6) |
| bdnz 6b |
| subf r5,r0,r5 |
| rlwinm. r7,r5,32-3,3,31 |
| beq 2b |
| mtctr r7 |
| b 1b |
| |
| _GLOBAL(__copy_tofrom_user) |
| addi r4,r4,-4 |
| addi r6,r3,-4 |
| neg r0,r3 |
| andi. r0,r0,CACHELINE_MASK /* # bytes to start of cache line */ |
| beq 58f |
| |
| cmplw 0,r5,r0 /* is this more than total to do? */ |
| blt 63f /* if not much to do */ |
| andi. r8,r0,3 /* get it word-aligned first */ |
| mtctr r8 |
| beq+ 61f |
| 70: lbz r9,4(r4) /* do some bytes */ |
| 71: stb r9,4(r6) |
| addi r4,r4,1 |
| addi r6,r6,1 |
| bdnz 70b |
| 61: subf r5,r0,r5 |
| srwi. r0,r0,2 |
| mtctr r0 |
| beq 58f |
| 72: lwzu r9,4(r4) /* do some words */ |
| 73: stwu r9,4(r6) |
| bdnz 72b |
| |
| EX_TABLE(70b,100f) |
| EX_TABLE(71b,101f) |
| EX_TABLE(72b,102f) |
| EX_TABLE(73b,103f) |
| |
| 58: srwi. r0,r5,LG_CACHELINE_BYTES /* # complete cachelines */ |
| clrlwi r5,r5,32-LG_CACHELINE_BYTES |
| li r11,4 |
| beq 63f |
| |
| /* Here we decide how far ahead to prefetch the source */ |
| li r3,4 |
| cmpwi r0,1 |
| li r7,0 |
| ble 114f |
| li r7,1 |
| #if MAX_COPY_PREFETCH > 1 |
| /* Heuristically, for large transfers we prefetch |
| MAX_COPY_PREFETCH cachelines ahead. For small transfers |
| we prefetch 1 cacheline ahead. */ |
| cmpwi r0,MAX_COPY_PREFETCH |
| ble 112f |
| li r7,MAX_COPY_PREFETCH |
| 112: mtctr r7 |
| 111: dcbt r3,r4 |
| addi r3,r3,CACHELINE_BYTES |
| bdnz 111b |
| #else |
| dcbt r3,r4 |
| addi r3,r3,CACHELINE_BYTES |
| #endif /* MAX_COPY_PREFETCH > 1 */ |
| |
| 114: subf r8,r7,r0 |
| mr r0,r7 |
| mtctr r8 |
| |
| 53: dcbt r3,r4 |
| 54: dcbz r11,r6 |
| EX_TABLE(54b,105f) |
| /* the main body of the cacheline loop */ |
| COPY_16_BYTES_WITHEX(0) |
| #if L1_CACHE_BYTES >= 32 |
| COPY_16_BYTES_WITHEX(1) |
| #if L1_CACHE_BYTES >= 64 |
| COPY_16_BYTES_WITHEX(2) |
| COPY_16_BYTES_WITHEX(3) |
| #if L1_CACHE_BYTES >= 128 |
| COPY_16_BYTES_WITHEX(4) |
| COPY_16_BYTES_WITHEX(5) |
| COPY_16_BYTES_WITHEX(6) |
| COPY_16_BYTES_WITHEX(7) |
| #endif |
| #endif |
| #endif |
| bdnz 53b |
| cmpwi r0,0 |
| li r3,4 |
| li r7,0 |
| bne 114b |
| |
| 63: srwi. r0,r5,2 |
| mtctr r0 |
| beq 64f |
| 30: lwzu r0,4(r4) |
| 31: stwu r0,4(r6) |
| bdnz 30b |
| |
| 64: andi. r0,r5,3 |
| mtctr r0 |
| beq+ 65f |
| 40: lbz r0,4(r4) |
| 41: stb r0,4(r6) |
| addi r4,r4,1 |
| addi r6,r6,1 |
| bdnz 40b |
| 65: li r3,0 |
| blr |
| |
| /* read fault, initial single-byte copy */ |
| 100: li r9,0 |
| b 90f |
| /* write fault, initial single-byte copy */ |
| 101: li r9,1 |
| 90: subf r5,r8,r5 |
| li r3,0 |
| b 99f |
| /* read fault, initial word copy */ |
| 102: li r9,0 |
| b 91f |
| /* write fault, initial word copy */ |
| 103: li r9,1 |
| 91: li r3,2 |
| b 99f |
| |
| /* |
| * this stuff handles faults in the cacheline loop and branches to either |
| * 104f (if in read part) or 105f (if in write part), after updating r5 |
| */ |
| COPY_16_BYTES_EXCODE(0) |
| #if L1_CACHE_BYTES >= 32 |
| COPY_16_BYTES_EXCODE(1) |
| #if L1_CACHE_BYTES >= 64 |
| COPY_16_BYTES_EXCODE(2) |
| COPY_16_BYTES_EXCODE(3) |
| #if L1_CACHE_BYTES >= 128 |
| COPY_16_BYTES_EXCODE(4) |
| COPY_16_BYTES_EXCODE(5) |
| COPY_16_BYTES_EXCODE(6) |
| COPY_16_BYTES_EXCODE(7) |
| #endif |
| #endif |
| #endif |
| |
| /* read fault in cacheline loop */ |
| 104: li r9,0 |
| b 92f |
| /* fault on dcbz (effectively a write fault) */ |
| /* or write fault in cacheline loop */ |
| 105: li r9,1 |
| 92: li r3,LG_CACHELINE_BYTES |
| mfctr r8 |
| add r0,r0,r8 |
| b 106f |
| /* read fault in final word loop */ |
| 108: li r9,0 |
| b 93f |
| /* write fault in final word loop */ |
| 109: li r9,1 |
| 93: andi. r5,r5,3 |
| li r3,2 |
| b 99f |
| /* read fault in final byte loop */ |
| 110: li r9,0 |
| b 94f |
| /* write fault in final byte loop */ |
| 111: li r9,1 |
| 94: li r5,0 |
| li r3,0 |
| /* |
| * At this stage the number of bytes not copied is |
| * r5 + (ctr << r3), and r9 is 0 for read or 1 for write. |
| */ |
| 99: mfctr r0 |
| 106: slw r3,r0,r3 |
| add. r3,r3,r5 |
| beq 120f /* shouldn't happen */ |
| cmpwi 0,r9,0 |
| bne 120f |
| /* for a read fault, first try to continue the copy one byte at a time */ |
| mtctr r3 |
| 130: lbz r0,4(r4) |
| 131: stb r0,4(r6) |
| addi r4,r4,1 |
| addi r6,r6,1 |
| bdnz 130b |
| /* then clear out the destination: r3 bytes starting at 4(r6) */ |
| 132: mfctr r3 |
| 120: blr |
| |
| EX_TABLE(30b,108b) |
| EX_TABLE(31b,109b) |
| EX_TABLE(40b,110b) |
| EX_TABLE(41b,111b) |
| EX_TABLE(130b,132b) |
| EX_TABLE(131b,120b) |
| |
| EXPORT_SYMBOL(__copy_tofrom_user) |
