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 #define CONFIG_DISABLE_HFCLK 1
  45
  46 #define ENABLE_VAUX1_DEDICATED  0x03
  47 #define ENABLE_VAUX1_DEV_GRP    0x20
  48
  49 #define TWL4030_MSECURE_GPIO    22
  50
  51 static int ts_gpio;
  52
  53 static int __init msecure_init(void)
  54 {
  55         int ret = 0;
  56
  57 #ifdef CONFIG_RTC_DRV_TWL4030
  58         /* 3430ES2.0 doesn't have msecure/gpio-22 line connected to T2 */
  59         if (omap_type() == OMAP2_DEVICE_TYPE_GP &&
  60                         omap_rev() < OMAP3430_REV_ES2_0) {
  61                 void __iomem *msecure_pad_config_reg =
  62                         omap_ctrl_base_get() + 0xA3C;
  63                 int mux_mask = 0x04;
  64                 u16 tmp;
  65
  66                 ret = gpio_request(TWL4030_MSECURE_GPIO, "msecure");
  67                 if (ret < 0) {
  68                         printk(KERN_ERR "msecure_init: can't"
  69                                 "reserve GPIO:%d !\n", TWL4030_MSECURE_GPIO);
  70                         goto out;
  71                 }
  72                 /*
  73                  * TWL4030 will be in secure mode if msecure line from OMAP
  74                  * is low. Make msecure line high in order to change the
  75                  * TWL4030 RTC time and calender registers.
  76                  */
  77
  78                 tmp = __raw_readw(msecure_pad_config_reg);
  79                 tmp &= 0xF8;    /* To enable mux mode 03/04 = GPIO_RTC */
  80                 tmp |= mux_mask;/* To enable mux mode 03/04 = GPIO_RTC */
  81                 __raw_writew(tmp, msecure_pad_config_reg);
  82
  83                 gpio_direction_output(TWL4030_MSECURE_GPIO, 1);
  84         }
  85 out:
  86 #endif
  87         return ret;
  88 }
  89
  90 /**
  91  * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
  92  *
  93  * @return - void. If request gpio fails then Flag KERN_ERR.
  94  */
  95 static void ads7846_dev_init(void)
  96 {
  97         if (omap_request_gpio(ts_gpio) < 0) {
  98                 printk(KERN_ERR "can't get ads746 pen down GPIO\n");
  99                 return;
 100         }
 101
 102         omap_set_gpio_direction(ts_gpio, 1);
 103
 104         omap_set_gpio_debounce(ts_gpio, 1);
 105         omap_set_gpio_debounce_time(ts_gpio, 0xa);
 106 }
 107
 108 static int ads7846_get_pendown_state(void)
 109 {
 110         return !omap_get_gpio_datain(ts_gpio);
 111 }
 112
 113 /*
 114  * This enable(1)/disable(0) the voltage for TS: uses twl4030 calls
 115  */
 116 static int ads7846_vaux_control(int vaux_cntrl)
 117 {
 118         int ret = 0;
 119
 120 #ifdef CONFIG_TWL4030_CORE
 121         /* check for return value of ldo_use: if success it returns 0 */
 122         if (vaux_cntrl == VAUX_ENABLE) {
 123                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 124                         ENABLE_VAUX1_DEDICATED, TWL4030_VAUX1_DEDICATED))
 125                         return -EIO;
 126                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 127                         ENABLE_VAUX1_DEV_GRP, TWL4030_VAUX1_DEV_GRP))
 128                         return -EIO;
 129         } else if (vaux_cntrl == VAUX_DISABLE) {
 130                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 131                         0x00, TWL4030_VAUX1_DEDICATED))
 132                         return -EIO;
 133                 if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
 134                         0x00, TWL4030_VAUX1_DEV_GRP))
 135                         return -EIO;
 136         }
 137 #else
 138         ret = -EIO;
 139 #endif
 140         return ret;
 141 }
 142
 143 static struct ads7846_platform_data tsc2046_config __initdata = {
 144         .get_pendown_state      = ads7846_get_pendown_state,
 145         .keep_vref_on           = 1,
 146         .vaux_control           = ads7846_vaux_control,
 147 };
 148
 149
 150 static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
 151         .turbo_mode     = 0,
 152         .single_channel = 1,    /* 0: slave, 1: master */
 153 };
 154
 155 static struct spi_board_info ldp_spi_board_info[] __initdata = {
 156         [0] = {
 157                 /*
 158                  * TSC2046 operates at a max freqency of 2MHz, so
 159                  * operate slightly below at 1.5MHz
 160                  */
 161                 .modalias               = "ads7846",
 162                 .bus_num                = 1,
 163                 .chip_select            = 0,
 164                 .max_speed_hz           = 1500000,
 165                 .controller_data        = &tsc2046_mcspi_config,
 166                 .irq                    = 0,
 167                 .platform_data          = &tsc2046_config,
 168         },
 169 };
 170
 171 static struct platform_device ldp_lcd_device = {
 172         .name           = "ldp_lcd",
 173         .id             = -1,
 174 };
 175
 176 static struct platform_device *ldp_devices[] __initdata = {
 177         &ldp_lcd_device,
 178 };
 179
 180 static void __init omap_ldp_init_irq(void)
 181 {
 182         omap2_init_common_hw(NULL);
 183         omap_init_irq();
 184         omap_gpio_init();
 185 }
 186
 187 static struct omap_uart_config ldp_uart_config __initdata = {
 188         .enabled_uarts  = ((1 << 0) | (1 << 1) | (1 << 2)),
 189 };
 190
 191 static struct omap_lcd_config ldp_lcd_config __initdata = {
 192         .ctrl_name      = "internal",
 193 };
 194
 195 static struct omap_board_config_kernel ldp_config[] __initdata = {
 196         { OMAP_TAG_UART,        &ldp_uart_config },
 197         { OMAP_TAG_LCD,         &ldp_lcd_config },
 198 };
 199
 200 static int ldp_batt_table[] = {
 201 /* 0 C*/
 202 30800, 29500, 28300, 27100,
 203 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 204 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 205 11600, 11200, 10800, 10400, 10000, 9630,   9280,   8950,   8620,   8310,
 206 8020,   7730,   7460,   7200,   6950,   6710,   6470,   6250,   6040,   5830,
 207 5640,   5450,   5260,   5090,   4920,   4760,   4600,   4450,   4310,   4170,
 208 4040,   3910,   3790,   3670,   3550
 209 };
 210
 211 static struct twl4030_ins __initdata sleep_on_seq[] = {
 212 /*
 213  * Turn off VDD1 and VDD2.
 214  */
 215         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_OFF), 4},
 216         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_OFF), 2},
 217 #ifdef CONFIG_DISABLE_HFCLK
 218 /*
 219  * And also turn off the OMAP3 PLLs and the sysclk output.
 220  */
 221         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_OFF), 3},
 222         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_OFF), 3},
 223 #endif
 224 };
 225
 226 static struct twl4030_script sleep_on_script __initdata = {
 227         .script = sleep_on_seq,
 228         .size   = ARRAY_SIZE(sleep_on_seq),
 229         .flags  = TRITON_SLEEP_SCRIPT,
 230 };
 231
 232 static struct twl4030_ins wakeup_seq[] __initdata = {
 233 #ifndef CONFIG_DISABLE_HFCLK
 234 /*
 235  * Wakeup VDD1 and VDD2.
 236  */
 237         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_ACTIVE), 4},
 238         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_ACTIVE), 2},
 239 #else
 240 /*
 241  * Reenable the OMAP3 PLLs.
 242  * Wakeup VDD1 and VDD2.
 243  * Reenable sysclk output.
 244  */
 245         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_ACTIVE), 0x30},
 246         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_ACTIVE), 0x30},
 247         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_ACTIVE), 0x37},
 248         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_ACTIVE), 3},
 249 #endif /* #ifndef CONFIG_DISABLE_HFCLK */
 250 };
 251
 252 static struct twl4030_script wakeup_script __initdata = {
 253         .script = wakeup_seq,
 254         .size   = ARRAY_SIZE(wakeup_seq),
 255         .flags  = TRITON_WAKEUP12_SCRIPT | TRITON_WAKEUP3_SCRIPT,
 256 };
 257
 258 static struct twl4030_ins wrst_seq[] __initdata = {
 259 /*
 260  * Reset twl4030.
 261  * Reset VDD1 regulator.
 262  * Reset VDD2 regulator.
 263  * Reset VPLL1 regulator.
 264  * Enable sysclk output.
 265  * Reenable twl4030.
 266  */
 267         {MSG_SINGULAR(DEV_GRP_NULL, 0x1b, RES_STATE_OFF), 2},
 268         {MSG_SINGULAR(DEV_GRP_P1, 0xf, RES_STATE_WRST), 15},
 269         {MSG_SINGULAR(DEV_GRP_P1, 0x10, RES_STATE_WRST), 15},
 270         {MSG_SINGULAR(DEV_GRP_P1, 0x7, RES_STATE_WRST), 0x60},
 271         {MSG_SINGULAR(DEV_GRP_P1, 0x19, RES_STATE_ACTIVE), 2},
 272         {MSG_SINGULAR(DEV_GRP_NULL, 0x1b, RES_STATE_ACTIVE), 2},
 273 };
 274
 275 static struct twl4030_script wrst_script __initdata = {
 276         .script = wrst_seq,
 277         .size   = ARRAY_SIZE(wakeup_seq),
 278         .flags  = TRITON_WRST_SCRIPT,
 279 };
 280
 281 static struct twl4030_script *twl4030_scripts[] __initdata = {
 282         &sleep_on_script,
 283         &wakeup_script,
 284         &wrst_script,
 285 };
 286
 287 static struct twl4030_power_data sdp3430_t2scripts_data __initdata = {
 288         .scripts        = twl4030_scripts,
 289         .size           = ARRAY_SIZE(twl4030_scripts),
 290 };
 291
 292 static struct twl4030_bci_platform_data ldp_bci_data = {
 293         .battery_tmp_tbl        = ldp_batt_table,
 294         .tblsize                = ARRAY_SIZE(ldp_batt_table),
 295 };
 296
 297 static struct twl4030_usb_data ldp_usb_data = {
 298         .usb_mode       = T2_USB_MODE_ULPI,
 299 };
 300
 301 static struct twl4030_gpio_platform_data ldp_gpio_data = {
 302         .gpio_base      = OMAP_MAX_GPIO_LINES,
 303         .irq_base       = TWL4030_GPIO_IRQ_BASE,
 304         .irq_end        = TWL4030_GPIO_IRQ_END,
 305 };
 306
 307 static struct twl4030_madc_platform_data ldp_madc_data = {
 308         .irq_line       = 1,
 309 };
 310
 311 static struct twl4030_platform_data ldp_twldata = {
 312         .irq_base       = TWL4030_IRQ_BASE,
 313         .irq_end        = TWL4030_IRQ_END,
 314
 315         /* platform_data for children goes here */
 316         .bci            = &ldp_bci_data,
 317         .madc           = &ldp_madc_data,
 318         .usb            = &ldp_usb_data,
 319         .power          = &sdp3430_t2scripts_data,
 320         .gpio           = &ldp_gpio_data,
 321 };
 322
 323 static struct i2c_board_info __initdata ldp_i2c_boardinfo[] = {
 324         {
 325                 I2C_BOARD_INFO("twl4030", 0x48),
 326                 .flags = I2C_CLIENT_WAKE,
 327                 .irq = INT_34XX_SYS_NIRQ,
 328                 .platform_data = &ldp_twldata,
 329         },
 330 };
 331
 332 static int __init omap_i2c_init(void)
 333 {
 334         omap_register_i2c_bus(1, 2600, ldp_i2c_boardinfo,
 335                         ARRAY_SIZE(ldp_i2c_boardinfo));
 336         omap_register_i2c_bus(2, 400, NULL, 0);
 337         omap_register_i2c_bus(3, 400, NULL, 0);
 338         return 0;
 339 }
 340
 341 static void __init omap_ldp_init(void)
 342 {
 343         omap_i2c_init();
 344         platform_add_devices(ldp_devices, ARRAY_SIZE(ldp_devices));
 345         omap_board_config = ldp_config;
 346         omap_board_config_size = ARRAY_SIZE(ldp_config);
 347         ts_gpio = 54;
 348         ldp_spi_board_info[0].irq = OMAP_GPIO_IRQ(ts_gpio);
 349         spi_register_board_info(ldp_spi_board_info,
 350                                 ARRAY_SIZE(ldp_spi_board_info));
 351         msecure_init();
 352         ads7846_dev_init();
 353         omap_serial_init();
 354         usb_musb_init();
 355         hsmmc_init(HSMMC1);
 356 }
 357
 358 static void __init omap_ldp_map_io(void)
 359 {
 360         omap2_set_globals_343x();
 361         omap2_map_common_io();
 362 }
 363
 364 MACHINE_START(OMAP_LDP, "OMAP LDP board")
 365         .phys_io        = 0x48000000,
 366         .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
 367         .boot_params    = 0x80000100,
 368         .map_io         = omap_ldp_map_io,
 369         .init_irq       = omap_ldp_init_irq,
 370         .init_machine   = omap_ldp_init,
 371         .timer          = &omap_timer,
 372 MACHINE_END