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/hsmmc.h>
  39 #include <mach/common.h>
  40 #include <mach/keypad.h>
  41 #include <mach/dma.h>
  42 #include <mach/gpmc.h>
  43
  44 #include <asm/io.h>
  45 #include <asm/delay.h>
  46 #include <mach/control.h>
  47
  48 #include "sdram-qimonda-hyb18m512160af-6.h"
  49
  50 #define SDP3430_SMC91X_CS       3
  51
  52 #define ENABLE_VAUX3_DEDICATED  0x03
  53 #define ENABLE_VAUX3_DEV_GRP    0x20
  54
  55
  56 #define TWL4030_MSECURE_GPIO 22
  57
  58 static struct resource sdp3430_smc91x_resources[] = {
  59         [0] = {
  60                 .start  = OMAP34XX_ETHR_START,
  61                 .end    = OMAP34XX_ETHR_START + SZ_4K,
  62                 .flags  = IORESOURCE_MEM,
  63         },
  64         [1] = {
  65                 .start  = 0,
  66                 .end    = 0,
  67                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
  68         },
  69 };
  70
  71 static struct platform_device sdp3430_smc91x_device = {
  72         .name           = "smc91x",
  73         .id             = -1,
  74         .num_resources  = ARRAY_SIZE(sdp3430_smc91x_resources),
  75         .resource       = sdp3430_smc91x_resources,
  76 };
  77
  78 static int sdp3430_keymap[] = {
  79         KEY(0, 0, KEY_LEFT),
  80         KEY(0, 1, KEY_RIGHT),
  81         KEY(0, 2, KEY_A),
  82         KEY(0, 3, KEY_B),
  83         KEY(0, 4, KEY_C),
  84         KEY(1, 0, KEY_DOWN),
  85         KEY(1, 1, KEY_UP),
  86         KEY(1, 2, KEY_E),
  87         KEY(1, 3, KEY_F),
  88         KEY(1, 4, KEY_G),
  89         KEY(2, 0, KEY_ENTER),
  90         KEY(2, 1, KEY_I),
  91         KEY(2, 2, KEY_J),
  92         KEY(2, 3, KEY_K),
  93         KEY(2, 4, KEY_3),
  94         KEY(3, 0, KEY_M),
  95         KEY(3, 1, KEY_N),
  96         KEY(3, 2, KEY_O),
  97         KEY(3, 3, KEY_P),
  98         KEY(3, 4, KEY_Q),
  99         KEY(4, 0, KEY_R),
 100         KEY(4, 1, KEY_4),
 101         KEY(4, 2, KEY_T),
 102         KEY(4, 3, KEY_U),
 103         KEY(4, 4, KEY_D),
 104         KEY(5, 0, KEY_V),
 105         KEY(5, 1, KEY_W),
 106         KEY(5, 2, KEY_L),
 107         KEY(5, 3, KEY_S),
 108         KEY(5, 4, KEY_H),
 109         0
 110 };
 111
 112 static struct twl4030_keypad_data sdp3430_kp_data = {
 113         .rows           = 5,
 114         .cols           = 6,
 115         .keymap         = sdp3430_keymap,
 116         .keymapsize     = ARRAY_SIZE(sdp3430_keymap),
 117         .rep            = 1,
 118         .irq            = TWL4030_MODIRQ_KEYPAD,
 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                         system_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 (omap_request_gpio(ts_gpio) < 0) {
 167                 printk(KERN_ERR "can't get ads746 pen down GPIO\n");
 168                 return;
 169         }
 170
 171         omap_set_gpio_direction(ts_gpio, 1);
 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 !omap_get_gpio_datain(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 (system_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 = OMAP_GPIO_IRQ(eth_gpio);
 273
 274         if (omap_request_gpio(eth_gpio) < 0) {
 275                 printk(KERN_ERR "Failed to request GPIO%d for smc91x IRQ\n",
 276                         eth_gpio);
 277                 return;
 278         }
 279         omap_set_gpio_direction(eth_gpio, 1);
 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 static struct twl4030_platform_data sdp3430_twldata = {
 334         .irq_base       = TWL4030_IRQ_BASE,
 335         .irq_end        = TWL4030_IRQ_END,
 336
 337         /* platform_data for children goes here */
 338         .bci            = &sdp3430_bci_data,
 339         .gpio           = &sdp3430_gpio_data,
 340         .madc           = &sdp3430_madc_data,
 341         .keypad         = &sdp3430_kp_data,
 342         .usb            = &sdp3430_usb_data,
 343 };
 344
 345 static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
 346         {
 347                 I2C_BOARD_INFO("twl4030", 0x48),
 348                 .flags = I2C_CLIENT_WAKE,
 349                 .irq = INT_34XX_SYS_NIRQ,
 350                 .platform_data = &sdp3430_twldata,
 351         },
 352 };
 353
 354 static int __init omap3430_i2c_init(void)
 355 {
 356         omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
 357                         ARRAY_SIZE(sdp3430_i2c_boardinfo));
 358         omap_register_i2c_bus(2, 400, NULL, 0);
 359         omap_register_i2c_bus(3, 400, NULL, 0);
 360         return 0;
 361 }
 362
 363 extern void __init sdp3430_flash_init(void);
 364
 365 static void __init omap_3430sdp_init(void)
 366 {
 367         omap3430_i2c_init();
 368         platform_add_devices(sdp3430_devices, ARRAY_SIZE(sdp3430_devices));
 369         omap_board_config = sdp3430_config;
 370         omap_board_config_size = ARRAY_SIZE(sdp3430_config);
 371         if (system_rev > OMAP3430_REV_ES1_0)
 372                 ts_gpio = OMAP34XX_TS_GPIO_IRQ_SDPV2;
 373         else
 374                 ts_gpio = OMAP34XX_TS_GPIO_IRQ_SDPV1;
 375         sdp3430_spi_board_info[0].irq = OMAP_GPIO_IRQ(ts_gpio);
 376         spi_register_board_info(sdp3430_spi_board_info,
 377                                 ARRAY_SIZE(sdp3430_spi_board_info));
 378         ads7846_dev_init();
 379         sdp3430_flash_init();
 380         msecure_init();
 381         omap_serial_init();
 382         usb_musb_init();
 383         usb_ehci_init();
 384         hsmmc_init();
 385 }
 386
 387 static void __init omap_3430sdp_map_io(void)
 388 {
 389         omap2_set_globals_343x();
 390         omap2_map_common_io();
 391 }
 392
 393 MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
 394         /* Maintainer: Syed Khasim - Texas Instruments Inc */
 395         .phys_io        = 0x48000000,
 396         .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
 397         .boot_params    = 0x80000100,
 398         .map_io         = omap_3430sdp_map_io,
 399         .init_irq       = omap_3430sdp_init_irq,
 400         .init_machine   = omap_3430sdp_init,
 401         .timer          = &omap_timer,
 402 MACHINE_END