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