diff options
author | Linus Torvalds <torvalds@g5.osdl.org> | 2005-11-02 00:32:14 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@g5.osdl.org> | 2005-11-02 00:32:14 -0500 |
commit | 7f36b1e9582c06d0ddef5f2416c9b17017647d1f (patch) | |
tree | f83cbcef623476b9b8a14f7a0cc66eb92552a651 /arch/arm | |
parent | 0e016b9fa134d79341cca5e336ccbcea066d5f81 (diff) | |
parent | 73ee723e4c6d179c2e9496cc4caf160a18d95603 (diff) |
Merge master.kernel.org:/home/rmk/linux-2.6-arm
Diffstat (limited to 'arch/arm')
30 files changed, 2522 insertions, 455 deletions
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index 682367bd0f65..dc6d8342e5e6 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig | |||
@@ -194,6 +194,13 @@ config ARCH_VERSATILE | |||
194 | help | 194 | help |
195 | This enables support for ARM Ltd Versatile board. | 195 | This enables support for ARM Ltd Versatile board. |
196 | 196 | ||
197 | config ARCH_REALVIEW | ||
198 | bool "RealView" | ||
199 | select ARM_AMBA | ||
200 | select ICST307 | ||
201 | help | ||
202 | This enables support for ARM Ltd RealView boards. | ||
203 | |||
197 | config ARCH_IMX | 204 | config ARCH_IMX |
198 | bool "IMX" | 205 | bool "IMX" |
199 | 206 | ||
@@ -244,6 +251,8 @@ source "arch/arm/mach-versatile/Kconfig" | |||
244 | 251 | ||
245 | source "arch/arm/mach-aaec2000/Kconfig" | 252 | source "arch/arm/mach-aaec2000/Kconfig" |
246 | 253 | ||
254 | source "arch/arm/mach-realview/Kconfig" | ||
255 | |||
247 | # Definitions to make life easier | 256 | # Definitions to make life easier |
248 | config ARCH_ACORN | 257 | config ARCH_ACORN |
249 | bool | 258 | bool |
diff --git a/arch/arm/Makefile b/arch/arm/Makefile index 64cf480b0b02..d80749ae2a7e 100644 --- a/arch/arm/Makefile +++ b/arch/arm/Makefile | |||
@@ -99,6 +99,7 @@ textaddr-$(CONFIG_ARCH_FORTUNET) := 0xc0008000 | |||
99 | machine-$(CONFIG_ARCH_IMX) := imx | 99 | machine-$(CONFIG_ARCH_IMX) := imx |
100 | machine-$(CONFIG_ARCH_H720X) := h720x | 100 | machine-$(CONFIG_ARCH_H720X) := h720x |
101 | machine-$(CONFIG_ARCH_AAEC2000) := aaec2000 | 101 | machine-$(CONFIG_ARCH_AAEC2000) := aaec2000 |
102 | machine-$(CONFIG_ARCH_REALVIEW) := realview | ||
102 | 103 | ||
103 | ifeq ($(CONFIG_ARCH_EBSA110),y) | 104 | ifeq ($(CONFIG_ARCH_EBSA110),y) |
104 | # This is what happens if you forget the IOCS16 line. | 105 | # This is what happens if you forget the IOCS16 line. |
diff --git a/arch/arm/configs/ixp4xx_defconfig b/arch/arm/configs/ixp4xx_defconfig index c279e41ed10e..f74c926beb42 100644 --- a/arch/arm/configs/ixp4xx_defconfig +++ b/arch/arm/configs/ixp4xx_defconfig | |||
@@ -104,7 +104,7 @@ CONFIG_ARCH_IXCDP1100=y | |||
104 | CONFIG_ARCH_PRPMC1100=y | 104 | CONFIG_ARCH_PRPMC1100=y |
105 | CONFIG_ARCH_IXDP4XX=y | 105 | CONFIG_ARCH_IXDP4XX=y |
106 | CONFIG_CPU_IXP46X=y | 106 | CONFIG_CPU_IXP46X=y |
107 | CONFIG_MACH_GTWX5715=y | 107 | # CONFIG_MACH_GTWX5715 is not set |
108 | 108 | ||
109 | # | 109 | # |
110 | # IXP4xx Options | 110 | # IXP4xx Options |
diff --git a/arch/arm/lib/Makefile b/arch/arm/lib/Makefile index 71e5b99e519e..391f3ab3ff32 100644 --- a/arch/arm/lib/Makefile +++ b/arch/arm/lib/Makefile | |||
@@ -7,13 +7,27 @@ | |||
7 | lib-y := backtrace.o changebit.o csumipv6.o csumpartial.o \ | 7 | lib-y := backtrace.o changebit.o csumipv6.o csumpartial.o \ |
8 | csumpartialcopy.o csumpartialcopyuser.o clearbit.o \ | 8 | csumpartialcopy.o csumpartialcopyuser.o clearbit.o \ |
9 | copy_page.o delay.o findbit.o memchr.o memcpy.o \ | 9 | copy_page.o delay.o findbit.o memchr.o memcpy.o \ |
10 | memset.o memzero.o setbit.o strncpy_from_user.o \ | 10 | memmove.o memset.o memzero.o setbit.o \ |
11 | strnlen_user.o strchr.o strrchr.o testchangebit.o \ | 11 | strncpy_from_user.o strnlen_user.o \ |
12 | testclearbit.o testsetbit.o uaccess.o getuser.o \ | 12 | strchr.o strrchr.o \ |
13 | putuser.o ashldi3.o ashrdi3.o lshrdi3.o muldi3.o \ | 13 | testchangebit.o testclearbit.o testsetbit.o \ |
14 | getuser.o putuser.o clear_user.o \ | ||
15 | ashldi3.o ashrdi3.o lshrdi3.o muldi3.o \ | ||
14 | ucmpdi2.o lib1funcs.o div64.o sha1.o \ | 16 | ucmpdi2.o lib1funcs.o div64.o sha1.o \ |
15 | io-readsb.o io-writesb.o io-readsl.o io-writesl.o | 17 | io-readsb.o io-writesb.o io-readsl.o io-writesl.o |
16 | 18 | ||
19 | # the code in uaccess.S is not preemption safe and | ||
20 | # probably faster on ARMv3 only | ||
21 | ifeq ($CONFIG_PREEMPT,y) | ||
22 | lib-y += copy_from_user.o copy_to_user.o | ||
23 | else | ||
24 | ifneq ($(CONFIG_CPU_32v3),y) | ||
25 | lib-y += copy_from_user.o copy_to_user.o | ||
26 | else | ||
27 | lib-y += uaccess.o | ||
28 | endif | ||
29 | endif | ||
30 | |||
17 | ifeq ($(CONFIG_CPU_32v3),y) | 31 | ifeq ($(CONFIG_CPU_32v3),y) |
18 | lib-y += io-readsw-armv3.o io-writesw-armv3.o | 32 | lib-y += io-readsw-armv3.o io-writesw-armv3.o |
19 | else | 33 | else |
diff --git a/arch/arm/lib/clear_user.S b/arch/arm/lib/clear_user.S new file mode 100644 index 000000000000..7ff9f831b3f9 --- /dev/null +++ b/arch/arm/lib/clear_user.S | |||
@@ -0,0 +1,52 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/lib/clear_user.S | ||
3 | * | ||
4 | * Copyright (C) 1995, 1996,1997,1998 Russell King | ||
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 version 2 as | ||
8 | * published by the Free Software Foundation. | ||
9 | */ | ||
10 | #include <linux/linkage.h> | ||
11 | #include <asm/assembler.h> | ||
12 | |||
13 | .text | ||
14 | |||
15 | /* Prototype: int __arch_clear_user(void *addr, size_t sz) | ||
16 | * Purpose : clear some user memory | ||
17 | * Params : addr - user memory address to clear | ||
18 | * : sz - number of bytes to clear | ||
19 | * Returns : number of bytes NOT cleared | ||
20 | */ | ||
21 | ENTRY(__arch_clear_user) | ||
22 | stmfd sp!, {r1, lr} | ||
23 | mov r2, #0 | ||
24 | cmp r1, #4 | ||
25 | blt 2f | ||
26 | ands ip, r0, #3 | ||
27 | beq 1f | ||
28 | cmp ip, #2 | ||
29 | USER( strbt r2, [r0], #1) | ||
30 | USER( strlebt r2, [r0], #1) | ||
31 | USER( strltbt r2, [r0], #1) | ||
32 | rsb ip, ip, #4 | ||
33 | sub r1, r1, ip @ 7 6 5 4 3 2 1 | ||
34 | 1: subs r1, r1, #8 @ -1 -2 -3 -4 -5 -6 -7 | ||
35 | USER( strplt r2, [r0], #4) | ||
36 | USER( strplt r2, [r0], #4) | ||
37 | bpl 1b | ||
38 | adds r1, r1, #4 @ 3 2 1 0 -1 -2 -3 | ||
39 | USER( strplt r2, [r0], #4) | ||
40 | 2: tst r1, #2 @ 1x 1x 0x 0x 1x 1x 0x | ||
41 | USER( strnebt r2, [r0], #1) | ||
42 | USER( strnebt r2, [r0], #1) | ||
43 | tst r1, #1 @ x1 x0 x1 x0 x1 x0 x1 | ||
44 | USER( strnebt r2, [r0], #1) | ||
45 | mov r0, #0 | ||
46 | LOADREGS(fd,sp!, {r1, pc}) | ||
47 | |||
48 | .section .fixup,"ax" | ||
49 | .align 0 | ||
50 | 9001: LOADREGS(fd,sp!, {r0, pc}) | ||
51 | .previous | ||
52 | |||
diff --git a/arch/arm/lib/copy_from_user.S b/arch/arm/lib/copy_from_user.S new file mode 100644 index 000000000000..7497393a0e81 --- /dev/null +++ b/arch/arm/lib/copy_from_user.S | |||
@@ -0,0 +1,101 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/lib/copy_from_user.S | ||
3 | * | ||
4 | * Author: Nicolas Pitre | ||
5 | * Created: Sep 29, 2005 | ||
6 | * Copyright: MontaVista Software, Inc. | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | #include <linux/linkage.h> | ||
14 | #include <asm/assembler.h> | ||
15 | |||
16 | /* | ||
17 | * Prototype: | ||
18 | * | ||
19 | * size_t __arch_copy_from_user(void *to, const void *from, size_t n) | ||
20 | * | ||
21 | * Purpose: | ||
22 | * | ||
23 | * copy a block to kernel memory from user memory | ||
24 | * | ||
25 | * Params: | ||
26 | * | ||
27 | * to = kernel memory | ||
28 | * from = user memory | ||
29 | * n = number of bytes to copy | ||
30 | * | ||
31 | * Return value: | ||
32 | * | ||
33 | * Number of bytes NOT copied. | ||
34 | */ | ||
35 | |||
36 | .macro ldr1w ptr reg abort | ||
37 | 100: ldrt \reg, [\ptr], #4 | ||
38 | .section __ex_table, "a" | ||
39 | .long 100b, \abort | ||
40 | .previous | ||
41 | .endm | ||
42 | |||
43 | .macro ldr4w ptr reg1 reg2 reg3 reg4 abort | ||
44 | ldr1w \ptr, \reg1, \abort | ||
45 | ldr1w \ptr, \reg2, \abort | ||
46 | ldr1w \ptr, \reg3, \abort | ||
47 | ldr1w \ptr, \reg4, \abort | ||
48 | .endm | ||
49 | |||
50 | .macro ldr8w ptr reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 abort | ||
51 | ldr4w \ptr, \reg1, \reg2, \reg3, \reg4, \abort | ||
52 | ldr4w \ptr, \reg5, \reg6, \reg7, \reg8, \abort | ||
53 | .endm | ||
54 | |||
55 | .macro ldr1b ptr reg cond=al abort | ||
56 | 100: ldr\cond\()bt \reg, [\ptr], #1 | ||
57 | .section __ex_table, "a" | ||
58 | .long 100b, \abort | ||
59 | .previous | ||
60 | .endm | ||
61 | |||
62 | .macro str1w ptr reg abort | ||
63 | str \reg, [\ptr], #4 | ||
64 | .endm | ||
65 | |||
66 | .macro str8w ptr reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 abort | ||
67 | stmia \ptr!, {\reg1, \reg2, \reg3, \reg4, \reg5, \reg6, \reg7, \reg8} | ||
68 | .endm | ||
69 | |||
70 | .macro str1b ptr reg cond=al abort | ||
71 | str\cond\()b \reg, [\ptr], #1 | ||
72 | .endm | ||
73 | |||
74 | .macro enter reg1 reg2 | ||
75 | mov r3, #0 | ||
76 | stmdb sp!, {r0, r2, r3, \reg1, \reg2} | ||
77 | .endm | ||
78 | |||
79 | .macro exit reg1 reg2 | ||
80 | add sp, sp, #8 | ||
81 | ldmfd sp!, {r0, \reg1, \reg2} | ||
82 | .endm | ||
83 | |||
84 | .text | ||
85 | |||
86 | ENTRY(__arch_copy_from_user) | ||
87 | |||
88 | #include "copy_template.S" | ||
89 | |||
90 | .section .fixup,"ax" | ||
91 | .align 0 | ||
92 | copy_abort_preamble | ||
93 | ldmfd sp!, {r1, r2} | ||
94 | sub r3, r0, r1 | ||
95 | rsb r1, r3, r2 | ||
96 | str r1, [sp] | ||
97 | bl __memzero | ||
98 | ldr r0, [sp], #4 | ||
99 | copy_abort_end | ||
100 | .previous | ||
101 | |||
diff --git a/arch/arm/lib/copy_template.S b/arch/arm/lib/copy_template.S new file mode 100644 index 000000000000..838e435e4922 --- /dev/null +++ b/arch/arm/lib/copy_template.S | |||
@@ -0,0 +1,255 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/lib/copy_template.s | ||
3 | * | ||
4 | * Code template for optimized memory copy functions | ||
5 | * | ||
6 | * Author: Nicolas Pitre | ||
7 | * Created: Sep 28, 2005 | ||
8 | * Copyright: MontaVista Software, Inc. | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License version 2 as | ||
12 | * published by the Free Software Foundation. | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | * This can be used to enable code to cacheline align the source pointer. | ||
17 | * Experiments on tested architectures (StrongARM and XScale) didn't show | ||
18 | * this a worthwhile thing to do. That might be different in the future. | ||
19 | */ | ||
20 | //#define CALGN(code...) code | ||
21 | #define CALGN(code...) | ||
22 | |||
23 | /* | ||
24 | * Theory of operation | ||
25 | * ------------------- | ||
26 | * | ||
27 | * This file provides the core code for a forward memory copy used in | ||
28 | * the implementation of memcopy(), copy_to_user() and copy_from_user(). | ||
29 | * | ||
30 | * The including file must define the following accessor macros | ||
31 | * according to the need of the given function: | ||
32 | * | ||
33 | * ldr1w ptr reg abort | ||
34 | * | ||
35 | * This loads one word from 'ptr', stores it in 'reg' and increments | ||
36 | * 'ptr' to the next word. The 'abort' argument is used for fixup tables. | ||
37 | * | ||
38 | * ldr4w ptr reg1 reg2 reg3 reg4 abort | ||
39 | * ldr8w ptr, reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 abort | ||
40 | * | ||
41 | * This loads four or eight words starting from 'ptr', stores them | ||
42 | * in provided registers and increments 'ptr' past those words. | ||
43 | * The'abort' argument is used for fixup tables. | ||
44 | * | ||
45 | * ldr1b ptr reg cond abort | ||
46 | * | ||
47 | * Similar to ldr1w, but it loads a byte and increments 'ptr' one byte. | ||
48 | * It also must apply the condition code if provided, otherwise the | ||
49 | * "al" condition is assumed by default. | ||
50 | * | ||
51 | * str1w ptr reg abort | ||
52 | * str8w ptr reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 abort | ||
53 | * str1b ptr reg cond abort | ||
54 | * | ||
55 | * Same as their ldr* counterparts, but data is stored to 'ptr' location | ||
56 | * rather than being loaded. | ||
57 | * | ||
58 | * enter reg1 reg2 | ||
59 | * | ||
60 | * Preserve the provided registers on the stack plus any additional | ||
61 | * data as needed by the implementation including this code. Called | ||
62 | * upon code entry. | ||
63 | * | ||
64 | * exit reg1 reg2 | ||
65 | * | ||
66 | * Restore registers with the values previously saved with the | ||
67 | * 'preserv' macro. Called upon code termination. | ||
68 | */ | ||
69 | |||
70 | |||
71 | enter r4, lr | ||
72 | |||
73 | subs r2, r2, #4 | ||
74 | blt 8f | ||
75 | ands ip, r0, #3 | ||
76 | PLD( pld [r1, #0] ) | ||
77 | bne 9f | ||
78 | ands ip, r1, #3 | ||
79 | bne 10f | ||
80 | |||
81 | 1: subs r2, r2, #(28) | ||
82 | stmfd sp!, {r5 - r8} | ||
83 | blt 5f | ||
84 | |||
85 | CALGN( ands ip, r1, #31 ) | ||
86 | CALGN( rsb r3, ip, #32 ) | ||
87 | CALGN( sbcnes r4, r3, r2 ) @ C is always set here | ||
88 | CALGN( bcs 2f ) | ||
89 | CALGN( adr r4, 6f ) | ||
90 | CALGN( subs r2, r2, r3 ) @ C gets set | ||
91 | CALGN( add pc, r4, ip ) | ||
92 | |||
93 | PLD( pld [r1, #0] ) | ||
94 | 2: PLD( subs r2, r2, #96 ) | ||
95 | PLD( pld [r1, #28] ) | ||
96 | PLD( blt 4f ) | ||
97 | PLD( pld [r1, #60] ) | ||
98 | PLD( pld [r1, #92] ) | ||
99 | |||
100 | 3: PLD( pld [r1, #124] ) | ||
101 | 4: ldr8w r1, r3, r4, r5, r6, r7, r8, ip, lr, abort=20f | ||
102 | subs r2, r2, #32 | ||
103 | str8w r0, r3, r4, r5, r6, r7, r8, ip, lr, abort=20f | ||
104 | bge 3b | ||
105 | PLD( cmn r2, #96 ) | ||
106 | PLD( bge 4b ) | ||
107 | |||
108 | 5: ands ip, r2, #28 | ||
109 | rsb ip, ip, #32 | ||
110 | addne pc, pc, ip @ C is always clear here | ||
111 | b 7f | ||
112 | 6: nop | ||
113 | ldr1w r1, r3, abort=20f | ||
114 | ldr1w r1, r4, abort=20f | ||
115 | ldr1w r1, r5, abort=20f | ||
116 | ldr1w r1, r6, abort=20f | ||
117 | ldr1w r1, r7, abort=20f | ||
118 | ldr1w r1, r8, abort=20f | ||
119 | ldr1w r1, lr, abort=20f | ||
120 | |||
121 | add pc, pc, ip | ||
122 | nop | ||
123 | nop | ||
124 | str1w r0, r3, abort=20f | ||
125 | str1w r0, r4, abort=20f | ||
126 | str1w r0, r5, abort=20f | ||
127 | str1w r0, r6, abort=20f | ||
128 | str1w r0, r7, abort=20f | ||
129 | str1w r0, r8, abort=20f | ||
130 | str1w r0, lr, abort=20f | ||
131 | |||
132 | CALGN( bcs 2b ) | ||
133 | |||
134 | 7: ldmfd sp!, {r5 - r8} | ||
135 | |||
136 | 8: movs r2, r2, lsl #31 | ||
137 | ldr1b r1, r3, ne, abort=21f | ||
138 | ldr1b r1, r4, cs, abort=21f | ||
139 | ldr1b r1, ip, cs, abort=21f | ||
140 | str1b r0, r3, ne, abort=21f | ||
141 | str1b r0, r4, cs, abort=21f | ||
142 | str1b r0, ip, cs, abort=21f | ||
143 | |||
144 | exit r4, pc | ||
145 | |||
146 | 9: rsb ip, ip, #4 | ||
147 | cmp ip, #2 | ||
148 | ldr1b r1, r3, gt, abort=21f | ||
149 | ldr1b r1, r4, ge, abort=21f | ||
150 | ldr1b r1, lr, abort=21f | ||
151 | str1b r0, r3, gt, abort=21f | ||
152 | str1b r0, r4, ge, abort=21f | ||
153 | subs r2, r2, ip | ||
154 | str1b r0, lr, abort=21f | ||
155 | blt 8b | ||
156 | ands ip, r1, #3 | ||
157 | beq 1b | ||
158 | |||
159 | 10: bic r1, r1, #3 | ||
160 | cmp ip, #2 | ||
161 | ldr1w r1, lr, abort=21f | ||
162 | beq 17f | ||
163 | bgt 18f | ||
164 | |||
165 | |||
166 | .macro forward_copy_shift pull push | ||
167 | |||
168 | subs r2, r2, #28 | ||
169 | blt 14f | ||
170 | |||
171 | CALGN( ands ip, r1, #31 ) | ||
172 | CALGN( rsb ip, ip, #32 ) | ||
173 | CALGN( sbcnes r4, ip, r2 ) @ C is always set here | ||
174 | CALGN( subcc r2, r2, ip ) | ||
175 | CALGN( bcc 15f ) | ||
176 | |||
177 | 11: stmfd sp!, {r5 - r9} | ||
178 | |||
179 | PLD( pld [r1, #0] ) | ||
180 | PLD( subs r2, r2, #96 ) | ||
181 | PLD( pld [r1, #28] ) | ||
182 | PLD( blt 13f ) | ||
183 | PLD( pld [r1, #60] ) | ||
184 | PLD( pld [r1, #92] ) | ||
185 | |||
186 | 12: PLD( pld [r1, #124] ) | ||
187 | 13: ldr4w r1, r4, r5, r6, r7, abort=19f | ||
188 | mov r3, lr, pull #\pull | ||
189 | subs r2, r2, #32 | ||
190 | ldr4w r1, r8, r9, ip, lr, abort=19f | ||
191 | orr r3, r3, r4, push #\push | ||
192 | mov r4, r4, pull #\pull | ||
193 | orr r4, r4, r5, push #\push | ||
194 | mov r5, r5, pull #\pull | ||
195 | orr r5, r5, r6, push #\push | ||
196 | mov r6, r6, pull #\pull | ||
197 | orr r6, r6, r7, push #\push | ||
198 | mov r7, r7, pull #\pull | ||
199 | orr r7, r7, r8, push #\push | ||
200 | mov r8, r8, pull #\pull | ||
201 | orr r8, r8, r9, push #\push | ||
202 | mov r9, r9, pull #\pull | ||
203 | orr r9, r9, ip, push #\push | ||
204 | mov ip, ip, pull #\pull | ||
205 | orr ip, ip, lr, push #\push | ||
206 | str8w r0, r3, r4, r5, r6, r7, r8, r9, ip, , abort=19f | ||
207 | bge 12b | ||
208 | PLD( cmn r2, #96 ) | ||
209 | PLD( bge 13b ) | ||
210 | |||
211 | ldmfd sp!, {r5 - r9} | ||
212 | |||
213 | 14: ands ip, r2, #28 | ||
214 | beq 16f | ||
215 | |||
216 | 15: mov r3, lr, pull #\pull | ||
217 | ldr1w r1, lr, abort=21f | ||
218 | subs ip, ip, #4 | ||
219 | orr r3, r3, lr, push #\push | ||
220 | str1w r0, r3, abort=21f | ||
221 | bgt 15b | ||
222 | CALGN( cmp r2, #0 ) | ||
223 | CALGN( bge 11b ) | ||
224 | |||
225 | 16: sub r1, r1, #(\push / 8) | ||
226 | b 8b | ||
227 | |||
228 | .endm | ||
229 | |||
230 | |||
231 | forward_copy_shift pull=8 push=24 | ||
232 | |||
233 | 17: forward_copy_shift pull=16 push=16 | ||
234 | |||
235 | 18: forward_copy_shift pull=24 push=8 | ||
236 | |||
237 | |||
238 | /* | ||
239 | * Abort preanble and completion macros. | ||
240 | * If a fixup handler is required then those macros must surround it. | ||
241 | * It is assumed that the fixup code will handle the private part of | ||
242 | * the exit macro. | ||
243 | */ | ||
244 | |||
245 | .macro copy_abort_preamble | ||
246 | 19: ldmfd sp!, {r5 - r9} | ||
247 | b 21f | ||
248 | 20: ldmfd sp!, {r5 - r8} | ||
249 | 21: | ||
250 | .endm | ||
251 | |||
252 | .macro copy_abort_end | ||
253 | ldmfd sp!, {r4, pc} | ||
254 | .endm | ||
255 | |||
diff --git a/arch/arm/lib/copy_to_user.S b/arch/arm/lib/copy_to_user.S new file mode 100644 index 000000000000..4a6d8ea14022 --- /dev/null +++ b/arch/arm/lib/copy_to_user.S | |||
@@ -0,0 +1,101 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/lib/copy_to_user.S | ||
3 | * | ||
4 | * Author: Nicolas Pitre | ||
5 | * Created: Sep 29, 2005 | ||
6 | * Copyright: MontaVista Software, Inc. | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | #include <linux/linkage.h> | ||
14 | #include <asm/assembler.h> | ||
15 | |||
16 | /* | ||
17 | * Prototype: | ||
18 | * | ||
19 | * size_t __arch_copy_to_user(void *to, const void *from, size_t n) | ||
20 | * | ||
21 | * Purpose: | ||
22 | * | ||
23 | * copy a block to user memory from kernel memory | ||
24 | * | ||
25 | * Params: | ||
26 | * | ||
27 | * to = user memory | ||
28 | * from = kernel memory | ||
29 | * n = number of bytes to copy | ||
30 | * | ||
31 | * Return value: | ||
32 | * | ||
33 | * Number of bytes NOT copied. | ||
34 | */ | ||
35 | |||
36 | .macro ldr1w ptr reg abort | ||
37 | ldr \reg, [\ptr], #4 | ||
38 | .endm | ||
39 | |||
40 | .macro ldr4w ptr reg1 reg2 reg3 reg4 abort | ||
41 | ldmia \ptr!, {\reg1, \reg2, \reg3, \reg4} | ||
42 | .endm | ||
43 | |||
44 | .macro ldr8w ptr reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 abort | ||
45 | ldmia \ptr!, {\reg1, \reg2, \reg3, \reg4, \reg5, \reg6, \reg7, \reg8} | ||
46 | .endm | ||
47 | |||
48 | .macro ldr1b ptr reg cond=al abort | ||
49 | ldr\cond\()b \reg, [\ptr], #1 | ||
50 | .endm | ||
51 | |||
52 | .macro str1w ptr reg abort | ||
53 | 100: strt \reg, [\ptr], #4 | ||
54 | .section __ex_table, "a" | ||
55 | .long 100b, \abort | ||
56 | .previous | ||
57 | .endm | ||
58 | |||
59 | .macro str8w ptr reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 abort | ||
60 | str1w \ptr, \reg1, \abort | ||
61 | str1w \ptr, \reg2, \abort | ||
62 | str1w \ptr, \reg3, \abort | ||
63 | str1w \ptr, \reg4, \abort | ||
64 | str1w \ptr, \reg5, \abort | ||
65 | str1w \ptr, \reg6, \abort | ||
66 | str1w \ptr, \reg7, \abort | ||
67 | str1w \ptr, \reg8, \abort | ||
68 | .endm | ||
69 | |||
70 | .macro str1b ptr reg cond=al abort | ||
71 | 100: str\cond\()bt \reg, [\ptr], #1 | ||
72 | .section __ex_table, "a" | ||
73 | .long 100b, \abort | ||
74 | .previous | ||
75 | .endm | ||
76 | |||
77 | .macro enter reg1 reg2 | ||
78 | mov r3, #0 | ||
79 | stmdb sp!, {r0, r2, r3, \reg1, \reg2} | ||
80 | .endm | ||
81 | |||
82 | .macro exit reg1 reg2 | ||
83 | add sp, sp, #8 | ||
84 | ldmfd sp!, {r0, \reg1, \reg2} | ||
85 | .endm | ||
86 | |||
87 | .text | ||
88 | |||
89 | ENTRY(__arch_copy_to_user) | ||
90 | |||
91 | #include "copy_template.S" | ||
92 | |||
93 | .section .fixup,"ax" | ||
94 | .align 0 | ||
95 | copy_abort_preamble | ||
96 | ldmfd sp!, {r1, r2, r3} | ||
97 | sub r0, r0, r1 | ||
98 | rsb r0, r0, r2 | ||
99 | copy_abort_end | ||
100 | .previous | ||
101 | |||
diff --git a/arch/arm/lib/memcpy.S b/arch/arm/lib/memcpy.S index f5a593ceb8cc..7e71d6708a8d 100644 --- a/arch/arm/lib/memcpy.S +++ b/arch/arm/lib/memcpy.S | |||
@@ -1,393 +1,59 @@ | |||
1 | /* | 1 | /* |
2 | * linux/arch/arm/lib/memcpy.S | 2 | * linux/arch/arm/lib/memcpy.S |
3 | * | 3 | * |
4 | * Copyright (C) 1995-1999 Russell King | 4 | * Author: Nicolas Pitre |
5 | * Created: Sep 28, 2005 | ||
6 | * Copyright: MontaVista Software, Inc. | ||
5 | * | 7 | * |
6 | * This program is free software; you can redistribute it and/or modify | 8 | * This program is free software; you can redistribute it and/or modify |
7 | * it under the terms of the GNU General Public License version 2 as | 9 | * it under the terms of the GNU General Public License version 2 as |
8 | * published by the Free Software Foundation. | 10 | * published by the Free Software Foundation. |
9 | * | ||
10 | * ASM optimised string functions | ||
11 | */ | 11 | */ |
12 | |||
12 | #include <linux/linkage.h> | 13 | #include <linux/linkage.h> |
13 | #include <asm/assembler.h> | 14 | #include <asm/assembler.h> |
14 | 15 | ||
15 | .text | 16 | .macro ldr1w ptr reg abort |
16 | 17 | ldr \reg, [\ptr], #4 | |
17 | #define ENTER \ | 18 | .endm |
18 | mov ip,sp ;\ | ||
19 | stmfd sp!,{r0,r4-r9,fp,ip,lr,pc} ;\ | ||
20 | sub fp,ip,#4 | ||
21 | |||
22 | #define EXIT \ | ||
23 | LOADREGS(ea, fp, {r0, r4 - r9, fp, sp, pc}) | ||
24 | |||
25 | #define EXITEQ \ | ||
26 | LOADREGS(eqea, fp, {r0, r4 - r9, fp, sp, pc}) | ||
27 | |||
28 | /* | ||
29 | * Prototype: void memcpy(void *to,const void *from,unsigned long n); | ||
30 | */ | ||
31 | ENTRY(memcpy) | ||
32 | ENTRY(memmove) | ||
33 | ENTER | ||
34 | cmp r1, r0 | ||
35 | bcc 23f | ||
36 | subs r2, r2, #4 | ||
37 | blt 6f | ||
38 | PLD( pld [r1, #0] ) | ||
39 | ands ip, r0, #3 | ||
40 | bne 7f | ||
41 | ands ip, r1, #3 | ||
42 | bne 8f | ||
43 | 19 | ||
44 | 1: subs r2, r2, #8 | 20 | .macro ldr4w ptr reg1 reg2 reg3 reg4 abort |
45 | blt 5f | 21 | ldmia \ptr!, {\reg1, \reg2, \reg3, \reg4} |
46 | subs r2, r2, #20 | 22 | .endm |
47 | blt 4f | ||
48 | PLD( pld [r1, #28] ) | ||
49 | PLD( subs r2, r2, #64 ) | ||
50 | PLD( blt 3f ) | ||
51 | 2: PLD( pld [r1, #60] ) | ||
52 | PLD( pld [r1, #92] ) | ||
53 | ldmia r1!, {r3 - r9, ip} | ||
54 | subs r2, r2, #32 | ||
55 | stmgeia r0!, {r3 - r9, ip} | ||
56 | ldmgeia r1!, {r3 - r9, ip} | ||
57 | subges r2, r2, #32 | ||
58 | stmia r0!, {r3 - r9, ip} | ||
59 | bge 2b | ||
60 | 3: PLD( ldmia r1!, {r3 - r9, ip} ) | ||
61 | PLD( adds r2, r2, #32 ) | ||
62 | PLD( stmgeia r0!, {r3 - r9, ip} ) | ||
63 | PLD( ldmgeia r1!, {r3 - r9, ip} ) | ||
64 | PLD( subges r2, r2, #32 ) | ||
65 | PLD( stmia r0!, {r3 - r9, ip} ) | ||
66 | 4: cmn r2, #16 | ||
67 | ldmgeia r1!, {r3 - r6} | ||
68 | subge r2, r2, #16 | ||
69 | stmgeia r0!, {r3 - r6} | ||
70 | adds r2, r2, #20 | ||
71 | ldmgeia r1!, {r3 - r5} | ||
72 | subge r2, r2, #12 | ||
73 | stmgeia r0!, {r3 - r5} | ||
74 | 5: adds r2, r2, #8 | ||
75 | blt 6f | ||
76 | subs r2, r2, #4 | ||
77 | ldrlt r3, [r1], #4 | ||
78 | ldmgeia r1!, {r4, r5} | ||
79 | subge r2, r2, #4 | ||
80 | strlt r3, [r0], #4 | ||
81 | stmgeia r0!, {r4, r5} | ||
82 | 23 | ||
83 | 6: adds r2, r2, #4 | 24 | .macro ldr8w ptr reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 abort |
84 | EXITEQ | 25 | ldmia \ptr!, {\reg1, \reg2, \reg3, \reg4, \reg5, \reg6, \reg7, \reg8} |
85 | cmp r2, #2 | 26 | .endm |
86 | ldrb r3, [r1], #1 | ||
87 | ldrgeb r4, [r1], #1 | ||
88 | ldrgtb r5, [r1], #1 | ||
89 | strb r3, [r0], #1 | ||
90 | strgeb r4, [r0], #1 | ||
91 | strgtb r5, [r0], #1 | ||
92 | EXIT | ||
93 | 27 | ||
94 | 7: rsb ip, ip, #4 | 28 | .macro ldr1b ptr reg cond=al abort |
95 | cmp ip, #2 | 29 | ldr\cond\()b \reg, [\ptr], #1 |
96 | ldrb r3, [r1], #1 | 30 | .endm |
97 | ldrgeb r4, [r1], #1 | ||
98 | ldrgtb r5, [r1], #1 | ||
99 | strb r3, [r0], #1 | ||
100 | strgeb r4, [r0], #1 | ||
101 | strgtb r5, [r0], #1 | ||
102 | subs r2, r2, ip | ||
103 | blt 6b | ||
104 | ands ip, r1, #3 | ||
105 | beq 1b | ||
106 | 31 | ||
107 | 8: bic r1, r1, #3 | 32 | .macro str1w ptr reg abort |
108 | ldr r7, [r1], #4 | 33 | str \reg, [\ptr], #4 |
109 | cmp ip, #2 | 34 | .endm |
110 | bgt 18f | ||
111 | beq 13f | ||
112 | cmp r2, #12 | ||
113 | blt 11f | ||
114 | PLD( pld [r1, #12] ) | ||
115 | sub r2, r2, #12 | ||
116 | PLD( subs r2, r2, #32 ) | ||
117 | PLD( blt 10f ) | ||
118 | PLD( pld [r1, #28] ) | ||
119 | 9: PLD( pld [r1, #44] ) | ||
120 | 10: mov r3, r7, pull #8 | ||
121 | ldmia r1!, {r4 - r7} | ||
122 | subs r2, r2, #16 | ||
123 | orr r3, r3, r4, push #24 | ||
124 | mov r4, r4, pull #8 | ||
125 | orr r4, r4, r5, push #24 | ||
126 | mov r5, r5, pull #8 | ||
127 | orr r5, r5, r6, push #24 | ||
128 | mov r6, r6, pull #8 | ||
129 | orr r6, r6, r7, push #24 | ||
130 | stmia r0!, {r3 - r6} | ||
131 | bge 9b | ||
132 | PLD( cmn r2, #32 ) | ||
133 | PLD( bge 10b ) | ||
134 | PLD( add r2, r2, #32 ) | ||
135 | adds r2, r2, #12 | ||
136 | blt 12f | ||
137 | 11: mov r3, r7, pull #8 | ||
138 | ldr r7, [r1], #4 | ||
139 | subs r2, r2, #4 | ||
140 | orr r3, r3, r7, push #24 | ||
141 | str r3, [r0], #4 | ||
142 | bge 11b | ||
143 | 12: sub r1, r1, #3 | ||
144 | b 6b | ||
145 | 35 | ||
146 | 13: cmp r2, #12 | 36 | .macro str8w ptr reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 abort |
147 | blt 16f | 37 | stmia \ptr!, {\reg1, \reg2, \reg3, \reg4, \reg5, \reg6, \reg7, \reg8} |
148 | PLD( pld [r1, #12] ) | 38 | .endm |
149 | sub r2, r2, #12 | ||
150 | PLD( subs r2, r2, #32 ) | ||
151 | PLD( blt 15f ) | ||
152 | PLD( pld [r1, #28] ) | ||
153 | 14: PLD( pld [r1, #44] ) | ||
154 | 15: mov r3, r7, pull #16 | ||
155 | ldmia r1!, {r4 - r7} | ||
156 | subs r2, r2, #16 | ||
157 | orr r3, r3, r4, push #16 | ||
158 | mov r4, r4, pull #16 | ||
159 | orr r4, r4, r5, push #16 | ||
160 | mov r5, r5, pull #16 | ||
161 | orr r5, r5, r6, push #16 | ||
162 | mov r6, r6, pull #16 | ||
163 | orr r6, r6, r7, push #16 | ||
164 | stmia r0!, {r3 - r6} | ||
165 | bge 14b | ||
166 | PLD( cmn r2, #32 ) | ||
167 | PLD( bge 15b ) | ||
168 | PLD( add r2, r2, #32 ) | ||
169 | adds r2, r2, #12 | ||
170 | blt 17f | ||
171 | 16: mov r3, r7, pull #16 | ||
172 | ldr r7, [r1], #4 | ||
173 | subs r2, r2, #4 | ||
174 | orr r3, r3, r7, push #16 | ||
175 | str r3, [r0], #4 | ||
176 | bge 16b | ||
177 | 17: sub r1, r1, #2 | ||
178 | b 6b | ||
179 | 39 | ||
180 | 18: cmp r2, #12 | 40 | .macro str1b ptr reg cond=al abort |
181 | blt 21f | 41 | str\cond\()b \reg, [\ptr], #1 |
182 | PLD( pld [r1, #12] ) | 42 | .endm |
183 | sub r2, r2, #12 | ||
184 | PLD( subs r2, r2, #32 ) | ||
185 | PLD( blt 20f ) | ||
186 | PLD( pld [r1, #28] ) | ||
187 | 19: PLD( pld [r1, #44] ) | ||
188 | 20: mov r3, r7, pull #24 | ||
189 | ldmia r1!, {r4 - r7} | ||
190 | subs r2, r2, #16 | ||
191 | orr r3, r3, r4, push #8 | ||
192 | mov r4, r4, pull #24 | ||
193 | orr r4, r4, r5, push #8 | ||
194 | mov r5, r5, pull #24 | ||
195 | orr r5, r5, r6, push #8 | ||
196 | mov r6, r6, pull #24 | ||
197 | orr r6, r6, r7, push #8 | ||
198 | stmia r0!, {r3 - r6} | ||
199 | bge 19b | ||
200 | PLD( cmn r2, #32 ) | ||
201 | PLD( bge 20b ) | ||
202 | PLD( add r2, r2, #32 ) | ||
203 | adds r2, r2, #12 | ||
204 | blt 22f | ||
205 | 21: mov r3, r7, pull #24 | ||
206 | ldr r7, [r1], #4 | ||
207 | subs r2, r2, #4 | ||
208 | orr r3, r3, r7, push #8 | ||
209 | str r3, [r0], #4 | ||
210 | bge 21b | ||
211 | 22: sub r1, r1, #1 | ||
212 | b 6b | ||
213 | 43 | ||
44 | .macro enter reg1 reg2 | ||
45 | stmdb sp!, {r0, \reg1, \reg2} | ||
46 | .endm | ||
214 | 47 | ||
215 | 23: add r1, r1, r2 | 48 | .macro exit reg1 reg2 |
216 | add r0, r0, r2 | 49 | ldmfd sp!, {r0, \reg1, \reg2} |
217 | subs r2, r2, #4 | 50 | .endm |
218 | blt 29f | ||
219 | PLD( pld [r1, #-4] ) | ||
220 | ands ip, r0, #3 | ||
221 | bne 30f | ||
222 | ands ip, r1, #3 | ||
223 | bne 31f | ||
224 | 51 | ||
225 | 24: subs r2, r2, #8 | 52 | .text |
226 | blt 28f | ||
227 | subs r2, r2, #20 | ||
228 | blt 27f | ||
229 | PLD( pld [r1, #-32] ) | ||
230 | PLD( subs r2, r2, #64 ) | ||
231 | PLD( blt 26f ) | ||
232 | 25: PLD( pld [r1, #-64] ) | ||
233 | PLD( pld [r1, #-96] ) | ||
234 | ldmdb r1!, {r3 - r9, ip} | ||
235 | subs r2, r2, #32 | ||
236 | stmgedb r0!, {r3 - r9, ip} | ||
237 | ldmgedb r1!, {r3 - r9, ip} | ||
238 | subges r2, r2, #32 | ||
239 | stmdb r0!, {r3 - r9, ip} | ||
240 | bge 25b | ||
241 | 26: PLD( ldmdb r1!, {r3 - r9, ip} ) | ||
242 | PLD( adds r2, r2, #32 ) | ||
243 | PLD( stmgedb r0!, {r3 - r9, ip} ) | ||
244 | PLD( ldmgedb r1!, {r3 - r9, ip} ) | ||
245 | PLD( subges r2, r2, #32 ) | ||
246 | PLD( stmdb r0!, {r3 - r9, ip} ) | ||
247 | 27: cmn r2, #16 | ||
248 | ldmgedb r1!, {r3 - r6} | ||
249 | subge r2, r2, #16 | ||
250 | stmgedb r0!, {r3 - r6} | ||
251 | adds r2, r2, #20 | ||
252 | ldmgedb r1!, {r3 - r5} | ||
253 | subge r2, r2, #12 | ||
254 | stmgedb r0!, {r3 - r5} | ||
255 | 28: adds r2, r2, #8 | ||
256 | blt 29f | ||
257 | subs r2, r2, #4 | ||
258 | ldrlt r3, [r1, #-4]! | ||
259 | ldmgedb r1!, {r4, r5} | ||
260 | subge r2, r2, #4 | ||
261 | strlt r3, [r0, #-4]! | ||
262 | stmgedb r0!, {r4, r5} | ||
263 | 53 | ||
264 | 29: adds r2, r2, #4 | 54 | /* Prototype: void *memcpy(void *dest, const void *src, size_t n); */ |
265 | EXITEQ | ||
266 | cmp r2, #2 | ||
267 | ldrb r3, [r1, #-1]! | ||
268 | ldrgeb r4, [r1, #-1]! | ||
269 | ldrgtb r5, [r1, #-1]! | ||
270 | strb r3, [r0, #-1]! | ||
271 | strgeb r4, [r0, #-1]! | ||
272 | strgtb r5, [r0, #-1]! | ||
273 | EXIT | ||
274 | 55 | ||
275 | 30: cmp ip, #2 | 56 | ENTRY(memcpy) |
276 | ldrb r3, [r1, #-1]! | ||
277 | ldrgeb r4, [r1, #-1]! | ||
278 | ldrgtb r5, [r1, #-1]! | ||
279 | strb r3, [r0, #-1]! | ||
280 | strgeb r4, [r0, #-1]! | ||
281 | strgtb r5, [r0, #-1]! | ||
282 | subs r2, r2, ip | ||
283 | blt 29b | ||
284 | ands ip, r1, #3 | ||
285 | beq 24b | ||
286 | |||
287 | 31: bic r1, r1, #3 | ||
288 | ldr r3, [r1], #0 | ||
289 | cmp ip, #2 | ||
290 | blt 41f | ||
291 | beq 36f | ||
292 | cmp r2, #12 | ||
293 | blt 34f | ||
294 | PLD( pld [r1, #-16] ) | ||
295 | sub r2, r2, #12 | ||
296 | PLD( subs r2, r2, #32 ) | ||
297 | PLD( blt 33f ) | ||
298 | PLD( pld [r1, #-32] ) | ||
299 | 32: PLD( pld [r1, #-48] ) | ||
300 | 33: mov r7, r3, push #8 | ||
301 | ldmdb r1!, {r3, r4, r5, r6} | ||
302 | subs r2, r2, #16 | ||
303 | orr r7, r7, r6, pull #24 | ||
304 | mov r6, r6, push #8 | ||
305 | orr r6, r6, r5, pull #24 | ||
306 | mov r5, r5, push #8 | ||
307 | orr r5, r5, r4, pull #24 | ||
308 | mov r4, r4, push #8 | ||
309 | orr r4, r4, r3, pull #24 | ||
310 | stmdb r0!, {r4, r5, r6, r7} | ||
311 | bge 32b | ||
312 | PLD( cmn r2, #32 ) | ||
313 | PLD( bge 33b ) | ||
314 | PLD( add r2, r2, #32 ) | ||
315 | adds r2, r2, #12 | ||
316 | blt 35f | ||
317 | 34: mov ip, r3, push #8 | ||
318 | ldr r3, [r1, #-4]! | ||
319 | subs r2, r2, #4 | ||
320 | orr ip, ip, r3, pull #24 | ||
321 | str ip, [r0, #-4]! | ||
322 | bge 34b | ||
323 | 35: add r1, r1, #3 | ||
324 | b 29b | ||
325 | |||
326 | 36: cmp r2, #12 | ||
327 | blt 39f | ||
328 | PLD( pld [r1, #-16] ) | ||
329 | sub r2, r2, #12 | ||
330 | PLD( subs r2, r2, #32 ) | ||
331 | PLD( blt 38f ) | ||
332 | PLD( pld [r1, #-32] ) | ||
333 | 37: PLD( pld [r1, #-48] ) | ||
334 | 38: mov r7, r3, push #16 | ||
335 | ldmdb r1!, {r3, r4, r5, r6} | ||
336 | subs r2, r2, #16 | ||
337 | orr r7, r7, r6, pull #16 | ||
338 | mov r6, r6, push #16 | ||
339 | orr r6, r6, r5, pull #16 | ||
340 | mov r5, r5, push #16 | ||
341 | orr r5, r5, r4, pull #16 | ||
342 | mov r4, r4, push #16 | ||
343 | orr r4, r4, r3, pull #16 | ||
344 | stmdb r0!, {r4, r5, r6, r7} | ||
345 | bge 37b | ||
346 | PLD( cmn r2, #32 ) | ||
347 | PLD( bge 38b ) | ||
348 | PLD( add r2, r2, #32 ) | ||
349 | adds r2, r2, #12 | ||
350 | blt 40f | ||
351 | 39: mov ip, r3, push #16 | ||
352 | ldr r3, [r1, #-4]! | ||
353 | subs r2, r2, #4 | ||
354 | orr ip, ip, r3, pull #16 | ||
355 | str ip, [r0, #-4]! | ||
356 | bge 39b | ||
357 | 40: add r1, r1, #2 | ||
358 | b 29b | ||
359 | 57 | ||
360 | 41: cmp r2, #12 | 58 | #include "copy_template.S" |
361 | blt 44f | ||
362 | PLD( pld [r1, #-16] ) | ||
363 | sub r2, r2, #12 | ||
364 | PLD( subs r2, r2, #32 ) | ||
365 | PLD( blt 43f ) | ||
366 | PLD( pld [r1, #-32] ) | ||
367 | 42: PLD( pld [r1, #-48] ) | ||
368 | 43: mov r7, r3, push #24 | ||
369 | ldmdb r1!, {r3, r4, r5, r6} | ||
370 | subs r2, r2, #16 | ||
371 | orr r7, r7, r6, pull #8 | ||
372 | mov r6, r6, push #24 | ||
373 | orr r6, r6, r5, pull #8 | ||
374 | mov r5, r5, push #24 | ||
375 | orr r5, r5, r4, pull #8 | ||
376 | mov r4, r4, push #24 | ||
377 | orr r4, r4, r3, pull #8 | ||
378 | stmdb r0!, {r4, r5, r6, r7} | ||
379 | bge 42b | ||
380 | PLD( cmn r2, #32 ) | ||
381 | PLD( bge 43b ) | ||
382 | PLD( add r2, r2, #32 ) | ||
383 | adds r2, r2, #12 | ||
384 | blt 45f | ||
385 | 44: mov ip, r3, push #24 | ||
386 | ldr r3, [r1, #-4]! | ||
387 | subs r2, r2, #4 | ||
388 | orr ip, ip, r3, pull #8 | ||
389 | str ip, [r0, #-4]! | ||
390 | bge 44b | ||
391 | 45: add r1, r1, #1 | ||
392 | b 29b | ||
393 | 59 | ||
diff --git a/arch/arm/lib/memmove.S b/arch/arm/lib/memmove.S new file mode 100644 index 000000000000..ef7fddc14ac9 --- /dev/null +++ b/arch/arm/lib/memmove.S | |||
@@ -0,0 +1,206 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/lib/memmove.S | ||
3 | * | ||
4 | * Author: Nicolas Pitre | ||
5 | * Created: Sep 28, 2005 | ||
6 | * Copyright: (C) MontaVista Software Inc. | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License version 2 as | ||
10 | * published by the Free Software Foundation. | ||
11 | */ | ||
12 | |||
13 | #include <linux/linkage.h> | ||
14 | #include <asm/assembler.h> | ||
15 | |||
16 | /* | ||
17 | * This can be used to enable code to cacheline align the source pointer. | ||
18 | * Experiments on tested architectures (StrongARM and XScale) didn't show | ||
19 | * this a worthwhile thing to do. That might be different in the future. | ||
20 | */ | ||
21 | //#define CALGN(code...) code | ||
22 | #define CALGN(code...) | ||
23 | |||
24 | .text | ||
25 | |||
26 | /* | ||
27 | * Prototype: void *memmove(void *dest, const void *src, size_t n); | ||
28 | * | ||
29 | * Note: | ||
30 | * | ||
31 | * If the memory regions don't overlap, we simply branch to memcpy which is | ||
32 | * normally a bit faster. Otherwise the copy is done going downwards. This | ||
33 | * is a transposition of the code from copy_template.S but with the copy | ||
34 | * occurring in the opposite direction. | ||
35 | */ | ||
36 | |||
37 | ENTRY(memmove) | ||
38 | |||
39 | subs ip, r0, r1 | ||
40 | cmphi r2, ip | ||
41 | bls memcpy | ||
42 | |||
43 | stmfd sp!, {r0, r4, lr} | ||
44 | add r1, r1, r2 | ||
45 | add r0, r0, r2 | ||
46 | subs r2, r2, #4 | ||
47 | blt 8f | ||
48 | ands ip, r0, #3 | ||
49 | PLD( pld [r1, #-4] ) | ||
50 | bne 9f | ||
51 | ands ip, r1, #3 | ||
52 | bne 10f | ||
53 | |||
54 | 1: subs r2, r2, #(28) | ||
55 | stmfd sp!, {r5 - r8} | ||
56 | blt 5f | ||
57 | |||
58 | CALGN( ands ip, r1, #31 ) | ||
59 | CALGN( sbcnes r4, ip, r2 ) @ C is always set here | ||
60 | CALGN( bcs 2f ) | ||
61 | CALGN( adr r4, 6f ) | ||
62 | CALGN( subs r2, r2, ip ) @ C is set here | ||
63 | CALGN( add pc, r4, ip ) | ||
64 | |||
65 | PLD( pld [r1, #-4] ) | ||
66 | 2: PLD( subs r2, r2, #96 ) | ||
67 | PLD( pld [r1, #-32] ) | ||
68 | PLD( blt 4f ) | ||
69 | PLD( pld [r1, #-64] ) | ||
70 | PLD( pld [r1, #-96] ) | ||
71 | |||
72 | 3: PLD( pld [r1, #-128] ) | ||
73 | 4: ldmdb r1!, {r3, r4, r5, r6, r7, r8, ip, lr} | ||
74 | subs r2, r2, #32 | ||
75 | stmdb r0!, {r3, r4, r5, r6, r7, r8, ip, lr} | ||
76 | bge 3b | ||
77 | PLD( cmn r2, #96 ) | ||
78 | PLD( bge 4b ) | ||
79 | |||
80 | 5: ands ip, r2, #28 | ||
81 | rsb ip, ip, #32 | ||
82 | addne pc, pc, ip @ C is always clear here | ||
83 | b 7f | ||
84 | 6: nop | ||
85 | ldr r3, [r1, #-4]! | ||
86 | ldr r4, [r1, #-4]! | ||
87 | ldr r5, [r1, #-4]! | ||
88 | ldr r6, [r1, #-4]! | ||
89 | ldr r7, [r1, #-4]! | ||
90 | ldr r8, [r1, #-4]! | ||
91 | ldr lr, [r1, #-4]! | ||
92 | |||
93 | add pc, pc, ip | ||
94 | nop | ||
95 | nop | ||
96 | str r3, [r0, #-4]! | ||
97 | str r4, [r0, #-4]! | ||
98 | str r5, [r0, #-4]! | ||
99 | str r6, [r0, #-4]! | ||
100 | str r7, [r0, #-4]! | ||
101 | str r8, [r0, #-4]! | ||
102 | str lr, [r0, #-4]! | ||
103 | |||
104 | CALGN( bcs 2b ) | ||
105 | |||
106 | 7: ldmfd sp!, {r5 - r8} | ||
107 | |||
108 | 8: movs r2, r2, lsl #31 | ||
109 | ldrneb r3, [r1, #-1]! | ||
110 | ldrcsb r4, [r1, #-1]! | ||
111 | ldrcsb ip, [r1, #-1] | ||
112 | strneb r3, [r0, #-1]! | ||
113 | strcsb r4, [r0, #-1]! | ||
114 | strcsb ip, [r0, #-1] | ||
115 | ldmfd sp!, {r0, r4, pc} | ||
116 | |||
117 | 9: cmp ip, #2 | ||
118 | ldrgtb r3, [r1, #-1]! | ||
119 | ldrgeb r4, [r1, #-1]! | ||
120 | ldrb lr, [r1, #-1]! | ||
121 | strgtb r3, [r0, #-1]! | ||
122 | strgeb r4, [r0, #-1]! | ||
123 | subs r2, r2, ip | ||
124 | strb lr, [r0, #-1]! | ||
125 | blt 8b | ||
126 | ands ip, r1, #3 | ||
127 | beq 1b | ||
128 | |||
129 | 10: bic r1, r1, #3 | ||
130 | cmp ip, #2 | ||
131 | ldr r3, [r1, #0] | ||
132 | beq 17f | ||
133 | blt 18f | ||
134 | |||
135 | |||
136 | .macro backward_copy_shift push pull | ||
137 | |||
138 | subs r2, r2, #28 | ||
139 | blt 14f | ||
140 | |||
141 | CALGN( ands ip, r1, #31 ) | ||
142 | CALGN( rsb ip, ip, #32 ) | ||
143 | CALGN( sbcnes r4, ip, r2 ) @ C is always set here | ||
144 | CALGN( subcc r2, r2, ip ) | ||
145 | CALGN( bcc 15f ) | ||
146 | |||
147 | 11: stmfd sp!, {r5 - r9} | ||
148 | |||
149 | PLD( pld [r1, #-4] ) | ||
150 | PLD( subs r2, r2, #96 ) | ||
151 | PLD( pld [r1, #-32] ) | ||
152 | PLD( blt 13f ) | ||
153 | PLD( pld [r1, #-64] ) | ||
154 | PLD( pld [r1, #-96] ) | ||
155 | |||
156 | 12: PLD( pld [r1, #-128] ) | ||
157 | 13: ldmdb r1!, {r7, r8, r9, ip} | ||
158 | mov lr, r3, push #\push | ||
159 | subs r2, r2, #32 | ||
160 | ldmdb r1!, {r3, r4, r5, r6} | ||
161 | orr lr, lr, ip, pull #\pull | ||
162 | mov ip, ip, push #\push | ||
163 | orr ip, ip, r9, pull #\pull | ||
164 | mov r9, r9, push #\push | ||
165 | orr r9, r9, r8, pull #\pull | ||
166 | mov r8, r8, push #\push | ||
167 | orr r8, r8, r7, pull #\pull | ||
168 | mov r7, r7, push #\push | ||
169 | orr r7, r7, r6, pull #\pull | ||
170 | mov r6, r6, push #\push | ||
171 | orr r6, r6, r5, pull #\pull | ||
172 | mov r5, r5, push #\push | ||
173 | orr r5, r5, r4, pull #\pull | ||
174 | mov r4, r4, push #\push | ||
175 | orr r4, r4, r3, pull #\pull | ||
176 | stmdb r0!, {r4 - r9, ip, lr} | ||
177 | bge 12b | ||
178 | PLD( cmn r2, #96 ) | ||
179 | PLD( bge 13b ) | ||
180 | |||
181 | ldmfd sp!, {r5 - r9} | ||
182 | |||
183 | 14: ands ip, r2, #28 | ||
184 | beq 16f | ||
185 | |||
186 | 15: mov lr, r3, push #\push | ||
187 | ldr r3, [r1, #-4]! | ||
188 | subs ip, ip, #4 | ||
189 | orr lr, lr, r3, pull #\pull | ||
190 | str lr, [r0, #-4]! | ||
191 | bgt 15b | ||
192 | CALGN( cmp r2, #0 ) | ||
193 | CALGN( bge 11b ) | ||
194 | |||
195 | 16: add r1, r1, #(\pull / 8) | ||
196 | b 8b | ||
197 | |||
198 | .endm | ||
199 | |||
200 | |||
201 | backward_copy_shift push=8 pull=24 | ||
202 | |||
203 | 17: backward_copy_shift push=16 pull=16 | ||
204 | |||
205 | 18: backward_copy_shift push=24 pull=8 | ||
206 | |||
diff --git a/arch/arm/lib/uaccess.S b/arch/arm/lib/uaccess.S index d3ed0636c008..c28449157bea 100644 --- a/arch/arm/lib/uaccess.S +++ b/arch/arm/lib/uaccess.S | |||
@@ -657,41 +657,3 @@ USER( ldrgtbt r3, [r1], #1) @ May fault | |||
657 | LOADREGS(fd,sp!, {r4 - r7, pc}) | 657 | LOADREGS(fd,sp!, {r4 - r7, pc}) |
658 | .previous | 658 | .previous |
659 | 659 | ||
660 | /* Prototype: int __arch_clear_user(void *addr, size_t sz) | ||
661 | * Purpose : clear some user memory | ||
662 | * Params : addr - user memory address to clear | ||
663 | * : sz - number of bytes to clear | ||
664 | * Returns : number of bytes NOT cleared | ||
665 | */ | ||
666 | ENTRY(__arch_clear_user) | ||
667 | stmfd sp!, {r1, lr} | ||
668 | mov r2, #0 | ||
669 | cmp r1, #4 | ||
670 | blt 2f | ||
671 | ands ip, r0, #3 | ||
672 | beq 1f | ||
673 | cmp ip, #2 | ||
674 | USER( strbt r2, [r0], #1) | ||
675 | USER( strlebt r2, [r0], #1) | ||
676 | USER( strltbt r2, [r0], #1) | ||
677 | rsb ip, ip, #4 | ||
678 | sub r1, r1, ip @ 7 6 5 4 3 2 1 | ||
679 | 1: subs r1, r1, #8 @ -1 -2 -3 -4 -5 -6 -7 | ||
680 | USER( strplt r2, [r0], #4) | ||
681 | USER( strplt r2, [r0], #4) | ||
682 | bpl 1b | ||
683 | adds r1, r1, #4 @ 3 2 1 0 -1 -2 -3 | ||
684 | USER( strplt r2, [r0], #4) | ||
685 | 2: tst r1, #2 @ 1x 1x 0x 0x 1x 1x 0x | ||
686 | USER( strnebt r2, [r0], #1) | ||
687 | USER( strnebt r2, [r0], #1) | ||
688 | tst r1, #1 @ x1 x0 x1 x0 x1 x0 x1 | ||
689 | USER( strnebt r2, [r0], #1) | ||
690 | mov r0, #0 | ||
691 | LOADREGS(fd,sp!, {r1, pc}) | ||
692 | |||
693 | .section .fixup,"ax" | ||
694 | .align 0 | ||
695 | 9001: LOADREGS(fd,sp!, {r0, pc}) | ||
696 | .previous | ||
697 | |||
diff --git a/arch/arm/mach-ebsa110/core.c b/arch/arm/mach-ebsa110/core.c index 15261646dcdd..ed4614983adb 100644 --- a/arch/arm/mach-ebsa110/core.c +++ b/arch/arm/mach-ebsa110/core.c | |||
@@ -251,9 +251,33 @@ static struct platform_device serial_device = { | |||
251 | }, | 251 | }, |
252 | }; | 252 | }; |
253 | 253 | ||
254 | static struct resource am79c961_resources[] = { | ||
255 | { | ||
256 | .start = 0x220, | ||
257 | .end = 0x238, | ||
258 | .flags = IORESOURCE_IO, | ||
259 | }, { | ||
260 | .start = IRQ_EBSA110_ETHERNET, | ||
261 | .end = IRQ_EBSA110_ETHERNET, | ||
262 | .flags = IORESOURCE_IRQ, | ||
263 | }, | ||
264 | }; | ||
265 | |||
266 | static struct platform_device am79c961_device = { | ||
267 | .name = "am79c961", | ||
268 | .id = -1, | ||
269 | .num_resources = ARRAY_SIZE(am79c961_resources), | ||
270 | .resource = am79c961_resources, | ||
271 | }; | ||
272 | |||
273 | static struct platform_device *ebsa110_devices[] = { | ||
274 | &serial_device, | ||
275 | &am79c961_device, | ||
276 | }; | ||
277 | |||
254 | static int __init ebsa110_init(void) | 278 | static int __init ebsa110_init(void) |
255 | { | 279 | { |
256 | return platform_device_register(&serial_device); | 280 | return platform_add_devices(ebsa110_devices, ARRAY_SIZE(ebsa110_devices)); |
257 | } | 281 | } |
258 | 282 | ||
259 | arch_initcall(ebsa110_init); | 283 | arch_initcall(ebsa110_init); |
diff --git a/arch/arm/mach-ixp2000/Makefile b/arch/arm/mach-ixp2000/Makefile index 1e6139d42a92..9621aeb61f46 100644 --- a/arch/arm/mach-ixp2000/Makefile +++ b/arch/arm/mach-ixp2000/Makefile | |||
@@ -1,7 +1,7 @@ | |||
1 | # | 1 | # |
2 | # Makefile for the linux kernel. | 2 | # Makefile for the linux kernel. |
3 | # | 3 | # |
4 | obj-y := core.o pci.o | 4 | obj-y := core.o pci.o uengine.o |
5 | obj-m := | 5 | obj-m := |
6 | obj-n := | 6 | obj-n := |
7 | obj- := | 7 | obj- := |
diff --git a/arch/arm/mach-ixp2000/core.c b/arch/arm/mach-ixp2000/core.c index 01c393c504d0..c93a98b2a32c 100644 --- a/arch/arm/mach-ixp2000/core.c +++ b/arch/arm/mach-ixp2000/core.c | |||
@@ -1,5 +1,5 @@ | |||
1 | /* | 1 | /* |
2 | * arch/arm/mach-ixp2000/common.c | 2 | * arch/arm/mach-ixp2000/core.c |
3 | * | 3 | * |
4 | * Common routines used by all IXP2400/2800 based platforms. | 4 | * Common routines used by all IXP2400/2800 based platforms. |
5 | * | 5 | * |
@@ -49,7 +49,6 @@ static unsigned long ixp2000_slowport_irq_flags; | |||
49 | *************************************************************************/ | 49 | *************************************************************************/ |
50 | void ixp2000_acquire_slowport(struct slowport_cfg *new_cfg, struct slowport_cfg *old_cfg) | 50 | void ixp2000_acquire_slowport(struct slowport_cfg *new_cfg, struct slowport_cfg *old_cfg) |
51 | { | 51 | { |
52 | |||
53 | spin_lock_irqsave(&ixp2000_slowport_lock, ixp2000_slowport_irq_flags); | 52 | spin_lock_irqsave(&ixp2000_slowport_lock, ixp2000_slowport_irq_flags); |
54 | 53 | ||
55 | old_cfg->CCR = *IXP2000_SLOWPORT_CCR; | 54 | old_cfg->CCR = *IXP2000_SLOWPORT_CCR; |
@@ -62,7 +61,7 @@ void ixp2000_acquire_slowport(struct slowport_cfg *new_cfg, struct slowport_cfg | |||
62 | ixp2000_reg_write(IXP2000_SLOWPORT_WTC2, new_cfg->WTC); | 61 | ixp2000_reg_write(IXP2000_SLOWPORT_WTC2, new_cfg->WTC); |
63 | ixp2000_reg_write(IXP2000_SLOWPORT_RTC2, new_cfg->RTC); | 62 | ixp2000_reg_write(IXP2000_SLOWPORT_RTC2, new_cfg->RTC); |
64 | ixp2000_reg_write(IXP2000_SLOWPORT_PCR, new_cfg->PCR); | 63 | ixp2000_reg_write(IXP2000_SLOWPORT_PCR, new_cfg->PCR); |
65 | ixp2000_reg_write(IXP2000_SLOWPORT_ADC, new_cfg->ADC); | 64 | ixp2000_reg_wrb(IXP2000_SLOWPORT_ADC, new_cfg->ADC); |
66 | } | 65 | } |
67 | 66 | ||
68 | void ixp2000_release_slowport(struct slowport_cfg *old_cfg) | 67 | void ixp2000_release_slowport(struct slowport_cfg *old_cfg) |
@@ -71,7 +70,7 @@ void ixp2000_release_slowport(struct slowport_cfg *old_cfg) | |||
71 | ixp2000_reg_write(IXP2000_SLOWPORT_WTC2, old_cfg->WTC); | 70 | ixp2000_reg_write(IXP2000_SLOWPORT_WTC2, old_cfg->WTC); |
72 | ixp2000_reg_write(IXP2000_SLOWPORT_RTC2, old_cfg->RTC); | 71 | ixp2000_reg_write(IXP2000_SLOWPORT_RTC2, old_cfg->RTC); |
73 | ixp2000_reg_write(IXP2000_SLOWPORT_PCR, old_cfg->PCR); | 72 | ixp2000_reg_write(IXP2000_SLOWPORT_PCR, old_cfg->PCR); |
74 | ixp2000_reg_write(IXP2000_SLOWPORT_ADC, old_cfg->ADC); | 73 | ixp2000_reg_wrb(IXP2000_SLOWPORT_ADC, old_cfg->ADC); |
75 | 74 | ||
76 | spin_unlock_irqrestore(&ixp2000_slowport_lock, | 75 | spin_unlock_irqrestore(&ixp2000_slowport_lock, |
77 | ixp2000_slowport_irq_flags); | 76 | ixp2000_slowport_irq_flags); |
@@ -145,7 +144,7 @@ void __init ixp2000_map_io(void) | |||
145 | iotable_init(ixp2000_io_desc, ARRAY_SIZE(ixp2000_io_desc)); | 144 | iotable_init(ixp2000_io_desc, ARRAY_SIZE(ixp2000_io_desc)); |
146 | 145 | ||
147 | /* Set slowport to 8-bit mode. */ | 146 | /* Set slowport to 8-bit mode. */ |
148 | ixp2000_reg_write(IXP2000_SLOWPORT_FRM, 1); | 147 | ixp2000_reg_wrb(IXP2000_SLOWPORT_FRM, 1); |
149 | } | 148 | } |
150 | 149 | ||
151 | 150 | ||
@@ -209,7 +208,7 @@ static int ixp2000_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs) | |||
209 | write_seqlock(&xtime_lock); | 208 | write_seqlock(&xtime_lock); |
210 | 209 | ||
211 | /* clear timer 1 */ | 210 | /* clear timer 1 */ |
212 | ixp2000_reg_write(IXP2000_T1_CLR, 1); | 211 | ixp2000_reg_wrb(IXP2000_T1_CLR, 1); |
213 | 212 | ||
214 | while ((next_jiffy_time - *missing_jiffy_timer_csr) > ticks_per_jiffy) { | 213 | while ((next_jiffy_time - *missing_jiffy_timer_csr) > ticks_per_jiffy) { |
215 | timer_tick(regs); | 214 | timer_tick(regs); |
@@ -252,12 +251,12 @@ void __init ixp2000_init_time(unsigned long tick_rate) | |||
252 | 251 | ||
253 | ixp2000_reg_write(IXP2000_T4_CLR, 0); | 252 | ixp2000_reg_write(IXP2000_T4_CLR, 0); |
254 | ixp2000_reg_write(IXP2000_T4_CLD, -1); | 253 | ixp2000_reg_write(IXP2000_T4_CLD, -1); |
255 | ixp2000_reg_write(IXP2000_T4_CTL, (1 << 7)); | 254 | ixp2000_reg_wrb(IXP2000_T4_CTL, (1 << 7)); |
256 | missing_jiffy_timer_csr = IXP2000_T4_CSR; | 255 | missing_jiffy_timer_csr = IXP2000_T4_CSR; |
257 | } else { | 256 | } else { |
258 | ixp2000_reg_write(IXP2000_T2_CLR, 0); | 257 | ixp2000_reg_write(IXP2000_T2_CLR, 0); |
259 | ixp2000_reg_write(IXP2000_T2_CLD, -1); | 258 | ixp2000_reg_write(IXP2000_T2_CLD, -1); |
260 | ixp2000_reg_write(IXP2000_T2_CTL, (1 << 7)); | 259 | ixp2000_reg_wrb(IXP2000_T2_CTL, (1 << 7)); |
261 | missing_jiffy_timer_csr = IXP2000_T2_CSR; | 260 | missing_jiffy_timer_csr = IXP2000_T2_CSR; |
262 | } | 261 | } |
263 | next_jiffy_time = 0xffffffff; | 262 | next_jiffy_time = 0xffffffff; |
@@ -279,7 +278,7 @@ static void update_gpio_int_csrs(void) | |||
279 | ixp2000_reg_write(IXP2000_GPIO_FEDR, GPIO_IRQ_falling_edge); | 278 | ixp2000_reg_write(IXP2000_GPIO_FEDR, GPIO_IRQ_falling_edge); |
280 | ixp2000_reg_write(IXP2000_GPIO_REDR, GPIO_IRQ_rising_edge); | 279 | ixp2000_reg_write(IXP2000_GPIO_REDR, GPIO_IRQ_rising_edge); |
281 | ixp2000_reg_write(IXP2000_GPIO_LSLR, GPIO_IRQ_level_low); | 280 | ixp2000_reg_write(IXP2000_GPIO_LSLR, GPIO_IRQ_level_low); |
282 | ixp2000_reg_write(IXP2000_GPIO_LSHR, GPIO_IRQ_level_high); | 281 | ixp2000_reg_wrb(IXP2000_GPIO_LSHR, GPIO_IRQ_level_high); |
283 | } | 282 | } |
284 | 283 | ||
285 | void gpio_line_config(int line, int direction) | 284 | void gpio_line_config(int line, int direction) |
@@ -297,9 +296,9 @@ void gpio_line_config(int line, int direction) | |||
297 | GPIO_IRQ_level_high &= ~(1 << line); | 296 | GPIO_IRQ_level_high &= ~(1 << line); |
298 | update_gpio_int_csrs(); | 297 | update_gpio_int_csrs(); |
299 | 298 | ||
300 | ixp2000_reg_write(IXP2000_GPIO_PDSR, 1 << line); | 299 | ixp2000_reg_wrb(IXP2000_GPIO_PDSR, 1 << line); |
301 | } else if (direction == GPIO_IN) { | 300 | } else if (direction == GPIO_IN) { |
302 | ixp2000_reg_write(IXP2000_GPIO_PDCR, 1 << line); | 301 | ixp2000_reg_wrb(IXP2000_GPIO_PDCR, 1 << line); |
303 | } | 302 | } |
304 | local_irq_restore(flags); | 303 | local_irq_restore(flags); |
305 | } | 304 | } |
@@ -365,12 +364,12 @@ static void ixp2000_GPIO_irq_mask_ack(unsigned int irq) | |||
365 | 364 | ||
366 | ixp2000_reg_write(IXP2000_GPIO_EDSR, (1 << (irq - IRQ_IXP2000_GPIO0))); | 365 | ixp2000_reg_write(IXP2000_GPIO_EDSR, (1 << (irq - IRQ_IXP2000_GPIO0))); |
367 | ixp2000_reg_write(IXP2000_GPIO_LDSR, (1 << (irq - IRQ_IXP2000_GPIO0))); | 366 | ixp2000_reg_write(IXP2000_GPIO_LDSR, (1 << (irq - IRQ_IXP2000_GPIO0))); |
368 | ixp2000_reg_write(IXP2000_GPIO_INST, (1 << (irq - IRQ_IXP2000_GPIO0))); | 367 | ixp2000_reg_wrb(IXP2000_GPIO_INST, (1 << (irq - IRQ_IXP2000_GPIO0))); |
369 | } | 368 | } |
370 | 369 | ||
371 | static void ixp2000_GPIO_irq_mask(unsigned int irq) | 370 | static void ixp2000_GPIO_irq_mask(unsigned int irq) |
372 | { | 371 | { |
373 | ixp2000_reg_write(IXP2000_GPIO_INCR, (1 << (irq - IRQ_IXP2000_GPIO0))); | 372 | ixp2000_reg_wrb(IXP2000_GPIO_INCR, (1 << (irq - IRQ_IXP2000_GPIO0))); |
374 | } | 373 | } |
375 | 374 | ||
376 | static void ixp2000_GPIO_irq_unmask(unsigned int irq) | 375 | static void ixp2000_GPIO_irq_unmask(unsigned int irq) |
@@ -389,9 +388,9 @@ static void ixp2000_pci_irq_mask(unsigned int irq) | |||
389 | { | 388 | { |
390 | unsigned long temp = *IXP2000_PCI_XSCALE_INT_ENABLE; | 389 | unsigned long temp = *IXP2000_PCI_XSCALE_INT_ENABLE; |
391 | if (irq == IRQ_IXP2000_PCIA) | 390 | if (irq == IRQ_IXP2000_PCIA) |
392 | ixp2000_reg_write(IXP2000_PCI_XSCALE_INT_ENABLE, (temp & ~(1 << 26))); | 391 | ixp2000_reg_wrb(IXP2000_PCI_XSCALE_INT_ENABLE, (temp & ~(1 << 26))); |
393 | else if (irq == IRQ_IXP2000_PCIB) | 392 | else if (irq == IRQ_IXP2000_PCIB) |
394 | ixp2000_reg_write(IXP2000_PCI_XSCALE_INT_ENABLE, (temp & ~(1 << 27))); | 393 | ixp2000_reg_wrb(IXP2000_PCI_XSCALE_INT_ENABLE, (temp & ~(1 << 27))); |
395 | } | 394 | } |
396 | 395 | ||
397 | static void ixp2000_pci_irq_unmask(unsigned int irq) | 396 | static void ixp2000_pci_irq_unmask(unsigned int irq) |
@@ -411,7 +410,7 @@ static struct irqchip ixp2000_pci_irq_chip = { | |||
411 | 410 | ||
412 | static void ixp2000_irq_mask(unsigned int irq) | 411 | static void ixp2000_irq_mask(unsigned int irq) |
413 | { | 412 | { |
414 | ixp2000_reg_write(IXP2000_IRQ_ENABLE_CLR, (1 << irq)); | 413 | ixp2000_reg_wrb(IXP2000_IRQ_ENABLE_CLR, (1 << irq)); |
415 | } | 414 | } |
416 | 415 | ||
417 | static void ixp2000_irq_unmask(unsigned int irq) | 416 | static void ixp2000_irq_unmask(unsigned int irq) |
@@ -443,7 +442,7 @@ void __init ixp2000_init_irq(void) | |||
443 | ixp2000_reg_write(IXP2000_GPIO_INCR, -1); | 442 | ixp2000_reg_write(IXP2000_GPIO_INCR, -1); |
444 | 443 | ||
445 | /* clear PCI interrupt sources */ | 444 | /* clear PCI interrupt sources */ |
446 | ixp2000_reg_write(IXP2000_PCI_XSCALE_INT_ENABLE, 0); | 445 | ixp2000_reg_wrb(IXP2000_PCI_XSCALE_INT_ENABLE, 0); |
447 | 446 | ||
448 | /* | 447 | /* |
449 | * Certain bits in the IRQ status register of the | 448 | * Certain bits in the IRQ status register of the |
diff --git a/arch/arm/mach-ixp2000/enp2611.c b/arch/arm/mach-ixp2000/enp2611.c index 643f5e1c3d93..7719c478aa84 100644 --- a/arch/arm/mach-ixp2000/enp2611.c +++ b/arch/arm/mach-ixp2000/enp2611.c | |||
@@ -64,6 +64,35 @@ static struct sys_timer enp2611_timer = { | |||
64 | 64 | ||
65 | 65 | ||
66 | /************************************************************************* | 66 | /************************************************************************* |
67 | * ENP-2611 I/O | ||
68 | *************************************************************************/ | ||
69 | static struct map_desc enp2611_io_desc[] __initdata = { | ||
70 | { | ||
71 | .virtual = ENP2611_CALEB_VIRT_BASE, | ||
72 | .physical = ENP2611_CALEB_PHYS_BASE, | ||
73 | .length = ENP2611_CALEB_SIZE, | ||
74 | .type = MT_IXP2000_DEVICE | ||
75 | }, { | ||
76 | .virtual = ENP2611_PM3386_0_VIRT_BASE, | ||
77 | .physical = ENP2611_PM3386_0_PHYS_BASE, | ||
78 | .length = ENP2611_PM3386_0_SIZE, | ||
79 | .type = MT_IXP2000_DEVICE | ||
80 | }, { | ||
81 | .virtual = ENP2611_PM3386_1_VIRT_BASE, | ||
82 | .physical = ENP2611_PM3386_1_PHYS_BASE, | ||
83 | .length = ENP2611_PM3386_1_SIZE, | ||
84 | .type = MT_IXP2000_DEVICE | ||
85 | } | ||
86 | }; | ||
87 | |||
88 | void __init enp2611_map_io(void) | ||
89 | { | ||
90 | ixp2000_map_io(); | ||
91 | iotable_init(enp2611_io_desc, ARRAY_SIZE(enp2611_io_desc)); | ||
92 | } | ||
93 | |||
94 | |||
95 | /************************************************************************* | ||
67 | * ENP-2611 PCI | 96 | * ENP-2611 PCI |
68 | *************************************************************************/ | 97 | *************************************************************************/ |
69 | static int enp2611_pci_setup(int nr, struct pci_sys_data *sys) | 98 | static int enp2611_pci_setup(int nr, struct pci_sys_data *sys) |
@@ -229,7 +258,7 @@ MACHINE_START(ENP2611, "Radisys ENP-2611 PCI network processor board") | |||
229 | .phys_io = IXP2000_UART_PHYS_BASE, | 258 | .phys_io = IXP2000_UART_PHYS_BASE, |
230 | .io_pg_offst = ((IXP2000_UART_VIRT_BASE) >> 18) & 0xfffc, | 259 | .io_pg_offst = ((IXP2000_UART_VIRT_BASE) >> 18) & 0xfffc, |
231 | .boot_params = 0x00000100, | 260 | .boot_params = 0x00000100, |
232 | .map_io = ixp2000_map_io, | 261 | .map_io = enp2611_map_io, |
233 | .init_irq = ixp2000_init_irq, | 262 | .init_irq = ixp2000_init_irq, |
234 | .timer = &enp2611_timer, | 263 | .timer = &enp2611_timer, |
235 | .init_machine = enp2611_init_machine, | 264 | .init_machine = enp2611_init_machine, |
diff --git a/arch/arm/mach-ixp2000/ixdp2x00.c b/arch/arm/mach-ixp2000/ixdp2x00.c index 05dfcb48c2b6..d628da56b4bc 100644 --- a/arch/arm/mach-ixp2000/ixdp2x00.c +++ b/arch/arm/mach-ixp2000/ixdp2x00.c | |||
@@ -81,7 +81,7 @@ static void ixdp2x00_irq_mask(unsigned int irq) | |||
81 | 81 | ||
82 | dummy = *board_irq_mask; | 82 | dummy = *board_irq_mask; |
83 | dummy |= IXP2000_BOARD_IRQ_MASK(irq); | 83 | dummy |= IXP2000_BOARD_IRQ_MASK(irq); |
84 | ixp2000_reg_write(board_irq_mask, dummy); | 84 | ixp2000_reg_wrb(board_irq_mask, dummy); |
85 | 85 | ||
86 | #ifdef CONFIG_ARCH_IXDP2400 | 86 | #ifdef CONFIG_ARCH_IXDP2400 |
87 | if (machine_is_ixdp2400()) | 87 | if (machine_is_ixdp2400()) |
@@ -101,7 +101,7 @@ static void ixdp2x00_irq_unmask(unsigned int irq) | |||
101 | 101 | ||
102 | dummy = *board_irq_mask; | 102 | dummy = *board_irq_mask; |
103 | dummy &= ~IXP2000_BOARD_IRQ_MASK(irq); | 103 | dummy &= ~IXP2000_BOARD_IRQ_MASK(irq); |
104 | ixp2000_reg_write(board_irq_mask, dummy); | 104 | ixp2000_reg_wrb(board_irq_mask, dummy); |
105 | 105 | ||
106 | if (machine_is_ixdp2400()) | 106 | if (machine_is_ixdp2400()) |
107 | ixp2000_release_slowport(&old_cfg); | 107 | ixp2000_release_slowport(&old_cfg); |
diff --git a/arch/arm/mach-ixp2000/ixdp2x01.c b/arch/arm/mach-ixp2000/ixdp2x01.c index b21249908ae4..e6a882f35da2 100644 --- a/arch/arm/mach-ixp2000/ixdp2x01.c +++ b/arch/arm/mach-ixp2000/ixdp2x01.c | |||
@@ -51,7 +51,7 @@ | |||
51 | *************************************************************************/ | 51 | *************************************************************************/ |
52 | static void ixdp2x01_irq_mask(unsigned int irq) | 52 | static void ixdp2x01_irq_mask(unsigned int irq) |
53 | { | 53 | { |
54 | ixp2000_reg_write(IXDP2X01_INT_MASK_SET_REG, | 54 | ixp2000_reg_wrb(IXDP2X01_INT_MASK_SET_REG, |
55 | IXP2000_BOARD_IRQ_MASK(irq)); | 55 | IXP2000_BOARD_IRQ_MASK(irq)); |
56 | } | 56 | } |
57 | 57 | ||
@@ -114,7 +114,7 @@ void __init ixdp2x01_init_irq(void) | |||
114 | 114 | ||
115 | /* Mask all interrupts from CPLD, disable simulation */ | 115 | /* Mask all interrupts from CPLD, disable simulation */ |
116 | ixp2000_reg_write(IXDP2X01_INT_MASK_SET_REG, 0xffffffff); | 116 | ixp2000_reg_write(IXDP2X01_INT_MASK_SET_REG, 0xffffffff); |
117 | ixp2000_reg_write(IXDP2X01_INT_SIM_REG, 0); | 117 | ixp2000_reg_wrb(IXDP2X01_INT_SIM_REG, 0); |
118 | 118 | ||
119 | for (irq = NR_IXP2000_IRQS; irq < NR_IXDP2X01_IRQS; irq++) { | 119 | for (irq = NR_IXP2000_IRQS; irq < NR_IXDP2X01_IRQS; irq++) { |
120 | if (irq & valid_irq_mask) { | 120 | if (irq & valid_irq_mask) { |
@@ -299,7 +299,6 @@ struct hw_pci ixdp2x01_pci __initdata = { | |||
299 | 299 | ||
300 | int __init ixdp2x01_pci_init(void) | 300 | int __init ixdp2x01_pci_init(void) |
301 | { | 301 | { |
302 | |||
303 | pci_common_init(&ixdp2x01_pci); | 302 | pci_common_init(&ixdp2x01_pci); |
304 | return 0; | 303 | return 0; |
305 | } | 304 | } |
@@ -316,7 +315,7 @@ static struct flash_platform_data ixdp2x01_flash_platform_data = { | |||
316 | 315 | ||
317 | static unsigned long ixdp2x01_flash_bank_setup(unsigned long ofs) | 316 | static unsigned long ixdp2x01_flash_bank_setup(unsigned long ofs) |
318 | { | 317 | { |
319 | ixp2000_reg_write(IXDP2X01_CPLD_FLASH_REG, | 318 | ixp2000_reg_wrb(IXDP2X01_CPLD_FLASH_REG, |
320 | ((ofs >> IXDP2X01_FLASH_WINDOW_BITS) | IXDP2X01_CPLD_FLASH_INTERN)); | 319 | ((ofs >> IXDP2X01_FLASH_WINDOW_BITS) | IXDP2X01_CPLD_FLASH_INTERN)); |
321 | return (ofs & IXDP2X01_FLASH_WINDOW_MASK); | 320 | return (ofs & IXDP2X01_FLASH_WINDOW_MASK); |
322 | } | 321 | } |
@@ -363,7 +362,7 @@ static struct platform_device *ixdp2x01_devices[] __initdata = { | |||
363 | 362 | ||
364 | static void __init ixdp2x01_init_machine(void) | 363 | static void __init ixdp2x01_init_machine(void) |
365 | { | 364 | { |
366 | ixp2000_reg_write(IXDP2X01_CPLD_FLASH_REG, | 365 | ixp2000_reg_wrb(IXDP2X01_CPLD_FLASH_REG, |
367 | (IXDP2X01_CPLD_FLASH_BANK_MASK | IXDP2X01_CPLD_FLASH_INTERN)); | 366 | (IXDP2X01_CPLD_FLASH_BANK_MASK | IXDP2X01_CPLD_FLASH_INTERN)); |
368 | 367 | ||
369 | ixdp2x01_flash_data.nr_banks = | 368 | ixdp2x01_flash_data.nr_banks = |
diff --git a/arch/arm/mach-ixp2000/pci.c b/arch/arm/mach-ixp2000/pci.c index 522205acb316..d4bf1e1c0031 100644 --- a/arch/arm/mach-ixp2000/pci.c +++ b/arch/arm/mach-ixp2000/pci.c | |||
@@ -148,7 +148,7 @@ int ixp2000_pci_abort_handler(unsigned long addr, unsigned int fsr, struct pt_re | |||
148 | local_irq_save(flags); | 148 | local_irq_save(flags); |
149 | temp = *(IXP2000_PCI_CONTROL); | 149 | temp = *(IXP2000_PCI_CONTROL); |
150 | if (temp & ((1 << 8) | (1 << 5))) { | 150 | if (temp & ((1 << 8) | (1 << 5))) { |
151 | ixp2000_reg_write(IXP2000_PCI_CONTROL, temp); | 151 | ixp2000_reg_wrb(IXP2000_PCI_CONTROL, temp); |
152 | } | 152 | } |
153 | 153 | ||
154 | temp = *(IXP2000_PCI_CMDSTAT); | 154 | temp = *(IXP2000_PCI_CMDSTAT); |
@@ -178,8 +178,8 @@ clear_master_aborts(void) | |||
178 | 178 | ||
179 | local_irq_save(flags); | 179 | local_irq_save(flags); |
180 | temp = *(IXP2000_PCI_CONTROL); | 180 | temp = *(IXP2000_PCI_CONTROL); |
181 | if (temp & ((1 << 8) | (1 << 5))) { | 181 | if (temp & ((1 << 8) | (1 << 5))) { |
182 | ixp2000_reg_write(IXP2000_PCI_CONTROL, temp); | 182 | ixp2000_reg_wrb(IXP2000_PCI_CONTROL, temp); |
183 | } | 183 | } |
184 | 184 | ||
185 | temp = *(IXP2000_PCI_CMDSTAT); | 185 | temp = *(IXP2000_PCI_CMDSTAT); |
diff --git a/arch/arm/mach-ixp2000/uengine.c b/arch/arm/mach-ixp2000/uengine.c new file mode 100644 index 000000000000..43e234349d4a --- /dev/null +++ b/arch/arm/mach-ixp2000/uengine.c | |||
@@ -0,0 +1,474 @@ | |||
1 | /* | ||
2 | * Generic library functions for the microengines found on the Intel | ||
3 | * IXP2000 series of network processors. | ||
4 | * | ||
5 | * Copyright (C) 2004, 2005 Lennert Buytenhek <buytenh@wantstofly.org> | ||
6 | * Dedicated to Marija Kulikova. | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU Lesser General Public License as | ||
10 | * published by the Free Software Foundation; either version 2.1 of the | ||
11 | * License, or (at your option) any later version. | ||
12 | */ | ||
13 | |||
14 | #include <linux/config.h> | ||
15 | #include <linux/kernel.h> | ||
16 | #include <linux/init.h> | ||
17 | #include <linux/slab.h> | ||
18 | #include <linux/module.h> | ||
19 | #include <linux/string.h> | ||
20 | #include <asm/hardware.h> | ||
21 | #include <asm/arch/ixp2000-regs.h> | ||
22 | #include <asm/arch/uengine.h> | ||
23 | #include <asm/io.h> | ||
24 | |||
25 | #define USTORE_ADDRESS 0x000 | ||
26 | #define USTORE_DATA_LOWER 0x004 | ||
27 | #define USTORE_DATA_UPPER 0x008 | ||
28 | #define CTX_ENABLES 0x018 | ||
29 | #define CC_ENABLE 0x01c | ||
30 | #define CSR_CTX_POINTER 0x020 | ||
31 | #define INDIRECT_CTX_STS 0x040 | ||
32 | #define ACTIVE_CTX_STS 0x044 | ||
33 | #define INDIRECT_CTX_SIG_EVENTS 0x048 | ||
34 | #define INDIRECT_CTX_WAKEUP_EVENTS 0x050 | ||
35 | #define NN_PUT 0x080 | ||
36 | #define NN_GET 0x084 | ||
37 | #define TIMESTAMP_LOW 0x0c0 | ||
38 | #define TIMESTAMP_HIGH 0x0c4 | ||
39 | #define T_INDEX_BYTE_INDEX 0x0f4 | ||
40 | #define LOCAL_CSR_STATUS 0x180 | ||
41 | |||
42 | u32 ixp2000_uengine_mask; | ||
43 | |||
44 | static void *ixp2000_uengine_csr_area(int uengine) | ||
45 | { | ||
46 | return ((void *)IXP2000_UENGINE_CSR_VIRT_BASE) + (uengine << 10); | ||
47 | } | ||
48 | |||
49 | /* | ||
50 | * LOCAL_CSR_STATUS=1 after a read or write to a microengine's CSR | ||
51 | * space means that the microengine we tried to access was also trying | ||
52 | * to access its own CSR space on the same clock cycle as we did. When | ||
53 | * this happens, we lose the arbitration process by default, and the | ||
54 | * read or write we tried to do was not actually performed, so we try | ||
55 | * again until it succeeds. | ||
56 | */ | ||
57 | u32 ixp2000_uengine_csr_read(int uengine, int offset) | ||
58 | { | ||
59 | void *uebase; | ||
60 | u32 *local_csr_status; | ||
61 | u32 *reg; | ||
62 | u32 value; | ||
63 | |||
64 | uebase = ixp2000_uengine_csr_area(uengine); | ||
65 | |||
66 | local_csr_status = (u32 *)(uebase + LOCAL_CSR_STATUS); | ||
67 | reg = (u32 *)(uebase + offset); | ||
68 | do { | ||
69 | value = ixp2000_reg_read(reg); | ||
70 | } while (ixp2000_reg_read(local_csr_status) & 1); | ||
71 | |||
72 | return value; | ||
73 | } | ||
74 | EXPORT_SYMBOL(ixp2000_uengine_csr_read); | ||
75 | |||
76 | void ixp2000_uengine_csr_write(int uengine, int offset, u32 value) | ||
77 | { | ||
78 | void *uebase; | ||
79 | u32 *local_csr_status; | ||
80 | u32 *reg; | ||
81 | |||
82 | uebase = ixp2000_uengine_csr_area(uengine); | ||
83 | |||
84 | local_csr_status = (u32 *)(uebase + LOCAL_CSR_STATUS); | ||
85 | reg = (u32 *)(uebase + offset); | ||
86 | do { | ||
87 | ixp2000_reg_write(reg, value); | ||
88 | } while (ixp2000_reg_read(local_csr_status) & 1); | ||
89 | } | ||
90 | EXPORT_SYMBOL(ixp2000_uengine_csr_write); | ||
91 | |||
92 | void ixp2000_uengine_reset(u32 uengine_mask) | ||
93 | { | ||
94 | ixp2000_reg_write(IXP2000_RESET1, uengine_mask & ixp2000_uengine_mask); | ||
95 | ixp2000_reg_write(IXP2000_RESET1, 0); | ||
96 | } | ||
97 | EXPORT_SYMBOL(ixp2000_uengine_reset); | ||
98 | |||
99 | void ixp2000_uengine_set_mode(int uengine, u32 mode) | ||
100 | { | ||
101 | /* | ||
102 | * CTL_STR_PAR_EN: unconditionally enable parity checking on | ||
103 | * control store. | ||
104 | */ | ||
105 | mode |= 0x10000000; | ||
106 | ixp2000_uengine_csr_write(uengine, CTX_ENABLES, mode); | ||
107 | |||
108 | /* | ||
109 | * Enable updating of condition codes. | ||
110 | */ | ||
111 | ixp2000_uengine_csr_write(uengine, CC_ENABLE, 0x00002000); | ||
112 | |||
113 | /* | ||
114 | * Initialise other per-microengine registers. | ||
115 | */ | ||
116 | ixp2000_uengine_csr_write(uengine, NN_PUT, 0x00); | ||
117 | ixp2000_uengine_csr_write(uengine, NN_GET, 0x00); | ||
118 | ixp2000_uengine_csr_write(uengine, T_INDEX_BYTE_INDEX, 0); | ||
119 | } | ||
120 | EXPORT_SYMBOL(ixp2000_uengine_set_mode); | ||
121 | |||
122 | static int make_even_parity(u32 x) | ||
123 | { | ||
124 | return hweight32(x) & 1; | ||
125 | } | ||
126 | |||
127 | static void ustore_write(int uengine, u64 insn) | ||
128 | { | ||
129 | /* | ||
130 | * Generate even parity for top and bottom 20 bits. | ||
131 | */ | ||
132 | insn |= (u64)make_even_parity((insn >> 20) & 0x000fffff) << 41; | ||
133 | insn |= (u64)make_even_parity(insn & 0x000fffff) << 40; | ||
134 | |||
135 | /* | ||
136 | * Write to microstore. The second write auto-increments | ||
137 | * the USTORE_ADDRESS index register. | ||
138 | */ | ||
139 | ixp2000_uengine_csr_write(uengine, USTORE_DATA_LOWER, (u32)insn); | ||
140 | ixp2000_uengine_csr_write(uengine, USTORE_DATA_UPPER, (u32)(insn >> 32)); | ||
141 | } | ||
142 | |||
143 | void ixp2000_uengine_load_microcode(int uengine, u8 *ucode, int insns) | ||
144 | { | ||
145 | int i; | ||
146 | |||
147 | /* | ||
148 | * Start writing to microstore at address 0. | ||
149 | */ | ||
150 | ixp2000_uengine_csr_write(uengine, USTORE_ADDRESS, 0x80000000); | ||
151 | for (i = 0; i < insns; i++) { | ||
152 | u64 insn; | ||
153 | |||
154 | insn = (((u64)ucode[0]) << 32) | | ||
155 | (((u64)ucode[1]) << 24) | | ||
156 | (((u64)ucode[2]) << 16) | | ||
157 | (((u64)ucode[3]) << 8) | | ||
158 | ((u64)ucode[4]); | ||
159 | ucode += 5; | ||
160 | |||
161 | ustore_write(uengine, insn); | ||
162 | } | ||
163 | |||
164 | /* | ||
165 | * Pad with a few NOPs at the end (to avoid the microengine | ||
166 | * aborting as it prefetches beyond the last instruction), unless | ||
167 | * we run off the end of the instruction store first, at which | ||
168 | * point the address register will wrap back to zero. | ||
169 | */ | ||
170 | for (i = 0; i < 4; i++) { | ||
171 | u32 addr; | ||
172 | |||
173 | addr = ixp2000_uengine_csr_read(uengine, USTORE_ADDRESS); | ||
174 | if (addr == 0x80000000) | ||
175 | break; | ||
176 | ustore_write(uengine, 0xf0000c0300ULL); | ||
177 | } | ||
178 | |||
179 | /* | ||
180 | * End programming. | ||
181 | */ | ||
182 | ixp2000_uengine_csr_write(uengine, USTORE_ADDRESS, 0x00000000); | ||
183 | } | ||
184 | EXPORT_SYMBOL(ixp2000_uengine_load_microcode); | ||
185 | |||
186 | void ixp2000_uengine_init_context(int uengine, int context, int pc) | ||
187 | { | ||
188 | /* | ||
189 | * Select the right context for indirect access. | ||
190 | */ | ||
191 | ixp2000_uengine_csr_write(uengine, CSR_CTX_POINTER, context); | ||
192 | |||
193 | /* | ||
194 | * Initialise signal masks to immediately go to Ready state. | ||
195 | */ | ||
196 | ixp2000_uengine_csr_write(uengine, INDIRECT_CTX_SIG_EVENTS, 1); | ||
197 | ixp2000_uengine_csr_write(uengine, INDIRECT_CTX_WAKEUP_EVENTS, 1); | ||
198 | |||
199 | /* | ||
200 | * Set program counter. | ||
201 | */ | ||
202 | ixp2000_uengine_csr_write(uengine, INDIRECT_CTX_STS, pc); | ||
203 | } | ||
204 | EXPORT_SYMBOL(ixp2000_uengine_init_context); | ||
205 | |||
206 | void ixp2000_uengine_start_contexts(int uengine, u8 ctx_mask) | ||
207 | { | ||
208 | u32 mask; | ||
209 | |||
210 | /* | ||
211 | * Enable the specified context to go to Executing state. | ||
212 | */ | ||
213 | mask = ixp2000_uengine_csr_read(uengine, CTX_ENABLES); | ||
214 | mask |= ctx_mask << 8; | ||
215 | ixp2000_uengine_csr_write(uengine, CTX_ENABLES, mask); | ||
216 | } | ||
217 | EXPORT_SYMBOL(ixp2000_uengine_start_contexts); | ||
218 | |||
219 | void ixp2000_uengine_stop_contexts(int uengine, u8 ctx_mask) | ||
220 | { | ||
221 | u32 mask; | ||
222 | |||
223 | /* | ||
224 | * Disable the Ready->Executing transition. Note that this | ||
225 | * does not stop the context until it voluntarily yields. | ||
226 | */ | ||
227 | mask = ixp2000_uengine_csr_read(uengine, CTX_ENABLES); | ||
228 | mask &= ~(ctx_mask << 8); | ||
229 | ixp2000_uengine_csr_write(uengine, CTX_ENABLES, mask); | ||
230 | } | ||
231 | EXPORT_SYMBOL(ixp2000_uengine_stop_contexts); | ||
232 | |||
233 | static int check_ixp_type(struct ixp2000_uengine_code *c) | ||
234 | { | ||
235 | u32 product_id; | ||
236 | u32 rev; | ||
237 | |||
238 | product_id = ixp2000_reg_read(IXP2000_PRODUCT_ID); | ||
239 | if (((product_id >> 16) & 0x1f) != 0) | ||
240 | return 0; | ||
241 | |||
242 | switch ((product_id >> 8) & 0xff) { | ||
243 | case 0: /* IXP2800 */ | ||
244 | if (!(c->cpu_model_bitmask & 4)) | ||
245 | return 0; | ||
246 | break; | ||
247 | |||
248 | case 1: /* IXP2850 */ | ||
249 | if (!(c->cpu_model_bitmask & 8)) | ||
250 | return 0; | ||
251 | break; | ||
252 | |||
253 | case 2: /* IXP2400 */ | ||
254 | if (!(c->cpu_model_bitmask & 2)) | ||
255 | return 0; | ||
256 | break; | ||
257 | |||
258 | default: | ||
259 | return 0; | ||
260 | } | ||
261 | |||
262 | rev = product_id & 0xff; | ||
263 | if (rev < c->cpu_min_revision || rev > c->cpu_max_revision) | ||
264 | return 0; | ||
265 | |||
266 | return 1; | ||
267 | } | ||
268 | |||
269 | static void generate_ucode(u8 *ucode, u32 *gpr_a, u32 *gpr_b) | ||
270 | { | ||
271 | int offset; | ||
272 | int i; | ||
273 | |||
274 | offset = 0; | ||
275 | |||
276 | for (i = 0; i < 128; i++) { | ||
277 | u8 b3; | ||
278 | u8 b2; | ||
279 | u8 b1; | ||
280 | u8 b0; | ||
281 | |||
282 | b3 = (gpr_a[i] >> 24) & 0xff; | ||
283 | b2 = (gpr_a[i] >> 16) & 0xff; | ||
284 | b1 = (gpr_a[i] >> 8) & 0xff; | ||
285 | b0 = gpr_a[i] & 0xff; | ||
286 | |||
287 | // immed[@ai, (b1 << 8) | b0] | ||
288 | // 11110000 0000VVVV VVVV11VV VVVVVV00 1IIIIIII | ||
289 | ucode[offset++] = 0xf0; | ||
290 | ucode[offset++] = (b1 >> 4); | ||
291 | ucode[offset++] = (b1 << 4) | 0x0c | (b0 >> 6); | ||
292 | ucode[offset++] = (b0 << 2); | ||
293 | ucode[offset++] = 0x80 | i; | ||
294 | |||
295 | // immed_w1[@ai, (b3 << 8) | b2] | ||
296 | // 11110100 0100VVVV VVVV11VV VVVVVV00 1IIIIIII | ||
297 | ucode[offset++] = 0xf4; | ||
298 | ucode[offset++] = 0x40 | (b3 >> 4); | ||
299 | ucode[offset++] = (b3 << 4) | 0x0c | (b2 >> 6); | ||
300 | ucode[offset++] = (b2 << 2); | ||
301 | ucode[offset++] = 0x80 | i; | ||
302 | } | ||
303 | |||
304 | for (i = 0; i < 128; i++) { | ||
305 | u8 b3; | ||
306 | u8 b2; | ||
307 | u8 b1; | ||
308 | u8 b0; | ||
309 | |||
310 | b3 = (gpr_b[i] >> 24) & 0xff; | ||
311 | b2 = (gpr_b[i] >> 16) & 0xff; | ||
312 | b1 = (gpr_b[i] >> 8) & 0xff; | ||
313 | b0 = gpr_b[i] & 0xff; | ||
314 | |||
315 | // immed[@bi, (b1 << 8) | b0] | ||
316 | // 11110000 0000VVVV VVVV001I IIIIII11 VVVVVVVV | ||
317 | ucode[offset++] = 0xf0; | ||
318 | ucode[offset++] = (b1 >> 4); | ||
319 | ucode[offset++] = (b1 << 4) | 0x02 | (i >> 6); | ||
320 | ucode[offset++] = (i << 2) | 0x03; | ||
321 | ucode[offset++] = b0; | ||
322 | |||
323 | // immed_w1[@bi, (b3 << 8) | b2] | ||
324 | // 11110100 0100VVVV VVVV001I IIIIII11 VVVVVVVV | ||
325 | ucode[offset++] = 0xf4; | ||
326 | ucode[offset++] = 0x40 | (b3 >> 4); | ||
327 | ucode[offset++] = (b3 << 4) | 0x02 | (i >> 6); | ||
328 | ucode[offset++] = (i << 2) | 0x03; | ||
329 | ucode[offset++] = b2; | ||
330 | } | ||
331 | |||
332 | // ctx_arb[kill] | ||
333 | ucode[offset++] = 0xe0; | ||
334 | ucode[offset++] = 0x00; | ||
335 | ucode[offset++] = 0x01; | ||
336 | ucode[offset++] = 0x00; | ||
337 | ucode[offset++] = 0x00; | ||
338 | } | ||
339 | |||
340 | static int set_initial_registers(int uengine, struct ixp2000_uengine_code *c) | ||
341 | { | ||
342 | int per_ctx_regs; | ||
343 | u32 *gpr_a; | ||
344 | u32 *gpr_b; | ||
345 | u8 *ucode; | ||
346 | int i; | ||
347 | |||
348 | gpr_a = kmalloc(128 * sizeof(u32), GFP_KERNEL); | ||
349 | gpr_b = kmalloc(128 * sizeof(u32), GFP_KERNEL); | ||
350 | ucode = kmalloc(513 * 5, GFP_KERNEL); | ||
351 | if (gpr_a == NULL || gpr_b == NULL || ucode == NULL) { | ||
352 | kfree(ucode); | ||
353 | kfree(gpr_b); | ||
354 | kfree(gpr_a); | ||
355 | return 1; | ||
356 | } | ||
357 | |||
358 | per_ctx_regs = 16; | ||
359 | if (c->uengine_parameters & IXP2000_UENGINE_4_CONTEXTS) | ||
360 | per_ctx_regs = 32; | ||
361 | |||
362 | memset(gpr_a, 0, sizeof(gpr_a)); | ||
363 | memset(gpr_b, 0, sizeof(gpr_b)); | ||
364 | for (i = 0; i < 256; i++) { | ||
365 | struct ixp2000_reg_value *r = c->initial_reg_values + i; | ||
366 | u32 *bank; | ||
367 | int inc; | ||
368 | int j; | ||
369 | |||
370 | if (r->reg == -1) | ||
371 | break; | ||
372 | |||
373 | bank = (r->reg & 0x400) ? gpr_b : gpr_a; | ||
374 | inc = (r->reg & 0x80) ? 128 : per_ctx_regs; | ||
375 | |||
376 | j = r->reg & 0x7f; | ||
377 | while (j < 128) { | ||
378 | bank[j] = r->value; | ||
379 | j += inc; | ||
380 | } | ||
381 | } | ||
382 | |||
383 | generate_ucode(ucode, gpr_a, gpr_b); | ||
384 | ixp2000_uengine_load_microcode(uengine, ucode, 513); | ||
385 | ixp2000_uengine_init_context(uengine, 0, 0); | ||
386 | ixp2000_uengine_start_contexts(uengine, 0x01); | ||
387 | for (i = 0; i < 100; i++) { | ||
388 | u32 status; | ||
389 | |||
390 | status = ixp2000_uengine_csr_read(uengine, ACTIVE_CTX_STS); | ||
391 | if (!(status & 0x80000000)) | ||
392 | break; | ||
393 | } | ||
394 | ixp2000_uengine_stop_contexts(uengine, 0x01); | ||
395 | |||
396 | kfree(ucode); | ||
397 | kfree(gpr_b); | ||
398 | kfree(gpr_a); | ||
399 | |||
400 | return !!(i == 100); | ||
401 | } | ||
402 | |||
403 | int ixp2000_uengine_load(int uengine, struct ixp2000_uengine_code *c) | ||
404 | { | ||
405 | int ctx; | ||
406 | |||
407 | if (!check_ixp_type(c)) | ||
408 | return 1; | ||
409 | |||
410 | if (!(ixp2000_uengine_mask & (1 << uengine))) | ||
411 | return 1; | ||
412 | |||
413 | ixp2000_uengine_reset(1 << uengine); | ||
414 | ixp2000_uengine_set_mode(uengine, c->uengine_parameters); | ||
415 | if (set_initial_registers(uengine, c)) | ||
416 | return 1; | ||
417 | ixp2000_uengine_load_microcode(uengine, c->insns, c->num_insns); | ||
418 | |||
419 | for (ctx = 0; ctx < 8; ctx++) | ||
420 | ixp2000_uengine_init_context(uengine, ctx, 0); | ||
421 | |||
422 | return 0; | ||
423 | } | ||
424 | EXPORT_SYMBOL(ixp2000_uengine_load); | ||
425 | |||
426 | |||
427 | static int __init ixp2000_uengine_init(void) | ||
428 | { | ||
429 | int uengine; | ||
430 | u32 value; | ||
431 | |||
432 | /* | ||
433 | * Determine number of microengines present. | ||
434 | */ | ||
435 | switch ((ixp2000_reg_read(IXP2000_PRODUCT_ID) >> 8) & 0x1fff) { | ||
436 | case 0: /* IXP2800 */ | ||
437 | case 1: /* IXP2850 */ | ||
438 | ixp2000_uengine_mask = 0x00ff00ff; | ||
439 | break; | ||
440 | |||
441 | case 2: /* IXP2400 */ | ||
442 | ixp2000_uengine_mask = 0x000f000f; | ||
443 | break; | ||
444 | |||
445 | default: | ||
446 | printk(KERN_INFO "Detected unknown IXP2000 model (%.8x)\n", | ||
447 | (unsigned int)ixp2000_reg_read(IXP2000_PRODUCT_ID)); | ||
448 | ixp2000_uengine_mask = 0x00000000; | ||
449 | break; | ||
450 | } | ||
451 | |||
452 | /* | ||
453 | * Reset microengines. | ||
454 | */ | ||
455 | ixp2000_reg_write(IXP2000_RESET1, ixp2000_uengine_mask); | ||
456 | ixp2000_reg_write(IXP2000_RESET1, 0); | ||
457 | |||
458 | /* | ||
459 | * Synchronise timestamp counters across all microengines. | ||
460 | */ | ||
461 | value = ixp2000_reg_read(IXP2000_MISC_CONTROL); | ||
462 | ixp2000_reg_write(IXP2000_MISC_CONTROL, value & ~0x80); | ||
463 | for (uengine = 0; uengine < 32; uengine++) { | ||
464 | if (ixp2000_uengine_mask & (1 << uengine)) { | ||
465 | ixp2000_uengine_csr_write(uengine, TIMESTAMP_LOW, 0); | ||
466 | ixp2000_uengine_csr_write(uengine, TIMESTAMP_HIGH, 0); | ||
467 | } | ||
468 | } | ||
469 | ixp2000_reg_write(IXP2000_MISC_CONTROL, value | 0x80); | ||
470 | |||
471 | return 0; | ||
472 | } | ||
473 | |||
474 | subsys_initcall(ixp2000_uengine_init); | ||
diff --git a/arch/arm/mach-pxa/lubbock.c b/arch/arm/mach-pxa/lubbock.c index 1f6857d7747d..9c6e77faec5b 100644 --- a/arch/arm/mach-pxa/lubbock.c +++ b/arch/arm/mach-pxa/lubbock.c | |||
@@ -175,7 +175,7 @@ static struct platform_device sa1111_device = { | |||
175 | static struct resource smc91x_resources[] = { | 175 | static struct resource smc91x_resources[] = { |
176 | [0] = { | 176 | [0] = { |
177 | .name = "smc91x-regs", | 177 | .name = "smc91x-regs", |
178 | .start = 0x0c000000, | 178 | .start = 0x0c000c00, |
179 | .end = 0x0c0fffff, | 179 | .end = 0x0c0fffff, |
180 | .flags = IORESOURCE_MEM, | 180 | .flags = IORESOURCE_MEM, |
181 | }, | 181 | }, |
@@ -224,18 +224,75 @@ static struct pxafb_mach_info sharp_lm8v31 __initdata = { | |||
224 | .lccr3 = LCCR3_PCP | LCCR3_Acb(255), | 224 | .lccr3 = LCCR3_PCP | LCCR3_Acb(255), |
225 | }; | 225 | }; |
226 | 226 | ||
227 | static int lubbock_mci_init(struct device *dev, irqreturn_t (*lubbock_detect_int)(int, void *, struct pt_regs *), void *data) | 227 | #define MMC_POLL_RATE msecs_to_jiffies(1000) |
228 | |||
229 | static void lubbock_mmc_poll(unsigned long); | ||
230 | static irqreturn_t (*mmc_detect_int)(int, void *, struct pt_regs *); | ||
231 | |||
232 | static struct timer_list mmc_timer = { | ||
233 | .function = lubbock_mmc_poll, | ||
234 | }; | ||
235 | |||
236 | static void lubbock_mmc_poll(unsigned long data) | ||
237 | { | ||
238 | unsigned long flags; | ||
239 | |||
240 | /* clear any previous irq state, then ... */ | ||
241 | local_irq_save(flags); | ||
242 | LUB_IRQ_SET_CLR &= ~(1 << 0); | ||
243 | local_irq_restore(flags); | ||
244 | |||
245 | /* poll until mmc/sd card is removed */ | ||
246 | if (LUB_IRQ_SET_CLR & (1 << 0)) | ||
247 | mod_timer(&mmc_timer, jiffies + MMC_POLL_RATE); | ||
248 | else { | ||
249 | (void) mmc_detect_int(LUBBOCK_SD_IRQ, (void *)data, NULL); | ||
250 | enable_irq(LUBBOCK_SD_IRQ); | ||
251 | } | ||
252 | } | ||
253 | |||
254 | static irqreturn_t lubbock_detect_int(int irq, void *data, struct pt_regs *regs) | ||
255 | { | ||
256 | /* IRQ is level triggered; disable, and poll for removal */ | ||
257 | disable_irq(irq); | ||
258 | mod_timer(&mmc_timer, jiffies + MMC_POLL_RATE); | ||
259 | |||
260 | return mmc_detect_int(irq, data, regs); | ||
261 | } | ||
262 | |||
263 | static int lubbock_mci_init(struct device *dev, | ||
264 | irqreturn_t (*detect_int)(int, void *, struct pt_regs *), | ||
265 | void *data) | ||
228 | { | 266 | { |
229 | /* setup GPIO for PXA25x MMC controller */ | 267 | /* setup GPIO for PXA25x MMC controller */ |
230 | pxa_gpio_mode(GPIO6_MMCCLK_MD); | 268 | pxa_gpio_mode(GPIO6_MMCCLK_MD); |
231 | pxa_gpio_mode(GPIO8_MMCCS0_MD); | 269 | pxa_gpio_mode(GPIO8_MMCCS0_MD); |
232 | 270 | ||
233 | return 0; | 271 | /* detect card insert/eject */ |
272 | mmc_detect_int = detect_int; | ||
273 | init_timer(&mmc_timer); | ||
274 | mmc_timer.data = (unsigned long) data; | ||
275 | return request_irq(LUBBOCK_SD_IRQ, lubbock_detect_int, | ||
276 | SA_SAMPLE_RANDOM, "lubbock-sd-detect", data); | ||
277 | } | ||
278 | |||
279 | static int lubbock_mci_get_ro(struct device *dev) | ||
280 | { | ||
281 | return (LUB_MISC_RD & (1 << 2)) != 0; | ||
282 | } | ||
283 | |||
284 | static void lubbock_mci_exit(struct device *dev, void *data) | ||
285 | { | ||
286 | free_irq(LUBBOCK_SD_IRQ, data); | ||
287 | del_timer_sync(&mmc_timer); | ||
234 | } | 288 | } |
235 | 289 | ||
236 | static struct pxamci_platform_data lubbock_mci_platform_data = { | 290 | static struct pxamci_platform_data lubbock_mci_platform_data = { |
237 | .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, | 291 | .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, |
292 | .detect_delay = 1, | ||
238 | .init = lubbock_mci_init, | 293 | .init = lubbock_mci_init, |
294 | .get_ro = lubbock_mci_get_ro, | ||
295 | .exit = lubbock_mci_exit, | ||
239 | }; | 296 | }; |
240 | 297 | ||
241 | static void lubbock_irda_transceiver_mode(struct device *dev, int mode) | 298 | static void lubbock_irda_transceiver_mode(struct device *dev, int mode) |
diff --git a/arch/arm/mach-realview/Kconfig b/arch/arm/mach-realview/Kconfig new file mode 100644 index 000000000000..4b63dc9eabfe --- /dev/null +++ b/arch/arm/mach-realview/Kconfig | |||
@@ -0,0 +1,11 @@ | |||
1 | menu "RealView platform type" | ||
2 | depends on ARCH_REALVIEW | ||
3 | |||
4 | config MACH_REALVIEW_EB | ||
5 | bool "Support RealView/EB platform" | ||
6 | default n | ||
7 | select ARM_GIC | ||
8 | help | ||
9 | Include support for the ARM(R) RealView Emulation Baseboard platform. | ||
10 | |||
11 | endmenu | ||
diff --git a/arch/arm/mach-realview/Makefile b/arch/arm/mach-realview/Makefile new file mode 100644 index 000000000000..8d37ea1605fd --- /dev/null +++ b/arch/arm/mach-realview/Makefile | |||
@@ -0,0 +1,6 @@ | |||
1 | # | ||
2 | # Makefile for the linux kernel. | ||
3 | # | ||
4 | |||
5 | obj-y := core.o clock.o | ||
6 | obj-$(CONFIG_MACH_REALVIEW_EB) += realview_eb.o | ||
diff --git a/arch/arm/mach-realview/Makefile.boot b/arch/arm/mach-realview/Makefile.boot new file mode 100644 index 000000000000..c7e75acfe6c9 --- /dev/null +++ b/arch/arm/mach-realview/Makefile.boot | |||
@@ -0,0 +1,4 @@ | |||
1 | zreladdr-y := 0x00008000 | ||
2 | params_phys-y := 0x00000100 | ||
3 | initrd_phys-y := 0x00800000 | ||
4 | |||
diff --git a/arch/arm/mach-realview/clock.c b/arch/arm/mach-realview/clock.c new file mode 100644 index 000000000000..002635c97bb6 --- /dev/null +++ b/arch/arm/mach-realview/clock.c | |||
@@ -0,0 +1,145 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/mach-realview/clock.c | ||
3 | * | ||
4 | * Copyright (C) 2004 ARM Limited. | ||
5 | * Written by Deep Blue Solutions Limited. | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License version 2 as | ||
9 | * published by the Free Software Foundation. | ||
10 | */ | ||
11 | #include <linux/module.h> | ||
12 | #include <linux/kernel.h> | ||
13 | #include <linux/list.h> | ||
14 | #include <linux/errno.h> | ||
15 | #include <linux/err.h> | ||
16 | |||
17 | #include <asm/semaphore.h> | ||
18 | #include <asm/hardware/clock.h> | ||
19 | #include <asm/hardware/icst307.h> | ||
20 | |||
21 | #include "clock.h" | ||
22 | |||
23 | static LIST_HEAD(clocks); | ||
24 | static DECLARE_MUTEX(clocks_sem); | ||
25 | |||
26 | struct clk *clk_get(struct device *dev, const char *id) | ||
27 | { | ||
28 | struct clk *p, *clk = ERR_PTR(-ENOENT); | ||
29 | |||
30 | down(&clocks_sem); | ||
31 | list_for_each_entry(p, &clocks, node) { | ||
32 | if (strcmp(id, p->name) == 0 && try_module_get(p->owner)) { | ||
33 | clk = p; | ||
34 | break; | ||
35 | } | ||
36 | } | ||
37 | up(&clocks_sem); | ||
38 | |||
39 | return clk; | ||
40 | } | ||
41 | EXPORT_SYMBOL(clk_get); | ||
42 | |||
43 | void clk_put(struct clk *clk) | ||
44 | { | ||
45 | module_put(clk->owner); | ||
46 | } | ||
47 | EXPORT_SYMBOL(clk_put); | ||
48 | |||
49 | int clk_enable(struct clk *clk) | ||
50 | { | ||
51 | return 0; | ||
52 | } | ||
53 | EXPORT_SYMBOL(clk_enable); | ||
54 | |||
55 | void clk_disable(struct clk *clk) | ||
56 | { | ||
57 | } | ||
58 | EXPORT_SYMBOL(clk_disable); | ||
59 | |||
60 | int clk_use(struct clk *clk) | ||
61 | { | ||
62 | return 0; | ||
63 | } | ||
64 | EXPORT_SYMBOL(clk_use); | ||
65 | |||
66 | void clk_unuse(struct clk *clk) | ||
67 | { | ||
68 | } | ||
69 | EXPORT_SYMBOL(clk_unuse); | ||
70 | |||
71 | unsigned long clk_get_rate(struct clk *clk) | ||
72 | { | ||
73 | return clk->rate; | ||
74 | } | ||
75 | EXPORT_SYMBOL(clk_get_rate); | ||
76 | |||
77 | long clk_round_rate(struct clk *clk, unsigned long rate) | ||
78 | { | ||
79 | return rate; | ||
80 | } | ||
81 | EXPORT_SYMBOL(clk_round_rate); | ||
82 | |||
83 | int clk_set_rate(struct clk *clk, unsigned long rate) | ||
84 | { | ||
85 | int ret = -EIO; | ||
86 | |||
87 | if (clk->setvco) { | ||
88 | struct icst307_vco vco; | ||
89 | |||
90 | vco = icst307_khz_to_vco(clk->params, rate / 1000); | ||
91 | clk->rate = icst307_khz(clk->params, vco) * 1000; | ||
92 | |||
93 | printk("Clock %s: setting VCO reg params: S=%d R=%d V=%d\n", | ||
94 | clk->name, vco.s, vco.r, vco.v); | ||
95 | |||
96 | clk->setvco(clk, vco); | ||
97 | ret = 0; | ||
98 | } | ||
99 | return ret; | ||
100 | } | ||
101 | EXPORT_SYMBOL(clk_set_rate); | ||
102 | |||
103 | /* | ||
104 | * These are fixed clocks. | ||
105 | */ | ||
106 | static struct clk kmi_clk = { | ||
107 | .name = "KMIREFCLK", | ||
108 | .rate = 24000000, | ||
109 | }; | ||
110 | |||
111 | static struct clk uart_clk = { | ||
112 | .name = "UARTCLK", | ||
113 | .rate = 24000000, | ||
114 | }; | ||
115 | |||
116 | static struct clk mmci_clk = { | ||
117 | .name = "MCLK", | ||
118 | .rate = 33000000, | ||
119 | }; | ||
120 | |||
121 | int clk_register(struct clk *clk) | ||
122 | { | ||
123 | down(&clocks_sem); | ||
124 | list_add(&clk->node, &clocks); | ||
125 | up(&clocks_sem); | ||
126 | return 0; | ||
127 | } | ||
128 | EXPORT_SYMBOL(clk_register); | ||
129 | |||
130 | void clk_unregister(struct clk *clk) | ||
131 | { | ||
132 | down(&clocks_sem); | ||
133 | list_del(&clk->node); | ||
134 | up(&clocks_sem); | ||
135 | } | ||
136 | EXPORT_SYMBOL(clk_unregister); | ||
137 | |||
138 | static int __init clk_init(void) | ||
139 | { | ||
140 | clk_register(&kmi_clk); | ||
141 | clk_register(&uart_clk); | ||
142 | clk_register(&mmci_clk); | ||
143 | return 0; | ||
144 | } | ||
145 | arch_initcall(clk_init); | ||
diff --git a/arch/arm/mach-realview/clock.h b/arch/arm/mach-realview/clock.h new file mode 100644 index 000000000000..dadba695e181 --- /dev/null +++ b/arch/arm/mach-realview/clock.h | |||
@@ -0,0 +1,25 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/mach-realview/clock.h | ||
3 | * | ||
4 | * Copyright (C) 2004 ARM Limited. | ||
5 | * Written by Deep Blue Solutions Limited. | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License version 2 as | ||
9 | * published by the Free Software Foundation. | ||
10 | */ | ||
11 | struct module; | ||
12 | struct icst307_params; | ||
13 | |||
14 | struct clk { | ||
15 | struct list_head node; | ||
16 | unsigned long rate; | ||
17 | struct module *owner; | ||
18 | const char *name; | ||
19 | const struct icst307_params *params; | ||
20 | void *data; | ||
21 | void (*setvco)(struct clk *, struct icst307_vco vco); | ||
22 | }; | ||
23 | |||
24 | int clk_register(struct clk *clk); | ||
25 | void clk_unregister(struct clk *clk); | ||
diff --git a/arch/arm/mach-realview/core.c b/arch/arm/mach-realview/core.c new file mode 100644 index 000000000000..482eb512ebe8 --- /dev/null +++ b/arch/arm/mach-realview/core.c | |||
@@ -0,0 +1,605 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/mach-realview/core.c | ||
3 | * | ||
4 | * Copyright (C) 1999 - 2003 ARM Limited | ||
5 | * Copyright (C) 2000 Deep Blue Solutions Ltd | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to the Free Software | ||
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
20 | */ | ||
21 | #include <linux/config.h> | ||
22 | #include <linux/init.h> | ||
23 | #include <linux/platform_device.h> | ||
24 | #include <linux/dma-mapping.h> | ||
25 | #include <linux/sysdev.h> | ||
26 | #include <linux/interrupt.h> | ||
27 | |||
28 | #include <asm/system.h> | ||
29 | #include <asm/hardware.h> | ||
30 | #include <asm/io.h> | ||
31 | #include <asm/irq.h> | ||
32 | #include <asm/leds.h> | ||
33 | #include <asm/mach-types.h> | ||
34 | #include <asm/hardware/amba.h> | ||
35 | #include <asm/hardware/amba_clcd.h> | ||
36 | #include <asm/hardware/arm_timer.h> | ||
37 | #include <asm/hardware/icst307.h> | ||
38 | |||
39 | #include <asm/mach/arch.h> | ||
40 | #include <asm/mach/flash.h> | ||
41 | #include <asm/mach/irq.h> | ||
42 | #include <asm/mach/time.h> | ||
43 | #include <asm/mach/map.h> | ||
44 | #include <asm/mach/mmc.h> | ||
45 | |||
46 | #include <asm/hardware/gic.h> | ||
47 | |||
48 | #include "core.h" | ||
49 | #include "clock.h" | ||
50 | |||
51 | #define REALVIEW_REFCOUNTER (__io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_24MHz_OFFSET) | ||
52 | |||
53 | /* | ||
54 | * This is the RealView sched_clock implementation. This has | ||
55 | * a resolution of 41.7ns, and a maximum value of about 179s. | ||
56 | */ | ||
57 | unsigned long long sched_clock(void) | ||
58 | { | ||
59 | unsigned long long v; | ||
60 | |||
61 | v = (unsigned long long)readl(REALVIEW_REFCOUNTER) * 125; | ||
62 | do_div(v, 3); | ||
63 | |||
64 | return v; | ||
65 | } | ||
66 | |||
67 | |||
68 | #define REALVIEW_FLASHCTRL (__io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_FLASH_OFFSET) | ||
69 | |||
70 | static int realview_flash_init(void) | ||
71 | { | ||
72 | u32 val; | ||
73 | |||
74 | val = __raw_readl(REALVIEW_FLASHCTRL); | ||
75 | val &= ~REALVIEW_FLASHPROG_FLVPPEN; | ||
76 | __raw_writel(val, REALVIEW_FLASHCTRL); | ||
77 | |||
78 | return 0; | ||
79 | } | ||
80 | |||
81 | static void realview_flash_exit(void) | ||
82 | { | ||
83 | u32 val; | ||
84 | |||
85 | val = __raw_readl(REALVIEW_FLASHCTRL); | ||
86 | val &= ~REALVIEW_FLASHPROG_FLVPPEN; | ||
87 | __raw_writel(val, REALVIEW_FLASHCTRL); | ||
88 | } | ||
89 | |||
90 | static void realview_flash_set_vpp(int on) | ||
91 | { | ||
92 | u32 val; | ||
93 | |||
94 | val = __raw_readl(REALVIEW_FLASHCTRL); | ||
95 | if (on) | ||
96 | val |= REALVIEW_FLASHPROG_FLVPPEN; | ||
97 | else | ||
98 | val &= ~REALVIEW_FLASHPROG_FLVPPEN; | ||
99 | __raw_writel(val, REALVIEW_FLASHCTRL); | ||
100 | } | ||
101 | |||
102 | static struct flash_platform_data realview_flash_data = { | ||
103 | .map_name = "cfi_probe", | ||
104 | .width = 4, | ||
105 | .init = realview_flash_init, | ||
106 | .exit = realview_flash_exit, | ||
107 | .set_vpp = realview_flash_set_vpp, | ||
108 | }; | ||
109 | |||
110 | static struct resource realview_flash_resource = { | ||
111 | .start = REALVIEW_FLASH_BASE, | ||
112 | .end = REALVIEW_FLASH_BASE + REALVIEW_FLASH_SIZE, | ||
113 | .flags = IORESOURCE_MEM, | ||
114 | }; | ||
115 | |||
116 | struct platform_device realview_flash_device = { | ||
117 | .name = "armflash", | ||
118 | .id = 0, | ||
119 | .dev = { | ||
120 | .platform_data = &realview_flash_data, | ||
121 | }, | ||
122 | .num_resources = 1, | ||
123 | .resource = &realview_flash_resource, | ||
124 | }; | ||
125 | |||
126 | static struct resource realview_smc91x_resources[] = { | ||
127 | [0] = { | ||
128 | .start = REALVIEW_ETH_BASE, | ||
129 | .end = REALVIEW_ETH_BASE + SZ_64K - 1, | ||
130 | .flags = IORESOURCE_MEM, | ||
131 | }, | ||
132 | [1] = { | ||
133 | .start = IRQ_ETH, | ||
134 | .end = IRQ_ETH, | ||
135 | .flags = IORESOURCE_IRQ, | ||
136 | }, | ||
137 | }; | ||
138 | |||
139 | struct platform_device realview_smc91x_device = { | ||
140 | .name = "smc91x", | ||
141 | .id = 0, | ||
142 | .num_resources = ARRAY_SIZE(realview_smc91x_resources), | ||
143 | .resource = realview_smc91x_resources, | ||
144 | }; | ||
145 | |||
146 | #define REALVIEW_SYSMCI (__io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_MCI_OFFSET) | ||
147 | |||
148 | static unsigned int realview_mmc_status(struct device *dev) | ||
149 | { | ||
150 | struct amba_device *adev = container_of(dev, struct amba_device, dev); | ||
151 | u32 mask; | ||
152 | |||
153 | if (adev->res.start == REALVIEW_MMCI0_BASE) | ||
154 | mask = 1; | ||
155 | else | ||
156 | mask = 2; | ||
157 | |||
158 | return readl(REALVIEW_SYSMCI) & mask; | ||
159 | } | ||
160 | |||
161 | struct mmc_platform_data realview_mmc0_plat_data = { | ||
162 | .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, | ||
163 | .status = realview_mmc_status, | ||
164 | }; | ||
165 | |||
166 | struct mmc_platform_data realview_mmc1_plat_data = { | ||
167 | .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34, | ||
168 | .status = realview_mmc_status, | ||
169 | }; | ||
170 | |||
171 | /* | ||
172 | * Clock handling | ||
173 | */ | ||
174 | static const struct icst307_params realview_oscvco_params = { | ||
175 | .ref = 24000, | ||
176 | .vco_max = 200000, | ||
177 | .vd_min = 4 + 8, | ||
178 | .vd_max = 511 + 8, | ||
179 | .rd_min = 1 + 2, | ||
180 | .rd_max = 127 + 2, | ||
181 | }; | ||
182 | |||
183 | static void realview_oscvco_set(struct clk *clk, struct icst307_vco vco) | ||
184 | { | ||
185 | void __iomem *sys_lock = __io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_LOCK_OFFSET; | ||
186 | void __iomem *sys_osc = __io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_OSC1_OFFSET; | ||
187 | u32 val; | ||
188 | |||
189 | val = readl(sys_osc) & ~0x7ffff; | ||
190 | val |= vco.v | (vco.r << 9) | (vco.s << 16); | ||
191 | |||
192 | writel(0xa05f, sys_lock); | ||
193 | writel(val, sys_osc); | ||
194 | writel(0, sys_lock); | ||
195 | } | ||
196 | |||
197 | struct clk realview_clcd_clk = { | ||
198 | .name = "CLCDCLK", | ||
199 | .params = &realview_oscvco_params, | ||
200 | .setvco = realview_oscvco_set, | ||
201 | }; | ||
202 | |||
203 | /* | ||
204 | * CLCD support. | ||
205 | */ | ||
206 | #define SYS_CLCD_MODE_MASK (3 << 0) | ||
207 | #define SYS_CLCD_MODE_888 (0 << 0) | ||
208 | #define SYS_CLCD_MODE_5551 (1 << 0) | ||
209 | #define SYS_CLCD_MODE_565_RLSB (2 << 0) | ||
210 | #define SYS_CLCD_MODE_565_BLSB (3 << 0) | ||
211 | #define SYS_CLCD_NLCDIOON (1 << 2) | ||
212 | #define SYS_CLCD_VDDPOSSWITCH (1 << 3) | ||
213 | #define SYS_CLCD_PWR3V5SWITCH (1 << 4) | ||
214 | #define SYS_CLCD_ID_MASK (0x1f << 8) | ||
215 | #define SYS_CLCD_ID_SANYO_3_8 (0x00 << 8) | ||
216 | #define SYS_CLCD_ID_UNKNOWN_8_4 (0x01 << 8) | ||
217 | #define SYS_CLCD_ID_EPSON_2_2 (0x02 << 8) | ||
218 | #define SYS_CLCD_ID_SANYO_2_5 (0x07 << 8) | ||
219 | #define SYS_CLCD_ID_VGA (0x1f << 8) | ||
220 | |||
221 | static struct clcd_panel vga = { | ||
222 | .mode = { | ||
223 | .name = "VGA", | ||
224 | .refresh = 60, | ||
225 | .xres = 640, | ||
226 | .yres = 480, | ||
227 | .pixclock = 39721, | ||
228 | .left_margin = 40, | ||
229 | .right_margin = 24, | ||
230 | .upper_margin = 32, | ||
231 | .lower_margin = 11, | ||
232 | .hsync_len = 96, | ||
233 | .vsync_len = 2, | ||
234 | .sync = 0, | ||
235 | .vmode = FB_VMODE_NONINTERLACED, | ||
236 | }, | ||
237 | .width = -1, | ||
238 | .height = -1, | ||
239 | .tim2 = TIM2_BCD | TIM2_IPC, | ||
240 | .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1), | ||
241 | .bpp = 16, | ||
242 | }; | ||
243 | |||
244 | static struct clcd_panel sanyo_3_8_in = { | ||
245 | .mode = { | ||
246 | .name = "Sanyo QVGA", | ||
247 | .refresh = 116, | ||
248 | .xres = 320, | ||
249 | .yres = 240, | ||
250 | .pixclock = 100000, | ||
251 | .left_margin = 6, | ||
252 | .right_margin = 6, | ||
253 | .upper_margin = 5, | ||
254 | .lower_margin = 5, | ||
255 | .hsync_len = 6, | ||
256 | .vsync_len = 6, | ||
257 | .sync = 0, | ||
258 | .vmode = FB_VMODE_NONINTERLACED, | ||
259 | }, | ||
260 | .width = -1, | ||
261 | .height = -1, | ||
262 | .tim2 = TIM2_BCD, | ||
263 | .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1), | ||
264 | .bpp = 16, | ||
265 | }; | ||
266 | |||
267 | static struct clcd_panel sanyo_2_5_in = { | ||
268 | .mode = { | ||
269 | .name = "Sanyo QVGA Portrait", | ||
270 | .refresh = 116, | ||
271 | .xres = 240, | ||
272 | .yres = 320, | ||
273 | .pixclock = 100000, | ||
274 | .left_margin = 20, | ||
275 | .right_margin = 10, | ||
276 | .upper_margin = 2, | ||
277 | .lower_margin = 2, | ||
278 | .hsync_len = 10, | ||
279 | .vsync_len = 2, | ||
280 | .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, | ||
281 | .vmode = FB_VMODE_NONINTERLACED, | ||
282 | }, | ||
283 | .width = -1, | ||
284 | .height = -1, | ||
285 | .tim2 = TIM2_IVS | TIM2_IHS | TIM2_IPC, | ||
286 | .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1), | ||
287 | .bpp = 16, | ||
288 | }; | ||
289 | |||
290 | static struct clcd_panel epson_2_2_in = { | ||
291 | .mode = { | ||
292 | .name = "Epson QCIF", | ||
293 | .refresh = 390, | ||
294 | .xres = 176, | ||
295 | .yres = 220, | ||
296 | .pixclock = 62500, | ||
297 | .left_margin = 3, | ||
298 | .right_margin = 2, | ||
299 | .upper_margin = 1, | ||
300 | .lower_margin = 0, | ||
301 | .hsync_len = 3, | ||
302 | .vsync_len = 2, | ||
303 | .sync = 0, | ||
304 | .vmode = FB_VMODE_NONINTERLACED, | ||
305 | }, | ||
306 | .width = -1, | ||
307 | .height = -1, | ||
308 | .tim2 = TIM2_BCD | TIM2_IPC, | ||
309 | .cntl = CNTL_LCDTFT | CNTL_LCDVCOMP(1), | ||
310 | .bpp = 16, | ||
311 | }; | ||
312 | |||
313 | /* | ||
314 | * Detect which LCD panel is connected, and return the appropriate | ||
315 | * clcd_panel structure. Note: we do not have any information on | ||
316 | * the required timings for the 8.4in panel, so we presently assume | ||
317 | * VGA timings. | ||
318 | */ | ||
319 | static struct clcd_panel *realview_clcd_panel(void) | ||
320 | { | ||
321 | void __iomem *sys_clcd = __io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_CLCD_OFFSET; | ||
322 | struct clcd_panel *panel = &vga; | ||
323 | u32 val; | ||
324 | |||
325 | val = readl(sys_clcd) & SYS_CLCD_ID_MASK; | ||
326 | if (val == SYS_CLCD_ID_SANYO_3_8) | ||
327 | panel = &sanyo_3_8_in; | ||
328 | else if (val == SYS_CLCD_ID_SANYO_2_5) | ||
329 | panel = &sanyo_2_5_in; | ||
330 | else if (val == SYS_CLCD_ID_EPSON_2_2) | ||
331 | panel = &epson_2_2_in; | ||
332 | else if (val == SYS_CLCD_ID_VGA) | ||
333 | panel = &vga; | ||
334 | else { | ||
335 | printk(KERN_ERR "CLCD: unknown LCD panel ID 0x%08x, using VGA\n", | ||
336 | val); | ||
337 | panel = &vga; | ||
338 | } | ||
339 | |||
340 | return panel; | ||
341 | } | ||
342 | |||
343 | /* | ||
344 | * Disable all display connectors on the interface module. | ||
345 | */ | ||
346 | static void realview_clcd_disable(struct clcd_fb *fb) | ||
347 | { | ||
348 | void __iomem *sys_clcd = __io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_CLCD_OFFSET; | ||
349 | u32 val; | ||
350 | |||
351 | val = readl(sys_clcd); | ||
352 | val &= ~SYS_CLCD_NLCDIOON | SYS_CLCD_PWR3V5SWITCH; | ||
353 | writel(val, sys_clcd); | ||
354 | } | ||
355 | |||
356 | /* | ||
357 | * Enable the relevant connector on the interface module. | ||
358 | */ | ||
359 | static void realview_clcd_enable(struct clcd_fb *fb) | ||
360 | { | ||
361 | void __iomem *sys_clcd = __io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_CLCD_OFFSET; | ||
362 | u32 val; | ||
363 | |||
364 | val = readl(sys_clcd); | ||
365 | val &= ~SYS_CLCD_MODE_MASK; | ||
366 | |||
367 | switch (fb->fb.var.green.length) { | ||
368 | case 5: | ||
369 | val |= SYS_CLCD_MODE_5551; | ||
370 | break; | ||
371 | case 6: | ||
372 | val |= SYS_CLCD_MODE_565_RLSB; | ||
373 | break; | ||
374 | case 8: | ||
375 | val |= SYS_CLCD_MODE_888; | ||
376 | break; | ||
377 | } | ||
378 | |||
379 | /* | ||
380 | * Set the MUX | ||
381 | */ | ||
382 | writel(val, sys_clcd); | ||
383 | |||
384 | /* | ||
385 | * And now enable the PSUs | ||
386 | */ | ||
387 | val |= SYS_CLCD_NLCDIOON | SYS_CLCD_PWR3V5SWITCH; | ||
388 | writel(val, sys_clcd); | ||
389 | } | ||
390 | |||
391 | static unsigned long framesize = SZ_1M; | ||
392 | |||
393 | static int realview_clcd_setup(struct clcd_fb *fb) | ||
394 | { | ||
395 | dma_addr_t dma; | ||
396 | |||
397 | fb->panel = realview_clcd_panel(); | ||
398 | |||
399 | fb->fb.screen_base = dma_alloc_writecombine(&fb->dev->dev, framesize, | ||
400 | &dma, GFP_KERNEL); | ||
401 | if (!fb->fb.screen_base) { | ||
402 | printk(KERN_ERR "CLCD: unable to map framebuffer\n"); | ||
403 | return -ENOMEM; | ||
404 | } | ||
405 | |||
406 | fb->fb.fix.smem_start = dma; | ||
407 | fb->fb.fix.smem_len = framesize; | ||
408 | |||
409 | return 0; | ||
410 | } | ||
411 | |||
412 | static int realview_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma) | ||
413 | { | ||
414 | return dma_mmap_writecombine(&fb->dev->dev, vma, | ||
415 | fb->fb.screen_base, | ||
416 | fb->fb.fix.smem_start, | ||
417 | fb->fb.fix.smem_len); | ||
418 | } | ||
419 | |||
420 | static void realview_clcd_remove(struct clcd_fb *fb) | ||
421 | { | ||
422 | dma_free_writecombine(&fb->dev->dev, fb->fb.fix.smem_len, | ||
423 | fb->fb.screen_base, fb->fb.fix.smem_start); | ||
424 | } | ||
425 | |||
426 | struct clcd_board clcd_plat_data = { | ||
427 | .name = "RealView", | ||
428 | .check = clcdfb_check, | ||
429 | .decode = clcdfb_decode, | ||
430 | .disable = realview_clcd_disable, | ||
431 | .enable = realview_clcd_enable, | ||
432 | .setup = realview_clcd_setup, | ||
433 | .mmap = realview_clcd_mmap, | ||
434 | .remove = realview_clcd_remove, | ||
435 | }; | ||
436 | |||
437 | #ifdef CONFIG_LEDS | ||
438 | #define VA_LEDS_BASE (__io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_LED_OFFSET) | ||
439 | |||
440 | void realview_leds_event(led_event_t ledevt) | ||
441 | { | ||
442 | unsigned long flags; | ||
443 | u32 val; | ||
444 | |||
445 | local_irq_save(flags); | ||
446 | val = readl(VA_LEDS_BASE); | ||
447 | |||
448 | switch (ledevt) { | ||
449 | case led_idle_start: | ||
450 | val = val & ~REALVIEW_SYS_LED0; | ||
451 | break; | ||
452 | |||
453 | case led_idle_end: | ||
454 | val = val | REALVIEW_SYS_LED0; | ||
455 | break; | ||
456 | |||
457 | case led_timer: | ||
458 | val = val ^ REALVIEW_SYS_LED1; | ||
459 | break; | ||
460 | |||
461 | case led_halted: | ||
462 | val = 0; | ||
463 | break; | ||
464 | |||
465 | default: | ||
466 | break; | ||
467 | } | ||
468 | |||
469 | writel(val, VA_LEDS_BASE); | ||
470 | local_irq_restore(flags); | ||
471 | } | ||
472 | #endif /* CONFIG_LEDS */ | ||
473 | |||
474 | /* | ||
475 | * Where is the timer (VA)? | ||
476 | */ | ||
477 | #define TIMER0_VA_BASE __io_address(REALVIEW_TIMER0_1_BASE) | ||
478 | #define TIMER1_VA_BASE (__io_address(REALVIEW_TIMER0_1_BASE) + 0x20) | ||
479 | #define TIMER2_VA_BASE __io_address(REALVIEW_TIMER2_3_BASE) | ||
480 | #define TIMER3_VA_BASE (__io_address(REALVIEW_TIMER2_3_BASE) + 0x20) | ||
481 | |||
482 | /* | ||
483 | * How long is the timer interval? | ||
484 | */ | ||
485 | #define TIMER_INTERVAL (TICKS_PER_uSEC * mSEC_10) | ||
486 | #if TIMER_INTERVAL >= 0x100000 | ||
487 | #define TIMER_RELOAD (TIMER_INTERVAL >> 8) | ||
488 | #define TIMER_DIVISOR (TIMER_CTRL_DIV256) | ||
489 | #define TICKS2USECS(x) (256 * (x) / TICKS_PER_uSEC) | ||
490 | #elif TIMER_INTERVAL >= 0x10000 | ||
491 | #define TIMER_RELOAD (TIMER_INTERVAL >> 4) /* Divide by 16 */ | ||
492 | #define TIMER_DIVISOR (TIMER_CTRL_DIV16) | ||
493 | #define TICKS2USECS(x) (16 * (x) / TICKS_PER_uSEC) | ||
494 | #else | ||
495 | #define TIMER_RELOAD (TIMER_INTERVAL) | ||
496 | #define TIMER_DIVISOR (TIMER_CTRL_DIV1) | ||
497 | #define TICKS2USECS(x) ((x) / TICKS_PER_uSEC) | ||
498 | #endif | ||
499 | |||
500 | /* | ||
501 | * Returns number of ms since last clock interrupt. Note that interrupts | ||
502 | * will have been disabled by do_gettimeoffset() | ||
503 | */ | ||
504 | static unsigned long realview_gettimeoffset(void) | ||
505 | { | ||
506 | unsigned long ticks1, ticks2, status; | ||
507 | |||
508 | /* | ||
509 | * Get the current number of ticks. Note that there is a race | ||
510 | * condition between us reading the timer and checking for | ||
511 | * an interrupt. We get around this by ensuring that the | ||
512 | * counter has not reloaded between our two reads. | ||
513 | */ | ||
514 | ticks2 = readl(TIMER0_VA_BASE + TIMER_VALUE) & 0xffff; | ||
515 | do { | ||
516 | ticks1 = ticks2; | ||
517 | status = __raw_readl(__io_address(REALVIEW_GIC_DIST_BASE + GIC_DIST_PENDING_SET) | ||
518 | + ((IRQ_TIMERINT0_1 >> 5) << 2)); | ||
519 | ticks2 = readl(TIMER0_VA_BASE + TIMER_VALUE) & 0xffff; | ||
520 | } while (ticks2 > ticks1); | ||
521 | |||
522 | /* | ||
523 | * Number of ticks since last interrupt. | ||
524 | */ | ||
525 | ticks1 = TIMER_RELOAD - ticks2; | ||
526 | |||
527 | /* | ||
528 | * Interrupt pending? If so, we've reloaded once already. | ||
529 | * | ||
530 | * FIXME: Need to check this is effectively timer 0 that expires | ||
531 | */ | ||
532 | if (status & IRQMASK_TIMERINT0_1) | ||
533 | ticks1 += TIMER_RELOAD; | ||
534 | |||
535 | /* | ||
536 | * Convert the ticks to usecs | ||
537 | */ | ||
538 | return TICKS2USECS(ticks1); | ||
539 | } | ||
540 | |||
541 | /* | ||
542 | * IRQ handler for the timer | ||
543 | */ | ||
544 | static irqreturn_t realview_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs) | ||
545 | { | ||
546 | write_seqlock(&xtime_lock); | ||
547 | |||
548 | // ...clear the interrupt | ||
549 | writel(1, TIMER0_VA_BASE + TIMER_INTCLR); | ||
550 | |||
551 | timer_tick(regs); | ||
552 | |||
553 | write_sequnlock(&xtime_lock); | ||
554 | |||
555 | return IRQ_HANDLED; | ||
556 | } | ||
557 | |||
558 | static struct irqaction realview_timer_irq = { | ||
559 | .name = "RealView Timer Tick", | ||
560 | .flags = SA_INTERRUPT | SA_TIMER, | ||
561 | .handler = realview_timer_interrupt, | ||
562 | }; | ||
563 | |||
564 | /* | ||
565 | * Set up timer interrupt, and return the current time in seconds. | ||
566 | */ | ||
567 | static void __init realview_timer_init(void) | ||
568 | { | ||
569 | u32 val; | ||
570 | |||
571 | /* | ||
572 | * set clock frequency: | ||
573 | * REALVIEW_REFCLK is 32KHz | ||
574 | * REALVIEW_TIMCLK is 1MHz | ||
575 | */ | ||
576 | val = readl(__io_address(REALVIEW_SCTL_BASE)); | ||
577 | writel((REALVIEW_TIMCLK << REALVIEW_TIMER1_EnSel) | | ||
578 | (REALVIEW_TIMCLK << REALVIEW_TIMER2_EnSel) | | ||
579 | (REALVIEW_TIMCLK << REALVIEW_TIMER3_EnSel) | | ||
580 | (REALVIEW_TIMCLK << REALVIEW_TIMER4_EnSel) | val, | ||
581 | __io_address(REALVIEW_SCTL_BASE)); | ||
582 | |||
583 | /* | ||
584 | * Initialise to a known state (all timers off) | ||
585 | */ | ||
586 | writel(0, TIMER0_VA_BASE + TIMER_CTRL); | ||
587 | writel(0, TIMER1_VA_BASE + TIMER_CTRL); | ||
588 | writel(0, TIMER2_VA_BASE + TIMER_CTRL); | ||
589 | writel(0, TIMER3_VA_BASE + TIMER_CTRL); | ||
590 | |||
591 | writel(TIMER_RELOAD, TIMER0_VA_BASE + TIMER_LOAD); | ||
592 | writel(TIMER_RELOAD, TIMER0_VA_BASE + TIMER_VALUE); | ||
593 | writel(TIMER_DIVISOR | TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC | | ||
594 | TIMER_CTRL_IE, TIMER0_VA_BASE + TIMER_CTRL); | ||
595 | |||
596 | /* | ||
597 | * Make irqs happen for the system timer | ||
598 | */ | ||
599 | setup_irq(IRQ_TIMERINT0_1, &realview_timer_irq); | ||
600 | } | ||
601 | |||
602 | struct sys_timer realview_timer = { | ||
603 | .init = realview_timer_init, | ||
604 | .offset = realview_gettimeoffset, | ||
605 | }; | ||
diff --git a/arch/arm/mach-realview/core.h b/arch/arm/mach-realview/core.h new file mode 100644 index 000000000000..575599db74db --- /dev/null +++ b/arch/arm/mach-realview/core.h | |||
@@ -0,0 +1,118 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/mach-realview/core.h | ||
3 | * | ||
4 | * Copyright (C) 2004 ARM Limited | ||
5 | * Copyright (C) 2000 Deep Blue Solutions Ltd | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to the Free Software | ||
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
20 | */ | ||
21 | |||
22 | #ifndef __ASM_ARCH_REALVIEW_H | ||
23 | #define __ASM_ARCH_REALVIEW_H | ||
24 | |||
25 | #include <asm/hardware/amba.h> | ||
26 | #include <asm/io.h> | ||
27 | |||
28 | #define __io_address(n) __io(IO_ADDRESS(n)) | ||
29 | |||
30 | extern struct sys_timer realview_timer; | ||
31 | |||
32 | #define AMBA_DEVICE(name,busid,base,plat) \ | ||
33 | static struct amba_device name##_device = { \ | ||
34 | .dev = { \ | ||
35 | .coherent_dma_mask = ~0, \ | ||
36 | .bus_id = busid, \ | ||
37 | .platform_data = plat, \ | ||
38 | }, \ | ||
39 | .res = { \ | ||
40 | .start = REALVIEW_##base##_BASE, \ | ||
41 | .end = (REALVIEW_##base##_BASE) + SZ_4K - 1,\ | ||
42 | .flags = IORESOURCE_MEM, \ | ||
43 | }, \ | ||
44 | .dma_mask = ~0, \ | ||
45 | .irq = base##_IRQ, \ | ||
46 | /* .dma = base##_DMA,*/ \ | ||
47 | } | ||
48 | |||
49 | /* | ||
50 | * These devices are connected via the core APB bridge | ||
51 | */ | ||
52 | #define GPIO2_IRQ { IRQ_GPIOINT2, NO_IRQ } | ||
53 | #define GPIO2_DMA { 0, 0 } | ||
54 | #define GPIO3_IRQ { IRQ_GPIOINT3, NO_IRQ } | ||
55 | #define GPIO3_DMA { 0, 0 } | ||
56 | |||
57 | #define AACI_IRQ { IRQ_AACI, NO_IRQ } | ||
58 | #define AACI_DMA { 0x80, 0x81 } | ||
59 | #define MMCI0_IRQ { IRQ_MMCI0A,IRQ_MMCI0B } | ||
60 | #define MMCI0_DMA { 0x84, 0 } | ||
61 | #define KMI0_IRQ { IRQ_KMI0, NO_IRQ } | ||
62 | #define KMI0_DMA { 0, 0 } | ||
63 | #define KMI1_IRQ { IRQ_KMI1, NO_IRQ } | ||
64 | #define KMI1_DMA { 0, 0 } | ||
65 | |||
66 | /* | ||
67 | * These devices are connected directly to the multi-layer AHB switch | ||
68 | */ | ||
69 | #define SMC_IRQ { NO_IRQ, NO_IRQ } | ||
70 | #define SMC_DMA { 0, 0 } | ||
71 | #define MPMC_IRQ { NO_IRQ, NO_IRQ } | ||
72 | #define MPMC_DMA { 0, 0 } | ||
73 | #define CLCD_IRQ { IRQ_CLCDINT, NO_IRQ } | ||
74 | #define CLCD_DMA { 0, 0 } | ||
75 | #define DMAC_IRQ { IRQ_DMAINT, NO_IRQ } | ||
76 | #define DMAC_DMA { 0, 0 } | ||
77 | |||
78 | /* | ||
79 | * These devices are connected via the core APB bridge | ||
80 | */ | ||
81 | #define SCTL_IRQ { NO_IRQ, NO_IRQ } | ||
82 | #define SCTL_DMA { 0, 0 } | ||
83 | #define WATCHDOG_IRQ { IRQ_WDOGINT, NO_IRQ } | ||
84 | #define WATCHDOG_DMA { 0, 0 } | ||
85 | #define GPIO0_IRQ { IRQ_GPIOINT0, NO_IRQ } | ||
86 | #define GPIO0_DMA { 0, 0 } | ||
87 | #define GPIO1_IRQ { IRQ_GPIOINT1, NO_IRQ } | ||
88 | #define GPIO1_DMA { 0, 0 } | ||
89 | #define RTC_IRQ { IRQ_RTCINT, NO_IRQ } | ||
90 | #define RTC_DMA { 0, 0 } | ||
91 | |||
92 | /* | ||
93 | * These devices are connected via the DMA APB bridge | ||
94 | */ | ||
95 | #define SCI_IRQ { IRQ_SCIINT, NO_IRQ } | ||
96 | #define SCI_DMA { 7, 6 } | ||
97 | #define UART0_IRQ { IRQ_UARTINT0, NO_IRQ } | ||
98 | #define UART0_DMA { 15, 14 } | ||
99 | #define UART1_IRQ { IRQ_UARTINT1, NO_IRQ } | ||
100 | #define UART1_DMA { 13, 12 } | ||
101 | #define UART2_IRQ { IRQ_UARTINT2, NO_IRQ } | ||
102 | #define UART2_DMA { 11, 10 } | ||
103 | #define UART3_IRQ { IRQ_UART3, NO_IRQ } | ||
104 | #define UART3_DMA { 0x86, 0x87 } | ||
105 | #define SSP_IRQ { IRQ_SSPINT, NO_IRQ } | ||
106 | #define SSP_DMA { 9, 8 } | ||
107 | |||
108 | |||
109 | extern struct platform_device realview_flash_device; | ||
110 | extern struct platform_device realview_smc91x_device; | ||
111 | extern struct mmc_platform_data realview_mmc0_plat_data; | ||
112 | extern struct mmc_platform_data realview_mmc1_plat_data; | ||
113 | extern struct clk realview_clcd_clk; | ||
114 | extern struct clcd_board clcd_plat_data; | ||
115 | |||
116 | extern void realview_leds_event(led_event_t ledevt); | ||
117 | |||
118 | #endif | ||
diff --git a/arch/arm/mach-realview/realview_eb.c b/arch/arm/mach-realview/realview_eb.c new file mode 100644 index 000000000000..01b264be5029 --- /dev/null +++ b/arch/arm/mach-realview/realview_eb.c | |||
@@ -0,0 +1,142 @@ | |||
1 | /* | ||
2 | * linux/arch/arm/mach-realview/realview_eb.c | ||
3 | * | ||
4 | * Copyright (C) 2004 ARM Limited | ||
5 | * Copyright (C) 2000 Deep Blue Solutions Ltd | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License as published by | ||
9 | * the Free Software Foundation; either version 2 of the License, or | ||
10 | * (at your option) any later version. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
15 | * GNU General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License | ||
18 | * along with this program; if not, write to the Free Software | ||
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
20 | */ | ||
21 | |||
22 | #include <linux/config.h> | ||
23 | #include <linux/init.h> | ||
24 | #include <linux/platform_device.h> | ||
25 | #include <linux/sysdev.h> | ||
26 | |||
27 | #include <asm/hardware.h> | ||
28 | #include <asm/io.h> | ||
29 | #include <asm/irq.h> | ||
30 | #include <asm/leds.h> | ||
31 | #include <asm/mach-types.h> | ||
32 | #include <asm/hardware/gic.h> | ||
33 | #include <asm/hardware/amba.h> | ||
34 | #include <asm/hardware/icst307.h> | ||
35 | |||
36 | #include <asm/mach/arch.h> | ||
37 | #include <asm/mach/map.h> | ||
38 | #include <asm/mach/mmc.h> | ||
39 | |||
40 | #include <asm/arch/irqs.h> | ||
41 | |||
42 | #include "core.h" | ||
43 | #include "clock.h" | ||
44 | |||
45 | static struct map_desc realview_eb_io_desc[] __initdata = { | ||
46 | { IO_ADDRESS(REALVIEW_SYS_BASE), REALVIEW_SYS_BASE, SZ_4K, MT_DEVICE }, | ||
47 | { IO_ADDRESS(REALVIEW_GIC_CPU_BASE), REALVIEW_GIC_CPU_BASE, SZ_4K, MT_DEVICE }, | ||
48 | { IO_ADDRESS(REALVIEW_GIC_DIST_BASE), REALVIEW_GIC_DIST_BASE, SZ_4K, MT_DEVICE }, | ||
49 | { IO_ADDRESS(REALVIEW_SCTL_BASE), REALVIEW_SCTL_BASE, SZ_4K, MT_DEVICE }, | ||
50 | { IO_ADDRESS(REALVIEW_TIMER0_1_BASE), REALVIEW_TIMER0_1_BASE, SZ_4K, MT_DEVICE }, | ||
51 | { IO_ADDRESS(REALVIEW_TIMER2_3_BASE), REALVIEW_TIMER2_3_BASE, SZ_4K, MT_DEVICE }, | ||
52 | #ifdef CONFIG_DEBUG_LL | ||
53 | { IO_ADDRESS(REALVIEW_UART0_BASE), REALVIEW_UART0_BASE, SZ_4K, MT_DEVICE }, | ||
54 | #endif | ||
55 | }; | ||
56 | |||
57 | static void __init realview_eb_map_io(void) | ||
58 | { | ||
59 | iotable_init(realview_eb_io_desc, ARRAY_SIZE(realview_eb_io_desc)); | ||
60 | } | ||
61 | |||
62 | /* FPGA Primecells */ | ||
63 | AMBA_DEVICE(aaci, "fpga:04", AACI, NULL); | ||
64 | AMBA_DEVICE(mmc0, "fpga:05", MMCI0, &realview_mmc0_plat_data); | ||
65 | AMBA_DEVICE(kmi0, "fpga:06", KMI0, NULL); | ||
66 | AMBA_DEVICE(kmi1, "fpga:07", KMI1, NULL); | ||
67 | AMBA_DEVICE(uart3, "fpga:09", UART3, NULL); | ||
68 | |||
69 | /* DevChip Primecells */ | ||
70 | AMBA_DEVICE(smc, "dev:00", SMC, NULL); | ||
71 | AMBA_DEVICE(clcd, "dev:20", CLCD, &clcd_plat_data); | ||
72 | AMBA_DEVICE(dmac, "dev:30", DMAC, NULL); | ||
73 | AMBA_DEVICE(sctl, "dev:e0", SCTL, NULL); | ||
74 | AMBA_DEVICE(wdog, "dev:e1", WATCHDOG, NULL); | ||
75 | AMBA_DEVICE(gpio0, "dev:e4", GPIO0, NULL); | ||
76 | AMBA_DEVICE(gpio1, "dev:e5", GPIO1, NULL); | ||
77 | AMBA_DEVICE(gpio2, "dev:e6", GPIO2, NULL); | ||
78 | AMBA_DEVICE(rtc, "dev:e8", RTC, NULL); | ||
79 | AMBA_DEVICE(sci0, "dev:f0", SCI, NULL); | ||
80 | AMBA_DEVICE(uart0, "dev:f1", UART0, NULL); | ||
81 | AMBA_DEVICE(uart1, "dev:f2", UART1, NULL); | ||
82 | AMBA_DEVICE(uart2, "dev:f3", UART2, NULL); | ||
83 | AMBA_DEVICE(ssp0, "dev:f4", SSP, NULL); | ||
84 | |||
85 | static struct amba_device *amba_devs[] __initdata = { | ||
86 | &dmac_device, | ||
87 | &uart0_device, | ||
88 | &uart1_device, | ||
89 | &uart2_device, | ||
90 | &uart3_device, | ||
91 | &smc_device, | ||
92 | &clcd_device, | ||
93 | &sctl_device, | ||
94 | &wdog_device, | ||
95 | &gpio0_device, | ||
96 | &gpio1_device, | ||
97 | &gpio2_device, | ||
98 | &rtc_device, | ||
99 | &sci0_device, | ||
100 | &ssp0_device, | ||
101 | &aaci_device, | ||
102 | &mmc0_device, | ||
103 | &kmi0_device, | ||
104 | &kmi1_device, | ||
105 | }; | ||
106 | |||
107 | static void __init gic_init_irq(void) | ||
108 | { | ||
109 | gic_dist_init(__io_address(REALVIEW_GIC_DIST_BASE)); | ||
110 | gic_cpu_init(__io_address(REALVIEW_GIC_CPU_BASE)); | ||
111 | } | ||
112 | |||
113 | static void __init realview_eb_init(void) | ||
114 | { | ||
115 | int i; | ||
116 | |||
117 | clk_register(&realview_clcd_clk); | ||
118 | |||
119 | platform_device_register(&realview_flash_device); | ||
120 | platform_device_register(&realview_smc91x_device); | ||
121 | |||
122 | for (i = 0; i < ARRAY_SIZE(amba_devs); i++) { | ||
123 | struct amba_device *d = amba_devs[i]; | ||
124 | amba_device_register(d, &iomem_resource); | ||
125 | } | ||
126 | |||
127 | #ifdef CONFIG_LEDS | ||
128 | leds_event = realview_leds_event; | ||
129 | #endif | ||
130 | } | ||
131 | |||
132 | MACHINE_START(REALVIEW_EB, "ARM-RealView EB") | ||
133 | /* Maintainer: ARM Ltd/Deep Blue Solutions Ltd */ | ||
134 | .phys_ram = 0x00000000, | ||
135 | .phys_io = REALVIEW_UART0_BASE, | ||
136 | .io_pg_offst = (IO_ADDRESS(REALVIEW_UART0_BASE) >> 18) & 0xfffc, | ||
137 | .boot_params = 0x00000100, | ||
138 | .map_io = realview_eb_map_io, | ||
139 | .init_irq = gic_init_irq, | ||
140 | .timer = &realview_timer, | ||
141 | .init_machine = realview_eb_init, | ||
142 | MACHINE_END | ||
diff --git a/arch/arm/mach-s3c2410/mach-rx3715.c b/arch/arm/mach-s3c2410/mach-rx3715.c index 8f2a90bf940b..24d69019a843 100644 --- a/arch/arm/mach-s3c2410/mach-rx3715.c +++ b/arch/arm/mach-s3c2410/mach-rx3715.c | |||
@@ -17,6 +17,7 @@ | |||
17 | * 10-Mar-2005 LCVR Changed S3C2410_VA to S3C24XX_VA | 17 | * 10-Mar-2005 LCVR Changed S3C2410_VA to S3C24XX_VA |
18 | * 14-Mar-2005 BJD Fixed __iomem warnings | 18 | * 14-Mar-2005 BJD Fixed __iomem warnings |
19 | * 20-Sep-2005 BJD Added static to non-exported items | 19 | * 20-Sep-2005 BJD Added static to non-exported items |
20 | * 31-Oct-2005 BJD Added LCD setup for framebuffer | ||
20 | */ | 21 | */ |
21 | 22 | ||
22 | #include <linux/kernel.h> | 23 | #include <linux/kernel.h> |
@@ -43,6 +44,9 @@ | |||
43 | 44 | ||
44 | #include <asm/arch/regs-serial.h> | 45 | #include <asm/arch/regs-serial.h> |
45 | #include <asm/arch/regs-gpio.h> | 46 | #include <asm/arch/regs-gpio.h> |
47 | #include <asm/arch/regs-lcd.h> | ||
48 | |||
49 | #include <asm/arch/fb.h> | ||
46 | 50 | ||
47 | #include "clock.h" | 51 | #include "clock.h" |
48 | #include "devs.h" | 52 | #include "devs.h" |
@@ -97,6 +101,66 @@ static struct s3c2410_uartcfg rx3715_uartcfgs[] = { | |||
97 | } | 101 | } |
98 | }; | 102 | }; |
99 | 103 | ||
104 | /* framebuffer lcd controller information */ | ||
105 | |||
106 | static struct s3c2410fb_mach_info rx3715_lcdcfg __initdata = { | ||
107 | .regs = { | ||
108 | .lcdcon1 = S3C2410_LCDCON1_TFT16BPP | \ | ||
109 | S3C2410_LCDCON1_TFT | \ | ||
110 | S3C2410_LCDCON1_CLKVAL(0x0C), | ||
111 | |||
112 | .lcdcon2 = S3C2410_LCDCON2_VBPD(5) | \ | ||
113 | S3C2410_LCDCON2_LINEVAL(319) | \ | ||
114 | S3C2410_LCDCON2_VFPD(6) | \ | ||
115 | S3C2410_LCDCON2_VSPW(2), | ||
116 | |||
117 | .lcdcon3 = S3C2410_LCDCON3_HBPD(35) | \ | ||
118 | S3C2410_LCDCON3_HOZVAL(239) | \ | ||
119 | S3C2410_LCDCON3_HFPD(35), | ||
120 | |||
121 | .lcdcon4 = S3C2410_LCDCON4_MVAL(0) | \ | ||
122 | S3C2410_LCDCON4_HSPW(7), | ||
123 | |||
124 | .lcdcon5 = S3C2410_LCDCON5_INVVLINE | | ||
125 | S3C2410_LCDCON5_FRM565 | | ||
126 | S3C2410_LCDCON5_HWSWP, | ||
127 | }, | ||
128 | |||
129 | .lpcsel = 0xf82, | ||
130 | |||
131 | .gpccon = 0xaa955699, | ||
132 | .gpccon_mask = 0xffc003cc, | ||
133 | .gpcup = 0x0000ffff, | ||
134 | .gpcup_mask = 0xffffffff, | ||
135 | |||
136 | .gpdcon = 0xaa95aaa1, | ||
137 | .gpdcon_mask = 0xffc0fff0, | ||
138 | .gpdup = 0x0000faff, | ||
139 | .gpdup_mask = 0xffffffff, | ||
140 | |||
141 | .fixed_syncs = 1, | ||
142 | .width = 240, | ||
143 | .height = 320, | ||
144 | |||
145 | .xres = { | ||
146 | .min = 240, | ||
147 | .max = 240, | ||
148 | .defval = 240, | ||
149 | }, | ||
150 | |||
151 | .yres = { | ||
152 | .max = 320, | ||
153 | .min = 320, | ||
154 | .defval = 320, | ||
155 | }, | ||
156 | |||
157 | .bpp = { | ||
158 | .min = 16, | ||
159 | .max = 16, | ||
160 | .defval = 16, | ||
161 | }, | ||
162 | }; | ||
163 | |||
100 | static struct platform_device *rx3715_devices[] __initdata = { | 164 | static struct platform_device *rx3715_devices[] __initdata = { |
101 | &s3c_device_usb, | 165 | &s3c_device_usb, |
102 | &s3c_device_lcd, | 166 | &s3c_device_lcd, |
@@ -123,14 +187,12 @@ static void __init rx3715_init_irq(void) | |||
123 | s3c24xx_init_irq(); | 187 | s3c24xx_init_irq(); |
124 | } | 188 | } |
125 | 189 | ||
126 | #ifdef CONFIG_PM | ||
127 | static void __init rx3715_init_machine(void) | 190 | static void __init rx3715_init_machine(void) |
128 | { | 191 | { |
129 | s3c2410_pm_init(); | 192 | s3c2410_pm_init(); |
193 | s3c24xx_fb_set_platdata(&rx3715_lcdcfg); | ||
130 | } | 194 | } |
131 | #else | 195 | |
132 | #define rx3715_init_machine NULL | ||
133 | #endif | ||
134 | 196 | ||
135 | MACHINE_START(RX3715, "IPAQ-RX3715") | 197 | MACHINE_START(RX3715, "IPAQ-RX3715") |
136 | /* Maintainer: Ben Dooks <ben@fluff.org> */ | 198 | /* Maintainer: Ben Dooks <ben@fluff.org> */ |
diff --git a/arch/arm/mm/Kconfig b/arch/arm/mm/Kconfig index c54e04c995ee..5568403e984d 100644 --- a/arch/arm/mm/Kconfig +++ b/arch/arm/mm/Kconfig | |||
@@ -120,8 +120,8 @@ config CPU_ARM925T | |||
120 | 120 | ||
121 | # ARM926T | 121 | # ARM926T |
122 | config CPU_ARM926T | 122 | config CPU_ARM926T |
123 | bool "Support ARM926T processor" if ARCH_INTEGRATOR | 123 | bool "Support ARM926T processor" |
124 | depends on ARCH_INTEGRATOR || ARCH_VERSATILE_PB || MACH_VERSATILE_AB || ARCH_OMAP730 || ARCH_OMAP16XX | 124 | depends on ARCH_INTEGRATOR || ARCH_VERSATILE_PB || MACH_VERSATILE_AB || ARCH_OMAP730 || ARCH_OMAP16XX || MACH_REALVIEW_EB |
125 | default y if ARCH_VERSATILE_PB || MACH_VERSATILE_AB || ARCH_OMAP730 || ARCH_OMAP16XX | 125 | default y if ARCH_VERSATILE_PB || MACH_VERSATILE_AB || ARCH_OMAP730 || ARCH_OMAP16XX |
126 | select CPU_32v5 | 126 | select CPU_32v5 |
127 | select CPU_ABRT_EV5TJ | 127 | select CPU_ABRT_EV5TJ |
@@ -242,7 +242,7 @@ config CPU_XSCALE | |||
242 | # ARMv6 | 242 | # ARMv6 |
243 | config CPU_V6 | 243 | config CPU_V6 |
244 | bool "Support ARM V6 processor" | 244 | bool "Support ARM V6 processor" |
245 | depends on ARCH_INTEGRATOR | 245 | depends on ARCH_INTEGRATOR || MACH_REALVIEW_EB |
246 | select CPU_32v6 | 246 | select CPU_32v6 |
247 | select CPU_ABRT_EV6 | 247 | select CPU_ABRT_EV6 |
248 | select CPU_CACHE_V6 | 248 | select CPU_CACHE_V6 |