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