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