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
  40 #include <linux/platform_data/mtd-nand-omap2.h>
  41 #include <linux/platform_data/spi-omap2-mcspi.h>
  42
  43 #include <asm/mach-types.h>
  44 #include <asm/mach/arch.h>
  45 #include <asm/mach/flash.h>
  46 #include <asm/mach/map.h>
  47
  48 #include <video/omapdss.h>
  49 #include <video/omap-panel-generic-dpi.h>
  50 #include <video/omap-panel-tfp410.h>
  51 #include <plat/gpmc.h>
  52 #include <plat/usb.h>
  53
  54 #include "mux.h"
  55 #include "sdram-micron-mt46h32m32lf-6.h"
  56 #include "hsmmc.h"
  57 #include "common-board-devices.h"
  58
  59 #define OVERO_GPIO_BT_XGATE     15
  60 #define OVERO_GPIO_W2W_NRESET   16
  61 #define OVERO_GPIO_PENDOWN      114
  62 #define OVERO_GPIO_BT_NRESET    164
  63 #define OVERO_GPIO_USBH_CPEN    168
  64 #define OVERO_GPIO_USBH_NRESET  183
  65
  66 #define OVERO_SMSC911X_CS      5
  67 #define OVERO_SMSC911X_GPIO    176
  68 #define OVERO_SMSC911X2_CS     4
  69 #define OVERO_SMSC911X2_GPIO   65
  70
  71 #if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
  72         defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
  73
  74 /* fixed regulator for ads7846 */
  75 static struct regulator_consumer_supply ads7846_supply[] = {
  76         REGULATOR_SUPPLY("vcc", "spi1.0"),
  77 };
  78
  79 static struct regulator_init_data vads7846_regulator = {
  80         .constraints = {
  81                 .valid_ops_mask         = REGULATOR_CHANGE_STATUS,
  82         },
  83         .num_consumer_supplies  = ARRAY_SIZE(ads7846_supply),
  84         .consumer_supplies      = ads7846_supply,
  85 };
  86
  87 static struct fixed_voltage_config vads7846 = {
  88         .supply_name            = "vads7846",
  89         .microvolts             = 3300000, /* 3.3V */
  90         .gpio                   = -EINVAL,
  91         .startup_delay          = 0,
  92         .init_data              = &vads7846_regulator,
  93 };
  94
  95 static struct platform_device vads7846_device = {
  96         .name           = "reg-fixed-voltage",
  97         .id             = 1,
  98         .dev = {
  99                 .platform_data = &vads7846,
 100         },
 101 };
 102
 103 static void __init overo_ads7846_init(void)
 104 {
 105         omap_ads7846_init(1, OVERO_GPIO_PENDOWN, 0, NULL);
 106         platform_device_register(&vads7846_device);
 107 }
 108
 109 #else
 110 static inline void __init overo_ads7846_init(void) { return; }
 111 #endif
 112
 113 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
 114
 115 #include <linux/smsc911x.h>
 116 #include "gpmc-smsc911x.h"
 117
 118 static struct omap_smsc911x_platform_data smsc911x_cfg = {
 119         .id             = 0,
 120         .cs             = OVERO_SMSC911X_CS,
 121         .gpio_irq       = OVERO_SMSC911X_GPIO,
 122         .gpio_reset     = -EINVAL,
 123         .flags          = SMSC911X_USE_32BIT,
 124 };
 125
 126 static struct omap_smsc911x_platform_data smsc911x2_cfg = {
 127         .id             = 1,
 128         .cs             = OVERO_SMSC911X2_CS,
 129         .gpio_irq       = OVERO_SMSC911X2_GPIO,
 130         .gpio_reset     = -EINVAL,
 131         .flags          = SMSC911X_USE_32BIT,
 132 };
 133
 134 static void __init overo_init_smsc911x(void)
 135 {
 136         gpmc_smsc911x_init(&smsc911x_cfg);
 137         gpmc_smsc911x_init(&smsc911x2_cfg);
 138 }
 139
 140 #else
 141 static inline void __init overo_init_smsc911x(void) { return; }
 142 #endif
 143
 144 /* DSS */
 145 static int lcd_enabled;
 146 static int dvi_enabled;
 147
 148 #define OVERO_GPIO_LCD_EN 144
 149 #define OVERO_GPIO_LCD_BL 145
 150
 151 static struct gpio overo_dss_gpios[] __initdata = {
 152         { OVERO_GPIO_LCD_EN, GPIOF_OUT_INIT_HIGH, "OVERO_GPIO_LCD_EN" },
 153         { OVERO_GPIO_LCD_BL, GPIOF_OUT_INIT_HIGH, "OVERO_GPIO_LCD_BL" },
 154 };
 155
 156 static void __init overo_display_init(void)
 157 {
 158         if (gpio_request_array(overo_dss_gpios, ARRAY_SIZE(overo_dss_gpios))) {
 159                 printk(KERN_ERR "could not obtain DSS control GPIOs\n");
 160                 return;
 161         }
 162
 163         gpio_export(OVERO_GPIO_LCD_EN, 0);
 164         gpio_export(OVERO_GPIO_LCD_BL, 0);
 165 }
 166
 167 static struct tfp410_platform_data dvi_panel = {
 168         .i2c_bus_num            = 3,
 169         .power_down_gpio        = -1,
 170 };
 171
 172 static struct omap_dss_device overo_dvi_device = {
 173         .name                   = "dvi",
 174         .type                   = OMAP_DISPLAY_TYPE_DPI,
 175         .driver_name            = "tfp410",
 176         .data                   = &dvi_panel,
 177         .phy.dpi.data_lines     = 24,
 178 };
 179
 180 static struct omap_dss_device overo_tv_device = {
 181         .name = "tv",
 182         .driver_name = "venc",
 183         .type = OMAP_DISPLAY_TYPE_VENC,
 184         .phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
 185 };
 186
 187 static int overo_panel_enable_lcd(struct omap_dss_device *dssdev)
 188 {
 189         if (dvi_enabled) {
 190                 printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
 191                 return -EINVAL;
 192         }
 193
 194         gpio_set_value(OVERO_GPIO_LCD_EN, 1);
 195         gpio_set_value(OVERO_GPIO_LCD_BL, 1);
 196         lcd_enabled = 1;
 197         return 0;
 198 }
 199
 200 static void overo_panel_disable_lcd(struct omap_dss_device *dssdev)
 201 {
 202         gpio_set_value(OVERO_GPIO_LCD_EN, 0);
 203         gpio_set_value(OVERO_GPIO_LCD_BL, 0);
 204         lcd_enabled = 0;
 205 }
 206
 207 static struct panel_generic_dpi_data lcd43_panel = {
 208         .name                   = "samsung_lte430wq_f0c",
 209         .platform_enable        = overo_panel_enable_lcd,
 210         .platform_disable       = overo_panel_disable_lcd,
 211 };
 212
 213 static struct omap_dss_device overo_lcd43_device = {
 214         .name                   = "lcd43",
 215         .type                   = OMAP_DISPLAY_TYPE_DPI,
 216         .driver_name            = "generic_dpi_panel",
 217         .data                   = &lcd43_panel,
 218         .phy.dpi.data_lines     = 24,
 219 };
 220
 221 #if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
 222         defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
 223 static struct omap_dss_device overo_lcd35_device = {
 224         .type                   = OMAP_DISPLAY_TYPE_DPI,
 225         .name                   = "lcd35",
 226         .driver_name            = "lgphilips_lb035q02_panel",
 227         .phy.dpi.data_lines     = 24,
 228         .platform_enable        = overo_panel_enable_lcd,
 229         .platform_disable       = overo_panel_disable_lcd,
 230 };
 231 #endif
 232
 233 static struct omap_dss_device *overo_dss_devices[] = {
 234         &overo_dvi_device,
 235         &overo_tv_device,
 236 #if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
 237         defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
 238         &overo_lcd35_device,
 239 #endif
 240         &overo_lcd43_device,
 241 };
 242
 243 static struct omap_dss_board_info overo_dss_data = {
 244         .num_devices    = ARRAY_SIZE(overo_dss_devices),
 245         .devices        = overo_dss_devices,
 246         .default_device = &overo_dvi_device,
 247 };
 248
 249 static struct mtd_partition overo_nand_partitions[] = {
 250         {
 251                 .name           = "xloader",
 252                 .offset         = 0,                    /* Offset = 0x00000 */
 253                 .size           = 4 * NAND_BLOCK_SIZE,
 254                 .mask_flags     = MTD_WRITEABLE
 255         },
 256         {
 257                 .name           = "uboot",
 258                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
 259                 .size           = 14 * NAND_BLOCK_SIZE,
 260         },
 261         {
 262                 .name           = "uboot environment",
 263                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x240000 */
 264                 .size           = 2 * NAND_BLOCK_SIZE,
 265         },
 266         {
 267                 .name           = "linux",
 268                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x280000 */
 269                 .size           = 32 * NAND_BLOCK_SIZE,
 270         },
 271         {
 272                 .name           = "rootfs",
 273                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x680000 */
 274                 .size           = MTDPART_SIZ_FULL,
 275         },
 276 };
 277
 278 static struct omap2_hsmmc_info mmc[] = {
 279         {
 280                 .mmc            = 1,
 281                 .caps           = MMC_CAP_4_BIT_DATA,
 282                 .gpio_cd        = -EINVAL,
 283                 .gpio_wp        = -EINVAL,
 284         },
 285         {
 286                 .mmc            = 2,
 287                 .caps           = MMC_CAP_4_BIT_DATA,
 288                 .gpio_cd        = -EINVAL,
 289                 .gpio_wp        = -EINVAL,
 290                 .transceiver    = true,
 291                 .ocr_mask       = 0x00100000,   /* 3.3V */
 292         },
 293         {}      /* Terminator */
 294 };
 295
 296 static struct regulator_consumer_supply overo_vmmc1_supply[] = {
 297         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
 298 };
 299
 300 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
 301 #include <linux/leds.h>
 302
 303 static struct gpio_led gpio_leds[] = {
 304         {
 305                 .name                   = "overo:red:gpio21",
 306                 .default_trigger        = "heartbeat",
 307                 .gpio                   = 21,
 308                 .active_low             = true,
 309         },
 310         {
 311                 .name                   = "overo:blue:gpio22",
 312                 .default_trigger        = "none",
 313                 .gpio                   = 22,
 314                 .active_low             = true,
 315         },
 316         {
 317                 .name                   = "overo:blue:COM",
 318                 .default_trigger        = "mmc0",
 319                 .gpio                   = -EINVAL,      /* gets replaced */
 320                 .active_low             = true,
 321         },
 322 };
 323
 324 static struct gpio_led_platform_data gpio_leds_pdata = {
 325         .leds           = gpio_leds,
 326         .num_leds       = ARRAY_SIZE(gpio_leds),
 327 };
 328
 329 static struct platform_device gpio_leds_device = {
 330         .name   = "leds-gpio",
 331         .id     = -1,
 332         .dev    = {
 333                 .platform_data  = &gpio_leds_pdata,
 334         },
 335 };
 336
 337 static void __init overo_init_led(void)
 338 {
 339         platform_device_register(&gpio_leds_device);
 340 }
 341
 342 #else
 343 static inline void __init overo_init_led(void) { return; }
 344 #endif
 345
 346 #if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
 347 #include <linux/input.h>
 348 #include <linux/gpio_keys.h>
 349
 350 static struct gpio_keys_button gpio_buttons[] = {
 351         {
 352                 .code                   = BTN_0,
 353                 .gpio                   = 23,
 354                 .desc                   = "button0",
 355                 .wakeup                 = 1,
 356         },
 357         {
 358                 .code                   = BTN_1,
 359                 .gpio                   = 14,
 360                 .desc                   = "button1",
 361                 .wakeup                 = 1,
 362         },
 363 };
 364
 365 static struct gpio_keys_platform_data gpio_keys_pdata = {
 366         .buttons        = gpio_buttons,
 367         .nbuttons       = ARRAY_SIZE(gpio_buttons),
 368 };
 369
 370 static struct platform_device gpio_keys_device = {
 371         .name   = "gpio-keys",
 372         .id     = -1,
 373         .dev    = {
 374                 .platform_data  = &gpio_keys_pdata,
 375         },
 376 };
 377
 378 static void __init overo_init_keys(void)
 379 {
 380         platform_device_register(&gpio_keys_device);
 381 }
 382
 383 #else
 384 static inline void __init overo_init_keys(void) { return; }
 385 #endif
 386
 387 static int overo_twl_gpio_setup(struct device *dev,
 388                 unsigned gpio, unsigned ngpio)
 389 {
 390 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
 391         /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
 392         gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
 393 #endif
 394
 395         return 0;
 396 }
 397
 398 static struct twl4030_gpio_platform_data overo_gpio_data = {
 399         .use_leds       = true,
 400         .setup          = overo_twl_gpio_setup,
 401 };
 402
 403 static struct regulator_init_data overo_vmmc1 = {
 404         .constraints = {
 405                 .min_uV                 = 1850000,
 406                 .max_uV                 = 3150000,
 407                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 408                                         | REGULATOR_MODE_STANDBY,
 409                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 410                                         | REGULATOR_CHANGE_MODE
 411                                         | REGULATOR_CHANGE_STATUS,
 412         },
 413         .num_consumer_supplies  = ARRAY_SIZE(overo_vmmc1_supply),
 414         .consumer_supplies      = overo_vmmc1_supply,
 415 };
 416
 417 static struct twl4030_platform_data overo_twldata = {
 418         .gpio           = &overo_gpio_data,
 419         .vmmc1          = &overo_vmmc1,
 420 };
 421
 422 static int __init overo_i2c_init(void)
 423 {
 424         omap3_pmic_get_config(&overo_twldata,
 425                         TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_AUDIO,
 426                         TWL_COMMON_REGULATOR_VDAC | TWL_COMMON_REGULATOR_VPLL2);
 427
 428         overo_twldata.vpll2->constraints.name = "VDVI";
 429
 430         omap3_pmic_init("tps65950", &overo_twldata);
 431         /* i2c2 pins are used for gpio */
 432         omap_register_i2c_bus(3, 400, NULL, 0);
 433         return 0;
 434 }
 435
 436 static struct spi_board_info overo_spi_board_info[] __initdata = {
 437 #if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
 438         defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
 439         {
 440                 .modalias               = "lgphilips_lb035q02_panel-spi",
 441                 .bus_num                = 1,
 442                 .chip_select            = 1,
 443                 .max_speed_hz           = 500000,
 444                 .mode                   = SPI_MODE_3,
 445         },
 446 #endif
 447 };
 448
 449 static int __init overo_spi_init(void)
 450 {
 451         overo_ads7846_init();
 452         spi_register_board_info(overo_spi_board_info,
 453                         ARRAY_SIZE(overo_spi_board_info));
 454         return 0;
 455 }
 456
 457 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
 458         .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
 459         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
 460         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
 461         .phy_reset  = true,
 462         .reset_gpio_port[0]  = -EINVAL,
 463         .reset_gpio_port[1]  = OVERO_GPIO_USBH_NRESET,
 464         .reset_gpio_port[2]  = -EINVAL
 465 };
 466
 467 #ifdef CONFIG_OMAP_MUX
 468 static struct omap_board_mux board_mux[] __initdata = {
 469         { .reg_offset = OMAP_MUX_TERMINATOR },
 470 };
 471 #endif
 472
 473 static struct gpio overo_bt_gpios[] __initdata = {
 474         { OVERO_GPIO_BT_XGATE,  GPIOF_OUT_INIT_LOW,     "lcd enable"    },
 475         { OVERO_GPIO_BT_NRESET, GPIOF_OUT_INIT_HIGH,    "lcd bl enable" },
 476 };
 477
 478 static struct regulator_consumer_supply dummy_supplies[] = {
 479         REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
 480         REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
 481         REGULATOR_SUPPLY("vddvario", "smsc911x.1"),
 482         REGULATOR_SUPPLY("vdd33a", "smsc911x.1"),
 483 };
 484
 485 static void __init overo_init(void)
 486 {
 487         int ret;
 488
 489         regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
 490         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 491         overo_i2c_init();
 492         omap_hsmmc_init(mmc);
 493         omap_display_init(&overo_dss_data);
 494         omap_serial_init();
 495         omap_sdrc_init(mt46h32m32lf6_sdrc_params,
 496                                   mt46h32m32lf6_sdrc_params);
 497         omap_nand_flash_init(0, overo_nand_partitions,
 498                              ARRAY_SIZE(overo_nand_partitions));
 499         usb_musb_init(NULL);
 500         usbhs_init(&usbhs_bdata);
 501         overo_spi_init();
 502         overo_init_smsc911x();
 503         overo_display_init();
 504         overo_init_led();
 505         overo_init_keys();
 506         omap_twl4030_audio_init("overo");
 507
 508         /* Ensure SDRC pins are mux'd for self-refresh */
 509         omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
 510         omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
 511
 512         ret = gpio_request_one(OVERO_GPIO_W2W_NRESET, GPIOF_OUT_INIT_HIGH,
 513                                "OVERO_GPIO_W2W_NRESET");
 514         if (ret == 0) {
 515                 gpio_export(OVERO_GPIO_W2W_NRESET, 0);
 516                 gpio_set_value(OVERO_GPIO_W2W_NRESET, 0);
 517                 udelay(10);
 518                 gpio_set_value(OVERO_GPIO_W2W_NRESET, 1);
 519         } else {
 520                 pr_err("could not obtain gpio for OVERO_GPIO_W2W_NRESET\n");
 521         }
 522
 523         ret = gpio_request_array(overo_bt_gpios, ARRAY_SIZE(overo_bt_gpios));
 524         if (ret) {
 525                 pr_err("%s: could not obtain BT gpios\n", __func__);
 526         } else {
 527                 gpio_export(OVERO_GPIO_BT_XGATE, 0);
 528                 gpio_export(OVERO_GPIO_BT_NRESET, 0);
 529                 gpio_set_value(OVERO_GPIO_BT_NRESET, 0);
 530                 mdelay(6);
 531                 gpio_set_value(OVERO_GPIO_BT_NRESET, 1);
 532         }
 533
 534         ret = gpio_request_one(OVERO_GPIO_USBH_CPEN, GPIOF_OUT_INIT_HIGH,
 535                                "OVERO_GPIO_USBH_CPEN");
 536         if (ret == 0)
 537                 gpio_export(OVERO_GPIO_USBH_CPEN, 0);
 538         else
 539                 pr_err("could not obtain gpio for OVERO_GPIO_USBH_CPEN\n");
 540 }
 541
 542 MACHINE_START(OVERO, "Gumstix Overo")
 543         .atag_offset    = 0x100,
 544         .reserve        = omap_reserve,
 545         .map_io         = omap3_map_io,
 546         .init_early     = omap35xx_init_early,
 547         .init_irq       = omap3_init_irq,
 548         .handle_irq     = omap3_intc_handle_irq,
 549         .init_machine   = overo_init,
 550         .init_late      = omap35xx_init_late,
 551         .timer          = &omap3_timer,
 552         .restart        = omap_prcm_restart,
 553 MACHINE_END