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

   1 /*
   2  * linux/arch/arm/mach-omap2/board-ldp.c
   3  *
   4  * Copyright (C) 2008 Texas Instruments Inc.
   5  * Nishant Kamat <nskamat@ti.com>
   6  *
   7  * Modified from mach-omap2/board-3430sdp.c
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13 #include <linux/gpio.h>
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/delay.h>
  18 #include <linux/input.h>
  19 #include <linux/input/matrix_keypad.h>
  20 #include <linux/gpio_keys.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/err.h>
  23 #include <linux/clk.h>
  24 #include <linux/spi/spi.h>
  25 #include <linux/regulator/machine.h>
  26 #include <linux/i2c/twl.h>
  27 #include <linux/io.h>
  28 #include <linux/smsc911x.h>
  29 #include <linux/mmc/host.h>
  30 #include <linux/gpio.h>
  31
  32 #include <mach/hardware.h>
  33 #include <asm/mach-types.h>
  34 #include <asm/mach/arch.h>
  35 #include <asm/mach/map.h>
  36
  37 #include <plat/mcspi.h>
  38 #include <plat/board.h>
  39 #include <plat/common.h>
  40 #include <plat/gpmc.h>
  41 #include <mach/board-zoom.h>
  42
  43 #include <asm/delay.h>
  44 #include <plat/usb.h>
  45 #include <plat/gpmc-smsc911x.h>
  46
  47 #include <video/omapdss.h>
  48 #include <video/omap-panel-generic-dpi.h>
  49
  50 #include "board-flash.h"
  51 #include "mux.h"
  52 #include "hsmmc.h"
  53 #include "control.h"
  54 #include "common-board-devices.h"
  55
  56 #define LDP_SMSC911X_CS         1
  57 #define LDP_SMSC911X_GPIO       152
  58 #define DEBUG_BASE              0x08000000
  59 #define LDP_ETHR_START          DEBUG_BASE
  60
  61 static uint32_t board_keymap[] = {
  62         KEY(0, 0, KEY_1),
  63         KEY(1, 0, KEY_2),
  64         KEY(2, 0, KEY_3),
  65         KEY(0, 1, KEY_4),
  66         KEY(1, 1, KEY_5),
  67         KEY(2, 1, KEY_6),
  68         KEY(3, 1, KEY_F5),
  69         KEY(0, 2, KEY_7),
  70         KEY(1, 2, KEY_8),
  71         KEY(2, 2, KEY_9),
  72         KEY(3, 2, KEY_F6),
  73         KEY(0, 3, KEY_F7),
  74         KEY(1, 3, KEY_0),
  75         KEY(2, 3, KEY_F8),
  76         PERSISTENT_KEY(4, 5),
  77         KEY(4, 4, KEY_VOLUMEUP),
  78         KEY(5, 5, KEY_VOLUMEDOWN),
  79         0
  80 };
  81
  82 static struct matrix_keymap_data board_map_data = {
  83         .keymap                 = board_keymap,
  84         .keymap_size            = ARRAY_SIZE(board_keymap),
  85 };
  86
  87 static struct twl4030_keypad_data ldp_kp_twl4030_data = {
  88         .keymap_data    = &board_map_data,
  89         .rows           = 6,
  90         .cols           = 6,
  91         .rep            = 1,
  92 };
  93
  94 static struct gpio_keys_button ldp_gpio_keys_buttons[] = {
  95         [0] = {
  96                 .code                   = KEY_ENTER,
  97                 .gpio                   = 101,
  98                 .desc                   = "enter sw",
  99                 .active_low             = 1,
 100                 .debounce_interval      = 30,
 101         },
 102         [1] = {
 103                 .code                   = KEY_F1,
 104                 .gpio                   = 102,
 105                 .desc                   = "func 1",
 106                 .active_low             = 1,
 107                 .debounce_interval      = 30,
 108         },
 109         [2] = {
 110                 .code                   = KEY_F2,
 111                 .gpio                   = 103,
 112                 .desc                   = "func 2",
 113                 .active_low             = 1,
 114                 .debounce_interval      = 30,
 115         },
 116         [3] = {
 117                 .code                   = KEY_F3,
 118                 .gpio                   = 104,
 119                 .desc                   = "func 3",
 120                 .active_low             = 1,
 121                 .debounce_interval      = 30,
 122         },
 123         [4] = {
 124                 .code                   = KEY_F4,
 125                 .gpio                   = 105,
 126                 .desc                   = "func 4",
 127                 .active_low             = 1,
 128                 .debounce_interval      = 30,
 129         },
 130         [5] = {
 131                 .code                   = KEY_LEFT,
 132                 .gpio                   = 106,
 133                 .desc                   = "left sw",
 134                 .active_low             = 1,
 135                 .debounce_interval      = 30,
 136         },
 137         [6] = {
 138                 .code                   = KEY_RIGHT,
 139                 .gpio                   = 107,
 140                 .desc                   = "right sw",
 141                 .active_low             = 1,
 142                 .debounce_interval      = 30,
 143         },
 144         [7] = {
 145                 .code                   = KEY_UP,
 146                 .gpio                   = 108,
 147                 .desc                   = "up sw",
 148                 .active_low             = 1,
 149                 .debounce_interval      = 30,
 150         },
 151         [8] = {
 152                 .code                   = KEY_DOWN,
 153                 .gpio                   = 109,
 154                 .desc                   = "down sw",
 155                 .active_low             = 1,
 156                 .debounce_interval      = 30,
 157         },
 158 };
 159
 160 static struct gpio_keys_platform_data ldp_gpio_keys = {
 161         .buttons                = ldp_gpio_keys_buttons,
 162         .nbuttons               = ARRAY_SIZE(ldp_gpio_keys_buttons),
 163         .rep                    = 1,
 164 };
 165
 166 static struct platform_device ldp_gpio_keys_device = {
 167         .name           = "gpio-keys",
 168         .id             = -1,
 169         .dev            = {
 170                 .platform_data  = &ldp_gpio_keys,
 171         },
 172 };
 173
 174 static struct omap_smsc911x_platform_data smsc911x_cfg = {
 175         .cs             = LDP_SMSC911X_CS,
 176         .gpio_irq       = LDP_SMSC911X_GPIO,
 177         .gpio_reset     = -EINVAL,
 178         .flags          = SMSC911X_USE_32BIT,
 179 };
 180
 181 static inline void __init ldp_init_smsc911x(void)
 182 {
 183         gpmc_smsc911x_init(&smsc911x_cfg);
 184 }
 185
 186 /* LCD */
 187
 188 static int ldp_backlight_gpio;
 189 static int ldp_lcd_enable_gpio;
 190
 191 #define LCD_PANEL_RESET_GPIO            55
 192 #define LCD_PANEL_QVGA_GPIO             56
 193
 194 static int ldp_panel_enable_lcd(struct omap_dss_device *dssdev)
 195 {
 196         if (gpio_is_valid(ldp_lcd_enable_gpio))
 197                 gpio_direction_output(ldp_lcd_enable_gpio, 1);
 198         if (gpio_is_valid(ldp_backlight_gpio))
 199                 gpio_direction_output(ldp_backlight_gpio, 1);
 200
 201         return 0;
 202 }
 203
 204 static void ldp_panel_disable_lcd(struct omap_dss_device *dssdev)
 205 {
 206         if (gpio_is_valid(ldp_lcd_enable_gpio))
 207                 gpio_direction_output(ldp_lcd_enable_gpio, 0);
 208         if (gpio_is_valid(ldp_backlight_gpio))
 209                 gpio_direction_output(ldp_backlight_gpio, 0);
 210 }
 211
 212 static struct panel_generic_dpi_data ldp_panel_data = {
 213         .name                   = "nec_nl2432dr22-11b",
 214         .platform_enable        = ldp_panel_enable_lcd,
 215         .platform_disable       = ldp_panel_disable_lcd,
 216 };
 217
 218 static struct omap_dss_device ldp_lcd_device = {
 219         .name                   = "lcd",
 220         .driver_name            = "generic_dpi_panel",
 221         .type                   = OMAP_DISPLAY_TYPE_DPI,
 222         .phy.dpi.data_lines     = 18,
 223         .data                   = &ldp_panel_data,
 224 };
 225
 226 static struct omap_dss_device *ldp_dss_devices[] = {
 227         &ldp_lcd_device,
 228 };
 229
 230 static struct omap_dss_board_info ldp_dss_data = {
 231         .num_devices    = ARRAY_SIZE(ldp_dss_devices),
 232         .devices        = ldp_dss_devices,
 233         .default_device = &ldp_lcd_device,
 234 };
 235
 236 static void __init ldp_display_init(void)
 237 {
 238         int r;
 239
 240         static struct gpio gpios[] __initdata = {
 241                 {LCD_PANEL_RESET_GPIO, GPIOF_OUT_INIT_HIGH, "LCD RESET"},
 242                 {LCD_PANEL_QVGA_GPIO, GPIOF_OUT_INIT_HIGH, "LCD QVGA"},
 243         };
 244
 245         r = gpio_request_array(gpios, ARRAY_SIZE(gpios));
 246         if (r) {
 247                 pr_err("Cannot request LCD GPIOs, error %d\n", r);
 248                 return;
 249         }
 250
 251         omap_display_init(&ldp_dss_data);
 252 }
 253
 254 static int ldp_twl_gpio_setup(struct device *dev, unsigned gpio, unsigned ngpio)
 255 {
 256         int r;
 257
 258         struct gpio gpios[] = {
 259                 {gpio + 7 , GPIOF_OUT_INIT_LOW, "LCD ENABLE"},
 260                 {gpio + 15, GPIOF_OUT_INIT_LOW, "LCD BACKLIGHT"},
 261         };
 262
 263         r = gpio_request_array(gpios, ARRAY_SIZE(gpios));
 264         if (r) {
 265                 pr_err("Cannot request LCD GPIOs, error %d\n", r);
 266                 ldp_backlight_gpio = -EINVAL;
 267                 ldp_lcd_enable_gpio = -EINVAL;
 268                 return r;
 269         }
 270
 271         ldp_backlight_gpio = gpio + 15;
 272         ldp_lcd_enable_gpio = gpio + 7;
 273
 274         return 0;
 275 }
 276
 277 static struct twl4030_gpio_platform_data ldp_gpio_data = {
 278         .gpio_base      = OMAP_MAX_GPIO_LINES,
 279         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 280         .irq_end        = TWL4030_GPIO_IRQ_END,
 281         .setup          = ldp_twl_gpio_setup,
 282 };
 283
 284 static struct regulator_consumer_supply ldp_vmmc1_supply[] = {
 285         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
 286 };
 287
 288 /* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
 289 static struct regulator_init_data ldp_vmmc1 = {
 290         .constraints = {
 291                 .min_uV                 = 1850000,
 292                 .max_uV                 = 3150000,
 293                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 294                                         | REGULATOR_MODE_STANDBY,
 295                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 296                                         | REGULATOR_CHANGE_MODE
 297                                         | REGULATOR_CHANGE_STATUS,
 298         },
 299         .num_consumer_supplies  = ARRAY_SIZE(ldp_vmmc1_supply),
 300         .consumer_supplies      = ldp_vmmc1_supply,
 301 };
 302
 303 /* ads7846 on SPI */
 304 static struct regulator_consumer_supply ldp_vaux1_supplies[] = {
 305         REGULATOR_SUPPLY("vcc", "spi1.0"),
 306 };
 307
 308 /* VAUX1 */
 309 static struct regulator_init_data ldp_vaux1 = {
 310         .constraints = {
 311                 .min_uV                 = 3000000,
 312                 .max_uV                 = 3000000,
 313                 .apply_uV               = true,
 314                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 315                                         | REGULATOR_MODE_STANDBY,
 316                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 317                                         | REGULATOR_CHANGE_STATUS,
 318         },
 319         .num_consumer_supplies          = ARRAY_SIZE(ldp_vaux1_supplies),
 320         .consumer_supplies              = ldp_vaux1_supplies,
 321 };
 322
 323 static struct regulator_consumer_supply ldp_vpll2_supplies[] = {
 324         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
 325         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
 326 };
 327
 328 static struct regulator_init_data ldp_vpll2 = {
 329         .constraints = {
 330                 .name                   = "VDVI",
 331                 .min_uV                 = 1800000,
 332                 .max_uV                 = 1800000,
 333                 .apply_uV               = true,
 334                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 335                                         | REGULATOR_MODE_STANDBY,
 336                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 337                                         | REGULATOR_CHANGE_STATUS,
 338         },
 339         .num_consumer_supplies  = ARRAY_SIZE(ldp_vpll2_supplies),
 340         .consumer_supplies      = ldp_vpll2_supplies,
 341 };
 342
 343 static struct twl4030_platform_data ldp_twldata = {
 344         /* platform_data for children goes here */
 345         .vmmc1          = &ldp_vmmc1,
 346         .vaux1          = &ldp_vaux1,
 347         .vpll2          = &ldp_vpll2,
 348         .gpio           = &ldp_gpio_data,
 349         .keypad         = &ldp_kp_twl4030_data,
 350 };
 351
 352 static int __init omap_i2c_init(void)
 353 {
 354         omap3_pmic_get_config(&ldp_twldata,
 355                           TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_MADC, 0);
 356         omap3_pmic_init("twl4030", &ldp_twldata);
 357         omap_register_i2c_bus(2, 400, NULL, 0);
 358         omap_register_i2c_bus(3, 400, NULL, 0);
 359         return 0;
 360 }
 361
 362 static struct omap2_hsmmc_info mmc[] __initdata = {
 363         {
 364                 .mmc            = 1,
 365                 .caps           = MMC_CAP_4_BIT_DATA,
 366                 .gpio_cd        = -EINVAL,
 367                 .gpio_wp        = -EINVAL,
 368         },
 369         {}      /* Terminator */
 370 };
 371
 372 static struct platform_device *ldp_devices[] __initdata = {
 373         &ldp_gpio_keys_device,
 374 };
 375
 376 #ifdef CONFIG_OMAP_MUX
 377 static struct omap_board_mux board_mux[] __initdata = {
 378         { .reg_offset = OMAP_MUX_TERMINATOR },
 379 };
 380 #endif
 381
 382 static struct mtd_partition ldp_nand_partitions[] = {
 383         /* All the partition sizes are listed in terms of NAND block size */
 384         {
 385                 .name           = "X-Loader-NAND",
 386                 .offset         = 0,
 387                 .size           = 4 * (64 * 2048),      /* 512KB, 0x80000 */
 388                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
 389         },
 390         {
 391                 .name           = "U-Boot-NAND",
 392                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
 393                 .size           = 10 * (64 * 2048),     /* 1.25MB, 0x140000 */
 394                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
 395         },
 396         {
 397                 .name           = "Boot Env-NAND",
 398                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x1c0000 */
 399                 .size           = 2 * (64 * 2048),      /* 256KB, 0x40000 */
 400         },
 401         {
 402                 .name           = "Kernel-NAND",
 403                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x0200000*/
 404                 .size           = 240 * (64 * 2048),    /* 30M, 0x1E00000 */
 405         },
 406         {
 407                 .name           = "File System - NAND",
 408                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x2000000 */
 409                 .size           = MTDPART_SIZ_FULL,     /* 96MB, 0x6000000 */
 410         },
 411
 412 };
 413
 414 static void __init omap_ldp_init(void)
 415 {
 416         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 417         ldp_init_smsc911x();
 418         omap_i2c_init();
 419         platform_add_devices(ldp_devices, ARRAY_SIZE(ldp_devices));
 420         omap_ads7846_init(1, 54, 310, NULL);
 421         omap_serial_init();
 422         omap_sdrc_init(NULL, NULL);
 423         usb_musb_init(NULL);
 424         board_nand_init(ldp_nand_partitions,
 425                 ARRAY_SIZE(ldp_nand_partitions), ZOOM_NAND_CS, 0);
 426
 427         omap2_hsmmc_init(mmc);
 428         ldp_display_init();
 429 }
 430
 431 MACHINE_START(OMAP_LDP, "OMAP LDP board")
 432         .atag_offset    = 0x100,
 433         .reserve        = omap_reserve,
 434         .map_io         = omap3_map_io,
 435         .init_early     = omap3430_init_early,
 436         .init_irq       = omap3_init_irq,
 437         .init_machine   = omap_ldp_init,
 438         .timer          = &omap3_timer,
 439 MACHINE_END