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 void __init omap_ldp_init_early(void)
 255 {
 256         omap2_init_common_infrastructure();
 257         omap2_init_common_devices(NULL, NULL);
 258 }
 259
 260 static int ldp_twl_gpio_setup(struct device *dev, unsigned gpio, unsigned ngpio)
 261 {
 262         int r;
 263
 264         struct gpio gpios[] = {
 265                 {gpio + 7 , GPIOF_OUT_INIT_LOW, "LCD ENABLE"},
 266                 {gpio + 15, GPIOF_OUT_INIT_LOW, "LCD BACKLIGHT"},
 267         };
 268
 269         r = gpio_request_array(gpios, ARRAY_SIZE(gpios));
 270         if (r) {
 271                 pr_err("Cannot request LCD GPIOs, error %d\n", r);
 272                 ldp_backlight_gpio = -EINVAL;
 273                 ldp_lcd_enable_gpio = -EINVAL;
 274                 return r;
 275         }
 276
 277         ldp_backlight_gpio = gpio + 15;
 278         ldp_lcd_enable_gpio = gpio + 7;
 279
 280         return 0;
 281 }
 282
 283 static struct twl4030_gpio_platform_data ldp_gpio_data = {
 284         .gpio_base      = OMAP_MAX_GPIO_LINES,
 285         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 286         .irq_end        = TWL4030_GPIO_IRQ_END,
 287         .setup          = ldp_twl_gpio_setup,
 288 };
 289
 290 static struct regulator_consumer_supply ldp_vmmc1_supply[] = {
 291         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
 292 };
 293
 294 /* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
 295 static struct regulator_init_data ldp_vmmc1 = {
 296         .constraints = {
 297                 .min_uV                 = 1850000,
 298                 .max_uV                 = 3150000,
 299                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 300                                         | REGULATOR_MODE_STANDBY,
 301                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 302                                         | REGULATOR_CHANGE_MODE
 303                                         | REGULATOR_CHANGE_STATUS,
 304         },
 305         .num_consumer_supplies  = ARRAY_SIZE(ldp_vmmc1_supply),
 306         .consumer_supplies      = ldp_vmmc1_supply,
 307 };
 308
 309 /* ads7846 on SPI */
 310 static struct regulator_consumer_supply ldp_vaux1_supplies[] = {
 311         REGULATOR_SUPPLY("vcc", "spi1.0"),
 312 };
 313
 314 /* VAUX1 */
 315 static struct regulator_init_data ldp_vaux1 = {
 316         .constraints = {
 317                 .min_uV                 = 3000000,
 318                 .max_uV                 = 3000000,
 319                 .apply_uV               = true,
 320                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 321                                         | REGULATOR_MODE_STANDBY,
 322                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 323                                         | REGULATOR_CHANGE_STATUS,
 324         },
 325         .num_consumer_supplies          = ARRAY_SIZE(ldp_vaux1_supplies),
 326         .consumer_supplies              = ldp_vaux1_supplies,
 327 };
 328
 329 static struct regulator_consumer_supply ldp_vpll2_supplies[] = {
 330         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
 331         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
 332 };
 333
 334 static struct regulator_init_data ldp_vpll2 = {
 335         .constraints = {
 336                 .name                   = "VDVI",
 337                 .min_uV                 = 1800000,
 338                 .max_uV                 = 1800000,
 339                 .apply_uV               = true,
 340                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 341                                         | REGULATOR_MODE_STANDBY,
 342                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 343                                         | REGULATOR_CHANGE_STATUS,
 344         },
 345         .num_consumer_supplies  = ARRAY_SIZE(ldp_vpll2_supplies),
 346         .consumer_supplies      = ldp_vpll2_supplies,
 347 };
 348
 349 static struct twl4030_platform_data ldp_twldata = {
 350         /* platform_data for children goes here */
 351         .vmmc1          = &ldp_vmmc1,
 352         .vaux1          = &ldp_vaux1,
 353         .vpll2          = &ldp_vpll2,
 354         .gpio           = &ldp_gpio_data,
 355         .keypad         = &ldp_kp_twl4030_data,
 356 };
 357
 358 static int __init omap_i2c_init(void)
 359 {
 360         omap3_pmic_get_config(&ldp_twldata,
 361                           TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_MADC, 0);
 362         omap3_pmic_init("twl4030", &ldp_twldata);
 363         omap_register_i2c_bus(2, 400, NULL, 0);
 364         omap_register_i2c_bus(3, 400, NULL, 0);
 365         return 0;
 366 }
 367
 368 static struct omap2_hsmmc_info mmc[] __initdata = {
 369         {
 370                 .mmc            = 1,
 371                 .caps           = MMC_CAP_4_BIT_DATA,
 372                 .gpio_cd        = -EINVAL,
 373                 .gpio_wp        = -EINVAL,
 374         },
 375         {}      /* Terminator */
 376 };
 377
 378 static struct platform_device *ldp_devices[] __initdata = {
 379         &ldp_gpio_keys_device,
 380 };
 381
 382 #ifdef CONFIG_OMAP_MUX
 383 static struct omap_board_mux board_mux[] __initdata = {
 384         { .reg_offset = OMAP_MUX_TERMINATOR },
 385 };
 386 #endif
 387
 388 static struct mtd_partition ldp_nand_partitions[] = {
 389         /* All the partition sizes are listed in terms of NAND block size */
 390         {
 391                 .name           = "X-Loader-NAND",
 392                 .offset         = 0,
 393                 .size           = 4 * (64 * 2048),      /* 512KB, 0x80000 */
 394                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
 395         },
 396         {
 397                 .name           = "U-Boot-NAND",
 398                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
 399                 .size           = 10 * (64 * 2048),     /* 1.25MB, 0x140000 */
 400                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
 401         },
 402         {
 403                 .name           = "Boot Env-NAND",
 404                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x1c0000 */
 405                 .size           = 2 * (64 * 2048),      /* 256KB, 0x40000 */
 406         },
 407         {
 408                 .name           = "Kernel-NAND",
 409                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x0200000*/
 410                 .size           = 240 * (64 * 2048),    /* 30M, 0x1E00000 */
 411         },
 412         {
 413                 .name           = "File System - NAND",
 414                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x2000000 */
 415                 .size           = MTDPART_SIZ_FULL,     /* 96MB, 0x6000000 */
 416         },
 417
 418 };
 419
 420 static void __init omap_ldp_init(void)
 421 {
 422         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 423         ldp_init_smsc911x();
 424         omap_i2c_init();
 425         platform_add_devices(ldp_devices, ARRAY_SIZE(ldp_devices));
 426         omap_ads7846_init(1, 54, 310, NULL);
 427         omap_serial_init();
 428         usb_musb_init(NULL);
 429         board_nand_init(ldp_nand_partitions,
 430                 ARRAY_SIZE(ldp_nand_partitions), ZOOM_NAND_CS, 0);
 431
 432         omap2_hsmmc_init(mmc);
 433         ldp_display_init();
 434 }
 435
 436 MACHINE_START(OMAP_LDP, "OMAP LDP board")
 437         .atag_offset    = 0x100,
 438         .reserve        = omap_reserve,
 439         .map_io         = omap3_map_io,
 440         .init_early     = omap_ldp_init_early,
 441         .init_irq       = omap3_init_irq,
 442         .init_machine   = omap_ldp_init,
 443         .timer          = &omap3_timer,
 444 MACHINE_END