arch/arm/mach-omap2/board-3430sdp.c

   1 /*
   2  * linux/arch/arm/mach-omap2/board-3430sdp.c
   3  *
   4  * Copyright (C) 2007 Texas Instruments
   5  *
   6  * Modified from mach-omap2/board-generic.c
   7  *
   8  * Initial code: Syed Mohammed Khasim
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/delay.h>
  19 #include <linux/input.h>
  20 #include <linux/input/matrix_keypad.h>
  21 #include <linux/spi/spi.h>
  22 #include <linux/spi/ads7846.h>
  23 #include <linux/i2c/twl.h>
  24 #include <linux/regulator/machine.h>
  25 #include <linux/io.h>
  26 #include <linux/gpio.h>
  27
  28 #include <mach/hardware.h>
  29 #include <asm/mach-types.h>
  30 #include <asm/mach/arch.h>
  31 #include <asm/mach/map.h>
  32
  33 #include <plat/mcspi.h>
  34 #include <plat/board.h>
  35 #include <plat/usb.h>
  36 #include <plat/common.h>
  37 #include <plat/dma.h>
  38 #include <plat/gpmc.h>
  39 #include <plat/display.h>
  40
  41 #include <plat/control.h>
  42 #include <plat/gpmc-smc91x.h>
  43
  44 #include <mach/board-sdp.h>
  45
  46 #include "mux.h"
  47 #include "sdram-qimonda-hyb18m512160af-6.h"
  48 #include "hsmmc.h"
  49 #include "pm.h"
  50
  51 #define CONFIG_DISABLE_HFCLK 1
  52
  53 #define SDP3430_TS_GPIO_IRQ_SDPV1       3
  54 #define SDP3430_TS_GPIO_IRQ_SDPV2       2
  55
  56 #define ENABLE_VAUX3_DEDICATED  0x03
  57 #define ENABLE_VAUX3_DEV_GRP    0x20
  58
  59 #define TWL4030_MSECURE_GPIO 22
  60
  61 /* FIXME: These values need to be updated based on more profiling on 3430sdp*/
  62 static struct cpuidle_params omap3_cpuidle_params_table[] = {
  63         /* C1 */
  64         {1, 2, 2, 5},
  65         /* C2 */
  66         {1, 10, 10, 30},
  67         /* C3 */
  68         {1, 50, 50, 300},
  69         /* C4 */
  70         {1, 1500, 1800, 4000},
  71         /* C5 */
  72         {1, 2500, 7500, 12000},
  73         /* C6 */
  74         {1, 3000, 8500, 15000},
  75         /* C7 */
  76         {1, 10000, 30000, 300000},
  77 };
  78
  79 static int board_keymap[] = {
  80         KEY(0, 0, KEY_LEFT),
  81         KEY(0, 1, KEY_RIGHT),
  82         KEY(0, 2, KEY_A),
  83         KEY(0, 3, KEY_B),
  84         KEY(0, 4, KEY_C),
  85         KEY(1, 0, KEY_DOWN),
  86         KEY(1, 1, KEY_UP),
  87         KEY(1, 2, KEY_E),
  88         KEY(1, 3, KEY_F),
  89         KEY(1, 4, KEY_G),
  90         KEY(2, 0, KEY_ENTER),
  91         KEY(2, 1, KEY_I),
  92         KEY(2, 2, KEY_J),
  93         KEY(2, 3, KEY_K),
  94         KEY(2, 4, KEY_3),
  95         KEY(3, 0, KEY_M),
  96         KEY(3, 1, KEY_N),
  97         KEY(3, 2, KEY_O),
  98         KEY(3, 3, KEY_P),
  99         KEY(3, 4, KEY_Q),
 100         KEY(4, 0, KEY_R),
 101         KEY(4, 1, KEY_4),
 102         KEY(4, 2, KEY_T),
 103         KEY(4, 3, KEY_U),
 104         KEY(4, 4, KEY_D),
 105         KEY(5, 0, KEY_V),
 106         KEY(5, 1, KEY_W),
 107         KEY(5, 2, KEY_L),
 108         KEY(5, 3, KEY_S),
 109         KEY(5, 4, KEY_H),
 110         0
 111 };
 112
 113 static struct matrix_keymap_data board_map_data = {
 114         .keymap                 = board_keymap,
 115         .keymap_size            = ARRAY_SIZE(board_keymap),
 116 };
 117
 118 static struct twl4030_keypad_data sdp3430_kp_data = {
 119         .keymap_data    = &board_map_data,
 120         .rows           = 5,
 121         .cols           = 6,
 122         .rep            = 1,
 123 };
 124
 125 static int ts_gpio;     /* Needed for ads7846_get_pendown_state */
 126
 127 /**
 128  * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
 129  *
 130  * @return - void. If request gpio fails then Flag KERN_ERR.
 131  */
 132 static void ads7846_dev_init(void)
 133 {
 134         if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
 135                 printk(KERN_ERR "can't get ads746 pen down GPIO\n");
 136                 return;
 137         }
 138
 139         gpio_direction_input(ts_gpio);
 140
 141         omap_set_gpio_debounce(ts_gpio, 1);
 142         omap_set_gpio_debounce_time(ts_gpio, 0xa);
 143 }
 144
 145 static int ads7846_get_pendown_state(void)
 146 {
 147         return !gpio_get_value(ts_gpio);
 148 }
 149
 150 static struct ads7846_platform_data tsc2046_config __initdata = {
 151         .get_pendown_state      = ads7846_get_pendown_state,
 152         .keep_vref_on           = 1,
 153         .wakeup                         = true,
 154 };
 155
 156
 157 static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
 158         .turbo_mode     = 0,
 159         .single_channel = 1,    /* 0: slave, 1: master */
 160 };
 161
 162 static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
 163         [0] = {
 164                 /*
 165                  * TSC2046 operates at a max freqency of 2MHz, so
 166                  * operate slightly below at 1.5MHz
 167                  */
 168                 .modalias               = "ads7846",
 169                 .bus_num                = 1,
 170                 .chip_select            = 0,
 171                 .max_speed_hz           = 1500000,
 172                 .controller_data        = &tsc2046_mcspi_config,
 173                 .irq                    = 0,
 174                 .platform_data          = &tsc2046_config,
 175         },
 176 };
 177
 178
 179 #define SDP3430_LCD_PANEL_BACKLIGHT_GPIO        8
 180 #define SDP3430_LCD_PANEL_ENABLE_GPIO           5
 181
 182 static unsigned backlight_gpio;
 183 static unsigned enable_gpio;
 184 static int lcd_enabled;
 185 static int dvi_enabled;
 186
 187 static void __init sdp3430_display_init(void)
 188 {
 189         int r;
 190
 191         enable_gpio    = SDP3430_LCD_PANEL_ENABLE_GPIO;
 192         backlight_gpio = SDP3430_LCD_PANEL_BACKLIGHT_GPIO;
 193
 194         r = gpio_request(enable_gpio, "LCD reset");
 195         if (r) {
 196                 printk(KERN_ERR "failed to get LCD reset GPIO\n");
 197                 goto err0;
 198         }
 199
 200         r = gpio_request(backlight_gpio, "LCD Backlight");
 201         if (r) {
 202                 printk(KERN_ERR "failed to get LCD backlight GPIO\n");
 203                 goto err1;
 204         }
 205
 206         gpio_direction_output(enable_gpio, 0);
 207         gpio_direction_output(backlight_gpio, 0);
 208
 209         return;
 210 err1:
 211         gpio_free(enable_gpio);
 212 err0:
 213         return;
 214 }
 215
 216 static int sdp3430_panel_enable_lcd(struct omap_dss_device *dssdev)
 217 {
 218         if (dvi_enabled) {
 219                 printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
 220                 return -EINVAL;
 221         }
 222
 223         gpio_direction_output(enable_gpio, 1);
 224         gpio_direction_output(backlight_gpio, 1);
 225
 226         lcd_enabled = 1;
 227
 228         return 0;
 229 }
 230
 231 static void sdp3430_panel_disable_lcd(struct omap_dss_device *dssdev)
 232 {
 233         lcd_enabled = 0;
 234
 235         gpio_direction_output(enable_gpio, 0);
 236         gpio_direction_output(backlight_gpio, 0);
 237 }
 238
 239 static int sdp3430_panel_enable_dvi(struct omap_dss_device *dssdev)
 240 {
 241         if (lcd_enabled) {
 242                 printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
 243                 return -EINVAL;
 244         }
 245
 246         dvi_enabled = 1;
 247
 248         return 0;
 249 }
 250
 251 static void sdp3430_panel_disable_dvi(struct omap_dss_device *dssdev)
 252 {
 253         dvi_enabled = 0;
 254 }
 255
 256 static int sdp3430_panel_enable_tv(struct omap_dss_device *dssdev)
 257 {
 258         return 0;
 259 }
 260
 261 static void sdp3430_panel_disable_tv(struct omap_dss_device *dssdev)
 262 {
 263 }
 264
 265
 266 static struct omap_dss_device sdp3430_lcd_device = {
 267         .name                   = "lcd",
 268         .driver_name            = "sharp_ls_panel",
 269         .type                   = OMAP_DISPLAY_TYPE_DPI,
 270         .phy.dpi.data_lines     = 16,
 271         .platform_enable        = sdp3430_panel_enable_lcd,
 272         .platform_disable       = sdp3430_panel_disable_lcd,
 273 };
 274
 275 static struct omap_dss_device sdp3430_dvi_device = {
 276         .name                   = "dvi",
 277         .driver_name            = "generic_panel",
 278         .type                   = OMAP_DISPLAY_TYPE_DPI,
 279         .phy.dpi.data_lines     = 24,
 280         .platform_enable        = sdp3430_panel_enable_dvi,
 281         .platform_disable       = sdp3430_panel_disable_dvi,
 282 };
 283
 284 static struct omap_dss_device sdp3430_tv_device = {
 285         .name                   = "tv",
 286         .driver_name            = "venc",
 287         .type                   = OMAP_DISPLAY_TYPE_VENC,
 288         .phy.venc.type          = OMAP_DSS_VENC_TYPE_SVIDEO,
 289         .platform_enable        = sdp3430_panel_enable_tv,
 290         .platform_disable       = sdp3430_panel_disable_tv,
 291 };
 292
 293
 294 static struct omap_dss_device *sdp3430_dss_devices[] = {
 295         &sdp3430_lcd_device,
 296         &sdp3430_dvi_device,
 297         &sdp3430_tv_device,
 298 };
 299
 300 static struct omap_dss_board_info sdp3430_dss_data = {
 301         .num_devices    = ARRAY_SIZE(sdp3430_dss_devices),
 302         .devices        = sdp3430_dss_devices,
 303         .default_device = &sdp3430_lcd_device,
 304 };
 305
 306 static struct platform_device sdp3430_dss_device = {
 307         .name           = "omapdss",
 308         .id             = -1,
 309         .dev            = {
 310                 .platform_data = &sdp3430_dss_data,
 311         },
 312 };
 313
 314 static struct regulator_consumer_supply sdp3430_vdda_dac_supply = {
 315         .supply         = "vdda_dac",
 316         .dev            = &sdp3430_dss_device.dev,
 317 };
 318
 319 static struct platform_device *sdp3430_devices[] __initdata = {
 320         &sdp3430_dss_device,
 321 };
 322
 323 static struct omap_board_config_kernel sdp3430_config[] __initdata = {
 324 };
 325
 326 static void __init omap_3430sdp_init_irq(void)
 327 {
 328         omap_board_config = sdp3430_config;
 329         omap_board_config_size = ARRAY_SIZE(sdp3430_config);
 330         omap3_pm_init_cpuidle(omap3_cpuidle_params_table);
 331         omap2_init_common_hw(hyb18m512160af6_sdrc_params, NULL);
 332         omap_init_irq();
 333         omap_gpio_init();
 334 }
 335
 336 static int sdp3430_batt_table[] = {
 337 /* 0 C*/
 338 30800, 29500, 28300, 27100,
 339 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 340 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 341 11600, 11200, 10800, 10400, 10000, 9630,   9280,   8950,   8620,   8310,
 342 8020,   7730,   7460,   7200,   6950,   6710,   6470,   6250,   6040,   5830,
 343 5640,   5450,   5260,   5090,   4920,   4760,   4600,   4450,   4310,   4170,
 344 4040,   3910,   3790,   3670,   3550
 345 };
 346
 347 static struct twl4030_bci_platform_data sdp3430_bci_data = {
 348         .battery_tmp_tbl        = sdp3430_batt_table,
 349         .tblsize                = ARRAY_SIZE(sdp3430_batt_table),
 350 };
 351
 352 static struct omap2_hsmmc_info mmc[] = {
 353         {
 354                 .mmc            = 1,
 355                 /* 8 bits (default) requires S6.3 == ON,
 356                  * so the SIM card isn't used; else 4 bits.
 357                  */
 358                 .wires          = 8,
 359                 .gpio_wp        = 4,
 360         },
 361         {
 362                 .mmc            = 2,
 363                 .wires          = 8,
 364                 .gpio_wp        = 7,
 365         },
 366         {}      /* Terminator */
 367 };
 368
 369 static struct regulator_consumer_supply sdp3430_vmmc1_supply = {
 370         .supply                 = "vmmc",
 371 };
 372
 373 static struct regulator_consumer_supply sdp3430_vsim_supply = {
 374         .supply                 = "vmmc_aux",
 375 };
 376
 377 static struct regulator_consumer_supply sdp3430_vmmc2_supply = {
 378         .supply                 = "vmmc",
 379 };
 380
 381 static int sdp3430_twl_gpio_setup(struct device *dev,
 382                 unsigned gpio, unsigned ngpio)
 383 {
 384         /* gpio + 0 is "mmc0_cd" (input/IRQ),
 385          * gpio + 1 is "mmc1_cd" (input/IRQ)
 386          */
 387         mmc[0].gpio_cd = gpio + 0;
 388         mmc[1].gpio_cd = gpio + 1;
 389         omap2_hsmmc_init(mmc);
 390
 391         /* link regulators to MMC adapters ... we "know" the
 392          * regulators will be set up only *after* we return.
 393          */
 394         sdp3430_vmmc1_supply.dev = mmc[0].dev;
 395         sdp3430_vsim_supply.dev = mmc[0].dev;
 396         sdp3430_vmmc2_supply.dev = mmc[1].dev;
 397
 398         /* gpio + 7 is "sub_lcd_en_bkl" (output/PWM1) */
 399         gpio_request(gpio + 7, "sub_lcd_en_bkl");
 400         gpio_direction_output(gpio + 7, 0);
 401
 402         /* gpio + 15 is "sub_lcd_nRST" (output) */
 403         gpio_request(gpio + 15, "sub_lcd_nRST");
 404         gpio_direction_output(gpio + 15, 0);
 405
 406         return 0;
 407 }
 408
 409 static struct twl4030_gpio_platform_data sdp3430_gpio_data = {
 410         .gpio_base      = OMAP_MAX_GPIO_LINES,
 411         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 412         .irq_end        = TWL4030_GPIO_IRQ_END,
 413         .pulldowns      = BIT(2) | BIT(6) | BIT(8) | BIT(13)
 414                                 | BIT(16) | BIT(17),
 415         .setup          = sdp3430_twl_gpio_setup,
 416 };
 417
 418 static struct twl4030_usb_data sdp3430_usb_data = {
 419         .usb_mode       = T2_USB_MODE_ULPI,
 420 };
 421
 422 static struct twl4030_madc_platform_data sdp3430_madc_data = {
 423         .irq_line       = 1,
 424 };
 425
 426 /*
 427  * Apply all the fixed voltages since most versions of U-Boot
 428  * don't bother with that initialization.
 429  */
 430
 431 /* VAUX1 for mainboard (irda and sub-lcd) */
 432 static struct regulator_init_data sdp3430_vaux1 = {
 433         .constraints = {
 434                 .min_uV                 = 2800000,
 435                 .max_uV                 = 2800000,
 436                 .apply_uV               = true,
 437                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 438                                         | REGULATOR_MODE_STANDBY,
 439                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 440                                         | REGULATOR_CHANGE_STATUS,
 441         },
 442 };
 443
 444 /* VAUX2 for camera module */
 445 static struct regulator_init_data sdp3430_vaux2 = {
 446         .constraints = {
 447                 .min_uV                 = 2800000,
 448                 .max_uV                 = 2800000,
 449                 .apply_uV               = true,
 450                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 451                                         | REGULATOR_MODE_STANDBY,
 452                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 453                                         | REGULATOR_CHANGE_STATUS,
 454         },
 455 };
 456
 457 /* VAUX3 for LCD board */
 458 static struct regulator_init_data sdp3430_vaux3 = {
 459         .constraints = {
 460                 .min_uV                 = 2800000,
 461                 .max_uV                 = 2800000,
 462                 .apply_uV               = true,
 463                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 464                                         | REGULATOR_MODE_STANDBY,
 465                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 466                                         | REGULATOR_CHANGE_STATUS,
 467         },
 468 };
 469
 470 /* VAUX4 for OMAP VDD_CSI2 (camera) */
 471 static struct regulator_init_data sdp3430_vaux4 = {
 472         .constraints = {
 473                 .min_uV                 = 1800000,
 474                 .max_uV                 = 1800000,
 475                 .apply_uV               = true,
 476                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 477                                         | REGULATOR_MODE_STANDBY,
 478                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 479                                         | REGULATOR_CHANGE_STATUS,
 480         },
 481 };
 482
 483 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 484 static struct regulator_init_data sdp3430_vmmc1 = {
 485         .constraints = {
 486                 .min_uV                 = 1850000,
 487                 .max_uV                 = 3150000,
 488                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 489                                         | REGULATOR_MODE_STANDBY,
 490                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 491                                         | REGULATOR_CHANGE_MODE
 492                                         | REGULATOR_CHANGE_STATUS,
 493         },
 494         .num_consumer_supplies  = 1,
 495         .consumer_supplies      = &sdp3430_vmmc1_supply,
 496 };
 497
 498 /* VMMC2 for MMC2 card */
 499 static struct regulator_init_data sdp3430_vmmc2 = {
 500         .constraints = {
 501                 .min_uV                 = 1850000,
 502                 .max_uV                 = 1850000,
 503                 .apply_uV               = true,
 504                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 505                                         | REGULATOR_MODE_STANDBY,
 506                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 507                                         | REGULATOR_CHANGE_STATUS,
 508         },
 509         .num_consumer_supplies  = 1,
 510         .consumer_supplies      = &sdp3430_vmmc2_supply,
 511 };
 512
 513 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
 514 static struct regulator_init_data sdp3430_vsim = {
 515         .constraints = {
 516                 .min_uV                 = 1800000,
 517                 .max_uV                 = 3000000,
 518                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 519                                         | REGULATOR_MODE_STANDBY,
 520                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 521                                         | REGULATOR_CHANGE_MODE
 522                                         | REGULATOR_CHANGE_STATUS,
 523         },
 524         .num_consumer_supplies  = 1,
 525         .consumer_supplies      = &sdp3430_vsim_supply,
 526 };
 527
 528 /* VDAC for DSS driving S-Video */
 529 static struct regulator_init_data sdp3430_vdac = {
 530         .constraints = {
 531                 .min_uV                 = 1800000,
 532                 .max_uV                 = 1800000,
 533                 .apply_uV               = true,
 534                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 535                                         | REGULATOR_MODE_STANDBY,
 536                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 537                                         | REGULATOR_CHANGE_STATUS,
 538         },
 539         .num_consumer_supplies  = 1,
 540         .consumer_supplies      = &sdp3430_vdda_dac_supply,
 541 };
 542
 543 /* VPLL2 for digital video outputs */
 544 static struct regulator_consumer_supply sdp3430_vpll2_supplies[] = {
 545         {
 546                 .supply         = "vdds_dsi",
 547                 .dev            = &sdp3430_dss_device.dev,
 548         }
 549 };
 550
 551 static struct regulator_init_data sdp3430_vpll2 = {
 552         .constraints = {
 553                 .name                   = "VDVI",
 554                 .min_uV                 = 1800000,
 555                 .max_uV                 = 1800000,
 556                 .apply_uV               = true,
 557                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 558                                         | REGULATOR_MODE_STANDBY,
 559                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 560                                         | REGULATOR_CHANGE_STATUS,
 561         },
 562         .num_consumer_supplies  = ARRAY_SIZE(sdp3430_vpll2_supplies),
 563         .consumer_supplies      = sdp3430_vpll2_supplies,
 564 };
 565
 566 static struct twl4030_codec_audio_data sdp3430_audio = {
 567         .audio_mclk = 26000000,
 568 };
 569
 570 static struct twl4030_codec_data sdp3430_codec = {
 571         .audio_mclk = 26000000,
 572         .audio = &sdp3430_audio,
 573 };
 574
 575 static struct twl4030_platform_data sdp3430_twldata = {
 576         .irq_base       = TWL4030_IRQ_BASE,
 577         .irq_end        = TWL4030_IRQ_END,
 578
 579         /* platform_data for children goes here */
 580         .bci            = &sdp3430_bci_data,
 581         .gpio           = &sdp3430_gpio_data,
 582         .madc           = &sdp3430_madc_data,
 583         .keypad         = &sdp3430_kp_data,
 584         .usb            = &sdp3430_usb_data,
 585         .codec          = &sdp3430_codec,
 586
 587         .vaux1          = &sdp3430_vaux1,
 588         .vaux2          = &sdp3430_vaux2,
 589         .vaux3          = &sdp3430_vaux3,
 590         .vaux4          = &sdp3430_vaux4,
 591         .vmmc1          = &sdp3430_vmmc1,
 592         .vmmc2          = &sdp3430_vmmc2,
 593         .vsim           = &sdp3430_vsim,
 594         .vdac           = &sdp3430_vdac,
 595         .vpll2          = &sdp3430_vpll2,
 596 };
 597
 598 static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
 599         {
 600                 I2C_BOARD_INFO("twl4030", 0x48),
 601                 .flags = I2C_CLIENT_WAKE,
 602                 .irq = INT_34XX_SYS_NIRQ,
 603                 .platform_data = &sdp3430_twldata,
 604         },
 605 };
 606
 607 static int __init omap3430_i2c_init(void)
 608 {
 609         /* i2c1 for PMIC only */
 610         omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
 611                         ARRAY_SIZE(sdp3430_i2c_boardinfo));
 612         /* i2c2 on camera connector (for sensor control) and optional isp1301 */
 613         omap_register_i2c_bus(2, 400, NULL, 0);
 614         /* i2c3 on display connector (for DVI, tfp410) */
 615         omap_register_i2c_bus(3, 400, NULL, 0);
 616         return 0;
 617 }
 618
 619 #if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE)
 620
 621 static struct omap_smc91x_platform_data board_smc91x_data = {
 622         .cs             = 3,
 623         .flags          = GPMC_MUX_ADD_DATA | GPMC_TIMINGS_SMC91C96 |
 624                                 IORESOURCE_IRQ_LOWLEVEL,
 625 };
 626
 627 static void __init board_smc91x_init(void)
 628 {
 629         if (omap_rev() > OMAP3430_REV_ES1_0)
 630                 board_smc91x_data.gpio_irq = 6;
 631         else
 632                 board_smc91x_data.gpio_irq = 29;
 633
 634         gpmc_smc91x_init(&board_smc91x_data);
 635 }
 636
 637 #else
 638
 639 static inline void board_smc91x_init(void)
 640 {
 641 }
 642
 643 #endif
 644
 645 static void enable_board_wakeup_source(void)
 646 {
 647         /* T2 interrupt line (keypad) */
 648         omap_mux_init_signal("sys_nirq",
 649                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
 650 }
 651
 652 static const struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
 653
 654         .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
 655         .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
 656         .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
 657
 658         .phy_reset  = true,
 659         .reset_gpio_port[0]  = 57,
 660         .reset_gpio_port[1]  = 61,
 661         .reset_gpio_port[2]  = -EINVAL
 662 };
 663
 664 #ifdef CONFIG_OMAP_MUX
 665 static struct omap_board_mux board_mux[] __initdata = {
 666         { .reg_offset = OMAP_MUX_TERMINATOR },
 667 };
 668 #else
 669 #define board_mux       NULL
 670 #endif
 671
 672 static struct mtd_partition sdp_nor_partitions[] = {
 673         /* bootloader (U-Boot, etc) in first sector */
 674         {
 675                 .name           = "Bootloader-NOR",
 676                 .offset         = 0,
 677                 .size           = SZ_256K,
 678                 .mask_flags     = MTD_WRITEABLE, /* force read-only */
 679         },
 680         /* bootloader params in the next sector */
 681         {
 682                 .name           = "Params-NOR",
 683                 .offset         = MTDPART_OFS_APPEND,
 684                 .size           = SZ_256K,
 685                 .mask_flags     = 0,
 686         },
 687         /* kernel */
 688         {
 689                 .name           = "Kernel-NOR",
 690                 .offset         = MTDPART_OFS_APPEND,
 691                 .size           = SZ_2M,
 692                 .mask_flags     = 0
 693         },
 694         /* file system */
 695         {
 696                 .name           = "Filesystem-NOR",
 697                 .offset         = MTDPART_OFS_APPEND,
 698                 .size           = MTDPART_SIZ_FULL,
 699                 .mask_flags     = 0
 700         }
 701 };
 702
 703 static struct mtd_partition sdp_onenand_partitions[] = {
 704         {
 705                 .name           = "X-Loader-OneNAND",
 706                 .offset         = 0,
 707                 .size           = 4 * (64 * 2048),
 708                 .mask_flags     = MTD_WRITEABLE  /* force read-only */
 709         },
 710         {
 711                 .name           = "U-Boot-OneNAND",
 712                 .offset         = MTDPART_OFS_APPEND,
 713                 .size           = 2 * (64 * 2048),
 714                 .mask_flags     = MTD_WRITEABLE  /* force read-only */
 715         },
 716         {
 717                 .name           = "U-Boot Environment-OneNAND",
 718                 .offset         = MTDPART_OFS_APPEND,
 719                 .size           = 1 * (64 * 2048),
 720         },
 721         {
 722                 .name           = "Kernel-OneNAND",
 723                 .offset         = MTDPART_OFS_APPEND,
 724                 .size           = 16 * (64 * 2048),
 725         },
 726         {
 727                 .name           = "File System-OneNAND",
 728                 .offset         = MTDPART_OFS_APPEND,
 729                 .size           = MTDPART_SIZ_FULL,
 730         },
 731 };
 732
 733 static struct mtd_partition sdp_nand_partitions[] = {
 734         /* All the partition sizes are listed in terms of NAND block size */
 735         {
 736                 .name           = "X-Loader-NAND",
 737                 .offset         = 0,
 738                 .size           = 4 * (64 * 2048),
 739                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
 740         },
 741         {
 742                 .name           = "U-Boot-NAND",
 743                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
 744                 .size           = 10 * (64 * 2048),
 745                 .mask_flags     = MTD_WRITEABLE,        /* force read-only */
 746         },
 747         {
 748                 .name           = "Boot Env-NAND",
 749
 750                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x1c0000 */
 751                 .size           = 6 * (64 * 2048),
 752         },
 753         {
 754                 .name           = "Kernel-NAND",
 755                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x280000 */
 756                 .size           = 40 * (64 * 2048),
 757         },
 758         {
 759                 .name           = "File System - NAND",
 760                 .size           = MTDPART_SIZ_FULL,
 761                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x780000 */
 762         },
 763 };
 764
 765 static struct flash_partitions sdp_flash_partitions[] = {
 766         {
 767                 .parts = sdp_nor_partitions,
 768                 .nr_parts = ARRAY_SIZE(sdp_nor_partitions),
 769         },
 770         {
 771                 .parts = sdp_onenand_partitions,
 772                 .nr_parts = ARRAY_SIZE(sdp_onenand_partitions),
 773         },
 774         {
 775                 .parts = sdp_nand_partitions,
 776                 .nr_parts = ARRAY_SIZE(sdp_nand_partitions),
 777         },
 778 };
 779
 780 static struct omap_musb_board_data musb_board_data = {
 781         .interface_type         = MUSB_INTERFACE_ULPI,
 782         .mode                   = MUSB_OTG,
 783         .power                  = 100,
 784 };
 785
 786 static void __init omap_3430sdp_init(void)
 787 {
 788         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 789         omap3430_i2c_init();
 790         platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
 791         if (omap_rev() > OMAP3430_REV_ES1_0)
 792                 ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV2;
 793         else
 794                 ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV1;
 795         sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
 796         spi_register_board_info(sdp3430_spi_board_info,
 797                                 ARRAY_SIZE(sdp3430_spi_board_info));
 798         ads7846_dev_init();
 799         omap_serial_init();
 800         usb_musb_init(&musb_board_data);
 801         board_smc91x_init();
 802         sdp_flash_init(sdp_flash_partitions);
 803         sdp3430_display_init();
 804         enable_board_wakeup_source();
 805         usb_ehci_init(&ehci_pdata);
 806 }
 807
 808 static void __init omap_3430sdp_map_io(void)
 809 {
 810         omap2_set_globals_343x();
 811         omap34xx_map_common_io();
 812 }
 813
 814 MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
 815         /* Maintainer: Syed Khasim - Texas Instruments Inc */
 816         .phys_io        = 0x48000000,
 817         .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
 818         .boot_params    = 0x80000100,
 819         .map_io         = omap_3430sdp_map_io,
 820         .init_irq       = omap_3430sdp_init_irq,
 821         .init_machine   = omap_3430sdp_init,
 822         .timer          = &omap_timer,
 823 MACHINE_END