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/spi/spi.h>
  21 #include <linux/spi/ads7846.h>
  22 #include <linux/i2c/twl4030.h>
  23 #include <linux/regulator/machine.h>
  24 #include <linux/io.h>
  25 #include <linux/gpio.h>
  26
  27 #include <mach/hardware.h>
  28 #include <asm/mach-types.h>
  29 #include <asm/mach/arch.h>
  30 #include <asm/mach/map.h>
  31
  32 #include <mach/mcspi.h>
  33 #include <mach/mux.h>
  34 #include <mach/board.h>
  35 #include <mach/usb.h>
  36 #include <mach/common.h>
  37 #include <mach/dma.h>
  38 #include <mach/gpmc.h>
  39
  40 #include <mach/control.h>
  41 #include <mach/keypad.h>
  42 #include <mach/gpmc-smc91x.h>
  43
  44 #include "sdram-qimonda-hyb18m512160af-6.h"
  45 #include "mmc-twl4030.h"
  46
  47 #define CONFIG_DISABLE_HFCLK 1
  48
  49 #define SDP3430_TS_GPIO_IRQ_SDPV1       3
  50 #define SDP3430_TS_GPIO_IRQ_SDPV2       2
  51
  52 #define ENABLE_VAUX3_DEDICATED  0x03
  53 #define ENABLE_VAUX3_DEV_GRP    0x20
  54
  55 #define TWL4030_MSECURE_GPIO 22
  56
  57 static int sdp3430_keymap[] = {
  58         KEY(0, 0, KEY_LEFT),
  59         KEY(0, 1, KEY_RIGHT),
  60         KEY(0, 2, KEY_A),
  61         KEY(0, 3, KEY_B),
  62         KEY(0, 4, KEY_C),
  63         KEY(1, 0, KEY_DOWN),
  64         KEY(1, 1, KEY_UP),
  65         KEY(1, 2, KEY_E),
  66         KEY(1, 3, KEY_F),
  67         KEY(1, 4, KEY_G),
  68         KEY(2, 0, KEY_ENTER),
  69         KEY(2, 1, KEY_I),
  70         KEY(2, 2, KEY_J),
  71         KEY(2, 3, KEY_K),
  72         KEY(2, 4, KEY_3),
  73         KEY(3, 0, KEY_M),
  74         KEY(3, 1, KEY_N),
  75         KEY(3, 2, KEY_O),
  76         KEY(3, 3, KEY_P),
  77         KEY(3, 4, KEY_Q),
  78         KEY(4, 0, KEY_R),
  79         KEY(4, 1, KEY_4),
  80         KEY(4, 2, KEY_T),
  81         KEY(4, 3, KEY_U),
  82         KEY(4, 4, KEY_D),
  83         KEY(5, 0, KEY_V),
  84         KEY(5, 1, KEY_W),
  85         KEY(5, 2, KEY_L),
  86         KEY(5, 3, KEY_S),
  87         KEY(5, 4, KEY_H),
  88         0
  89 };
  90
  91 static struct twl4030_keypad_data sdp3430_kp_data = {
  92         .rows           = 5,
  93         .cols           = 6,
  94         .keymap         = sdp3430_keymap,
  95         .keymapsize     = ARRAY_SIZE(sdp3430_keymap),
  96         .rep            = 1,
  97 };
  98
  99 static int ts_gpio;     /* Needed for ads7846_get_pendown_state */
 100
 101 /**
 102  * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
 103  *
 104  * @return - void. If request gpio fails then Flag KERN_ERR.
 105  */
 106 static void ads7846_dev_init(void)
 107 {
 108         if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
 109                 printk(KERN_ERR "can't get ads746 pen down GPIO\n");
 110                 return;
 111         }
 112
 113         gpio_direction_input(ts_gpio);
 114
 115         omap_set_gpio_debounce(ts_gpio, 1);
 116         omap_set_gpio_debounce_time(ts_gpio, 0xa);
 117 }
 118
 119 static int ads7846_get_pendown_state(void)
 120 {
 121         return !gpio_get_value(ts_gpio);
 122 }
 123
 124 static struct ads7846_platform_data tsc2046_config __initdata = {
 125         .get_pendown_state      = ads7846_get_pendown_state,
 126         .keep_vref_on           = 1,
 127 };
 128
 129
 130 static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
 131         .turbo_mode     = 0,
 132         .single_channel = 1,    /* 0: slave, 1: master */
 133 };
 134
 135 static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
 136         [0] = {
 137                 /*
 138                  * TSC2046 operates at a max freqency of 2MHz, so
 139                  * operate slightly below at 1.5MHz
 140                  */
 141                 .modalias               = "ads7846",
 142                 .bus_num                = 1,
 143                 .chip_select            = 0,
 144                 .max_speed_hz           = 1500000,
 145                 .controller_data        = &tsc2046_mcspi_config,
 146                 .irq                    = 0,
 147                 .platform_data          = &tsc2046_config,
 148         },
 149 };
 150
 151 static struct platform_device sdp3430_lcd_device = {
 152         .name           = "sdp2430_lcd",
 153         .id             = -1,
 154 };
 155
 156 static struct regulator_consumer_supply sdp3430_vdac_supply = {
 157         .supply         = "vdac",
 158         .dev            = &sdp3430_lcd_device.dev,
 159 };
 160
 161 static struct regulator_consumer_supply sdp3430_vdvi_supply = {
 162         .supply         = "vdvi",
 163         .dev            = &sdp3430_lcd_device.dev,
 164 };
 165
 166 static struct platform_device *sdp3430_devices[] __initdata = {
 167         &sdp3430_lcd_device,
 168 };
 169
 170 static void __init omap_3430sdp_init_irq(void)
 171 {
 172         omap2_init_common_hw(hyb18m512160af6_sdrc_params, NULL);
 173         omap_init_irq();
 174         omap_gpio_init();
 175 }
 176
 177 static struct omap_lcd_config sdp3430_lcd_config __initdata = {
 178         .ctrl_name      = "internal",
 179 };
 180
 181 static struct omap_board_config_kernel sdp3430_config[] __initdata = {
 182         { OMAP_TAG_LCD,         &sdp3430_lcd_config },
 183 };
 184
 185 static int sdp3430_batt_table[] = {
 186 /* 0 C*/
 187 30800, 29500, 28300, 27100,
 188 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 189 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 190 11600, 11200, 10800, 10400, 10000, 9630,   9280,   8950,   8620,   8310,
 191 8020,   7730,   7460,   7200,   6950,   6710,   6470,   6250,   6040,   5830,
 192 5640,   5450,   5260,   5090,   4920,   4760,   4600,   4450,   4310,   4170,
 193 4040,   3910,   3790,   3670,   3550
 194 };
 195
 196 static struct twl4030_bci_platform_data sdp3430_bci_data = {
 197         .battery_tmp_tbl        = sdp3430_batt_table,
 198         .tblsize                = ARRAY_SIZE(sdp3430_batt_table),
 199 };
 200
 201 static struct twl4030_hsmmc_info mmc[] = {
 202         {
 203                 .mmc            = 1,
 204                 /* 8 bits (default) requires S6.3 == ON,
 205                  * so the SIM card isn't used; else 4 bits.
 206                  */
 207                 .wires          = 8,
 208                 .gpio_wp        = 4,
 209         },
 210         {
 211                 .mmc            = 2,
 212                 .wires          = 8,
 213                 .gpio_wp        = 7,
 214         },
 215         {}      /* Terminator */
 216 };
 217
 218 static struct regulator_consumer_supply sdp3430_vmmc1_supply = {
 219         .supply                 = "vmmc",
 220 };
 221
 222 static struct regulator_consumer_supply sdp3430_vsim_supply = {
 223         .supply                 = "vmmc_aux",
 224 };
 225
 226 static struct regulator_consumer_supply sdp3430_vmmc2_supply = {
 227         .supply                 = "vmmc",
 228 };
 229
 230 static int sdp3430_twl_gpio_setup(struct device *dev,
 231                 unsigned gpio, unsigned ngpio)
 232 {
 233         /* gpio + 0 is "mmc0_cd" (input/IRQ),
 234          * gpio + 1 is "mmc1_cd" (input/IRQ)
 235          */
 236         mmc[0].gpio_cd = gpio + 0;
 237         mmc[1].gpio_cd = gpio + 1;
 238         twl4030_mmc_init(mmc);
 239
 240         /* link regulators to MMC adapters ... we "know" the
 241          * regulators will be set up only *after* we return.
 242          */
 243         sdp3430_vmmc1_supply.dev = mmc[0].dev;
 244         sdp3430_vsim_supply.dev = mmc[0].dev;
 245         sdp3430_vmmc2_supply.dev = mmc[1].dev;
 246
 247         /* gpio + 7 is "sub_lcd_en_bkl" (output/PWM1) */
 248         gpio_request(gpio + 7, "sub_lcd_en_bkl");
 249         gpio_direction_output(gpio + 7, 0);
 250
 251         /* gpio + 15 is "sub_lcd_nRST" (output) */
 252         gpio_request(gpio + 15, "sub_lcd_nRST");
 253         gpio_direction_output(gpio + 15, 0);
 254
 255         return 0;
 256 }
 257
 258 static struct twl4030_gpio_platform_data sdp3430_gpio_data = {
 259         .gpio_base      = OMAP_MAX_GPIO_LINES,
 260         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 261         .irq_end        = TWL4030_GPIO_IRQ_END,
 262         .pulldowns      = BIT(2) | BIT(6) | BIT(8) | BIT(13)
 263                                 | BIT(16) | BIT(17),
 264         .setup          = sdp3430_twl_gpio_setup,
 265 };
 266
 267 static struct twl4030_usb_data sdp3430_usb_data = {
 268         .usb_mode       = T2_USB_MODE_ULPI,
 269 };
 270
 271 static struct twl4030_madc_platform_data sdp3430_madc_data = {
 272         .irq_line       = 1,
 273 };
 274
 275 /*
 276  * Apply all the fixed voltages since most versions of U-Boot
 277  * don't bother with that initialization.
 278  */
 279
 280 /* VAUX1 for mainboard (irda and sub-lcd) */
 281 static struct regulator_init_data sdp3430_vaux1 = {
 282         .constraints = {
 283                 .min_uV                 = 2800000,
 284                 .max_uV                 = 2800000,
 285                 .apply_uV               = true,
 286                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 287                                         | REGULATOR_MODE_STANDBY,
 288                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 289                                         | REGULATOR_CHANGE_STATUS,
 290         },
 291 };
 292
 293 /* VAUX2 for camera module */
 294 static struct regulator_init_data sdp3430_vaux2 = {
 295         .constraints = {
 296                 .min_uV                 = 2800000,
 297                 .max_uV                 = 2800000,
 298                 .apply_uV               = true,
 299                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 300                                         | REGULATOR_MODE_STANDBY,
 301                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 302                                         | REGULATOR_CHANGE_STATUS,
 303         },
 304 };
 305
 306 /* VAUX3 for LCD board */
 307 static struct regulator_init_data sdp3430_vaux3 = {
 308         .constraints = {
 309                 .min_uV                 = 2800000,
 310                 .max_uV                 = 2800000,
 311                 .apply_uV               = true,
 312                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 313                                         | REGULATOR_MODE_STANDBY,
 314                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 315                                         | REGULATOR_CHANGE_STATUS,
 316         },
 317 };
 318
 319 /* VAUX4 for OMAP VDD_CSI2 (camera) */
 320 static struct regulator_init_data sdp3430_vaux4 = {
 321         .constraints = {
 322                 .min_uV                 = 1800000,
 323                 .max_uV                 = 1800000,
 324                 .apply_uV               = true,
 325                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 326                                         | REGULATOR_MODE_STANDBY,
 327                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 328                                         | REGULATOR_CHANGE_STATUS,
 329         },
 330 };
 331
 332 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
 333 static struct regulator_init_data sdp3430_vmmc1 = {
 334         .constraints = {
 335                 .min_uV                 = 1850000,
 336                 .max_uV                 = 3150000,
 337                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 338                                         | REGULATOR_MODE_STANDBY,
 339                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 340                                         | REGULATOR_CHANGE_MODE
 341                                         | REGULATOR_CHANGE_STATUS,
 342         },
 343         .num_consumer_supplies  = 1,
 344         .consumer_supplies      = &sdp3430_vmmc1_supply,
 345 };
 346
 347 /* VMMC2 for MMC2 card */
 348 static struct regulator_init_data sdp3430_vmmc2 = {
 349         .constraints = {
 350                 .min_uV                 = 1850000,
 351                 .max_uV                 = 1850000,
 352                 .apply_uV               = true,
 353                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 354                                         | REGULATOR_MODE_STANDBY,
 355                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 356                                         | REGULATOR_CHANGE_STATUS,
 357         },
 358         .num_consumer_supplies  = 1,
 359         .consumer_supplies      = &sdp3430_vmmc2_supply,
 360 };
 361
 362 /* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
 363 static struct regulator_init_data sdp3430_vsim = {
 364         .constraints = {
 365                 .min_uV                 = 1800000,
 366                 .max_uV                 = 3000000,
 367                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 368                                         | REGULATOR_MODE_STANDBY,
 369                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 370                                         | REGULATOR_CHANGE_MODE
 371                                         | REGULATOR_CHANGE_STATUS,
 372         },
 373         .num_consumer_supplies  = 1,
 374         .consumer_supplies      = &sdp3430_vsim_supply,
 375 };
 376
 377 /* VDAC for DSS driving S-Video */
 378 static struct regulator_init_data sdp3430_vdac = {
 379         .constraints = {
 380                 .min_uV                 = 1800000,
 381                 .max_uV                 = 1800000,
 382                 .apply_uV               = true,
 383                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 384                                         | REGULATOR_MODE_STANDBY,
 385                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 386                                         | REGULATOR_CHANGE_STATUS,
 387         },
 388         .num_consumer_supplies  = 1,
 389         .consumer_supplies      = &sdp3430_vdac_supply,
 390 };
 391
 392 /* VPLL2 for digital video outputs */
 393 static struct regulator_init_data sdp3430_vpll2 = {
 394         .constraints = {
 395                 .name                   = "VDVI",
 396                 .min_uV                 = 1800000,
 397                 .max_uV                 = 1800000,
 398                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 399                                         | REGULATOR_MODE_STANDBY,
 400                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 401                                         | REGULATOR_CHANGE_STATUS,
 402         },
 403         .num_consumer_supplies  = 1,
 404         .consumer_supplies      = &sdp3430_vdvi_supply,
 405 };
 406
 407 static struct twl4030_platform_data sdp3430_twldata = {
 408         .irq_base       = TWL4030_IRQ_BASE,
 409         .irq_end        = TWL4030_IRQ_END,
 410
 411         /* platform_data for children goes here */
 412         .bci            = &sdp3430_bci_data,
 413         .gpio           = &sdp3430_gpio_data,
 414         .madc           = &sdp3430_madc_data,
 415         .keypad         = &sdp3430_kp_data,
 416         .usb            = &sdp3430_usb_data,
 417
 418         .vaux1          = &sdp3430_vaux1,
 419         .vaux2          = &sdp3430_vaux2,
 420         .vaux3          = &sdp3430_vaux3,
 421         .vaux4          = &sdp3430_vaux4,
 422         .vmmc1          = &sdp3430_vmmc1,
 423         .vmmc2          = &sdp3430_vmmc2,
 424         .vsim           = &sdp3430_vsim,
 425         .vdac           = &sdp3430_vdac,
 426         .vpll2          = &sdp3430_vpll2,
 427 };
 428
 429 static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
 430         {
 431                 I2C_BOARD_INFO("twl4030", 0x48),
 432                 .flags = I2C_CLIENT_WAKE,
 433                 .irq = INT_34XX_SYS_NIRQ,
 434                 .platform_data = &sdp3430_twldata,
 435         },
 436 };
 437
 438 static int __init omap3430_i2c_init(void)
 439 {
 440         /* i2c1 for PMIC only */
 441         omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
 442                         ARRAY_SIZE(sdp3430_i2c_boardinfo));
 443         /* i2c2 on camera connector (for sensor control) and optional isp1301 */
 444         omap_register_i2c_bus(2, 400, NULL, 0);
 445         /* i2c3 on display connector (for DVI, tfp410) */
 446         omap_register_i2c_bus(3, 400, NULL, 0);
 447         return 0;
 448 }
 449
 450 #if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE)
 451
 452 static struct omap_smc91x_platform_data board_smc91x_data = {
 453         .cs             = 3,
 454         .flags          = GPMC_MUX_ADD_DATA | GPMC_TIMINGS_SMC91C96 |
 455                                 IORESOURCE_IRQ_LOWLEVEL,
 456 };
 457
 458 static void __init board_smc91x_init(void)
 459 {
 460         if (omap_rev() > OMAP3430_REV_ES1_0)
 461                 board_smc91x_data.gpio_irq = 6;
 462         else
 463                 board_smc91x_data.gpio_irq = 29;
 464
 465         gpmc_smc91x_init(&board_smc91x_data);
 466 }
 467
 468 #else
 469
 470 static inline void board_smc91x_init(void)
 471 {
 472 }
 473
 474 #endif
 475
 476 static void enable_board_wakeup_source(void)
 477 {
 478         omap_cfg_reg(AF26_34XX_SYS_NIRQ); /* T2 interrupt line (keypad) */
 479 }
 480
 481 static void __init omap_3430sdp_init(void)
 482 {
 483         omap3430_i2c_init();
 484         platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
 485         omap_board_config = sdp3430_config;
 486         omap_board_config_size = ARRAY_SIZE(sdp3430_config);
 487         if (omap_rev() > OMAP3430_REV_ES1_0)
 488                 ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV2;
 489         else
 490                 ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV1;
 491         sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
 492         spi_register_board_info(sdp3430_spi_board_info,
 493                                 ARRAY_SIZE(sdp3430_spi_board_info));
 494         ads7846_dev_init();
 495         omap_serial_init();
 496         usb_musb_init();
 497         board_smc91x_init();
 498         enable_board_wakeup_source();
 499 }
 500
 501 static void __init omap_3430sdp_map_io(void)
 502 {
 503         omap2_set_globals_343x();
 504         omap2_map_common_io();
 505 }
 506
 507 MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
 508         /* Maintainer: Syed Khasim - Texas Instruments Inc */
 509         .phys_io        = 0x48000000,
 510         .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
 511         .boot_params    = 0x80000100,
 512         .map_io         = omap_3430sdp_map_io,
 513         .init_irq       = omap_3430sdp_init_irq,
 514         .init_machine   = omap_3430sdp_init,
 515         .timer          = &omap_timer,
 516 MACHINE_END