1/* 2 * linux/arch/arm/mach-omap1/board-h2.c 3 * 4 * Board specific inits for OMAP-1610 H2 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 * H2 specific changes and cleanup 15 * Copyright (C) 2004 Nokia Corporation by Imre Deak <imre.deak@nokia.com> 16 * 17 * This program is free software; you can redistribute it and/or modify 18 * it under the terms of the GNU General Public License version 2 as 19 * published by the Free Software Foundation. 20 */ 21#include <linux/gpio.h> 22#include <linux/kernel.h> 23#include <linux/platform_device.h> 24#include <linux/delay.h> 25#include <linux/i2c.h> 26#include <linux/mtd/mtd.h> 27#include <linux/mtd/nand.h> 28#include <linux/mtd/partitions.h> 29#include <linux/mtd/physmap.h> 30#include <linux/input.h> 31#include <linux/i2c/tps65010.h> 32#include <linux/smc91x.h> 33#include <linux/omapfb.h> 34#include <linux/platform_data/gpio-omap.h> 35#include <linux/leds.h> 36 37#include <asm/mach-types.h> 38#include <asm/mach/arch.h> 39#include <asm/mach/map.h> 40 41#include <mach/mux.h> 42#include <linux/omap-dma.h> 43#include <mach/tc.h> 44#include <linux/platform_data/keypad-omap.h> 45#include <mach/flash.h> 46 47#include <mach/hardware.h> 48#include <mach/usb.h> 49 50#include "common.h" 51#include "board-h2.h" 52 53/* At OMAP1610 Innovator the Ethernet is directly connected to CS1 */ 54#define OMAP1610_ETHR_START 0x04000300 55 56static const unsigned int h2_keymap[] = { 57 KEY(0, 0, KEY_LEFT), 58 KEY(1, 0, KEY_RIGHT), 59 KEY(2, 0, KEY_3), 60 KEY(3, 0, KEY_F10), 61 KEY(4, 0, KEY_F5), 62 KEY(5, 0, KEY_9), 63 KEY(0, 1, KEY_DOWN), 64 KEY(1, 1, KEY_UP), 65 KEY(2, 1, KEY_2), 66 KEY(3, 1, KEY_F9), 67 KEY(4, 1, KEY_F7), 68 KEY(5, 1, KEY_0), 69 KEY(0, 2, KEY_ENTER), 70 KEY(1, 2, KEY_6), 71 KEY(2, 2, KEY_1), 72 KEY(3, 2, KEY_F2), 73 KEY(4, 2, KEY_F6), 74 KEY(5, 2, KEY_HOME), 75 KEY(0, 3, KEY_8), 76 KEY(1, 3, KEY_5), 77 KEY(2, 3, KEY_F12), 78 KEY(3, 3, KEY_F3), 79 KEY(4, 3, KEY_F8), 80 KEY(5, 3, KEY_END), 81 KEY(0, 4, KEY_7), 82 KEY(1, 4, KEY_4), 83 KEY(2, 4, KEY_F11), 84 KEY(3, 4, KEY_F1), 85 KEY(4, 4, KEY_F4), 86 KEY(5, 4, KEY_ESC), 87 KEY(0, 5, KEY_F13), 88 KEY(1, 5, KEY_F14), 89 KEY(2, 5, KEY_F15), 90 KEY(3, 5, KEY_F16), 91 KEY(4, 5, KEY_SLEEP), 92}; 93 94static struct mtd_partition h2_nor_partitions[] = { 95 /* bootloader (U-Boot, etc) in first sector */ 96 { 97 .name = "bootloader", 98 .offset = 0, 99 .size = SZ_128K, 100 .mask_flags = MTD_WRITEABLE, /* force read-only */ 101 }, 102 /* bootloader params in the next sector */ 103 { 104 .name = "params", 105 .offset = MTDPART_OFS_APPEND, 106 .size = SZ_128K, 107 .mask_flags = 0, 108 }, 109 /* kernel */ 110 { 111 .name = "kernel", 112 .offset = MTDPART_OFS_APPEND, 113 .size = SZ_2M, 114 .mask_flags = 0 115 }, 116 /* file system */ 117 { 118 .name = "filesystem", 119 .offset = MTDPART_OFS_APPEND, 120 .size = MTDPART_SIZ_FULL, 121 .mask_flags = 0 122 } 123}; 124 125static struct physmap_flash_data h2_nor_data = { 126 .width = 2, 127 .set_vpp = omap1_set_vpp, 128 .parts = h2_nor_partitions, 129 .nr_parts = ARRAY_SIZE(h2_nor_partitions), 130}; 131 132static struct resource h2_nor_resource = { 133 /* This is on CS3, wherever it's mapped */ 134 .flags = IORESOURCE_MEM, 135}; 136 137static struct platform_device h2_nor_device = { 138 .name = "physmap-flash", 139 .id = 0, 140 .dev = { 141 .platform_data = &h2_nor_data, 142 }, 143 .num_resources = 1, 144 .resource = &h2_nor_resource, 145}; 146 147static struct mtd_partition h2_nand_partitions[] = { 148#if 0 149 /* REVISIT: enable these partitions if you make NAND BOOT 150 * work on your H2 (rev C or newer); published versions of 151 * x-load only support P2 and H3. 152 */ 153 { 154 .name = "xloader", 155 .offset = 0, 156 .size = 64 * 1024, 157 .mask_flags = MTD_WRITEABLE, /* force read-only */ 158 }, 159 { 160 .name = "bootloader", 161 .offset = MTDPART_OFS_APPEND, 162 .size = 256 * 1024, 163 .mask_flags = MTD_WRITEABLE, /* force read-only */ 164 }, 165 { 166 .name = "params", 167 .offset = MTDPART_OFS_APPEND, 168 .size = 192 * 1024, 169 }, 170 { 171 .name = "kernel", 172 .offset = MTDPART_OFS_APPEND, 173 .size = 2 * SZ_1M, 174 }, 175#endif 176 { 177 .name = "filesystem", 178 .size = MTDPART_SIZ_FULL, 179 .offset = MTDPART_OFS_APPEND, 180 }, 181}; 182 183#define H2_NAND_RB_GPIO_PIN 62 184 185static int h2_nand_dev_ready(struct mtd_info *mtd) 186{ 187 return gpio_get_value(H2_NAND_RB_GPIO_PIN); 188} 189 190static struct platform_nand_data h2_nand_platdata = { 191 .chip = { 192 .nr_chips = 1, 193 .chip_offset = 0, 194 .nr_partitions = ARRAY_SIZE(h2_nand_partitions), 195 .partitions = h2_nand_partitions, 196 .options = NAND_SAMSUNG_LP_OPTIONS, 197 }, 198 .ctrl = { 199 .cmd_ctrl = omap1_nand_cmd_ctl, 200 .dev_ready = h2_nand_dev_ready, 201 }, 202}; 203 204static struct resource h2_nand_resource = { 205 .flags = IORESOURCE_MEM, 206}; 207 208static struct platform_device h2_nand_device = { 209 .name = "gen_nand", 210 .id = 0, 211 .dev = { 212 .platform_data = &h2_nand_platdata, 213 }, 214 .num_resources = 1, 215 .resource = &h2_nand_resource, 216}; 217 218static struct smc91x_platdata h2_smc91x_info = { 219 .flags = SMC91X_USE_16BIT | SMC91X_NOWAIT, 220 .leda = RPC_LED_100_10, 221 .ledb = RPC_LED_TX_RX, 222}; 223 224static struct resource h2_smc91x_resources[] = { 225 [0] = { 226 .start = OMAP1610_ETHR_START, /* Physical */ 227 .end = OMAP1610_ETHR_START + 0xf, 228 .flags = IORESOURCE_MEM, 229 }, 230 [1] = { 231 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWEDGE, 232 }, 233}; 234 235static struct platform_device h2_smc91x_device = { 236 .name = "smc91x", 237 .id = 0, 238 .dev = { 239 .platform_data = &h2_smc91x_info, 240 }, 241 .num_resources = ARRAY_SIZE(h2_smc91x_resources), 242 .resource = h2_smc91x_resources, 243}; 244 245static struct resource h2_kp_resources[] = { 246 [0] = { 247 .start = INT_KEYBOARD, 248 .end = INT_KEYBOARD, 249 .flags = IORESOURCE_IRQ, 250 }, 251}; 252 253static const struct matrix_keymap_data h2_keymap_data = { 254 .keymap = h2_keymap, 255 .keymap_size = ARRAY_SIZE(h2_keymap), 256}; 257 258static struct omap_kp_platform_data h2_kp_data = { 259 .rows = 8, 260 .cols = 8, 261 .keymap_data = &h2_keymap_data, 262 .rep = true, 263 .delay = 9, 264 .dbounce = true, 265}; 266 267static struct platform_device h2_kp_device = { 268 .name = "omap-keypad", 269 .id = -1, 270 .dev = { 271 .platform_data = &h2_kp_data, 272 }, 273 .num_resources = ARRAY_SIZE(h2_kp_resources), 274 .resource = h2_kp_resources, 275}; 276 277static struct gpio_led h2_gpio_led_pins[] = { 278 { 279 .name = "h2:red", 280 .default_trigger = "heartbeat", 281 .gpio = 3, 282 }, 283 { 284 .name = "h2:green", 285 .default_trigger = "cpu0", 286 .gpio = OMAP_MPUIO(4), 287 }, 288}; 289 290static struct gpio_led_platform_data h2_gpio_led_data = { 291 .leds = h2_gpio_led_pins, 292 .num_leds = ARRAY_SIZE(h2_gpio_led_pins), 293}; 294 295static struct platform_device h2_gpio_leds = { 296 .name = "leds-gpio", 297 .id = -1, 298 .dev = { 299 .platform_data = &h2_gpio_led_data, 300 }, 301}; 302 303static struct platform_device *h2_devices[] __initdata = { 304 &h2_nor_device, 305 &h2_nand_device, 306 &h2_smc91x_device, 307 &h2_kp_device, 308 &h2_gpio_leds, 309}; 310 311static void __init h2_init_smc91x(void) 312{ 313 if (gpio_request(0, "SMC91x irq") < 0) { 314 printk("Error requesting gpio 0 for smc91x irq\n"); 315 return; 316 } 317} 318 319static int tps_setup(struct i2c_client *client, void *context) 320{ 321 if (!IS_BUILTIN(CONFIG_TPS65010)) 322 return -ENOSYS; 323 324 tps65010_config_vregs1(TPS_LDO2_ENABLE | TPS_VLDO2_3_0V | 325 TPS_LDO1_ENABLE | TPS_VLDO1_3_0V); 326 327 return 0; 328} 329 330static struct tps65010_board tps_board = { 331 .base = H2_TPS_GPIO_BASE, 332 .outmask = 0x0f, 333 .setup = tps_setup, 334}; 335 336static struct i2c_board_info __initdata h2_i2c_board_info[] = { 337 { 338 I2C_BOARD_INFO("tps65010", 0x48), 339 .platform_data = &tps_board, 340 }, { 341 I2C_BOARD_INFO("isp1301_omap", 0x2d), 342 }, 343}; 344 345static struct omap_usb_config h2_usb_config __initdata = { 346 /* usb1 has a Mini-AB port and external isp1301 transceiver */ 347 .otg = 2, 348 349#if IS_ENABLED(CONFIG_USB_OMAP) 350 .hmc_mode = 19, /* 0:host(off) 1:dev|otg 2:disabled */ 351 /* .hmc_mode = 21,*/ /* 0:host(off) 1:dev(loopback) 2:host(loopback) */ 352#elif defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE) 353 /* needs OTG cable, or NONSTANDARD (B-to-MiniB) */ 354 .hmc_mode = 20, /* 1:dev|otg(off) 1:host 2:disabled */ 355#endif 356 357 .pins[1] = 3, 358}; 359 360static struct omap_lcd_config h2_lcd_config __initdata = { 361 .ctrl_name = "internal", 362}; 363 364static void __init h2_init(void) 365{ 366 h2_init_smc91x(); 367 368 /* Here we assume the NOR boot config: NOR on CS3 (possibly swapped 369 * to address 0 by a dip switch), NAND on CS2B. The NAND driver will 370 * notice whether a NAND chip is enabled at probe time. 371 * 372 * FIXME revC boards (and H3) support NAND-boot, with a dip switch to 373 * put NOR on CS2B and NAND (which on H2 may be 16bit) on CS3. Try 374 * detecting that in code here, to avoid probing every possible flash 375 * configuration... 376 */ 377 h2_nor_resource.end = h2_nor_resource.start = omap_cs3_phys(); 378 h2_nor_resource.end += SZ_32M - 1; 379 380 h2_nand_resource.end = h2_nand_resource.start = OMAP_CS2B_PHYS; 381 h2_nand_resource.end += SZ_4K - 1; 382 BUG_ON(gpio_request(H2_NAND_RB_GPIO_PIN, "NAND ready") < 0); 383 gpio_direction_input(H2_NAND_RB_GPIO_PIN); 384 385 omap_cfg_reg(L3_1610_FLASH_CS2B_OE); 386 omap_cfg_reg(M8_1610_FLASH_CS2B_WE); 387 388 /* MMC: card detect and WP */ 389 /* omap_cfg_reg(U19_ARMIO1); */ /* CD */ 390 omap_cfg_reg(BALLOUT_V8_ARMIO3); /* WP */ 391 392 /* Mux pins for keypad */ 393 omap_cfg_reg(F18_1610_KBC0); 394 omap_cfg_reg(D20_1610_KBC1); 395 omap_cfg_reg(D19_1610_KBC2); 396 omap_cfg_reg(E18_1610_KBC3); 397 omap_cfg_reg(C21_1610_KBC4); 398 omap_cfg_reg(G18_1610_KBR0); 399 omap_cfg_reg(F19_1610_KBR1); 400 omap_cfg_reg(H14_1610_KBR2); 401 omap_cfg_reg(E20_1610_KBR3); 402 omap_cfg_reg(E19_1610_KBR4); 403 omap_cfg_reg(N19_1610_KBR5); 404 405 /* GPIO based LEDs */ 406 omap_cfg_reg(P18_1610_GPIO3); 407 omap_cfg_reg(MPUIO4); 408 409 h2_smc91x_resources[1].start = gpio_to_irq(0); 410 h2_smc91x_resources[1].end = gpio_to_irq(0); 411 platform_add_devices(h2_devices, ARRAY_SIZE(h2_devices)); 412 omap_serial_init(); 413 h2_i2c_board_info[0].irq = gpio_to_irq(58); 414 h2_i2c_board_info[1].irq = gpio_to_irq(2); 415 omap_register_i2c_bus(1, 100, h2_i2c_board_info, 416 ARRAY_SIZE(h2_i2c_board_info)); 417 omap1_usb_init(&h2_usb_config); 418 h2_mmc_init(); 419 420 omapfb_set_lcd_config(&h2_lcd_config); 421} 422 423MACHINE_START(OMAP_H2, "TI-H2") 424 /* Maintainer: Imre Deak <imre.deak@nokia.com> */ 425 .atag_offset = 0x100, 426 .map_io = omap16xx_map_io, 427 .init_early = omap1_init_early, 428 .init_irq = omap1_init_irq, 429 .handle_irq = omap1_handle_irq, 430 .init_machine = h2_init, 431 .init_late = omap1_init_late, 432 .init_time = omap1_timer_init, 433 .restart = omap1_restart, 434MACHINE_END 435