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/workqueue.h>
  21 #include <linux/err.h>
  22 #include <linux/clk.h>
  23 #include <linux/spi/spi.h>
  24 #include <linux/spi/ads7846.h>
  25 #include <linux/i2c/twl4030.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/gpio.h>
  34 #include <mach/mux.h>
  35 #include <mach/board.h>
  36 #include <mach/usb-musb.h>
  37 #include <mach/usb-ehci.h>
  38 #include <mach/common.h>
  39 #include <mach/dma.h>
  40 #include <mach/gpmc.h>
  41
  42 #include <asm/io.h>
  43 #include <asm/delay.h>
  44 #include <mach/control.h>
  45
  46 #include "sdram-qimonda-hyb18m512160af-6.h"
  47 #include "mmc-twl4030.h"
  48
  49 #define CONFIG_DISABLE_HFCLK 1
  50
  51 #define SDP3430_SMC91X_CS       3
  52
  53 #define ENABLE_VAUX3_DEDICATED  0x03
  54 #define ENABLE_VAUX3_DEV_GRP    0x20
  55
  56
  57 #define TWL4030_MSECURE_GPIO 22
  58
  59 static struct resource sdp3430_smc91x_resources[] = {
  60         [0] = {
  61                 .start  = OMAP34XX_ETHR_START,
  62                 .end    = OMAP34XX_ETHR_START + SZ_4K,
  63                 .flags  = IORESOURCE_MEM,
  64         },
  65         [1] = {
  66                 .start  = 0,
  67                 .end    = 0,
  68                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
  69         },
  70 };
  71
  72 static struct platform_device sdp3430_smc91x_device = {
  73         .name           = "smc91x",
  74         .id             = -1,
  75         .num_resources  = ARRAY_SIZE(sdp3430_smc91x_resources),
  76         .resource       = sdp3430_smc91x_resources,
  77 };
  78
  79 static int sdp3430_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 twl4030_keypad_data sdp3430_kp_data = {
 114         .rows           = 5,
 115         .cols           = 6,
 116         .keymap         = sdp3430_keymap,
 117         .keymapsize     = ARRAY_SIZE(sdp3430_keymap),
 118         .rep            = 1,
 119 };
 120
 121 static int ts_gpio;
 122
 123 static int __init msecure_init(void)
 124 {
 125         int ret = 0;
 126
 127 #ifdef CONFIG_RTC_DRV_TWL4030
 128         /* 3430ES2.0 doesn't have msecure/gpio-22 line connected to T2 */
 129         if (omap_type() == OMAP2_DEVICE_TYPE_GP &&
 130                         omap_rev() < OMAP3430_REV_ES2_0) {
 131                 void __iomem *msecure_pad_config_reg = omap_ctrl_base_get() +
 132                         0xA3C;
 133                 int mux_mask = 0x04;
 134                 u16 tmp;
 135
 136                 ret = gpio_request(TWL4030_MSECURE_GPIO, "msecure");
 137                 if (ret < 0) {
 138                         printk(KERN_ERR "msecure_init: can't"
 139                                 "reserve GPIO:%d !\n", TWL4030_MSECURE_GPIO);
 140                         goto out;
 141                 }
 142                 /*
 143                  * TWL4030 will be in secure mode if msecure line from OMAP
 144                  * is low. Make msecure line high in order to change the
 145                  * TWL4030 RTC time and calender registers.
 146                  */
 147                 tmp = __raw_readw(msecure_pad_config_reg);
 148                 tmp &= 0xF8; /* To enable mux mode 03/04 = GPIO_RTC */
 149                 tmp |= mux_mask;/* To enable mux mode 03/04 = GPIO_RTC */
 150                 __raw_writew(tmp, msecure_pad_config_reg);
 151
 152                 gpio_direction_output(TWL4030_MSECURE_GPIO, 1);
 153         }
 154 out:
 155 #endif
 156         return ret;
 157 }
 158
 159 /**
 160  * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
 161  *
 162  * @return - void. If request gpio fails then Flag KERN_ERR.
 163  */
 164 static void ads7846_dev_init(void)
 165 {
 166         if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
 167                 printk(KERN_ERR "can't get ads746 pen down GPIO\n");
 168                 return;
 169         }
 170
 171         gpio_direction_input(ts_gpio);
 172
 173         omap_set_gpio_debounce(ts_gpio, 1);
 174         omap_set_gpio_debounce_time(ts_gpio, 0xa);
 175 }
 176
 177 static int ads7846_get_pendown_state(void)
 178 {
 179         return !gpio_get_value(ts_gpio);
 180 }
 181
 182 /*
 183  * This enable(1)/disable(0) the voltage for TS: uses twl4030 calls
 184  */
 185 static int ads7846_vaux_control(int vaux_cntrl)
 186 {
 187         int ret = 0;
 188
 189 #ifdef CONFIG_TWL4030_CORE
 190         /* check for return value of ldo_use: if success it returns 0 */
 191         if (vaux_cntrl == VAUX_ENABLE) {
 192                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 193                         ENABLE_VAUX3_DEDICATED, TWL4030_VAUX3_DEDICATED))
 194                         return -EIO;
 195                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 196                         ENABLE_VAUX3_DEV_GRP, TWL4030_VAUX3_DEV_GRP))
 197                         return -EIO;
 198         } else if (vaux_cntrl == VAUX_DISABLE) {
 199                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 200                         0x00, TWL4030_VAUX3_DEDICATED))
 201                         return -EIO;
 202                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 203                         0x00, TWL4030_VAUX3_DEV_GRP))
 204                         return -EIO;
 205         }
 206 #else
 207         ret = -EIO;
 208 #endif
 209         return ret;
 210 }
 211
 212 static struct ads7846_platform_data tsc2046_config __initdata = {
 213         .get_pendown_state      = ads7846_get_pendown_state,
 214         .keep_vref_on           = 1,
 215         .vaux_control           = ads7846_vaux_control,
 216 };
 217
 218
 219 static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
 220         .turbo_mode     = 0,
 221         .single_channel = 1,  /* 0: slave, 1: master */
 222 };
 223
 224 static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
 225         [0] = {
 226                 /*
 227                  * TSC2046 operates at a max freqency of 2MHz, so
 228                  * operate slightly below at 1.5MHz
 229                  */
 230                 .modalias               = "ads7846",
 231                 .bus_num                = 1,
 232                 .chip_select            = 0,
 233                 .max_speed_hz           = 1500000,
 234                 .controller_data        = &tsc2046_mcspi_config,
 235                 .irq                    = 0,
 236                 .platform_data          = &tsc2046_config,
 237         },
 238 };
 239
 240 static struct platform_device sdp3430_lcd_device = {
 241         .name           = "sdp2430_lcd",
 242         .id             = -1,
 243 };
 244
 245 static struct platform_device *sdp3430_devices[] __initdata = {
 246         &sdp3430_smc91x_device,
 247         &sdp3430_lcd_device,
 248 };
 249
 250 static inline void __init sdp3430_init_smc91x(void)
 251 {
 252         int eth_cs;
 253         unsigned long cs_mem_base;
 254         int eth_gpio = 0;
 255
 256         eth_cs = SDP3430_SMC91X_CS;
 257
 258         if (gpmc_cs_request(eth_cs, SZ_16M, &cs_mem_base) < 0) {
 259                 printk(KERN_ERR "Failed to request GPMC mem for smc91x\n");
 260                 return;
 261         }
 262
 263         sdp3430_smc91x_resources[0].start = cs_mem_base + 0x0;
 264         sdp3430_smc91x_resources[0].end   = cs_mem_base + 0xf;
 265         udelay(100);
 266
 267         if (omap_rev() > OMAP3430_REV_ES1_0)
 268                 eth_gpio = OMAP34XX_ETHR_GPIO_IRQ_SDPV2;
 269         else
 270                 eth_gpio = OMAP34XX_ETHR_GPIO_IRQ_SDPV1;
 271
 272         sdp3430_smc91x_resources[1].start = gpio_to_irq(eth_gpio);
 273
 274         if (gpio_request(eth_gpio, "SMC91x irq") < 0) {
 275                 printk(KERN_ERR "Failed to request GPIO%d for smc91x IRQ\n",
 276                         eth_gpio);
 277                 return;
 278         }
 279         gpio_direction_input(eth_gpio);
 280 }
 281
 282 static void __init omap_3430sdp_init_irq(void)
 283 {
 284         omap2_init_common_hw(hyb18m512160af6_sdrc_params);
 285         omap_init_irq();
 286         omap_gpio_init();
 287         sdp3430_init_smc91x();
 288 }
 289
 290 static struct omap_uart_config sdp3430_uart_config __initdata = {
 291         .enabled_uarts  = ((1 << 0) | (1 << 1) | (1 << 2)),
 292 };
 293
 294 static struct omap_lcd_config sdp3430_lcd_config __initdata = {
 295         .ctrl_name      = "internal",
 296 };
 297
 298 static struct omap_board_config_kernel sdp3430_config[] __initdata = {
 299         { OMAP_TAG_UART,        &sdp3430_uart_config },
 300         { OMAP_TAG_LCD,         &sdp3430_lcd_config },
 301 };
 302
 303 static int sdp3430_batt_table[] = {
 304 /* 0 C*/
 305 30800, 29500, 28300, 27100,
 306 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 307 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 308 11600, 11200, 10800, 10400, 10000, 9630,   9280,   8950,   8620,   8310,
 309 8020,   7730,   7460,   7200,   6950,   6710,   6470,   6250,   6040,   5830,
 310 5640,   5450,   5260,   5090,   4920,   4760,   4600,   4450,   4310,   4170,
 311 4040,   3910,   3790,   3670,   3550
 312 };
 313
 314 static struct twl4030_bci_platform_data sdp3430_bci_data = {
 315       .battery_tmp_tbl  = sdp3430_batt_table,
 316       .tblsize          = ARRAY_SIZE(sdp3430_batt_table),
 317 };
 318
 319 static struct twl4030_gpio_platform_data sdp3430_gpio_data = {
 320         .gpio_base      = OMAP_MAX_GPIO_LINES,
 321         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 322         .irq_end        = TWL4030_GPIO_IRQ_END,
 323 };
 324
 325 static struct twl4030_usb_data sdp3430_usb_data = {
 326         .usb_mode       = T2_USB_MODE_ULPI,
 327 };
 328
 329 static struct twl4030_madc_platform_data sdp3430_madc_data = {
 330         .irq_line       = 1,
 331 };
 332
 333
 334 static struct twl4030_ins __initdata sleep_on_seq[] = {
 335 /*
 336  * Turn off VDD1 and VDD2.
 337  */
 338         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_OFF), 4},
 339         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_OFF), 2},
 340 #ifdef CONFIG_DISABLE_HFCLK
 341 /*
 342  * And also turn off the OMAP3 PLLs and the sysclk output.
 343  */
 344         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_OFF), 3},
 345         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_OFF), 3},
 346 #endif
 347 };
 348
 349 static struct twl4030_script sleep_on_script __initdata = {
 350         .script = sleep_on_seq,
 351         .size   = ARRAY_SIZE(sleep_on_seq),
 352         .flags  = TRITON_SLEEP_SCRIPT,
 353 };
 354
 355 static struct twl4030_ins wakeup_seq[] __initdata = {
 356 #ifndef CONFIG_DISABLE_HFCLK
 357 /*
 358  * Wakeup VDD1 and VDD2.
 359  */
 360         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_ACTIVE), 4},
 361         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_ACTIVE), 2},
 362 #else
 363 /*
 364  * Reenable the OMAP3 PLLs.
 365  * Wakeup VDD1 and VDD2.
 366  * Reenable sysclk output.
 367  */
 368         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_ACTIVE), 0x30},
 369         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_ACTIVE), 0x30},
 370         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_ACTIVE), 0x37},
 371         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_ACTIVE), 3},
 372 #endif /* #ifndef CONFIG_DISABLE_HFCLK */
 373 };
 374
 375 static struct twl4030_script wakeup_script __initdata = {
 376         .script = wakeup_seq,
 377         .size   = ARRAY_SIZE(wakeup_seq),
 378         .flags  = TRITON_WAKEUP12_SCRIPT | TRITON_WAKEUP3_SCRIPT,
 379 };
 380
 381 static struct twl4030_ins wrst_seq[] __initdata = {
 382 /*
 383  * Reset twl4030.
 384  * Reset VDD1 regulator.
 385  * Reset VDD2 regulator.
 386  * Reset VPLL1 regulator.
 387  * Enable sysclk output.
 388  * Reenable twl4030.
 389  */
 390         {MSG_SINGULAR(DEV_GRP_NULL, 0x1b, RES_STATE_OFF), 2},
 391         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_WRST), 15},
 392         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_WRST), 15},
 393         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_WRST), 0x60},
 394         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_ACTIVE), 2},
 395         {MSG_SINGULAR(DEV_GRP_NULL, 0x1b, RES_STATE_ACTIVE), 2},
 396 };
 397 static struct twl4030_script wrst_script __initdata = {
 398         .script = wrst_seq,
 399         .size   = ARRAY_SIZE(wakeup_seq),
 400         .flags  = TRITON_WRST_SCRIPT,
 401 };
 402
 403 static struct twl4030_script *twl4030_scripts[] __initdata = {
 404         &sleep_on_script,
 405         &wakeup_script,
 406         &wrst_script,
 407 };
 408
 409 static struct twl4030_power_data sdp3430_t2scripts_data __initdata = {
 410         .scripts        = twl4030_scripts,
 411         .size           = ARRAY_SIZE(twl4030_scripts),
 412 };
 413
 414 static struct twl4030_platform_data sdp3430_twldata = {
 415         .irq_base       = TWL4030_IRQ_BASE,
 416         .irq_end        = TWL4030_IRQ_END,
 417
 418         /* platform_data for children goes here */
 419         .bci            = &sdp3430_bci_data,
 420         .gpio           = &sdp3430_gpio_data,
 421         .madc           = &sdp3430_madc_data,
 422         .keypad         = &sdp3430_kp_data,
 423         .power          = &sdp3430_t2scripts_data,
 424         .usb            = &sdp3430_usb_data,
 425 };
 426
 427 static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
 428         {
 429                 I2C_BOARD_INFO("twl4030", 0x48),
 430                 .flags = I2C_CLIENT_WAKE,
 431                 .irq = INT_34XX_SYS_NIRQ,
 432                 .platform_data = &sdp3430_twldata,
 433         },
 434 };
 435
 436 static int __init omap3430_i2c_init(void)
 437 {
 438         omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
 439                         ARRAY_SIZE(sdp3430_i2c_boardinfo));
 440         omap_register_i2c_bus(2, 400, NULL, 0);
 441         omap_register_i2c_bus(3, 400, NULL, 0);
 442         return 0;
 443 }
 444
 445 static struct twl4030_hsmmc_info mmc[] __initdata = {
 446         {
 447                 .mmc            = 1,
 448                 .wires          = 8,
 449                 .gpio_cd        = -EINVAL,
 450                 .gpio_wp        = -EINVAL,
 451         },
 452         {
 453                 .mmc            = 2,
 454                 .wires          = 8,
 455                 .gpio_cd        = -EINVAL,
 456                 .gpio_wp        = -EINVAL,
 457         },
 458         {}      /* Terminator */
 459 };
 460
 461 extern void __init sdp3430_flash_init(void);
 462
 463 static void __init omap_3430sdp_init(void)
 464 {
 465         omap3430_i2c_init();
 466         platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
 467         omap_board_config = sdp3430_config;
 468         omap_board_config_size = ARRAY_SIZE(sdp3430_config);
 469         if (omap_rev() > OMAP3430_REV_ES1_0)
 470                 ts_gpio = OMAP34XX_TS_GPIO_IRQ_SDPV2;
 471         else
 472                 ts_gpio = OMAP34XX_TS_GPIO_IRQ_SDPV1;
 473         sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
 474         spi_register_board_info(sdp3430_spi_board_info,
 475                                 ARRAY_SIZE(sdp3430_spi_board_info));
 476         ads7846_dev_init();
 477         sdp3430_flash_init();
 478         msecure_init();
 479         omap_serial_init();
 480         usb_musb_init();
 481         usb_ehci_init();
 482         twl4030_mmc_init(mmc);
 483 }
 484
 485 static void __init omap_3430sdp_map_io(void)
 486 {
 487         omap2_set_globals_343x();
 488         omap2_map_common_io();
 489 }
 490
 491 MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
 492         /* Maintainer: Syed Khasim - Texas Instruments Inc */
 493         .phys_io        = 0x48000000,
 494         .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
 495         .boot_params    = 0x80000100,
 496         .map_io         = omap_3430sdp_map_io,
 497         .init_irq       = omap_3430sdp_init_irq,
 498         .init_machine   = omap_3430sdp_init,
 499         .timer          = &omap_timer,
 500 MACHINE_END