1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
2f5d45dc9SStafford Horne /*
3f5d45dc9SStafford Horne * arch/openrisc/lib/memcpy.c
4f5d45dc9SStafford Horne *
5f5d45dc9SStafford Horne * Optimized memory copy routines for openrisc. These are mostly copied
6f5d45dc9SStafford Horne * from ohter sources but slightly entended based on ideas discuassed in
7f5d45dc9SStafford Horne * #openrisc.
8f5d45dc9SStafford Horne *
9f5d45dc9SStafford Horne * The word unroll implementation is an extension to the arm byte
10f5d45dc9SStafford Horne * unrolled implementation, but using word copies (if things are
11f5d45dc9SStafford Horne * properly aligned)
12f5d45dc9SStafford Horne *
13f5d45dc9SStafford Horne * The great arm loop unroll algorithm can be found at:
14f5d45dc9SStafford Horne * arch/arm/boot/compressed/string.c
15f5d45dc9SStafford Horne */
16f5d45dc9SStafford Horne
17f5d45dc9SStafford Horne #include <linux/export.h>
18f5d45dc9SStafford Horne
19f5d45dc9SStafford Horne #include <linux/string.h>
20f5d45dc9SStafford Horne
21e34f671dSValentin Rothberg #ifdef CONFIG_OR1K_1200
22f5d45dc9SStafford Horne /*
23f5d45dc9SStafford Horne * Do memcpy with word copies and loop unrolling. This gives the
24f5d45dc9SStafford Horne * best performance on the OR1200 and MOR1KX archirectures
25f5d45dc9SStafford Horne */
memcpy(void * dest,__const void * src,__kernel_size_t n)26f5d45dc9SStafford Horne void *memcpy(void *dest, __const void *src, __kernel_size_t n)
27f5d45dc9SStafford Horne {
28f5d45dc9SStafford Horne int i = 0;
29f5d45dc9SStafford Horne unsigned char *d, *s;
30f5d45dc9SStafford Horne uint32_t *dest_w = (uint32_t *)dest, *src_w = (uint32_t *)src;
31f5d45dc9SStafford Horne
32f5d45dc9SStafford Horne /* If both source and dest are word aligned copy words */
33f5d45dc9SStafford Horne if (!((unsigned int)dest_w & 3) && !((unsigned int)src_w & 3)) {
34f5d45dc9SStafford Horne /* Copy 32 bytes per loop */
35f5d45dc9SStafford Horne for (i = n >> 5; i > 0; i--) {
36f5d45dc9SStafford Horne *dest_w++ = *src_w++;
37f5d45dc9SStafford Horne *dest_w++ = *src_w++;
38f5d45dc9SStafford Horne *dest_w++ = *src_w++;
39f5d45dc9SStafford Horne *dest_w++ = *src_w++;
40f5d45dc9SStafford Horne *dest_w++ = *src_w++;
41f5d45dc9SStafford Horne *dest_w++ = *src_w++;
42f5d45dc9SStafford Horne *dest_w++ = *src_w++;
43f5d45dc9SStafford Horne *dest_w++ = *src_w++;
44f5d45dc9SStafford Horne }
45f5d45dc9SStafford Horne
46f5d45dc9SStafford Horne if (n & 1 << 4) {
47f5d45dc9SStafford Horne *dest_w++ = *src_w++;
48f5d45dc9SStafford Horne *dest_w++ = *src_w++;
49f5d45dc9SStafford Horne *dest_w++ = *src_w++;
50f5d45dc9SStafford Horne *dest_w++ = *src_w++;
51f5d45dc9SStafford Horne }
52f5d45dc9SStafford Horne
53f5d45dc9SStafford Horne if (n & 1 << 3) {
54f5d45dc9SStafford Horne *dest_w++ = *src_w++;
55f5d45dc9SStafford Horne *dest_w++ = *src_w++;
56f5d45dc9SStafford Horne }
57f5d45dc9SStafford Horne
58f5d45dc9SStafford Horne if (n & 1 << 2)
59f5d45dc9SStafford Horne *dest_w++ = *src_w++;
60f5d45dc9SStafford Horne
61f5d45dc9SStafford Horne d = (unsigned char *)dest_w;
62f5d45dc9SStafford Horne s = (unsigned char *)src_w;
63f5d45dc9SStafford Horne
64f5d45dc9SStafford Horne } else {
65f5d45dc9SStafford Horne d = (unsigned char *)dest_w;
66f5d45dc9SStafford Horne s = (unsigned char *)src_w;
67f5d45dc9SStafford Horne
68f5d45dc9SStafford Horne for (i = n >> 3; i > 0; i--) {
69f5d45dc9SStafford Horne *d++ = *s++;
70f5d45dc9SStafford Horne *d++ = *s++;
71f5d45dc9SStafford Horne *d++ = *s++;
72f5d45dc9SStafford Horne *d++ = *s++;
73f5d45dc9SStafford Horne *d++ = *s++;
74f5d45dc9SStafford Horne *d++ = *s++;
75f5d45dc9SStafford Horne *d++ = *s++;
76f5d45dc9SStafford Horne *d++ = *s++;
77f5d45dc9SStafford Horne }
78f5d45dc9SStafford Horne
79f5d45dc9SStafford Horne if (n & 1 << 2) {
80f5d45dc9SStafford Horne *d++ = *s++;
81f5d45dc9SStafford Horne *d++ = *s++;
82f5d45dc9SStafford Horne *d++ = *s++;
83f5d45dc9SStafford Horne *d++ = *s++;
84f5d45dc9SStafford Horne }
85f5d45dc9SStafford Horne }
86f5d45dc9SStafford Horne
87f5d45dc9SStafford Horne if (n & 1 << 1) {
88f5d45dc9SStafford Horne *d++ = *s++;
89f5d45dc9SStafford Horne *d++ = *s++;
90f5d45dc9SStafford Horne }
91f5d45dc9SStafford Horne
92f5d45dc9SStafford Horne if (n & 1)
93f5d45dc9SStafford Horne *d++ = *s++;
94f5d45dc9SStafford Horne
95f5d45dc9SStafford Horne return dest;
96f5d45dc9SStafford Horne }
97f5d45dc9SStafford Horne #else
98f5d45dc9SStafford Horne /*
99f5d45dc9SStafford Horne * Use word copies but no loop unrolling as we cannot assume there
100f5d45dc9SStafford Horne * will be benefits on the archirecture
101f5d45dc9SStafford Horne */
memcpy(void * dest,__const void * src,__kernel_size_t n)102f5d45dc9SStafford Horne void *memcpy(void *dest, __const void *src, __kernel_size_t n)
103f5d45dc9SStafford Horne {
104*862cf8d5SKuniyuki Iwashima unsigned char *d, *s;
105f5d45dc9SStafford Horne uint32_t *dest_w = (uint32_t *)dest, *src_w = (uint32_t *)src;
106f5d45dc9SStafford Horne
107f5d45dc9SStafford Horne /* If both source and dest are word aligned copy words */
108f5d45dc9SStafford Horne if (!((unsigned int)dest_w & 3) && !((unsigned int)src_w & 3)) {
109f5d45dc9SStafford Horne for (; n >= 4; n -= 4)
110f5d45dc9SStafford Horne *dest_w++ = *src_w++;
111f5d45dc9SStafford Horne }
112f5d45dc9SStafford Horne
113f5d45dc9SStafford Horne d = (unsigned char *)dest_w;
114f5d45dc9SStafford Horne s = (unsigned char *)src_w;
115f5d45dc9SStafford Horne
116f5d45dc9SStafford Horne /* For remaining or if not aligned, copy bytes */
117f5d45dc9SStafford Horne for (; n >= 1; n -= 1)
118f5d45dc9SStafford Horne *d++ = *s++;
119f5d45dc9SStafford Horne
120f5d45dc9SStafford Horne return dest;
121f5d45dc9SStafford Horne
122f5d45dc9SStafford Horne }
123f5d45dc9SStafford Horne #endif
124f5d45dc9SStafford Horne
125f5d45dc9SStafford Horne EXPORT_SYMBOL(memcpy);
126