arch/arm/mach-omap2/board-ldp.c

   1 /*
   2  * linux/arch/arm/mach-omap2/board-ldp.c
   3  *
   4  * Copyright (C) 2008 Texas Instruments Inc.
   5  * Nishant Kamat <nskamat@ti.com>
   6  *
   7  * Modified from mach-omap2/board-3430sdp.c
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/delay.h>
  18 #include <linux/input.h>
  19 #include <linux/workqueue.h>
  20 #include <linux/err.h>
  21 #include <linux/clk.h>
  22 #include <linux/spi/spi.h>
  23 #include <linux/spi/ads7846.h>
  24 #include <linux/i2c/twl4030.h>
  25
  26 #include <mach/hardware.h>
  27 #include <asm/mach-types.h>
  28 #include <asm/mach/arch.h>
  29 #include <asm/mach/map.h>
  30
  31 #include <mach/board-ldp.h>
  32 #include <mach/mcspi.h>
  33 #include <mach/gpio.h>
  34 #include <mach/board.h>
  35 #include <mach/common.h>
  36 #include <mach/gpmc.h>
  37 #include <mach/mmc.h>
  38 #include <mach/usb-musb.h>
  39
  40 #include <asm/io.h>
  41 #include <asm/delay.h>
  42 #include <mach/control.h>
  43
  44 #include "mmc-twl4030.h"
  45
  46
  47 #define SDP3430_SMC91X_CS       3
  48 #define CONFIG_DISABLE_HFCLK 1
  49
  50 #define ENABLE_VAUX1_DEDICATED  0x03
  51 #define ENABLE_VAUX1_DEV_GRP    0x20
  52
  53 #define TWL4030_MSECURE_GPIO    22
  54
  55 static struct resource ldp_smc911x_resources[] = {
  56         [0] = {
  57                 .start  = OMAP34XX_ETHR_START,
  58                 .end    = OMAP34XX_ETHR_START + SZ_4K,
  59                 .flags  = IORESOURCE_MEM,
  60         },
  61         [1] = {
  62                 .start  = 0,
  63                 .end    = 0,
  64                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
  65         },
  66 };
  67
  68 static struct platform_device ldp_smc911x_device = {
  69         .name           = "smc911x",
  70         .id             = -1,
  71         .num_resources  = ARRAY_SIZE(ldp_smc911x_resources),
  72         .resource       = ldp_smc911x_resources,
  73 };
  74
  75 static int ts_gpio;
  76
  77 static int __init msecure_init(void)
  78 {
  79         int ret = 0;
  80
  81 #ifdef CONFIG_RTC_DRV_TWL4030
  82         /* 3430ES2.0 doesn't have msecure/gpio-22 line connected to T2 */
  83         if (omap_type() == OMAP2_DEVICE_TYPE_GP &&
  84                         omap_rev() < OMAP3430_REV_ES2_0) {
  85                 void __iomem *msecure_pad_config_reg =
  86                         omap_ctrl_base_get() + 0xA3C;
  87                 int mux_mask = 0x04;
  88                 u16 tmp;
  89
  90                 ret = gpio_request(TWL4030_MSECURE_GPIO, "msecure");
  91                 if (ret < 0) {
  92                         printk(KERN_ERR "msecure_init: can't"
  93                                 "reserve GPIO:%d !\n", TWL4030_MSECURE_GPIO);
  94                         goto out;
  95                 }
  96                 /*
  97                  * TWL4030 will be in secure mode if msecure line from OMAP
  98                  * is low. Make msecure line high in order to change the
  99                  * TWL4030 RTC time and calender registers.
 100                  */
 101
 102                 tmp = __raw_readw(msecure_pad_config_reg);
 103                 tmp &= 0xF8;    /* To enable mux mode 03/04 = GPIO_RTC */
 104                 tmp |= mux_mask;/* To enable mux mode 03/04 = GPIO_RTC */
 105                 __raw_writew(tmp, msecure_pad_config_reg);
 106
 107                 gpio_direction_output(TWL4030_MSECURE_GPIO, 1);
 108         }
 109 out:
 110 #endif
 111         return ret;
 112 }
 113
 114 /**
 115  * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
 116  *
 117  * @return - void. If request gpio fails then Flag KERN_ERR.
 118  */
 119 static void ads7846_dev_init(void)
 120 {
 121         if (omap_request_gpio(ts_gpio) < 0) {
 122                 printk(KERN_ERR "can't get ads746 pen down GPIO\n");
 123                 return;
 124         }
 125
 126         gpio_direction_input(ts_gpio);
 127
 128         omap_set_gpio_debounce(ts_gpio, 1);
 129         omap_set_gpio_debounce_time(ts_gpio, 0xa);
 130 }
 131
 132 static int ads7846_get_pendown_state(void)
 133 {
 134         return !gpio_get_value(ts_gpio);
 135 }
 136
 137 /*
 138  * This enable(1)/disable(0) the voltage for TS: uses twl4030 calls
 139  */
 140 static int ads7846_vaux_control(int vaux_cntrl)
 141 {
 142         int ret = 0;
 143
 144 #ifdef CONFIG_TWL4030_CORE
 145         /* check for return value of ldo_use: if success it returns 0 */
 146         if (vaux_cntrl == VAUX_ENABLE) {
 147                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 148                         ENABLE_VAUX1_DEDICATED, TWL4030_VAUX1_DEDICATED))
 149                         return -EIO;
 150                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 151                         ENABLE_VAUX1_DEV_GRP, TWL4030_VAUX1_DEV_GRP))
 152                         return -EIO;
 153         } else if (vaux_cntrl == VAUX_DISABLE) {
 154                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 155                         0x00, TWL4030_VAUX1_DEDICATED))
 156                         return -EIO;
 157                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 158                         0x00, TWL4030_VAUX1_DEV_GRP))
 159                         return -EIO;
 160         }
 161 #else
 162         ret = -EIO;
 163 #endif
 164         return ret;
 165 }
 166
 167 static struct ads7846_platform_data tsc2046_config __initdata = {
 168         .get_pendown_state      = ads7846_get_pendown_state,
 169         .keep_vref_on           = 1,
 170         .vaux_control           = ads7846_vaux_control,
 171 };
 172
 173
 174 static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
 175         .turbo_mode     = 0,
 176         .single_channel = 1,    /* 0: slave, 1: master */
 177 };
 178
 179 static struct spi_board_info ldp_spi_board_info[] __initdata = {
 180         [0] = {
 181                 /*
 182                  * TSC2046 operates at a max freqency of 2MHz, so
 183                  * operate slightly below at 1.5MHz
 184                  */
 185                 .modalias               = "ads7846",
 186                 .bus_num                = 1,
 187                 .chip_select            = 0,
 188                 .max_speed_hz           = 1500000,
 189                 .controller_data        = &tsc2046_mcspi_config,
 190                 .irq                    = 0,
 191                 .platform_data          = &tsc2046_config,
 192         },
 193 };
 194
 195 static struct platform_device ldp_lcd_device = {
 196         .name           = "ldp_lcd",
 197         .id             = -1,
 198 };
 199
 200 static struct platform_device *ldp_devices[] __initdata = {
 201         &ldp_smc911x_device,
 202         &ldp_lcd_device,
 203 };
 204
 205 static inline void __init ldp_init_smc911x(void)
 206 {
 207         int eth_cs;
 208         unsigned long cs_mem_base;
 209         int eth_gpio = 0;
 210
 211         eth_cs = LDP_SMC911X_CS;
 212
 213         if (gpmc_cs_request(eth_cs, SZ_16M, &cs_mem_base) < 0) {
 214                 printk(KERN_ERR "Failed to request GPMC mem for smc911x\n");
 215                 return;
 216         }
 217
 218         ldp_smc911x_resources[0].start = cs_mem_base + 0x0;
 219         ldp_smc911x_resources[0].end   = cs_mem_base + 0xf;
 220         udelay(100);
 221
 222         eth_gpio = LDP_SMC911X_GPIO;
 223
 224         ldp_smc911x_resources[1].start = OMAP_GPIO_IRQ(eth_gpio);
 225
 226         if (omap_request_gpio(eth_gpio) < 0) {
 227                 printk(KERN_ERR "Failed to request GPIO%d for smc911x IRQ\n",
 228                                 eth_gpio);
 229                 return;
 230         }
 231         omap_set_gpio_direction(eth_gpio, 1);
 232 }
 233
 234
 235 static void __init omap_ldp_init_irq(void)
 236 {
 237         omap2_init_common_hw(NULL);
 238         omap_init_irq();
 239         omap_gpio_init();
 240         ldp_init_smc911x();
 241 }
 242
 243 static struct omap_uart_config ldp_uart_config __initdata = {
 244         .enabled_uarts  = ((1 << 0) | (1 << 1) | (1 << 2)),
 245 };
 246
 247 static struct omap_lcd_config ldp_lcd_config __initdata = {
 248         .ctrl_name      = "internal",
 249 };
 250
 251 static struct omap_board_config_kernel ldp_config[] __initdata = {
 252         { OMAP_TAG_UART,        &ldp_uart_config },
 253         { OMAP_TAG_LCD,         &ldp_lcd_config },
 254 };
 255
 256 static int ldp_batt_table[] = {
 257 /* 0 C*/
 258 30800, 29500, 28300, 27100,
 259 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 260 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 261 11600, 11200, 10800, 10400, 10000, 9630,   9280,   8950,   8620,   8310,
 262 8020,   7730,   7460,   7200,   6950,   6710,   6470,   6250,   6040,   5830,
 263 5640,   5450,   5260,   5090,   4920,   4760,   4600,   4450,   4310,   4170,
 264 4040,   3910,   3790,   3670,   3550
 265 };
 266
 267 static struct twl4030_ins __initdata sleep_on_seq[] = {
 268 /*
 269  * Turn off VDD1 and VDD2.
 270  */
 271         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_OFF), 4},
 272         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_OFF), 2},
 273 #ifdef CONFIG_DISABLE_HFCLK
 274 /*
 275  * And also turn off the OMAP3 PLLs and the sysclk output.
 276  */
 277         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_OFF), 3},
 278         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_OFF), 3},
 279 #endif
 280 };
 281
 282 static struct twl4030_script sleep_on_script __initdata = {
 283         .script = sleep_on_seq,
 284         .size   = ARRAY_SIZE(sleep_on_seq),
 285         .flags  = TRITON_SLEEP_SCRIPT,
 286 };
 287
 288 static struct twl4030_ins wakeup_seq[] __initdata = {
 289 #ifndef CONFIG_DISABLE_HFCLK
 290 /*
 291  * Wakeup VDD1 and VDD2.
 292  */
 293         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_ACTIVE), 4},
 294         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_ACTIVE), 2},
 295 #else
 296 /*
 297  * Reenable the OMAP3 PLLs.
 298  * Wakeup VDD1 and VDD2.
 299  * Reenable sysclk output.
 300  */
 301         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_ACTIVE), 0x30},
 302         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_ACTIVE), 0x30},
 303         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_ACTIVE), 0x37},
 304         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_ACTIVE), 3},
 305 #endif /* #ifndef CONFIG_DISABLE_HFCLK */
 306 };
 307
 308 static struct twl4030_script wakeup_script __initdata = {
 309         .script = wakeup_seq,
 310         .size   = ARRAY_SIZE(wakeup_seq),
 311         .flags  = TRITON_WAKEUP12_SCRIPT | TRITON_WAKEUP3_SCRIPT,
 312 };
 313
 314 static struct twl4030_ins wrst_seq[] __initdata = {
 315 /*
 316  * Reset twl4030.
 317  * Reset VDD1 regulator.
 318  * Reset VDD2 regulator.
 319  * Reset VPLL1 regulator.
 320  * Enable sysclk output.
 321  * Reenable twl4030.
 322  */
 323         {MSG_SINGULAR(DEV_GRP_NULL, 0x1b, RES_STATE_OFF), 2},
 324         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_WRST), 15},
 325         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_WRST), 15},
 326         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_WRST), 0x60},
 327         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_ACTIVE), 2},
 328         {MSG_SINGULAR(DEV_GRP_NULL, 0x1b, RES_STATE_ACTIVE), 2},
 329 };
 330
 331 static struct twl4030_script wrst_script __initdata = {
 332         .script = wrst_seq,
 333         .size   = ARRAY_SIZE(wakeup_seq),
 334         .flags  = TRITON_WRST_SCRIPT,
 335 };
 336
 337 static struct twl4030_script *twl4030_scripts[] __initdata = {
 338         &sleep_on_script,
 339         &wakeup_script,
 340         &wrst_script,
 341 };
 342
 343 static struct twl4030_power_data sdp3430_t2scripts_data __initdata = {
 344         .scripts        = twl4030_scripts,
 345         .size           = ARRAY_SIZE(twl4030_scripts),
 346 };
 347
 348 static struct twl4030_bci_platform_data ldp_bci_data = {
 349         .battery_tmp_tbl        = ldp_batt_table,
 350         .tblsize                = ARRAY_SIZE(ldp_batt_table),
 351 };
 352
 353 static struct twl4030_usb_data ldp_usb_data = {
 354         .usb_mode       = T2_USB_MODE_ULPI,
 355 };
 356
 357 static struct twl4030_gpio_platform_data ldp_gpio_data = {
 358         .gpio_base      = OMAP_MAX_GPIO_LINES,
 359         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 360         .irq_end        = TWL4030_GPIO_IRQ_END,
 361 };
 362
 363 static struct twl4030_madc_platform_data ldp_madc_data = {
 364         .irq_line       = 1,
 365 };
 366
 367 static struct twl4030_platform_data ldp_twldata = {
 368         .irq_base       = TWL4030_IRQ_BASE,
 369         .irq_end        = TWL4030_IRQ_END,
 370
 371         /* platform_data for children goes here */
 372         .bci            = &ldp_bci_data,
 373         .madc           = &ldp_madc_data,
 374         .usb            = &ldp_usb_data,
 375         .power          = &sdp3430_t2scripts_data,
 376         .gpio           = &ldp_gpio_data,
 377 };
 378
 379 static struct i2c_board_info __initdata ldp_i2c_boardinfo[] = {
 380         {
 381                 I2C_BOARD_INFO("twl4030", 0x48),
 382                 .flags = I2C_CLIENT_WAKE,
 383                 .irq = INT_34XX_SYS_NIRQ,
 384                 .platform_data = &ldp_twldata,
 385         },
 386 };
 387
 388 static int __init omap_i2c_init(void)
 389 {
 390         omap_register_i2c_bus(1, 2600, ldp_i2c_boardinfo,
 391                         ARRAY_SIZE(ldp_i2c_boardinfo));
 392         omap_register_i2c_bus(2, 400, NULL, 0);
 393         omap_register_i2c_bus(3, 400, NULL, 0);
 394         return 0;
 395 }
 396
 397 static struct twl4030_hsmmc_info mmc[] __initdata = {
 398         {
 399                 .mmc            = 1,
 400                 .wires          = 4,
 401                 .gpio_cd        = -EINVAL,
 402                 .gpio_wp        = -EINVAL,
 403         },
 404         {}      /* Terminator */
 405 };
 406
 407 static void __init omap_ldp_init(void)
 408 {
 409         omap_i2c_init();
 410         platform_add_devices(ldp_devices, ARRAY_SIZE(ldp_devices));
 411         omap_board_config = ldp_config;
 412         omap_board_config_size = ARRAY_SIZE(ldp_config);
 413         ts_gpio = 54;
 414         ldp_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
 415         spi_register_board_info(ldp_spi_board_info,
 416                                 ARRAY_SIZE(ldp_spi_board_info));
 417         msecure_init();
 418         ads7846_dev_init();
 419         omap_serial_init();
 420         usb_musb_init();
 421         hsmmc_init(mmc);
 422 }
 423
 424 static void __init omap_ldp_map_io(void)
 425 {
 426         omap2_set_globals_343x();
 427         omap2_map_common_io();
 428 }
 429
 430 MACHINE_START(OMAP_LDP, "OMAP LDP board")
 431         .phys_io        = 0x48000000,
 432         .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
 433         .boot_params    = 0x80000100,
 434         .map_io         = omap_ldp_map_io,
 435         .init_irq       = omap_ldp_init_irq,
 436         .init_machine   = omap_ldp_init,
 437         .timer          = &omap_timer,
 438 MACHINE_END