arm64: dts: Revert "specify console via command line"
[linux/fpc-iii.git] / arch / sparc / lib / NG4memcpy.S
blob7ad58ebe0d0096ffce4a9a333eb9cc7113c065fe
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* NG4memcpy.S: Niagara-4 optimized memcpy.
3  *
4  * Copyright (C) 2012 David S. Miller (davem@davemloft.net)
5  */
7 #ifdef __KERNEL__
8 #include <linux/linkage.h>
9 #include <asm/visasm.h>
10 #include <asm/asi.h>
11 #define GLOBAL_SPARE    %g7
12 #else
13 #define ASI_BLK_INIT_QUAD_LDD_P 0xe2
14 #define FPRS_FEF  0x04
16 /* On T4 it is very expensive to access ASRs like %fprs and
17  * %asi, avoiding a read or a write can save ~50 cycles.
18  */
19 #define FPU_ENTER                       \
20         rd      %fprs, %o5;             \
21         andcc   %o5, FPRS_FEF, %g0;     \
22         be,a,pn %icc, 999f;             \
23          wr     %g0, FPRS_FEF, %fprs;   \
24         999:
26 #ifdef MEMCPY_DEBUG
27 #define VISEntryHalf FPU_ENTER; \
28                      clr %g1; clr %g2; clr %g3; clr %g5; subcc %g0, %g0, %g0;
29 #define VISExitHalf and %o5, FPRS_FEF, %o5; wr %o5, 0x0, %fprs
30 #else
31 #define VISEntryHalf FPU_ENTER
32 #define VISExitHalf and %o5, FPRS_FEF, %o5; wr %o5, 0x0, %fprs
33 #endif
35 #define GLOBAL_SPARE    %g5
36 #endif
38 #ifndef STORE_ASI
39 #ifndef SIMULATE_NIAGARA_ON_NON_NIAGARA
40 #define STORE_ASI       ASI_BLK_INIT_QUAD_LDD_P
41 #else
42 #define STORE_ASI       0x80            /* ASI_P */
43 #endif
44 #endif
46 #if !defined(EX_LD) && !defined(EX_ST)
47 #define NON_USER_COPY
48 #endif
50 #ifndef EX_LD
51 #define EX_LD(x,y)      x
52 #endif
53 #ifndef EX_LD_FP
54 #define EX_LD_FP(x,y)   x
55 #endif
57 #ifndef EX_ST
58 #define EX_ST(x,y)      x
59 #endif
60 #ifndef EX_ST_FP
61 #define EX_ST_FP(x,y)   x
62 #endif
65 #ifndef LOAD
66 #define LOAD(type,addr,dest)    type [addr], dest
67 #endif
69 #ifndef STORE
70 #ifndef MEMCPY_DEBUG
71 #define STORE(type,src,addr)    type src, [addr]
72 #else
73 #define STORE(type,src,addr)    type##a src, [addr] %asi
74 #endif
75 #endif
77 #ifndef STORE_INIT
78 #define STORE_INIT(src,addr)    stxa src, [addr] STORE_ASI
79 #endif
81 #ifndef FUNC_NAME
82 #define FUNC_NAME       NG4memcpy
83 #endif
84 #ifndef PREAMBLE
85 #define PREAMBLE
86 #endif
88 #ifndef XCC
89 #define XCC xcc
90 #endif
92         .register       %g2,#scratch
93         .register       %g3,#scratch
95         .text
96 #ifndef EX_RETVAL
97 #define EX_RETVAL(x)    x
98 #endif
99         .align          64
101         .globl  FUNC_NAME
102         .type   FUNC_NAME,#function
103 FUNC_NAME:      /* %o0=dst, %o1=src, %o2=len */
104 #ifdef MEMCPY_DEBUG
105         wr              %g0, 0x80, %asi
106 #endif
107         srlx            %o2, 31, %g2
108         cmp             %g2, 0
109         tne             %XCC, 5
110         PREAMBLE
111         mov             %o0, %o3
112         brz,pn          %o2, .Lexit
113          cmp            %o2, 3
114         ble,pn          %icc, .Ltiny
115          cmp            %o2, 19
116         ble,pn          %icc, .Lsmall
117          or             %o0, %o1, %g2
118         cmp             %o2, 128
119         bl,pn           %icc, .Lmedium
120          nop
122 .Llarge:/* len >= 0x80 */
123         /* First get dest 8 byte aligned.  */
124         sub             %g0, %o0, %g1
125         and             %g1, 0x7, %g1
126         brz,pt          %g1, 51f
127          sub            %o2, %g1, %o2
130 1:      EX_LD(LOAD(ldub, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
131         add             %o1, 1, %o1
132         subcc           %g1, 1, %g1
133         add             %o0, 1, %o0
134         bne,pt          %icc, 1b
135          EX_ST(STORE(stb, %g2, %o0 - 0x01), memcpy_retl_o2_plus_g1_plus_1)
137 51:     LOAD(prefetch, %o1 + 0x040, #n_reads_strong)
138         LOAD(prefetch, %o1 + 0x080, #n_reads_strong)
139         LOAD(prefetch, %o1 + 0x0c0, #n_reads_strong)
140         LOAD(prefetch, %o1 + 0x100, #n_reads_strong)
141         LOAD(prefetch, %o1 + 0x140, #n_reads_strong)
142         LOAD(prefetch, %o1 + 0x180, #n_reads_strong)
143         LOAD(prefetch, %o1 + 0x1c0, #n_reads_strong)
144         LOAD(prefetch, %o1 + 0x200, #n_reads_strong)
146         /* Check if we can use the straight fully aligned
147          * loop, or we require the alignaddr/faligndata variant.
148          */
149         andcc           %o1, 0x7, %o5
150         bne,pn          %icc, .Llarge_src_unaligned
151          sub            %g0, %o0, %g1
153         /* Legitimize the use of initializing stores by getting dest
154          * to be 64-byte aligned.
155          */
156         and             %g1, 0x3f, %g1
157         brz,pt          %g1, .Llarge_aligned
158          sub            %o2, %g1, %o2
160 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
161         add             %o1, 8, %o1
162         subcc           %g1, 8, %g1
163         add             %o0, 8, %o0
164         bne,pt          %icc, 1b
165          EX_ST(STORE(stx, %g2, %o0 - 0x08), memcpy_retl_o2_plus_g1_plus_8)
167 .Llarge_aligned:
168         /* len >= 0x80 && src 8-byte aligned && dest 8-byte aligned */
169         andn            %o2, 0x3f, %o4
170         sub             %o2, %o4, %o2
172 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o4)
173         add             %o1, 0x40, %o1
174         EX_LD(LOAD(ldx, %o1 - 0x38, %g2), memcpy_retl_o2_plus_o4)
175         subcc           %o4, 0x40, %o4
176         EX_LD(LOAD(ldx, %o1 - 0x30, %g3), memcpy_retl_o2_plus_o4_plus_64)
177         EX_LD(LOAD(ldx, %o1 - 0x28, GLOBAL_SPARE), memcpy_retl_o2_plus_o4_plus_64)
178         EX_LD(LOAD(ldx, %o1 - 0x20, %o5), memcpy_retl_o2_plus_o4_plus_64)
179         EX_ST(STORE_INIT(%g1, %o0), memcpy_retl_o2_plus_o4_plus_64)
180         add             %o0, 0x08, %o0
181         EX_ST(STORE_INIT(%g2, %o0), memcpy_retl_o2_plus_o4_plus_56)
182         add             %o0, 0x08, %o0
183         EX_LD(LOAD(ldx, %o1 - 0x18, %g2), memcpy_retl_o2_plus_o4_plus_48)
184         EX_ST(STORE_INIT(%g3, %o0), memcpy_retl_o2_plus_o4_plus_48)
185         add             %o0, 0x08, %o0
186         EX_LD(LOAD(ldx, %o1 - 0x10, %g3), memcpy_retl_o2_plus_o4_plus_40)
187         EX_ST(STORE_INIT(GLOBAL_SPARE, %o0), memcpy_retl_o2_plus_o4_plus_40)
188         add             %o0, 0x08, %o0
189         EX_LD(LOAD(ldx, %o1 - 0x08, GLOBAL_SPARE), memcpy_retl_o2_plus_o4_plus_32)
190         EX_ST(STORE_INIT(%o5, %o0), memcpy_retl_o2_plus_o4_plus_32)
191         add             %o0, 0x08, %o0
192         EX_ST(STORE_INIT(%g2, %o0), memcpy_retl_o2_plus_o4_plus_24)
193         add             %o0, 0x08, %o0
194         EX_ST(STORE_INIT(%g3, %o0), memcpy_retl_o2_plus_o4_plus_16)
195         add             %o0, 0x08, %o0
196         EX_ST(STORE_INIT(GLOBAL_SPARE, %o0), memcpy_retl_o2_plus_o4_plus_8)
197         add             %o0, 0x08, %o0
198         bne,pt          %icc, 1b
199          LOAD(prefetch, %o1 + 0x200, #n_reads_strong)
201         membar          #StoreLoad | #StoreStore
203         brz,pn          %o2, .Lexit
204          cmp            %o2, 19
205         ble,pn          %icc, .Lsmall_unaligned
206          nop
207         ba,a,pt         %icc, .Lmedium_noprefetch
209 .Lexit: retl
210          mov            EX_RETVAL(%o3), %o0
212 .Llarge_src_unaligned:
213 #ifdef NON_USER_COPY
214         VISEntryHalfFast(.Lmedium_vis_entry_fail)
215 #else
216         VISEntryHalf
217 #endif
218         andn            %o2, 0x3f, %o4
219         sub             %o2, %o4, %o2
220         alignaddr       %o1, %g0, %g1
221         add             %o1, %o4, %o1
222         EX_LD_FP(LOAD(ldd, %g1 + 0x00, %f0), memcpy_retl_o2_plus_o4)
223 1:      EX_LD_FP(LOAD(ldd, %g1 + 0x08, %f2), memcpy_retl_o2_plus_o4)
224         subcc           %o4, 0x40, %o4
225         EX_LD_FP(LOAD(ldd, %g1 + 0x10, %f4), memcpy_retl_o2_plus_o4_plus_64)
226         EX_LD_FP(LOAD(ldd, %g1 + 0x18, %f6), memcpy_retl_o2_plus_o4_plus_64)
227         EX_LD_FP(LOAD(ldd, %g1 + 0x20, %f8), memcpy_retl_o2_plus_o4_plus_64)
228         EX_LD_FP(LOAD(ldd, %g1 + 0x28, %f10), memcpy_retl_o2_plus_o4_plus_64)
229         EX_LD_FP(LOAD(ldd, %g1 + 0x30, %f12), memcpy_retl_o2_plus_o4_plus_64)
230         EX_LD_FP(LOAD(ldd, %g1 + 0x38, %f14), memcpy_retl_o2_plus_o4_plus_64)
231         faligndata      %f0, %f2, %f16
232         EX_LD_FP(LOAD(ldd, %g1 + 0x40, %f0), memcpy_retl_o2_plus_o4_plus_64)
233         faligndata      %f2, %f4, %f18
234         add             %g1, 0x40, %g1
235         faligndata      %f4, %f6, %f20
236         faligndata      %f6, %f8, %f22
237         faligndata      %f8, %f10, %f24
238         faligndata      %f10, %f12, %f26
239         faligndata      %f12, %f14, %f28
240         faligndata      %f14, %f0, %f30
241         EX_ST_FP(STORE(std, %f16, %o0 + 0x00), memcpy_retl_o2_plus_o4_plus_64)
242         EX_ST_FP(STORE(std, %f18, %o0 + 0x08), memcpy_retl_o2_plus_o4_plus_56)
243         EX_ST_FP(STORE(std, %f20, %o0 + 0x10), memcpy_retl_o2_plus_o4_plus_48)
244         EX_ST_FP(STORE(std, %f22, %o0 + 0x18), memcpy_retl_o2_plus_o4_plus_40)
245         EX_ST_FP(STORE(std, %f24, %o0 + 0x20), memcpy_retl_o2_plus_o4_plus_32)
246         EX_ST_FP(STORE(std, %f26, %o0 + 0x28), memcpy_retl_o2_plus_o4_plus_24)
247         EX_ST_FP(STORE(std, %f28, %o0 + 0x30), memcpy_retl_o2_plus_o4_plus_16)
248         EX_ST_FP(STORE(std, %f30, %o0 + 0x38), memcpy_retl_o2_plus_o4_plus_8)
249         add             %o0, 0x40, %o0
250         bne,pt          %icc, 1b
251          LOAD(prefetch, %g1 + 0x200, #n_reads_strong)
252 #ifdef NON_USER_COPY
253         VISExitHalfFast
254 #else
255         VISExitHalf
256 #endif
257         brz,pn          %o2, .Lexit
258          cmp            %o2, 19
259         ble,pn          %icc, .Lsmall_unaligned
260          nop
261         ba,a,pt         %icc, .Lmedium_unaligned
263 #ifdef NON_USER_COPY
264 .Lmedium_vis_entry_fail:
265          or             %o0, %o1, %g2
266 #endif
267 .Lmedium:
268         LOAD(prefetch, %o1 + 0x40, #n_reads_strong)
269         andcc           %g2, 0x7, %g0
270         bne,pn          %icc, .Lmedium_unaligned
271          nop
272 .Lmedium_noprefetch:
273         andncc          %o2, 0x20 - 1, %o5
274         be,pn           %icc, 2f
275          sub            %o2, %o5, %o2
276 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
277         EX_LD(LOAD(ldx, %o1 + 0x08, %g2), memcpy_retl_o2_plus_o5)
278         EX_LD(LOAD(ldx, %o1 + 0x10, GLOBAL_SPARE), memcpy_retl_o2_plus_o5)
279         EX_LD(LOAD(ldx, %o1 + 0x18, %o4), memcpy_retl_o2_plus_o5)
280         add             %o1, 0x20, %o1
281         subcc           %o5, 0x20, %o5
282         EX_ST(STORE(stx, %g1, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_32)
283         EX_ST(STORE(stx, %g2, %o0 + 0x08), memcpy_retl_o2_plus_o5_plus_24)
284         EX_ST(STORE(stx, GLOBAL_SPARE, %o0 + 0x10), memcpy_retl_o2_plus_o5_plus_24)
285         EX_ST(STORE(stx, %o4, %o0 + 0x18), memcpy_retl_o2_plus_o5_plus_8)
286         bne,pt          %icc, 1b
287          add            %o0, 0x20, %o0
288 2:      andcc           %o2, 0x18, %o5
289         be,pt           %icc, 3f
290          sub            %o2, %o5, %o2
292 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
293         add             %o1, 0x08, %o1
294         add             %o0, 0x08, %o0
295         subcc           %o5, 0x08, %o5
296         bne,pt          %icc, 1b
297          EX_ST(STORE(stx, %g1, %o0 - 0x08), memcpy_retl_o2_plus_o5_plus_8)
298 3:      brz,pt          %o2, .Lexit
299          cmp            %o2, 0x04
300         bl,pn           %icc, .Ltiny
301          nop
302         EX_LD(LOAD(lduw, %o1 + 0x00, %g1), memcpy_retl_o2)
303         add             %o1, 0x04, %o1
304         add             %o0, 0x04, %o0
305         subcc           %o2, 0x04, %o2
306         bne,pn          %icc, .Ltiny
307          EX_ST(STORE(stw, %g1, %o0 - 0x04), memcpy_retl_o2_plus_4)
308         ba,a,pt         %icc, .Lexit
309 .Lmedium_unaligned:
310         /* First get dest 8 byte aligned.  */
311         sub             %g0, %o0, %g1
312         and             %g1, 0x7, %g1
313         brz,pt          %g1, 2f
314          sub            %o2, %g1, %o2
316 1:      EX_LD(LOAD(ldub, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
317         add             %o1, 1, %o1
318         subcc           %g1, 1, %g1
319         add             %o0, 1, %o0
320         bne,pt          %icc, 1b
321          EX_ST(STORE(stb, %g2, %o0 - 0x01), memcpy_retl_o2_plus_g1_plus_1)
323         and             %o1, 0x7, %g1
324         brz,pn          %g1, .Lmedium_noprefetch
325          sll            %g1, 3, %g1
326         mov             64, %g2
327         sub             %g2, %g1, %g2
328         andn            %o1, 0x7, %o1
329         EX_LD(LOAD(ldx, %o1 + 0x00, %o4), memcpy_retl_o2)
330         sllx            %o4, %g1, %o4
331         andn            %o2, 0x08 - 1, %o5
332         sub             %o2, %o5, %o2
333 1:      EX_LD(LOAD(ldx, %o1 + 0x08, %g3), memcpy_retl_o2_plus_o5)
334         add             %o1, 0x08, %o1
335         subcc           %o5, 0x08, %o5
336         srlx            %g3, %g2, GLOBAL_SPARE
337         or              GLOBAL_SPARE, %o4, GLOBAL_SPARE
338         EX_ST(STORE(stx, GLOBAL_SPARE, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_8)
339         add             %o0, 0x08, %o0
340         bne,pt          %icc, 1b
341          sllx           %g3, %g1, %o4
342         srl             %g1, 3, %g1
343         add             %o1, %g1, %o1
344         brz,pn          %o2, .Lexit
345          nop
346         ba,pt           %icc, .Lsmall_unaligned
348 .Ltiny:
349         EX_LD(LOAD(ldub, %o1 + 0x00, %g1), memcpy_retl_o2)
350         subcc           %o2, 1, %o2
351         be,pn           %icc, .Lexit
352          EX_ST(STORE(stb, %g1, %o0 + 0x00), memcpy_retl_o2_plus_1)
353         EX_LD(LOAD(ldub, %o1 + 0x01, %g1), memcpy_retl_o2)
354         subcc           %o2, 1, %o2
355         be,pn           %icc, .Lexit
356          EX_ST(STORE(stb, %g1, %o0 + 0x01), memcpy_retl_o2_plus_1)
357         EX_LD(LOAD(ldub, %o1 + 0x02, %g1), memcpy_retl_o2)
358         ba,pt           %icc, .Lexit
359          EX_ST(STORE(stb, %g1, %o0 + 0x02), memcpy_retl_o2)
361 .Lsmall:
362         andcc           %g2, 0x3, %g0
363         bne,pn          %icc, .Lsmall_unaligned
364          andn           %o2, 0x4 - 1, %o5
365         sub             %o2, %o5, %o2
367         EX_LD(LOAD(lduw, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
368         add             %o1, 0x04, %o1
369         subcc           %o5, 0x04, %o5
370         add             %o0, 0x04, %o0
371         bne,pt          %icc, 1b
372          EX_ST(STORE(stw, %g1, %o0 - 0x04), memcpy_retl_o2_plus_o5_plus_4)
373         brz,pt          %o2, .Lexit
374          nop
375         ba,a,pt         %icc, .Ltiny
377 .Lsmall_unaligned:
378 1:      EX_LD(LOAD(ldub, %o1 + 0x00, %g1), memcpy_retl_o2)
379         add             %o1, 1, %o1
380         add             %o0, 1, %o0
381         subcc           %o2, 1, %o2
382         bne,pt          %icc, 1b
383          EX_ST(STORE(stb, %g1, %o0 - 0x01), memcpy_retl_o2_plus_1)
384         ba,a,pt         %icc, .Lexit
385          nop
386         .size           FUNC_NAME, .-FUNC_NAME