target/linux/brcm2708/patches-4.9/0063-Improve-__copy_to_user-and-__copy_from_user-performa.patch

   1 From ebd731dd71ec9728a5a87ec1cd695be15828c32c Mon Sep 17 00:00:00 2001
   2 From: popcornmix <popcornmix@gmail.com>
   3 Date: Mon, 28 Nov 2016 16:50:04 +0000
   4 Subject: [PATCH] Improve __copy_to_user and __copy_from_user performance
   5
   6 Provide a __copy_from_user that uses memcpy. On BCM2708, use
   7 optimised memcpy/memmove/memcmp/memset implementations.
   8
   9 arch/arm: Add mmiocpy/set aliases for memcpy/set
  10
  11 See: https://github.com/raspberrypi/linux/issues/1082
  12
  13 copy_from_user: CPU_SW_DOMAIN_PAN compatibility
  14
  15 The downstream copy_from_user acceleration must also play nice with
  16 CONFIG_CPU_SW_DOMAIN_PAN.
  17
  18 See: https://github.com/raspberrypi/linux/issues/1381
  19
  20 Signed-off-by: Phil Elwell <phil@raspberrypi.org>
  21 ---
  22  arch/arm/include/asm/string.h      |   5 +
  23  arch/arm/include/asm/uaccess.h     |   3 +
  24  arch/arm/lib/Makefile              |  15 +-
  25  arch/arm/lib/arm-mem.h             | 159 ++++++++++++
  26  arch/arm/lib/copy_from_user.S      |   4 +-
  27  arch/arm/lib/exports_rpi.c         |  37 +++
  28  arch/arm/lib/memcmp_rpi.S          | 285 +++++++++++++++++++++
  29  arch/arm/lib/memcpy_rpi.S          |  61 +++++
  30  arch/arm/lib/memcpymove.h          | 506 +++++++++++++++++++++++++++++++++++++
  31  arch/arm/lib/memmove_rpi.S         |  61 +++++
  32  arch/arm/lib/memset_rpi.S          | 123 +++++++++
  33  arch/arm/lib/uaccess_with_memcpy.c | 120 ++++++++-
  34  arch/arm/mach-bcm/Kconfig          |   7 +
  35  13 files changed, 1380 insertions(+), 6 deletions(-)
  36  create mode 100644 arch/arm/lib/arm-mem.h
  37  create mode 100644 arch/arm/lib/exports_rpi.c
  38  create mode 100644 arch/arm/lib/memcmp_rpi.S
  39  create mode 100644 arch/arm/lib/memcpy_rpi.S
  40  create mode 100644 arch/arm/lib/memcpymove.h
  41  create mode 100644 arch/arm/lib/memmove_rpi.S
  42  create mode 100644 arch/arm/lib/memset_rpi.S
  43
  44 --- a/arch/arm/include/asm/string.h
  45 +++ b/arch/arm/include/asm/string.h
  46 @@ -24,6 +24,11 @@ extern void * memchr(const void *, int,
  47  #define __HAVE_ARCH_MEMSET
  48  extern void * memset(void *, int, __kernel_size_t);
  49
  50 +#ifdef CONFIG_BCM2835_FAST_MEMCPY
  51 +#define __HAVE_ARCH_MEMCMP
  52 +extern int memcmp(const void *, const void *, size_t);
  53 +#endif
  54 +
  55  extern void __memzero(void *ptr, __kernel_size_t n);
  56
  57  #define memset(p,v,n)                                                  \
  58 --- a/arch/arm/include/asm/uaccess.h
  59 +++ b/arch/arm/include/asm/uaccess.h
  60 @@ -477,6 +477,9 @@ do {                                                                        \
  61  extern unsigned long __must_check
  62  arm_copy_from_user(void *to, const void __user *from, unsigned long n);
  63
  64 +extern unsigned long __must_check
  65 +__copy_from_user_std(void *to, const void __user *from, unsigned long n);
  66 +
  67  static inline unsigned long __must_check
  68  __copy_from_user(void *to, const void __user *from, unsigned long n)
  69  {
  70 --- a/arch/arm/lib/Makefile
  71 +++ b/arch/arm/lib/Makefile
  72 @@ -6,9 +6,8 @@
  73
  74  lib-y          := backtrace.o changebit.o csumipv6.o csumpartial.o   \
  75                    csumpartialcopy.o csumpartialcopyuser.o clearbit.o \
  76 -                  delay.o delay-loop.o findbit.o memchr.o memcpy.o   \
  77 -                  memmove.o memset.o memzero.o setbit.o              \
  78 -                  strchr.o strrchr.o                                 \
  79 +                  delay.o delay-loop.o findbit.o memchr.o memzero.o  \
  80 +                  setbit.o strchr.o strrchr.o                        \
  81                    testchangebit.o testclearbit.o testsetbit.o        \
  82                    ashldi3.o ashrdi3.o lshrdi3.o muldi3.o             \
  83                    ucmpdi2.o lib1funcs.o div64.o                      \
  84 @@ -18,6 +17,16 @@ lib-y                := backtrace.o changebit.o csumip
  85  mmu-y          := clear_user.o copy_page.o getuser.o putuser.o       \
  86                    copy_from_user.o copy_to_user.o
  87
  88 +# Choose optimised implementations for Raspberry Pi
  89 +ifeq ($(CONFIG_BCM2835_FAST_MEMCPY),y)
  90 +  CFLAGS_uaccess_with_memcpy.o += -DCOPY_FROM_USER_THRESHOLD=1600
  91 +  CFLAGS_uaccess_with_memcpy.o += -DCOPY_TO_USER_THRESHOLD=672
  92 +  obj-$(CONFIG_MODULES) += exports_rpi.o
  93 +  lib-y        += memcpy_rpi.o memmove_rpi.o memset_rpi.o memcmp_rpi.o
  94 +else
  95 +  lib-y        += memcpy.o memmove.o memset.o
  96 +endif
  97 +
  98  # using lib_ here won't override already available weak symbols
  99  obj-$(CONFIG_UACCESS_WITH_MEMCPY) += uaccess_with_memcpy.o
 100
 101 --- /dev/null
 102 +++ b/arch/arm/lib/arm-mem.h
 103 @@ -0,0 +1,159 @@
 104 +/*
 105 +Copyright (c) 2013, Raspberry Pi Foundation
 106 +Copyright (c) 2013, RISC OS Open Ltd
 107 +All rights reserved.
 108 +
 109 +Redistribution and use in source and binary forms, with or without
 110 +modification, are permitted provided that the following conditions are met:
 111 +    * Redistributions of source code must retain the above copyright
 112 +      notice, this list of conditions and the following disclaimer.
 113 +    * Redistributions in binary form must reproduce the above copyright
 114 +      notice, this list of conditions and the following disclaimer in the
 115 +      documentation and/or other materials provided with the distribution.
 116 +    * Neither the name of the copyright holder nor the
 117 +      names of its contributors may be used to endorse or promote products
 118 +      derived from this software without specific prior written permission.
 119 +
 120 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 121 +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 122 +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 123 +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
 124 +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 125 +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 126 +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 127 +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 128 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 129 +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 130 +*/
 131 +
 132 +.macro myfunc fname
 133 + .func fname
 134 + .global fname
 135 +fname:
 136 +.endm
 137 +
 138 +.macro preload_leading_step1  backwards, ptr, base
 139 +/* If the destination is already 16-byte aligned, then we need to preload
 140 + * between 0 and prefetch_distance (inclusive) cache lines ahead so there
 141 + * are no gaps when the inner loop starts.
 142 + */
 143 + .if backwards
 144 +        sub     ptr, base, #1
 145 +        bic     ptr, ptr, #31
 146 + .else
 147 +        bic     ptr, base, #31
 148 + .endif
 149 + .set OFFSET, 0
 150 + .rept prefetch_distance+1
 151 +        pld     [ptr, #OFFSET]
 152 +  .if backwards
 153 +   .set OFFSET, OFFSET-32
 154 +  .else
 155 +   .set OFFSET, OFFSET+32
 156 +  .endif
 157 + .endr
 158 +.endm
 159 +
 160 +.macro preload_leading_step2  backwards, ptr, base, leading_bytes, tmp
 161 +/* However, if the destination is not 16-byte aligned, we may need to
 162 + * preload one more cache line than that. The question we need to ask is:
 163 + * are the leading bytes more than the amount by which the source
 164 + * pointer will be rounded down for preloading, and if so, by how many
 165 + * cache lines?
 166 + */
 167 + .if backwards
 168 +/* Here we compare against how many bytes we are into the
 169 + * cache line, counting down from the highest such address.
 170 + * Effectively, we want to calculate
 171 + *     leading_bytes = dst&15
 172 + *     cacheline_offset = 31-((src-leading_bytes-1)&31)
 173 + *     extra_needed = leading_bytes - cacheline_offset
 174 + * and test if extra_needed is <= 0, or rearranging:
 175 + *     leading_bytes + (src-leading_bytes-1)&31 <= 31
 176 + */
 177 +        mov     tmp, base, lsl #32-5
 178 +        sbc     tmp, tmp, leading_bytes, lsl #32-5
 179 +        adds    tmp, tmp, leading_bytes, lsl #32-5
 180 +        bcc     61f
 181 +        pld     [ptr, #-32*(prefetch_distance+1)]
 182 + .else
 183 +/* Effectively, we want to calculate
 184 + *     leading_bytes = (-dst)&15
 185 + *     cacheline_offset = (src+leading_bytes)&31
 186 + *     extra_needed = leading_bytes - cacheline_offset
 187 + * and test if extra_needed is <= 0.
 188 + */
 189 +        mov     tmp, base, lsl #32-5
 190 +        add     tmp, tmp, leading_bytes, lsl #32-5
 191 +        rsbs    tmp, tmp, leading_bytes, lsl #32-5
 192 +        bls     61f
 193 +        pld     [ptr, #32*(prefetch_distance+1)]
 194 + .endif
 195 +61:
 196 +.endm
 197 +
 198 +.macro preload_trailing  backwards, base, remain, tmp
 199 +        /* We need either 0, 1 or 2 extra preloads */
 200 + .if backwards
 201 +        rsb     tmp, base, #0
 202 +        mov     tmp, tmp, lsl #32-5
 203 + .else
 204 +        mov     tmp, base, lsl #32-5
 205 + .endif
 206 +        adds    tmp, tmp, remain, lsl #32-5
 207 +        adceqs  tmp, tmp, #0
 208 +        /* The instruction above has two effects: ensures Z is only
 209 +         * set if C was clear (so Z indicates that both shifted quantities
 210 +         * were 0), and clears C if Z was set (so C indicates that the sum
 211 +         * of the shifted quantities was greater and not equal to 32) */
 212 +        beq     82f
 213 + .if backwards
 214 +        sub     tmp, base, #1
 215 +        bic     tmp, tmp, #31
 216 + .else
 217 +        bic     tmp, base, #31
 218 + .endif
 219 +        bcc     81f
 220 + .if backwards
 221 +        pld     [tmp, #-32*(prefetch_distance+1)]
 222 +81:
 223 +        pld     [tmp, #-32*prefetch_distance]
 224 + .else
 225 +        pld     [tmp, #32*(prefetch_distance+2)]
 226 +81:
 227 +        pld     [tmp, #32*(prefetch_distance+1)]
 228 + .endif
 229 +82:
 230 +.endm
 231 +
 232 +.macro preload_all    backwards, narrow_case, shift, base, remain, tmp0, tmp1
 233 + .if backwards
 234 +        sub     tmp0, base, #1
 235 +        bic     tmp0, tmp0, #31
 236 +        pld     [tmp0]
 237 +        sub     tmp1, base, remain, lsl #shift
 238 + .else
 239 +        bic     tmp0, base, #31
 240 +        pld     [tmp0]
 241 +        add     tmp1, base, remain, lsl #shift
 242 +        sub     tmp1, tmp1, #1
 243 + .endif
 244 +        bic     tmp1, tmp1, #31
 245 +        cmp     tmp1, tmp0
 246 +        beq     92f
 247 + .if narrow_case
 248 +        /* In this case, all the data fits in either 1 or 2 cache lines */
 249 +        pld     [tmp1]
 250 + .else
 251 +91:
 252 +  .if backwards
 253 +        sub     tmp0, tmp0, #32
 254 +  .else
 255 +        add     tmp0, tmp0, #32
 256 +  .endif
 257 +        cmp     tmp0, tmp1
 258 +        pld     [tmp0]
 259 +        bne     91b
 260 + .endif
 261 +92:
 262 +.endm
 263 --- a/arch/arm/lib/copy_from_user.S
 264 +++ b/arch/arm/lib/copy_from_user.S
 265 @@ -89,11 +89,13 @@
 266
 267         .text
 268
 269 -ENTRY(arm_copy_from_user)
 270 +ENTRY(__copy_from_user_std)
 271 +WEAK(arm_copy_from_user)
 272
 273  #include "copy_template.S"
 274
 275  ENDPROC(arm_copy_from_user)
 276 +ENDPROC(__copy_from_user_std)
 277
 278         .pushsection .fixup,"ax"
 279         .align 0
 280 --- /dev/null
 281 +++ b/arch/arm/lib/exports_rpi.c
 282 @@ -0,0 +1,37 @@
 283 +/**
 284 + * Copyright (c) 2014, Raspberry Pi (Trading) Ltd.
 285 + *
 286 + * Redistribution and use in source and binary forms, with or without
 287 + * modification, are permitted provided that the following conditions
 288 + * are met:
 289 + * 1. Redistributions of source code must retain the above copyright
 290 + *    notice, this list of conditions, and the following disclaimer,
 291 + *    without modification.
 292 + * 2. Redistributions in binary form must reproduce the above copyright
 293 + *    notice, this list of conditions and the following disclaimer in the
 294 + *    documentation and/or other materials provided with the distribution.
 295 + * 3. The names of the above-listed copyright holders may not be used
 296 + *    to endorse or promote products derived from this software without
 297 + *    specific prior written permission.
 298 + *
 299 + * ALTERNATIVELY, this software may be distributed under the terms of the
 300 + * GNU General Public License ("GPL") version 2, as published by the Free
 301 + * Software Foundation.
 302 + *
 303 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 304 + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 305 + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 306 + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 307 + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 308 + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 309 + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 310 + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 311 + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 312 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 313 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 314 + */
 315 +
 316 +#include <linux/kernel.h>
 317 +#include <linux/module.h>
 318 +
 319 +EXPORT_SYMBOL(memcmp);
 320 --- /dev/null
 321 +++ b/arch/arm/lib/memcmp_rpi.S
 322 @@ -0,0 +1,285 @@
 323 +/*
 324 +Copyright (c) 2013, Raspberry Pi Foundation
 325 +Copyright (c) 2013, RISC OS Open Ltd
 326 +All rights reserved.
 327 +
 328 +Redistribution and use in source and binary forms, with or without
 329 +modification, are permitted provided that the following conditions are met:
 330 +    * Redistributions of source code must retain the above copyright
 331 +      notice, this list of conditions and the following disclaimer.
 332 +    * Redistributions in binary form must reproduce the above copyright
 333 +      notice, this list of conditions and the following disclaimer in the
 334 +      documentation and/or other materials provided with the distribution.
 335 +    * Neither the name of the copyright holder nor the
 336 +      names of its contributors may be used to endorse or promote products
 337 +      derived from this software without specific prior written permission.
 338 +
 339 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 340 +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 341 +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 342 +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
 343 +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 344 +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 345 +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 346 +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 347 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 348 +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 349 +*/
 350 +
 351 +#include <linux/linkage.h>
 352 +#include "arm-mem.h"
 353 +
 354 +/* Prevent the stack from becoming executable */
 355 +#if defined(__linux__) && defined(__ELF__)
 356 +.section .note.GNU-stack,"",%progbits
 357 +#endif
 358 +
 359 +    .text
 360 +    .arch armv6
 361 +    .object_arch armv4
 362 +    .arm
 363 +    .altmacro
 364 +    .p2align 2
 365 +
 366 +.macro memcmp_process_head  unaligned
 367 + .if unaligned
 368 +        ldr     DAT0, [S_1], #4
 369 +        ldr     DAT1, [S_1], #4
 370 +        ldr     DAT2, [S_1], #4
 371 +        ldr     DAT3, [S_1], #4
 372 + .else
 373 +        ldmia   S_1!, {DAT0, DAT1, DAT2, DAT3}
 374 + .endif
 375 +        ldmia   S_2!, {DAT4, DAT5, DAT6, DAT7}
 376 +.endm
 377 +
 378 +.macro memcmp_process_tail
 379 +        cmp     DAT0, DAT4
 380 +        cmpeq   DAT1, DAT5
 381 +        cmpeq   DAT2, DAT6
 382 +        cmpeq   DAT3, DAT7
 383 +        bne     200f
 384 +.endm
 385 +
 386 +.macro memcmp_leading_31bytes
 387 +        movs    DAT0, OFF, lsl #31
 388 +        ldrmib  DAT0, [S_1], #1
 389 +        ldrcsh  DAT1, [S_1], #2
 390 +        ldrmib  DAT4, [S_2], #1
 391 +        ldrcsh  DAT5, [S_2], #2
 392 +        movpl   DAT0, #0
 393 +        movcc   DAT1, #0
 394 +        movpl   DAT4, #0
 395 +        movcc   DAT5, #0
 396 +        submi   N, N, #1
 397 +        subcs   N, N, #2
 398 +        cmp     DAT0, DAT4
 399 +        cmpeq   DAT1, DAT5
 400 +        bne     200f
 401 +        movs    DAT0, OFF, lsl #29
 402 +        ldrmi   DAT0, [S_1], #4
 403 +        ldrcs   DAT1, [S_1], #4
 404 +        ldrcs   DAT2, [S_1], #4
 405 +        ldrmi   DAT4, [S_2], #4
 406 +        ldmcsia S_2!, {DAT5, DAT6}
 407 +        movpl   DAT0, #0
 408 +        movcc   DAT1, #0
 409 +        movcc   DAT2, #0
 410 +        movpl   DAT4, #0
 411 +        movcc   DAT5, #0
 412 +        movcc   DAT6, #0
 413 +        submi   N, N, #4
 414 +        subcs   N, N, #8
 415 +        cmp     DAT0, DAT4
 416 +        cmpeq   DAT1, DAT5
 417 +        cmpeq   DAT2, DAT6
 418 +        bne     200f
 419 +        tst     OFF, #16
 420 +        beq     105f
 421 +        memcmp_process_head  1
 422 +        sub     N, N, #16
 423 +        memcmp_process_tail
 424 +105:
 425 +.endm
 426 +
 427 +.macro memcmp_trailing_15bytes  unaligned
 428 +        movs    N, N, lsl #29
 429 + .if unaligned
 430 +        ldrcs   DAT0, [S_1], #4
 431 +        ldrcs   DAT1, [S_1], #4
 432 + .else
 433 +        ldmcsia S_1!, {DAT0, DAT1}
 434 + .endif
 435 +        ldrmi   DAT2, [S_1], #4
 436 +        ldmcsia S_2!, {DAT4, DAT5}
 437 +        ldrmi   DAT6, [S_2], #4
 438 +        movcc   DAT0, #0
 439 +        movcc   DAT1, #0
 440 +        movpl   DAT2, #0
 441 +        movcc   DAT4, #0
 442 +        movcc   DAT5, #0
 443 +        movpl   DAT6, #0
 444 +        cmp     DAT0, DAT4
 445 +        cmpeq   DAT1, DAT5
 446 +        cmpeq   DAT2, DAT6
 447 +        bne     200f
 448 +        movs    N, N, lsl #2
 449 +        ldrcsh  DAT0, [S_1], #2
 450 +        ldrmib  DAT1, [S_1]
 451 +        ldrcsh  DAT4, [S_2], #2
 452 +        ldrmib  DAT5, [S_2]
 453 +        movcc   DAT0, #0
 454 +        movpl   DAT1, #0
 455 +        movcc   DAT4, #0
 456 +        movpl   DAT5, #0
 457 +        cmp     DAT0, DAT4
 458 +        cmpeq   DAT1, DAT5
 459 +        bne     200f
 460 +.endm
 461 +
 462 +.macro memcmp_long_inner_loop  unaligned
 463 +110:
 464 +        memcmp_process_head  unaligned
 465 +        pld     [S_2, #prefetch_distance*32 + 16]
 466 +        memcmp_process_tail
 467 +        memcmp_process_head  unaligned
 468 +        pld     [S_1, OFF]
 469 +        memcmp_process_tail
 470 +        subs    N, N, #32
 471 +        bhs     110b
 472 +        /* Just before the final (prefetch_distance+1) 32-byte blocks,
 473 +         * deal with final preloads */
 474 +        preload_trailing  0, S_1, N, DAT0
 475 +        preload_trailing  0, S_2, N, DAT0
 476 +        add     N, N, #(prefetch_distance+2)*32 - 16
 477 +120:
 478 +        memcmp_process_head  unaligned
 479 +        memcmp_process_tail
 480 +        subs    N, N, #16
 481 +        bhs     120b
 482 +        /* Trailing words and bytes */
 483 +        tst     N, #15
 484 +        beq     199f
 485 +        memcmp_trailing_15bytes  unaligned
 486 +199:    /* Reached end without detecting a difference */
 487 +        mov     a1, #0
 488 +        setend  le
 489 +        pop     {DAT1-DAT6, pc}
 490 +.endm
 491 +
 492 +.macro memcmp_short_inner_loop  unaligned
 493 +        subs    N, N, #16     /* simplifies inner loop termination */
 494 +        blo     122f
 495 +120:
 496 +        memcmp_process_head  unaligned
 497 +        memcmp_process_tail
 498 +        subs    N, N, #16
 499 +        bhs     120b
 500 +122:    /* Trailing words and bytes */
 501 +        tst     N, #15
 502 +        beq     199f
 503 +        memcmp_trailing_15bytes  unaligned
 504 +199:    /* Reached end without detecting a difference */
 505 +        mov     a1, #0
 506 +        setend  le
 507 +        pop     {DAT1-DAT6, pc}
 508 +.endm
 509 +
 510 +/*
 511 + * int memcmp(const void *s1, const void *s2, size_t n);
 512 + * On entry:
 513 + * a1 = pointer to buffer 1
 514 + * a2 = pointer to buffer 2
 515 + * a3 = number of bytes to compare (as unsigned chars)
 516 + * On exit:
 517 + * a1 = >0/=0/<0 if s1 >/=/< s2
 518 + */
 519 +
 520 +.set prefetch_distance, 2
 521 +
 522 +ENTRY(memcmp)
 523 +        S_1     .req    a1
 524 +        S_2     .req    a2
 525 +        N       .req    a3
 526 +        DAT0    .req    a4
 527 +        DAT1    .req    v1
 528 +        DAT2    .req    v2
 529 +        DAT3    .req    v3
 530 +        DAT4    .req    v4
 531 +        DAT5    .req    v5
 532 +        DAT6    .req    v6
 533 +        DAT7    .req    ip
 534 +        OFF     .req    lr
 535 +
 536 +        push    {DAT1-DAT6, lr}
 537 +        setend  be /* lowest-addressed bytes are most significant */
 538 +
 539 +        /* To preload ahead as we go, we need at least (prefetch_distance+2) 32-byte blocks */
 540 +        cmp     N, #(prefetch_distance+3)*32 - 1
 541 +        blo     170f
 542 +
 543 +        /* Long case */
 544 +        /* Adjust N so that the decrement instruction can also test for
 545 +         * inner loop termination. We want it to stop when there are
 546 +         * (prefetch_distance+1) complete blocks to go. */
 547 +        sub     N, N, #(prefetch_distance+2)*32
 548 +        preload_leading_step1  0, DAT0, S_1
 549 +        preload_leading_step1  0, DAT1, S_2
 550 +        tst     S_2, #31
 551 +        beq     154f
 552 +        rsb     OFF, S_2, #0 /* no need to AND with 15 here */
 553 +        preload_leading_step2  0, DAT0, S_1, OFF, DAT2
 554 +        preload_leading_step2  0, DAT1, S_2, OFF, DAT2
 555 +        memcmp_leading_31bytes
 556 +154:    /* Second source now cacheline (32-byte) aligned; we have at
 557 +         * least one prefetch to go. */
 558 +        /* Prefetch offset is best selected such that it lies in the
 559 +         * first 8 of each 32 bytes - but it's just as easy to aim for
 560 +         * the first one */
 561 +        and     OFF, S_1, #31
 562 +        rsb     OFF, OFF, #32*prefetch_distance
 563 +        tst     S_1, #3
 564 +        bne     140f
 565 +        memcmp_long_inner_loop  0
 566 +140:    memcmp_long_inner_loop  1
 567 +
 568 +170:    /* Short case */
 569 +        teq     N, #0
 570 +        beq     199f
 571 +        preload_all 0, 0, 0, S_1, N, DAT0, DAT1
 572 +        preload_all 0, 0, 0, S_2, N, DAT0, DAT1
 573 +        tst     S_2, #3
 574 +        beq     174f
 575 +172:    subs    N, N, #1
 576 +        blo     199f
 577 +        ldrb    DAT0, [S_1], #1
 578 +        ldrb    DAT4, [S_2], #1
 579 +        cmp     DAT0, DAT4
 580 +        bne     200f
 581 +        tst     S_2, #3
 582 +        bne     172b
 583 +174:    /* Second source now 4-byte aligned; we have 0 or more bytes to go */
 584 +        tst     S_1, #3
 585 +        bne     140f
 586 +        memcmp_short_inner_loop  0
 587 +140:    memcmp_short_inner_loop  1
 588 +
 589 +200:    /* Difference found: determine sign. */
 590 +        movhi   a1, #1
 591 +        movlo   a1, #-1
 592 +        setend  le
 593 +        pop     {DAT1-DAT6, pc}
 594 +
 595 +        .unreq  S_1
 596 +        .unreq  S_2
 597 +        .unreq  N
 598 +        .unreq  DAT0
 599 +        .unreq  DAT1
 600 +        .unreq  DAT2
 601 +        .unreq  DAT3
 602 +        .unreq  DAT4
 603 +        .unreq  DAT5
 604 +        .unreq  DAT6
 605 +        .unreq  DAT7
 606 +        .unreq  OFF
 607 +ENDPROC(memcmp)
 608 --- /dev/null
 609 +++ b/arch/arm/lib/memcpy_rpi.S
 610 @@ -0,0 +1,61 @@
 611 +/*
 612 +Copyright (c) 2013, Raspberry Pi Foundation
 613 +Copyright (c) 2013, RISC OS Open Ltd
 614 +All rights reserved.
 615 +
 616 +Redistribution and use in source and binary forms, with or without
 617 +modification, are permitted provided that the following conditions are met:
 618 +    * Redistributions of source code must retain the above copyright
 619 +      notice, this list of conditions and the following disclaimer.
 620 +    * Redistributions in binary form must reproduce the above copyright
 621 +      notice, this list of conditions and the following disclaimer in the
 622 +      documentation and/or other materials provided with the distribution.
 623 +    * Neither the name of the copyright holder nor the
 624 +      names of its contributors may be used to endorse or promote products
 625 +      derived from this software without specific prior written permission.
 626 +
 627 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 628 +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 629 +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 630 +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
 631 +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 632 +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 633 +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 634 +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 635 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 636 +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 637 +*/
 638 +
 639 +#include <linux/linkage.h>
 640 +#include "arm-mem.h"
 641 +#include "memcpymove.h"
 642 +
 643 +/* Prevent the stack from becoming executable */
 644 +#if defined(__linux__) && defined(__ELF__)
 645 +.section .note.GNU-stack,"",%progbits
 646 +#endif
 647 +
 648 +    .text
 649 +    .arch armv6
 650 +    .object_arch armv4
 651 +    .arm
 652 +    .altmacro
 653 +    .p2align 2
 654 +
 655 +/*
 656 + * void *memcpy(void * restrict s1, const void * restrict s2, size_t n);
 657 + * On entry:
 658 + * a1 = pointer to destination
 659 + * a2 = pointer to source
 660 + * a3 = number of bytes to copy
 661 + * On exit:
 662 + * a1 preserved
 663 + */
 664 +
 665 +.set prefetch_distance, 3
 666 +
 667 +ENTRY(mmiocpy)
 668 +ENTRY(memcpy)
 669 +        memcpy  0
 670 +ENDPROC(memcpy)
 671 +ENDPROC(mmiocpy)
 672 --- /dev/null
 673 +++ b/arch/arm/lib/memcpymove.h
 674 @@ -0,0 +1,506 @@
 675 +/*
 676 +Copyright (c) 2013, Raspberry Pi Foundation
 677 +Copyright (c) 2013, RISC OS Open Ltd
 678 +All rights reserved.
 679 +
 680 +Redistribution and use in source and binary forms, with or without
 681 +modification, are permitted provided that the following conditions are met:
 682 +    * Redistributions of source code must retain the above copyright
 683 +      notice, this list of conditions and the following disclaimer.
 684 +    * Redistributions in binary form must reproduce the above copyright
 685 +      notice, this list of conditions and the following disclaimer in the
 686 +      documentation and/or other materials provided with the distribution.
 687 +    * Neither the name of the copyright holder nor the
 688 +      names of its contributors may be used to endorse or promote products
 689 +      derived from this software without specific prior written permission.
 690 +
 691 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 692 +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 693 +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 694 +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
 695 +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 696 +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 697 +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 698 +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 699 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 700 +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 701 +*/
 702 +
 703 +.macro unaligned_words  backwards, align, use_pld, words, r0, r1, r2, r3, r4, r5, r6, r7, r8
 704 + .if words == 1
 705 +  .if backwards
 706 +        mov     r1, r0, lsl #32-align*8
 707 +        ldr     r0, [S, #-4]!
 708 +        orr     r1, r1, r0, lsr #align*8
 709 +        str     r1, [D, #-4]!
 710 +  .else
 711 +        mov     r0, r1, lsr #align*8
 712 +        ldr     r1, [S, #4]!
 713 +        orr     r0, r0, r1, lsl #32-align*8
 714 +        str     r0, [D], #4
 715 +  .endif
 716 + .elseif words == 2
 717 +  .if backwards
 718 +        ldr     r1, [S, #-4]!
 719 +        mov     r2, r0, lsl #32-align*8
 720 +        ldr     r0, [S, #-4]!
 721 +        orr     r2, r2, r1, lsr #align*8
 722 +        mov     r1, r1, lsl #32-align*8
 723 +        orr     r1, r1, r0, lsr #align*8
 724 +        stmdb   D!, {r1, r2}
 725 +  .else
 726 +        ldr     r1, [S, #4]!
 727 +        mov     r0, r2, lsr #align*8
 728 +        ldr     r2, [S, #4]!
 729 +        orr     r0, r0, r1, lsl #32-align*8
 730 +        mov     r1, r1, lsr #align*8
 731 +        orr     r1, r1, r2, lsl #32-align*8
 732 +        stmia   D!, {r0, r1}
 733 +  .endif
 734 + .elseif words == 4
 735 +  .if backwards
 736 +        ldmdb   S!, {r2, r3}
 737 +        mov     r4, r0, lsl #32-align*8
 738 +        ldmdb   S!, {r0, r1}
 739 +        orr     r4, r4, r3, lsr #align*8
 740 +        mov     r3, r3, lsl #32-align*8
 741 +        orr     r3, r3, r2, lsr #align*8
 742 +        mov     r2, r2, lsl #32-align*8
 743 +        orr     r2, r2, r1, lsr #align*8
 744 +        mov     r1, r1, lsl #32-align*8
 745 +        orr     r1, r1, r0, lsr #align*8
 746 +        stmdb   D!, {r1, r2, r3, r4}
 747 +  .else
 748 +        ldmib   S!, {r1, r2}
 749 +        mov     r0, r4, lsr #align*8
 750 +        ldmib   S!, {r3, r4}
 751 +        orr     r0, r0, r1, lsl #32-align*8
 752 +        mov     r1, r1, lsr #align*8
 753 +        orr     r1, r1, r2, lsl #32-align*8
 754 +        mov     r2, r2, lsr #align*8
 755 +        orr     r2, r2, r3, lsl #32-align*8
 756 +        mov     r3, r3, lsr #align*8
 757 +        orr     r3, r3, r4, lsl #32-align*8
 758 +        stmia   D!, {r0, r1, r2, r3}
 759 +  .endif
 760 + .elseif words == 8
 761 +  .if backwards
 762 +        ldmdb   S!, {r4, r5, r6, r7}
 763 +        mov     r8, r0, lsl #32-align*8
 764 +        ldmdb   S!, {r0, r1, r2, r3}
 765 +   .if use_pld
 766 +        pld     [S, OFF]
 767 +   .endif
 768 +        orr     r8, r8, r7, lsr #align*8
 769 +        mov     r7, r7, lsl #32-align*8
 770 +        orr     r7, r7, r6, lsr #align*8
 771 +        mov     r6, r6, lsl #32-align*8
 772 +        orr     r6, r6, r5, lsr #align*8
 773 +        mov     r5, r5, lsl #32-align*8
 774 +        orr     r5, r5, r4, lsr #align*8
 775 +        mov     r4, r4, lsl #32-align*8
 776 +        orr     r4, r4, r3, lsr #align*8
 777 +        mov     r3, r3, lsl #32-align*8
 778 +        orr     r3, r3, r2, lsr #align*8
 779 +        mov     r2, r2, lsl #32-align*8
 780 +        orr     r2, r2, r1, lsr #align*8
 781 +        mov     r1, r1, lsl #32-align*8
 782 +        orr     r1, r1, r0, lsr #align*8
 783 +        stmdb   D!, {r5, r6, r7, r8}
 784 +        stmdb   D!, {r1, r2, r3, r4}
 785 +  .else
 786 +        ldmib   S!, {r1, r2, r3, r4}
 787 +        mov     r0, r8, lsr #align*8
 788 +        ldmib   S!, {r5, r6, r7, r8}
 789 +   .if use_pld
 790 +        pld     [S, OFF]
 791 +   .endif
 792 +        orr     r0, r0, r1, lsl #32-align*8
 793 +        mov     r1, r1, lsr #align*8
 794 +        orr     r1, r1, r2, lsl #32-align*8
 795 +        mov     r2, r2, lsr #align*8
 796 +        orr     r2, r2, r3, lsl #32-align*8
 797 +        mov     r3, r3, lsr #align*8
 798 +        orr     r3, r3, r4, lsl #32-align*8
 799 +        mov     r4, r4, lsr #align*8
 800 +        orr     r4, r4, r5, lsl #32-align*8
 801 +        mov     r5, r5, lsr #align*8
 802 +        orr     r5, r5, r6, lsl #32-align*8
 803 +        mov     r6, r6, lsr #align*8
 804 +        orr     r6, r6, r7, lsl #32-align*8
 805 +        mov     r7, r7, lsr #align*8
 806 +        orr     r7, r7, r8, lsl #32-align*8
 807 +        stmia   D!, {r0, r1, r2, r3}
 808 +        stmia   D!, {r4, r5, r6, r7}
 809 +  .endif
 810 + .endif
 811 +.endm
 812 +
 813 +.macro memcpy_leading_15bytes  backwards, align
 814 +        movs    DAT1, DAT2, lsl #31
 815 +        sub     N, N, DAT2
 816 + .if backwards
 817 +        ldrmib  DAT0, [S, #-1]!
 818 +        ldrcsh  DAT1, [S, #-2]!
 819 +        strmib  DAT0, [D, #-1]!
 820 +        strcsh  DAT1, [D, #-2]!
 821 + .else
 822 +        ldrmib  DAT0, [S], #1
 823 +        ldrcsh  DAT1, [S], #2
 824 +        strmib  DAT0, [D], #1
 825 +        strcsh  DAT1, [D], #2
 826 + .endif
 827 +        movs    DAT1, DAT2, lsl #29
 828 + .if backwards
 829 +        ldrmi   DAT0, [S, #-4]!
 830 +  .if align == 0
 831 +        ldmcsdb S!, {DAT1, DAT2}
 832 +  .else
 833 +        ldrcs   DAT2, [S, #-4]!
 834 +        ldrcs   DAT1, [S, #-4]!
 835 +  .endif
 836 +        strmi   DAT0, [D, #-4]!
 837 +        stmcsdb D!, {DAT1, DAT2}
 838 + .else
 839 +        ldrmi   DAT0, [S], #4
 840 +  .if align == 0
 841 +        ldmcsia S!, {DAT1, DAT2}
 842 +  .else
 843 +        ldrcs   DAT1, [S], #4
 844 +        ldrcs   DAT2, [S], #4
 845 +  .endif
 846 +        strmi   DAT0, [D], #4
 847 +        stmcsia D!, {DAT1, DAT2}
 848 + .endif
 849 +.endm
 850 +
 851 +.macro memcpy_trailing_15bytes  backwards, align
 852 +        movs    N, N, lsl #29
 853 + .if backwards
 854 +  .if align == 0
 855 +        ldmcsdb S!, {DAT0, DAT1}
 856 +  .else
 857 +        ldrcs   DAT1, [S, #-4]!
 858 +        ldrcs   DAT0, [S, #-4]!
 859 +  .endif
 860 +        ldrmi   DAT2, [S, #-4]!
 861 +        stmcsdb D!, {DAT0, DAT1}
 862 +        strmi   DAT2, [D, #-4]!
 863 + .else
 864 +  .if align == 0
 865 +        ldmcsia S!, {DAT0, DAT1}
 866 +  .else
 867 +        ldrcs   DAT0, [S], #4
 868 +        ldrcs   DAT1, [S], #4
 869 +  .endif
 870 +        ldrmi   DAT2, [S], #4
 871 +        stmcsia D!, {DAT0, DAT1}
 872 +        strmi   DAT2, [D], #4
 873 + .endif
 874 +        movs    N, N, lsl #2
 875 + .if backwards
 876 +        ldrcsh  DAT0, [S, #-2]!
 877 +        ldrmib  DAT1, [S, #-1]
 878 +        strcsh  DAT0, [D, #-2]!
 879 +        strmib  DAT1, [D, #-1]
 880 + .else
 881 +        ldrcsh  DAT0, [S], #2
 882 +        ldrmib  DAT1, [S]
 883 +        strcsh  DAT0, [D], #2
 884 +        strmib  DAT1, [D]
 885 + .endif
 886 +.endm
 887 +
 888 +.macro memcpy_long_inner_loop  backwards, align
 889 + .if align != 0
 890 +  .if backwards
 891 +        ldr     DAT0, [S, #-align]!
 892 +  .else
 893 +        ldr     LAST, [S, #-align]!
 894 +  .endif
 895 + .endif
 896 +110:
 897 + .if align == 0
 898 +  .if backwards
 899 +        ldmdb   S!, {DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, LAST}
 900 +        pld     [S, OFF]
 901 +        stmdb   D!, {DAT4, DAT5, DAT6, LAST}
 902 +        stmdb   D!, {DAT0, DAT1, DAT2, DAT3}
 903 +  .else
 904 +        ldmia   S!, {DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, LAST}
 905 +        pld     [S, OFF]
 906 +        stmia   D!, {DAT0, DAT1, DAT2, DAT3}
 907 +        stmia   D!, {DAT4, DAT5, DAT6, LAST}
 908 +  .endif
 909 + .else
 910 +        unaligned_words  backwards, align, 1, 8, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7, LAST
 911 + .endif
 912 +        subs    N, N, #32
 913 +        bhs     110b
 914 +        /* Just before the final (prefetch_distance+1) 32-byte blocks, deal with final preloads */
 915 +        preload_trailing  backwards, S, N, OFF
 916 +        add     N, N, #(prefetch_distance+2)*32 - 32
 917 +120:
 918 + .if align == 0
 919 +  .if backwards
 920 +        ldmdb   S!, {DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, LAST}
 921 +        stmdb   D!, {DAT4, DAT5, DAT6, LAST}
 922 +        stmdb   D!, {DAT0, DAT1, DAT2, DAT3}
 923 +  .else
 924 +        ldmia   S!, {DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, LAST}
 925 +        stmia   D!, {DAT0, DAT1, DAT2, DAT3}
 926 +        stmia   D!, {DAT4, DAT5, DAT6, LAST}
 927 +  .endif
 928 + .else
 929 +        unaligned_words  backwards, align, 0, 8, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7, LAST
 930 + .endif
 931 +        subs    N, N, #32
 932 +        bhs     120b
 933 +        tst     N, #16
 934 + .if align == 0
 935 +  .if backwards
 936 +        ldmnedb S!, {DAT0, DAT1, DAT2, LAST}
 937 +        stmnedb D!, {DAT0, DAT1, DAT2, LAST}
 938 +  .else
 939 +        ldmneia S!, {DAT0, DAT1, DAT2, LAST}
 940 +        stmneia D!, {DAT0, DAT1, DAT2, LAST}
 941 +  .endif
 942 + .else
 943 +        beq     130f
 944 +        unaligned_words  backwards, align, 0, 4, DAT0, DAT1, DAT2, DAT3, LAST
 945 +130:
 946 + .endif
 947 +        /* Trailing words and bytes */
 948 +        tst      N, #15
 949 +        beq      199f
 950 + .if align != 0
 951 +        add     S, S, #align
 952 + .endif
 953 +        memcpy_trailing_15bytes  backwards, align
 954 +199:
 955 +        pop     {DAT3, DAT4, DAT5, DAT6, DAT7}
 956 +        pop     {D, DAT1, DAT2, pc}
 957 +.endm
 958 +
 959 +.macro memcpy_medium_inner_loop  backwards, align
 960 +120:
 961 + .if backwards
 962 +  .if align == 0
 963 +        ldmdb   S!, {DAT0, DAT1, DAT2, LAST}
 964 +  .else
 965 +        ldr     LAST, [S, #-4]!
 966 +        ldr     DAT2, [S, #-4]!
 967 +        ldr     DAT1, [S, #-4]!
 968 +        ldr     DAT0, [S, #-4]!
 969 +  .endif
 970 +        stmdb   D!, {DAT0, DAT1, DAT2, LAST}
 971 + .else
 972 +  .if align == 0
 973 +        ldmia   S!, {DAT0, DAT1, DAT2, LAST}
 974 +  .else
 975 +        ldr     DAT0, [S], #4
 976 +        ldr     DAT1, [S], #4
 977 +        ldr     DAT2, [S], #4
 978 +        ldr     LAST, [S], #4
 979 +  .endif
 980 +        stmia   D!, {DAT0, DAT1, DAT2, LAST}
 981 + .endif
 982 +        subs     N, N, #16
 983 +        bhs      120b
 984 +        /* Trailing words and bytes */
 985 +        tst      N, #15
 986 +        beq      199f
 987 +        memcpy_trailing_15bytes  backwards, align
 988 +199:
 989 +        pop     {D, DAT1, DAT2, pc}
 990 +.endm
 991 +
 992 +.macro memcpy_short_inner_loop  backwards, align
 993 +        tst     N, #16
 994 + .if backwards
 995 +  .if align == 0
 996 +        ldmnedb S!, {DAT0, DAT1, DAT2, LAST}
 997 +  .else
 998 +        ldrne   LAST, [S, #-4]!
 999 +        ldrne   DAT2, [S, #-4]!
1000 +        ldrne   DAT1, [S, #-4]!
1001 +        ldrne   DAT0, [S, #-4]!
1002 +  .endif
1003 +        stmnedb D!, {DAT0, DAT1, DAT2, LAST}
1004 + .else
1005 +  .if align == 0
1006 +        ldmneia S!, {DAT0, DAT1, DAT2, LAST}
1007 +  .else
1008 +        ldrne   DAT0, [S], #4
1009 +        ldrne   DAT1, [S], #4
1010 +        ldrne   DAT2, [S], #4
1011 +        ldrne   LAST, [S], #4
1012 +  .endif
1013 +        stmneia D!, {DAT0, DAT1, DAT2, LAST}
1014 + .endif
1015 +        memcpy_trailing_15bytes  backwards, align
1016 +199:
1017 +        pop     {D, DAT1, DAT2, pc}
1018 +.endm
1019 +
1020 +.macro memcpy backwards
1021 +        D       .req    a1
1022 +        S       .req    a2
1023 +        N       .req    a3
1024 +        DAT0    .req    a4
1025 +        DAT1    .req    v1
1026 +        DAT2    .req    v2
1027 +        DAT3    .req    v3
1028 +        DAT4    .req    v4
1029 +        DAT5    .req    v5
1030 +        DAT6    .req    v6
1031 +        DAT7    .req    sl
1032 +        LAST    .req    ip
1033 +        OFF     .req    lr
1034 +
1035 +        .cfi_startproc
1036 +
1037 +        push    {D, DAT1, DAT2, lr}
1038 +
1039 +        .cfi_def_cfa_offset 16
1040 +        .cfi_rel_offset D, 0
1041 +        .cfi_undefined  S
1042 +        .cfi_undefined  N
1043 +        .cfi_undefined  DAT0
1044 +        .cfi_rel_offset DAT1, 4
1045 +        .cfi_rel_offset DAT2, 8
1046 +        .cfi_undefined  LAST
1047 +        .cfi_rel_offset lr, 12
1048 +
1049 + .if backwards
1050 +        add     D, D, N
1051 +        add     S, S, N
1052 + .endif
1053 +
1054 +        /* See if we're guaranteed to have at least one 16-byte aligned 16-byte write */
1055 +        cmp     N, #31
1056 +        blo     170f
1057 +        /* To preload ahead as we go, we need at least (prefetch_distance+2) 32-byte blocks */
1058 +        cmp     N, #(prefetch_distance+3)*32 - 1
1059 +        blo     160f
1060 +
1061 +        /* Long case */
1062 +        push    {DAT3, DAT4, DAT5, DAT6, DAT7}
1063 +
1064 +        .cfi_def_cfa_offset 36
1065 +        .cfi_rel_offset D, 20
1066 +        .cfi_rel_offset DAT1, 24
1067 +        .cfi_rel_offset DAT2, 28
1068 +        .cfi_rel_offset DAT3, 0
1069 +        .cfi_rel_offset DAT4, 4
1070 +        .cfi_rel_offset DAT5, 8
1071 +        .cfi_rel_offset DAT6, 12
1072 +        .cfi_rel_offset DAT7, 16
1073 +        .cfi_rel_offset lr, 32
1074 +
1075 +        /* Adjust N so that the decrement instruction can also test for
1076 +         * inner loop termination. We want it to stop when there are
1077 +         * (prefetch_distance+1) complete blocks to go. */
1078 +        sub     N, N, #(prefetch_distance+2)*32
1079 +        preload_leading_step1  backwards, DAT0, S
1080 + .if backwards
1081 +        /* Bug in GAS: it accepts, but mis-assembles the instruction
1082 +         * ands    DAT2, D, #60, 2
1083 +         * which sets DAT2 to the number of leading bytes until destination is aligned and also clears C (sets borrow)
1084 +         */
1085 +        .word   0xE210513C
1086 +        beq     154f
1087 + .else
1088 +        ands    DAT2, D, #15
1089 +        beq     154f
1090 +        rsb     DAT2, DAT2, #16 /* number of leading bytes until destination aligned */
1091 + .endif
1092 +        preload_leading_step2  backwards, DAT0, S, DAT2, OFF
1093 +        memcpy_leading_15bytes backwards, 1
1094 +154:    /* Destination now 16-byte aligned; we have at least one prefetch as well as at least one 16-byte output block */
1095 +        /* Prefetch offset is best selected such that it lies in the first 8 of each 32 bytes - but it's just as easy to aim for the first one */
1096 + .if backwards
1097 +        rsb     OFF, S, #3
1098 +        and     OFF, OFF, #28
1099 +        sub     OFF, OFF, #32*(prefetch_distance+1)
1100 + .else
1101 +        and     OFF, S, #28
1102 +        rsb     OFF, OFF, #32*prefetch_distance
1103 + .endif
1104 +        movs    DAT0, S, lsl #31
1105 +        bhi     157f
1106 +        bcs     156f
1107 +        bmi     155f
1108 +        memcpy_long_inner_loop  backwards, 0
1109 +155:    memcpy_long_inner_loop  backwards, 1
1110 +156:    memcpy_long_inner_loop  backwards, 2
1111 +157:    memcpy_long_inner_loop  backwards, 3
1112 +
1113 +        .cfi_def_cfa_offset 16
1114 +        .cfi_rel_offset D, 0
1115 +        .cfi_rel_offset DAT1, 4
1116 +        .cfi_rel_offset DAT2, 8
1117 +        .cfi_same_value DAT3
1118 +        .cfi_same_value DAT4
1119 +        .cfi_same_value DAT5
1120 +        .cfi_same_value DAT6
1121 +        .cfi_same_value DAT7
1122 +        .cfi_rel_offset lr, 12
1123 +
1124 +160:    /* Medium case */
1125 +        preload_all  backwards, 0, 0, S, N, DAT2, OFF
1126 +        sub     N, N, #16     /* simplifies inner loop termination */
1127 + .if backwards
1128 +        ands    DAT2, D, #15
1129 +        beq     164f
1130 + .else
1131 +        ands    DAT2, D, #15
1132 +        beq     164f
1133 +        rsb     DAT2, DAT2, #16
1134 + .endif
1135 +        memcpy_leading_15bytes backwards, align
1136 +164:    /* Destination now 16-byte aligned; we have at least one 16-byte output block */
1137 +        tst     S, #3
1138 +        bne     140f
1139 +        memcpy_medium_inner_loop  backwards, 0
1140 +140:    memcpy_medium_inner_loop  backwards, 1
1141 +
1142 +170:    /* Short case, less than 31 bytes, so no guarantee of at least one 16-byte block */
1143 +        teq     N, #0
1144 +        beq     199f
1145 +        preload_all  backwards, 1, 0, S, N, DAT2, LAST
1146 +        tst     D, #3
1147 +        beq     174f
1148 +172:    subs    N, N, #1
1149 +        blo     199f
1150 + .if backwards
1151 +        ldrb    DAT0, [S, #-1]!
1152 +        strb    DAT0, [D, #-1]!
1153 + .else
1154 +        ldrb    DAT0, [S], #1
1155 +        strb    DAT0, [D], #1
1156 + .endif
1157 +        tst     D, #3
1158 +        bne     172b
1159 +174:    /* Destination now 4-byte aligned; we have 0 or more output bytes to go */
1160 +        tst     S, #3
1161 +        bne     140f
1162 +        memcpy_short_inner_loop  backwards, 0
1163 +140:    memcpy_short_inner_loop  backwards, 1
1164 +
1165 +        .cfi_endproc
1166 +
1167 +        .unreq  D
1168 +        .unreq  S
1169 +        .unreq  N
1170 +        .unreq  DAT0
1171 +        .unreq  DAT1
1172 +        .unreq  DAT2
1173 +        .unreq  DAT3
1174 +        .unreq  DAT4
1175 +        .unreq  DAT5
1176 +        .unreq  DAT6
1177 +        .unreq  DAT7
1178 +        .unreq  LAST
1179 +        .unreq  OFF
1180 +.endm
1181 --- /dev/null
1182 +++ b/arch/arm/lib/memmove_rpi.S
1183 @@ -0,0 +1,61 @@
1184 +/*
1185 +Copyright (c) 2013, Raspberry Pi Foundation
1186 +Copyright (c) 2013, RISC OS Open Ltd
1187 +All rights reserved.
1188 +
1189 +Redistribution and use in source and binary forms, with or without
1190 +modification, are permitted provided that the following conditions are met:
1191 +    * Redistributions of source code must retain the above copyright
1192 +      notice, this list of conditions and the following disclaimer.
1193 +    * Redistributions in binary form must reproduce the above copyright
1194 +      notice, this list of conditions and the following disclaimer in the
1195 +      documentation and/or other materials provided with the distribution.
1196 +    * Neither the name of the copyright holder nor the
1197 +      names of its contributors may be used to endorse or promote products
1198 +      derived from this software without specific prior written permission.
1199 +
1200 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
1201 +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1202 +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
1203 +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
1204 +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
1205 +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
1206 +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
1207 +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
1208 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
1209 +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1210 +*/
1211 +
1212 +#include <linux/linkage.h>
1213 +#include "arm-mem.h"
1214 +#include "memcpymove.h"
1215 +
1216 +/* Prevent the stack from becoming executable */
1217 +#if defined(__linux__) && defined(__ELF__)
1218 +.section .note.GNU-stack,"",%progbits
1219 +#endif
1220 +
1221 +    .text
1222 +    .arch armv6
1223 +    .object_arch armv4
1224 +    .arm
1225 +    .altmacro
1226 +    .p2align 2
1227 +
1228 +/*
1229 + * void *memmove(void *s1, const void *s2, size_t n);
1230 + * On entry:
1231 + * a1 = pointer to destination
1232 + * a2 = pointer to source
1233 + * a3 = number of bytes to copy
1234 + * On exit:
1235 + * a1 preserved
1236 + */
1237 +
1238 +.set prefetch_distance, 3
1239 +
1240 +ENTRY(memmove)
1241 +        cmp     a2, a1
1242 +        bpl     memcpy  /* pl works even over -1 - 0 and 0x7fffffff - 0x80000000 boundaries */
1243 +        memcpy  1
1244 +ENDPROC(memmove)
1245 --- /dev/null
1246 +++ b/arch/arm/lib/memset_rpi.S
1247 @@ -0,0 +1,123 @@
1248 +/*
1249 +Copyright (c) 2013, Raspberry Pi Foundation
1250 +Copyright (c) 2013, RISC OS Open Ltd
1251 +All rights reserved.
1252 +
1253 +Redistribution and use in source and binary forms, with or without
1254 +modification, are permitted provided that the following conditions are met:
1255 +    * Redistributions of source code must retain the above copyright
1256 +      notice, this list of conditions and the following disclaimer.
1257 +    * Redistributions in binary form must reproduce the above copyright
1258 +      notice, this list of conditions and the following disclaimer in the
1259 +      documentation and/or other materials provided with the distribution.
1260 +    * Neither the name of the copyright holder nor the
1261 +      names of its contributors may be used to endorse or promote products
1262 +      derived from this software without specific prior written permission.
1263 +
1264 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
1265 +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1266 +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
1267 +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
1268 +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
1269 +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
1270 +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
1271 +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
1272 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
1273 +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1274 +*/
1275 +
1276 +#include <linux/linkage.h>
1277 +#include "arm-mem.h"
1278 +
1279 +/* Prevent the stack from becoming executable */
1280 +#if defined(__linux__) && defined(__ELF__)
1281 +.section .note.GNU-stack,"",%progbits
1282 +#endif
1283 +
1284 +    .text
1285 +    .arch armv6
1286 +    .object_arch armv4
1287 +    .arm
1288 +    .altmacro
1289 +    .p2align 2
1290 +
1291 +/*
1292 + *  void *memset(void *s, int c, size_t n);
1293 + *  On entry:
1294 + *  a1 = pointer to buffer to fill
1295 + *  a2 = byte pattern to fill with (caller-narrowed)
1296 + *  a3 = number of bytes to fill
1297 + *  On exit:
1298 + *  a1 preserved
1299 + */
1300 +ENTRY(mmioset)
1301 +ENTRY(memset)
1302 +        S       .req    a1
1303 +        DAT0    .req    a2
1304 +        N       .req    a3
1305 +        DAT1    .req    a4
1306 +        DAT2    .req    ip
1307 +        DAT3    .req    lr
1308 +
1309 +        orr     DAT0, DAT0, lsl #8
1310 +        push    {S, lr}
1311 +        orr     DAT0, DAT0, lsl #16
1312 +        mov     DAT1, DAT0
1313 +
1314 +        /* See if we're guaranteed to have at least one 16-byte aligned 16-byte write */
1315 +        cmp     N, #31
1316 +        blo     170f
1317 +
1318 +161:    sub     N, N, #16     /* simplifies inner loop termination */
1319 +        /* Leading words and bytes */
1320 +        tst     S, #15
1321 +        beq     164f
1322 +        rsb     DAT3, S, #0   /* bits 0-3 = number of leading bytes until aligned */
1323 +        movs    DAT2, DAT3, lsl #31
1324 +        submi   N, N, #1
1325 +        strmib  DAT0, [S], #1
1326 +        subcs   N, N, #2
1327 +        strcsh  DAT0, [S], #2
1328 +        movs    DAT2, DAT3, lsl #29
1329 +        submi   N, N, #4
1330 +        strmi   DAT0, [S], #4
1331 +        subcs   N, N, #8
1332 +        stmcsia S!, {DAT0, DAT1}
1333 +164:    /* Delayed set up of DAT2 and DAT3 so we could use them as scratch registers above */
1334 +        mov     DAT2, DAT0
1335 +        mov     DAT3, DAT0
1336 +        /* Now the inner loop of 16-byte stores */
1337 +165:    stmia   S!, {DAT0, DAT1, DAT2, DAT3}
1338 +        subs    N, N, #16
1339 +        bhs     165b
1340 +166:    /* Trailing words and bytes */
1341 +        movs    N, N, lsl #29
1342 +        stmcsia S!, {DAT0, DAT1}
1343 +        strmi   DAT0, [S], #4
1344 +        movs    N, N, lsl #2
1345 +        strcsh  DAT0, [S], #2
1346 +        strmib  DAT0, [S]
1347 +199:    pop     {S, pc}
1348 +
1349 +170:    /* Short case */
1350 +        mov     DAT2, DAT0
1351 +        mov     DAT3, DAT0
1352 +        tst     S, #3
1353 +        beq     174f
1354 +172:    subs    N, N, #1
1355 +        blo     199b
1356 +        strb    DAT0, [S], #1
1357 +        tst     S, #3
1358 +        bne     172b
1359 +174:    tst     N, #16
1360 +        stmneia S!, {DAT0, DAT1, DAT2, DAT3}
1361 +        b       166b
1362 +
1363 +        .unreq  S
1364 +        .unreq  DAT0
1365 +        .unreq  N
1366 +        .unreq  DAT1
1367 +        .unreq  DAT2
1368 +        .unreq  DAT3
1369 +ENDPROC(memset)
1370 +ENDPROC(mmioset)
1371 --- a/arch/arm/lib/uaccess_with_memcpy.c
1372 +++ b/arch/arm/lib/uaccess_with_memcpy.c
1373 @@ -22,6 +22,14 @@
1374  #include <asm/current.h>
1375  #include <asm/page.h>
1376
1377 +#ifndef COPY_FROM_USER_THRESHOLD
1378 +#define COPY_FROM_USER_THRESHOLD 64
1379 +#endif
1380 +
1381 +#ifndef COPY_TO_USER_THRESHOLD
1382 +#define COPY_TO_USER_THRESHOLD 64
1383 +#endif
1384 +
1385  static int
1386  pin_page_for_write(const void __user *_addr, pte_t **ptep, spinlock_t **ptlp)
1387  {
1388 @@ -84,7 +92,44 @@ pin_page_for_write(const void __user *_a
1389         return 1;
1390  }
1391
1392 -static unsigned long noinline
1393 +static int
1394 +pin_page_for_read(const void __user *_addr, pte_t **ptep, spinlock_t **ptlp)
1395 +{
1396 +       unsigned long addr = (unsigned long)_addr;
1397 +       pgd_t *pgd;
1398 +       pmd_t *pmd;
1399 +       pte_t *pte;
1400 +       pud_t *pud;
1401 +       spinlock_t *ptl;
1402 +
1403 +       pgd = pgd_offset(current->mm, addr);
1404 +       if (unlikely(pgd_none(*pgd) || pgd_bad(*pgd)))
1405 +       {
1406 +               return 0;
1407 +       }
1408 +       pud = pud_offset(pgd, addr);
1409 +       if (unlikely(pud_none(*pud) || pud_bad(*pud)))
1410 +       {
1411 +               return 0;
1412 +       }
1413 +
1414 +       pmd = pmd_offset(pud, addr);
1415 +       if (unlikely(pmd_none(*pmd) || pmd_bad(*pmd)))
1416 +               return 0;
1417 +
1418 +       pte = pte_offset_map_lock(current->mm, pmd, addr, &ptl);
1419 +       if (unlikely(!pte_present(*pte) || !pte_young(*pte))) {
1420 +               pte_unmap_unlock(pte, ptl);
1421 +               return 0;
1422 +       }
1423 +
1424 +       *ptep = pte;
1425 +       *ptlp = ptl;
1426 +
1427 +       return 1;
1428 +}
1429 +
1430 +unsigned long noinline
1431  __copy_to_user_memcpy(void __user *to, const void *from, unsigned long n)
1432  {
1433         unsigned long ua_flags;
1434 @@ -137,6 +182,57 @@ out:
1435         return n;
1436  }
1437
1438 +unsigned long noinline
1439 +__copy_from_user_memcpy(void *to, const void __user *from, unsigned long n)
1440 +{
1441 +       unsigned long ua_flags;
1442 +       int atomic;
1443 +
1444 +       if (unlikely(segment_eq(get_fs(), KERNEL_DS))) {
1445 +               memcpy(to, (const void *)from, n);
1446 +               return 0;
1447 +       }
1448 +
1449 +       /* the mmap semaphore is taken only if not in an atomic context */
1450 +       atomic = in_atomic();
1451 +
1452 +       if (!atomic)
1453 +               down_read(&current->mm->mmap_sem);
1454 +       while (n) {
1455 +               pte_t *pte;
1456 +               spinlock_t *ptl;
1457 +               int tocopy;
1458 +
1459 +               while (!pin_page_for_read(from, &pte, &ptl)) {
1460 +                       char temp;
1461 +                       if (!atomic)
1462 +                               up_read(&current->mm->mmap_sem);
1463 +                       if (__get_user(temp, (char __user *)from))
1464 +                               goto out;
1465 +                       if (!atomic)
1466 +                               down_read(&current->mm->mmap_sem);
1467 +               }
1468 +
1469 +               tocopy = (~(unsigned long)from & ~PAGE_MASK) + 1;
1470 +               if (tocopy > n)
1471 +                       tocopy = n;
1472 +
1473 +               ua_flags = uaccess_save_and_enable();
1474 +               memcpy(to, (const void *)from, tocopy);
1475 +               uaccess_restore(ua_flags);
1476 +               to += tocopy;
1477 +               from += tocopy;
1478 +               n -= tocopy;
1479 +
1480 +               pte_unmap_unlock(pte, ptl);
1481 +       }
1482 +       if (!atomic)
1483 +               up_read(&current->mm->mmap_sem);
1484 +
1485 +out:
1486 +       return n;
1487 +}
1488 +
1489  unsigned long
1490  arm_copy_to_user(void __user *to, const void *from, unsigned long n)
1491  {
1492 @@ -147,7 +243,7 @@ arm_copy_to_user(void __user *to, const
1493          * With frame pointer disabled, tail call optimization kicks in
1494          * as well making this test almost invisible.
1495          */
1496 -       if (n < 64) {
1497 +       if (n < COPY_TO_USER_THRESHOLD) {
1498                 unsigned long ua_flags = uaccess_save_and_enable();
1499                 n = __copy_to_user_std(to, from, n);
1500                 uaccess_restore(ua_flags);
1501 @@ -156,6 +252,26 @@ arm_copy_to_user(void __user *to, const
1502         }
1503         return n;
1504  }
1505 +
1506 +unsigned long __must_check
1507 +arm_copy_from_user(void *to, const void __user *from, unsigned long n)
1508 +{
1509 +       /*
1510 +        * This test is stubbed out of the main function above to keep
1511 +        * the overhead for small copies low by avoiding a large
1512 +        * register dump on the stack just to reload them right away.
1513 +        * With frame pointer disabled, tail call optimization kicks in
1514 +        * as well making this test almost invisible.
1515 +        */
1516 +       if (n < COPY_TO_USER_THRESHOLD) {
1517 +               unsigned long ua_flags = uaccess_save_and_enable();
1518 +               n = __copy_from_user_std(to, from, n);
1519 +               uaccess_restore(ua_flags);
1520 +       } else {
1521 +               n = __copy_from_user_memcpy(to, from, n);
1522 +       }
1523 +       return n;
1524 +}
1525
1526  static unsigned long noinline
1527  __clear_user_memset(void __user *addr, unsigned long n)
1528 --- a/arch/arm/mach-bcm/Kconfig
1529 +++ b/arch/arm/mach-bcm/Kconfig
1530 @@ -174,6 +174,13 @@ config ARCH_BCM_53573
1531           The base chip is BCM53573 and there are some packaging modifications
1532           like BCM47189 and BCM47452.
1533
1534 +config BCM2835_FAST_MEMCPY
1535 +       bool "Enable optimized __copy_to_user and __copy_from_user"
1536 +       depends on ARCH_BCM2835 && ARCH_MULTI_V6
1537 +       default y
1538 +       help
1539 +         Optimized versions of __copy_to_user and __copy_from_user for Pi1.
1540 +
1541  config ARCH_BCM_63XX
1542         bool "Broadcom BCM63xx DSL SoC"
1543         depends on ARCH_MULTI_V7