arch/arm/mach-omap2/board-overo.c

   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 */
  76 static bool overo_use_lcd35;
  77
  78 #if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
  79         defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
  80
  81 /* fixed regulator for ads7846 */
  82 static struct regulator_consumer_supply ads7846_supply[] = {
  83         REGULATOR_SUPPLY("vcc", "spi1.0"),
  84 };
  85
  86 static 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
  94 static 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
 102 static struct platform_device vads7846_device = {
 103         .name           = "reg-fixed-voltage",
 104         .id             = 1,
 105         .dev = {
 106                 .platform_data = &vads7846,
 107         },
 108 };
 109
 110 static 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
 117 static 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
 125 static 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
 133 static 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
 141 static void __init overo_init_smsc911x(void)
 142 {
 143         gpmc_smsc911x_init(&smsc911x_cfg);
 144         gpmc_smsc911x_init(&smsc911x2_cfg);
 145 }
 146
 147 #else
 148 static 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
 155 static 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
 162 static struct platform_device overo_tv_connector_device = {
 163         .name                   = "connector-analog-tv",
 164         .id                     = 0,
 165         .dev.platform_data      = &overo_tv_pdata,
 166 };
 167
 168 static 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
 185 static 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
 197 static struct platform_device overo_lcd43_device = {
 198         .name                   = "panel-dpi",
 199         .id                     = 0,
 200         .dev.platform_data      = &overo_lcd43_pdata,
 201 };
 202
 203 static struct connector_dvi_platform_data overo_dvi_connector_pdata = {
 204         .name                   = "dvi",
 205         .source                 = "tfp410.0",
 206         .i2c_bus_num            = 3,
 207 };
 208
 209 static struct platform_device overo_dvi_connector_device = {
 210         .name                   = "connector-dvi",
 211         .id                     = 0,
 212         .dev.platform_data      = &overo_dvi_connector_pdata,
 213 };
 214
 215 static 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
 222 static struct platform_device overo_tfp410_device = {
 223         .name                   = "tfp410",
 224         .id                     = 0,
 225         .dev.platform_data      = &overo_tfp410_pdata,
 226 };
 227
 228 static struct omap_dss_board_info overo_dss_data = {
 229         .default_display_name = "lcd43",
 230 };
 231
 232 static 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
 243 static 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
 272 static 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
 290 static 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
 297 static 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
 318 static struct gpio_led_platform_data gpio_leds_pdata = {
 319         .leds           = gpio_leds,
 320         .num_leds       = ARRAY_SIZE(gpio_leds),
 321 };
 322
 323 static struct platform_device gpio_leds_device = {
 324         .name   = "leds-gpio",
 325         .id     = -1,
 326         .dev    = {
 327                 .platform_data  = &gpio_leds_pdata,
 328         },
 329 };
 330
 331 static void __init overo_init_led(void)
 332 {
 333         platform_device_register(&gpio_leds_device);
 334 }
 335
 336 #else
 337 static 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
 344 static 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
 359 static struct gpio_keys_platform_data gpio_keys_pdata = {
 360         .buttons        = gpio_buttons,
 361         .nbuttons       = ARRAY_SIZE(gpio_buttons),
 362 };
 363
 364 static struct platform_device gpio_keys_device = {
 365         .name   = "gpio-keys",
 366         .id     = -1,
 367         .dev    = {
 368                 .platform_data  = &gpio_keys_pdata,
 369         },
 370 };
 371
 372 static void __init overo_init_keys(void)
 373 {
 374         platform_device_register(&gpio_keys_device);
 375 }
 376
 377 #else
 378 static inline void __init overo_init_keys(void) { return; }
 379 #endif
 380
 381 static 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
 392 static struct twl4030_gpio_platform_data overo_gpio_data = {
 393         .use_leds       = true,
 394         .setup          = overo_twl_gpio_setup,
 395 };
 396
 397 static 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
 411 static struct twl4030_platform_data overo_twldata = {
 412         .gpio           = &overo_gpio_data,
 413         .vmmc1          = &overo_vmmc1,
 414 };
 415
 416 static 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
 430 static 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  */
 446 static 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
 457 static 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
 468 static 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
 476 static struct usbhs_omap_platform_data usbhs_bdata __initdata = {
 477         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
 478 };
 479
 480 #ifdef CONFIG_OMAP_MUX
 481 static struct omap_board_mux board_mux[] __initdata = {
 482         { .reg_offset = OMAP_MUX_TERMINATOR },
 483 };
 484 #endif
 485
 486 static 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
 491 static 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
 498 static 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
 561 MACHINE_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         .handle_irq     = omap3_intc_handle_irq,
 568         .init_machine   = overo_init,
 569         .init_late      = omap35xx_init_late,
 570         .init_time      = omap3_sync32k_timer_init,
 571         .restart        = omap3xxx_restart,
 572 MACHINE_END