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/twl4030.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/mux.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/control.h>
  43 #include <plat/gpmc-smc91x.h>
  44
  45 #include "mux.h"
  46 #include "sdram-qimonda-hyb18m512160af-6.h"
  47 #include "mmc-twl4030.h"
  48
  49 #define CONFIG_DISABLE_HFCLK 1
  50
  51 #define SDP3430_TS_GPIO_IRQ_SDPV1       3
  52 #define SDP3430_TS_GPIO_IRQ_SDPV2       2
  53
  54 #define ENABLE_VAUX3_DEDICATED  0x03
  55 #define ENABLE_VAUX3_DEV_GRP    0x20
  56
  57 #define TWL4030_MSECURE_GPIO 22
  58
  59 static int board_keymap[] = {
  60         KEY(0, 0, KEY_LEFT),
  61         KEY(0, 1, KEY_RIGHT),
  62         KEY(0, 2, KEY_A),
  63         KEY(0, 3, KEY_B),
  64         KEY(0, 4, KEY_C),
  65         KEY(1, 0, KEY_DOWN),
  66         KEY(1, 1, KEY_UP),
  67         KEY(1, 2, KEY_E),
  68         KEY(1, 3, KEY_F),
  69         KEY(1, 4, KEY_G),
  70         KEY(2, 0, KEY_ENTER),
  71         KEY(2, 1, KEY_I),
  72         KEY(2, 2, KEY_J),
  73         KEY(2, 3, KEY_K),
  74         KEY(2, 4, KEY_3),
  75         KEY(3, 0, KEY_M),
  76         KEY(3, 1, KEY_N),
  77         KEY(3, 2, KEY_O),
  78         KEY(3, 3, KEY_P),
  79         KEY(3, 4, KEY_Q),
  80         KEY(4, 0, KEY_R),
  81         KEY(4, 1, KEY_4),
  82         KEY(4, 2, KEY_T),
  83         KEY(4, 3, KEY_U),
  84         KEY(4, 4, KEY_D),
  85         KEY(5, 0, KEY_V),
  86         KEY(5, 1, KEY_W),
  87         KEY(5, 2, KEY_L),
  88         KEY(5, 3, KEY_S),
  89         KEY(5, 4, KEY_H),
  90         0
  91 };
  92
  93 static struct matrix_keymap_data board_map_data = {
  94         .keymap                 = board_keymap,
  95         .keymap_size            = ARRAY_SIZE(board_keymap),
  96 };
  97
  98 static struct twl4030_keypad_data sdp3430_kp_data = {
  99         .keymap_data    = &board_map_data,
 100         .rows           = 5,
 101         .cols           = 6,
 102         .rep            = 1,
 103 };
 104
 105 static int ts_gpio;     /* Needed for ads7846_get_pendown_state */
 106
 107 /**
 108  * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
 109  *
 110  * @return - void. If request gpio fails then Flag KERN_ERR.
 111  */
 112 static void ads7846_dev_init(void)
 113 {
 114         if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
 115                 printk(KERN_ERR "can't get ads746 pen down GPIO\n");
 116                 return;
 117         }
 118
 119         gpio_direction_input(ts_gpio);
 120
 121         omap_set_gpio_debounce(ts_gpio, 1);
 122         omap_set_gpio_debounce_time(ts_gpio, 0xa);
 123 }
 124
 125 static int ads7846_get_pendown_state(void)
 126 {
 127         return !gpio_get_value(ts_gpio);
 128 }
 129
 130 static struct ads7846_platform_data tsc2046_config __initdata = {
 131         .get_pendown_state      = ads7846_get_pendown_state,
 132         .keep_vref_on           = 1,
 133 };
 134
 135
 136 static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
 137         .turbo_mode     = 0,
 138         .single_channel = 1,    /* 0: slave, 1: master */
 139 };
 140
 141 static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
 142         [0] = {
 143                 /*
 144                  * TSC2046 operates at a max freqency of 2MHz, so
 145                  * operate slightly below at 1.5MHz
 146                  */
 147                 .modalias               = "ads7846",
 148                 .bus_num                = 1,
 149                 .chip_select            = 0,
 150                 .max_speed_hz           = 1500000,
 151                 .controller_data        = &tsc2046_mcspi_config,
 152                 .irq                    = 0,
 153                 .platform_data          = &tsc2046_config,
 154         },
 155 };
 156
 157
 158 #define SDP3430_LCD_PANEL_BACKLIGHT_GPIO        8
 159 #define SDP3430_LCD_PANEL_ENABLE_GPIO           5
 160
 161 static unsigned backlight_gpio;
 162 static unsigned enable_gpio;
 163 static int lcd_enabled;
 164 static int dvi_enabled;
 165
 166 static void __init sdp3430_display_init(void)
 167 {
 168         int r;
 169
 170         enable_gpio    = SDP3430_LCD_PANEL_ENABLE_GPIO;
 171         backlight_gpio = SDP3430_LCD_PANEL_BACKLIGHT_GPIO;
 172
 173         r = gpio_request(enable_gpio, "LCD reset");
 174         if (r) {
 175                 printk(KERN_ERR "failed to get LCD reset GPIO\n");
 176                 goto err0;
 177         }
 178
 179         r = gpio_request(backlight_gpio, "LCD Backlight");
 180         if (r) {
 181                 printk(KERN_ERR "failed to get LCD backlight GPIO\n");
 182                 goto err1;
 183         }
 184
 185         gpio_direction_output(enable_gpio, 0);
 186         gpio_direction_output(backlight_gpio, 0);
 187
 188         return;
 189 err1:
 190         gpio_free(enable_gpio);
 191 err0:
 192         return;
 193 }
 194
 195 static int sdp3430_panel_enable_lcd(struct omap_dss_device *dssdev)
 196 {
 197         if (dvi_enabled) {
 198                 printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
 199                 return -EINVAL;
 200         }
 201
 202         gpio_direction_output(enable_gpio, 1);
 203         gpio_direction_output(backlight_gpio, 1);
 204
 205         lcd_enabled = 1;
 206
 207         return 0;
 208 }
 209
 210 static void sdp3430_panel_disable_lcd(struct omap_dss_device *dssdev)
 211 {
 212         lcd_enabled = 0;
 213
 214         gpio_direction_output(enable_gpio, 0);
 215         gpio_direction_output(backlight_gpio, 0);
 216 }
 217
 218 static int sdp3430_panel_enable_dvi(struct omap_dss_device *dssdev)
 219 {
 220         if (lcd_enabled) {
 221                 printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
 222                 return -EINVAL;
 223         }
 224
 225         dvi_enabled = 1;
 226
 227         return 0;
 228 }
 229
 230 static void sdp3430_panel_disable_dvi(struct omap_dss_device *dssdev)
 231 {
 232         dvi_enabled = 0;
 233 }
 234
 235 static int sdp3430_panel_enable_tv(struct omap_dss_device *dssdev)
 236 {
 237         return 0;
 238 }
 239
 240 static void sdp3430_panel_disable_tv(struct omap_dss_device *dssdev)
 241 {
 242 }
 243
 244
 245 static struct omap_dss_device sdp3430_lcd_device = {
 246         .name                   = "lcd",
 247         .driver_name            = "sharp_ls_panel",
 248         .type                   = OMAP_DISPLAY_TYPE_DPI,
 249         .phy.dpi.data_lines     = 16,
 250         .platform_enable        = sdp3430_panel_enable_lcd,
 251         .platform_disable       = sdp3430_panel_disable_lcd,
 252 };
 253
 254 static struct omap_dss_device sdp3430_dvi_device = {
 255         .name                   = "dvi",
 256         .driver_name            = "generic_panel",
 257         .type                   = OMAP_DISPLAY_TYPE_DPI,
 258         .phy.dpi.data_lines     = 24,
 259         .platform_enable        = sdp3430_panel_enable_dvi,
 260         .platform_disable       = sdp3430_panel_disable_dvi,
 261 };
 262
 263 static struct omap_dss_device sdp3430_tv_device = {
 264         .name                   = "tv",
 265         .driver_name            = "venc",
 266         .type                   = OMAP_DISPLAY_TYPE_VENC,
 267         .phy.venc.type          = OMAP_DSS_VENC_TYPE_SVIDEO,
 268         .platform_enable        = sdp3430_panel_enable_tv,
 269         .platform_disable       = sdp3430_panel_disable_tv,
 270 };
 271
 272
 273 static struct omap_dss_device *sdp3430_dss_devices[] = {
 274         &sdp3430_lcd_device,
 275         &sdp3430_dvi_device,
 276         &sdp3430_tv_device,
 277 };
 278
 279 static struct omap_dss_board_info sdp3430_dss_data = {
 280         .num_devices    = ARRAY_SIZE(sdp3430_dss_devices),
 281         .devices        = sdp3430_dss_devices,
 282         .default_device = &sdp3430_lcd_device,
 283 };
 284
 285 static struct platform_device sdp3430_dss_device = {
 286         .name           = "omapdss",
 287         .id             = -1,
 288         .dev            = {
 289                 .platform_data = &sdp3430_dss_data,
 290         },
 291 };
 292
 293 static struct regulator_consumer_supply sdp3430_vdda_dac_supply = {
 294         .supply         = "vdda_dac",
 295         .dev            = &sdp3430_dss_device.dev,
 296 };
 297
 298 static struct platform_device *sdp3430_devices[] __initdata = {
 299         &sdp3430_dss_device,
 300 };
 301
 302 static struct omap_board_config_kernel sdp3430_config[] __initdata = {
 303 };
 304
 305 static void __init omap_3430sdp_init_irq(void)
 306 {
 307         omap_board_config = sdp3430_config;
 308         omap_board_config_size = ARRAY_SIZE(sdp3430_config);
 309         omap2_init_common_hw(hyb18m512160af6_sdrc_params, NULL);
 310         omap_init_irq();
 311         omap_gpio_init();
 312 }
 313
 314 static int sdp3430_batt_table[] = {
 315 /* 0 C*/
 316 30800, 29500, 28300, 27100,
 317 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 318 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 319 11600, 11200, 10800, 10400, 10000, 9630,   9280,   8950,   8620,   8310,
 320 8020,   7730,   7460,   7200,   6950,   6710,   6470,   6250,   6040,   5830,
 321 5640,   5450,   5260,   5090,   4920,   4760,   4600,   4450,   4310,   4170,
 322 4040,   3910,   3790,   3670,   3550
 323 };
 324
 325 static struct twl4030_bci_platform_data sdp3430_bci_data = {
 326         .battery_tmp_tbl        = sdp3430_batt_table,
 327         .tblsize                = ARRAY_SIZE(sdp3430_batt_table),
 328 };
 329
 330 static struct twl4030_hsmmc_info mmc[] = {
 331         {
 332                 .mmc            = 1,
 333                 /* 8 bits (default) requires S6.3 == ON,
 334                  * so the SIM card isn't used; else 4 bits.
 335                  */
 336                 .wires          = 8,
 337                 .gpio_wp        = 4,
 338         },
 339         {
 340                 .mmc            = 2,
 341                 .wires          = 8,
 342                 .gpio_wp        = 7,
 343         },
 344         {}      /* Terminator */
 345 };
 346
 347 static struct regulator_consumer_supply sdp3430_vmmc1_supply = {
 348         .supply                 = "vmmc",
 349 };
 350
 351 static struct regulator_consumer_supply sdp3430_vsim_supply = {
 352         .supply                 = "vmmc_aux",
 353 };
 354
 355 static struct regulator_consumer_supply sdp3430_vmmc2_supply = {
 356         .supply                 = "vmmc",
 357 };
 358
 359 static int sdp3430_twl_gpio_setup(struct device *dev,
 360                 unsigned gpio, unsigned ngpio)
 361 {
 362         /* gpio + 0 is "mmc0_cd" (input/IRQ),
 363          * gpio + 1 is "mmc1_cd" (input/IRQ)
 364          */
 365         mmc[0].gpio_cd = gpio + 0;
 366         mmc[1].gpio_cd = gpio + 1;
 367         twl4030_mmc_init(mmc);
 368
 369         /* link regulators to MMC adapters ... we "know" the
 370          * regulators will be set up only *after* we return.
 371          */
 372         sdp3430_vmmc1_supply.dev = mmc[0].dev;
 373         sdp3430_vsim_supply.dev = mmc[0].dev;
 374         sdp3430_vmmc2_supply.dev = mmc[1].dev;
 375
 376         /* gpio + 7 is "sub_lcd_en_bkl" (output/PWM1) */
 377         gpio_request(gpio + 7, "sub_lcd_en_bkl");
 378         gpio_direction_output(gpio + 7, 0);
 379
 380         /* gpio + 15 is "sub_lcd_nRST" (output) */
 381         gpio_request(gpio + 15, "sub_lcd_nRST");
 382         gpio_direction_output(gpio + 15, 0);
 383
 384         return 0;
 385 }
 386
 387 static struct twl4030_gpio_platform_data sdp3430_gpio_data = {
 388         .gpio_base      = OMAP_MAX_GPIO_LINES,
 389         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 390         .irq_end        = TWL4030_GPIO_IRQ_END,
 391         .pulldowns      = BIT(2) | BIT(6) | BIT(8) | BIT(13)
 392                                 | BIT(16) | BIT(17),
 393         .setup          = sdp3430_twl_gpio_setup,
 394 };
 395
 396 static struct twl4030_usb_data sdp3430_usb_data = {
 397         .usb_mode       = T2_USB_MODE_ULPI,
 398 };
 399
 400 static struct twl4030_madc_platform_data sdp3430_madc_data = {
 401         .irq_line       = 1,
 402 };
 403
 404 /*
 405  * Apply all the fixed voltages since most versions of U-Boot
 406  * don't bother with that initialization.
 407  */
 408
 409 /* VAUX1 for mainboard (irda and sub-lcd) */
 410 static struct regulator_init_data sdp3430_vaux1 = {
 411         .constraints = {
 412                 .min_uV                 = 2800000,
 413                 .max_uV                 = 2800000,
 414                 .apply_uV               = true,
 415                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 416                                         | REGULATOR_MODE_STANDBY,
 417                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 418                                         | REGULATOR_CHANGE_STATUS,
 419         },
 420 };
 421
 422 /* VAUX2 for camera module */
 423 static struct regulator_init_data sdp3430_vaux2 = {
 424         .constraints = {
 425                 .min_uV                 = 2800000,
 426                 .max_uV                 = 2800000,
 427                 .apply_uV               = true,
 428                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 429                                         | REGULATOR_MODE_STANDBY,
 430                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 431                                         | REGULATOR_CHANGE_STATUS,
 432         },
 433 };
 434
 435 /* VAUX3 for LCD board */
 436 static struct regulator_init_data sdp3430_vaux3 = {
 437         .constraints = {
 438                 .min_uV                 = 2800000,
 439                 .max_uV                 = 2800000,
 440                 .apply_uV               = true,
 441                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 442                                         | REGULATOR_MODE_STANDBY,
 443                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 444                                         | REGULATOR_CHANGE_STATUS,
 445         },
 446 };
 447
 448 /* VAUX4 for OMAP VDD_CSI2 (camera) */
 449 static struct regulator_init_data sdp3430_vaux4 = {
 450         .constraints = {
 451                 .min_uV                 = 1800000,
 452                 .max_uV                 = 1800000,
 453                 .apply_uV               = true,
 454                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 455                                         | REGULATOR_MODE_STANDBY,
 456                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 457                                         | REGULATOR_CHANGE_STATUS,
 458         },
 459 };
 460
 461 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 462 static struct regulator_init_data sdp3430_vmmc1 = {
 463         .constraints = {
 464                 .min_uV                 = 1850000,
 465                 .max_uV                 = 3150000,
 466                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 467                                         | REGULATOR_MODE_STANDBY,
 468                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 469                                         | REGULATOR_CHANGE_MODE
 470                                         | REGULATOR_CHANGE_STATUS,
 471         },
 472         .num_consumer_supplies  = 1,
 473         .consumer_supplies      = &sdp3430_vmmc1_supply,
 474 };
 475
 476 /* VMMC2 for MMC2 card */
 477 static struct regulator_init_data sdp3430_vmmc2 = {
 478         .constraints = {
 479                 .min_uV                 = 1850000,
 480                 .max_uV                 = 1850000,
 481                 .apply_uV               = true,
 482                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 483                                         | REGULATOR_MODE_STANDBY,
 484                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 485                                         | REGULATOR_CHANGE_STATUS,
 486         },
 487         .num_consumer_supplies  = 1,
 488         .consumer_supplies      = &sdp3430_vmmc2_supply,
 489 };
 490
 491 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
 492 static struct regulator_init_data sdp3430_vsim = {
 493         .constraints = {
 494                 .min_uV                 = 1800000,
 495                 .max_uV                 = 3000000,
 496                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 497                                         | REGULATOR_MODE_STANDBY,
 498                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 499                                         | REGULATOR_CHANGE_MODE
 500                                         | REGULATOR_CHANGE_STATUS,
 501         },
 502         .num_consumer_supplies  = 1,
 503         .consumer_supplies      = &sdp3430_vsim_supply,
 504 };
 505
 506 /* VDAC for DSS driving S-Video */
 507 static struct regulator_init_data sdp3430_vdac = {
 508         .constraints = {
 509                 .min_uV                 = 1800000,
 510                 .max_uV                 = 1800000,
 511                 .apply_uV               = true,
 512                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 513                                         | REGULATOR_MODE_STANDBY,
 514                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 515                                         | REGULATOR_CHANGE_STATUS,
 516         },
 517         .num_consumer_supplies  = 1,
 518         .consumer_supplies      = &sdp3430_vdda_dac_supply,
 519 };
 520
 521 /* VPLL2 for digital video outputs */
 522 static struct regulator_consumer_supply sdp3430_vpll2_supplies[] = {
 523         {
 524                 .supply         = "vdvi",
 525                 .dev            = &sdp3430_lcd_device.dev,
 526         },
 527         {
 528                 .supply         = "vdds_dsi",
 529                 .dev            = &sdp3430_dss_device.dev,
 530         }
 531 };
 532
 533 static struct regulator_init_data sdp3430_vpll2 = {
 534         .constraints = {
 535                 .name                   = "VDVI",
 536                 .min_uV                 = 1800000,
 537                 .max_uV                 = 1800000,
 538                 .apply_uV               = true,
 539                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 540                                         | REGULATOR_MODE_STANDBY,
 541                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 542                                         | REGULATOR_CHANGE_STATUS,
 543         },
 544         .num_consumer_supplies  = ARRAY_SIZE(sdp3430_vpll2_supplies),
 545         .consumer_supplies      = sdp3430_vpll2_supplies,
 546 };
 547
 548 static struct twl4030_codec_audio_data sdp3430_audio = {
 549         .audio_mclk = 26000000,
 550 };
 551
 552 static struct twl4030_codec_data sdp3430_codec = {
 553         .audio_mclk = 26000000,
 554         .audio = &sdp3430_audio,
 555 };
 556
 557 static struct twl4030_platform_data sdp3430_twldata = {
 558         .irq_base       = TWL4030_IRQ_BASE,
 559         .irq_end        = TWL4030_IRQ_END,
 560
 561         /* platform_data for children goes here */
 562         .bci            = &sdp3430_bci_data,
 563         .gpio           = &sdp3430_gpio_data,
 564         .madc           = &sdp3430_madc_data,
 565         .keypad         = &sdp3430_kp_data,
 566         .usb            = &sdp3430_usb_data,
 567         .codec          = &sdp3430_codec,
 568
 569         .vaux1          = &sdp3430_vaux1,
 570         .vaux2          = &sdp3430_vaux2,
 571         .vaux3          = &sdp3430_vaux3,
 572         .vaux4          = &sdp3430_vaux4,
 573         .vmmc1          = &sdp3430_vmmc1,
 574         .vmmc2          = &sdp3430_vmmc2,
 575         .vsim           = &sdp3430_vsim,
 576         .vdac           = &sdp3430_vdac,
 577         .vpll2          = &sdp3430_vpll2,
 578 };
 579
 580 static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
 581         {
 582                 I2C_BOARD_INFO("twl4030", 0x48),
 583                 .flags = I2C_CLIENT_WAKE,
 584                 .irq = INT_34XX_SYS_NIRQ,
 585                 .platform_data = &sdp3430_twldata,
 586         },
 587 };
 588
 589 static int __init omap3430_i2c_init(void)
 590 {
 591         /* i2c1 for PMIC only */
 592         omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
 593                         ARRAY_SIZE(sdp3430_i2c_boardinfo));
 594         /* i2c2 on camera connector (for sensor control) and optional isp1301 */
 595         omap_register_i2c_bus(2, 400, NULL, 0);
 596         /* i2c3 on display connector (for DVI, tfp410) */
 597         omap_register_i2c_bus(3, 400, NULL, 0);
 598         return 0;
 599 }
 600
 601 #if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE)
 602
 603 static struct omap_smc91x_platform_data board_smc91x_data = {
 604         .cs             = 3,
 605         .flags          = GPMC_MUX_ADD_DATA | GPMC_TIMINGS_SMC91C96 |
 606                                 IORESOURCE_IRQ_LOWLEVEL,
 607 };
 608
 609 static void __init board_smc91x_init(void)
 610 {
 611         if (omap_rev() > OMAP3430_REV_ES1_0)
 612                 board_smc91x_data.gpio_irq = 6;
 613         else
 614                 board_smc91x_data.gpio_irq = 29;
 615
 616         gpmc_smc91x_init(&board_smc91x_data);
 617 }
 618
 619 #else
 620
 621 static inline void board_smc91x_init(void)
 622 {
 623 }
 624
 625 #endif
 626
 627 static void enable_board_wakeup_source(void)
 628 {
 629         /* T2 interrupt line (keypad) */
 630         omap_mux_init_signal("sys_nirq",
 631                 OMAP_WAKEUP_EN | OMAP_PIN_INPUT_PULLUP);
 632 }
 633
 634 static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
 635
 636         .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
 637         .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
 638         .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
 639
 640         .phy_reset  = true,
 641         .reset_gpio_port[0]  = 57,
 642         .reset_gpio_port[1]  = 61,
 643         .reset_gpio_port[2]  = -EINVAL
 644 };
 645
 646 #ifdef CONFIG_OMAP_MUX
 647 static struct omap_board_mux board_mux[] __initdata = {
 648         { .reg_offset = OMAP_MUX_TERMINATOR },
 649 };
 650 #else
 651 #define board_mux       NULL
 652 #endif
 653
 654 static void __init omap_3430sdp_init(void)
 655 {
 656         omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 657         omap3430_i2c_init();
 658         platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
 659         if (omap_rev() > OMAP3430_REV_ES1_0)
 660                 ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV2;
 661         else
 662                 ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV1;
 663         sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
 664         spi_register_board_info(sdp3430_spi_board_info,
 665                                 ARRAY_SIZE(sdp3430_spi_board_info));
 666         ads7846_dev_init();
 667         omap_serial_init();
 668         usb_musb_init();
 669         board_smc91x_init();
 670         sdp3430_display_init();
 671         enable_board_wakeup_source();
 672         usb_ehci_init(&ehci_pdata);
 673 }
 674
 675 static void __init omap_3430sdp_map_io(void)
 676 {
 677         omap2_set_globals_343x();
 678         omap2_map_common_io();
 679 }
 680
 681 MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
 682         /* Maintainer: Syed Khasim - Texas Instruments Inc */
 683         .phys_io        = 0x48000000,
 684         .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
 685         .boot_params    = 0x80000100,
 686         .map_io         = omap_3430sdp_map_io,
 687         .init_irq       = omap_3430sdp_init_irq,
 688         .init_machine   = omap_3430sdp_init,
 689         .timer          = &omap_timer,
 690 MACHINE_END