Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/kaber/nf-next-2.6
[linux-2.6.git] / arch / arm / mach-omap1 / board-innovator.c
1 /*
2  * linux/arch/arm/mach-omap1/board-innovator.c
3  *
4  * Board specific inits for OMAP-1510 and OMAP-1610 Innovator
5  *
6  * Copyright (C) 2001 RidgeRun, Inc.
7  * Author: Greg Lonnon <glonnon@ridgerun.com>
8  *
9  * Copyright (C) 2002 MontaVista Software, Inc.
10  *
11  * Separated FPGA interrupts from innovator1510.c and cleaned up for 2.6
12  * Copyright (C) 2004 Nokia Corporation by Tony Lindrgen <tony@atomide.com>
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License version 2 as
16  * published by the Free Software Foundation.
17  */
18
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/platform_device.h>
22 #include <linux/delay.h>
23 #include <linux/mtd/mtd.h>
24 #include <linux/mtd/partitions.h>
25 #include <linux/input.h>
26
27 #include <mach/hardware.h>
28 #include <asm/mach-types.h>
29 #include <asm/mach/arch.h>
30 #include <asm/mach/flash.h>
31 #include <asm/mach/map.h>
32
33 #include <mach/mux.h>
34 #include <mach/fpga.h>
35 #include <mach/gpio.h>
36 #include <mach/tc.h>
37 #include <mach/usb.h>
38 #include <mach/keypad.h>
39 #include <mach/common.h>
40 #include <mach/mmc.h>
41
42 /* At OMAP1610 Innovator the Ethernet is directly connected to CS1 */
43 #define INNOVATOR1610_ETHR_START        0x04000300
44
45 static int innovator_keymap[] = {
46         KEY(0, 0, KEY_F1),
47         KEY(0, 3, KEY_DOWN),
48         KEY(1, 1, KEY_F2),
49         KEY(1, 2, KEY_RIGHT),
50         KEY(2, 0, KEY_F3),
51         KEY(2, 1, KEY_F4),
52         KEY(2, 2, KEY_UP),
53         KEY(3, 2, KEY_ENTER),
54         KEY(3, 3, KEY_LEFT),
55         0
56 };
57
58 static struct mtd_partition innovator_partitions[] = {
59         /* bootloader (U-Boot, etc) in first sector */
60         {
61               .name             = "bootloader",
62               .offset           = 0,
63               .size             = SZ_128K,
64               .mask_flags       = MTD_WRITEABLE, /* force read-only */
65         },
66         /* bootloader params in the next sector */
67         {
68               .name             = "params",
69               .offset           = MTDPART_OFS_APPEND,
70               .size             = SZ_128K,
71               .mask_flags       = 0,
72         },
73         /* kernel */
74         {
75               .name             = "kernel",
76               .offset           = MTDPART_OFS_APPEND,
77               .size             = SZ_2M,
78               .mask_flags       = 0
79         },
80         /* rest of flash1 is a file system */
81         {
82               .name             = "rootfs",
83               .offset           = MTDPART_OFS_APPEND,
84               .size             = SZ_16M - SZ_2M - 2 * SZ_128K,
85               .mask_flags       = 0
86         },
87         /* file system */
88         {
89               .name             = "filesystem",
90               .offset           = MTDPART_OFS_APPEND,
91               .size             = MTDPART_SIZ_FULL,
92               .mask_flags       = 0
93         }
94 };
95
96 static struct flash_platform_data innovator_flash_data = {
97         .map_name       = "cfi_probe",
98         .width          = 2,
99         .parts          = innovator_partitions,
100         .nr_parts       = ARRAY_SIZE(innovator_partitions),
101 };
102
103 static struct resource innovator_flash_resource = {
104         .start          = OMAP_CS0_PHYS,
105         .end            = OMAP_CS0_PHYS + SZ_32M - 1,
106         .flags          = IORESOURCE_MEM,
107 };
108
109 static struct platform_device innovator_flash_device = {
110         .name           = "omapflash",
111         .id             = 0,
112         .dev            = {
113                 .platform_data  = &innovator_flash_data,
114         },
115         .num_resources  = 1,
116         .resource       = &innovator_flash_resource,
117 };
118
119 static struct resource innovator_kp_resources[] = {
120         [0] = {
121                 .start  = INT_KEYBOARD,
122                 .end    = INT_KEYBOARD,
123                 .flags  = IORESOURCE_IRQ,
124         },
125 };
126
127 static struct omap_kp_platform_data innovator_kp_data = {
128         .rows           = 8,
129         .cols           = 8,
130         .keymap         = innovator_keymap,
131         .keymapsize     = ARRAY_SIZE(innovator_keymap),
132         .delay          = 4,
133 };
134
135 static struct platform_device innovator_kp_device = {
136         .name           = "omap-keypad",
137         .id             = -1,
138         .dev            = {
139                 .platform_data = &innovator_kp_data,
140         },
141         .num_resources  = ARRAY_SIZE(innovator_kp_resources),
142         .resource       = innovator_kp_resources,
143 };
144
145
146 #ifdef CONFIG_ARCH_OMAP15XX
147
148 #include <linux/spi/spi.h>
149 #include <linux/spi/ads7846.h>
150
151
152 /* Only FPGA needs to be mapped here. All others are done with ioremap */
153 static struct map_desc innovator1510_io_desc[] __initdata = {
154         {
155                 .virtual        = OMAP1510_FPGA_BASE,
156                 .pfn            = __phys_to_pfn(OMAP1510_FPGA_START),
157                 .length         = OMAP1510_FPGA_SIZE,
158                 .type           = MT_DEVICE
159         }
160 };
161
162 static struct resource innovator1510_smc91x_resources[] = {
163         [0] = {
164                 .start  = OMAP1510_FPGA_ETHR_START,     /* Physical */
165                 .end    = OMAP1510_FPGA_ETHR_START + 0xf,
166                 .flags  = IORESOURCE_MEM,
167         },
168         [1] = {
169                 .start  = OMAP1510_INT_ETHER,
170                 .end    = OMAP1510_INT_ETHER,
171                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
172         },
173 };
174
175 static struct platform_device innovator1510_smc91x_device = {
176         .name           = "smc91x",
177         .id             = 0,
178         .num_resources  = ARRAY_SIZE(innovator1510_smc91x_resources),
179         .resource       = innovator1510_smc91x_resources,
180 };
181
182 static struct platform_device innovator1510_lcd_device = {
183         .name           = "lcd_inn1510",
184         .id             = -1,
185 };
186
187 static struct platform_device innovator1510_spi_device = {
188         .name           = "spi_inn1510",
189         .id             = -1,
190 };
191
192 static struct platform_device *innovator1510_devices[] __initdata = {
193         &innovator_flash_device,
194         &innovator1510_smc91x_device,
195         &innovator_kp_device,
196         &innovator1510_lcd_device,
197         &innovator1510_spi_device,
198 };
199
200 static int innovator_get_pendown_state(void)
201 {
202         return !(fpga_read(OMAP1510_FPGA_TOUCHSCREEN) & (1 << 5));
203 }
204
205 static const struct ads7846_platform_data innovator1510_ts_info = {
206         .model                  = 7846,
207         .vref_delay_usecs       = 100,  /* internal, no capacitor */
208         .x_plate_ohms           = 419,
209         .y_plate_ohms           = 486,
210         .get_pendown_state      = innovator_get_pendown_state,
211 };
212
213 static struct spi_board_info __initdata innovator1510_boardinfo[] = { {
214         /* FPGA (bus "10") CS0 has an ads7846e */
215         .modalias               = "ads7846",
216         .platform_data          = &innovator1510_ts_info,
217         .irq                    = OMAP1510_INT_FPGA_TS,
218         .max_speed_hz           = 120000 /* max sample rate at 3V */
219                                         * 26 /* command + data + overhead */,
220         .bus_num                = 10,
221         .chip_select            = 0,
222 } };
223
224 #endif /* CONFIG_ARCH_OMAP15XX */
225
226 #ifdef CONFIG_ARCH_OMAP16XX
227
228 static struct resource innovator1610_smc91x_resources[] = {
229         [0] = {
230                 .start  = INNOVATOR1610_ETHR_START,             /* Physical */
231                 .end    = INNOVATOR1610_ETHR_START + 0xf,
232                 .flags  = IORESOURCE_MEM,
233         },
234         [1] = {
235                 .start  = OMAP_GPIO_IRQ(0),
236                 .end    = OMAP_GPIO_IRQ(0),
237                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWEDGE,
238         },
239 };
240
241 static struct platform_device innovator1610_smc91x_device = {
242         .name           = "smc91x",
243         .id             = 0,
244         .num_resources  = ARRAY_SIZE(innovator1610_smc91x_resources),
245         .resource       = innovator1610_smc91x_resources,
246 };
247
248 static struct platform_device innovator1610_lcd_device = {
249         .name           = "inn1610_lcd",
250         .id             = -1,
251 };
252
253 static struct platform_device *innovator1610_devices[] __initdata = {
254         &innovator_flash_device,
255         &innovator1610_smc91x_device,
256         &innovator_kp_device,
257         &innovator1610_lcd_device,
258 };
259
260 #endif /* CONFIG_ARCH_OMAP16XX */
261
262 static void __init innovator_init_smc91x(void)
263 {
264         if (cpu_is_omap1510()) {
265                 fpga_write(fpga_read(OMAP1510_FPGA_RST) & ~1,
266                            OMAP1510_FPGA_RST);
267                 udelay(750);
268         } else {
269                 if (gpio_request(0, "SMC91x irq") < 0) {
270                         printk("Error requesting gpio 0 for smc91x irq\n");
271                         return;
272                 }
273         }
274 }
275
276 static void __init innovator_init_irq(void)
277 {
278         omap1_init_common_hw();
279         omap_init_irq();
280         omap_gpio_init();
281 #ifdef CONFIG_ARCH_OMAP15XX
282         if (cpu_is_omap1510()) {
283                 omap1510_fpga_init_irq();
284         }
285 #endif
286         innovator_init_smc91x();
287 }
288
289 #ifdef CONFIG_ARCH_OMAP15XX
290 static struct omap_usb_config innovator1510_usb_config __initdata = {
291         /* for bundled non-standard host and peripheral cables */
292         .hmc_mode       = 4,
293
294         .register_host  = 1,
295         .pins[1]        = 6,
296         .pins[2]        = 6,            /* Conflicts with UART2 */
297
298         .register_dev   = 1,
299         .pins[0]        = 2,
300 };
301
302 static struct omap_lcd_config innovator1510_lcd_config __initdata = {
303         .ctrl_name      = "internal",
304 };
305 #endif
306
307 #ifdef CONFIG_ARCH_OMAP16XX
308 static struct omap_usb_config h2_usb_config __initdata = {
309         /* usb1 has a Mini-AB port and external isp1301 transceiver */
310         .otg            = 2,
311
312 #ifdef  CONFIG_USB_GADGET_OMAP
313         .hmc_mode       = 19,   /* 0:host(off) 1:dev|otg 2:disabled */
314         /* .hmc_mode    = 21,*/ /* 0:host(off) 1:dev(loopback) 2:host(loopback) */
315 #elif   defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
316         /* NONSTANDARD CABLE NEEDED (B-to-Mini-B) */
317         .hmc_mode       = 20,   /* 1:dev|otg(off) 1:host 2:disabled */
318 #endif
319
320         .pins[1]        = 3,
321 };
322
323 static struct omap_lcd_config innovator1610_lcd_config __initdata = {
324         .ctrl_name      = "internal",
325 };
326 #endif
327
328 #if defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE)
329
330 static int mmc_set_power(struct device *dev, int slot, int power_on,
331                                 int vdd)
332 {
333         if (power_on)
334                 fpga_write(fpga_read(OMAP1510_FPGA_POWER) | (1 << 3),
335                                 OMAP1510_FPGA_POWER);
336         else
337                 fpga_write(fpga_read(OMAP1510_FPGA_POWER) & ~(1 << 3),
338                                 OMAP1510_FPGA_POWER);
339
340         return 0;
341 }
342
343 /*
344  * Innovator could use the following functions tested:
345  * - mmc_get_wp that uses OMAP_MPUIO(3)
346  * - mmc_get_cover_state that uses FPGA F4 UIO43
347  */
348 static struct omap_mmc_platform_data mmc1_data = {
349         .nr_slots                       = 1,
350         .slots[0]       = {
351                 .set_power              = mmc_set_power,
352                 .wires                  = 4,
353                 .name                   = "mmcblk",
354         },
355 };
356
357 static struct omap_mmc_platform_data *mmc_data[OMAP16XX_NR_MMC];
358
359 void __init innovator_mmc_init(void)
360 {
361         mmc_data[0] = &mmc1_data;
362         omap1_init_mmc(mmc_data, OMAP15XX_NR_MMC);
363 }
364
365 #else
366 static inline void innovator_mmc_init(void)
367 {
368 }
369 #endif
370
371 static struct omap_board_config_kernel innovator_config[] = {
372         { OMAP_TAG_LCD,         NULL },
373 };
374
375 static void __init innovator_init(void)
376 {
377 #ifdef CONFIG_ARCH_OMAP15XX
378         if (cpu_is_omap1510()) {
379                 unsigned char reg;
380
381                 /* mux pins for uarts */
382                 omap_cfg_reg(UART1_TX);
383                 omap_cfg_reg(UART1_RTS);
384                 omap_cfg_reg(UART2_TX);
385                 omap_cfg_reg(UART2_RTS);
386                 omap_cfg_reg(UART3_TX);
387                 omap_cfg_reg(UART3_RX);
388
389                 reg = fpga_read(OMAP1510_FPGA_POWER);
390                 reg |= OMAP1510_FPGA_PCR_COM1_EN;
391                 fpga_write(reg, OMAP1510_FPGA_POWER);
392                 udelay(10);
393
394                 reg = fpga_read(OMAP1510_FPGA_POWER);
395                 reg |= OMAP1510_FPGA_PCR_COM2_EN;
396                 fpga_write(reg, OMAP1510_FPGA_POWER);
397                 udelay(10);
398
399                 platform_add_devices(innovator1510_devices, ARRAY_SIZE(innovator1510_devices));
400                 spi_register_board_info(innovator1510_boardinfo,
401                                 ARRAY_SIZE(innovator1510_boardinfo));
402         }
403 #endif
404 #ifdef CONFIG_ARCH_OMAP16XX
405         if (!cpu_is_omap1510()) {
406                 platform_add_devices(innovator1610_devices, ARRAY_SIZE(innovator1610_devices));
407         }
408 #endif
409
410 #ifdef CONFIG_ARCH_OMAP15XX
411         if (cpu_is_omap1510()) {
412                 omap_usb_init(&innovator1510_usb_config);
413                 innovator_config[1].data = &innovator1510_lcd_config;
414         }
415 #endif
416 #ifdef CONFIG_ARCH_OMAP16XX
417         if (cpu_is_omap1610()) {
418                 omap_usb_init(&h2_usb_config);
419                 innovator_config[1].data = &innovator1610_lcd_config;
420         }
421 #endif
422         omap_board_config = innovator_config;
423         omap_board_config_size = ARRAY_SIZE(innovator_config);
424         omap_serial_init();
425         omap_register_i2c_bus(1, 100, NULL, 0);
426         innovator_mmc_init();
427 }
428
429 static void __init innovator_map_io(void)
430 {
431         omap1_map_common_io();
432
433 #ifdef CONFIG_ARCH_OMAP15XX
434         if (cpu_is_omap1510()) {
435                 iotable_init(innovator1510_io_desc, ARRAY_SIZE(innovator1510_io_desc));
436                 udelay(10);     /* Delay needed for FPGA */
437
438                 /* Dump the Innovator FPGA rev early - useful info for support. */
439                 printk("Innovator FPGA Rev %d.%d Board Rev %d\n",
440                        fpga_read(OMAP1510_FPGA_REV_HIGH),
441                        fpga_read(OMAP1510_FPGA_REV_LOW),
442                        fpga_read(OMAP1510_FPGA_BOARD_REV));
443         }
444 #endif
445 }
446
447 MACHINE_START(OMAP_INNOVATOR, "TI-Innovator")
448         /* Maintainer: MontaVista Software, Inc. */
449         .phys_io        = 0xfff00000,
450         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
451         .boot_params    = 0x10000100,
452         .map_io         = innovator_map_io,
453         .init_irq       = innovator_init_irq,
454         .init_machine   = innovator_init,
455         .timer          = &omap_timer,
456 MACHINE_END