← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to arch/hexagon/lib/memset.S

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/hexagon/lib/memset.S
 
1
/*
 
2
 * Copyright (c) 2011 Code Aurora Forum. All rights reserved.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License version 2 and
 
6
 * only version 2 as published by the Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 * GNU General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU General Public License
 
14
 * along with this program; if not, write to the Free Software
 
15
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 
16
 * 02110-1301, USA.
 
17
 */
 
18
 
 
19
 
 
20
/* HEXAGON assembly optimized memset */
 
21
/* Replaces the standard library function memset */
 
22
 
 
23
 
 
24
        .macro HEXAGON_OPT_FUNC_BEGIN name
 
25
        .text
 
26
        .p2align 4
 
27
        .globl \name
 
28
        .type  \name, @function
 
29
\name:
 
30
        .endm
 
31
 
 
32
        .macro HEXAGON_OPT_FUNC_FINISH name
 
33
        .size  \name, . - \name
 
34
        .endm
 
35
 
 
36
/* FUNCTION: memset (v2 version) */
 
37
#if __HEXAGON_ARCH__ < 3
 
38
HEXAGON_OPT_FUNC_BEGIN memset
 
39
        {
 
40
                r6 = #8
 
41
                r7 = extractu(r0, #3 , #0)
 
42
                p0 = cmp.eq(r2, #0)
 
43
                p1 = cmp.gtu(r2, #7)
 
44
        }
 
45
        {
 
46
                r4 = vsplatb(r1)
 
47
                r8 = r0           /* leave r0 intact for return val  */
 
48
                r9 = sub(r6, r7)  /* bytes until double alignment  */
 
49
                if p0 jumpr r31   /* count == 0, so return  */
 
50
        }
 
51
        {
 
52
                r3 = #0
 
53
                r7 = #0
 
54
                p0 = tstbit(r9, #0)
 
55
                if p1 jump 2f /* skip byte loop */
 
56
        }
 
57
 
 
58
/* less than 8 bytes to set, so just set a byte at a time and return  */
 
59
 
 
60
                loop0(1f, r2) /* byte loop */
 
61
        .falign
 
62
1: /* byte loop */
 
63
        {
 
64
                memb(r8++#1) = r4
 
65
        }:endloop0
 
66
                jumpr r31
 
67
        .falign
 
68
2: /* skip byte loop */
 
69
        {
 
70
                r6 = #1
 
71
                p0 = tstbit(r9, #1)
 
72
                p1 = cmp.eq(r2, #1)
 
73
                if !p0 jump 3f /* skip initial byte store */
 
74
        }
 
75
        {
 
76
                memb(r8++#1) = r4
 
77
                r3:2 = sub(r3:2, r7:6)
 
78
                if p1 jumpr r31
 
79
        }
 
80
        .falign
 
81
3: /* skip initial byte store */
 
82
        {
 
83
                r6 = #2
 
84
                p0 = tstbit(r9, #2)
 
85
                p1 = cmp.eq(r2, #2)
 
86
                if !p0 jump 4f /* skip initial half store */
 
87
        }
 
88
        {
 
89
                memh(r8++#2) = r4
 
90
                r3:2 = sub(r3:2, r7:6)
 
91
                if p1 jumpr r31
 
92
        }
 
93
        .falign
 
94
4: /* skip initial half store */
 
95
        {
 
96
                r6 = #4
 
97
                p0 = cmp.gtu(r2, #7)
 
98
                p1 = cmp.eq(r2, #4)
 
99
                if !p0 jump 5f /* skip initial word store */
 
100
        }
 
101
        {
 
102
                memw(r8++#4) = r4
 
103
                r3:2 = sub(r3:2, r7:6)
 
104
                p0 = cmp.gtu(r2, #11)
 
105
                if p1 jumpr r31
 
106
        }
 
107
        .falign
 
108
5: /* skip initial word store */
 
109
        {
 
110
                r10 = lsr(r2, #3)
 
111
                p1 = cmp.eq(r3, #1)
 
112
                if !p0 jump 7f /* skip double loop */
 
113
        }
 
114
        {
 
115
                r5 = r4
 
116
                r6 = #8
 
117
                loop0(6f, r10) /* double loop */
 
118
        }
 
119
 
 
120
/* set bytes a double word at a time  */
 
121
 
 
122
        .falign
 
123
6: /* double loop */
 
124
        {
 
125
                memd(r8++#8) = r5:4
 
126
                r3:2 = sub(r3:2, r7:6)
 
127
                p1 = cmp.eq(r2, #8)
 
128
        }:endloop0
 
129
        .falign
 
130
7: /* skip double loop */
 
131
        {
 
132
                p0 = tstbit(r2, #2)
 
133
                if p1 jumpr r31
 
134
        }
 
135
        {
 
136
                r6 = #4
 
137
                p0 = tstbit(r2, #1)
 
138
                p1 = cmp.eq(r2, #4)
 
139
                if !p0 jump 8f /* skip final word store */
 
140
        }
 
141
        {
 
142
                memw(r8++#4) = r4
 
143
                r3:2 = sub(r3:2, r7:6)
 
144
                if p1 jumpr r31
 
145
        }
 
146
        .falign
 
147
8: /* skip final word store */
 
148
        {
 
149
                p1 = cmp.eq(r2, #2)
 
150
                if !p0 jump 9f /* skip final half store */
 
151
        }
 
152
        {
 
153
                memh(r8++#2) = r4
 
154
                if p1 jumpr r31
 
155
        }
 
156
        .falign
 
157
9: /* skip final half store */
 
158
        {
 
159
                memb(r8++#1) = r4
 
160
                jumpr r31
 
161
        }
 
162
HEXAGON_OPT_FUNC_FINISH memset
 
163
#endif
 
164
 
 
165
 
 
166
/*  FUNCTION: memset (v3 and higher version)  */
 
167
#if __HEXAGON_ARCH__ >= 3
 
168
HEXAGON_OPT_FUNC_BEGIN memset
 
169
        {
 
170
                r7=vsplatb(r1)
 
171
                r6 = r0
 
172
                if (r2==#0) jump:nt .L1
 
173
        }
 
174
        {
 
175
                r5:4=combine(r7,r7)
 
176
                p0 = cmp.gtu(r2,#8)
 
177
                if (p0.new) jump:nt .L3
 
178
        }
 
179
        {
 
180
                r3 = r0
 
181
                loop0(.L47,r2)
 
182
        }
 
183
        .falign
 
184
.L47:
 
185
        {
 
186
                memb(r3++#1) = r1
 
187
        }:endloop0 /* start=.L47 */
 
188
                jumpr r31
 
189
.L3:
 
190
        {
 
191
                p0 = tstbit(r0,#0)
 
192
                if (!p0.new) jump:nt .L8
 
193
                p1 = cmp.eq(r2, #1)
 
194
        }
 
195
        {
 
196
                r6 = add(r0, #1)
 
197
                r2 = add(r2,#-1)
 
198
                memb(r0) = r1
 
199
                if (p1) jump .L1
 
200
        }
 
201
.L8:
 
202
        {
 
203
                p0 = tstbit(r6,#1)
 
204
                if (!p0.new) jump:nt .L10
 
205
        }
 
206
        {
 
207
                r2 = add(r2,#-2)
 
208
                memh(r6++#2) = r7
 
209
                p0 = cmp.eq(r2, #2)
 
210
                if (p0.new) jump:nt .L1
 
211
        }
 
212
.L10:
 
213
        {
 
214
                p0 = tstbit(r6,#2)
 
215
                if (!p0.new) jump:nt .L12
 
216
        }
 
217
        {
 
218
                r2 = add(r2,#-4)
 
219
                memw(r6++#4) = r7
 
220
                p0 = cmp.eq(r2, #4)
 
221
                if (p0.new) jump:nt .L1
 
222
        }
 
223
.L12:
 
224
        {
 
225
                p0 = cmp.gtu(r2,#127)
 
226
                if (!p0.new) jump:nt .L14
 
227
        }
 
228
                r3 = and(r6,#31)
 
229
                if (r3==#0) jump:nt .L17
 
230
        {
 
231
                memd(r6++#8) = r5:4
 
232
                r2 = add(r2,#-8)
 
233
        }
 
234
                r3 = and(r6,#31)
 
235
                if (r3==#0) jump:nt .L17
 
236
        {
 
237
                memd(r6++#8) = r5:4
 
238
                r2 = add(r2,#-8)
 
239
        }
 
240
                r3 = and(r6,#31)
 
241
                if (r3==#0) jump:nt .L17
 
242
        {
 
243
                memd(r6++#8) = r5:4
 
244
                r2 = add(r2,#-8)
 
245
        }
 
246
.L17:
 
247
        {
 
248
                r3 = lsr(r2,#5)
 
249
                if (r1!=#0) jump:nt .L18
 
250
        }
 
251
        {
 
252
                r8 = r3
 
253
                r3 = r6
 
254
                loop0(.L46,r3)
 
255
        }
 
256
        .falign
 
257
.L46:
 
258
        {
 
259
                dczeroa(r6)
 
260
                r6 = add(r6,#32)
 
261
                r2 = add(r2,#-32)
 
262
        }:endloop0 /* start=.L46 */
 
263
.L14:
 
264
        {
 
265
                p0 = cmp.gtu(r2,#7)
 
266
                if (!p0.new) jump:nt .L28
 
267
                r8 = lsr(r2,#3)
 
268
        }
 
269
                loop0(.L44,r8)
 
270
        .falign
 
271
.L44:
 
272
        {
 
273
                memd(r6++#8) = r5:4
 
274
                r2 = add(r2,#-8)
 
275
        }:endloop0 /* start=.L44 */
 
276
.L28:
 
277
        {
 
278
                p0 = tstbit(r2,#2)
 
279
                if (!p0.new) jump:nt .L33
 
280
        }
 
281
        {
 
282
                r2 = add(r2,#-4)
 
283
                memw(r6++#4) = r7
 
284
        }
 
285
.L33:
 
286
        {
 
287
                p0 = tstbit(r2,#1)
 
288
                if (!p0.new) jump:nt .L35
 
289
        }
 
290
        {
 
291
                r2 = add(r2,#-2)
 
292
                memh(r6++#2) = r7
 
293
        }
 
294
.L35:
 
295
                p0 = cmp.eq(r2,#1)
 
296
                if (p0) memb(r6) = r1
 
297
.L1:
 
298
                jumpr r31
 
299
.L18:
 
300
                loop0(.L45,r3)
 
301
        .falign
 
302
.L45:
 
303
                dczeroa(r6)
 
304
        {
 
305
                memd(r6++#8) = r5:4
 
306
                r2 = add(r2,#-32)
 
307
        }
 
308
                memd(r6++#8) = r5:4
 
309
                memd(r6++#8) = r5:4
 
310
        {
 
311
                memd(r6++#8) = r5:4
 
312
        }:endloop0 /* start=.L45  */
 
313
                jump .L14
 
314
HEXAGON_OPT_FUNC_FINISH memset
 
315
#endif