omap: headers: Move remaining headers from include/mach to include/plat
[linux-2.6.git] / arch / arm / plat-omap / common.c
1 /*
2  * linux/arch/arm/plat-omap/common.c
3  *
4  * Code common to all OMAP machines.
5  * The file is created by Tony Lindgren <tony@atomide.com>
6  *
7  * Copyright (C) 2009 Texas Instruments
8  * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
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 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/delay.h>
18 #include <linux/console.h>
19 #include <linux/serial.h>
20 #include <linux/tty.h>
21 #include <linux/serial_8250.h>
22 #include <linux/serial_reg.h>
23 #include <linux/clk.h>
24 #include <linux/io.h>
25
26 #include <mach/hardware.h>
27 #include <asm/system.h>
28 #include <asm/pgtable.h>
29 #include <asm/mach/map.h>
30 #include <asm/setup.h>
31
32 #include <plat/common.h>
33 #include <plat/board.h>
34 #include <plat/control.h>
35 #include <plat/mux.h>
36 #include <plat/fpga.h>
37
38 #include <plat/clock.h>
39
40 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
41 # include "../mach-omap2/sdrc.h"
42 #endif
43
44 #define NO_LENGTH_CHECK 0xffffffff
45
46 unsigned char omap_bootloader_tag[512];
47 int omap_bootloader_tag_len;
48
49 struct omap_board_config_kernel *omap_board_config;
50 int omap_board_config_size;
51
52 /* used by omap-smp.c and board-4430sdp.c */
53 void __iomem *gic_cpu_base_addr;
54
55 static const void *get_config(u16 tag, size_t len, int skip, size_t *len_out)
56 {
57         struct omap_board_config_kernel *kinfo = NULL;
58         int i;
59
60         /* Try to find the config from the board-specific structures
61          * in the kernel. */
62         for (i = 0; i < omap_board_config_size; i++) {
63                 if (omap_board_config[i].tag == tag) {
64                         if (skip == 0) {
65                                 kinfo = &omap_board_config[i];
66                                 break;
67                         } else {
68                                 skip--;
69                         }
70                 }
71         }
72         if (kinfo == NULL)
73                 return NULL;
74         return kinfo->data;
75 }
76
77 const void *__omap_get_config(u16 tag, size_t len, int nr)
78 {
79         return get_config(tag, len, nr, NULL);
80 }
81 EXPORT_SYMBOL(__omap_get_config);
82
83 const void *omap_get_var_config(u16 tag, size_t *len)
84 {
85         return get_config(tag, NO_LENGTH_CHECK, 0, len);
86 }
87 EXPORT_SYMBOL(omap_get_var_config);
88
89 /*
90  * 32KHz clocksource ... always available, on pretty most chips except
91  * OMAP 730 and 1510.  Other timers could be used as clocksources, with
92  * higher resolution in free-running counter modes (e.g. 12 MHz xtal),
93  * but systems won't necessarily want to spend resources that way.
94  */
95
96 #define OMAP16XX_TIMER_32K_SYNCHRONIZED         0xfffbc410
97
98 #if !(defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP15XX))
99
100 #include <linux/clocksource.h>
101
102 #ifdef CONFIG_ARCH_OMAP16XX
103 static cycle_t omap16xx_32k_read(struct clocksource *cs)
104 {
105         return omap_readl(OMAP16XX_TIMER_32K_SYNCHRONIZED);
106 }
107 #else
108 #define omap16xx_32k_read       NULL
109 #endif
110
111 #ifdef CONFIG_ARCH_OMAP2420
112 static cycle_t omap2420_32k_read(struct clocksource *cs)
113 {
114         return omap_readl(OMAP2420_32KSYNCT_BASE + 0x10);
115 }
116 #else
117 #define omap2420_32k_read       NULL
118 #endif
119
120 #ifdef CONFIG_ARCH_OMAP2430
121 static cycle_t omap2430_32k_read(struct clocksource *cs)
122 {
123         return omap_readl(OMAP2430_32KSYNCT_BASE + 0x10);
124 }
125 #else
126 #define omap2430_32k_read       NULL
127 #endif
128
129 #ifdef CONFIG_ARCH_OMAP34XX
130 static cycle_t omap34xx_32k_read(struct clocksource *cs)
131 {
132         return omap_readl(OMAP3430_32KSYNCT_BASE + 0x10);
133 }
134 #else
135 #define omap34xx_32k_read       NULL
136 #endif
137
138 #ifdef CONFIG_ARCH_OMAP4
139 static cycle_t omap44xx_32k_read(struct clocksource *cs)
140 {
141         return omap_readl(OMAP4430_32KSYNCT_BASE + 0x10);
142 }
143 #else
144 #define omap44xx_32k_read       NULL
145 #endif
146
147 /*
148  * Kernel assumes that sched_clock can be called early but may not have
149  * things ready yet.
150  */
151 static cycle_t omap_32k_read_dummy(struct clocksource *cs)
152 {
153         return 0;
154 }
155
156 static struct clocksource clocksource_32k = {
157         .name           = "32k_counter",
158         .rating         = 250,
159         .read           = omap_32k_read_dummy,
160         .mask           = CLOCKSOURCE_MASK(32),
161         .shift          = 10,
162         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
163 };
164
165 /*
166  * Returns current time from boot in nsecs. It's OK for this to wrap
167  * around for now, as it's just a relative time stamp.
168  */
169 unsigned long long sched_clock(void)
170 {
171         return clocksource_cyc2ns(clocksource_32k.read(&clocksource_32k),
172                                   clocksource_32k.mult, clocksource_32k.shift);
173 }
174
175 static int __init omap_init_clocksource_32k(void)
176 {
177         static char err[] __initdata = KERN_ERR
178                         "%s: can't register clocksource!\n";
179
180         if (cpu_is_omap16xx() || cpu_class_is_omap2()) {
181                 struct clk *sync_32k_ick;
182
183                 if (cpu_is_omap16xx())
184                         clocksource_32k.read = omap16xx_32k_read;
185                 else if (cpu_is_omap2420())
186                         clocksource_32k.read = omap2420_32k_read;
187                 else if (cpu_is_omap2430())
188                         clocksource_32k.read = omap2430_32k_read;
189                 else if (cpu_is_omap34xx())
190                         clocksource_32k.read = omap34xx_32k_read;
191                 else if (cpu_is_omap44xx())
192                         clocksource_32k.read = omap44xx_32k_read;
193                 else
194                         return -ENODEV;
195
196                 sync_32k_ick = clk_get(NULL, "omap_32ksync_ick");
197                 if (sync_32k_ick)
198                         clk_enable(sync_32k_ick);
199
200                 clocksource_32k.mult = clocksource_hz2mult(32768,
201                                             clocksource_32k.shift);
202
203                 if (clocksource_register(&clocksource_32k))
204                         printk(err, clocksource_32k.name);
205         }
206         return 0;
207 }
208 arch_initcall(omap_init_clocksource_32k);
209
210 #endif  /* !(defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP15XX)) */
211
212 /* Global address base setup code */
213
214 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
215
216 static void __init __omap2_set_globals(struct omap_globals *omap2_globals)
217 {
218         omap2_set_globals_tap(omap2_globals);
219         omap2_set_globals_sdrc(omap2_globals);
220         omap2_set_globals_control(omap2_globals);
221         omap2_set_globals_prcm(omap2_globals);
222 }
223
224 #endif
225
226 #if defined(CONFIG_ARCH_OMAP2420)
227
228 static struct omap_globals omap242x_globals = {
229         .class  = OMAP242X_CLASS,
230         .tap    = OMAP2_L4_IO_ADDRESS(0x48014000),
231         .sdrc   = OMAP2_L3_IO_ADDRESS(OMAP2420_SDRC_BASE),
232         .sms    = OMAP2_L3_IO_ADDRESS(OMAP2420_SMS_BASE),
233         .ctrl   = OMAP2_L4_IO_ADDRESS(OMAP2420_CTRL_BASE),
234         .prm    = OMAP2_L4_IO_ADDRESS(OMAP2420_PRM_BASE),
235         .cm     = OMAP2_L4_IO_ADDRESS(OMAP2420_CM_BASE),
236 };
237
238 void __init omap2_set_globals_242x(void)
239 {
240         __omap2_set_globals(&omap242x_globals);
241 }
242 #endif
243
244 #if defined(CONFIG_ARCH_OMAP2430)
245
246 static struct omap_globals omap243x_globals = {
247         .class  = OMAP243X_CLASS,
248         .tap    = OMAP2_L4_IO_ADDRESS(0x4900a000),
249         .sdrc   = OMAP2_L3_IO_ADDRESS(OMAP243X_SDRC_BASE),
250         .sms    = OMAP2_L3_IO_ADDRESS(OMAP243X_SMS_BASE),
251         .ctrl   = OMAP2_L4_IO_ADDRESS(OMAP243X_CTRL_BASE),
252         .prm    = OMAP2_L4_IO_ADDRESS(OMAP2430_PRM_BASE),
253         .cm     = OMAP2_L4_IO_ADDRESS(OMAP2430_CM_BASE),
254 };
255
256 void __init omap2_set_globals_243x(void)
257 {
258         __omap2_set_globals(&omap243x_globals);
259 }
260 #endif
261
262 #if defined(CONFIG_ARCH_OMAP3430)
263
264 static struct omap_globals omap343x_globals = {
265         .class  = OMAP343X_CLASS,
266         .tap    = OMAP2_L4_IO_ADDRESS(0x4830A000),
267         .sdrc   = OMAP2_L3_IO_ADDRESS(OMAP343X_SDRC_BASE),
268         .sms    = OMAP2_L3_IO_ADDRESS(OMAP343X_SMS_BASE),
269         .ctrl   = OMAP2_L4_IO_ADDRESS(OMAP343X_CTRL_BASE),
270         .prm    = OMAP2_L4_IO_ADDRESS(OMAP3430_PRM_BASE),
271         .cm     = OMAP2_L4_IO_ADDRESS(OMAP3430_CM_BASE),
272 };
273
274 void __init omap2_set_globals_343x(void)
275 {
276         __omap2_set_globals(&omap343x_globals);
277 }
278 #endif
279
280 #if defined(CONFIG_ARCH_OMAP4)
281 static struct omap_globals omap4_globals = {
282         .class  = OMAP443X_CLASS,
283         .tap    = OMAP2_L4_IO_ADDRESS(0x4830a000),
284         .ctrl   = OMAP2_L4_IO_ADDRESS(OMAP443X_CTRL_BASE),
285         .prm    = OMAP2_L4_IO_ADDRESS(OMAP4430_PRM_BASE),
286         .cm     = OMAP2_L4_IO_ADDRESS(OMAP4430_CM_BASE),
287 };
288
289 void __init omap2_set_globals_443x(void)
290 {
291         omap2_set_globals_tap(&omap4_globals);
292         omap2_set_globals_control(&omap4_globals);
293 }
294 #endif
295