1/* 2 * board-overo.c (Gumstix Overo) 3 * 4 * Initial code: Steve Sakoman <steve@sakoman.com> 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * version 2 as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 18 * 02110-1301 USA 19 * 20 */ 21 22#include <linux/clk.h> 23#include <linux/delay.h> 24#include <linux/err.h> 25#include <linux/init.h> 26#include <linux/io.h> 27#include <linux/gpio.h> 28#include <linux/kernel.h> 29#include <linux/platform_device.h> 30#include <linux/i2c/twl.h> 31#include <linux/regulator/machine.h> 32#include <linux/regulator/fixed.h> 33#include <linux/spi/spi.h> 34 35#include <linux/mtd/mtd.h> 36#include <linux/mtd/nand.h> 37#include <linux/mtd/partitions.h> 38#include <linux/mmc/host.h> 39#include <linux/usb/phy.h> 40 41#include <linux/platform_data/mtd-nand-omap2.h> 42#include <linux/platform_data/spi-omap2-mcspi.h> 43 44#include <asm/mach-types.h> 45#include <asm/mach/arch.h> 46#include <asm/mach/flash.h> 47#include <asm/mach/map.h> 48 49#include <video/omapdss.h> 50#include <video/omap-panel-data.h> 51 52#include "common.h" 53#include "mux.h" 54#include "sdram-micron-mt46h32m32lf-6.h" 55#include "gpmc.h" 56#include "hsmmc.h" 57#include "board-flash.h" 58#include "common-board-devices.h" 59 60#define NAND_CS 0 61 62#define OVERO_GPIO_BT_XGATE 15 63#define OVERO_GPIO_W2W_NRESET 16 64#define OVERO_GPIO_PENDOWN 114 65#define OVERO_GPIO_BT_NRESET 164 66#define OVERO_GPIO_USBH_CPEN 168 67#define OVERO_GPIO_USBH_NRESET 183 68 69#define OVERO_SMSC911X_CS 5 70#define OVERO_SMSC911X_GPIO 176 71#define OVERO_SMSC911X_NRESET 64 72#define OVERO_SMSC911X2_CS 4 73#define OVERO_SMSC911X2_GPIO 65 74 75/* whether to register LCD35 instead of LCD43 */ 76static bool overo_use_lcd35; 77 78#if defined(CONFIG_TOUCHSCREEN_ADS7846) || \ 79 defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE) 80 81/* fixed regulator for ads7846 */ 82static struct regulator_consumer_supply ads7846_supply[] = { 83 REGULATOR_SUPPLY("vcc", "spi1.0"), 84}; 85 86static struct regulator_init_data vads7846_regulator = { 87 .constraints = { 88 .valid_ops_mask = REGULATOR_CHANGE_STATUS, 89 }, 90 .num_consumer_supplies = ARRAY_SIZE(ads7846_supply), 91 .consumer_supplies = ads7846_supply, 92}; 93 94static struct fixed_voltage_config vads7846 = { 95 .supply_name = "vads7846", 96 .microvolts = 3300000, /* 3.3V */ 97 .gpio = -EINVAL, 98 .startup_delay = 0, 99 .init_data = &vads7846_regulator, 100}; 101 102static struct platform_device vads7846_device = { 103 .name = "reg-fixed-voltage", 104 .id = 1, 105 .dev = { 106 .platform_data = &vads7846, 107 }, 108}; 109 110static void __init overo_ads7846_init(void) 111{ 112 omap_ads7846_init(1, OVERO_GPIO_PENDOWN, 0, NULL); 113 platform_device_register(&vads7846_device); 114} 115 116#else 117static inline void __init overo_ads7846_init(void) { return; } 118#endif 119 120#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE) 121 122#include <linux/smsc911x.h> 123#include "gpmc-smsc911x.h" 124 125static struct omap_smsc911x_platform_data smsc911x_cfg = { 126 .id = 0, 127 .cs = OVERO_SMSC911X_CS, 128 .gpio_irq = OVERO_SMSC911X_GPIO, 129 .gpio_reset = OVERO_SMSC911X_NRESET, 130 .flags = SMSC911X_USE_32BIT, 131}; 132 133static struct omap_smsc911x_platform_data smsc911x2_cfg = { 134 .id = 1, 135 .cs = OVERO_SMSC911X2_CS, 136 .gpio_irq = OVERO_SMSC911X2_GPIO, 137 .gpio_reset = -EINVAL, 138 .flags = SMSC911X_USE_32BIT, 139}; 140 141static void __init overo_init_smsc911x(void) 142{ 143 gpmc_smsc911x_init(&smsc911x_cfg); 144 gpmc_smsc911x_init(&smsc911x2_cfg); 145} 146 147#else 148static inline void __init overo_init_smsc911x(void) { return; } 149#endif 150 151/* DSS */ 152#define OVERO_GPIO_LCD_EN 144 153#define OVERO_GPIO_LCD_BL 145 154 155static struct connector_atv_platform_data overo_tv_pdata = { 156 .name = "tv", 157 .source = "venc.0", 158 .connector_type = OMAP_DSS_VENC_TYPE_SVIDEO, 159 .invert_polarity = false, 160}; 161 162static struct platform_device overo_tv_connector_device = { 163 .name = "connector-analog-tv", 164 .id = 0, 165 .dev.platform_data = &overo_tv_pdata, 166}; 167 168static const struct display_timing overo_lcd43_videomode = { 169 .pixelclock = { 0, 9200000, 0 }, 170 171 .hactive = { 0, 480, 0 }, 172 .hfront_porch = { 0, 8, 0 }, 173 .hback_porch = { 0, 4, 0 }, 174 .hsync_len = { 0, 41, 0 }, 175 176 .vactive = { 0, 272, 0 }, 177 .vfront_porch = { 0, 4, 0 }, 178 .vback_porch = { 0, 2, 0 }, 179 .vsync_len = { 0, 10, 0 }, 180 181 .flags = DISPLAY_FLAGS_HSYNC_LOW | DISPLAY_FLAGS_VSYNC_LOW | 182 DISPLAY_FLAGS_DE_HIGH | DISPLAY_FLAGS_PIXDATA_POSEDGE, 183}; 184 185static struct panel_dpi_platform_data overo_lcd43_pdata = { 186 .name = "lcd43", 187 .source = "dpi.0", 188 189 .data_lines = 24, 190 191 .display_timing = &overo_lcd43_videomode, 192 193 .enable_gpio = OVERO_GPIO_LCD_EN, 194 .backlight_gpio = OVERO_GPIO_LCD_BL, 195}; 196 197static struct platform_device overo_lcd43_device = { 198 .name = "panel-dpi", 199 .id = 0, 200 .dev.platform_data = &overo_lcd43_pdata, 201}; 202 203static struct connector_dvi_platform_data overo_dvi_connector_pdata = { 204 .name = "dvi", 205 .source = "tfp410.0", 206 .i2c_bus_num = 3, 207}; 208 209static struct platform_device overo_dvi_connector_device = { 210 .name = "connector-dvi", 211 .id = 0, 212 .dev.platform_data = &overo_dvi_connector_pdata, 213}; 214 215static struct encoder_tfp410_platform_data overo_tfp410_pdata = { 216 .name = "tfp410.0", 217 .source = "dpi.0", 218 .data_lines = 24, 219 .power_down_gpio = -1, 220}; 221 222static struct platform_device overo_tfp410_device = { 223 .name = "tfp410", 224 .id = 0, 225 .dev.platform_data = &overo_tfp410_pdata, 226}; 227 228static struct omap_dss_board_info overo_dss_data = { 229 .default_display_name = "lcd43", 230}; 231 232static void __init overo_display_init(void) 233{ 234 omap_display_init(&overo_dss_data); 235 236 if (!overo_use_lcd35) 237 platform_device_register(&overo_lcd43_device); 238 platform_device_register(&overo_tfp410_device); 239 platform_device_register(&overo_dvi_connector_device); 240 platform_device_register(&overo_tv_connector_device); 241} 242 243static struct mtd_partition overo_nand_partitions[] = { 244 { 245 .name = "xloader", 246 .offset = 0, /* Offset = 0x00000 */ 247 .size = 4 * NAND_BLOCK_SIZE, 248 .mask_flags = MTD_WRITEABLE 249 }, 250 { 251 .name = "uboot", 252 .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */ 253 .size = 14 * NAND_BLOCK_SIZE, 254 }, 255 { 256 .name = "uboot environment", 257 .offset = MTDPART_OFS_APPEND, /* Offset = 0x240000 */ 258 .size = 2 * NAND_BLOCK_SIZE, 259 }, 260 { 261 .name = "linux", 262 .offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */ 263 .size = 32 * NAND_BLOCK_SIZE, 264 }, 265 { 266 .name = "rootfs", 267 .offset = MTDPART_OFS_APPEND, /* Offset = 0x680000 */ 268 .size = MTDPART_SIZ_FULL, 269 }, 270}; 271 272static struct omap2_hsmmc_info mmc[] = { 273 { 274 .mmc = 1, 275 .caps = MMC_CAP_4_BIT_DATA, 276 .gpio_cd = -EINVAL, 277 .gpio_wp = -EINVAL, 278 }, 279 { 280 .mmc = 2, 281 .caps = MMC_CAP_4_BIT_DATA, 282 .gpio_cd = -EINVAL, 283 .gpio_wp = -EINVAL, 284 .transceiver = true, 285 .ocr_mask = 0x00100000, /* 3.3V */ 286 }, 287 {} /* Terminator */ 288}; 289 290static struct regulator_consumer_supply overo_vmmc1_supply[] = { 291 REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"), 292}; 293 294#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE) 295#include <linux/leds.h> 296 297static struct gpio_led gpio_leds[] = { 298 { 299 .name = "overo:red:gpio21", 300 .default_trigger = "heartbeat", 301 .gpio = 21, 302 .active_low = true, 303 }, 304 { 305 .name = "overo:blue:gpio22", 306 .default_trigger = "none", 307 .gpio = 22, 308 .active_low = true, 309 }, 310 { 311 .name = "overo:blue:COM", 312 .default_trigger = "mmc0", 313 .gpio = -EINVAL, /* gets replaced */ 314 .active_low = true, 315 }, 316}; 317 318static struct gpio_led_platform_data gpio_leds_pdata = { 319 .leds = gpio_leds, 320 .num_leds = ARRAY_SIZE(gpio_leds), 321}; 322 323static struct platform_device gpio_leds_device = { 324 .name = "leds-gpio", 325 .id = -1, 326 .dev = { 327 .platform_data = &gpio_leds_pdata, 328 }, 329}; 330 331static void __init overo_init_led(void) 332{ 333 platform_device_register(&gpio_leds_device); 334} 335 336#else 337static inline void __init overo_init_led(void) { return; } 338#endif 339 340#if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE) 341#include <linux/input.h> 342#include <linux/gpio_keys.h> 343 344static struct gpio_keys_button gpio_buttons[] = { 345 { 346 .code = BTN_0, 347 .gpio = 23, 348 .desc = "button0", 349 .wakeup = 1, 350 }, 351 { 352 .code = BTN_1, 353 .gpio = 14, 354 .desc = "button1", 355 .wakeup = 1, 356 }, 357}; 358 359static struct gpio_keys_platform_data gpio_keys_pdata = { 360 .buttons = gpio_buttons, 361 .nbuttons = ARRAY_SIZE(gpio_buttons), 362}; 363 364static struct platform_device gpio_keys_device = { 365 .name = "gpio-keys", 366 .id = -1, 367 .dev = { 368 .platform_data = &gpio_keys_pdata, 369 }, 370}; 371 372static void __init overo_init_keys(void) 373{ 374 platform_device_register(&gpio_keys_device); 375} 376 377#else 378static inline void __init overo_init_keys(void) { return; } 379#endif 380 381static int overo_twl_gpio_setup(struct device *dev, 382 unsigned gpio, unsigned ngpio) 383{ 384#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE) 385 /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */ 386 gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1; 387#endif 388 389 return 0; 390} 391 392static struct twl4030_gpio_platform_data overo_gpio_data = { 393 .use_leds = true, 394 .setup = overo_twl_gpio_setup, 395}; 396 397static struct regulator_init_data overo_vmmc1 = { 398 .constraints = { 399 .min_uV = 1850000, 400 .max_uV = 3150000, 401 .valid_modes_mask = REGULATOR_MODE_NORMAL 402 | REGULATOR_MODE_STANDBY, 403 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE 404 | REGULATOR_CHANGE_MODE 405 | REGULATOR_CHANGE_STATUS, 406 }, 407 .num_consumer_supplies = ARRAY_SIZE(overo_vmmc1_supply), 408 .consumer_supplies = overo_vmmc1_supply, 409}; 410 411static struct twl4030_platform_data overo_twldata = { 412 .gpio = &overo_gpio_data, 413 .vmmc1 = &overo_vmmc1, 414}; 415 416static int __init overo_i2c_init(void) 417{ 418 omap3_pmic_get_config(&overo_twldata, 419 TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_AUDIO, 420 TWL_COMMON_REGULATOR_VDAC | TWL_COMMON_REGULATOR_VPLL2); 421 422 overo_twldata.vpll2->constraints.name = "VDVI"; 423 424 omap3_pmic_init("tps65950", &overo_twldata); 425 /* i2c2 pins are used for gpio */ 426 omap_register_i2c_bus(3, 400, NULL, 0); 427 return 0; 428} 429 430static struct panel_lb035q02_platform_data overo_lcd35_pdata = { 431 .name = "lcd35", 432 .source = "dpi.0", 433 434 .data_lines = 24, 435 436 .enable_gpio = OVERO_GPIO_LCD_EN, 437 .backlight_gpio = OVERO_GPIO_LCD_BL, 438}; 439 440/* 441 * NOTE: We need to add either the lgphilips panel, or the lcd43 panel. The 442 * selection is done based on the overo_use_lcd35 field. If new SPI 443 * devices are added here, extra work is needed to make only the lgphilips panel 444 * affected by the overo_use_lcd35 field. 445 */ 446static struct spi_board_info overo_spi_board_info[] __initdata = { 447 { 448 .modalias = "panel_lgphilips_lb035q02", 449 .bus_num = 1, 450 .chip_select = 1, 451 .max_speed_hz = 500000, 452 .mode = SPI_MODE_3, 453 .platform_data = &overo_lcd35_pdata, 454 }, 455}; 456 457static int __init overo_spi_init(void) 458{ 459 overo_ads7846_init(); 460 461 if (overo_use_lcd35) { 462 spi_register_board_info(overo_spi_board_info, 463 ARRAY_SIZE(overo_spi_board_info)); 464 } 465 return 0; 466} 467 468static struct usbhs_phy_data phy_data[] __initdata = { 469 { 470 .port = 2, 471 .reset_gpio = OVERO_GPIO_USBH_NRESET, 472 .vcc_gpio = -EINVAL, 473 }, 474}; 475 476static struct usbhs_omap_platform_data usbhs_bdata __initdata = { 477 .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY, 478}; 479 480#ifdef CONFIG_OMAP_MUX 481static struct omap_board_mux board_mux[] __initdata = { 482 { .reg_offset = OMAP_MUX_TERMINATOR }, 483}; 484#endif 485 486static struct gpio overo_bt_gpios[] __initdata = { 487 { OVERO_GPIO_BT_XGATE, GPIOF_OUT_INIT_LOW, "lcd enable" }, 488 { OVERO_GPIO_BT_NRESET, GPIOF_OUT_INIT_HIGH, "lcd bl enable" }, 489}; 490 491static struct regulator_consumer_supply dummy_supplies[] = { 492 REGULATOR_SUPPLY("vddvario", "smsc911x.0"), 493 REGULATOR_SUPPLY("vdd33a", "smsc911x.0"), 494 REGULATOR_SUPPLY("vddvario", "smsc911x.1"), 495 REGULATOR_SUPPLY("vdd33a", "smsc911x.1"), 496}; 497 498static void __init overo_init(void) 499{ 500 int ret; 501 502 if (strstr(boot_command_line, "omapdss.def_disp=lcd35")) 503 overo_use_lcd35 = true; 504 505 regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies)); 506 omap3_mux_init(board_mux, OMAP_PACKAGE_CBB); 507 overo_i2c_init(); 508 omap_hsmmc_init(mmc); 509 omap_serial_init(); 510 omap_sdrc_init(mt46h32m32lf6_sdrc_params, 511 mt46h32m32lf6_sdrc_params); 512 board_nand_init(overo_nand_partitions, 513 ARRAY_SIZE(overo_nand_partitions), NAND_CS, 0, NULL); 514 usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb"); 515 usb_musb_init(NULL); 516 517 usbhs_init_phys(phy_data, ARRAY_SIZE(phy_data)); 518 usbhs_init(&usbhs_bdata); 519 overo_spi_init(); 520 overo_init_smsc911x(); 521 overo_init_led(); 522 overo_init_keys(); 523 omap_twl4030_audio_init("overo", NULL); 524 525 overo_display_init(); 526 527 /* Ensure SDRC pins are mux'd for self-refresh */ 528 omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT); 529 omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT); 530 531 ret = gpio_request_one(OVERO_GPIO_W2W_NRESET, GPIOF_OUT_INIT_HIGH, 532 "OVERO_GPIO_W2W_NRESET"); 533 if (ret == 0) { 534 gpio_export(OVERO_GPIO_W2W_NRESET, 0); 535 gpio_set_value(OVERO_GPIO_W2W_NRESET, 0); 536 udelay(10); 537 gpio_set_value(OVERO_GPIO_W2W_NRESET, 1); 538 } else { 539 pr_err("could not obtain gpio for OVERO_GPIO_W2W_NRESET\n"); 540 } 541 542 ret = gpio_request_array(overo_bt_gpios, ARRAY_SIZE(overo_bt_gpios)); 543 if (ret) { 544 pr_err("%s: could not obtain BT gpios\n", __func__); 545 } else { 546 gpio_export(OVERO_GPIO_BT_XGATE, 0); 547 gpio_export(OVERO_GPIO_BT_NRESET, 0); 548 gpio_set_value(OVERO_GPIO_BT_NRESET, 0); 549 mdelay(6); 550 gpio_set_value(OVERO_GPIO_BT_NRESET, 1); 551 } 552 553 ret = gpio_request_one(OVERO_GPIO_USBH_CPEN, GPIOF_OUT_INIT_HIGH, 554 "OVERO_GPIO_USBH_CPEN"); 555 if (ret == 0) 556 gpio_export(OVERO_GPIO_USBH_CPEN, 0); 557 else 558 pr_err("could not obtain gpio for OVERO_GPIO_USBH_CPEN\n"); 559} 560 561MACHINE_START(OVERO, "Gumstix Overo") 562 .atag_offset = 0x100, 563 .reserve = omap_reserve, 564 .map_io = omap3_map_io, 565 .init_early = omap35xx_init_early, 566 .init_irq = omap3_init_irq, 567 .init_machine = overo_init, 568 .init_late = omap35xx_init_late, 569 .init_time = omap3_sync32k_timer_init, 570 .restart = omap3xxx_restart, 571MACHINE_END 572