Remove obsolete #include <linux/config.h>
[linux-3.10.git] / arch / parisc / lib / memcpy.c
1 /*
2  *    Optimized memory copy routines.
3  *
4  *    Copyright (C) 2004 Randolph Chung <tausq@debian.org>
5  *
6  *    This program is free software; you can redistribute it and/or modify
7  *    it under the terms of the GNU General Public License as published by
8  *    the Free Software Foundation; either version 2, or (at your option)
9  *    any later version.
10  *
11  *    This program is distributed in the hope that it will be useful,
12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *    GNU General Public License for more details.
15  *
16  *    You should have received a copy of the GNU General Public License
17  *    along with this program; if not, write to the Free Software
18  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  *
20  *    Portions derived from the GNU C Library
21  *    Copyright (C) 1991, 1997, 2003 Free Software Foundation, Inc.
22  *
23  * Several strategies are tried to try to get the best performance for various
24  * conditions. In the optimal case, we copy 64-bytes in an unrolled loop using 
25  * fp regs. This is followed by loops that copy 32- or 16-bytes at a time using
26  * general registers.  Unaligned copies are handled either by aligning the 
27  * destination and then using shift-and-write method, or in a few cases by 
28  * falling back to a byte-at-a-time copy.
29  *
30  * I chose to implement this in C because it is easier to maintain and debug,
31  * and in my experiments it appears that the C code generated by gcc (3.3/3.4
32  * at the time of writing) is fairly optimal. Unfortunately some of the 
33  * semantics of the copy routine (exception handling) is difficult to express
34  * in C, so we have to play some tricks to get it to work.
35  *
36  * All the loads and stores are done via explicit asm() code in order to use
37  * the right space registers. 
38  * 
39  * Testing with various alignments and buffer sizes shows that this code is 
40  * often >10x faster than a simple byte-at-a-time copy, even for strangely
41  * aligned operands. It is interesting to note that the glibc version
42  * of memcpy (written in C) is actually quite fast already. This routine is 
43  * able to beat it by 30-40% for aligned copies because of the loop unrolling, 
44  * but in some cases the glibc version is still slightly faster. This lends 
45  * more credibility that gcc can generate very good code as long as we are 
46  * careful.
47  *
48  * TODO:
49  * - cache prefetching needs more experimentation to get optimal settings
50  * - try not to use the post-increment address modifiers; they create additional
51  *   interlocks
52  * - replace byte-copy loops with stybs sequences
53  */
54
55 #ifdef __KERNEL__
56 #include <linux/module.h>
57 #include <linux/compiler.h>
58 #include <asm/uaccess.h>
59 #define s_space "%%sr1"
60 #define d_space "%%sr2"
61 #else
62 #include "memcpy.h"
63 #define s_space "%%sr0"
64 #define d_space "%%sr0"
65 #define pa_memcpy new2_copy
66 #endif
67
68 DECLARE_PER_CPU(struct exception_data, exception_data);
69
70 #define preserve_branch(label)  do {                                    \
71         volatile int dummy;                                             \
72         /* The following branch is never taken, it's just here to  */   \
73         /* prevent gcc from optimizing away our exception code. */      \
74         if (unlikely(dummy != dummy))                                   \
75                 goto label;                                             \
76 } while (0)
77
78 #define get_user_space() (segment_eq(get_fs(), KERNEL_DS) ? 0 : mfsp(3))
79 #define get_kernel_space() (0)
80
81 #define MERGE(w0, sh_1, w1, sh_2)  ({                                   \
82         unsigned int _r;                                                \
83         asm volatile (                                                  \
84         "mtsar %3\n"                                                    \
85         "shrpw %1, %2, %%sar, %0\n"                                     \
86         : "=r"(_r)                                                      \
87         : "r"(w0), "r"(w1), "r"(sh_2)                                   \
88         );                                                              \
89         _r;                                                             \
90 })
91 #define THRESHOLD       16
92
93 #ifdef DEBUG_MEMCPY
94 #define DPRINTF(fmt, args...) do { printk(KERN_DEBUG "%s:%d:%s ", __FILE__, __LINE__, __FUNCTION__ ); printk(KERN_DEBUG fmt, ##args ); } while (0)
95 #else
96 #define DPRINTF(fmt, args...)
97 #endif
98
99 #ifndef __LP64__
100 #define EXC_WORD ".word"
101 #else
102 #define EXC_WORD ".dword"
103 #endif
104
105 #define def_load_ai_insn(_insn,_sz,_tt,_s,_a,_t,_e)     \
106         __asm__ __volatile__ (                          \
107         "1:\t" #_insn ",ma " #_sz "(" _s ",%1), %0\n"   \
108         "\t.section __ex_table,\"aw\"\n"                \
109         "\t" EXC_WORD "\t1b\n"                          \
110         "\t" EXC_WORD "\t" #_e "\n"                     \
111         "\t.previous\n"                                 \
112         : _tt(_t), "+r"(_a)                             \
113         :                                               \
114         : "r8")
115
116 #define def_store_ai_insn(_insn,_sz,_tt,_s,_a,_t,_e)    \
117         __asm__ __volatile__ (                          \
118         "1:\t" #_insn ",ma %1, " #_sz "(" _s ",%0)\n"   \
119         "\t.section __ex_table,\"aw\"\n"                \
120         "\t" EXC_WORD "\t1b\n"                          \
121         "\t" EXC_WORD "\t" #_e "\n"                     \
122         "\t.previous\n"                                 \
123         : "+r"(_a)                                      \
124         : _tt(_t)                                       \
125         : "r8")
126
127 #define ldbma(_s, _a, _t, _e) def_load_ai_insn(ldbs,1,"=r",_s,_a,_t,_e)
128 #define stbma(_s, _t, _a, _e) def_store_ai_insn(stbs,1,"r",_s,_a,_t,_e)
129 #define ldwma(_s, _a, _t, _e) def_load_ai_insn(ldw,4,"=r",_s,_a,_t,_e)
130 #define stwma(_s, _t, _a, _e) def_store_ai_insn(stw,4,"r",_s,_a,_t,_e)
131 #define flddma(_s, _a, _t, _e) def_load_ai_insn(fldd,8,"=f",_s,_a,_t,_e)
132 #define fstdma(_s, _t, _a, _e) def_store_ai_insn(fstd,8,"f",_s,_a,_t,_e)
133
134 #define def_load_insn(_insn,_tt,_s,_o,_a,_t,_e)         \
135         __asm__ __volatile__ (                          \
136         "1:\t" #_insn " " #_o "(" _s ",%1), %0\n"       \
137         "\t.section __ex_table,\"aw\"\n"                \
138         "\t" EXC_WORD "\t1b\n"                          \
139         "\t" EXC_WORD "\t" #_e "\n"                     \
140         "\t.previous\n"                                 \
141         : _tt(_t)                                       \
142         : "r"(_a)                                       \
143         : "r8")
144
145 #define def_store_insn(_insn,_tt,_s,_t,_o,_a,_e)        \
146         __asm__ __volatile__ (                          \
147         "1:\t" #_insn " %0, " #_o "(" _s ",%1)\n"       \
148         "\t.section __ex_table,\"aw\"\n"                \
149         "\t" EXC_WORD "\t1b\n"                          \
150         "\t" EXC_WORD "\t" #_e "\n"                     \
151         "\t.previous\n"                                 \
152         :                                               \
153         : _tt(_t), "r"(_a)                              \
154         : "r8")
155
156 #define ldw(_s,_o,_a,_t,_e)     def_load_insn(ldw,"=r",_s,_o,_a,_t,_e)
157 #define stw(_s,_t,_o,_a,_e)     def_store_insn(stw,"r",_s,_t,_o,_a,_e)
158
159 #ifdef  CONFIG_PREFETCH
160 extern inline void prefetch_src(const void *addr)
161 {
162         __asm__("ldw 0(" s_space ",%0), %%r0" : : "r" (addr));
163 }
164
165 extern inline void prefetch_dst(const void *addr)
166 {
167         __asm__("ldd 0(" d_space ",%0), %%r0" : : "r" (addr));
168 }
169 #else
170 #define prefetch_src(addr)
171 #define prefetch_dst(addr)
172 #endif
173
174 /* Copy from a not-aligned src to an aligned dst, using shifts. Handles 4 words
175  * per loop.  This code is derived from glibc. 
176  */
177 static inline unsigned long copy_dstaligned(unsigned long dst, unsigned long src, unsigned long len, unsigned long o_dst, unsigned long o_src, unsigned long o_len)
178 {
179         /* gcc complains that a2 and a3 may be uninitialized, but actually
180          * they cannot be.  Initialize a2/a3 to shut gcc up.
181          */
182         register unsigned int a0, a1, a2 = 0, a3 = 0;
183         int sh_1, sh_2;
184         struct exception_data *d;
185
186         /* prefetch_src((const void *)src); */
187
188         /* Calculate how to shift a word read at the memory operation
189            aligned srcp to make it aligned for copy.  */
190         sh_1 = 8 * (src % sizeof(unsigned int));
191         sh_2 = 8 * sizeof(unsigned int) - sh_1;
192
193         /* Make src aligned by rounding it down.  */
194         src &= -sizeof(unsigned int);
195
196         switch (len % 4)
197         {
198                 case 2:
199                         /* a1 = ((unsigned int *) src)[0];
200                            a2 = ((unsigned int *) src)[1]; */
201                         ldw(s_space, 0, src, a1, cda_ldw_exc);
202                         ldw(s_space, 4, src, a2, cda_ldw_exc);
203                         src -= 1 * sizeof(unsigned int);
204                         dst -= 3 * sizeof(unsigned int);
205                         len += 2;
206                         goto do1;
207                 case 3:
208                         /* a0 = ((unsigned int *) src)[0];
209                            a1 = ((unsigned int *) src)[1]; */
210                         ldw(s_space, 0, src, a0, cda_ldw_exc);
211                         ldw(s_space, 4, src, a1, cda_ldw_exc);
212                         src -= 0 * sizeof(unsigned int);
213                         dst -= 2 * sizeof(unsigned int);
214                         len += 1;
215                         goto do2;
216                 case 0:
217                         if (len == 0)
218                                 return 0;
219                         /* a3 = ((unsigned int *) src)[0];
220                            a0 = ((unsigned int *) src)[1]; */
221                         ldw(s_space, 0, src, a3, cda_ldw_exc);
222                         ldw(s_space, 4, src, a0, cda_ldw_exc);
223                         src -=-1 * sizeof(unsigned int);
224                         dst -= 1 * sizeof(unsigned int);
225                         len += 0;
226                         goto do3;
227                 case 1:
228                         /* a2 = ((unsigned int *) src)[0];
229                            a3 = ((unsigned int *) src)[1]; */
230                         ldw(s_space, 0, src, a2, cda_ldw_exc);
231                         ldw(s_space, 4, src, a3, cda_ldw_exc);
232                         src -=-2 * sizeof(unsigned int);
233                         dst -= 0 * sizeof(unsigned int);
234                         len -= 1;
235                         if (len == 0)
236                                 goto do0;
237                         goto do4;                       /* No-op.  */
238         }
239
240         do
241         {
242                 /* prefetch_src((const void *)(src + 4 * sizeof(unsigned int))); */
243 do4:
244                 /* a0 = ((unsigned int *) src)[0]; */
245                 ldw(s_space, 0, src, a0, cda_ldw_exc);
246                 /* ((unsigned int *) dst)[0] = MERGE (a2, sh_1, a3, sh_2); */
247                 stw(d_space, MERGE (a2, sh_1, a3, sh_2), 0, dst, cda_stw_exc);
248 do3:
249                 /* a1 = ((unsigned int *) src)[1]; */
250                 ldw(s_space, 4, src, a1, cda_ldw_exc);
251                 /* ((unsigned int *) dst)[1] = MERGE (a3, sh_1, a0, sh_2); */
252                 stw(d_space, MERGE (a3, sh_1, a0, sh_2), 4, dst, cda_stw_exc);
253 do2:
254                 /* a2 = ((unsigned int *) src)[2]; */
255                 ldw(s_space, 8, src, a2, cda_ldw_exc);
256                 /* ((unsigned int *) dst)[2] = MERGE (a0, sh_1, a1, sh_2); */
257                 stw(d_space, MERGE (a0, sh_1, a1, sh_2), 8, dst, cda_stw_exc);
258 do1:
259                 /* a3 = ((unsigned int *) src)[3]; */
260                 ldw(s_space, 12, src, a3, cda_ldw_exc);
261                 /* ((unsigned int *) dst)[3] = MERGE (a1, sh_1, a2, sh_2); */
262                 stw(d_space, MERGE (a1, sh_1, a2, sh_2), 12, dst, cda_stw_exc);
263
264                 src += 4 * sizeof(unsigned int);
265                 dst += 4 * sizeof(unsigned int);
266                 len -= 4;
267         }
268         while (len != 0);
269
270 do0:
271         /* ((unsigned int *) dst)[0] = MERGE (a2, sh_1, a3, sh_2); */
272         stw(d_space, MERGE (a2, sh_1, a3, sh_2), 0, dst, cda_stw_exc);
273
274         preserve_branch(handle_load_error);
275         preserve_branch(handle_store_error);
276
277         return 0;
278
279 handle_load_error:
280         __asm__ __volatile__ ("cda_ldw_exc:\n");
281         d = &__get_cpu_var(exception_data);
282         DPRINTF("cda_ldw_exc: o_len=%lu fault_addr=%lu o_src=%lu ret=%lu\n",
283                 o_len, d->fault_addr, o_src, o_len - d->fault_addr + o_src);
284         return o_len * 4 - d->fault_addr + o_src;
285
286 handle_store_error:
287         __asm__ __volatile__ ("cda_stw_exc:\n");
288         d = &__get_cpu_var(exception_data);
289         DPRINTF("cda_stw_exc: o_len=%lu fault_addr=%lu o_dst=%lu ret=%lu\n",
290                 o_len, d->fault_addr, o_dst, o_len - d->fault_addr + o_dst);
291         return o_len * 4 - d->fault_addr + o_dst;
292 }
293
294
295 /* Returns 0 for success, otherwise, returns number of bytes not transferred. */
296 unsigned long pa_memcpy(void *dstp, const void *srcp, unsigned long len)
297 {
298         register unsigned long src, dst, t1, t2, t3;
299         register unsigned char *pcs, *pcd;
300         register unsigned int *pws, *pwd;
301         register double *pds, *pdd;
302         unsigned long ret = 0;
303         unsigned long o_dst, o_src, o_len;
304         struct exception_data *d;
305
306         src = (unsigned long)srcp;
307         dst = (unsigned long)dstp;
308         pcs = (unsigned char *)srcp;
309         pcd = (unsigned char *)dstp;
310
311         o_dst = dst; o_src = src; o_len = len;
312
313         /* prefetch_src((const void *)srcp); */
314
315         if (len < THRESHOLD)
316                 goto byte_copy;
317
318         /* Check alignment */
319         t1 = (src ^ dst);
320         if (unlikely(t1 & (sizeof(double)-1)))
321                 goto unaligned_copy;
322
323         /* src and dst have same alignment. */
324
325         /* Copy bytes till we are double-aligned. */
326         t2 = src & (sizeof(double) - 1);
327         if (unlikely(t2 != 0)) {
328                 t2 = sizeof(double) - t2;
329                 while (t2 && len) {
330                         /* *pcd++ = *pcs++; */
331                         ldbma(s_space, pcs, t3, pmc_load_exc);
332                         len--;
333                         stbma(d_space, t3, pcd, pmc_store_exc);
334                         t2--;
335                 }
336         }
337
338         pds = (double *)pcs;
339         pdd = (double *)pcd;
340
341 #if 0
342         /* Copy 8 doubles at a time */
343         while (len >= 8*sizeof(double)) {
344                 register double r1, r2, r3, r4, r5, r6, r7, r8;
345                 /* prefetch_src((char *)pds + L1_CACHE_BYTES); */
346                 flddma(s_space, pds, r1, pmc_load_exc);
347                 flddma(s_space, pds, r2, pmc_load_exc);
348                 flddma(s_space, pds, r3, pmc_load_exc);
349                 flddma(s_space, pds, r4, pmc_load_exc);
350                 fstdma(d_space, r1, pdd, pmc_store_exc);
351                 fstdma(d_space, r2, pdd, pmc_store_exc);
352                 fstdma(d_space, r3, pdd, pmc_store_exc);
353                 fstdma(d_space, r4, pdd, pmc_store_exc);
354
355 #if 0
356                 if (L1_CACHE_BYTES <= 32)
357                         prefetch_src((char *)pds + L1_CACHE_BYTES);
358 #endif
359                 flddma(s_space, pds, r5, pmc_load_exc);
360                 flddma(s_space, pds, r6, pmc_load_exc);
361                 flddma(s_space, pds, r7, pmc_load_exc);
362                 flddma(s_space, pds, r8, pmc_load_exc);
363                 fstdma(d_space, r5, pdd, pmc_store_exc);
364                 fstdma(d_space, r6, pdd, pmc_store_exc);
365                 fstdma(d_space, r7, pdd, pmc_store_exc);
366                 fstdma(d_space, r8, pdd, pmc_store_exc);
367                 len -= 8*sizeof(double);
368         }
369 #endif
370
371         pws = (unsigned int *)pds;
372         pwd = (unsigned int *)pdd;
373
374 word_copy:
375         while (len >= 8*sizeof(unsigned int)) {
376                 register unsigned int r1,r2,r3,r4,r5,r6,r7,r8;
377                 /* prefetch_src((char *)pws + L1_CACHE_BYTES); */
378                 ldwma(s_space, pws, r1, pmc_load_exc);
379                 ldwma(s_space, pws, r2, pmc_load_exc);
380                 ldwma(s_space, pws, r3, pmc_load_exc);
381                 ldwma(s_space, pws, r4, pmc_load_exc);
382                 stwma(d_space, r1, pwd, pmc_store_exc);
383                 stwma(d_space, r2, pwd, pmc_store_exc);
384                 stwma(d_space, r3, pwd, pmc_store_exc);
385                 stwma(d_space, r4, pwd, pmc_store_exc);
386
387                 ldwma(s_space, pws, r5, pmc_load_exc);
388                 ldwma(s_space, pws, r6, pmc_load_exc);
389                 ldwma(s_space, pws, r7, pmc_load_exc);
390                 ldwma(s_space, pws, r8, pmc_load_exc);
391                 stwma(d_space, r5, pwd, pmc_store_exc);
392                 stwma(d_space, r6, pwd, pmc_store_exc);
393                 stwma(d_space, r7, pwd, pmc_store_exc);
394                 stwma(d_space, r8, pwd, pmc_store_exc);
395                 len -= 8*sizeof(unsigned int);
396         }
397
398         while (len >= 4*sizeof(unsigned int)) {
399                 register unsigned int r1,r2,r3,r4;
400                 ldwma(s_space, pws, r1, pmc_load_exc);
401                 ldwma(s_space, pws, r2, pmc_load_exc);
402                 ldwma(s_space, pws, r3, pmc_load_exc);
403                 ldwma(s_space, pws, r4, pmc_load_exc);
404                 stwma(d_space, r1, pwd, pmc_store_exc);
405                 stwma(d_space, r2, pwd, pmc_store_exc);
406                 stwma(d_space, r3, pwd, pmc_store_exc);
407                 stwma(d_space, r4, pwd, pmc_store_exc);
408                 len -= 4*sizeof(unsigned int);
409         }
410
411         pcs = (unsigned char *)pws;
412         pcd = (unsigned char *)pwd;
413
414 byte_copy:
415         while (len) {
416                 /* *pcd++ = *pcs++; */
417                 ldbma(s_space, pcs, t3, pmc_load_exc);
418                 stbma(d_space, t3, pcd, pmc_store_exc);
419                 len--;
420         }
421
422         return 0;
423
424 unaligned_copy:
425         /* possibly we are aligned on a word, but not on a double... */
426         if (likely(t1 & (sizeof(unsigned int)-1)) == 0) {
427                 t2 = src & (sizeof(unsigned int) - 1);
428
429                 if (unlikely(t2 != 0)) {
430                         t2 = sizeof(unsigned int) - t2;
431                         while (t2) {
432                                 /* *pcd++ = *pcs++; */
433                                 ldbma(s_space, pcs, t3, pmc_load_exc);
434                                 stbma(d_space, t3, pcd, pmc_store_exc);
435                                 len--;
436                                 t2--;
437                         }
438                 }
439
440                 pws = (unsigned int *)pcs;
441                 pwd = (unsigned int *)pcd;
442                 goto word_copy;
443         }
444
445         /* Align the destination.  */
446         if (unlikely((dst & (sizeof(unsigned int) - 1)) != 0)) {
447                 t2 = sizeof(unsigned int) - (dst & (sizeof(unsigned int) - 1));
448                 while (t2) {
449                         /* *pcd++ = *pcs++; */
450                         ldbma(s_space, pcs, t3, pmc_load_exc);
451                         stbma(d_space, t3, pcd, pmc_store_exc);
452                         len--;
453                         t2--;
454                 }
455                 dst = (unsigned long)pcd;
456                 src = (unsigned long)pcs;
457         }
458
459         ret = copy_dstaligned(dst, src, len / sizeof(unsigned int), 
460                 o_dst, o_src, o_len);
461         if (ret)
462                 return ret;
463
464         pcs += (len & -sizeof(unsigned int));
465         pcd += (len & -sizeof(unsigned int));
466         len %= sizeof(unsigned int);
467
468         preserve_branch(handle_load_error);
469         preserve_branch(handle_store_error);
470
471         goto byte_copy;
472
473 handle_load_error:
474         __asm__ __volatile__ ("pmc_load_exc:\n");
475         d = &__get_cpu_var(exception_data);
476         DPRINTF("pmc_load_exc: o_len=%lu fault_addr=%lu o_src=%lu ret=%lu\n",
477                 o_len, d->fault_addr, o_src, o_len - d->fault_addr + o_src);
478         return o_len - d->fault_addr + o_src;
479
480 handle_store_error:
481         __asm__ __volatile__ ("pmc_store_exc:\n");
482         d = &__get_cpu_var(exception_data);
483         DPRINTF("pmc_store_exc: o_len=%lu fault_addr=%lu o_dst=%lu ret=%lu\n",
484                 o_len, d->fault_addr, o_dst, o_len - d->fault_addr + o_dst);
485         return o_len - d->fault_addr + o_dst;
486 }
487
488 #ifdef __KERNEL__
489 unsigned long copy_to_user(void __user *dst, const void *src, unsigned long len)
490 {
491         mtsp(get_kernel_space(), 1);
492         mtsp(get_user_space(), 2);
493         return pa_memcpy((void __force *)dst, src, len);
494 }
495
496 unsigned long copy_from_user(void *dst, const void __user *src, unsigned long len)
497 {
498         mtsp(get_user_space(), 1);
499         mtsp(get_kernel_space(), 2);
500         return pa_memcpy(dst, (void __force *)src, len);
501 }
502
503 unsigned long copy_in_user(void __user *dst, const void __user *src, unsigned long len)
504 {
505         mtsp(get_user_space(), 1);
506         mtsp(get_user_space(), 2);
507         return pa_memcpy((void __force *)dst, (void __force *)src, len);
508 }
509
510
511 void * memcpy(void * dst,const void *src, size_t count)
512 {
513         mtsp(get_kernel_space(), 1);
514         mtsp(get_kernel_space(), 2);
515         pa_memcpy(dst, src, count);
516         return dst;
517 }
518
519 EXPORT_SYMBOL(copy_to_user);
520 EXPORT_SYMBOL(copy_from_user);
521 EXPORT_SYMBOL(copy_in_user);
522 EXPORT_SYMBOL(memcpy);
523 #endif