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