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 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 34#include <mach/hardware.h> 35#include <asm/gpio.h> 36 37#include <asm/mach-types.h> 38#include <asm/mach/arch.h> 39#include <asm/mach/map.h> 40 41#include <plat/mux.h> 42#include <plat/dma.h> 43#include <plat/tc.h> 44#include <plat/irda.h> 45#include <plat/usb.h> 46#include <plat/keypad.h> 47#include <plat/common.h> 48#include <plat/flash.h> 49 50#include "board-h2.h" 51 52/* At OMAP1610 Innovator the Ethernet is directly connected to CS1 */ 53#define OMAP1610_ETHR_START 0x04000300 54 55static int h2_keymap[] = { 56 KEY(0, 0, KEY_LEFT), 57 KEY(0, 1, KEY_RIGHT), 58 KEY(0, 2, KEY_3), 59 KEY(0, 3, KEY_F10), 60 KEY(0, 4, KEY_F5), 61 KEY(0, 5, KEY_9), 62 KEY(1, 0, KEY_DOWN), 63 KEY(1, 1, KEY_UP), 64 KEY(1, 2, KEY_2), 65 KEY(1, 3, KEY_F9), 66 KEY(1, 4, KEY_F7), 67 KEY(1, 5, KEY_0), 68 KEY(2, 0, KEY_ENTER), 69 KEY(2, 1, KEY_6), 70 KEY(2, 2, KEY_1), 71 KEY(2, 3, KEY_F2), 72 KEY(2, 4, KEY_F6), 73 KEY(2, 5, KEY_HOME), 74 KEY(3, 0, KEY_8), 75 KEY(3, 1, KEY_5), 76 KEY(3, 2, KEY_F12), 77 KEY(3, 3, KEY_F3), 78 KEY(3, 4, KEY_F8), 79 KEY(3, 5, KEY_END), 80 KEY(4, 0, KEY_7), 81 KEY(4, 1, KEY_4), 82 KEY(4, 2, KEY_F11), 83 KEY(4, 3, KEY_F1), 84 KEY(4, 4, KEY_F4), 85 KEY(4, 5, KEY_ESC), 86 KEY(5, 0, KEY_F13), 87 KEY(5, 1, KEY_F14), 88 KEY(5, 2, KEY_F15), 89 KEY(5, 3, KEY_F16), 90 KEY(5, 4, KEY_SLEEP), 91 0 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 { 149 .name = "filesystem", 150 .size = MTDPART_SIZ_FULL, 151 .offset = MTDPART_OFS_APPEND, 152 }, 153}; 154 155static void h2_nand_cmd_ctl(struct mtd_info *mtd, int cmd, unsigned int ctrl) 156{ 157 struct nand_chip *this = mtd->priv; 158 unsigned long mask; 159 160 if (cmd == NAND_CMD_NONE) 161 return; 162 163 mask = (ctrl & NAND_CLE) ? 0x02 : 0; 164 if (ctrl & NAND_ALE) 165 mask |= 0x04; 166 writeb(cmd, (unsigned long)this->IO_ADDR_W | mask); 167} 168 169#define H2_NAND_RB_GPIO_PIN 62 170 171static int h2_nand_dev_ready(struct mtd_info *mtd) 172{ 173 return gpio_get_value(H2_NAND_RB_GPIO_PIN); 174} 175 176static const char *h2_part_probes[] = { "cmdlinepart", NULL }; 177 178struct platform_nand_data h2_nand_platdata = { 179 .chip = { 180 .nr_chips = 1, 181 .chip_offset = 0, 182 .nr_partitions = ARRAY_SIZE(h2_nand_partitions), 183 .partitions = h2_nand_partitions, 184 .options = NAND_SAMSUNG_LP_OPTIONS, 185 .part_probe_types = h2_part_probes, 186 }, 187 .ctrl = { 188 .cmd_ctrl = h2_nand_cmd_ctl, 189 .dev_ready = h2_nand_dev_ready, 190 191 }, 192}; 193 194static struct resource h2_nand_resource = { 195 .flags = IORESOURCE_MEM, 196}; 197 198static struct platform_device h2_nand_device = { 199 .name = "gen_nand", 200 .id = 0, 201 .dev = { 202 .platform_data = &h2_nand_platdata, 203 }, 204 .num_resources = 1, 205 .resource = &h2_nand_resource, 206}; 207 208static struct smc91x_platdata h2_smc91x_info = { 209 .flags = SMC91X_USE_16BIT | SMC91X_NOWAIT, 210 .leda = RPC_LED_100_10, 211 .ledb = RPC_LED_TX_RX, 212}; 213 214static struct resource h2_smc91x_resources[] = { 215 [0] = { 216 .start = OMAP1610_ETHR_START, /* Physical */ 217 .end = OMAP1610_ETHR_START + 0xf, 218 .flags = IORESOURCE_MEM, 219 }, 220 [1] = { 221 .start = OMAP_GPIO_IRQ(0), 222 .end = OMAP_GPIO_IRQ(0), 223 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWEDGE, 224 }, 225}; 226 227static struct platform_device h2_smc91x_device = { 228 .name = "smc91x", 229 .id = 0, 230 .dev = { 231 .platform_data = &h2_smc91x_info, 232 }, 233 .num_resources = ARRAY_SIZE(h2_smc91x_resources), 234 .resource = h2_smc91x_resources, 235}; 236 237static struct resource h2_kp_resources[] = { 238 [0] = { 239 .start = INT_KEYBOARD, 240 .end = INT_KEYBOARD, 241 .flags = IORESOURCE_IRQ, 242 }, 243}; 244 245static struct omap_kp_platform_data h2_kp_data = { 246 .rows = 8, 247 .cols = 8, 248 .keymap = h2_keymap, 249 .keymapsize = ARRAY_SIZE(h2_keymap), 250 .rep = 1, 251 .delay = 9, 252 .dbounce = 1, 253}; 254 255static struct platform_device h2_kp_device = { 256 .name = "omap-keypad", 257 .id = -1, 258 .dev = { 259 .platform_data = &h2_kp_data, 260 }, 261 .num_resources = ARRAY_SIZE(h2_kp_resources), 262 .resource = h2_kp_resources, 263}; 264 265#define H2_IRDA_FIRSEL_GPIO_PIN 17 266 267static struct omap_irda_config h2_irda_data = { 268 .transceiver_cap = IR_SIRMODE | IR_MIRMODE | IR_FIRMODE, 269 .rx_channel = OMAP_DMA_UART3_RX, 270 .tx_channel = OMAP_DMA_UART3_TX, 271 .dest_start = UART3_THR, 272 .src_start = UART3_RHR, 273 .tx_trigger = 0, 274 .rx_trigger = 0, 275}; 276 277static struct resource h2_irda_resources[] = { 278 [0] = { 279 .start = INT_UART3, 280 .end = INT_UART3, 281 .flags = IORESOURCE_IRQ, 282 }, 283}; 284 285static u64 irda_dmamask = 0xffffffff; 286 287static struct platform_device h2_irda_device = { 288 .name = "omapirda", 289 .id = 0, 290 .dev = { 291 .platform_data = &h2_irda_data, 292 .dma_mask = &irda_dmamask, 293 }, 294 .num_resources = ARRAY_SIZE(h2_irda_resources), 295 .resource = h2_irda_resources, 296}; 297 298static struct platform_device h2_lcd_device = { 299 .name = "lcd_h2", 300 .id = -1, 301}; 302 303static struct platform_device *h2_devices[] __initdata = { 304 &h2_nor_device, 305 &h2_nand_device, 306 &h2_smc91x_device, 307 &h2_irda_device, 308 &h2_kp_device, 309 &h2_lcd_device, 310}; 311 312static void __init h2_init_smc91x(void) 313{ 314 if (gpio_request(0, "SMC91x irq") < 0) { 315 printk("Error requesting gpio 0 for smc91x irq\n"); 316 return; 317 } 318} 319 320static int tps_setup(struct i2c_client *client, void *context) 321{ 322 tps65010_config_vregs1(TPS_LDO2_ENABLE | TPS_VLDO2_3_0V | 323 TPS_LDO1_ENABLE | TPS_VLDO1_3_0V); 324 325 return 0; 326} 327 328static struct tps65010_board tps_board = { 329 .base = H2_TPS_GPIO_BASE, 330 .outmask = 0x0f, 331 .setup = tps_setup, 332}; 333 334static struct i2c_board_info __initdata h2_i2c_board_info[] = { 335 { 336 I2C_BOARD_INFO("tps65010", 0x48), 337 .irq = OMAP_GPIO_IRQ(58), 338 .platform_data = &tps_board, 339 }, { 340 I2C_BOARD_INFO("isp1301_omap", 0x2d), 341 .irq = OMAP_GPIO_IRQ(2), 342 }, 343}; 344 345static void __init h2_init_irq(void) 346{ 347 omap1_init_common_hw(); 348 omap_init_irq(); 349 omap_gpio_init(); 350 h2_init_smc91x(); 351} 352 353static struct omap_usb_config h2_usb_config __initdata = { 354 /* usb1 has a Mini-AB port and external isp1301 transceiver */ 355 .otg = 2, 356 357#ifdef CONFIG_USB_GADGET_OMAP 358 .hmc_mode = 19, /* 0:host(off) 1:dev|otg 2:disabled */ 359 /* .hmc_mode = 21,*/ /* 0:host(off) 1:dev(loopback) 2:host(loopback) */ 360#elif defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE) 361 /* needs OTG cable, or NONSTANDARD (B-to-MiniB) */ 362 .hmc_mode = 20, /* 1:dev|otg(off) 1:host 2:disabled */ 363#endif 364 365 .pins[1] = 3, 366}; 367 368static struct omap_lcd_config h2_lcd_config __initdata = { 369 .ctrl_name = "internal", 370}; 371 372static struct omap_board_config_kernel h2_config[] __initdata = { 373 { OMAP_TAG_LCD, &h2_lcd_config }, 374}; 375 376static void __init h2_init(void) 377{ 378 h2_nor_resource.end = h2_nor_resource.start = omap_cs3_phys(); 379 h2_nor_resource.end += SZ_32M - 1; 380 381 h2_nand_resource.end = h2_nand_resource.start = OMAP_CS2B_PHYS; 382 h2_nand_resource.end += SZ_4K - 1; 383 if (gpio_request(H2_NAND_RB_GPIO_PIN, "NAND ready") < 0) 384 BUG(); 385 gpio_direction_input(H2_NAND_RB_GPIO_PIN); 386 387 omap_cfg_reg(L3_1610_FLASH_CS2B_OE); 388 omap_cfg_reg(M8_1610_FLASH_CS2B_WE); 389 390 /* MMC: card detect and WP */ 391 /* omap_cfg_reg(U19_ARMIO1); */ /* CD */ 392 omap_cfg_reg(BALLOUT_V8_ARMIO3); /* WP */ 393 394 /* Mux pins for keypad */ 395 omap_cfg_reg(F18_1610_KBC0); 396 omap_cfg_reg(D20_1610_KBC1); 397 omap_cfg_reg(D19_1610_KBC2); 398 omap_cfg_reg(E18_1610_KBC3); 399 omap_cfg_reg(C21_1610_KBC4); 400 omap_cfg_reg(G18_1610_KBR0); 401 omap_cfg_reg(F19_1610_KBR1); 402 omap_cfg_reg(H14_1610_KBR2); 403 omap_cfg_reg(E20_1610_KBR3); 404 omap_cfg_reg(E19_1610_KBR4); 405 omap_cfg_reg(N19_1610_KBR5); 406 407 platform_add_devices(h2_devices, ARRAY_SIZE(h2_devices)); 408 omap_board_config = h2_config; 409 omap_board_config_size = ARRAY_SIZE(h2_config); 410 omap_serial_init(); 411 omap_register_i2c_bus(1, 100, h2_i2c_board_info, 412 ARRAY_SIZE(h2_i2c_board_info)); 413 omap1_usb_init(&h2_usb_config); 414 h2_mmc_init(); 415} 416 417static void __init h2_map_io(void) 418{ 419 omap1_map_common_io(); 420} 421 422MACHINE_START(OMAP_H2, "TI-H2") 423 /* Maintainer: Imre Deak <imre.deak@nokia.com> */ 424 .phys_io = 0xfff00000, 425 .io_pg_offst = ((0xfef00000) >> 18) & 0xfffc, 426 .boot_params = 0x10000100, 427 .map_io = h2_map_io, 428 .reserve = omap_reserve, 429 .init_irq = h2_init_irq, 430 .init_machine = h2_init, 431 .timer = &omap_timer, 432MACHINE_END 433