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