diff options
Diffstat (limited to 'arch/arm/mach-s5p64x0')
37 files changed, 4328 insertions, 0 deletions
diff --git a/arch/arm/mach-s5p64x0/Kconfig b/arch/arm/mach-s5p64x0/Kconfig new file mode 100644 index 000000000000..fbcae9352022 --- /dev/null +++ b/arch/arm/mach-s5p64x0/Kconfig | |||
@@ -0,0 +1,57 @@ | |||
1 | # arch/arm/mach-s5p64x0/Kconfig | ||
2 | # | ||
3 | # Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | # http://www.samsung.com/ | ||
5 | # | ||
6 | # Licensed under GPLv2 | ||
7 | |||
8 | if ARCH_S5P64X0 | ||
9 | |||
10 | config CPU_S5P6440 | ||
11 | bool | ||
12 | select PLAT_S5P | ||
13 | select S3C_PL330_DMA | ||
14 | help | ||
15 | Enable S5P6440 CPU support | ||
16 | |||
17 | config CPU_S5P6450 | ||
18 | bool | ||
19 | select PLAT_S5P | ||
20 | select S3C_PL330_DMA | ||
21 | help | ||
22 | Enable S5P6450 CPU support | ||
23 | |||
24 | config S5P64X0_SETUP_I2C1 | ||
25 | bool | ||
26 | help | ||
27 | Common setup code for i2c bus 1. | ||
28 | |||
29 | # machine support | ||
30 | |||
31 | config MACH_SMDK6440 | ||
32 | bool "SMDK6440" | ||
33 | select CPU_S5P6440 | ||
34 | select S3C_DEV_I2C1 | ||
35 | select S3C_DEV_RTC | ||
36 | select S3C_DEV_WDT | ||
37 | select S3C64XX_DEV_SPI | ||
38 | select SAMSUNG_DEV_ADC | ||
39 | select SAMSUNG_DEV_TS | ||
40 | select S5P64X0_SETUP_I2C1 | ||
41 | help | ||
42 | Machine support for the Samsung SMDK6440 | ||
43 | |||
44 | config MACH_SMDK6450 | ||
45 | bool "SMDK6450" | ||
46 | select CPU_S5P6450 | ||
47 | select S3C_DEV_I2C1 | ||
48 | select S3C_DEV_RTC | ||
49 | select S3C_DEV_WDT | ||
50 | select S3C64XX_DEV_SPI | ||
51 | select SAMSUNG_DEV_ADC | ||
52 | select SAMSUNG_DEV_TS | ||
53 | select S5P64X0_SETUP_I2C1 | ||
54 | help | ||
55 | Machine support for the Samsung SMDK6450 | ||
56 | |||
57 | endif | ||
diff --git a/arch/arm/mach-s5p64x0/Makefile b/arch/arm/mach-s5p64x0/Makefile new file mode 100644 index 000000000000..2655829e6bf8 --- /dev/null +++ b/arch/arm/mach-s5p64x0/Makefile | |||
@@ -0,0 +1,30 @@ | |||
1 | # arch/arm/mach-s5p64x0/Makefile | ||
2 | # | ||
3 | # Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | # http://www.samsung.com | ||
5 | # | ||
6 | # Licensed under GPLv2 | ||
7 | |||
8 | obj-y := | ||
9 | obj-m := | ||
10 | obj-n := | ||
11 | obj- := | ||
12 | |||
13 | # Core support for S5P64X0 system | ||
14 | |||
15 | obj-$(CONFIG_ARCH_S5P64X0) += cpu.o init.o clock.o dma.o | ||
16 | obj-$(CONFIG_ARCH_S5P64X0) += setup-i2c0.o | ||
17 | obj-$(CONFIG_CPU_S5P6440) += clock-s5p6440.o gpio.o | ||
18 | obj-$(CONFIG_CPU_S5P6450) += clock-s5p6450.o | ||
19 | |||
20 | # machine support | ||
21 | |||
22 | obj-$(CONFIG_MACH_SMDK6440) += mach-smdk6440.o | ||
23 | obj-$(CONFIG_MACH_SMDK6450) += mach-smdk6450.o | ||
24 | |||
25 | # device support | ||
26 | |||
27 | obj-y += dev-audio.o | ||
28 | obj-$(CONFIG_S3C64XX_DEV_SPI) += dev-spi.o | ||
29 | |||
30 | obj-$(CONFIG_S5P64X0_SETUP_I2C1) += setup-i2c1.o | ||
diff --git a/arch/arm/mach-s5p64x0/Makefile.boot b/arch/arm/mach-s5p64x0/Makefile.boot new file mode 100644 index 000000000000..ff90aa13bd67 --- /dev/null +++ b/arch/arm/mach-s5p64x0/Makefile.boot | |||
@@ -0,0 +1,2 @@ | |||
1 | zreladdr-y := 0x20008000 | ||
2 | params_phys-y := 0x20000100 | ||
diff --git a/arch/arm/mach-s5p64x0/clock-s5p6440.c b/arch/arm/mach-s5p64x0/clock-s5p6440.c new file mode 100644 index 000000000000..f93dcd8b4d6a --- /dev/null +++ b/arch/arm/mach-s5p64x0/clock-s5p6440.c | |||
@@ -0,0 +1,626 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/clock-s5p6440.c | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P6440 - Clock support | ||
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/init.h> | ||
14 | #include <linux/module.h> | ||
15 | #include <linux/kernel.h> | ||
16 | #include <linux/list.h> | ||
17 | #include <linux/errno.h> | ||
18 | #include <linux/err.h> | ||
19 | #include <linux/clk.h> | ||
20 | #include <linux/sysdev.h> | ||
21 | #include <linux/io.h> | ||
22 | |||
23 | #include <mach/hardware.h> | ||
24 | #include <mach/map.h> | ||
25 | #include <mach/regs-clock.h> | ||
26 | #include <mach/s5p64x0-clock.h> | ||
27 | |||
28 | #include <plat/cpu-freq.h> | ||
29 | #include <plat/clock.h> | ||
30 | #include <plat/cpu.h> | ||
31 | #include <plat/pll.h> | ||
32 | #include <plat/s5p-clock.h> | ||
33 | #include <plat/clock-clksrc.h> | ||
34 | #include <plat/s5p6440.h> | ||
35 | |||
36 | static u32 epll_div[][5] = { | ||
37 | { 36000000, 0, 48, 1, 4 }, | ||
38 | { 48000000, 0, 32, 1, 3 }, | ||
39 | { 60000000, 0, 40, 1, 3 }, | ||
40 | { 72000000, 0, 48, 1, 3 }, | ||
41 | { 84000000, 0, 28, 1, 2 }, | ||
42 | { 96000000, 0, 32, 1, 2 }, | ||
43 | { 32768000, 45264, 43, 1, 4 }, | ||
44 | { 45158000, 6903, 30, 1, 3 }, | ||
45 | { 49152000, 50332, 32, 1, 3 }, | ||
46 | { 67738000, 10398, 45, 1, 3 }, | ||
47 | { 73728000, 9961, 49, 1, 3 } | ||
48 | }; | ||
49 | |||
50 | static int s5p6440_epll_set_rate(struct clk *clk, unsigned long rate) | ||
51 | { | ||
52 | unsigned int epll_con, epll_con_k; | ||
53 | unsigned int i; | ||
54 | |||
55 | if (clk->rate == rate) /* Return if nothing changed */ | ||
56 | return 0; | ||
57 | |||
58 | epll_con = __raw_readl(S5P64X0_EPLL_CON); | ||
59 | epll_con_k = __raw_readl(S5P64X0_EPLL_CON_K); | ||
60 | |||
61 | epll_con_k &= ~(PLL90XX_KDIV_MASK); | ||
62 | epll_con &= ~(PLL90XX_MDIV_MASK | PLL90XX_PDIV_MASK | PLL90XX_SDIV_MASK); | ||
63 | |||
64 | for (i = 0; i < ARRAY_SIZE(epll_div); i++) { | ||
65 | if (epll_div[i][0] == rate) { | ||
66 | epll_con_k |= (epll_div[i][1] << PLL90XX_KDIV_SHIFT); | ||
67 | epll_con |= (epll_div[i][2] << PLL90XX_MDIV_SHIFT) | | ||
68 | (epll_div[i][3] << PLL90XX_PDIV_SHIFT) | | ||
69 | (epll_div[i][4] << PLL90XX_SDIV_SHIFT); | ||
70 | break; | ||
71 | } | ||
72 | } | ||
73 | |||
74 | if (i == ARRAY_SIZE(epll_div)) { | ||
75 | printk(KERN_ERR "%s: Invalid Clock EPLL Frequency\n", __func__); | ||
76 | return -EINVAL; | ||
77 | } | ||
78 | |||
79 | __raw_writel(epll_con, S5P64X0_EPLL_CON); | ||
80 | __raw_writel(epll_con_k, S5P64X0_EPLL_CON_K); | ||
81 | |||
82 | clk->rate = rate; | ||
83 | |||
84 | return 0; | ||
85 | } | ||
86 | |||
87 | static struct clk_ops s5p6440_epll_ops = { | ||
88 | .get_rate = s5p64x0_epll_get_rate, | ||
89 | .set_rate = s5p6440_epll_set_rate, | ||
90 | }; | ||
91 | |||
92 | static struct clksrc_clk clk_hclk = { | ||
93 | .clk = { | ||
94 | .name = "clk_hclk", | ||
95 | .id = -1, | ||
96 | .parent = &clk_armclk.clk, | ||
97 | }, | ||
98 | .reg_div = { .reg = S5P64X0_CLK_DIV0, .shift = 8, .size = 4 }, | ||
99 | }; | ||
100 | |||
101 | static struct clksrc_clk clk_pclk = { | ||
102 | .clk = { | ||
103 | .name = "clk_pclk", | ||
104 | .id = -1, | ||
105 | .parent = &clk_hclk.clk, | ||
106 | }, | ||
107 | .reg_div = { .reg = S5P64X0_CLK_DIV0, .shift = 12, .size = 4 }, | ||
108 | }; | ||
109 | static struct clksrc_clk clk_hclk_low = { | ||
110 | .clk = { | ||
111 | .name = "clk_hclk_low", | ||
112 | .id = -1, | ||
113 | }, | ||
114 | .sources = &clkset_hclk_low, | ||
115 | .reg_src = { .reg = S5P64X0_SYS_OTHERS, .shift = 6, .size = 1 }, | ||
116 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 8, .size = 4 }, | ||
117 | }; | ||
118 | |||
119 | static struct clksrc_clk clk_pclk_low = { | ||
120 | .clk = { | ||
121 | .name = "clk_pclk_low", | ||
122 | .id = -1, | ||
123 | .parent = &clk_hclk_low.clk, | ||
124 | }, | ||
125 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 12, .size = 4 }, | ||
126 | }; | ||
127 | |||
128 | /* | ||
129 | * The following clocks will be disabled during clock initialization. It is | ||
130 | * recommended to keep the following clocks disabled until the driver requests | ||
131 | * for enabling the clock. | ||
132 | */ | ||
133 | static struct clk init_clocks_disable[] = { | ||
134 | { | ||
135 | .name = "nand", | ||
136 | .id = -1, | ||
137 | .parent = &clk_hclk.clk, | ||
138 | .enable = s5p64x0_mem_ctrl, | ||
139 | .ctrlbit = (1 << 2), | ||
140 | }, { | ||
141 | .name = "post", | ||
142 | .id = -1, | ||
143 | .parent = &clk_hclk_low.clk, | ||
144 | .enable = s5p64x0_hclk0_ctrl, | ||
145 | .ctrlbit = (1 << 5) | ||
146 | }, { | ||
147 | .name = "2d", | ||
148 | .id = -1, | ||
149 | .parent = &clk_hclk.clk, | ||
150 | .enable = s5p64x0_hclk0_ctrl, | ||
151 | .ctrlbit = (1 << 8), | ||
152 | }, { | ||
153 | .name = "hsmmc", | ||
154 | .id = 0, | ||
155 | .parent = &clk_hclk_low.clk, | ||
156 | .enable = s5p64x0_hclk0_ctrl, | ||
157 | .ctrlbit = (1 << 17), | ||
158 | }, { | ||
159 | .name = "hsmmc", | ||
160 | .id = 1, | ||
161 | .parent = &clk_hclk_low.clk, | ||
162 | .enable = s5p64x0_hclk0_ctrl, | ||
163 | .ctrlbit = (1 << 18), | ||
164 | }, { | ||
165 | .name = "hsmmc", | ||
166 | .id = 2, | ||
167 | .parent = &clk_hclk_low.clk, | ||
168 | .enable = s5p64x0_hclk0_ctrl, | ||
169 | .ctrlbit = (1 << 19), | ||
170 | }, { | ||
171 | .name = "otg", | ||
172 | .id = -1, | ||
173 | .parent = &clk_hclk_low.clk, | ||
174 | .enable = s5p64x0_hclk0_ctrl, | ||
175 | .ctrlbit = (1 << 20) | ||
176 | }, { | ||
177 | .name = "irom", | ||
178 | .id = -1, | ||
179 | .parent = &clk_hclk.clk, | ||
180 | .enable = s5p64x0_hclk0_ctrl, | ||
181 | .ctrlbit = (1 << 25), | ||
182 | }, { | ||
183 | .name = "lcd", | ||
184 | .id = -1, | ||
185 | .parent = &clk_hclk_low.clk, | ||
186 | .enable = s5p64x0_hclk1_ctrl, | ||
187 | .ctrlbit = (1 << 1), | ||
188 | }, { | ||
189 | .name = "hclk_fimgvg", | ||
190 | .id = -1, | ||
191 | .parent = &clk_hclk.clk, | ||
192 | .enable = s5p64x0_hclk1_ctrl, | ||
193 | .ctrlbit = (1 << 2), | ||
194 | }, { | ||
195 | .name = "tsi", | ||
196 | .id = -1, | ||
197 | .parent = &clk_hclk_low.clk, | ||
198 | .enable = s5p64x0_hclk1_ctrl, | ||
199 | .ctrlbit = (1 << 0), | ||
200 | }, { | ||
201 | .name = "watchdog", | ||
202 | .id = -1, | ||
203 | .parent = &clk_pclk_low.clk, | ||
204 | .enable = s5p64x0_pclk_ctrl, | ||
205 | .ctrlbit = (1 << 5), | ||
206 | }, { | ||
207 | .name = "rtc", | ||
208 | .id = -1, | ||
209 | .parent = &clk_pclk_low.clk, | ||
210 | .enable = s5p64x0_pclk_ctrl, | ||
211 | .ctrlbit = (1 << 6), | ||
212 | }, { | ||
213 | .name = "timers", | ||
214 | .id = -1, | ||
215 | .parent = &clk_pclk_low.clk, | ||
216 | .enable = s5p64x0_pclk_ctrl, | ||
217 | .ctrlbit = (1 << 7), | ||
218 | }, { | ||
219 | .name = "pcm", | ||
220 | .id = -1, | ||
221 | .parent = &clk_pclk_low.clk, | ||
222 | .enable = s5p64x0_pclk_ctrl, | ||
223 | .ctrlbit = (1 << 8), | ||
224 | }, { | ||
225 | .name = "adc", | ||
226 | .id = -1, | ||
227 | .parent = &clk_pclk_low.clk, | ||
228 | .enable = s5p64x0_pclk_ctrl, | ||
229 | .ctrlbit = (1 << 12), | ||
230 | }, { | ||
231 | .name = "i2c", | ||
232 | .id = -1, | ||
233 | .parent = &clk_pclk_low.clk, | ||
234 | .enable = s5p64x0_pclk_ctrl, | ||
235 | .ctrlbit = (1 << 17), | ||
236 | }, { | ||
237 | .name = "spi", | ||
238 | .id = 0, | ||
239 | .parent = &clk_pclk_low.clk, | ||
240 | .enable = s5p64x0_pclk_ctrl, | ||
241 | .ctrlbit = (1 << 21), | ||
242 | }, { | ||
243 | .name = "spi", | ||
244 | .id = 1, | ||
245 | .parent = &clk_pclk_low.clk, | ||
246 | .enable = s5p64x0_pclk_ctrl, | ||
247 | .ctrlbit = (1 << 22), | ||
248 | }, { | ||
249 | .name = "gps", | ||
250 | .id = -1, | ||
251 | .parent = &clk_pclk_low.clk, | ||
252 | .enable = s5p64x0_pclk_ctrl, | ||
253 | .ctrlbit = (1 << 25), | ||
254 | }, { | ||
255 | .name = "i2s_v40", | ||
256 | .id = 0, | ||
257 | .parent = &clk_pclk_low.clk, | ||
258 | .enable = s5p64x0_pclk_ctrl, | ||
259 | .ctrlbit = (1 << 26), | ||
260 | }, { | ||
261 | .name = "dsim", | ||
262 | .id = -1, | ||
263 | .parent = &clk_pclk_low.clk, | ||
264 | .enable = s5p64x0_pclk_ctrl, | ||
265 | .ctrlbit = (1 << 28), | ||
266 | }, { | ||
267 | .name = "etm", | ||
268 | .id = -1, | ||
269 | .parent = &clk_pclk.clk, | ||
270 | .enable = s5p64x0_pclk_ctrl, | ||
271 | .ctrlbit = (1 << 29), | ||
272 | }, { | ||
273 | .name = "dmc0", | ||
274 | .id = -1, | ||
275 | .parent = &clk_pclk.clk, | ||
276 | .enable = s5p64x0_pclk_ctrl, | ||
277 | .ctrlbit = (1 << 30), | ||
278 | }, { | ||
279 | .name = "pclk_fimgvg", | ||
280 | .id = -1, | ||
281 | .parent = &clk_pclk.clk, | ||
282 | .enable = s5p64x0_pclk_ctrl, | ||
283 | .ctrlbit = (1 << 31), | ||
284 | }, { | ||
285 | .name = "sclk_spi_48", | ||
286 | .id = 0, | ||
287 | .parent = &clk_48m, | ||
288 | .enable = s5p64x0_sclk_ctrl, | ||
289 | .ctrlbit = (1 << 22), | ||
290 | }, { | ||
291 | .name = "sclk_spi_48", | ||
292 | .id = 1, | ||
293 | .parent = &clk_48m, | ||
294 | .enable = s5p64x0_sclk_ctrl, | ||
295 | .ctrlbit = (1 << 23), | ||
296 | }, { | ||
297 | .name = "mmc_48m", | ||
298 | .id = 0, | ||
299 | .parent = &clk_48m, | ||
300 | .enable = s5p64x0_sclk_ctrl, | ||
301 | .ctrlbit = (1 << 27), | ||
302 | }, { | ||
303 | .name = "mmc_48m", | ||
304 | .id = 1, | ||
305 | .parent = &clk_48m, | ||
306 | .enable = s5p64x0_sclk_ctrl, | ||
307 | .ctrlbit = (1 << 28), | ||
308 | }, { | ||
309 | .name = "mmc_48m", | ||
310 | .id = 2, | ||
311 | .parent = &clk_48m, | ||
312 | .enable = s5p64x0_sclk_ctrl, | ||
313 | .ctrlbit = (1 << 29), | ||
314 | }, | ||
315 | }; | ||
316 | |||
317 | /* | ||
318 | * The following clocks will be enabled during clock initialization. | ||
319 | */ | ||
320 | static struct clk init_clocks[] = { | ||
321 | { | ||
322 | .name = "intc", | ||
323 | .id = -1, | ||
324 | .parent = &clk_hclk.clk, | ||
325 | .enable = s5p64x0_hclk0_ctrl, | ||
326 | .ctrlbit = (1 << 1), | ||
327 | }, { | ||
328 | .name = "mem", | ||
329 | .id = -1, | ||
330 | .parent = &clk_hclk.clk, | ||
331 | .enable = s5p64x0_hclk0_ctrl, | ||
332 | .ctrlbit = (1 << 21), | ||
333 | }, { | ||
334 | .name = "dma", | ||
335 | .id = -1, | ||
336 | .parent = &clk_hclk_low.clk, | ||
337 | .enable = s5p64x0_hclk0_ctrl, | ||
338 | .ctrlbit = (1 << 12), | ||
339 | }, { | ||
340 | .name = "uart", | ||
341 | .id = 0, | ||
342 | .parent = &clk_pclk_low.clk, | ||
343 | .enable = s5p64x0_pclk_ctrl, | ||
344 | .ctrlbit = (1 << 1), | ||
345 | }, { | ||
346 | .name = "uart", | ||
347 | .id = 1, | ||
348 | .parent = &clk_pclk_low.clk, | ||
349 | .enable = s5p64x0_pclk_ctrl, | ||
350 | .ctrlbit = (1 << 2), | ||
351 | }, { | ||
352 | .name = "uart", | ||
353 | .id = 2, | ||
354 | .parent = &clk_pclk_low.clk, | ||
355 | .enable = s5p64x0_pclk_ctrl, | ||
356 | .ctrlbit = (1 << 3), | ||
357 | }, { | ||
358 | .name = "uart", | ||
359 | .id = 3, | ||
360 | .parent = &clk_pclk_low.clk, | ||
361 | .enable = s5p64x0_pclk_ctrl, | ||
362 | .ctrlbit = (1 << 4), | ||
363 | }, { | ||
364 | .name = "gpio", | ||
365 | .id = -1, | ||
366 | .parent = &clk_pclk_low.clk, | ||
367 | .enable = s5p64x0_pclk_ctrl, | ||
368 | .ctrlbit = (1 << 18), | ||
369 | }, | ||
370 | }; | ||
371 | |||
372 | static struct clk clk_iis_cd_v40 = { | ||
373 | .name = "iis_cdclk_v40", | ||
374 | .id = -1, | ||
375 | }; | ||
376 | |||
377 | static struct clk clk_pcm_cd = { | ||
378 | .name = "pcm_cdclk", | ||
379 | .id = -1, | ||
380 | }; | ||
381 | |||
382 | static struct clk *clkset_group1_list[] = { | ||
383 | &clk_mout_epll.clk, | ||
384 | &clk_dout_mpll.clk, | ||
385 | &clk_fin_epll, | ||
386 | }; | ||
387 | |||
388 | static struct clksrc_sources clkset_group1 = { | ||
389 | .sources = clkset_group1_list, | ||
390 | .nr_sources = ARRAY_SIZE(clkset_group1_list), | ||
391 | }; | ||
392 | |||
393 | static struct clk *clkset_uart_list[] = { | ||
394 | &clk_mout_epll.clk, | ||
395 | &clk_dout_mpll.clk, | ||
396 | }; | ||
397 | |||
398 | static struct clksrc_sources clkset_uart = { | ||
399 | .sources = clkset_uart_list, | ||
400 | .nr_sources = ARRAY_SIZE(clkset_uart_list), | ||
401 | }; | ||
402 | |||
403 | static struct clk *clkset_audio_list[] = { | ||
404 | &clk_mout_epll.clk, | ||
405 | &clk_dout_mpll.clk, | ||
406 | &clk_fin_epll, | ||
407 | &clk_iis_cd_v40, | ||
408 | &clk_pcm_cd, | ||
409 | }; | ||
410 | |||
411 | static struct clksrc_sources clkset_audio = { | ||
412 | .sources = clkset_audio_list, | ||
413 | .nr_sources = ARRAY_SIZE(clkset_audio_list), | ||
414 | }; | ||
415 | |||
416 | static struct clksrc_clk clksrcs[] = { | ||
417 | { | ||
418 | .clk = { | ||
419 | .name = "mmc_bus", | ||
420 | .id = 0, | ||
421 | .ctrlbit = (1 << 24), | ||
422 | .enable = s5p64x0_sclk_ctrl, | ||
423 | }, | ||
424 | .sources = &clkset_group1, | ||
425 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 18, .size = 2 }, | ||
426 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 0, .size = 4 }, | ||
427 | }, { | ||
428 | .clk = { | ||
429 | .name = "mmc_bus", | ||
430 | .id = 1, | ||
431 | .ctrlbit = (1 << 25), | ||
432 | .enable = s5p64x0_sclk_ctrl, | ||
433 | }, | ||
434 | .sources = &clkset_group1, | ||
435 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 20, .size = 2 }, | ||
436 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 4, .size = 4 }, | ||
437 | }, { | ||
438 | .clk = { | ||
439 | .name = "mmc_bus", | ||
440 | .id = 2, | ||
441 | .ctrlbit = (1 << 26), | ||
442 | .enable = s5p64x0_sclk_ctrl, | ||
443 | }, | ||
444 | .sources = &clkset_group1, | ||
445 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 22, .size = 2 }, | ||
446 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 8, .size = 4 }, | ||
447 | }, { | ||
448 | .clk = { | ||
449 | .name = "uclk1", | ||
450 | .id = -1, | ||
451 | .ctrlbit = (1 << 5), | ||
452 | .enable = s5p64x0_sclk_ctrl, | ||
453 | }, | ||
454 | .sources = &clkset_uart, | ||
455 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 13, .size = 1 }, | ||
456 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 16, .size = 4 }, | ||
457 | }, { | ||
458 | .clk = { | ||
459 | .name = "sclk_spi", | ||
460 | .id = 0, | ||
461 | .ctrlbit = (1 << 20), | ||
462 | .enable = s5p64x0_sclk_ctrl, | ||
463 | }, | ||
464 | .sources = &clkset_group1, | ||
465 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 14, .size = 2 }, | ||
466 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 0, .size = 4 }, | ||
467 | }, { | ||
468 | .clk = { | ||
469 | .name = "sclk_spi", | ||
470 | .id = 1, | ||
471 | .ctrlbit = (1 << 21), | ||
472 | .enable = s5p64x0_sclk_ctrl, | ||
473 | }, | ||
474 | .sources = &clkset_group1, | ||
475 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 16, .size = 2 }, | ||
476 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 4, .size = 4 }, | ||
477 | }, { | ||
478 | .clk = { | ||
479 | .name = "sclk_post", | ||
480 | .id = -1, | ||
481 | .ctrlbit = (1 << 10), | ||
482 | .enable = s5p64x0_sclk_ctrl, | ||
483 | }, | ||
484 | .sources = &clkset_group1, | ||
485 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 26, .size = 2 }, | ||
486 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 12, .size = 4 }, | ||
487 | }, { | ||
488 | .clk = { | ||
489 | .name = "sclk_dispcon", | ||
490 | .id = -1, | ||
491 | .ctrlbit = (1 << 1), | ||
492 | .enable = s5p64x0_sclk1_ctrl, | ||
493 | }, | ||
494 | .sources = &clkset_group1, | ||
495 | .reg_src = { .reg = S5P64X0_CLK_SRC1, .shift = 4, .size = 2 }, | ||
496 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 0, .size = 4 }, | ||
497 | }, { | ||
498 | .clk = { | ||
499 | .name = "sclk_fimgvg", | ||
500 | .id = -1, | ||
501 | .ctrlbit = (1 << 2), | ||
502 | .enable = s5p64x0_sclk1_ctrl, | ||
503 | }, | ||
504 | .sources = &clkset_group1, | ||
505 | .reg_src = { .reg = S5P64X0_CLK_SRC1, .shift = 8, .size = 2 }, | ||
506 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 4, .size = 4 }, | ||
507 | }, { | ||
508 | .clk = { | ||
509 | .name = "sclk_audio2", | ||
510 | .id = -1, | ||
511 | .ctrlbit = (1 << 11), | ||
512 | .enable = s5p64x0_sclk_ctrl, | ||
513 | }, | ||
514 | .sources = &clkset_audio, | ||
515 | .reg_src = { .reg = S5P64X0_CLK_SRC1, .shift = 0, .size = 3 }, | ||
516 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 24, .size = 4 }, | ||
517 | }, | ||
518 | }; | ||
519 | |||
520 | /* Clock initialization code */ | ||
521 | static struct clksrc_clk *sysclks[] = { | ||
522 | &clk_mout_apll, | ||
523 | &clk_mout_epll, | ||
524 | &clk_mout_mpll, | ||
525 | &clk_dout_mpll, | ||
526 | &clk_armclk, | ||
527 | &clk_hclk, | ||
528 | &clk_pclk, | ||
529 | &clk_hclk_low, | ||
530 | &clk_pclk_low, | ||
531 | }; | ||
532 | |||
533 | void __init_or_cpufreq s5p6440_setup_clocks(void) | ||
534 | { | ||
535 | struct clk *xtal_clk; | ||
536 | |||
537 | unsigned long xtal; | ||
538 | unsigned long fclk; | ||
539 | unsigned long hclk; | ||
540 | unsigned long hclk_low; | ||
541 | unsigned long pclk; | ||
542 | unsigned long pclk_low; | ||
543 | |||
544 | unsigned long apll; | ||
545 | unsigned long mpll; | ||
546 | unsigned long epll; | ||
547 | unsigned int ptr; | ||
548 | |||
549 | /* Set S5P6440 functions for clk_fout_epll */ | ||
550 | |||
551 | clk_fout_epll.enable = s5p64x0_epll_enable; | ||
552 | clk_fout_epll.ops = &s5p6440_epll_ops; | ||
553 | |||
554 | clk_48m.enable = s5p64x0_clk48m_ctrl; | ||
555 | |||
556 | xtal_clk = clk_get(NULL, "ext_xtal"); | ||
557 | BUG_ON(IS_ERR(xtal_clk)); | ||
558 | |||
559 | xtal = clk_get_rate(xtal_clk); | ||
560 | clk_put(xtal_clk); | ||
561 | |||
562 | apll = s5p_get_pll45xx(xtal, __raw_readl(S5P64X0_APLL_CON), pll_4502); | ||
563 | mpll = s5p_get_pll45xx(xtal, __raw_readl(S5P64X0_MPLL_CON), pll_4502); | ||
564 | epll = s5p_get_pll90xx(xtal, __raw_readl(S5P64X0_EPLL_CON), | ||
565 | __raw_readl(S5P64X0_EPLL_CON_K)); | ||
566 | |||
567 | clk_fout_apll.rate = apll; | ||
568 | clk_fout_mpll.rate = mpll; | ||
569 | clk_fout_epll.rate = epll; | ||
570 | |||
571 | printk(KERN_INFO "S5P6440: PLL settings, A=%ld.%ldMHz, M=%ld.%ldMHz," \ | ||
572 | " E=%ld.%ldMHz\n", | ||
573 | print_mhz(apll), print_mhz(mpll), print_mhz(epll)); | ||
574 | |||
575 | fclk = clk_get_rate(&clk_armclk.clk); | ||
576 | hclk = clk_get_rate(&clk_hclk.clk); | ||
577 | pclk = clk_get_rate(&clk_pclk.clk); | ||
578 | hclk_low = clk_get_rate(&clk_hclk_low.clk); | ||
579 | pclk_low = clk_get_rate(&clk_pclk_low.clk); | ||
580 | |||
581 | printk(KERN_INFO "S5P6440: HCLK=%ld.%ldMHz, HCLK_LOW=%ld.%ldMHz," \ | ||
582 | " PCLK=%ld.%ldMHz, PCLK_LOW=%ld.%ldMHz\n", | ||
583 | print_mhz(hclk), print_mhz(hclk_low), | ||
584 | print_mhz(pclk), print_mhz(pclk_low)); | ||
585 | |||
586 | clk_f.rate = fclk; | ||
587 | clk_h.rate = hclk; | ||
588 | clk_p.rate = pclk; | ||
589 | |||
590 | for (ptr = 0; ptr < ARRAY_SIZE(clksrcs); ptr++) | ||
591 | s3c_set_clksrc(&clksrcs[ptr], true); | ||
592 | } | ||
593 | |||
594 | static struct clk *clks[] __initdata = { | ||
595 | &clk_ext, | ||
596 | &clk_iis_cd_v40, | ||
597 | &clk_pcm_cd, | ||
598 | }; | ||
599 | |||
600 | void __init s5p6440_register_clocks(void) | ||
601 | { | ||
602 | struct clk *clkp; | ||
603 | int ret; | ||
604 | int ptr; | ||
605 | |||
606 | s3c24xx_register_clocks(clks, ARRAY_SIZE(clks)); | ||
607 | |||
608 | for (ptr = 0; ptr < ARRAY_SIZE(sysclks); ptr++) | ||
609 | s3c_register_clksrc(sysclks[ptr], 1); | ||
610 | |||
611 | s3c_register_clksrc(clksrcs, ARRAY_SIZE(clksrcs)); | ||
612 | s3c_register_clocks(init_clocks, ARRAY_SIZE(init_clocks)); | ||
613 | |||
614 | clkp = init_clocks_disable; | ||
615 | for (ptr = 0; ptr < ARRAY_SIZE(init_clocks_disable); ptr++, clkp++) { | ||
616 | |||
617 | ret = s3c24xx_register_clock(clkp); | ||
618 | if (ret < 0) { | ||
619 | printk(KERN_ERR "Failed to register clock %s (%d)\n", | ||
620 | clkp->name, ret); | ||
621 | } | ||
622 | (clkp->enable)(clkp, 0); | ||
623 | } | ||
624 | |||
625 | s3c_pwmclk_init(); | ||
626 | } | ||
diff --git a/arch/arm/mach-s5p64x0/clock-s5p6450.c b/arch/arm/mach-s5p64x0/clock-s5p6450.c new file mode 100644 index 000000000000..f9afb05b217c --- /dev/null +++ b/arch/arm/mach-s5p64x0/clock-s5p6450.c | |||
@@ -0,0 +1,655 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/clock-s5p6450.c | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P6450 - Clock support | ||
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/init.h> | ||
14 | #include <linux/module.h> | ||
15 | #include <linux/kernel.h> | ||
16 | #include <linux/list.h> | ||
17 | #include <linux/errno.h> | ||
18 | #include <linux/err.h> | ||
19 | #include <linux/clk.h> | ||
20 | #include <linux/sysdev.h> | ||
21 | #include <linux/io.h> | ||
22 | |||
23 | #include <mach/hardware.h> | ||
24 | #include <mach/map.h> | ||
25 | #include <mach/regs-clock.h> | ||
26 | #include <mach/s5p64x0-clock.h> | ||
27 | |||
28 | #include <plat/cpu-freq.h> | ||
29 | #include <plat/clock.h> | ||
30 | #include <plat/cpu.h> | ||
31 | #include <plat/pll.h> | ||
32 | #include <plat/s5p-clock.h> | ||
33 | #include <plat/clock-clksrc.h> | ||
34 | #include <plat/s5p6450.h> | ||
35 | |||
36 | static struct clksrc_clk clk_mout_dpll = { | ||
37 | .clk = { | ||
38 | .name = "mout_dpll", | ||
39 | .id = -1, | ||
40 | }, | ||
41 | .sources = &clk_src_dpll, | ||
42 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 5, .size = 1 }, | ||
43 | }; | ||
44 | |||
45 | static u32 epll_div[][5] = { | ||
46 | { 133000000, 27307, 55, 2, 2 }, | ||
47 | { 100000000, 43691, 41, 2, 2 }, | ||
48 | { 480000000, 0, 80, 2, 0 }, | ||
49 | }; | ||
50 | |||
51 | static int s5p6450_epll_set_rate(struct clk *clk, unsigned long rate) | ||
52 | { | ||
53 | unsigned int epll_con, epll_con_k; | ||
54 | unsigned int i; | ||
55 | |||
56 | if (clk->rate == rate) /* Return if nothing changed */ | ||
57 | return 0; | ||
58 | |||
59 | epll_con = __raw_readl(S5P64X0_EPLL_CON); | ||
60 | epll_con_k = __raw_readl(S5P64X0_EPLL_CON_K); | ||
61 | |||
62 | epll_con_k &= ~(PLL90XX_KDIV_MASK); | ||
63 | epll_con &= ~(PLL90XX_MDIV_MASK | PLL90XX_PDIV_MASK | PLL90XX_SDIV_MASK); | ||
64 | |||
65 | for (i = 0; i < ARRAY_SIZE(epll_div); i++) { | ||
66 | if (epll_div[i][0] == rate) { | ||
67 | epll_con_k |= (epll_div[i][1] << PLL90XX_KDIV_SHIFT); | ||
68 | epll_con |= (epll_div[i][2] << PLL90XX_MDIV_SHIFT) | | ||
69 | (epll_div[i][3] << PLL90XX_PDIV_SHIFT) | | ||
70 | (epll_div[i][4] << PLL90XX_SDIV_SHIFT); | ||
71 | break; | ||
72 | } | ||
73 | } | ||
74 | |||
75 | if (i == ARRAY_SIZE(epll_div)) { | ||
76 | printk(KERN_ERR "%s: Invalid Clock EPLL Frequency\n", __func__); | ||
77 | return -EINVAL; | ||
78 | } | ||
79 | |||
80 | __raw_writel(epll_con, S5P64X0_EPLL_CON); | ||
81 | __raw_writel(epll_con_k, S5P64X0_EPLL_CON_K); | ||
82 | |||
83 | clk->rate = rate; | ||
84 | |||
85 | return 0; | ||
86 | } | ||
87 | |||
88 | static struct clk_ops s5p6450_epll_ops = { | ||
89 | .get_rate = s5p64x0_epll_get_rate, | ||
90 | .set_rate = s5p6450_epll_set_rate, | ||
91 | }; | ||
92 | |||
93 | static struct clksrc_clk clk_dout_epll = { | ||
94 | .clk = { | ||
95 | .name = "dout_epll", | ||
96 | .id = -1, | ||
97 | .parent = &clk_mout_epll.clk, | ||
98 | }, | ||
99 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 24, .size = 4 }, | ||
100 | }; | ||
101 | |||
102 | static struct clksrc_clk clk_mout_hclk_sel = { | ||
103 | .clk = { | ||
104 | .name = "mout_hclk_sel", | ||
105 | .id = -1, | ||
106 | }, | ||
107 | .sources = &clkset_hclk_low, | ||
108 | .reg_src = { .reg = S5P64X0_OTHERS, .shift = 15, .size = 1 }, | ||
109 | }; | ||
110 | |||
111 | static struct clk *clkset_hclk_list[] = { | ||
112 | &clk_mout_hclk_sel.clk, | ||
113 | &clk_armclk.clk, | ||
114 | }; | ||
115 | |||
116 | static struct clksrc_sources clkset_hclk = { | ||
117 | .sources = clkset_hclk_list, | ||
118 | .nr_sources = ARRAY_SIZE(clkset_hclk_list), | ||
119 | }; | ||
120 | |||
121 | static struct clksrc_clk clk_hclk = { | ||
122 | .clk = { | ||
123 | .name = "clk_hclk", | ||
124 | .id = -1, | ||
125 | }, | ||
126 | .sources = &clkset_hclk, | ||
127 | .reg_src = { .reg = S5P64X0_OTHERS, .shift = 14, .size = 1 }, | ||
128 | .reg_div = { .reg = S5P64X0_CLK_DIV0, .shift = 8, .size = 4 }, | ||
129 | }; | ||
130 | |||
131 | static struct clksrc_clk clk_pclk = { | ||
132 | .clk = { | ||
133 | .name = "clk_pclk", | ||
134 | .id = -1, | ||
135 | .parent = &clk_hclk.clk, | ||
136 | }, | ||
137 | .reg_div = { .reg = S5P64X0_CLK_DIV0, .shift = 12, .size = 4 }, | ||
138 | }; | ||
139 | static struct clksrc_clk clk_dout_pwm_ratio0 = { | ||
140 | .clk = { | ||
141 | .name = "clk_dout_pwm_ratio0", | ||
142 | .id = -1, | ||
143 | .parent = &clk_mout_hclk_sel.clk, | ||
144 | }, | ||
145 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 16, .size = 4 }, | ||
146 | }; | ||
147 | |||
148 | static struct clksrc_clk clk_pclk_to_wdt_pwm = { | ||
149 | .clk = { | ||
150 | .name = "clk_pclk_to_wdt_pwm", | ||
151 | .id = -1, | ||
152 | .parent = &clk_dout_pwm_ratio0.clk, | ||
153 | }, | ||
154 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 20, .size = 4 }, | ||
155 | }; | ||
156 | |||
157 | static struct clksrc_clk clk_hclk_low = { | ||
158 | .clk = { | ||
159 | .name = "clk_hclk_low", | ||
160 | .id = -1, | ||
161 | }, | ||
162 | .sources = &clkset_hclk_low, | ||
163 | .reg_src = { .reg = S5P64X0_OTHERS, .shift = 6, .size = 1 }, | ||
164 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 8, .size = 4 }, | ||
165 | }; | ||
166 | |||
167 | static struct clksrc_clk clk_pclk_low = { | ||
168 | .clk = { | ||
169 | .name = "clk_pclk_low", | ||
170 | .id = -1, | ||
171 | .parent = &clk_hclk_low.clk, | ||
172 | }, | ||
173 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 12, .size = 4 }, | ||
174 | }; | ||
175 | |||
176 | /* | ||
177 | * The following clocks will be disabled during clock initialization. It is | ||
178 | * recommended to keep the following clocks disabled until the driver requests | ||
179 | * for enabling the clock. | ||
180 | */ | ||
181 | static struct clk init_clocks_disable[] = { | ||
182 | { | ||
183 | .name = "usbhost", | ||
184 | .id = -1, | ||
185 | .parent = &clk_hclk_low.clk, | ||
186 | .enable = s5p64x0_hclk0_ctrl, | ||
187 | .ctrlbit = (1 << 3), | ||
188 | }, { | ||
189 | .name = "hsmmc", | ||
190 | .id = 0, | ||
191 | .parent = &clk_hclk_low.clk, | ||
192 | .enable = s5p64x0_hclk0_ctrl, | ||
193 | .ctrlbit = (1 << 17), | ||
194 | }, { | ||
195 | .name = "hsmmc", | ||
196 | .id = 1, | ||
197 | .parent = &clk_hclk_low.clk, | ||
198 | .enable = s5p64x0_hclk0_ctrl, | ||
199 | .ctrlbit = (1 << 18), | ||
200 | }, { | ||
201 | .name = "hsmmc", | ||
202 | .id = 2, | ||
203 | .parent = &clk_hclk_low.clk, | ||
204 | .enable = s5p64x0_hclk0_ctrl, | ||
205 | .ctrlbit = (1 << 19), | ||
206 | }, { | ||
207 | .name = "usbotg", | ||
208 | .id = -1, | ||
209 | .parent = &clk_hclk_low.clk, | ||
210 | .enable = s5p64x0_hclk0_ctrl, | ||
211 | .ctrlbit = (1 << 20), | ||
212 | }, { | ||
213 | .name = "lcd", | ||
214 | .id = -1, | ||
215 | .parent = &clk_h, | ||
216 | .enable = s5p64x0_hclk1_ctrl, | ||
217 | .ctrlbit = (1 << 1), | ||
218 | }, { | ||
219 | .name = "watchdog", | ||
220 | .id = -1, | ||
221 | .parent = &clk_pclk_low.clk, | ||
222 | .enable = s5p64x0_pclk_ctrl, | ||
223 | .ctrlbit = (1 << 5), | ||
224 | }, { | ||
225 | .name = "adc", | ||
226 | .id = -1, | ||
227 | .parent = &clk_pclk_low.clk, | ||
228 | .enable = s5p64x0_pclk_ctrl, | ||
229 | .ctrlbit = (1 << 12), | ||
230 | }, { | ||
231 | .name = "i2c", | ||
232 | .id = 0, | ||
233 | .parent = &clk_pclk_low.clk, | ||
234 | .enable = s5p64x0_pclk_ctrl, | ||
235 | .ctrlbit = (1 << 17), | ||
236 | }, { | ||
237 | .name = "spi", | ||
238 | .id = 0, | ||
239 | .parent = &clk_pclk_low.clk, | ||
240 | .enable = s5p64x0_pclk_ctrl, | ||
241 | .ctrlbit = (1 << 21), | ||
242 | }, { | ||
243 | .name = "spi", | ||
244 | .id = 1, | ||
245 | .parent = &clk_pclk_low.clk, | ||
246 | .enable = s5p64x0_pclk_ctrl, | ||
247 | .ctrlbit = (1 << 22), | ||
248 | }, { | ||
249 | .name = "iis", | ||
250 | .id = -1, | ||
251 | .parent = &clk_pclk_low.clk, | ||
252 | .enable = s5p64x0_pclk_ctrl, | ||
253 | .ctrlbit = (1 << 26), | ||
254 | }, { | ||
255 | .name = "i2c", | ||
256 | .id = 1, | ||
257 | .parent = &clk_pclk_low.clk, | ||
258 | .enable = s5p64x0_pclk_ctrl, | ||
259 | .ctrlbit = (1 << 27), | ||
260 | }, { | ||
261 | .name = "dmc0", | ||
262 | .id = -1, | ||
263 | .parent = &clk_pclk.clk, | ||
264 | .enable = s5p64x0_pclk_ctrl, | ||
265 | .ctrlbit = (1 << 30), | ||
266 | } | ||
267 | }; | ||
268 | |||
269 | /* | ||
270 | * The following clocks will be enabled during clock initialization. | ||
271 | */ | ||
272 | static struct clk init_clocks[] = { | ||
273 | { | ||
274 | .name = "intc", | ||
275 | .id = -1, | ||
276 | .parent = &clk_hclk.clk, | ||
277 | .enable = s5p64x0_hclk0_ctrl, | ||
278 | .ctrlbit = (1 << 1), | ||
279 | }, { | ||
280 | .name = "mem", | ||
281 | .id = -1, | ||
282 | .parent = &clk_hclk.clk, | ||
283 | .enable = s5p64x0_hclk0_ctrl, | ||
284 | .ctrlbit = (1 << 21), | ||
285 | }, { | ||
286 | .name = "dma", | ||
287 | .id = -1, | ||
288 | .parent = &clk_hclk_low.clk, | ||
289 | .enable = s5p64x0_hclk0_ctrl, | ||
290 | .ctrlbit = (1 << 12), | ||
291 | }, { | ||
292 | .name = "uart", | ||
293 | .id = 0, | ||
294 | .parent = &clk_pclk_low.clk, | ||
295 | .enable = s5p64x0_pclk_ctrl, | ||
296 | .ctrlbit = (1 << 1), | ||
297 | }, { | ||
298 | .name = "uart", | ||
299 | .id = 1, | ||
300 | .parent = &clk_pclk_low.clk, | ||
301 | .enable = s5p64x0_pclk_ctrl, | ||
302 | .ctrlbit = (1 << 2), | ||
303 | }, { | ||
304 | .name = "uart", | ||
305 | .id = 2, | ||
306 | .parent = &clk_pclk_low.clk, | ||
307 | .enable = s5p64x0_pclk_ctrl, | ||
308 | .ctrlbit = (1 << 3), | ||
309 | }, { | ||
310 | .name = "uart", | ||
311 | .id = 3, | ||
312 | .parent = &clk_pclk_low.clk, | ||
313 | .enable = s5p64x0_pclk_ctrl, | ||
314 | .ctrlbit = (1 << 4), | ||
315 | }, { | ||
316 | .name = "timers", | ||
317 | .id = -1, | ||
318 | .parent = &clk_pclk_to_wdt_pwm.clk, | ||
319 | .enable = s5p64x0_pclk_ctrl, | ||
320 | .ctrlbit = (1 << 7), | ||
321 | }, { | ||
322 | .name = "gpio", | ||
323 | .id = -1, | ||
324 | .parent = &clk_pclk_low.clk, | ||
325 | .enable = s5p64x0_pclk_ctrl, | ||
326 | .ctrlbit = (1 << 18), | ||
327 | }, | ||
328 | }; | ||
329 | |||
330 | static struct clk *clkset_uart_list[] = { | ||
331 | &clk_dout_epll.clk, | ||
332 | &clk_dout_mpll.clk, | ||
333 | }; | ||
334 | |||
335 | static struct clksrc_sources clkset_uart = { | ||
336 | .sources = clkset_uart_list, | ||
337 | .nr_sources = ARRAY_SIZE(clkset_uart_list), | ||
338 | }; | ||
339 | |||
340 | static struct clk *clkset_mali_list[] = { | ||
341 | &clk_mout_epll.clk, | ||
342 | &clk_mout_apll.clk, | ||
343 | &clk_mout_mpll.clk, | ||
344 | }; | ||
345 | |||
346 | static struct clksrc_sources clkset_mali = { | ||
347 | .sources = clkset_mali_list, | ||
348 | .nr_sources = ARRAY_SIZE(clkset_mali_list), | ||
349 | }; | ||
350 | |||
351 | static struct clk *clkset_group2_list[] = { | ||
352 | &clk_dout_epll.clk, | ||
353 | &clk_dout_mpll.clk, | ||
354 | &clk_ext_xtal_mux, | ||
355 | }; | ||
356 | |||
357 | static struct clksrc_sources clkset_group2 = { | ||
358 | .sources = clkset_group2_list, | ||
359 | .nr_sources = ARRAY_SIZE(clkset_group2_list), | ||
360 | }; | ||
361 | |||
362 | static struct clk *clkset_dispcon_list[] = { | ||
363 | &clk_dout_epll.clk, | ||
364 | &clk_dout_mpll.clk, | ||
365 | &clk_ext_xtal_mux, | ||
366 | &clk_mout_dpll.clk, | ||
367 | }; | ||
368 | |||
369 | static struct clksrc_sources clkset_dispcon = { | ||
370 | .sources = clkset_dispcon_list, | ||
371 | .nr_sources = ARRAY_SIZE(clkset_dispcon_list), | ||
372 | }; | ||
373 | |||
374 | static struct clk *clkset_hsmmc44_list[] = { | ||
375 | &clk_dout_epll.clk, | ||
376 | &clk_dout_mpll.clk, | ||
377 | &clk_ext_xtal_mux, | ||
378 | &s5p_clk_27m, | ||
379 | &clk_48m, | ||
380 | }; | ||
381 | |||
382 | static struct clksrc_sources clkset_hsmmc44 = { | ||
383 | .sources = clkset_hsmmc44_list, | ||
384 | .nr_sources = ARRAY_SIZE(clkset_hsmmc44_list), | ||
385 | }; | ||
386 | |||
387 | static struct clk *clkset_sclk_audio0_list[] = { | ||
388 | [0] = &clk_dout_epll.clk, | ||
389 | [1] = &clk_dout_mpll.clk, | ||
390 | [2] = &clk_ext_xtal_mux, | ||
391 | [3] = NULL, | ||
392 | [4] = NULL, | ||
393 | }; | ||
394 | |||
395 | static struct clksrc_sources clkset_sclk_audio0 = { | ||
396 | .sources = clkset_sclk_audio0_list, | ||
397 | .nr_sources = ARRAY_SIZE(clkset_sclk_audio0_list), | ||
398 | }; | ||
399 | |||
400 | static struct clksrc_clk clk_sclk_audio0 = { | ||
401 | .clk = { | ||
402 | .name = "audio-bus", | ||
403 | .id = -1, | ||
404 | .enable = s5p64x0_sclk_ctrl, | ||
405 | .ctrlbit = (1 << 8), | ||
406 | .parent = &clk_dout_epll.clk, | ||
407 | }, | ||
408 | .sources = &clkset_sclk_audio0, | ||
409 | .reg_src = { .reg = S5P64X0_CLK_SRC1, .shift = 10, .size = 3 }, | ||
410 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 8, .size = 4 }, | ||
411 | }; | ||
412 | |||
413 | static struct clksrc_clk clksrcs[] = { | ||
414 | { | ||
415 | .clk = { | ||
416 | .name = "sclk_mmc", | ||
417 | .id = 0, | ||
418 | .ctrlbit = (1 << 24), | ||
419 | .enable = s5p64x0_sclk_ctrl, | ||
420 | }, | ||
421 | .sources = &clkset_group2, | ||
422 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 18, .size = 2 }, | ||
423 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 0, .size = 4 }, | ||
424 | }, { | ||
425 | .clk = { | ||
426 | .name = "sclk_mmc", | ||
427 | .id = 1, | ||
428 | .ctrlbit = (1 << 25), | ||
429 | .enable = s5p64x0_sclk_ctrl, | ||
430 | }, | ||
431 | .sources = &clkset_group2, | ||
432 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 20, .size = 2 }, | ||
433 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 4, .size = 4 }, | ||
434 | }, { | ||
435 | .clk = { | ||
436 | .name = "sclk_mmc", | ||
437 | .id = 2, | ||
438 | .ctrlbit = (1 << 26), | ||
439 | .enable = s5p64x0_sclk_ctrl, | ||
440 | }, | ||
441 | .sources = &clkset_group2, | ||
442 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 22, .size = 2 }, | ||
443 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 8, .size = 4 }, | ||
444 | }, { | ||
445 | .clk = { | ||
446 | .name = "uclk1", | ||
447 | .id = -1, | ||
448 | .ctrlbit = (1 << 5), | ||
449 | .enable = s5p64x0_sclk_ctrl, | ||
450 | }, | ||
451 | .sources = &clkset_uart, | ||
452 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 13, .size = 1 }, | ||
453 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 16, .size = 4 }, | ||
454 | }, { | ||
455 | .clk = { | ||
456 | .name = "sclk_spi", | ||
457 | .id = 0, | ||
458 | .ctrlbit = (1 << 20), | ||
459 | .enable = s5p64x0_sclk_ctrl, | ||
460 | }, | ||
461 | .sources = &clkset_group2, | ||
462 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 14, .size = 2 }, | ||
463 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 0, .size = 4 }, | ||
464 | }, { | ||
465 | .clk = { | ||
466 | .name = "sclk_spi", | ||
467 | .id = 1, | ||
468 | .ctrlbit = (1 << 21), | ||
469 | .enable = s5p64x0_sclk_ctrl, | ||
470 | }, | ||
471 | .sources = &clkset_group2, | ||
472 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 16, .size = 2 }, | ||
473 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 4, .size = 4 }, | ||
474 | }, { | ||
475 | .clk = { | ||
476 | .name = "sclk_fimc", | ||
477 | .id = -1, | ||
478 | .ctrlbit = (1 << 10), | ||
479 | .enable = s5p64x0_sclk_ctrl, | ||
480 | }, | ||
481 | .sources = &clkset_group2, | ||
482 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 26, .size = 2 }, | ||
483 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 12, .size = 4 }, | ||
484 | }, { | ||
485 | .clk = { | ||
486 | .name = "aclk_mali", | ||
487 | .id = -1, | ||
488 | .ctrlbit = (1 << 2), | ||
489 | .enable = s5p64x0_sclk1_ctrl, | ||
490 | }, | ||
491 | .sources = &clkset_mali, | ||
492 | .reg_src = { .reg = S5P64X0_CLK_SRC1, .shift = 8, .size = 2 }, | ||
493 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 4, .size = 4 }, | ||
494 | }, { | ||
495 | .clk = { | ||
496 | .name = "sclk_2d", | ||
497 | .id = -1, | ||
498 | .ctrlbit = (1 << 12), | ||
499 | .enable = s5p64x0_sclk_ctrl, | ||
500 | }, | ||
501 | .sources = &clkset_mali, | ||
502 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 30, .size = 2 }, | ||
503 | .reg_div = { .reg = S5P64X0_CLK_DIV2, .shift = 20, .size = 4 }, | ||
504 | }, { | ||
505 | .clk = { | ||
506 | .name = "sclk_usi", | ||
507 | .id = -1, | ||
508 | .ctrlbit = (1 << 7), | ||
509 | .enable = s5p64x0_sclk_ctrl, | ||
510 | }, | ||
511 | .sources = &clkset_group2, | ||
512 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 10, .size = 2 }, | ||
513 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 16, .size = 4 }, | ||
514 | }, { | ||
515 | .clk = { | ||
516 | .name = "sclk_camif", | ||
517 | .id = -1, | ||
518 | .ctrlbit = (1 << 6), | ||
519 | .enable = s5p64x0_sclk_ctrl, | ||
520 | }, | ||
521 | .sources = &clkset_group2, | ||
522 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 28, .size = 2 }, | ||
523 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 20, .size = 4 }, | ||
524 | }, { | ||
525 | .clk = { | ||
526 | .name = "sclk_dispcon", | ||
527 | .id = -1, | ||
528 | .ctrlbit = (1 << 1), | ||
529 | .enable = s5p64x0_sclk1_ctrl, | ||
530 | }, | ||
531 | .sources = &clkset_dispcon, | ||
532 | .reg_src = { .reg = S5P64X0_CLK_SRC1, .shift = 4, .size = 2 }, | ||
533 | .reg_div = { .reg = S5P64X0_CLK_DIV3, .shift = 0, .size = 4 }, | ||
534 | }, { | ||
535 | .clk = { | ||
536 | .name = "sclk_hsmmc44", | ||
537 | .id = -1, | ||
538 | .ctrlbit = (1 << 30), | ||
539 | .enable = s5p64x0_sclk_ctrl, | ||
540 | }, | ||
541 | .sources = &clkset_hsmmc44, | ||
542 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 6, .size = 3 }, | ||
543 | .reg_div = { .reg = S5P64X0_CLK_DIV1, .shift = 28, .size = 4 }, | ||
544 | }, | ||
545 | }; | ||
546 | |||
547 | /* Clock initialization code */ | ||
548 | static struct clksrc_clk *sysclks[] = { | ||
549 | &clk_mout_apll, | ||
550 | &clk_mout_epll, | ||
551 | &clk_dout_epll, | ||
552 | &clk_mout_mpll, | ||
553 | &clk_dout_mpll, | ||
554 | &clk_armclk, | ||
555 | &clk_mout_hclk_sel, | ||
556 | &clk_dout_pwm_ratio0, | ||
557 | &clk_pclk_to_wdt_pwm, | ||
558 | &clk_hclk, | ||
559 | &clk_pclk, | ||
560 | &clk_hclk_low, | ||
561 | &clk_pclk_low, | ||
562 | &clk_sclk_audio0, | ||
563 | }; | ||
564 | |||
565 | void __init_or_cpufreq s5p6450_setup_clocks(void) | ||
566 | { | ||
567 | struct clk *xtal_clk; | ||
568 | |||
569 | unsigned long xtal; | ||
570 | unsigned long fclk; | ||
571 | unsigned long hclk; | ||
572 | unsigned long hclk_low; | ||
573 | unsigned long pclk; | ||
574 | unsigned long pclk_low; | ||
575 | |||
576 | unsigned long apll; | ||
577 | unsigned long mpll; | ||
578 | unsigned long epll; | ||
579 | unsigned long dpll; | ||
580 | unsigned int ptr; | ||
581 | |||
582 | /* Set S5P6450 functions for clk_fout_epll */ | ||
583 | |||
584 | clk_fout_epll.enable = s5p64x0_epll_enable; | ||
585 | clk_fout_epll.ops = &s5p6450_epll_ops; | ||
586 | |||
587 | clk_48m.enable = s5p64x0_clk48m_ctrl; | ||
588 | |||
589 | xtal_clk = clk_get(NULL, "ext_xtal"); | ||
590 | BUG_ON(IS_ERR(xtal_clk)); | ||
591 | |||
592 | xtal = clk_get_rate(xtal_clk); | ||
593 | clk_put(xtal_clk); | ||
594 | |||
595 | apll = s5p_get_pll45xx(xtal, __raw_readl(S5P64X0_APLL_CON), pll_4502); | ||
596 | mpll = s5p_get_pll45xx(xtal, __raw_readl(S5P64X0_MPLL_CON), pll_4502); | ||
597 | epll = s5p_get_pll90xx(xtal, __raw_readl(S5P64X0_EPLL_CON), | ||
598 | __raw_readl(S5P64X0_EPLL_CON_K)); | ||
599 | dpll = s5p_get_pll46xx(xtal, __raw_readl(S5P6450_DPLL_CON), | ||
600 | __raw_readl(S5P6450_DPLL_CON_K), pll_4650c); | ||
601 | |||
602 | clk_fout_apll.rate = apll; | ||
603 | clk_fout_mpll.rate = mpll; | ||
604 | clk_fout_epll.rate = epll; | ||
605 | clk_fout_dpll.rate = dpll; | ||
606 | |||
607 | printk(KERN_INFO "S5P6450: PLL settings, A=%ld.%ldMHz, M=%ld.%ldMHz," \ | ||
608 | " E=%ld.%ldMHz, D=%ld.%ldMHz\n", | ||
609 | print_mhz(apll), print_mhz(mpll), print_mhz(epll), | ||
610 | print_mhz(dpll)); | ||
611 | |||
612 | fclk = clk_get_rate(&clk_armclk.clk); | ||
613 | hclk = clk_get_rate(&clk_hclk.clk); | ||
614 | pclk = clk_get_rate(&clk_pclk.clk); | ||
615 | hclk_low = clk_get_rate(&clk_hclk_low.clk); | ||
616 | pclk_low = clk_get_rate(&clk_pclk_low.clk); | ||
617 | |||
618 | printk(KERN_INFO "S5P6450: HCLK=%ld.%ldMHz, HCLK_LOW=%ld.%ldMHz," \ | ||
619 | " PCLK=%ld.%ldMHz, PCLK_LOW=%ld.%ldMHz\n", | ||
620 | print_mhz(hclk), print_mhz(hclk_low), | ||
621 | print_mhz(pclk), print_mhz(pclk_low)); | ||
622 | |||
623 | clk_f.rate = fclk; | ||
624 | clk_h.rate = hclk; | ||
625 | clk_p.rate = pclk; | ||
626 | |||
627 | for (ptr = 0; ptr < ARRAY_SIZE(clksrcs); ptr++) | ||
628 | s3c_set_clksrc(&clksrcs[ptr], true); | ||
629 | } | ||
630 | |||
631 | void __init s5p6450_register_clocks(void) | ||
632 | { | ||
633 | struct clk *clkp; | ||
634 | int ret; | ||
635 | int ptr; | ||
636 | |||
637 | for (ptr = 0; ptr < ARRAY_SIZE(sysclks); ptr++) | ||
638 | s3c_register_clksrc(sysclks[ptr], 1); | ||
639 | |||
640 | s3c_register_clksrc(clksrcs, ARRAY_SIZE(clksrcs)); | ||
641 | s3c_register_clocks(init_clocks, ARRAY_SIZE(init_clocks)); | ||
642 | |||
643 | clkp = init_clocks_disable; | ||
644 | for (ptr = 0; ptr < ARRAY_SIZE(init_clocks_disable); ptr++, clkp++) { | ||
645 | |||
646 | ret = s3c24xx_register_clock(clkp); | ||
647 | if (ret < 0) { | ||
648 | printk(KERN_ERR "Failed to register clock %s (%d)\n", | ||
649 | clkp->name, ret); | ||
650 | } | ||
651 | (clkp->enable)(clkp, 0); | ||
652 | } | ||
653 | |||
654 | s3c_pwmclk_init(); | ||
655 | } | ||
diff --git a/arch/arm/mach-s5p64x0/clock.c b/arch/arm/mach-s5p64x0/clock.c new file mode 100644 index 000000000000..523ba8039ac2 --- /dev/null +++ b/arch/arm/mach-s5p64x0/clock.c | |||
@@ -0,0 +1,253 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/clock.c | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - Clock support | ||
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/init.h> | ||
14 | #include <linux/module.h> | ||
15 | #include <linux/kernel.h> | ||
16 | #include <linux/list.h> | ||
17 | #include <linux/errno.h> | ||
18 | #include <linux/err.h> | ||
19 | #include <linux/clk.h> | ||
20 | #include <linux/sysdev.h> | ||
21 | #include <linux/io.h> | ||
22 | |||
23 | #include <mach/hardware.h> | ||
24 | #include <mach/map.h> | ||
25 | #include <mach/regs-clock.h> | ||
26 | |||
27 | #include <plat/cpu-freq.h> | ||
28 | #include <plat/clock.h> | ||
29 | #include <plat/cpu.h> | ||
30 | #include <plat/pll.h> | ||
31 | #include <plat/s5p-clock.h> | ||
32 | #include <plat/clock-clksrc.h> | ||
33 | #include <plat/s5p6440.h> | ||
34 | #include <plat/s5p6450.h> | ||
35 | |||
36 | struct clksrc_clk clk_mout_apll = { | ||
37 | .clk = { | ||
38 | .name = "mout_apll", | ||
39 | .id = -1, | ||
40 | }, | ||
41 | .sources = &clk_src_apll, | ||
42 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 0, .size = 1 }, | ||
43 | }; | ||
44 | |||
45 | struct clksrc_clk clk_mout_mpll = { | ||
46 | .clk = { | ||
47 | .name = "mout_mpll", | ||
48 | .id = -1, | ||
49 | }, | ||
50 | .sources = &clk_src_mpll, | ||
51 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 1, .size = 1 }, | ||
52 | }; | ||
53 | |||
54 | struct clksrc_clk clk_mout_epll = { | ||
55 | .clk = { | ||
56 | .name = "mout_epll", | ||
57 | .id = -1, | ||
58 | }, | ||
59 | .sources = &clk_src_epll, | ||
60 | .reg_src = { .reg = S5P64X0_CLK_SRC0, .shift = 2, .size = 1 }, | ||
61 | }; | ||
62 | |||
63 | enum perf_level { | ||
64 | L0 = 532*1000, | ||
65 | L1 = 266*1000, | ||
66 | L2 = 133*1000, | ||
67 | }; | ||
68 | |||
69 | static const u32 clock_table[][3] = { | ||
70 | /*{ARM_CLK, DIVarm, DIVhclk}*/ | ||
71 | {L0 * 1000, (0 << ARM_DIV_RATIO_SHIFT), (3 << S5P64X0_CLKDIV0_HCLK_SHIFT)}, | ||
72 | {L1 * 1000, (1 << ARM_DIV_RATIO_SHIFT), (1 << S5P64X0_CLKDIV0_HCLK_SHIFT)}, | ||
73 | {L2 * 1000, (3 << ARM_DIV_RATIO_SHIFT), (0 << S5P64X0_CLKDIV0_HCLK_SHIFT)}, | ||
74 | }; | ||
75 | |||
76 | int s5p64x0_epll_enable(struct clk *clk, int enable) | ||
77 | { | ||
78 | unsigned int ctrlbit = clk->ctrlbit; | ||
79 | unsigned int epll_con = __raw_readl(S5P64X0_EPLL_CON) & ~ctrlbit; | ||
80 | |||
81 | if (enable) | ||
82 | __raw_writel(epll_con | ctrlbit, S5P64X0_EPLL_CON); | ||
83 | else | ||
84 | __raw_writel(epll_con, S5P64X0_EPLL_CON); | ||
85 | |||
86 | return 0; | ||
87 | } | ||
88 | |||
89 | unsigned long s5p64x0_epll_get_rate(struct clk *clk) | ||
90 | { | ||
91 | return clk->rate; | ||
92 | } | ||
93 | |||
94 | unsigned long s5p64x0_armclk_get_rate(struct clk *clk) | ||
95 | { | ||
96 | unsigned long rate = clk_get_rate(clk->parent); | ||
97 | u32 clkdiv; | ||
98 | |||
99 | /* divisor mask starts at bit0, so no need to shift */ | ||
100 | clkdiv = __raw_readl(ARM_CLK_DIV) & ARM_DIV_MASK; | ||
101 | |||
102 | return rate / (clkdiv + 1); | ||
103 | } | ||
104 | |||
105 | unsigned long s5p64x0_armclk_round_rate(struct clk *clk, unsigned long rate) | ||
106 | { | ||
107 | u32 iter; | ||
108 | |||
109 | for (iter = 1 ; iter < ARRAY_SIZE(clock_table) ; iter++) { | ||
110 | if (rate > clock_table[iter][0]) | ||
111 | return clock_table[iter-1][0]; | ||
112 | } | ||
113 | |||
114 | return clock_table[ARRAY_SIZE(clock_table) - 1][0]; | ||
115 | } | ||
116 | |||
117 | int s5p64x0_armclk_set_rate(struct clk *clk, unsigned long rate) | ||
118 | { | ||
119 | u32 round_tmp; | ||
120 | u32 iter; | ||
121 | u32 clk_div0_tmp; | ||
122 | u32 cur_rate = clk->ops->get_rate(clk); | ||
123 | unsigned long flags; | ||
124 | |||
125 | round_tmp = clk->ops->round_rate(clk, rate); | ||
126 | if (round_tmp == cur_rate) | ||
127 | return 0; | ||
128 | |||
129 | |||
130 | for (iter = 0 ; iter < ARRAY_SIZE(clock_table) ; iter++) { | ||
131 | if (round_tmp == clock_table[iter][0]) | ||
132 | break; | ||
133 | } | ||
134 | |||
135 | if (iter >= ARRAY_SIZE(clock_table)) | ||
136 | iter = ARRAY_SIZE(clock_table) - 1; | ||
137 | |||
138 | local_irq_save(flags); | ||
139 | if (cur_rate > round_tmp) { | ||
140 | /* Frequency Down */ | ||
141 | clk_div0_tmp = __raw_readl(ARM_CLK_DIV) & ~(ARM_DIV_MASK); | ||
142 | clk_div0_tmp |= clock_table[iter][1]; | ||
143 | __raw_writel(clk_div0_tmp, ARM_CLK_DIV); | ||
144 | |||
145 | clk_div0_tmp = __raw_readl(ARM_CLK_DIV) & | ||
146 | ~(S5P64X0_CLKDIV0_HCLK_MASK); | ||
147 | clk_div0_tmp |= clock_table[iter][2]; | ||
148 | __raw_writel(clk_div0_tmp, ARM_CLK_DIV); | ||
149 | |||
150 | |||
151 | } else { | ||
152 | /* Frequency Up */ | ||
153 | clk_div0_tmp = __raw_readl(ARM_CLK_DIV) & | ||
154 | ~(S5P64X0_CLKDIV0_HCLK_MASK); | ||
155 | clk_div0_tmp |= clock_table[iter][2]; | ||
156 | __raw_writel(clk_div0_tmp, ARM_CLK_DIV); | ||
157 | |||
158 | clk_div0_tmp = __raw_readl(ARM_CLK_DIV) & ~(ARM_DIV_MASK); | ||
159 | clk_div0_tmp |= clock_table[iter][1]; | ||
160 | __raw_writel(clk_div0_tmp, ARM_CLK_DIV); | ||
161 | } | ||
162 | local_irq_restore(flags); | ||
163 | |||
164 | clk->rate = clock_table[iter][0]; | ||
165 | |||
166 | return 0; | ||
167 | } | ||
168 | |||
169 | struct clk_ops s5p64x0_clkarm_ops = { | ||
170 | .get_rate = s5p64x0_armclk_get_rate, | ||
171 | .set_rate = s5p64x0_armclk_set_rate, | ||
172 | .round_rate = s5p64x0_armclk_round_rate, | ||
173 | }; | ||
174 | |||
175 | struct clksrc_clk clk_armclk = { | ||
176 | .clk = { | ||
177 | .name = "armclk", | ||
178 | .id = 1, | ||
179 | .parent = &clk_mout_apll.clk, | ||
180 | .ops = &s5p64x0_clkarm_ops, | ||
181 | }, | ||
182 | .reg_div = { .reg = S5P64X0_CLK_DIV0, .shift = 0, .size = 4 }, | ||
183 | }; | ||
184 | |||
185 | struct clksrc_clk clk_dout_mpll = { | ||
186 | .clk = { | ||
187 | .name = "dout_mpll", | ||
188 | .id = -1, | ||
189 | .parent = &clk_mout_mpll.clk, | ||
190 | }, | ||
191 | .reg_div = { .reg = S5P64X0_CLK_DIV0, .shift = 4, .size = 1 }, | ||
192 | }; | ||
193 | |||
194 | struct clk *clkset_hclk_low_list[] = { | ||
195 | &clk_mout_apll.clk, | ||
196 | &clk_mout_mpll.clk, | ||
197 | }; | ||
198 | |||
199 | struct clksrc_sources clkset_hclk_low = { | ||
200 | .sources = clkset_hclk_low_list, | ||
201 | .nr_sources = ARRAY_SIZE(clkset_hclk_low_list), | ||
202 | }; | ||
203 | |||
204 | int s5p64x0_pclk_ctrl(struct clk *clk, int enable) | ||
205 | { | ||
206 | return s5p_gatectrl(S5P64X0_CLK_GATE_PCLK, clk, enable); | ||
207 | } | ||
208 | |||
209 | int s5p64x0_hclk0_ctrl(struct clk *clk, int enable) | ||
210 | { | ||
211 | return s5p_gatectrl(S5P64X0_CLK_GATE_HCLK0, clk, enable); | ||
212 | } | ||
213 | |||
214 | int s5p64x0_hclk1_ctrl(struct clk *clk, int enable) | ||
215 | { | ||
216 | return s5p_gatectrl(S5P64X0_CLK_GATE_HCLK1, clk, enable); | ||
217 | } | ||
218 | |||
219 | int s5p64x0_sclk_ctrl(struct clk *clk, int enable) | ||
220 | { | ||
221 | return s5p_gatectrl(S5P64X0_CLK_GATE_SCLK0, clk, enable); | ||
222 | } | ||
223 | |||
224 | int s5p64x0_sclk1_ctrl(struct clk *clk, int enable) | ||
225 | { | ||
226 | return s5p_gatectrl(S5P64X0_CLK_GATE_SCLK1, clk, enable); | ||
227 | } | ||
228 | |||
229 | int s5p64x0_mem_ctrl(struct clk *clk, int enable) | ||
230 | { | ||
231 | return s5p_gatectrl(S5P64X0_CLK_GATE_MEM0, clk, enable); | ||
232 | } | ||
233 | |||
234 | int s5p64x0_clk48m_ctrl(struct clk *clk, int enable) | ||
235 | { | ||
236 | unsigned long flags; | ||
237 | u32 val; | ||
238 | |||
239 | /* can't rely on clock lock, this register has other usages */ | ||
240 | local_irq_save(flags); | ||
241 | |||
242 | val = __raw_readl(S5P64X0_OTHERS); | ||
243 | if (enable) | ||
244 | val |= S5P64X0_OTHERS_USB_SIG_MASK; | ||
245 | else | ||
246 | val &= ~S5P64X0_OTHERS_USB_SIG_MASK; | ||
247 | |||
248 | __raw_writel(val, S5P64X0_OTHERS); | ||
249 | |||
250 | local_irq_restore(flags); | ||
251 | |||
252 | return 0; | ||
253 | } | ||
diff --git a/arch/arm/mach-s5p64x0/cpu.c b/arch/arm/mach-s5p64x0/cpu.c new file mode 100644 index 000000000000..b8d02eb4cf30 --- /dev/null +++ b/arch/arm/mach-s5p64x0/cpu.c | |||
@@ -0,0 +1,209 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/cpu.c | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
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 | |||
11 | #include <linux/kernel.h> | ||
12 | #include <linux/types.h> | ||
13 | #include <linux/interrupt.h> | ||
14 | #include <linux/list.h> | ||
15 | #include <linux/timer.h> | ||
16 | #include <linux/init.h> | ||
17 | #include <linux/clk.h> | ||
18 | #include <linux/io.h> | ||
19 | #include <linux/sysdev.h> | ||
20 | #include <linux/serial_core.h> | ||
21 | #include <linux/platform_device.h> | ||
22 | #include <linux/sched.h> | ||
23 | |||
24 | #include <asm/mach/arch.h> | ||
25 | #include <asm/mach/map.h> | ||
26 | #include <asm/mach/irq.h> | ||
27 | #include <asm/proc-fns.h> | ||
28 | #include <asm/irq.h> | ||
29 | |||
30 | #include <mach/hardware.h> | ||
31 | #include <mach/map.h> | ||
32 | #include <mach/regs-clock.h> | ||
33 | |||
34 | #include <plat/regs-serial.h> | ||
35 | #include <plat/cpu.h> | ||
36 | #include <plat/devs.h> | ||
37 | #include <plat/clock.h> | ||
38 | #include <plat/s5p6440.h> | ||
39 | #include <plat/s5p6450.h> | ||
40 | #include <plat/adc-core.h> | ||
41 | |||
42 | /* Initial IO mappings */ | ||
43 | |||
44 | static struct map_desc s5p64x0_iodesc[] __initdata = { | ||
45 | { | ||
46 | .virtual = (unsigned long)S5P_VA_GPIO, | ||
47 | .pfn = __phys_to_pfn(S5P64X0_PA_GPIO), | ||
48 | .length = SZ_4K, | ||
49 | .type = MT_DEVICE, | ||
50 | }, { | ||
51 | .virtual = (unsigned long)VA_VIC0, | ||
52 | .pfn = __phys_to_pfn(S5P64X0_PA_VIC0), | ||
53 | .length = SZ_16K, | ||
54 | .type = MT_DEVICE, | ||
55 | }, { | ||
56 | .virtual = (unsigned long)VA_VIC1, | ||
57 | .pfn = __phys_to_pfn(S5P64X0_PA_VIC1), | ||
58 | .length = SZ_16K, | ||
59 | .type = MT_DEVICE, | ||
60 | }, | ||
61 | }; | ||
62 | |||
63 | static struct map_desc s5p6440_iodesc[] __initdata = { | ||
64 | { | ||
65 | .virtual = (unsigned long)S3C_VA_UART, | ||
66 | .pfn = __phys_to_pfn(S5P6440_PA_UART(0)), | ||
67 | .length = SZ_4K, | ||
68 | .type = MT_DEVICE, | ||
69 | }, | ||
70 | }; | ||
71 | |||
72 | static struct map_desc s5p6450_iodesc[] __initdata = { | ||
73 | { | ||
74 | .virtual = (unsigned long)S3C_VA_UART, | ||
75 | .pfn = __phys_to_pfn(S5P6450_PA_UART(0)), | ||
76 | .length = SZ_512K, | ||
77 | .type = MT_DEVICE, | ||
78 | }, { | ||
79 | .virtual = (unsigned long)S3C_VA_UART + SZ_512K, | ||
80 | .pfn = __phys_to_pfn(S5P6450_PA_UART(5)), | ||
81 | .length = SZ_4K, | ||
82 | .type = MT_DEVICE, | ||
83 | }, | ||
84 | }; | ||
85 | |||
86 | static void s5p64x0_idle(void) | ||
87 | { | ||
88 | unsigned long val; | ||
89 | |||
90 | if (!need_resched()) { | ||
91 | val = __raw_readl(S5P64X0_PWR_CFG); | ||
92 | val &= ~(0x3 << 5); | ||
93 | val |= (0x1 << 5); | ||
94 | __raw_writel(val, S5P64X0_PWR_CFG); | ||
95 | |||
96 | cpu_do_idle(); | ||
97 | } | ||
98 | local_irq_enable(); | ||
99 | } | ||
100 | |||
101 | /* | ||
102 | * s5p64x0_map_io | ||
103 | * | ||
104 | * register the standard CPU IO areas | ||
105 | */ | ||
106 | |||
107 | void __init s5p6440_map_io(void) | ||
108 | { | ||
109 | /* initialize any device information early */ | ||
110 | s3c_adc_setname("s3c64xx-adc"); | ||
111 | |||
112 | iotable_init(s5p64x0_iodesc, ARRAY_SIZE(s5p64x0_iodesc)); | ||
113 | iotable_init(s5p6440_iodesc, ARRAY_SIZE(s5p6440_iodesc)); | ||
114 | } | ||
115 | |||
116 | void __init s5p6450_map_io(void) | ||
117 | { | ||
118 | /* initialize any device information early */ | ||
119 | s3c_adc_setname("s3c64xx-adc"); | ||
120 | |||
121 | iotable_init(s5p64x0_iodesc, ARRAY_SIZE(s5p64x0_iodesc)); | ||
122 | iotable_init(s5p6450_iodesc, ARRAY_SIZE(s5p6440_iodesc)); | ||
123 | } | ||
124 | |||
125 | /* | ||
126 | * s5p64x0_init_clocks | ||
127 | * | ||
128 | * register and setup the CPU clocks | ||
129 | */ | ||
130 | |||
131 | void __init s5p6440_init_clocks(int xtal) | ||
132 | { | ||
133 | printk(KERN_DEBUG "%s: initializing clocks\n", __func__); | ||
134 | |||
135 | s3c24xx_register_baseclocks(xtal); | ||
136 | s5p_register_clocks(xtal); | ||
137 | s5p6440_register_clocks(); | ||
138 | s5p6440_setup_clocks(); | ||
139 | } | ||
140 | |||
141 | void __init s5p6450_init_clocks(int xtal) | ||
142 | { | ||
143 | printk(KERN_DEBUG "%s: initializing clocks\n", __func__); | ||
144 | |||
145 | s3c24xx_register_baseclocks(xtal); | ||
146 | s5p_register_clocks(xtal); | ||
147 | s5p6450_register_clocks(); | ||
148 | s5p6450_setup_clocks(); | ||
149 | } | ||
150 | |||
151 | /* | ||
152 | * s5p64x0_init_irq | ||
153 | * | ||
154 | * register the CPU interrupts | ||
155 | */ | ||
156 | |||
157 | void __init s5p6440_init_irq(void) | ||
158 | { | ||
159 | /* S5P6440 supports 2 VIC */ | ||
160 | u32 vic[2]; | ||
161 | |||
162 | /* | ||
163 | * VIC0 is missing IRQ_VIC0[3, 4, 8, 10, (12-22)] | ||
164 | * VIC1 is missing IRQ VIC1[1, 3, 4, 10, 11, 12, 14, 15, 22] | ||
165 | */ | ||
166 | vic[0] = 0xff800ae7; | ||
167 | vic[1] = 0xffbf23e5; | ||
168 | |||
169 | s5p_init_irq(vic, ARRAY_SIZE(vic)); | ||
170 | } | ||
171 | |||
172 | void __init s5p6450_init_irq(void) | ||
173 | { | ||
174 | /* S5P6450 supports only 2 VIC */ | ||
175 | u32 vic[2]; | ||
176 | |||
177 | /* | ||
178 | * VIC0 is missing IRQ_VIC0[(13-15), (21-22)] | ||
179 | * VIC1 is missing IRQ VIC1[12, 14, 23] | ||
180 | */ | ||
181 | vic[0] = 0xff9f1fff; | ||
182 | vic[1] = 0xff7fafff; | ||
183 | |||
184 | s5p_init_irq(vic, ARRAY_SIZE(vic)); | ||
185 | } | ||
186 | |||
187 | struct sysdev_class s5p64x0_sysclass = { | ||
188 | .name = "s5p64x0-core", | ||
189 | }; | ||
190 | |||
191 | static struct sys_device s5p64x0_sysdev = { | ||
192 | .cls = &s5p64x0_sysclass, | ||
193 | }; | ||
194 | |||
195 | static int __init s5p64x0_core_init(void) | ||
196 | { | ||
197 | return sysdev_class_register(&s5p64x0_sysclass); | ||
198 | } | ||
199 | core_initcall(s5p64x0_core_init); | ||
200 | |||
201 | int __init s5p64x0_init(void) | ||
202 | { | ||
203 | printk(KERN_INFO "S5P64X0(S5P6440/S5P6450): Initializing architecture\n"); | ||
204 | |||
205 | /* set idle function */ | ||
206 | pm_idle = s5p64x0_idle; | ||
207 | |||
208 | return sysdev_register(&s5p64x0_sysdev); | ||
209 | } | ||
diff --git a/arch/arm/mach-s5p64x0/dev-audio.c b/arch/arm/mach-s5p64x0/dev-audio.c new file mode 100644 index 000000000000..fa097bd68ca4 --- /dev/null +++ b/arch/arm/mach-s5p64x0/dev-audio.c | |||
@@ -0,0 +1,164 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/dev-audio.c | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co. Ltd | ||
4 | * Jaswinder Singh <jassi.brar@samsung.com> | ||
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 | |||
11 | #include <linux/platform_device.h> | ||
12 | #include <linux/dma-mapping.h> | ||
13 | #include <linux/gpio.h> | ||
14 | |||
15 | #include <plat/gpio-cfg.h> | ||
16 | #include <plat/audio.h> | ||
17 | |||
18 | #include <mach/map.h> | ||
19 | #include <mach/dma.h> | ||
20 | #include <mach/irqs.h> | ||
21 | |||
22 | static int s5p6440_cfg_i2s(struct platform_device *pdev) | ||
23 | { | ||
24 | /* configure GPIO for i2s port */ | ||
25 | switch (pdev->id) { | ||
26 | case -1: | ||
27 | s3c_gpio_cfgpin(S5P6440_GPR(4), S3C_GPIO_SFN(5)); | ||
28 | s3c_gpio_cfgpin(S5P6440_GPR(5), S3C_GPIO_SFN(5)); | ||
29 | s3c_gpio_cfgpin(S5P6440_GPR(6), S3C_GPIO_SFN(5)); | ||
30 | s3c_gpio_cfgpin(S5P6440_GPR(7), S3C_GPIO_SFN(5)); | ||
31 | s3c_gpio_cfgpin(S5P6440_GPR(8), S3C_GPIO_SFN(5)); | ||
32 | s3c_gpio_cfgpin(S5P6440_GPR(13), S3C_GPIO_SFN(5)); | ||
33 | s3c_gpio_cfgpin(S5P6440_GPR(14), S3C_GPIO_SFN(5)); | ||
34 | break; | ||
35 | |||
36 | default: | ||
37 | printk(KERN_ERR "Invalid Device %d\n", pdev->id); | ||
38 | return -EINVAL; | ||
39 | } | ||
40 | |||
41 | return 0; | ||
42 | } | ||
43 | |||
44 | static int s5p6450_cfg_i2s(struct platform_device *pdev) | ||
45 | { | ||
46 | /* configure GPIO for i2s port */ | ||
47 | switch (pdev->id) { | ||
48 | case -1: | ||
49 | s3c_gpio_cfgpin(S5P6450_GPB(4), S3C_GPIO_SFN(5)); | ||
50 | s3c_gpio_cfgpin(S5P6450_GPR(4), S3C_GPIO_SFN(5)); | ||
51 | s3c_gpio_cfgpin(S5P6450_GPR(5), S3C_GPIO_SFN(5)); | ||
52 | s3c_gpio_cfgpin(S5P6450_GPR(6), S3C_GPIO_SFN(5)); | ||
53 | s3c_gpio_cfgpin(S5P6450_GPR(7), S3C_GPIO_SFN(5)); | ||
54 | s3c_gpio_cfgpin(S5P6450_GPR(8), S3C_GPIO_SFN(5)); | ||
55 | s3c_gpio_cfgpin(S5P6450_GPR(13), S3C_GPIO_SFN(5)); | ||
56 | s3c_gpio_cfgpin(S5P6450_GPR(14), S3C_GPIO_SFN(5)); | ||
57 | break; | ||
58 | |||
59 | default: | ||
60 | printk(KERN_ERR "Invalid Device %d\n", pdev->id); | ||
61 | return -EINVAL; | ||
62 | } | ||
63 | |||
64 | return 0; | ||
65 | } | ||
66 | |||
67 | static struct s3c_audio_pdata s5p6440_i2s_pdata = { | ||
68 | .cfg_gpio = s5p6440_cfg_i2s, | ||
69 | }; | ||
70 | |||
71 | static struct s3c_audio_pdata s5p6450_i2s_pdata = { | ||
72 | .cfg_gpio = s5p6450_cfg_i2s, | ||
73 | }; | ||
74 | |||
75 | static struct resource s5p64x0_iis0_resource[] = { | ||
76 | [0] = { | ||
77 | .start = S5P64X0_PA_I2S, | ||
78 | .end = S5P64X0_PA_I2S + 0x100 - 1, | ||
79 | .flags = IORESOURCE_MEM, | ||
80 | }, | ||
81 | [1] = { | ||
82 | .start = DMACH_I2S0_TX, | ||
83 | .end = DMACH_I2S0_TX, | ||
84 | .flags = IORESOURCE_DMA, | ||
85 | }, | ||
86 | [2] = { | ||
87 | .start = DMACH_I2S0_RX, | ||
88 | .end = DMACH_I2S0_RX, | ||
89 | .flags = IORESOURCE_DMA, | ||
90 | }, | ||
91 | }; | ||
92 | |||
93 | struct platform_device s5p6440_device_iis = { | ||
94 | .name = "s3c64xx-iis-v4", | ||
95 | .id = -1, | ||
96 | .num_resources = ARRAY_SIZE(s5p64x0_iis0_resource), | ||
97 | .resource = s5p64x0_iis0_resource, | ||
98 | .dev = { | ||
99 | .platform_data = &s5p6440_i2s_pdata, | ||
100 | }, | ||
101 | }; | ||
102 | |||
103 | struct platform_device s5p6450_device_iis0 = { | ||
104 | .name = "s3c64xx-iis-v4", | ||
105 | .id = -1, | ||
106 | .num_resources = ARRAY_SIZE(s5p64x0_iis0_resource), | ||
107 | .resource = s5p64x0_iis0_resource, | ||
108 | .dev = { | ||
109 | .platform_data = &s5p6450_i2s_pdata, | ||
110 | }, | ||
111 | }; | ||
112 | |||
113 | /* PCM Controller platform_devices */ | ||
114 | |||
115 | static int s5p6440_pcm_cfg_gpio(struct platform_device *pdev) | ||
116 | { | ||
117 | switch (pdev->id) { | ||
118 | case 0: | ||
119 | s3c_gpio_cfgpin(S5P6440_GPR(7), S3C_GPIO_SFN(2)); | ||
120 | s3c_gpio_cfgpin(S5P6440_GPR(13), S3C_GPIO_SFN(2)); | ||
121 | s3c_gpio_cfgpin(S5P6440_GPR(14), S3C_GPIO_SFN(2)); | ||
122 | s3c_gpio_cfgpin(S5P6440_GPR(8), S3C_GPIO_SFN(2)); | ||
123 | s3c_gpio_cfgpin(S5P6440_GPR(6), S3C_GPIO_SFN(2)); | ||
124 | break; | ||
125 | |||
126 | default: | ||
127 | printk(KERN_DEBUG "Invalid PCM Controller number!"); | ||
128 | return -EINVAL; | ||
129 | } | ||
130 | |||
131 | return 0; | ||
132 | } | ||
133 | |||
134 | static struct s3c_audio_pdata s5p6440_pcm_pdata = { | ||
135 | .cfg_gpio = s5p6440_pcm_cfg_gpio, | ||
136 | }; | ||
137 | |||
138 | static struct resource s5p6440_pcm0_resource[] = { | ||
139 | [0] = { | ||
140 | .start = S5P64X0_PA_PCM, | ||
141 | .end = S5P64X0_PA_PCM + 0x100 - 1, | ||
142 | .flags = IORESOURCE_MEM, | ||
143 | }, | ||
144 | [1] = { | ||
145 | .start = DMACH_PCM0_TX, | ||
146 | .end = DMACH_PCM0_TX, | ||
147 | .flags = IORESOURCE_DMA, | ||
148 | }, | ||
149 | [2] = { | ||
150 | .start = DMACH_PCM0_RX, | ||
151 | .end = DMACH_PCM0_RX, | ||
152 | .flags = IORESOURCE_DMA, | ||
153 | }, | ||
154 | }; | ||
155 | |||
156 | struct platform_device s5p6440_device_pcm = { | ||
157 | .name = "samsung-pcm", | ||
158 | .id = 0, | ||
159 | .num_resources = ARRAY_SIZE(s5p6440_pcm0_resource), | ||
160 | .resource = s5p6440_pcm0_resource, | ||
161 | .dev = { | ||
162 | .platform_data = &s5p6440_pcm_pdata, | ||
163 | }, | ||
164 | }; | ||
diff --git a/arch/arm/mach-s5p64x0/dev-spi.c b/arch/arm/mach-s5p64x0/dev-spi.c new file mode 100644 index 000000000000..5b69ec4c8af3 --- /dev/null +++ b/arch/arm/mach-s5p64x0/dev-spi.c | |||
@@ -0,0 +1,232 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/dev-spi.c | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Copyright (C) 2010 Samsung Electronics Co. Ltd. | ||
7 | * Jaswinder Singh <jassi.brar@samsung.com> | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | */ | ||
13 | |||
14 | #include <linux/platform_device.h> | ||
15 | #include <linux/dma-mapping.h> | ||
16 | #include <linux/gpio.h> | ||
17 | |||
18 | #include <mach/dma.h> | ||
19 | #include <mach/map.h> | ||
20 | #include <mach/irqs.h> | ||
21 | #include <mach/regs-clock.h> | ||
22 | #include <mach/spi-clocks.h> | ||
23 | |||
24 | #include <plat/s3c64xx-spi.h> | ||
25 | #include <plat/gpio-cfg.h> | ||
26 | |||
27 | static char *s5p64x0_spi_src_clks[] = { | ||
28 | [S5P64X0_SPI_SRCCLK_PCLK] = "pclk", | ||
29 | [S5P64X0_SPI_SRCCLK_SCLK] = "sclk_spi", | ||
30 | }; | ||
31 | |||
32 | /* SPI Controller platform_devices */ | ||
33 | |||
34 | /* Since we emulate multi-cs capability, we do not touch the CS. | ||
35 | * The emulated CS is toggled by board specific mechanism, as it can | ||
36 | * be either some immediate GPIO or some signal out of some other | ||
37 | * chip in between ... or some yet another way. | ||
38 | * We simply do not assume anything about CS. | ||
39 | */ | ||
40 | static int s5p6440_spi_cfg_gpio(struct platform_device *pdev) | ||
41 | { | ||
42 | switch (pdev->id) { | ||
43 | case 0: | ||
44 | s3c_gpio_cfgpin(S5P6440_GPC(0), S3C_GPIO_SFN(2)); | ||
45 | s3c_gpio_cfgpin(S5P6440_GPC(1), S3C_GPIO_SFN(2)); | ||
46 | s3c_gpio_cfgpin(S5P6440_GPC(2), S3C_GPIO_SFN(2)); | ||
47 | s3c_gpio_setpull(S5P6440_GPC(0), S3C_GPIO_PULL_UP); | ||
48 | s3c_gpio_setpull(S5P6440_GPC(1), S3C_GPIO_PULL_UP); | ||
49 | s3c_gpio_setpull(S5P6440_GPC(2), S3C_GPIO_PULL_UP); | ||
50 | break; | ||
51 | |||
52 | case 1: | ||
53 | s3c_gpio_cfgpin(S5P6440_GPC(4), S3C_GPIO_SFN(2)); | ||
54 | s3c_gpio_cfgpin(S5P6440_GPC(5), S3C_GPIO_SFN(2)); | ||
55 | s3c_gpio_cfgpin(S5P6440_GPC(6), S3C_GPIO_SFN(2)); | ||
56 | s3c_gpio_setpull(S5P6440_GPC(4), S3C_GPIO_PULL_UP); | ||
57 | s3c_gpio_setpull(S5P6440_GPC(5), S3C_GPIO_PULL_UP); | ||
58 | s3c_gpio_setpull(S5P6440_GPC(6), S3C_GPIO_PULL_UP); | ||
59 | break; | ||
60 | |||
61 | default: | ||
62 | dev_err(&pdev->dev, "Invalid SPI Controller number!"); | ||
63 | return -EINVAL; | ||
64 | } | ||
65 | |||
66 | return 0; | ||
67 | } | ||
68 | |||
69 | static int s5p6450_spi_cfg_gpio(struct platform_device *pdev) | ||
70 | { | ||
71 | switch (pdev->id) { | ||
72 | case 0: | ||
73 | s3c_gpio_cfgpin(S5P6450_GPC(0), S3C_GPIO_SFN(2)); | ||
74 | s3c_gpio_cfgpin(S5P6450_GPC(1), S3C_GPIO_SFN(2)); | ||
75 | s3c_gpio_cfgpin(S5P6450_GPC(2), S3C_GPIO_SFN(2)); | ||
76 | s3c_gpio_setpull(S5P6450_GPC(0), S3C_GPIO_PULL_UP); | ||
77 | s3c_gpio_setpull(S5P6450_GPC(1), S3C_GPIO_PULL_UP); | ||
78 | s3c_gpio_setpull(S5P6450_GPC(2), S3C_GPIO_PULL_UP); | ||
79 | break; | ||
80 | |||
81 | case 1: | ||
82 | s3c_gpio_cfgpin(S5P6450_GPC(4), S3C_GPIO_SFN(2)); | ||
83 | s3c_gpio_cfgpin(S5P6450_GPC(5), S3C_GPIO_SFN(2)); | ||
84 | s3c_gpio_cfgpin(S5P6450_GPC(6), S3C_GPIO_SFN(2)); | ||
85 | s3c_gpio_setpull(S5P6450_GPC(4), S3C_GPIO_PULL_UP); | ||
86 | s3c_gpio_setpull(S5P6450_GPC(5), S3C_GPIO_PULL_UP); | ||
87 | s3c_gpio_setpull(S5P6450_GPC(6), S3C_GPIO_PULL_UP); | ||
88 | break; | ||
89 | |||
90 | default: | ||
91 | dev_err(&pdev->dev, "Invalid SPI Controller number!"); | ||
92 | return -EINVAL; | ||
93 | } | ||
94 | |||
95 | return 0; | ||
96 | } | ||
97 | |||
98 | static struct resource s5p64x0_spi0_resource[] = { | ||
99 | [0] = { | ||
100 | .start = S5P64X0_PA_SPI0, | ||
101 | .end = S5P64X0_PA_SPI0 + 0x100 - 1, | ||
102 | .flags = IORESOURCE_MEM, | ||
103 | }, | ||
104 | [1] = { | ||
105 | .start = DMACH_SPI0_TX, | ||
106 | .end = DMACH_SPI0_TX, | ||
107 | .flags = IORESOURCE_DMA, | ||
108 | }, | ||
109 | [2] = { | ||
110 | .start = DMACH_SPI0_RX, | ||
111 | .end = DMACH_SPI0_RX, | ||
112 | .flags = IORESOURCE_DMA, | ||
113 | }, | ||
114 | [3] = { | ||
115 | .start = IRQ_SPI0, | ||
116 | .end = IRQ_SPI0, | ||
117 | .flags = IORESOURCE_IRQ, | ||
118 | }, | ||
119 | }; | ||
120 | |||
121 | static struct s3c64xx_spi_info s5p6440_spi0_pdata = { | ||
122 | .cfg_gpio = s5p6440_spi_cfg_gpio, | ||
123 | .fifo_lvl_mask = 0x1ff, | ||
124 | .rx_lvl_offset = 15, | ||
125 | }; | ||
126 | |||
127 | static struct s3c64xx_spi_info s5p6450_spi0_pdata = { | ||
128 | .cfg_gpio = s5p6450_spi_cfg_gpio, | ||
129 | .fifo_lvl_mask = 0x1ff, | ||
130 | .rx_lvl_offset = 15, | ||
131 | }; | ||
132 | |||
133 | static u64 spi_dmamask = DMA_BIT_MASK(32); | ||
134 | |||
135 | struct platform_device s5p64x0_device_spi0 = { | ||
136 | .name = "s3c64xx-spi", | ||
137 | .id = 0, | ||
138 | .num_resources = ARRAY_SIZE(s5p64x0_spi0_resource), | ||
139 | .resource = s5p64x0_spi0_resource, | ||
140 | .dev = { | ||
141 | .dma_mask = &spi_dmamask, | ||
142 | .coherent_dma_mask = DMA_BIT_MASK(32), | ||
143 | }, | ||
144 | }; | ||
145 | |||
146 | static struct resource s5p64x0_spi1_resource[] = { | ||
147 | [0] = { | ||
148 | .start = S5P64X0_PA_SPI1, | ||
149 | .end = S5P64X0_PA_SPI1 + 0x100 - 1, | ||
150 | .flags = IORESOURCE_MEM, | ||
151 | }, | ||
152 | [1] = { | ||
153 | .start = DMACH_SPI1_TX, | ||
154 | .end = DMACH_SPI1_TX, | ||
155 | .flags = IORESOURCE_DMA, | ||
156 | }, | ||
157 | [2] = { | ||
158 | .start = DMACH_SPI1_RX, | ||
159 | .end = DMACH_SPI1_RX, | ||
160 | .flags = IORESOURCE_DMA, | ||
161 | }, | ||
162 | [3] = { | ||
163 | .start = IRQ_SPI1, | ||
164 | .end = IRQ_SPI1, | ||
165 | .flags = IORESOURCE_IRQ, | ||
166 | }, | ||
167 | }; | ||
168 | |||
169 | static struct s3c64xx_spi_info s5p6440_spi1_pdata = { | ||
170 | .cfg_gpio = s5p6440_spi_cfg_gpio, | ||
171 | .fifo_lvl_mask = 0x7f, | ||
172 | .rx_lvl_offset = 15, | ||
173 | }; | ||
174 | |||
175 | static struct s3c64xx_spi_info s5p6450_spi1_pdata = { | ||
176 | .cfg_gpio = s5p6450_spi_cfg_gpio, | ||
177 | .fifo_lvl_mask = 0x7f, | ||
178 | .rx_lvl_offset = 15, | ||
179 | }; | ||
180 | |||
181 | struct platform_device s5p64x0_device_spi1 = { | ||
182 | .name = "s3c64xx-spi", | ||
183 | .id = 1, | ||
184 | .num_resources = ARRAY_SIZE(s5p64x0_spi1_resource), | ||
185 | .resource = s5p64x0_spi1_resource, | ||
186 | .dev = { | ||
187 | .dma_mask = &spi_dmamask, | ||
188 | .coherent_dma_mask = DMA_BIT_MASK(32), | ||
189 | }, | ||
190 | }; | ||
191 | |||
192 | void __init s5p64x0_spi_set_info(int cntrlr, int src_clk_nr, int num_cs) | ||
193 | { | ||
194 | unsigned int id; | ||
195 | struct s3c64xx_spi_info *pd; | ||
196 | |||
197 | id = __raw_readl(S5P64X0_SYS_ID) & 0xFF000; | ||
198 | |||
199 | /* Reject invalid configuration */ | ||
200 | if (!num_cs || src_clk_nr < 0 | ||
201 | || src_clk_nr > S5P64X0_SPI_SRCCLK_SCLK) { | ||
202 | printk(KERN_ERR "%s: Invalid SPI configuration\n", __func__); | ||
203 | return; | ||
204 | } | ||
205 | |||
206 | switch (cntrlr) { | ||
207 | case 0: | ||
208 | if (id == 0x50000) | ||
209 | pd = &s5p6450_spi0_pdata; | ||
210 | else | ||
211 | pd = &s5p6440_spi0_pdata; | ||
212 | |||
213 | s5p64x0_device_spi0.dev.platform_data = pd; | ||
214 | break; | ||
215 | case 1: | ||
216 | if (id == 0x50000) | ||
217 | pd = &s5p6450_spi1_pdata; | ||
218 | else | ||
219 | pd = &s5p6440_spi1_pdata; | ||
220 | |||
221 | s5p64x0_device_spi1.dev.platform_data = pd; | ||
222 | break; | ||
223 | default: | ||
224 | printk(KERN_ERR "%s: Invalid SPI controller(%d)\n", | ||
225 | __func__, cntrlr); | ||
226 | return; | ||
227 | } | ||
228 | |||
229 | pd->num_cs = num_cs; | ||
230 | pd->src_clk_nr = src_clk_nr; | ||
231 | pd->src_clk_name = s5p64x0_spi_src_clks[src_clk_nr]; | ||
232 | } | ||
diff --git a/arch/arm/mach-s5p64x0/dma.c b/arch/arm/mach-s5p64x0/dma.c new file mode 100644 index 000000000000..29a8c2410049 --- /dev/null +++ b/arch/arm/mach-s5p64x0/dma.c | |||
@@ -0,0 +1,149 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/dma.c | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Copyright (C) 2010 Samsung Electronics Co. Ltd. | ||
7 | * Jaswinder Singh <jassi.brar@samsung.com> | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License as published by | ||
11 | * the Free Software Foundation; either version 2 of the License, or | ||
12 | * (at your option) any later version. | ||
13 | * | ||
14 | * This program is distributed in the hope that it will be useful, | ||
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
17 | * GNU General Public License for more details. | ||
18 | * | ||
19 | * You should have received a copy of the GNU General Public License | ||
20 | * along with this program; if not, write to the Free Software | ||
21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
22 | */ | ||
23 | |||
24 | #include <linux/platform_device.h> | ||
25 | #include <linux/dma-mapping.h> | ||
26 | |||
27 | #include <mach/map.h> | ||
28 | #include <mach/irqs.h> | ||
29 | #include <mach/regs-clock.h> | ||
30 | |||
31 | #include <plat/devs.h> | ||
32 | #include <plat/s3c-pl330-pdata.h> | ||
33 | |||
34 | static u64 dma_dmamask = DMA_BIT_MASK(32); | ||
35 | |||
36 | static struct resource s5p64x0_pdma_resource[] = { | ||
37 | [0] = { | ||
38 | .start = S5P64X0_PA_PDMA, | ||
39 | .end = S5P64X0_PA_PDMA + SZ_4K, | ||
40 | .flags = IORESOURCE_MEM, | ||
41 | }, | ||
42 | [1] = { | ||
43 | .start = IRQ_DMA0, | ||
44 | .end = IRQ_DMA0, | ||
45 | .flags = IORESOURCE_IRQ, | ||
46 | }, | ||
47 | }; | ||
48 | |||
49 | static struct s3c_pl330_platdata s5p6440_pdma_pdata = { | ||
50 | .peri = { | ||
51 | [0] = DMACH_UART0_RX, | ||
52 | [1] = DMACH_UART0_TX, | ||
53 | [2] = DMACH_UART1_RX, | ||
54 | [3] = DMACH_UART1_TX, | ||
55 | [4] = DMACH_UART2_RX, | ||
56 | [5] = DMACH_UART2_TX, | ||
57 | [6] = DMACH_UART3_RX, | ||
58 | [7] = DMACH_UART3_TX, | ||
59 | [8] = DMACH_MAX, | ||
60 | [9] = DMACH_MAX, | ||
61 | [10] = DMACH_PCM0_TX, | ||
62 | [11] = DMACH_PCM0_RX, | ||
63 | [12] = DMACH_I2S0_TX, | ||
64 | [13] = DMACH_I2S0_RX, | ||
65 | [14] = DMACH_SPI0_TX, | ||
66 | [15] = DMACH_SPI0_RX, | ||
67 | [16] = DMACH_MAX, | ||
68 | [17] = DMACH_MAX, | ||
69 | [18] = DMACH_MAX, | ||
70 | [19] = DMACH_MAX, | ||
71 | [20] = DMACH_SPI1_TX, | ||
72 | [21] = DMACH_SPI1_RX, | ||
73 | [22] = DMACH_MAX, | ||
74 | [23] = DMACH_MAX, | ||
75 | [24] = DMACH_MAX, | ||
76 | [25] = DMACH_MAX, | ||
77 | [26] = DMACH_MAX, | ||
78 | [27] = DMACH_MAX, | ||
79 | [28] = DMACH_MAX, | ||
80 | [29] = DMACH_PWM, | ||
81 | [30] = DMACH_MAX, | ||
82 | [31] = DMACH_MAX, | ||
83 | }, | ||
84 | }; | ||
85 | |||
86 | static struct s3c_pl330_platdata s5p6450_pdma_pdata = { | ||
87 | .peri = { | ||
88 | [0] = DMACH_UART0_RX, | ||
89 | [1] = DMACH_UART0_TX, | ||
90 | [2] = DMACH_UART1_RX, | ||
91 | [3] = DMACH_UART1_TX, | ||
92 | [4] = DMACH_UART2_RX, | ||
93 | [5] = DMACH_UART2_TX, | ||
94 | [6] = DMACH_UART3_RX, | ||
95 | [7] = DMACH_UART3_TX, | ||
96 | [8] = DMACH_UART4_RX, | ||
97 | [9] = DMACH_UART4_TX, | ||
98 | [10] = DMACH_PCM0_TX, | ||
99 | [11] = DMACH_PCM0_RX, | ||
100 | [12] = DMACH_I2S0_TX, | ||
101 | [13] = DMACH_I2S0_RX, | ||
102 | [14] = DMACH_SPI0_TX, | ||
103 | [15] = DMACH_SPI0_RX, | ||
104 | [16] = DMACH_PCM1_TX, | ||
105 | [17] = DMACH_PCM1_RX, | ||
106 | [18] = DMACH_PCM2_TX, | ||
107 | [19] = DMACH_PCM2_RX, | ||
108 | [20] = DMACH_SPI1_TX, | ||
109 | [21] = DMACH_SPI1_RX, | ||
110 | [22] = DMACH_USI_TX, | ||
111 | [23] = DMACH_USI_RX, | ||
112 | [24] = DMACH_MAX, | ||
113 | [25] = DMACH_I2S1_TX, | ||
114 | [26] = DMACH_I2S1_RX, | ||
115 | [27] = DMACH_I2S2_TX, | ||
116 | [28] = DMACH_I2S2_RX, | ||
117 | [29] = DMACH_PWM, | ||
118 | [30] = DMACH_UART5_RX, | ||
119 | [31] = DMACH_UART5_TX, | ||
120 | }, | ||
121 | }; | ||
122 | |||
123 | static struct platform_device s5p64x0_device_pdma = { | ||
124 | .name = "s3c-pl330", | ||
125 | .id = 0, | ||
126 | .num_resources = ARRAY_SIZE(s5p64x0_pdma_resource), | ||
127 | .resource = s5p64x0_pdma_resource, | ||
128 | .dev = { | ||
129 | .dma_mask = &dma_dmamask, | ||
130 | .coherent_dma_mask = DMA_BIT_MASK(32), | ||
131 | }, | ||
132 | }; | ||
133 | |||
134 | static int __init s5p64x0_dma_init(void) | ||
135 | { | ||
136 | unsigned int id; | ||
137 | |||
138 | id = __raw_readl(S5P64X0_SYS_ID) & 0xFF000; | ||
139 | |||
140 | if (id == 0x50000) | ||
141 | s5p64x0_device_pdma.dev.platform_data = &s5p6450_pdma_pdata; | ||
142 | else | ||
143 | s5p64x0_device_pdma.dev.platform_data = &s5p6440_pdma_pdata; | ||
144 | |||
145 | platform_device_register(&s5p64x0_device_pdma); | ||
146 | |||
147 | return 0; | ||
148 | } | ||
149 | arch_initcall(s5p64x0_dma_init); | ||
diff --git a/arch/arm/mach-s5p64x0/gpio.c b/arch/arm/mach-s5p64x0/gpio.c new file mode 100644 index 000000000000..39159dd5a29a --- /dev/null +++ b/arch/arm/mach-s5p64x0/gpio.c | |||
@@ -0,0 +1,342 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/gpio.c | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - GPIOlib support | ||
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/kernel.h> | ||
14 | #include <linux/irq.h> | ||
15 | #include <linux/io.h> | ||
16 | #include <linux/gpio.h> | ||
17 | |||
18 | #include <mach/map.h> | ||
19 | #include <mach/regs-gpio.h> | ||
20 | |||
21 | #include <plat/gpio-core.h> | ||
22 | #include <plat/gpio-cfg.h> | ||
23 | #include <plat/gpio-cfg-helpers.h> | ||
24 | |||
25 | /* To be implemented S5P6450 GPIO */ | ||
26 | |||
27 | /* | ||
28 | * S5P6440 GPIO bank summary: | ||
29 | * | ||
30 | * Bank GPIOs Style SlpCon ExtInt Group | ||
31 | * A 6 4Bit Yes 1 | ||
32 | * B 7 4Bit Yes 1 | ||
33 | * C 8 4Bit Yes 2 | ||
34 | * F 2 2Bit Yes 4 [1] | ||
35 | * G 7 4Bit Yes 5 | ||
36 | * H 10 4Bit[2] Yes 6 | ||
37 | * I 16 2Bit Yes None | ||
38 | * J 12 2Bit Yes None | ||
39 | * N 16 2Bit No IRQ_EINT | ||
40 | * P 8 2Bit Yes 8 | ||
41 | * R 15 4Bit[2] Yes 8 | ||
42 | * | ||
43 | * [1] BANKF pins 14,15 do not form part of the external interrupt sources | ||
44 | * [2] BANK has two control registers, GPxCON0 and GPxCON1 | ||
45 | */ | ||
46 | |||
47 | static int s5p64x0_gpiolib_rbank_4bit2_input(struct gpio_chip *chip, | ||
48 | unsigned int offset) | ||
49 | { | ||
50 | struct s3c_gpio_chip *ourchip = to_s3c_gpio(chip); | ||
51 | void __iomem *base = ourchip->base; | ||
52 | void __iomem *regcon = base; | ||
53 | unsigned long con; | ||
54 | unsigned long flags; | ||
55 | |||
56 | switch (offset) { | ||
57 | case 6: | ||
58 | offset += 1; | ||
59 | case 0: | ||
60 | case 1: | ||
61 | case 2: | ||
62 | case 3: | ||
63 | case 4: | ||
64 | case 5: | ||
65 | regcon -= 4; | ||
66 | break; | ||
67 | default: | ||
68 | offset -= 7; | ||
69 | break; | ||
70 | } | ||
71 | |||
72 | s3c_gpio_lock(ourchip, flags); | ||
73 | |||
74 | con = __raw_readl(regcon); | ||
75 | con &= ~(0xf << con_4bit_shift(offset)); | ||
76 | __raw_writel(con, regcon); | ||
77 | |||
78 | s3c_gpio_unlock(ourchip, flags); | ||
79 | |||
80 | return 0; | ||
81 | } | ||
82 | |||
83 | static int s5p64x0_gpiolib_rbank_4bit2_output(struct gpio_chip *chip, | ||
84 | unsigned int offset, int value) | ||
85 | { | ||
86 | struct s3c_gpio_chip *ourchip = to_s3c_gpio(chip); | ||
87 | void __iomem *base = ourchip->base; | ||
88 | void __iomem *regcon = base; | ||
89 | unsigned long con; | ||
90 | unsigned long dat; | ||
91 | unsigned long flags; | ||
92 | unsigned con_offset = offset; | ||
93 | |||
94 | switch (con_offset) { | ||
95 | case 6: | ||
96 | con_offset += 1; | ||
97 | case 0: | ||
98 | case 1: | ||
99 | case 2: | ||
100 | case 3: | ||
101 | case 4: | ||
102 | case 5: | ||
103 | regcon -= 4; | ||
104 | break; | ||
105 | default: | ||
106 | con_offset -= 7; | ||
107 | break; | ||
108 | } | ||
109 | |||
110 | s3c_gpio_lock(ourchip, flags); | ||
111 | |||
112 | con = __raw_readl(regcon); | ||
113 | con &= ~(0xf << con_4bit_shift(con_offset)); | ||
114 | con |= 0x1 << con_4bit_shift(con_offset); | ||
115 | |||
116 | dat = __raw_readl(base + GPIODAT_OFF); | ||
117 | if (value) | ||
118 | dat |= 1 << offset; | ||
119 | else | ||
120 | dat &= ~(1 << offset); | ||
121 | |||
122 | __raw_writel(con, regcon); | ||
123 | __raw_writel(dat, base + GPIODAT_OFF); | ||
124 | |||
125 | s3c_gpio_unlock(ourchip, flags); | ||
126 | |||
127 | return 0; | ||
128 | } | ||
129 | |||
130 | int s5p64x0_gpio_setcfg_4bit_rbank(struct s3c_gpio_chip *chip, | ||
131 | unsigned int off, unsigned int cfg) | ||
132 | { | ||
133 | void __iomem *reg = chip->base; | ||
134 | unsigned int shift; | ||
135 | u32 con; | ||
136 | |||
137 | switch (off) { | ||
138 | case 0: | ||
139 | case 1: | ||
140 | case 2: | ||
141 | case 3: | ||
142 | case 4: | ||
143 | case 5: | ||
144 | shift = (off & 7) * 4; | ||
145 | reg -= 4; | ||
146 | break; | ||
147 | case 6: | ||
148 | shift = ((off + 1) & 7) * 4; | ||
149 | reg -= 4; | ||
150 | default: | ||
151 | shift = ((off + 1) & 7) * 4; | ||
152 | break; | ||
153 | } | ||
154 | |||
155 | if (s3c_gpio_is_cfg_special(cfg)) { | ||
156 | cfg &= 0xf; | ||
157 | cfg <<= shift; | ||
158 | } | ||
159 | |||
160 | con = __raw_readl(reg); | ||
161 | con &= ~(0xf << shift); | ||
162 | con |= cfg; | ||
163 | __raw_writel(con, reg); | ||
164 | |||
165 | return 0; | ||
166 | } | ||
167 | |||
168 | static struct s3c_gpio_cfg s5p64x0_gpio_cfgs[] = { | ||
169 | { | ||
170 | .cfg_eint = 0, | ||
171 | }, { | ||
172 | .cfg_eint = 7, | ||
173 | }, { | ||
174 | .cfg_eint = 3, | ||
175 | .set_config = s5p64x0_gpio_setcfg_4bit_rbank, | ||
176 | }, { | ||
177 | .cfg_eint = 0, | ||
178 | .set_config = s3c_gpio_setcfg_s3c24xx, | ||
179 | .get_config = s3c_gpio_getcfg_s3c24xx, | ||
180 | }, { | ||
181 | .cfg_eint = 2, | ||
182 | .set_config = s3c_gpio_setcfg_s3c24xx, | ||
183 | .get_config = s3c_gpio_getcfg_s3c24xx, | ||
184 | }, { | ||
185 | .cfg_eint = 3, | ||
186 | .set_config = s3c_gpio_setcfg_s3c24xx, | ||
187 | .get_config = s3c_gpio_getcfg_s3c24xx, | ||
188 | }, | ||
189 | }; | ||
190 | |||
191 | static struct s3c_gpio_chip s5p6440_gpio_4bit[] = { | ||
192 | { | ||
193 | .base = S5P6440_GPA_BASE, | ||
194 | .config = &s5p64x0_gpio_cfgs[1], | ||
195 | .chip = { | ||
196 | .base = S5P6440_GPA(0), | ||
197 | .ngpio = S5P6440_GPIO_A_NR, | ||
198 | .label = "GPA", | ||
199 | }, | ||
200 | }, { | ||
201 | .base = S5P6440_GPB_BASE, | ||
202 | .config = &s5p64x0_gpio_cfgs[1], | ||
203 | .chip = { | ||
204 | .base = S5P6440_GPB(0), | ||
205 | .ngpio = S5P6440_GPIO_B_NR, | ||
206 | .label = "GPB", | ||
207 | }, | ||
208 | }, { | ||
209 | .base = S5P6440_GPC_BASE, | ||
210 | .config = &s5p64x0_gpio_cfgs[1], | ||
211 | .chip = { | ||
212 | .base = S5P6440_GPC(0), | ||
213 | .ngpio = S5P6440_GPIO_C_NR, | ||
214 | .label = "GPC", | ||
215 | }, | ||
216 | }, { | ||
217 | .base = S5P6440_GPG_BASE, | ||
218 | .config = &s5p64x0_gpio_cfgs[1], | ||
219 | .chip = { | ||
220 | .base = S5P6440_GPG(0), | ||
221 | .ngpio = S5P6440_GPIO_G_NR, | ||
222 | .label = "GPG", | ||
223 | }, | ||
224 | }, | ||
225 | }; | ||
226 | |||
227 | static struct s3c_gpio_chip s5p6440_gpio_4bit2[] = { | ||
228 | { | ||
229 | .base = S5P6440_GPH_BASE + 0x4, | ||
230 | .config = &s5p64x0_gpio_cfgs[1], | ||
231 | .chip = { | ||
232 | .base = S5P6440_GPH(0), | ||
233 | .ngpio = S5P6440_GPIO_H_NR, | ||
234 | .label = "GPH", | ||
235 | }, | ||
236 | }, | ||
237 | }; | ||
238 | |||
239 | static struct s3c_gpio_chip s5p6440_gpio_rbank_4bit2[] = { | ||
240 | { | ||
241 | .base = S5P6440_GPR_BASE + 0x4, | ||
242 | .config = &s5p64x0_gpio_cfgs[2], | ||
243 | .chip = { | ||
244 | .base = S5P6440_GPR(0), | ||
245 | .ngpio = S5P6440_GPIO_R_NR, | ||
246 | .label = "GPR", | ||
247 | }, | ||
248 | }, | ||
249 | }; | ||
250 | |||
251 | static struct s3c_gpio_chip s5p6440_gpio_2bit[] = { | ||
252 | { | ||
253 | .base = S5P6440_GPF_BASE, | ||
254 | .config = &s5p64x0_gpio_cfgs[5], | ||
255 | .chip = { | ||
256 | .base = S5P6440_GPF(0), | ||
257 | .ngpio = S5P6440_GPIO_F_NR, | ||
258 | .label = "GPF", | ||
259 | }, | ||
260 | }, { | ||
261 | .base = S5P6440_GPI_BASE, | ||
262 | .config = &s5p64x0_gpio_cfgs[3], | ||
263 | .chip = { | ||
264 | .base = S5P6440_GPI(0), | ||
265 | .ngpio = S5P6440_GPIO_I_NR, | ||
266 | .label = "GPI", | ||
267 | }, | ||
268 | }, { | ||
269 | .base = S5P6440_GPJ_BASE, | ||
270 | .config = &s5p64x0_gpio_cfgs[3], | ||
271 | .chip = { | ||
272 | .base = S5P6440_GPJ(0), | ||
273 | .ngpio = S5P6440_GPIO_J_NR, | ||
274 | .label = "GPJ", | ||
275 | }, | ||
276 | }, { | ||
277 | .base = S5P6440_GPN_BASE, | ||
278 | .config = &s5p64x0_gpio_cfgs[4], | ||
279 | .chip = { | ||
280 | .base = S5P6440_GPN(0), | ||
281 | .ngpio = S5P6440_GPIO_N_NR, | ||
282 | .label = "GPN", | ||
283 | }, | ||
284 | }, { | ||
285 | .base = S5P6440_GPP_BASE, | ||
286 | .config = &s5p64x0_gpio_cfgs[5], | ||
287 | .chip = { | ||
288 | .base = S5P6440_GPP(0), | ||
289 | .ngpio = S5P6440_GPIO_P_NR, | ||
290 | .label = "GPP", | ||
291 | }, | ||
292 | }, | ||
293 | }; | ||
294 | |||
295 | void __init s5p64x0_gpiolib_set_cfg(struct s3c_gpio_cfg *chipcfg, int nr_chips) | ||
296 | { | ||
297 | for (; nr_chips > 0; nr_chips--, chipcfg++) { | ||
298 | if (!chipcfg->set_config) | ||
299 | chipcfg->set_config = s3c_gpio_setcfg_s3c64xx_4bit; | ||
300 | if (!chipcfg->get_config) | ||
301 | chipcfg->get_config = s3c_gpio_getcfg_s3c64xx_4bit; | ||
302 | if (!chipcfg->set_pull) | ||
303 | chipcfg->set_pull = s3c_gpio_setpull_updown; | ||
304 | if (!chipcfg->get_pull) | ||
305 | chipcfg->get_pull = s3c_gpio_getpull_updown; | ||
306 | } | ||
307 | } | ||
308 | |||
309 | static void __init s5p64x0_gpio_add_rbank_4bit2(struct s3c_gpio_chip *chip, | ||
310 | int nr_chips) | ||
311 | { | ||
312 | for (; nr_chips > 0; nr_chips--, chip++) { | ||
313 | chip->chip.direction_input = s5p64x0_gpiolib_rbank_4bit2_input; | ||
314 | chip->chip.direction_output = | ||
315 | s5p64x0_gpiolib_rbank_4bit2_output; | ||
316 | s3c_gpiolib_add(chip); | ||
317 | } | ||
318 | } | ||
319 | |||
320 | static int __init s5p6440_gpiolib_init(void) | ||
321 | { | ||
322 | struct s3c_gpio_chip *chips = s5p6440_gpio_2bit; | ||
323 | int nr_chips = ARRAY_SIZE(s5p6440_gpio_2bit); | ||
324 | |||
325 | s5p64x0_gpiolib_set_cfg(s5p64x0_gpio_cfgs, | ||
326 | ARRAY_SIZE(s5p64x0_gpio_cfgs)); | ||
327 | |||
328 | for (; nr_chips > 0; nr_chips--, chips++) | ||
329 | s3c_gpiolib_add(chips); | ||
330 | |||
331 | samsung_gpiolib_add_4bit_chips(s5p6440_gpio_4bit, | ||
332 | ARRAY_SIZE(s5p6440_gpio_4bit)); | ||
333 | |||
334 | samsung_gpiolib_add_4bit2_chips(s5p6440_gpio_4bit2, | ||
335 | ARRAY_SIZE(s5p6440_gpio_4bit2)); | ||
336 | |||
337 | s5p64x0_gpio_add_rbank_4bit2(s5p6440_gpio_rbank_4bit2, | ||
338 | ARRAY_SIZE(s5p6440_gpio_rbank_4bit2)); | ||
339 | |||
340 | return 0; | ||
341 | } | ||
342 | arch_initcall(s5p6440_gpiolib_init); | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/debug-macro.S b/arch/arm/mach-s5p64x0/include/mach/debug-macro.S new file mode 100644 index 000000000000..79b04e6a6f8e --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/debug-macro.S | |||
@@ -0,0 +1,33 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/debug-macro.S | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
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 | |||
11 | /* pull in the relevant register and map files. */ | ||
12 | |||
13 | #include <plat/map-base.h> | ||
14 | #include <plat/map-s5p.h> | ||
15 | |||
16 | #include <plat/regs-serial.h> | ||
17 | |||
18 | .macro addruart, rp, rv | ||
19 | mov \rp, #0xE0000000 | ||
20 | orr \rp, \rp, #0x00100000 | ||
21 | ldr \rp, [\rp, #0x118 ] | ||
22 | and \rp, \rp, #0xff000 | ||
23 | teq \rp, #0x50000 @@ S5P6450 | ||
24 | ldreq \rp, =0xEC800000 | ||
25 | movne \rp, #0xEC000000 @@ S5P6440 | ||
26 | ldrne \rv, = S3C_VA_UART | ||
27 | #if CONFIG_DEBUG_S3C_UART != 0 | ||
28 | add \rp, \rp, #(0x400 * CONFIG_DEBUG_S3C_UART) | ||
29 | add \rv, \rv, #(0x400 * CONFIG_DEBUG_S3C_UART) | ||
30 | #endif | ||
31 | .endm | ||
32 | |||
33 | #include <plat/debug-macro.S> | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/dma.h b/arch/arm/mach-s5p64x0/include/mach/dma.h new file mode 100644 index 000000000000..81209eb1409b --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/dma.h | |||
@@ -0,0 +1,26 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2010 Samsung Electronics Co. Ltd. | ||
3 | * Jaswinder Singh <jassi.brar@samsung.com> | ||
4 | * | ||
5 | * This program is free software; you can redistribute it and/or modify | ||
6 | * it under the terms of the GNU General Public License as published by | ||
7 | * the Free Software Foundation; either version 2 of the License, or | ||
8 | * (at your option) any later version. | ||
9 | * | ||
10 | * This program is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with this program; if not, write to the Free Software | ||
17 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
18 | */ | ||
19 | |||
20 | #ifndef __MACH_DMA_H | ||
21 | #define __MACH_DMA_H | ||
22 | |||
23 | /* This platform uses the common S3C DMA API driver for PL330 */ | ||
24 | #include <plat/s3c-dma-pl330.h> | ||
25 | |||
26 | #endif /* __MACH_DMA_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/entry-macro.S b/arch/arm/mach-s5p64x0/include/mach/entry-macro.S new file mode 100644 index 000000000000..10b62b4f8211 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/entry-macro.S | |||
@@ -0,0 +1,16 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/entry-macro.S | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Low-level IRQ helper macros for the Samsung S5P64X0 | ||
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 <mach/map.h> | ||
14 | #include <plat/irqs.h> | ||
15 | |||
16 | #include <asm/entry-macro-vic2.S> | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/gpio.h b/arch/arm/mach-s5p64x0/include/mach/gpio.h new file mode 100644 index 000000000000..5486c8f01f1d --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/gpio.h | |||
@@ -0,0 +1,139 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/gpio.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - GPIO lib support | ||
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 | #ifndef __ASM_ARCH_GPIO_H | ||
14 | #define __ASM_ARCH_GPIO_H __FILE__ | ||
15 | |||
16 | #define gpio_get_value __gpio_get_value | ||
17 | #define gpio_set_value __gpio_set_value | ||
18 | #define gpio_cansleep __gpio_cansleep | ||
19 | #define gpio_to_irq __gpio_to_irq | ||
20 | |||
21 | /* GPIO bank sizes */ | ||
22 | |||
23 | #define S5P6440_GPIO_A_NR (6) | ||
24 | #define S5P6440_GPIO_B_NR (7) | ||
25 | #define S5P6440_GPIO_C_NR (8) | ||
26 | #define S5P6440_GPIO_F_NR (2) | ||
27 | #define S5P6440_GPIO_G_NR (7) | ||
28 | #define S5P6440_GPIO_H_NR (10) | ||
29 | #define S5P6440_GPIO_I_NR (16) | ||
30 | #define S5P6440_GPIO_J_NR (12) | ||
31 | #define S5P6440_GPIO_N_NR (16) | ||
32 | #define S5P6440_GPIO_P_NR (8) | ||
33 | #define S5P6440_GPIO_R_NR (15) | ||
34 | |||
35 | #define S5P6450_GPIO_A_NR (6) | ||
36 | #define S5P6450_GPIO_B_NR (7) | ||
37 | #define S5P6450_GPIO_C_NR (8) | ||
38 | #define S5P6450_GPIO_D_NR (8) | ||
39 | #define S5P6450_GPIO_F_NR (2) | ||
40 | #define S5P6450_GPIO_G_NR (14) | ||
41 | #define S5P6450_GPIO_H_NR (10) | ||
42 | #define S5P6450_GPIO_I_NR (16) | ||
43 | #define S5P6450_GPIO_J_NR (12) | ||
44 | #define S5P6450_GPIO_K_NR (5) | ||
45 | #define S5P6450_GPIO_N_NR (16) | ||
46 | #define S5P6450_GPIO_P_NR (11) | ||
47 | #define S5P6450_GPIO_Q_NR (14) | ||
48 | #define S5P6450_GPIO_R_NR (15) | ||
49 | #define S5P6450_GPIO_S_NR (8) | ||
50 | |||
51 | /* GPIO bank numbers */ | ||
52 | |||
53 | /* CONFIG_S3C_GPIO_SPACE allows the user to select extra | ||
54 | * space for debugging purposes so that any accidental | ||
55 | * change from one gpio bank to another can be caught. | ||
56 | */ | ||
57 | |||
58 | #define S5P64X0_GPIO_NEXT(__gpio) \ | ||
59 | ((__gpio##_START) + (__gpio##_NR) + CONFIG_S3C_GPIO_SPACE + 1) | ||
60 | |||
61 | enum s5p6440_gpio_number { | ||
62 | S5P6440_GPIO_A_START = 0, | ||
63 | S5P6440_GPIO_B_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_A), | ||
64 | S5P6440_GPIO_C_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_B), | ||
65 | S5P6440_GPIO_F_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_C), | ||
66 | S5P6440_GPIO_G_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_F), | ||
67 | S5P6440_GPIO_H_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_G), | ||
68 | S5P6440_GPIO_I_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_H), | ||
69 | S5P6440_GPIO_J_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_I), | ||
70 | S5P6440_GPIO_N_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_J), | ||
71 | S5P6440_GPIO_P_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_N), | ||
72 | S5P6440_GPIO_R_START = S5P64X0_GPIO_NEXT(S5P6440_GPIO_P), | ||
73 | }; | ||
74 | |||
75 | enum s5p6450_gpio_number { | ||
76 | S5P6450_GPIO_A_START = 0, | ||
77 | S5P6450_GPIO_B_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_A), | ||
78 | S5P6450_GPIO_C_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_B), | ||
79 | S5P6450_GPIO_D_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_C), | ||
80 | S5P6450_GPIO_F_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_D), | ||
81 | S5P6450_GPIO_G_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_F), | ||
82 | S5P6450_GPIO_H_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_G), | ||
83 | S5P6450_GPIO_I_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_H), | ||
84 | S5P6450_GPIO_J_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_I), | ||
85 | S5P6450_GPIO_K_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_J), | ||
86 | S5P6450_GPIO_N_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_K), | ||
87 | S5P6450_GPIO_P_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_N), | ||
88 | S5P6450_GPIO_Q_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_P), | ||
89 | S5P6450_GPIO_R_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_Q), | ||
90 | S5P6450_GPIO_S_START = S5P64X0_GPIO_NEXT(S5P6450_GPIO_R), | ||
91 | }; | ||
92 | |||
93 | /* GPIO number definitions */ | ||
94 | |||
95 | #define S5P6440_GPA(_nr) (S5P6440_GPIO_A_START + (_nr)) | ||
96 | #define S5P6440_GPB(_nr) (S5P6440_GPIO_B_START + (_nr)) | ||
97 | #define S5P6440_GPC(_nr) (S5P6440_GPIO_C_START + (_nr)) | ||
98 | #define S5P6440_GPF(_nr) (S5P6440_GPIO_F_START + (_nr)) | ||
99 | #define S5P6440_GPG(_nr) (S5P6440_GPIO_G_START + (_nr)) | ||
100 | #define S5P6440_GPH(_nr) (S5P6440_GPIO_H_START + (_nr)) | ||
101 | #define S5P6440_GPI(_nr) (S5P6440_GPIO_I_START + (_nr)) | ||
102 | #define S5P6440_GPJ(_nr) (S5P6440_GPIO_J_START + (_nr)) | ||
103 | #define S5P6440_GPN(_nr) (S5P6440_GPIO_N_START + (_nr)) | ||
104 | #define S5P6440_GPP(_nr) (S5P6440_GPIO_P_START + (_nr)) | ||
105 | #define S5P6440_GPR(_nr) (S5P6440_GPIO_R_START + (_nr)) | ||
106 | |||
107 | #define S5P6450_GPA(_nr) (S5P6450_GPIO_A_START + (_nr)) | ||
108 | #define S5P6450_GPB(_nr) (S5P6450_GPIO_B_START + (_nr)) | ||
109 | #define S5P6450_GPC(_nr) (S5P6450_GPIO_C_START + (_nr)) | ||
110 | #define S5P6450_GPD(_nr) (S5P6450_GPIO_D_START + (_nr)) | ||
111 | #define S5P6450_GPF(_nr) (S5P6450_GPIO_F_START + (_nr)) | ||
112 | #define S5P6450_GPG(_nr) (S5P6450_GPIO_G_START + (_nr)) | ||
113 | #define S5P6450_GPH(_nr) (S5P6450_GPIO_H_START + (_nr)) | ||
114 | #define S5P6450_GPI(_nr) (S5P6450_GPIO_I_START + (_nr)) | ||
115 | #define S5P6450_GPJ(_nr) (S5P6450_GPIO_J_START + (_nr)) | ||
116 | #define S5P6450_GPK(_nr) (S5P6450_GPIO_K_START + (_nr)) | ||
117 | #define S5P6450_GPN(_nr) (S5P6450_GPIO_N_START + (_nr)) | ||
118 | #define S5P6450_GPP(_nr) (S5P6450_GPIO_P_START + (_nr)) | ||
119 | #define S5P6450_GPQ(_nr) (S5P6450_GPIO_Q_START + (_nr)) | ||
120 | #define S5P6450_GPR(_nr) (S5P6450_GPIO_R_START + (_nr)) | ||
121 | #define S5P6450_GPS(_nr) (S5P6450_GPIO_S_START + (_nr)) | ||
122 | |||
123 | /* the end of the S5P64X0 specific gpios */ | ||
124 | |||
125 | #define S5P6440_GPIO_END (S5P6440_GPR(S5P6440_GPIO_R_NR) + 1) | ||
126 | #define S5P6450_GPIO_END (S5P6450_GPS(S5P6450_GPIO_S_NR) + 1) | ||
127 | |||
128 | #define S5P64X0_GPIO_END (S5P6440_GPIO_END > S5P6450_GPIO_END ? \ | ||
129 | S5P6440_GPIO_END : S5P6450_GPIO_END) | ||
130 | |||
131 | #define S3C_GPIO_END S5P64X0_GPIO_END | ||
132 | |||
133 | /* define the number of gpios we need to the one after the last GPIO range */ | ||
134 | |||
135 | #define ARCH_NR_GPIOS (S5P64X0_GPIO_END + CONFIG_SAMSUNG_GPIO_EXTRA) | ||
136 | |||
137 | #include <asm-generic/gpio.h> | ||
138 | |||
139 | #endif /* __ASM_ARCH_GPIO_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/hardware.h b/arch/arm/mach-s5p64x0/include/mach/hardware.h new file mode 100644 index 000000000000..d3e87996dd9a --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/hardware.h | |||
@@ -0,0 +1,18 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/hardware.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - Hardware support | ||
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 | #ifndef __ASM_ARCH_HARDWARE_H | ||
14 | #define __ASM_ARCH_HARDWARE_H __FILE__ | ||
15 | |||
16 | /* currently nothing here, placeholder */ | ||
17 | |||
18 | #endif /* __ASM_ARCH_HARDWARE_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/i2c.h b/arch/arm/mach-s5p64x0/include/mach/i2c.h new file mode 100644 index 000000000000..887d25209e8e --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/i2c.h | |||
@@ -0,0 +1,17 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/i2c.h | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 I2C configuration | ||
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 | extern void s5p6440_i2c0_cfg_gpio(struct platform_device *dev); | ||
14 | extern void s5p6440_i2c1_cfg_gpio(struct platform_device *dev); | ||
15 | |||
16 | extern void s5p6450_i2c0_cfg_gpio(struct platform_device *dev); | ||
17 | extern void s5p6450_i2c1_cfg_gpio(struct platform_device *dev); | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/io.h b/arch/arm/mach-s5p64x0/include/mach/io.h new file mode 100644 index 000000000000..a3e095c02fb5 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/io.h | |||
@@ -0,0 +1,25 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/io.h | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Copyright 2008 Simtec Electronics | ||
7 | * Ben Dooks <ben-linux@fluff.org> | ||
8 | * | ||
9 | * Default IO routines for S5P64X0 based | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or modify | ||
12 | * it under the terms of the GNU General Public License version 2 as | ||
13 | * published by the Free Software Foundation. | ||
14 | */ | ||
15 | |||
16 | #ifndef __ASM_ARM_ARCH_IO_H | ||
17 | #define __ASM_ARM_ARCH_IO_H | ||
18 | |||
19 | /* No current ISA/PCI bus support. */ | ||
20 | #define __io(a) __typesafe_io(a) | ||
21 | #define __mem_pci(a) (a) | ||
22 | |||
23 | #define IO_SPACE_LIMIT (0xFFFFFFFF) | ||
24 | |||
25 | #endif | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/irqs.h b/arch/arm/mach-s5p64x0/include/mach/irqs.h new file mode 100644 index 000000000000..513abffc7604 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/irqs.h | |||
@@ -0,0 +1,142 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/irqs.h | ||
2 | * | ||
3 | * Copyright 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - IRQ definitions | ||
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 | #ifndef __ASM_ARCH_IRQS_H | ||
14 | #define __ASM_ARCH_IRQS_H __FILE__ | ||
15 | |||
16 | #include <plat/irqs.h> | ||
17 | |||
18 | /* VIC0 */ | ||
19 | |||
20 | #define IRQ_EINT0_3 S5P_IRQ_VIC0(0) | ||
21 | #define IRQ_EINT4_11 S5P_IRQ_VIC0(1) | ||
22 | #define IRQ_RTC_TIC S5P_IRQ_VIC0(2) | ||
23 | #define IRQ_IIS1 S5P_IRQ_VIC0(3) /* for only S5P6450 */ | ||
24 | #define IRQ_IIS2 S5P_IRQ_VIC0(4) /* for only S5P6450 */ | ||
25 | #define IRQ_IIC1 S5P_IRQ_VIC0(5) | ||
26 | #define IRQ_I2SV40 S5P_IRQ_VIC0(6) | ||
27 | #define IRQ_GPS S5P_IRQ_VIC0(7) /* for only S5P6450 */ | ||
28 | |||
29 | #define IRQ_2D S5P_IRQ_VIC0(11) | ||
30 | #define IRQ_TIMER0_VIC S5P_IRQ_VIC0(23) | ||
31 | #define IRQ_TIMER1_VIC S5P_IRQ_VIC0(24) | ||
32 | #define IRQ_TIMER2_VIC S5P_IRQ_VIC0(25) | ||
33 | #define IRQ_WDT S5P_IRQ_VIC0(26) | ||
34 | #define IRQ_TIMER3_VIC S5P_IRQ_VIC0(27) | ||
35 | #define IRQ_TIMER4_VIC S5P_IRQ_VIC0(28) | ||
36 | #define IRQ_DISPCON0 S5P_IRQ_VIC0(29) | ||
37 | #define IRQ_DISPCON1 S5P_IRQ_VIC0(30) | ||
38 | #define IRQ_DISPCON2 S5P_IRQ_VIC0(31) | ||
39 | |||
40 | /* VIC1 */ | ||
41 | |||
42 | #define IRQ_EINT12_15 S5P_IRQ_VIC1(0) | ||
43 | #define IRQ_PCM0 S5P_IRQ_VIC1(2) | ||
44 | #define IRQ_PCM1 S5P_IRQ_VIC1(3) /* for only S5P6450 */ | ||
45 | #define IRQ_PCM2 S5P_IRQ_VIC1(4) /* for only S5P6450 */ | ||
46 | #define IRQ_UART0 S5P_IRQ_VIC1(5) | ||
47 | #define IRQ_UART1 S5P_IRQ_VIC1(6) | ||
48 | #define IRQ_UART2 S5P_IRQ_VIC1(7) | ||
49 | #define IRQ_UART3 S5P_IRQ_VIC1(8) | ||
50 | #define IRQ_DMA0 S5P_IRQ_VIC1(9) | ||
51 | #define IRQ_UART4 S5P_IRQ_VIC1(10) /* S5P6450 */ | ||
52 | #define IRQ_UART5 S5P_IRQ_VIC1(11) /* S5P6450 */ | ||
53 | #define IRQ_NFC S5P_IRQ_VIC1(13) | ||
54 | #define IRQ_USI S5P_IRQ_VIC1(15) /* S5P6450 */ | ||
55 | #define IRQ_SPI0 S5P_IRQ_VIC1(16) | ||
56 | #define IRQ_SPI1 S5P_IRQ_VIC1(17) | ||
57 | #define IRQ_HSMMC2 S5P_IRQ_VIC1(17) /* Shared */ | ||
58 | #define IRQ_IIC S5P_IRQ_VIC1(18) | ||
59 | #define IRQ_DISPCON3 S5P_IRQ_VIC1(19) | ||
60 | #define IRQ_EINT_GROUPS S5P_IRQ_VIC1(21) | ||
61 | #define IRQ_PMU S5P_IRQ_VIC1(23) /* S5P6440 */ | ||
62 | #define IRQ_HSMMC0 S5P_IRQ_VIC1(24) | ||
63 | #define IRQ_HSMMC1 S5P_IRQ_VIC1(25) | ||
64 | #define IRQ_OTG S5P_IRQ_VIC1(26) | ||
65 | #define IRQ_DSI S5P_IRQ_VIC1(27) | ||
66 | #define IRQ_RTC_ALARM S5P_IRQ_VIC1(28) | ||
67 | #define IRQ_TSI S5P_IRQ_VIC1(29) | ||
68 | #define IRQ_PENDN S5P_IRQ_VIC1(30) | ||
69 | #define IRQ_TC IRQ_PENDN | ||
70 | #define IRQ_ADC S5P_IRQ_VIC1(31) | ||
71 | |||
72 | /* UART interrupts, S5P6450 has 5 UARTs */ | ||
73 | #define IRQ_S5P_UART_BASE4 (96) | ||
74 | #define IRQ_S5P_UART_BASE5 (100) | ||
75 | |||
76 | #define IRQ_S5P_UART_RX4 (IRQ_S5P_UART_BASE4 + UART_IRQ_RXD) | ||
77 | #define IRQ_S5P_UART_TX4 (IRQ_S5P_UART_BASE4 + UART_IRQ_TXD) | ||
78 | #define IRQ_S5P_UART_ERR4 (IRQ_S5P_UART_BASE4 + UART_IRQ_ERR) | ||
79 | |||
80 | #define IRQ_S5P_UART_RX5 (IRQ_S5P_UART_BASE5 + UART_IRQ_RXD) | ||
81 | #define IRQ_S5P_UART_TX5 (IRQ_S5P_UART_BASE5 + UART_IRQ_TXD) | ||
82 | #define IRQ_S5P_UART_ERR5 (IRQ_S5P_UART_BASE5 + UART_IRQ_ERR) | ||
83 | |||
84 | /* S3C compatibilty defines */ | ||
85 | #define IRQ_S3CUART_RX4 IRQ_S5P_UART_RX4 | ||
86 | #define IRQ_S3CUART_RX5 IRQ_S5P_UART_RX5 | ||
87 | |||
88 | /* S5P6450 EINT feature will be added */ | ||
89 | |||
90 | /* | ||
91 | * Since the IRQ_EINT(x) are a linear mapping on s5p6440 we just defined | ||
92 | * them as an IRQ_EINT(x) macro from S5P_IRQ_EINT_BASE which we place | ||
93 | * after the pair of VICs. | ||
94 | */ | ||
95 | |||
96 | #define S5P_IRQ_EINT_BASE (S5P_IRQ_VIC1(31) + 6) | ||
97 | |||
98 | #define S5P_EINT(x) ((x) + S5P_IRQ_EINT_BASE) | ||
99 | |||
100 | #define S5P_EINT_BASE1 (S5P_IRQ_EINT_BASE) | ||
101 | /* | ||
102 | * S5P6440 has 0-15 external interrupts in group 0. Only these can be used | ||
103 | * to wake up from sleep. If request is beyond this range, by mistake, a large | ||
104 | * return value for an irq number should be indication of something amiss. | ||
105 | */ | ||
106 | #define S5P_EINT_BASE2 (0xf0000000) | ||
107 | |||
108 | /* | ||
109 | * Next the external interrupt groups. These are similar to the IRQ_EINT(x) | ||
110 | * that they are sourced from the GPIO pins but with a different scheme for | ||
111 | * priority and source indication. | ||
112 | * | ||
113 | * The IRQ_EINT(x) can be thought of as 'group 0' of the available GPIO | ||
114 | * interrupts, but for historical reasons they are kept apart from these | ||
115 | * next interrupts. | ||
116 | * | ||
117 | * Use IRQ_EINT_GROUP(group, offset) to get the number for use in the | ||
118 | * machine specific support files. | ||
119 | */ | ||
120 | |||
121 | /* Actually, #6 and #7 are missing in the EINT_GROUP1 */ | ||
122 | #define IRQ_EINT_GROUP1_NR (15) | ||
123 | #define IRQ_EINT_GROUP2_NR (8) | ||
124 | #define IRQ_EINT_GROUP5_NR (7) | ||
125 | #define IRQ_EINT_GROUP6_NR (10) | ||
126 | /* Actually, #0, #1 and #2 are missing in the EINT_GROUP8 */ | ||
127 | #define IRQ_EINT_GROUP8_NR (11) | ||
128 | |||
129 | #define IRQ_EINT_GROUP_BASE S5P_EINT(16) | ||
130 | #define IRQ_EINT_GROUP1_BASE (IRQ_EINT_GROUP_BASE + 0) | ||
131 | #define IRQ_EINT_GROUP2_BASE (IRQ_EINT_GROUP1_BASE + IRQ_EINT_GROUP1_NR) | ||
132 | #define IRQ_EINT_GROUP5_BASE (IRQ_EINT_GROUP2_BASE + IRQ_EINT_GROUP2_NR) | ||
133 | #define IRQ_EINT_GROUP6_BASE (IRQ_EINT_GROUP5_BASE + IRQ_EINT_GROUP5_NR) | ||
134 | #define IRQ_EINT_GROUP8_BASE (IRQ_EINT_GROUP6_BASE + IRQ_EINT_GROUP6_NR) | ||
135 | |||
136 | #define IRQ_EINT_GROUP(grp, x) (IRQ_EINT_GROUP##grp##_BASE + (x)) | ||
137 | |||
138 | /* Set the default NR_IRQS */ | ||
139 | |||
140 | #define NR_IRQS (IRQ_EINT_GROUP8_BASE + IRQ_EINT_GROUP8_NR + 1) | ||
141 | |||
142 | #endif /* __ASM_ARCH_IRQS_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/map.h b/arch/arm/mach-s5p64x0/include/mach/map.h new file mode 100644 index 000000000000..31e534156e06 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/map.h | |||
@@ -0,0 +1,83 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/map.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - Memory map definitions | ||
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 | #ifndef __ASM_ARCH_MAP_H | ||
14 | #define __ASM_ARCH_MAP_H __FILE__ | ||
15 | |||
16 | #include <plat/map-base.h> | ||
17 | #include <plat/map-s5p.h> | ||
18 | |||
19 | #define S5P64X0_PA_SDRAM (0x20000000) | ||
20 | |||
21 | #define S5P64X0_PA_CHIPID (0xE0000000) | ||
22 | #define S5P_PA_CHIPID S5P64X0_PA_CHIPID | ||
23 | |||
24 | #define S5P64X0_PA_SYSCON (0xE0100000) | ||
25 | #define S5P_PA_SYSCON S5P64X0_PA_SYSCON | ||
26 | |||
27 | #define S5P64X0_PA_GPIO (0xE0308000) | ||
28 | |||
29 | #define S5P64X0_PA_VIC0 (0xE4000000) | ||
30 | #define S5P64X0_PA_VIC1 (0xE4100000) | ||
31 | |||
32 | #define S5P64X0_PA_PDMA (0xE9000000) | ||
33 | |||
34 | #define S5P64X0_PA_TIMER (0xEA000000) | ||
35 | #define S5P_PA_TIMER S5P64X0_PA_TIMER | ||
36 | |||
37 | #define S5P64X0_PA_RTC (0xEA100000) | ||
38 | |||
39 | #define S5P64X0_PA_WDT (0xEA200000) | ||
40 | |||
41 | #define S5P6440_PA_UART(x) (0xEC000000 + ((x) * S3C_UART_OFFSET)) | ||
42 | #define S5P6450_PA_UART(x) ((x < 5) ? (0xEC800000 + ((x) * S3C_UART_OFFSET)) : (0xEC000000)) | ||
43 | |||
44 | #define S5P_PA_UART0 S5P6450_PA_UART(0) | ||
45 | #define S5P_PA_UART1 S5P6450_PA_UART(1) | ||
46 | #define S5P_PA_UART2 S5P6450_PA_UART(2) | ||
47 | #define S5P_PA_UART3 S5P6450_PA_UART(3) | ||
48 | #define S5P_PA_UART4 S5P6450_PA_UART(4) | ||
49 | #define S5P_PA_UART5 S5P6450_PA_UART(5) | ||
50 | |||
51 | #define S5P_SZ_UART SZ_256 | ||
52 | |||
53 | #define S5P6440_PA_IIC0 (0xEC104000) | ||
54 | #define S5P6440_PA_IIC1 (0xEC20F000) | ||
55 | #define S5P6450_PA_IIC0 (0xEC100000) | ||
56 | #define S5P6450_PA_IIC1 (0xEC200000) | ||
57 | |||
58 | #define S5P64X0_PA_SPI0 (0xEC400000) | ||
59 | #define S5P64X0_PA_SPI1 (0xEC500000) | ||
60 | |||
61 | #define S5P64X0_PA_HSOTG (0xED100000) | ||
62 | |||
63 | #define S5P64X0_PA_HSMMC(x) (0xED800000 + ((x) * 0x100000)) | ||
64 | |||
65 | #define S5P64X0_PA_I2S (0xF2000000) | ||
66 | |||
67 | #define S5P64X0_PA_PCM (0xF2100000) | ||
68 | |||
69 | #define S5P64X0_PA_ADC (0xF3000000) | ||
70 | |||
71 | /* compatibiltiy defines. */ | ||
72 | |||
73 | #define S3C_PA_HSMMC0 S5P64X0_PA_HSMMC(0) | ||
74 | #define S3C_PA_HSMMC1 S5P64X0_PA_HSMMC(1) | ||
75 | #define S3C_PA_HSMMC2 S5P64X0_PA_HSMMC(2) | ||
76 | #define S3C_PA_IIC S5P6440_PA_IIC0 | ||
77 | #define S3C_PA_IIC1 S5P6440_PA_IIC1 | ||
78 | #define S3C_PA_RTC S5P64X0_PA_RTC | ||
79 | #define S3C_PA_WDT S5P64X0_PA_WDT | ||
80 | |||
81 | #define SAMSUNG_PA_ADC S5P64X0_PA_ADC | ||
82 | |||
83 | #endif /* __ASM_ARCH_MAP_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/memory.h b/arch/arm/mach-s5p64x0/include/mach/memory.h new file mode 100644 index 000000000000..1b036b0a24ce --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/memory.h | |||
@@ -0,0 +1,19 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/memory.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - Memory definitions | ||
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 | #ifndef __ASM_ARCH_MEMORY_H | ||
14 | #define __ASM_ARCH_MEMORY_H __FILE__ | ||
15 | |||
16 | #define PHYS_OFFSET UL(0x20000000) | ||
17 | #define CONSISTENT_DMA_SIZE SZ_8M | ||
18 | |||
19 | #endif /* __ASM_ARCH_MEMORY_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/pwm-clock.h b/arch/arm/mach-s5p64x0/include/mach/pwm-clock.h new file mode 100644 index 000000000000..19fff8b701c0 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/pwm-clock.h | |||
@@ -0,0 +1,68 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/pwm-clock.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Copyright 2008 Openmoko, Inc. | ||
7 | * Copyright 2008 Simtec Electronics | ||
8 | * Ben Dooks <ben@simtec.co.uk> | ||
9 | * http://armlinux.simtec.co.uk/ | ||
10 | * | ||
11 | * S5P64X0 - pwm clock and timer support | ||
12 | * | ||
13 | * This program is free software; you can redistribute it and/or modify | ||
14 | * it under the terms of the GNU General Public License version 2 as | ||
15 | * published by the Free Software Foundation. | ||
16 | */ | ||
17 | |||
18 | #ifndef __ASM_ARCH_PWMCLK_H | ||
19 | #define __ASM_ARCH_PWMCLK_H __FILE__ | ||
20 | |||
21 | /** | ||
22 | * pwm_cfg_src_is_tclk() - return whether the given mux config is a tclk | ||
23 | * @tcfg: The timer TCFG1 register bits shifted down to 0. | ||
24 | * | ||
25 | * Return true if the given configuration from TCFG1 is a TCLK instead | ||
26 | * any of the TDIV clocks. | ||
27 | */ | ||
28 | static inline int pwm_cfg_src_is_tclk(unsigned long tcfg) | ||
29 | { | ||
30 | return 0; | ||
31 | } | ||
32 | |||
33 | /** | ||
34 | * tcfg_to_divisor() - convert tcfg1 setting to a divisor | ||
35 | * @tcfg1: The tcfg1 setting, shifted down. | ||
36 | * | ||
37 | * Get the divisor value for the given tcfg1 setting. We assume the | ||
38 | * caller has already checked to see if this is not a TCLK source. | ||
39 | */ | ||
40 | static inline unsigned long tcfg_to_divisor(unsigned long tcfg1) | ||
41 | { | ||
42 | return 1 << tcfg1; | ||
43 | } | ||
44 | |||
45 | /** | ||
46 | * pwm_tdiv_has_div1() - does the tdiv setting have a /1 | ||
47 | * | ||
48 | * Return true if we have a /1 in the tdiv setting. | ||
49 | */ | ||
50 | static inline unsigned int pwm_tdiv_has_div1(void) | ||
51 | { | ||
52 | return 1; | ||
53 | } | ||
54 | |||
55 | /** | ||
56 | * pwm_tdiv_div_bits() - calculate TCFG1 divisor value. | ||
57 | * @div: The divisor to calculate the bit information for. | ||
58 | * | ||
59 | * Turn a divisor into the necessary bit field for TCFG1. | ||
60 | */ | ||
61 | static inline unsigned long pwm_tdiv_div_bits(unsigned int div) | ||
62 | { | ||
63 | return ilog2(div); | ||
64 | } | ||
65 | |||
66 | #define S3C_TCFG1_MUX_TCLK 0 | ||
67 | |||
68 | #endif /* __ASM_ARCH_PWMCLK_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/regs-clock.h b/arch/arm/mach-s5p64x0/include/mach/regs-clock.h new file mode 100644 index 000000000000..58e1bc813804 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/regs-clock.h | |||
@@ -0,0 +1,63 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/regs-clock.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - Clock register definitions | ||
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 | #ifndef __ASM_ARCH_REGS_CLOCK_H | ||
14 | #define __ASM_ARCH_REGS_CLOCK_H __FILE__ | ||
15 | |||
16 | #include <mach/map.h> | ||
17 | |||
18 | #define S5P_CLKREG(x) (S3C_VA_SYS + (x)) | ||
19 | |||
20 | #define S5P64X0_APLL_CON S5P_CLKREG(0x0C) | ||
21 | #define S5P64X0_MPLL_CON S5P_CLKREG(0x10) | ||
22 | #define S5P64X0_EPLL_CON S5P_CLKREG(0x14) | ||
23 | #define S5P64X0_EPLL_CON_K S5P_CLKREG(0x18) | ||
24 | |||
25 | #define S5P64X0_CLK_SRC0 S5P_CLKREG(0x1C) | ||
26 | |||
27 | #define S5P64X0_CLK_DIV0 S5P_CLKREG(0x20) | ||
28 | #define S5P64X0_CLK_DIV1 S5P_CLKREG(0x24) | ||
29 | #define S5P64X0_CLK_DIV2 S5P_CLKREG(0x28) | ||
30 | |||
31 | #define S5P64X0_CLK_GATE_HCLK0 S5P_CLKREG(0x30) | ||
32 | #define S5P64X0_CLK_GATE_PCLK S5P_CLKREG(0x34) | ||
33 | #define S5P64X0_CLK_GATE_SCLK0 S5P_CLKREG(0x38) | ||
34 | #define S5P64X0_CLK_GATE_MEM0 S5P_CLKREG(0x3C) | ||
35 | |||
36 | #define S5P64X0_CLK_DIV3 S5P_CLKREG(0x40) | ||
37 | |||
38 | #define S5P64X0_CLK_GATE_HCLK1 S5P_CLKREG(0x44) | ||
39 | #define S5P64X0_CLK_GATE_SCLK1 S5P_CLKREG(0x48) | ||
40 | |||
41 | #define S5P6450_DPLL_CON S5P_CLKREG(0x50) | ||
42 | #define S5P6450_DPLL_CON_K S5P_CLKREG(0x54) | ||
43 | |||
44 | #define S5P64X0_CLK_SRC1 S5P_CLKREG(0x10C) | ||
45 | |||
46 | #define S5P64X0_SYS_ID S5P_CLKREG(0x118) | ||
47 | #define S5P64X0_SYS_OTHERS S5P_CLKREG(0x11C) | ||
48 | |||
49 | #define S5P64X0_PWR_CFG S5P_CLKREG(0x804) | ||
50 | #define S5P64X0_OTHERS S5P_CLKREG(0x900) | ||
51 | |||
52 | #define S5P64X0_CLKDIV0_HCLK_SHIFT (8) | ||
53 | #define S5P64X0_CLKDIV0_HCLK_MASK (0xF << S5P64X0_CLKDIV0_HCLK_SHIFT) | ||
54 | |||
55 | #define S5P64X0_OTHERS_USB_SIG_MASK (1 << 16) | ||
56 | |||
57 | /* Compatibility defines */ | ||
58 | |||
59 | #define ARM_CLK_DIV S5P64X0_CLK_DIV0 | ||
60 | #define ARM_DIV_RATIO_SHIFT 0 | ||
61 | #define ARM_DIV_MASK (0xF << ARM_DIV_RATIO_SHIFT) | ||
62 | |||
63 | #endif /* __ASM_ARCH_REGS_CLOCK_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/regs-gpio.h b/arch/arm/mach-s5p64x0/include/mach/regs-gpio.h new file mode 100644 index 000000000000..85f448e20a8b --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/regs-gpio.h | |||
@@ -0,0 +1,62 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/regs-gpio.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - GPIO register definitions | ||
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 | #ifndef __ASM_ARCH_REGS_GPIO_H | ||
14 | #define __ASM_ARCH_REGS_GPIO_H __FILE__ | ||
15 | |||
16 | #include <mach/map.h> | ||
17 | |||
18 | /* Will be implemented S5P6442 GPIOlib */ | ||
19 | |||
20 | /* Base addresses for each of the banks */ | ||
21 | |||
22 | #define S5P6440_GPA_BASE (S5P_VA_GPIO + 0x0000) | ||
23 | #define S5P6440_GPB_BASE (S5P_VA_GPIO + 0x0020) | ||
24 | #define S5P6440_GPC_BASE (S5P_VA_GPIO + 0x0040) | ||
25 | #define S5P6440_GPF_BASE (S5P_VA_GPIO + 0x00A0) | ||
26 | #define S5P6440_GPG_BASE (S5P_VA_GPIO + 0x00C0) | ||
27 | #define S5P6440_GPH_BASE (S5P_VA_GPIO + 0x00E0) | ||
28 | #define S5P6440_GPI_BASE (S5P_VA_GPIO + 0x0100) | ||
29 | #define S5P6440_GPJ_BASE (S5P_VA_GPIO + 0x0120) | ||
30 | #define S5P6440_GPN_BASE (S5P_VA_GPIO + 0x0830) | ||
31 | #define S5P6440_GPP_BASE (S5P_VA_GPIO + 0x0160) | ||
32 | #define S5P6440_GPR_BASE (S5P_VA_GPIO + 0x0290) | ||
33 | |||
34 | #define S5P6440_EINT0CON0 (S5P_VA_GPIO + 0x900) | ||
35 | #define S5P6440_EINT0FLTCON0 (S5P_VA_GPIO + 0x910) | ||
36 | #define S5P6440_EINT0FLTCON1 (S5P_VA_GPIO + 0x914) | ||
37 | #define S5P6440_EINT0MASK (S5P_VA_GPIO + 0x920) | ||
38 | #define S5P6440_EINT0PEND (S5P_VA_GPIO + 0x924) | ||
39 | |||
40 | /* for LCD */ | ||
41 | |||
42 | #define S5P6440_SPCON_LCD_SEL_RGB (1 << 0) | ||
43 | #define S5P6440_SPCON_LCD_SEL_MASK (3 << 0) | ||
44 | |||
45 | /* | ||
46 | * These set of macros are not really useful for the | ||
47 | * GPF/GPI/GPJ/GPN/GPP, useful for others set of GPIO's (4 bit) | ||
48 | */ | ||
49 | |||
50 | #define S5P6440_GPIO_CONMASK(__gpio) (0xf << ((__gpio) * 4)) | ||
51 | #define S5P6440_GPIO_INPUT(__gpio) (0x0 << ((__gpio) * 4)) | ||
52 | #define S5P6440_GPIO_OUTPUT(__gpio) (0x1 << ((__gpio) * 4)) | ||
53 | |||
54 | /* | ||
55 | * Use these macros for GPF/GPI/GPJ/GPN/GPP set of GPIO (2 bit) | ||
56 | */ | ||
57 | |||
58 | #define S5P6440_GPIO2_CONMASK(__gpio) (0x3 << ((__gpio) * 2)) | ||
59 | #define S5P6440_GPIO2_INPUT(__gpio) (0x0 << ((__gpio) * 2)) | ||
60 | #define S5P6440_GPIO2_OUTPUT(__gpio) (0x1 << ((__gpio) * 2)) | ||
61 | |||
62 | #endif /* __ASM_ARCH_REGS_GPIO_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/regs-irq.h b/arch/arm/mach-s5p64x0/include/mach/regs-irq.h new file mode 100644 index 000000000000..4aaebdace55f --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/regs-irq.h | |||
@@ -0,0 +1,19 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/regs-irq.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - IRQ register definitions | ||
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 | #ifndef __ASM_ARCH_REGS_IRQ_H | ||
14 | #define __ASM_ARCH_REGS_IRQ_H __FILE__ | ||
15 | |||
16 | #include <asm/hardware/vic.h> | ||
17 | #include <mach/map.h> | ||
18 | |||
19 | #endif /* __ASM_ARCH_REGS_IRQ_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/s5p64x0-clock.h b/arch/arm/mach-s5p64x0/include/mach/s5p64x0-clock.h new file mode 100644 index 000000000000..ff85b4b6e8d9 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/s5p64x0-clock.h | |||
@@ -0,0 +1,46 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/s5p64x0-clock.h | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Header file for s5p64x0 clock support | ||
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 | #ifndef __ASM_ARCH_CLOCK_H | ||
14 | #define __ASM_ARCH_CLOCK_H __FILE__ | ||
15 | |||
16 | #include <linux/clk.h> | ||
17 | |||
18 | extern struct clksrc_clk clk_mout_apll; | ||
19 | extern struct clksrc_clk clk_mout_mpll; | ||
20 | extern struct clksrc_clk clk_mout_epll; | ||
21 | |||
22 | extern int s5p64x0_epll_enable(struct clk *clk, int enable); | ||
23 | extern unsigned long s5p64x0_epll_get_rate(struct clk *clk); | ||
24 | |||
25 | extern unsigned long s5p64x0_armclk_get_rate(struct clk *clk); | ||
26 | extern unsigned long s5p64x0_armclk_round_rate(struct clk *clk, unsigned long rate); | ||
27 | extern int s5p64x0_armclk_set_rate(struct clk *clk, unsigned long rate); | ||
28 | |||
29 | extern struct clk_ops s5p64x0_clkarm_ops; | ||
30 | |||
31 | extern struct clksrc_clk clk_armclk; | ||
32 | extern struct clksrc_clk clk_dout_mpll; | ||
33 | |||
34 | extern struct clk *clkset_hclk_low_list[]; | ||
35 | extern struct clksrc_sources clkset_hclk_low; | ||
36 | |||
37 | extern int s5p64x0_pclk_ctrl(struct clk *clk, int enable); | ||
38 | extern int s5p64x0_hclk0_ctrl(struct clk *clk, int enable); | ||
39 | extern int s5p64x0_hclk1_ctrl(struct clk *clk, int enable); | ||
40 | extern int s5p64x0_sclk_ctrl(struct clk *clk, int enable); | ||
41 | extern int s5p64x0_sclk1_ctrl(struct clk *clk, int enable); | ||
42 | extern int s5p64x0_mem_ctrl(struct clk *clk, int enable); | ||
43 | |||
44 | extern int s5p64x0_clk48m_ctrl(struct clk *clk, int enable); | ||
45 | |||
46 | #endif /* __ASM_ARCH_CLOCK_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/spi-clocks.h b/arch/arm/mach-s5p64x0/include/mach/spi-clocks.h new file mode 100644 index 000000000000..170a20a9643a --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/spi-clocks.h | |||
@@ -0,0 +1,20 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/spi-clocks.h | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Copyright (C) 2010 Samsung Electronics Co. Ltd. | ||
7 | * Jaswinder Singh <jassi.brar@samsung.com> | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | */ | ||
13 | |||
14 | #ifndef __ASM_ARCH_SPI_CLKS_H | ||
15 | #define __ASM_ARCH_SPI_CLKS_H __FILE__ | ||
16 | |||
17 | #define S5P64X0_SPI_SRCCLK_PCLK 0 | ||
18 | #define S5P64X0_SPI_SRCCLK_SCLK 1 | ||
19 | |||
20 | #endif /* __ASM_ARCH_SPI_CLKS_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/system.h b/arch/arm/mach-s5p64x0/include/mach/system.h new file mode 100644 index 000000000000..60f57532c970 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/system.h | |||
@@ -0,0 +1,23 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/system.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - system support header | ||
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 | #ifndef __ASM_ARCH_SYSTEM_H | ||
14 | #define __ASM_ARCH_SYSTEM_H __FILE__ | ||
15 | |||
16 | #include <plat/system-reset.h> | ||
17 | |||
18 | static void arch_idle(void) | ||
19 | { | ||
20 | /* nothing here yet */ | ||
21 | } | ||
22 | |||
23 | #endif /* __ASM_ARCH_SYSTEM_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/tick.h b/arch/arm/mach-s5p64x0/include/mach/tick.h new file mode 100644 index 000000000000..00aa7f1d8e51 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/tick.h | |||
@@ -0,0 +1,29 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/tick.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Copyright 2008 Openmoko, Inc. | ||
7 | * Copyright 2008 Simtec Electronics | ||
8 | * http://armlinux.simtec.co.uk/ | ||
9 | * Ben Dooks <ben@simtec.co.uk> | ||
10 | * | ||
11 | * S5P64X0 - Timer tick support definitions | ||
12 | * | ||
13 | * This program is free software; you can redistribute it and/or modify | ||
14 | * it under the terms of the GNU General Public License version 2 as | ||
15 | * published by the Free Software Foundation. | ||
16 | */ | ||
17 | |||
18 | #ifndef __ASM_ARCH_TICK_H | ||
19 | #define __ASM_ARCH_TICK_H __FILE__ | ||
20 | |||
21 | static inline u32 s3c24xx_ostimer_pending(void) | ||
22 | { | ||
23 | u32 pend = __raw_readl(VA_VIC0 + VIC_RAW_STATUS); | ||
24 | return pend & (1 << (IRQ_TIMER4_VIC - S5P_IRQ_VIC0(0))); | ||
25 | } | ||
26 | |||
27 | #define TICK_MAX (0xffffffff) | ||
28 | |||
29 | #endif /* __ASM_ARCH_TICK_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/timex.h b/arch/arm/mach-s5p64x0/include/mach/timex.h new file mode 100644 index 000000000000..4b91faa195a8 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/timex.h | |||
@@ -0,0 +1,27 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/timex.h | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Copyright (c) 2003-2005 Simtec Electronics | ||
7 | * Ben Dooks <ben@simtec.co.uk> | ||
8 | * | ||
9 | * S5P64X0 - time parameters | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or modify | ||
12 | * it under the terms of the GNU General Public License version 2 as | ||
13 | * published by the Free Software Foundation. | ||
14 | */ | ||
15 | |||
16 | #ifndef __ASM_ARCH_TIMEX_H | ||
17 | #define __ASM_ARCH_TIMEX_H | ||
18 | |||
19 | /* CLOCK_TICK_RATE needs to be evaluatable by the cpp, so making it | ||
20 | * a variable is useless. It seems as long as we make our timers an | ||
21 | * exact multiple of HZ, any value that makes a 1->1 correspondence | ||
22 | * for the time conversion functions to/from jiffies is acceptable. | ||
23 | */ | ||
24 | |||
25 | #define CLOCK_TICK_RATE 12000000 | ||
26 | |||
27 | #endif /* __ASM_ARCH_TIMEX_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/uncompress.h b/arch/arm/mach-s5p64x0/include/mach/uncompress.h new file mode 100644 index 000000000000..c65b229aab23 --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/uncompress.h | |||
@@ -0,0 +1,212 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/uncompress.h | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - uncompress code | ||
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 | #ifndef __ASM_ARCH_UNCOMPRESS_H | ||
14 | #define __ASM_ARCH_UNCOMPRESS_H | ||
15 | |||
16 | #include <mach/map.h> | ||
17 | |||
18 | /* | ||
19 | * cannot use commonly <plat/uncompress.h> | ||
20 | * because uart base of S5P6440 and S5P6450 is different | ||
21 | */ | ||
22 | |||
23 | typedef unsigned int upf_t; /* cannot include linux/serial_core.h */ | ||
24 | |||
25 | /* uart setup */ | ||
26 | |||
27 | static unsigned int fifo_mask; | ||
28 | static unsigned int fifo_max; | ||
29 | |||
30 | /* forward declerations */ | ||
31 | |||
32 | static void arch_detect_cpu(void); | ||
33 | |||
34 | /* defines for UART registers */ | ||
35 | |||
36 | #include <plat/regs-serial.h> | ||
37 | #include <plat/regs-watchdog.h> | ||
38 | |||
39 | /* working in physical space... */ | ||
40 | #undef S3C2410_WDOGREG | ||
41 | #define S3C2410_WDOGREG(x) ((S3C24XX_PA_WATCHDOG + (x))) | ||
42 | |||
43 | /* how many bytes we allow into the FIFO at a time in FIFO mode */ | ||
44 | #define FIFO_MAX (14) | ||
45 | |||
46 | static unsigned long uart_base; | ||
47 | |||
48 | static __inline__ void get_uart_base(void) | ||
49 | { | ||
50 | unsigned int chipid; | ||
51 | |||
52 | chipid = *(const volatile unsigned int __force *) 0xE0100118; | ||
53 | |||
54 | uart_base = S3C_UART_OFFSET * CONFIG_S3C_LOWLEVEL_UART_PORT; | ||
55 | |||
56 | if ((chipid & 0xff000) == 0x50000) | ||
57 | uart_base += 0xEC800000; | ||
58 | else | ||
59 | uart_base += 0xEC000000; | ||
60 | } | ||
61 | |||
62 | static __inline__ void uart_wr(unsigned int reg, unsigned int val) | ||
63 | { | ||
64 | volatile unsigned int *ptr; | ||
65 | |||
66 | get_uart_base(); | ||
67 | ptr = (volatile unsigned int *)(reg + uart_base); | ||
68 | *ptr = val; | ||
69 | } | ||
70 | |||
71 | static __inline__ unsigned int uart_rd(unsigned int reg) | ||
72 | { | ||
73 | volatile unsigned int *ptr; | ||
74 | |||
75 | get_uart_base(); | ||
76 | ptr = (volatile unsigned int *)(reg + uart_base); | ||
77 | return *ptr; | ||
78 | } | ||
79 | |||
80 | /* | ||
81 | * we can deal with the case the UARTs are being run | ||
82 | * in FIFO mode, so that we don't hold up our execution | ||
83 | * waiting for tx to happen... | ||
84 | */ | ||
85 | |||
86 | static void putc(int ch) | ||
87 | { | ||
88 | if (uart_rd(S3C2410_UFCON) & S3C2410_UFCON_FIFOMODE) { | ||
89 | int level; | ||
90 | |||
91 | while (1) { | ||
92 | level = uart_rd(S3C2410_UFSTAT); | ||
93 | level &= fifo_mask; | ||
94 | |||
95 | if (level < fifo_max) | ||
96 | break; | ||
97 | } | ||
98 | |||
99 | } else { | ||
100 | /* not using fifos */ | ||
101 | |||
102 | while ((uart_rd(S3C2410_UTRSTAT) & S3C2410_UTRSTAT_TXE) != S3C2410_UTRSTAT_TXE) | ||
103 | barrier(); | ||
104 | } | ||
105 | |||
106 | /* write byte to transmission register */ | ||
107 | uart_wr(S3C2410_UTXH, ch); | ||
108 | } | ||
109 | |||
110 | static inline void flush(void) | ||
111 | { | ||
112 | } | ||
113 | |||
114 | #define __raw_writel(d, ad) \ | ||
115 | do { \ | ||
116 | *((volatile unsigned int __force *)(ad)) = (d); \ | ||
117 | } while (0) | ||
118 | |||
119 | /* | ||
120 | * CONFIG_S3C_BOOT_WATCHDOG | ||
121 | * | ||
122 | * Simple boot-time watchdog setup, to reboot the system if there is | ||
123 | * any problem with the boot process | ||
124 | */ | ||
125 | |||
126 | #ifdef CONFIG_S3C_BOOT_WATCHDOG | ||
127 | |||
128 | #define WDOG_COUNT (0xff00) | ||
129 | |||
130 | static inline void arch_decomp_wdog(void) | ||
131 | { | ||
132 | __raw_writel(WDOG_COUNT, S3C2410_WTCNT); | ||
133 | } | ||
134 | |||
135 | static void arch_decomp_wdog_start(void) | ||
136 | { | ||
137 | __raw_writel(WDOG_COUNT, S3C2410_WTDAT); | ||
138 | __raw_writel(WDOG_COUNT, S3C2410_WTCNT); | ||
139 | __raw_writel(S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128 | S3C2410_WTCON_RSTEN | S3C2410_WTCON_PRESCALE(0x80), S3C2410_WTCON); | ||
140 | } | ||
141 | |||
142 | #else | ||
143 | #define arch_decomp_wdog_start() | ||
144 | #define arch_decomp_wdog() | ||
145 | #endif | ||
146 | |||
147 | #ifdef CONFIG_S3C_BOOT_ERROR_RESET | ||
148 | |||
149 | static void arch_decomp_error(const char *x) | ||
150 | { | ||
151 | putstr("\n\n"); | ||
152 | putstr(x); | ||
153 | putstr("\n\n -- System resetting\n"); | ||
154 | |||
155 | __raw_writel(0x4000, S3C2410_WTDAT); | ||
156 | __raw_writel(0x4000, S3C2410_WTCNT); | ||
157 | __raw_writel(S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128 | S3C2410_WTCON_RSTEN | S3C2410_WTCON_PRESCALE(0x40), S3C2410_WTCON); | ||
158 | |||
159 | while(1); | ||
160 | } | ||
161 | |||
162 | #define arch_error arch_decomp_error | ||
163 | #endif | ||
164 | |||
165 | #ifdef CONFIG_S3C_BOOT_UART_FORCE_FIFO | ||
166 | static inline void arch_enable_uart_fifo(void) | ||
167 | { | ||
168 | u32 fifocon = uart_rd(S3C2410_UFCON); | ||
169 | |||
170 | if (!(fifocon & S3C2410_UFCON_FIFOMODE)) { | ||
171 | fifocon |= S3C2410_UFCON_RESETBOTH; | ||
172 | uart_wr(S3C2410_UFCON, fifocon); | ||
173 | |||
174 | /* wait for fifo reset to complete */ | ||
175 | while (1) { | ||
176 | fifocon = uart_rd(S3C2410_UFCON); | ||
177 | if (!(fifocon & S3C2410_UFCON_RESETBOTH)) | ||
178 | break; | ||
179 | } | ||
180 | } | ||
181 | } | ||
182 | #else | ||
183 | #define arch_enable_uart_fifo() do { } while(0) | ||
184 | #endif | ||
185 | |||
186 | static void arch_decomp_setup(void) | ||
187 | { | ||
188 | /* | ||
189 | * we may need to setup the uart(s) here if we are not running | ||
190 | * on an BAST... the BAST will have left the uarts configured | ||
191 | * after calling linux. | ||
192 | */ | ||
193 | |||
194 | arch_detect_cpu(); | ||
195 | arch_decomp_wdog_start(); | ||
196 | |||
197 | /* | ||
198 | * Enable the UART FIFOs if they where not enabled and our | ||
199 | * configuration says we should turn them on. | ||
200 | */ | ||
201 | |||
202 | arch_enable_uart_fifo(); | ||
203 | } | ||
204 | |||
205 | |||
206 | |||
207 | static void arch_detect_cpu(void) | ||
208 | { | ||
209 | /* we do not need to do any cpu detection here at the moment. */ | ||
210 | } | ||
211 | |||
212 | #endif /* __ASM_ARCH_UNCOMPRESS_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/include/mach/vmalloc.h b/arch/arm/mach-s5p64x0/include/mach/vmalloc.h new file mode 100644 index 000000000000..97a9df38f1cf --- /dev/null +++ b/arch/arm/mach-s5p64x0/include/mach/vmalloc.h | |||
@@ -0,0 +1,20 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/include/mach/vmalloc.h | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * Copyright 2010 Ben Dooks <ben-linux@fluff.org> | ||
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 | * S3C6400 vmalloc definition | ||
13 | */ | ||
14 | |||
15 | #ifndef __ASM_ARCH_VMALLOC_H | ||
16 | #define __ASM_ARCH_VMALLOC_H | ||
17 | |||
18 | #define VMALLOC_END 0xE0000000UL | ||
19 | |||
20 | #endif /* __ASM_ARCH_VMALLOC_H */ | ||
diff --git a/arch/arm/mach-s5p64x0/init.c b/arch/arm/mach-s5p64x0/init.c new file mode 100644 index 000000000000..79833caf8165 --- /dev/null +++ b/arch/arm/mach-s5p64x0/init.c | |||
@@ -0,0 +1,73 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/init.c | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * S5P64X0 - Init support | ||
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/kernel.h> | ||
14 | #include <linux/types.h> | ||
15 | #include <linux/init.h> | ||
16 | #include <linux/serial_core.h> | ||
17 | |||
18 | #include <mach/map.h> | ||
19 | |||
20 | #include <plat/cpu.h> | ||
21 | #include <plat/devs.h> | ||
22 | #include <plat/s5p6440.h> | ||
23 | #include <plat/s5p6450.h> | ||
24 | #include <plat/regs-serial.h> | ||
25 | |||
26 | static struct s3c24xx_uart_clksrc s5p64x0_serial_clocks[] = { | ||
27 | [0] = { | ||
28 | .name = "pclk_low", | ||
29 | .divisor = 1, | ||
30 | .min_baud = 0, | ||
31 | .max_baud = 0, | ||
32 | }, | ||
33 | [1] = { | ||
34 | .name = "uclk1", | ||
35 | .divisor = 1, | ||
36 | .min_baud = 0, | ||
37 | .max_baud = 0, | ||
38 | }, | ||
39 | }; | ||
40 | |||
41 | /* uart registration process */ | ||
42 | |||
43 | void __init s5p64x0_common_init_uarts(struct s3c2410_uartcfg *cfg, int no) | ||
44 | { | ||
45 | struct s3c2410_uartcfg *tcfg = cfg; | ||
46 | u32 ucnt; | ||
47 | |||
48 | for (ucnt = 0; ucnt < no; ucnt++, tcfg++) { | ||
49 | if (!tcfg->clocks) { | ||
50 | tcfg->clocks = s5p64x0_serial_clocks; | ||
51 | tcfg->clocks_size = ARRAY_SIZE(s5p64x0_serial_clocks); | ||
52 | } | ||
53 | } | ||
54 | } | ||
55 | |||
56 | void __init s5p6440_init_uarts(struct s3c2410_uartcfg *cfg, int no) | ||
57 | { | ||
58 | int uart; | ||
59 | |||
60 | for (uart = 0; uart < no; uart++) { | ||
61 | s5p_uart_resources[uart].resources->start = S5P6440_PA_UART(uart); | ||
62 | s5p_uart_resources[uart].resources->end = S5P6440_PA_UART(uart) + S5P_SZ_UART; | ||
63 | } | ||
64 | |||
65 | s5p64x0_common_init_uarts(cfg, no); | ||
66 | s3c24xx_init_uartdevs("s3c6400-uart", s5p_uart_resources, cfg, no); | ||
67 | } | ||
68 | |||
69 | void __init s5p6450_init_uarts(struct s3c2410_uartcfg *cfg, int no) | ||
70 | { | ||
71 | s5p64x0_common_init_uarts(cfg, no); | ||
72 | s3c24xx_init_uartdevs("s3c6400-uart", s5p_uart_resources, cfg, no); | ||
73 | } | ||
diff --git a/arch/arm/mach-s5p64x0/mach-smdk6440.c b/arch/arm/mach-s5p64x0/mach-smdk6440.c new file mode 100644 index 000000000000..28de0a57208c --- /dev/null +++ b/arch/arm/mach-s5p64x0/mach-smdk6440.c | |||
@@ -0,0 +1,163 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/mach-smdk6440.c | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
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 | |||
11 | #include <linux/kernel.h> | ||
12 | #include <linux/types.h> | ||
13 | #include <linux/interrupt.h> | ||
14 | #include <linux/list.h> | ||
15 | #include <linux/timer.h> | ||
16 | #include <linux/delay.h> | ||
17 | #include <linux/init.h> | ||
18 | #include <linux/i2c.h> | ||
19 | #include <linux/serial_core.h> | ||
20 | #include <linux/platform_device.h> | ||
21 | #include <linux/io.h> | ||
22 | #include <linux/module.h> | ||
23 | #include <linux/clk.h> | ||
24 | #include <linux/gpio.h> | ||
25 | |||
26 | #include <asm/mach/arch.h> | ||
27 | #include <asm/mach/map.h> | ||
28 | #include <asm/irq.h> | ||
29 | #include <asm/mach-types.h> | ||
30 | |||
31 | #include <mach/hardware.h> | ||
32 | #include <mach/map.h> | ||
33 | #include <mach/regs-clock.h> | ||
34 | #include <mach/i2c.h> | ||
35 | |||
36 | #include <plat/regs-serial.h> | ||
37 | #include <plat/gpio-cfg.h> | ||
38 | #include <plat/s5p6440.h> | ||
39 | #include <plat/clock.h> | ||
40 | #include <plat/devs.h> | ||
41 | #include <plat/cpu.h> | ||
42 | #include <plat/iic.h> | ||
43 | #include <plat/pll.h> | ||
44 | #include <plat/adc.h> | ||
45 | #include <plat/ts.h> | ||
46 | |||
47 | #define SMDK6440_UCON_DEFAULT (S3C2410_UCON_TXILEVEL | \ | ||
48 | S3C2410_UCON_RXILEVEL | \ | ||
49 | S3C2410_UCON_TXIRQMODE | \ | ||
50 | S3C2410_UCON_RXIRQMODE | \ | ||
51 | S3C2410_UCON_RXFIFO_TOI | \ | ||
52 | S3C2443_UCON_RXERR_IRQEN) | ||
53 | |||
54 | #define SMDK6440_ULCON_DEFAULT S3C2410_LCON_CS8 | ||
55 | |||
56 | #define SMDK6440_UFCON_DEFAULT (S3C2410_UFCON_FIFOMODE | \ | ||
57 | S3C2440_UFCON_TXTRIG16 | \ | ||
58 | S3C2410_UFCON_RXTRIG8) | ||
59 | |||
60 | static struct s3c2410_uartcfg smdk6440_uartcfgs[] __initdata = { | ||
61 | [0] = { | ||
62 | .hwport = 0, | ||
63 | .flags = 0, | ||
64 | .ucon = SMDK6440_UCON_DEFAULT, | ||
65 | .ulcon = SMDK6440_ULCON_DEFAULT, | ||
66 | .ufcon = SMDK6440_UFCON_DEFAULT, | ||
67 | }, | ||
68 | [1] = { | ||
69 | .hwport = 1, | ||
70 | .flags = 0, | ||
71 | .ucon = SMDK6440_UCON_DEFAULT, | ||
72 | .ulcon = SMDK6440_ULCON_DEFAULT, | ||
73 | .ufcon = SMDK6440_UFCON_DEFAULT, | ||
74 | }, | ||
75 | [2] = { | ||
76 | .hwport = 2, | ||
77 | .flags = 0, | ||
78 | .ucon = SMDK6440_UCON_DEFAULT, | ||
79 | .ulcon = SMDK6440_ULCON_DEFAULT, | ||
80 | .ufcon = SMDK6440_UFCON_DEFAULT, | ||
81 | }, | ||
82 | [3] = { | ||
83 | .hwport = 3, | ||
84 | .flags = 0, | ||
85 | .ucon = SMDK6440_UCON_DEFAULT, | ||
86 | .ulcon = SMDK6440_ULCON_DEFAULT, | ||
87 | .ufcon = SMDK6440_UFCON_DEFAULT, | ||
88 | }, | ||
89 | }; | ||
90 | |||
91 | static struct platform_device *smdk6440_devices[] __initdata = { | ||
92 | &s3c_device_adc, | ||
93 | &s3c_device_rtc, | ||
94 | &s3c_device_i2c0, | ||
95 | &s3c_device_i2c1, | ||
96 | &s3c_device_ts, | ||
97 | &s3c_device_wdt, | ||
98 | &s5p6440_device_iis, | ||
99 | }; | ||
100 | |||
101 | static struct s3c2410_platform_i2c s5p6440_i2c0_data __initdata = { | ||
102 | .flags = 0, | ||
103 | .slave_addr = 0x10, | ||
104 | .frequency = 100*1000, | ||
105 | .sda_delay = 100, | ||
106 | .cfg_gpio = s5p6440_i2c0_cfg_gpio, | ||
107 | }; | ||
108 | |||
109 | static struct s3c2410_platform_i2c s5p6440_i2c1_data __initdata = { | ||
110 | .flags = 0, | ||
111 | .bus_num = 1, | ||
112 | .slave_addr = 0x10, | ||
113 | .frequency = 100*1000, | ||
114 | .sda_delay = 100, | ||
115 | .cfg_gpio = s5p6440_i2c1_cfg_gpio, | ||
116 | }; | ||
117 | |||
118 | static struct i2c_board_info smdk6440_i2c_devs0[] __initdata = { | ||
119 | { I2C_BOARD_INFO("24c08", 0x50), }, | ||
120 | }; | ||
121 | |||
122 | static struct i2c_board_info smdk6440_i2c_devs1[] __initdata = { | ||
123 | /* To be populated */ | ||
124 | }; | ||
125 | |||
126 | static struct s3c2410_ts_mach_info s3c_ts_platform __initdata = { | ||
127 | .delay = 10000, | ||
128 | .presc = 49, | ||
129 | .oversampling_shift = 2, | ||
130 | }; | ||
131 | |||
132 | static void __init smdk6440_map_io(void) | ||
133 | { | ||
134 | s5p_init_io(NULL, 0, S5P64X0_SYS_ID); | ||
135 | s3c24xx_init_clocks(12000000); | ||
136 | s3c24xx_init_uarts(smdk6440_uartcfgs, ARRAY_SIZE(smdk6440_uartcfgs)); | ||
137 | } | ||
138 | |||
139 | static void __init smdk6440_machine_init(void) | ||
140 | { | ||
141 | s3c24xx_ts_set_platdata(&s3c_ts_platform); | ||
142 | |||
143 | s3c_i2c0_set_platdata(&s5p6440_i2c0_data); | ||
144 | s3c_i2c1_set_platdata(&s5p6440_i2c1_data); | ||
145 | i2c_register_board_info(0, smdk6440_i2c_devs0, | ||
146 | ARRAY_SIZE(smdk6440_i2c_devs0)); | ||
147 | i2c_register_board_info(1, smdk6440_i2c_devs1, | ||
148 | ARRAY_SIZE(smdk6440_i2c_devs1)); | ||
149 | |||
150 | platform_add_devices(smdk6440_devices, ARRAY_SIZE(smdk6440_devices)); | ||
151 | } | ||
152 | |||
153 | MACHINE_START(SMDK6440, "SMDK6440") | ||
154 | /* Maintainer: Kukjin Kim <kgene.kim@samsung.com> */ | ||
155 | .phys_io = S5P6440_PA_UART(0) & 0xfff00000, | ||
156 | .io_pg_offst = (((u32)S3C_VA_UART) >> 18) & 0xfffc, | ||
157 | .boot_params = S5P64X0_PA_SDRAM + 0x100, | ||
158 | |||
159 | .init_irq = s5p6440_init_irq, | ||
160 | .map_io = smdk6440_map_io, | ||
161 | .init_machine = smdk6440_machine_init, | ||
162 | .timer = &s3c24xx_timer, | ||
163 | MACHINE_END | ||
diff --git a/arch/arm/mach-s5p64x0/mach-smdk6450.c b/arch/arm/mach-s5p64x0/mach-smdk6450.c new file mode 100644 index 000000000000..8e982171418b --- /dev/null +++ b/arch/arm/mach-s5p64x0/mach-smdk6450.c | |||
@@ -0,0 +1,182 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/mach-smdk6450.c | ||
2 | * | ||
3 | * Copyright (c) 2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
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 | |||
11 | #include <linux/kernel.h> | ||
12 | #include <linux/types.h> | ||
13 | #include <linux/interrupt.h> | ||
14 | #include <linux/list.h> | ||
15 | #include <linux/timer.h> | ||
16 | #include <linux/delay.h> | ||
17 | #include <linux/init.h> | ||
18 | #include <linux/i2c.h> | ||
19 | #include <linux/serial_core.h> | ||
20 | #include <linux/platform_device.h> | ||
21 | #include <linux/io.h> | ||
22 | #include <linux/module.h> | ||
23 | #include <linux/clk.h> | ||
24 | #include <linux/gpio.h> | ||
25 | |||
26 | #include <asm/mach/arch.h> | ||
27 | #include <asm/mach/map.h> | ||
28 | #include <asm/irq.h> | ||
29 | #include <asm/mach-types.h> | ||
30 | |||
31 | #include <mach/hardware.h> | ||
32 | #include <mach/map.h> | ||
33 | #include <mach/regs-clock.h> | ||
34 | #include <mach/i2c.h> | ||
35 | |||
36 | #include <plat/regs-serial.h> | ||
37 | #include <plat/gpio-cfg.h> | ||
38 | #include <plat/s5p6450.h> | ||
39 | #include <plat/clock.h> | ||
40 | #include <plat/devs.h> | ||
41 | #include <plat/cpu.h> | ||
42 | #include <plat/iic.h> | ||
43 | #include <plat/pll.h> | ||
44 | #include <plat/adc.h> | ||
45 | #include <plat/ts.h> | ||
46 | |||
47 | #define SMDK6450_UCON_DEFAULT (S3C2410_UCON_TXILEVEL | \ | ||
48 | S3C2410_UCON_RXILEVEL | \ | ||
49 | S3C2410_UCON_TXIRQMODE | \ | ||
50 | S3C2410_UCON_RXIRQMODE | \ | ||
51 | S3C2410_UCON_RXFIFO_TOI | \ | ||
52 | S3C2443_UCON_RXERR_IRQEN) | ||
53 | |||
54 | #define SMDK6450_ULCON_DEFAULT S3C2410_LCON_CS8 | ||
55 | |||
56 | #define SMDK6450_UFCON_DEFAULT (S3C2410_UFCON_FIFOMODE | \ | ||
57 | S3C2440_UFCON_TXTRIG16 | \ | ||
58 | S3C2410_UFCON_RXTRIG8) | ||
59 | |||
60 | static struct s3c2410_uartcfg smdk6450_uartcfgs[] __initdata = { | ||
61 | [0] = { | ||
62 | .hwport = 0, | ||
63 | .flags = 0, | ||
64 | .ucon = SMDK6450_UCON_DEFAULT, | ||
65 | .ulcon = SMDK6450_ULCON_DEFAULT, | ||
66 | .ufcon = SMDK6450_UFCON_DEFAULT, | ||
67 | }, | ||
68 | [1] = { | ||
69 | .hwport = 1, | ||
70 | .flags = 0, | ||
71 | .ucon = SMDK6450_UCON_DEFAULT, | ||
72 | .ulcon = SMDK6450_ULCON_DEFAULT, | ||
73 | .ufcon = SMDK6450_UFCON_DEFAULT, | ||
74 | }, | ||
75 | [2] = { | ||
76 | .hwport = 2, | ||
77 | .flags = 0, | ||
78 | .ucon = SMDK6450_UCON_DEFAULT, | ||
79 | .ulcon = SMDK6450_ULCON_DEFAULT, | ||
80 | .ufcon = SMDK6450_UFCON_DEFAULT, | ||
81 | }, | ||
82 | [3] = { | ||
83 | .hwport = 3, | ||
84 | .flags = 0, | ||
85 | .ucon = SMDK6450_UCON_DEFAULT, | ||
86 | .ulcon = SMDK6450_ULCON_DEFAULT, | ||
87 | .ufcon = SMDK6450_UFCON_DEFAULT, | ||
88 | }, | ||
89 | #if CONFIG_SERIAL_SAMSUNG_UARTS > 4 | ||
90 | [4] = { | ||
91 | .hwport = 4, | ||
92 | .flags = 0, | ||
93 | .ucon = SMDK6450_UCON_DEFAULT, | ||
94 | .ulcon = SMDK6450_ULCON_DEFAULT, | ||
95 | .ufcon = SMDK6450_UFCON_DEFAULT, | ||
96 | }, | ||
97 | #endif | ||
98 | #if CONFIG_SERIAL_SAMSUNG_UARTS > 5 | ||
99 | [5] = { | ||
100 | .hwport = 5, | ||
101 | .flags = 0, | ||
102 | .ucon = SMDK6450_UCON_DEFAULT, | ||
103 | .ulcon = SMDK6450_ULCON_DEFAULT, | ||
104 | .ufcon = SMDK6450_UFCON_DEFAULT, | ||
105 | }, | ||
106 | #endif | ||
107 | }; | ||
108 | |||
109 | static struct platform_device *smdk6450_devices[] __initdata = { | ||
110 | &s3c_device_adc, | ||
111 | &s3c_device_rtc, | ||
112 | &s3c_device_i2c0, | ||
113 | &s3c_device_i2c1, | ||
114 | &s3c_device_ts, | ||
115 | &s3c_device_wdt, | ||
116 | &s5p6450_device_iis0, | ||
117 | /* s5p6450_device_spi0 will be added */ | ||
118 | }; | ||
119 | |||
120 | static struct s3c2410_platform_i2c s5p6450_i2c0_data __initdata = { | ||
121 | .flags = 0, | ||
122 | .slave_addr = 0x10, | ||
123 | .frequency = 100*1000, | ||
124 | .sda_delay = 100, | ||
125 | .cfg_gpio = s5p6450_i2c0_cfg_gpio, | ||
126 | }; | ||
127 | |||
128 | static struct s3c2410_platform_i2c s5p6450_i2c1_data __initdata = { | ||
129 | .flags = 0, | ||
130 | .bus_num = 1, | ||
131 | .slave_addr = 0x10, | ||
132 | .frequency = 100*1000, | ||
133 | .sda_delay = 100, | ||
134 | .cfg_gpio = s5p6450_i2c1_cfg_gpio, | ||
135 | }; | ||
136 | |||
137 | static struct i2c_board_info smdk6450_i2c_devs0[] __initdata = { | ||
138 | { I2C_BOARD_INFO("24c08", 0x50), }, /* Samsung KS24C080C EEPROM */ | ||
139 | }; | ||
140 | |||
141 | static struct i2c_board_info smdk6450_i2c_devs1[] __initdata = { | ||
142 | { I2C_BOARD_INFO("24c128", 0x57), },/* Samsung S524AD0XD1 EEPROM */ | ||
143 | }; | ||
144 | |||
145 | static struct s3c2410_ts_mach_info s3c_ts_platform __initdata = { | ||
146 | .delay = 10000, | ||
147 | .presc = 49, | ||
148 | .oversampling_shift = 2, | ||
149 | }; | ||
150 | |||
151 | static void __init smdk6450_map_io(void) | ||
152 | { | ||
153 | s5p_init_io(NULL, 0, S5P64X0_SYS_ID); | ||
154 | s3c24xx_init_clocks(19200000); | ||
155 | s3c24xx_init_uarts(smdk6450_uartcfgs, ARRAY_SIZE(smdk6450_uartcfgs)); | ||
156 | } | ||
157 | |||
158 | static void __init smdk6450_machine_init(void) | ||
159 | { | ||
160 | s3c24xx_ts_set_platdata(&s3c_ts_platform); | ||
161 | |||
162 | s3c_i2c0_set_platdata(&s5p6450_i2c0_data); | ||
163 | s3c_i2c1_set_platdata(&s5p6450_i2c1_data); | ||
164 | i2c_register_board_info(0, smdk6450_i2c_devs0, | ||
165 | ARRAY_SIZE(smdk6450_i2c_devs0)); | ||
166 | i2c_register_board_info(1, smdk6450_i2c_devs1, | ||
167 | ARRAY_SIZE(smdk6450_i2c_devs1)); | ||
168 | |||
169 | platform_add_devices(smdk6450_devices, ARRAY_SIZE(smdk6450_devices)); | ||
170 | } | ||
171 | |||
172 | MACHINE_START(SMDK6450, "SMDK6450") | ||
173 | /* Maintainer: Kukjin Kim <kgene.kim@samsung.com> */ | ||
174 | .phys_io = S5P6450_PA_UART(0) & 0xfff00000, | ||
175 | .io_pg_offst = (((u32)S3C_VA_UART) >> 18) & 0xfffc, | ||
176 | .boot_params = S5P64X0_PA_SDRAM + 0x100, | ||
177 | |||
178 | .init_irq = s5p6450_init_irq, | ||
179 | .map_io = smdk6450_map_io, | ||
180 | .init_machine = smdk6450_machine_init, | ||
181 | .timer = &s3c24xx_timer, | ||
182 | MACHINE_END | ||
diff --git a/arch/arm/mach-s5p64x0/setup-i2c0.c b/arch/arm/mach-s5p64x0/setup-i2c0.c new file mode 100644 index 000000000000..dc4cc65a5019 --- /dev/null +++ b/arch/arm/mach-s5p64x0/setup-i2c0.c | |||
@@ -0,0 +1,42 @@ | |||
1 | /* linux/arch/arm/mach-s5p64x0/setup-i2c0.c | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * I2C0 GPIO configuration. | ||
7 | * | ||
8 | * Based on plat-s3c64x0/setup-i2c0.c | ||
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 | #include <linux/kernel.h> | ||
16 | #include <linux/types.h> | ||
17 | #include <linux/gpio.h> | ||
18 | |||
19 | struct platform_device; /* don't need the contents */ | ||
20 | |||
21 | #include <plat/gpio-cfg.h> | ||
22 | #include <plat/iic.h> | ||
23 | |||
24 | #include <mach/i2c.h> | ||
25 | |||
26 | void s5p6440_i2c0_cfg_gpio(struct platform_device *dev) | ||
27 | { | ||
28 | s3c_gpio_cfgpin(S5P6440_GPB(5), S3C_GPIO_SFN(2)); | ||
29 | s3c_gpio_setpull(S5P6440_GPB(5), S3C_GPIO_PULL_UP); | ||
30 | s3c_gpio_cfgpin(S5P6440_GPB(6), S3C_GPIO_SFN(2)); | ||
31 | s3c_gpio_setpull(S5P6440_GPB(6), S3C_GPIO_PULL_UP); | ||
32 | } | ||
33 | |||
34 | void s5p6450_i2c0_cfg_gpio(struct platform_device *dev) | ||
35 | { | ||
36 | s3c_gpio_cfgpin(S5P6450_GPB(5), S3C_GPIO_SFN(2)); | ||
37 | s3c_gpio_setpull(S5P6450_GPB(5), S3C_GPIO_PULL_UP); | ||
38 | s3c_gpio_cfgpin(S5P6450_GPB(6), S3C_GPIO_SFN(2)); | ||
39 | s3c_gpio_setpull(S5P6450_GPB(6), S3C_GPIO_PULL_UP); | ||
40 | } | ||
41 | |||
42 | void s3c_i2c0_cfg_gpio(struct platform_device *dev) { } | ||
diff --git a/arch/arm/mach-s5p64x0/setup-i2c1.c b/arch/arm/mach-s5p64x0/setup-i2c1.c new file mode 100644 index 000000000000..2edd7912f8e4 --- /dev/null +++ b/arch/arm/mach-s5p64x0/setup-i2c1.c | |||
@@ -0,0 +1,42 @@ | |||
1 | /* linux/arch/arm/mach-s5p64xx/setup-i2c1.c | ||
2 | * | ||
3 | * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | ||
4 | * http://www.samsung.com | ||
5 | * | ||
6 | * I2C1 GPIO configuration. | ||
7 | * | ||
8 | * Based on plat-s3c64xx/setup-i2c0.c | ||
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 | #include <linux/kernel.h> | ||
16 | #include <linux/types.h> | ||
17 | #include <linux/gpio.h> | ||
18 | |||
19 | struct platform_device; /* don't need the contents */ | ||
20 | |||
21 | #include <plat/gpio-cfg.h> | ||
22 | #include <plat/iic.h> | ||
23 | |||
24 | #include <mach/i2c.h> | ||
25 | |||
26 | void s5p6440_i2c1_cfg_gpio(struct platform_device *dev) | ||
27 | { | ||
28 | s3c_gpio_cfgpin(S5P6440_GPR(9), S3C_GPIO_SFN(6)); | ||
29 | s3c_gpio_setpull(S5P6440_GPR(9), S3C_GPIO_PULL_UP); | ||
30 | s3c_gpio_cfgpin(S5P6440_GPR(10), S3C_GPIO_SFN(6)); | ||
31 | s3c_gpio_setpull(S5P6440_GPR(10), S3C_GPIO_PULL_UP); | ||
32 | } | ||
33 | |||
34 | void s5p6450_i2c1_cfg_gpio(struct platform_device *dev) | ||
35 | { | ||
36 | s3c_gpio_cfgpin(S5P6450_GPR(9), S3C_GPIO_SFN(6)); | ||
37 | s3c_gpio_setpull(S5P6450_GPR(9), S3C_GPIO_PULL_UP); | ||
38 | s3c_gpio_cfgpin(S5P6450_GPR(10), S3C_GPIO_SFN(6)); | ||
39 | s3c_gpio_setpull(S5P6450_GPR(10), S3C_GPIO_PULL_UP); | ||
40 | } | ||
41 | |||
42 | void s3c_i2c1_cfg_gpio(struct platform_device *dev) { } | ||