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