b61d6143aaaa9d8f417160e59ca5c97f06fbf6e5
[linux-2.6.git] / arch / sh / kernel / cpu / sh4a / setup-sh7770.c
1 /*
2  * SH7770 Setup
3  *
4  *  Copyright (C) 2006 - 2008  Paul Mundt
5  *
6  * This file is subject to the terms and conditions of the GNU General Public
7  * License.  See the file "COPYING" in the main directory of this archive
8  * for more details.
9  */
10 #include <linux/platform_device.h>
11 #include <linux/init.h>
12 #include <linux/serial.h>
13 #include <linux/serial_sci.h>
14 #include <linux/sh_timer.h>
15
16 static struct plat_sci_port sci_platform_data[] = {
17         {
18                 .mapbase        = 0xff923000,
19                 .flags          = UPF_BOOT_AUTOCONF,
20                 .type           = PORT_SCIF,
21                 .irqs           = { 61, 61, 61, 61 },
22         }, {
23                 .mapbase        = 0xff924000,
24                 .flags          = UPF_BOOT_AUTOCONF,
25                 .type           = PORT_SCIF,
26                 .irqs           = { 62, 62, 62, 62 },
27         }, {
28                 .mapbase        = 0xff925000,
29                 .flags          = UPF_BOOT_AUTOCONF,
30                 .type           = PORT_SCIF,
31                 .irqs           = { 63, 63, 63, 63 },
32         }, {
33                 .mapbase        = 0xff926000,
34                 .flags          = UPF_BOOT_AUTOCONF,
35                 .type           = PORT_SCIF,
36                 .irqs           = { 64, 64, 64, 64 },
37         }, {
38                 .mapbase        = 0xff927000,
39                 .flags          = UPF_BOOT_AUTOCONF,
40                 .type           = PORT_SCIF,
41                 .irqs           = { 65, 65, 65, 65 },
42         }, {
43                 .mapbase        = 0xff928000,
44                 .flags          = UPF_BOOT_AUTOCONF,
45                 .type           = PORT_SCIF,
46                 .irqs           = { 66, 66, 66, 66 },
47         }, {
48                 .mapbase        = 0xff929000,
49                 .flags          = UPF_BOOT_AUTOCONF,
50                 .type           = PORT_SCIF,
51                 .irqs           = { 67, 67, 67, 67 },
52         }, {
53                 .mapbase        = 0xff92a000,
54                 .flags          = UPF_BOOT_AUTOCONF,
55                 .type           = PORT_SCIF,
56                 .irqs           = { 68, 68, 68, 68 },
57         }, {
58                 .mapbase        = 0xff92b000,
59                 .flags          = UPF_BOOT_AUTOCONF,
60                 .type           = PORT_SCIF,
61                 .irqs           = { 69, 69, 69, 69 },
62         }, {
63                 .mapbase        = 0xff92c000,
64                 .flags          = UPF_BOOT_AUTOCONF,
65                 .type           = PORT_SCIF,
66                 .irqs           = { 70, 70, 70, 70 },
67         }, {
68                 .flags = 0,
69         }
70 };
71
72 static struct platform_device sci_device = {
73         .name           = "sh-sci",
74         .id             = -1,
75         .dev            = {
76                 .platform_data  = sci_platform_data,
77         },
78 };
79
80 static struct sh_timer_config tmu0_platform_data = {
81         .name = "TMU0",
82         .channel_offset = 0x04,
83         .timer_bit = 0,
84         .clk = "module_clk",
85         .clockevent_rating = 200,
86 };
87
88 static struct resource tmu0_resources[] = {
89         [0] = {
90                 .name   = "TMU0",
91                 .start  = 0xffd80008,
92                 .end    = 0xffd80013,
93                 .flags  = IORESOURCE_MEM,
94         },
95         [1] = {
96                 .start  = 16,
97                 .flags  = IORESOURCE_IRQ,
98         },
99 };
100
101 static struct platform_device tmu0_device = {
102         .name           = "sh_tmu",
103         .id             = 0,
104         .dev = {
105                 .platform_data  = &tmu0_platform_data,
106         },
107         .resource       = tmu0_resources,
108         .num_resources  = ARRAY_SIZE(tmu0_resources),
109 };
110
111 static struct sh_timer_config tmu1_platform_data = {
112         .name = "TMU1",
113         .channel_offset = 0x10,
114         .timer_bit = 1,
115         .clk = "module_clk",
116         .clocksource_rating = 200,
117 };
118
119 static struct resource tmu1_resources[] = {
120         [0] = {
121                 .name   = "TMU1",
122                 .start  = 0xffd80014,
123                 .end    = 0xffd8001f,
124                 .flags  = IORESOURCE_MEM,
125         },
126         [1] = {
127                 .start  = 17,
128                 .flags  = IORESOURCE_IRQ,
129         },
130 };
131
132 static struct platform_device tmu1_device = {
133         .name           = "sh_tmu",
134         .id             = 1,
135         .dev = {
136                 .platform_data  = &tmu1_platform_data,
137         },
138         .resource       = tmu1_resources,
139         .num_resources  = ARRAY_SIZE(tmu1_resources),
140 };
141
142 static struct sh_timer_config tmu2_platform_data = {
143         .name = "TMU2",
144         .channel_offset = 0x1c,
145         .timer_bit = 2,
146         .clk = "module_clk",
147 };
148
149 static struct resource tmu2_resources[] = {
150         [0] = {
151                 .name   = "TMU2",
152                 .start  = 0xffd80020,
153                 .end    = 0xffd8002f,
154                 .flags  = IORESOURCE_MEM,
155         },
156         [1] = {
157                 .start  = 18,
158                 .flags  = IORESOURCE_IRQ,
159         },
160 };
161
162 static struct platform_device tmu2_device = {
163         .name           = "sh_tmu",
164         .id             = 2,
165         .dev = {
166                 .platform_data  = &tmu2_platform_data,
167         },
168         .resource       = tmu2_resources,
169         .num_resources  = ARRAY_SIZE(tmu2_resources),
170 };
171
172 static struct sh_timer_config tmu3_platform_data = {
173         .name = "TMU3",
174         .channel_offset = 0x04,
175         .timer_bit = 0,
176         .clk = "module_clk",
177 };
178
179 static struct resource tmu3_resources[] = {
180         [0] = {
181                 .name   = "TMU3",
182                 .start  = 0xffd81008,
183                 .end    = 0xffd81013,
184                 .flags  = IORESOURCE_MEM,
185         },
186         [1] = {
187                 .start  = 19,
188                 .flags  = IORESOURCE_IRQ,
189         },
190 };
191
192 static struct platform_device tmu3_device = {
193         .name           = "sh_tmu",
194         .id             = 3,
195         .dev = {
196                 .platform_data  = &tmu3_platform_data,
197         },
198         .resource       = tmu3_resources,
199         .num_resources  = ARRAY_SIZE(tmu3_resources),
200 };
201
202 static struct sh_timer_config tmu4_platform_data = {
203         .name = "TMU4",
204         .channel_offset = 0x10,
205         .timer_bit = 1,
206         .clk = "module_clk",
207 };
208
209 static struct resource tmu4_resources[] = {
210         [0] = {
211                 .name   = "TMU4",
212                 .start  = 0xffd81014,
213                 .end    = 0xffd8101f,
214                 .flags  = IORESOURCE_MEM,
215         },
216         [1] = {
217                 .start  = 20,
218                 .flags  = IORESOURCE_IRQ,
219         },
220 };
221
222 static struct platform_device tmu4_device = {
223         .name           = "sh_tmu",
224         .id             = 4,
225         .dev = {
226                 .platform_data  = &tmu4_platform_data,
227         },
228         .resource       = tmu4_resources,
229         .num_resources  = ARRAY_SIZE(tmu4_resources),
230 };
231
232 static struct sh_timer_config tmu5_platform_data = {
233         .name = "TMU5",
234         .channel_offset = 0x1c,
235         .timer_bit = 2,
236         .clk = "module_clk",
237 };
238
239 static struct resource tmu5_resources[] = {
240         [0] = {
241                 .name   = "TMU5",
242                 .start  = 0xffd81020,
243                 .end    = 0xffd8102f,
244                 .flags  = IORESOURCE_MEM,
245         },
246         [1] = {
247                 .start  = 21,
248                 .flags  = IORESOURCE_IRQ,
249         },
250 };
251
252 static struct platform_device tmu5_device = {
253         .name           = "sh_tmu",
254         .id             = 5,
255         .dev = {
256                 .platform_data  = &tmu5_platform_data,
257         },
258         .resource       = tmu5_resources,
259         .num_resources  = ARRAY_SIZE(tmu5_resources),
260 };
261
262 static struct sh_timer_config tmu6_platform_data = {
263         .name = "TMU6",
264         .channel_offset = 0x04,
265         .timer_bit = 0,
266         .clk = "module_clk",
267 };
268
269 static struct resource tmu6_resources[] = {
270         [0] = {
271                 .name   = "TMU6",
272                 .start  = 0xffd82008,
273                 .end    = 0xffd82013,
274                 .flags  = IORESOURCE_MEM,
275         },
276         [1] = {
277                 .start  = 22,
278                 .flags  = IORESOURCE_IRQ,
279         },
280 };
281
282 static struct platform_device tmu6_device = {
283         .name           = "sh_tmu",
284         .id             = 6,
285         .dev = {
286                 .platform_data  = &tmu6_platform_data,
287         },
288         .resource       = tmu6_resources,
289         .num_resources  = ARRAY_SIZE(tmu6_resources),
290 };
291
292 static struct sh_timer_config tmu7_platform_data = {
293         .name = "TMU7",
294         .channel_offset = 0x10,
295         .timer_bit = 1,
296         .clk = "module_clk",
297 };
298
299 static struct resource tmu7_resources[] = {
300         [0] = {
301                 .name   = "TMU7",
302                 .start  = 0xffd82014,
303                 .end    = 0xffd8201f,
304                 .flags  = IORESOURCE_MEM,
305         },
306         [1] = {
307                 .start  = 23,
308                 .flags  = IORESOURCE_IRQ,
309         },
310 };
311
312 static struct platform_device tmu7_device = {
313         .name           = "sh_tmu",
314         .id             = 7,
315         .dev = {
316                 .platform_data  = &tmu7_platform_data,
317         },
318         .resource       = tmu7_resources,
319         .num_resources  = ARRAY_SIZE(tmu7_resources),
320 };
321
322 static struct sh_timer_config tmu8_platform_data = {
323         .name = "TMU8",
324         .channel_offset = 0x1c,
325         .timer_bit = 2,
326         .clk = "module_clk",
327 };
328
329 static struct resource tmu8_resources[] = {
330         [0] = {
331                 .name   = "TMU8",
332                 .start  = 0xffd82020,
333                 .end    = 0xffd8202b,
334                 .flags  = IORESOURCE_MEM,
335         },
336         [1] = {
337                 .start  = 24,
338                 .flags  = IORESOURCE_IRQ,
339         },
340 };
341
342 static struct platform_device tmu8_device = {
343         .name           = "sh_tmu",
344         .id             = 8,
345         .dev = {
346                 .platform_data  = &tmu8_platform_data,
347         },
348         .resource       = tmu8_resources,
349         .num_resources  = ARRAY_SIZE(tmu8_resources),
350 };
351
352 static struct platform_device *sh7770_devices[] __initdata = {
353         &tmu0_device,
354         &tmu1_device,
355         &tmu2_device,
356         &tmu3_device,
357         &tmu4_device,
358         &tmu5_device,
359         &tmu6_device,
360         &tmu7_device,
361         &tmu8_device,
362         &sci_device,
363 };
364
365 static int __init sh7770_devices_setup(void)
366 {
367         return platform_add_devices(sh7770_devices,
368                                     ARRAY_SIZE(sh7770_devices));
369 }
370 __initcall(sh7770_devices_setup);
371
372 static struct platform_device *sh7770_early_devices[] __initdata = {
373         &tmu0_device,
374         &tmu1_device,
375         &tmu2_device,
376         &tmu3_device,
377         &tmu4_device,
378         &tmu5_device,
379         &tmu6_device,
380         &tmu7_device,
381         &tmu8_device,
382 };
383
384 void __init plat_early_device_setup(void)
385 {
386         early_platform_add_devices(sh7770_early_devices,
387                                    ARRAY_SIZE(sh7770_early_devices));
388 }
389
390 void __init plat_irq_setup(void)
391 {
392 }