arch/arm/mach-omap2/board-am335x-tx48.c

   1 /*
   2  * Code for Ka-Ro electronics GmbH TX48 module with TI AM335X.
   3  * (C) Copyright 2013 Lothar Waßmann <LW@KARO-electronics.de>
   4  *
   5  * based on board-am335xevm.c
   6  * Copyright (C) 2011 Texas Instruments, Inc. - http://www.ti.com/
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation version 2.
  11  *
  12  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  13  * kind, whether express or implied; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17 #include <linux/kernel.h>
  18 #include <linux/init.h>
  19 #include <linux/i2c.h>
  20 #include <linux/module.h>
  21 #include <linux/i2c/at24.h>
  22 #include <linux/phy.h>
  23 #include <linux/gpio.h>
  24 #include <linux/spi/spi.h>
  25 #include <linux/gpio_keys.h>
  26 #include <linux/input.h>
  27 #include <linux/input/matrix_keypad.h>
  28 #include <linux/mtd/mtd.h>
  29 #include <linux/mtd/nand.h>
  30 #include <linux/mtd/partitions.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/clk.h>
  33 #include <linux/err.h>
  34 #include <linux/export.h>
  35 #include <linux/wl12xx.h>
  36 #include <linux/ethtool.h>
  37 #include <linux/pwm_backlight.h>
  38 #include <linux/input/ti_tsc.h>
  39 #include <linux/platform_data/ti_adc.h>
  40 #include <linux/mfd/ti_tscadc.h>
  41 #include <linux/reboot.h>
  42 #include <linux/pwm/pwm.h>
  43 #include <linux/rtc/rtc-omap.h>
  44 #include <linux/opp.h>
  45 #include <linux/i2c/tsc2007.h>
  46
  47 /* LCD controller is similar to DA850 */
  48 #include <video/da8xx-fb.h>
  49
  50 #include <mach/hardware.h>
  51
  52 #include <asm/mach-types.h>
  53 #include <asm/mach/arch.h>
  54 #include <asm/mach/map.h>
  55 #include <asm/hardware/asp.h>
  56
  57 #include <plat/omap_device.h>
  58 #include <plat/omap-pm.h>
  59 #include <plat/irqs.h>
  60 #include <plat/board.h>
  61 #include <plat/common.h>
  62 #include <plat/lcdc.h>
  63 #include <plat/usb.h>
  64 #include <plat/mmc.h>
  65 #include <plat/emif.h>
  66 #include <plat/nand.h>
  67
  68 #include "common.h"
  69 #include "board-flash.h"
  70 #include "cpuidle33xx.h"
  71 #include "mux.h"
  72 #include "devices.h"
  73 #include "hsmmc.h"
  74
  75 void am33xx_d_can_init(unsigned int instance);
  76
  77 /* Convert GPIO signal to GPIO pin number */
  78 #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
  79
  80 enum tx48_baseboards {
  81         STK5_V3 = 3,
  82         STK5_V5 = 5,
  83 };
  84
  85 static enum tx48_baseboards tx48_baseboard __initdata = STK5_V3;
  86
  87 static int __init tx48_setup_baseboard(char *option)
  88 {
  89         if (strcasecmp(option, "stk5-v5") == 0)
  90                 tx48_baseboard = STK5_V5;
  91         else
  92                 return 0;
  93         return 1;
  94 }
  95 __setup("tx48_base=", tx48_setup_baseboard);
  96
  97 static const struct display_panel disp_panel = {
  98         WVGA,
  99         32,
 100         32,
 101         COLOR_ACTIVE,
 102 };
 103
 104 /* module pin mux structure */
 105 struct pinmux_config {
 106         const char *string_name; /* signal name format */
 107         int val; /* Options for the mux register value */
 108 };
 109
 110 static void setup_pin_mux(const struct pinmux_config *pin_mux)
 111 {
 112         int i;
 113
 114         for (i = 0; pin_mux->string_name != NULL; pin_mux++)
 115                 omap_mux_init_signal(pin_mux->string_name, pin_mux->val);
 116 }
 117
 118 /* LCD backlight platform Data */
 119 #define STK5_BACKLIGHT_MAX_BRIGHTNESS           100
 120 #define STK5_BACKLIGHT_DEFAULT_BRIGHTNESS       100
 121 #define STK5_PWM_PERIOD_NANO_SECONDS            (5000 * 10)
 122 #define STK5_BACKLIGHT_GPIO                     GPIO_TO_PIN(3, 16)
 123
 124 static struct platform_pwm_backlight_data stk5_backlight_data;
 125
 126 /* Module pin mux for EHRPWM */
 127 static const struct pinmux_config ehrpwm0_pin_mux[] = {
 128         { "mcasp0_aclkx.ehrpwm0a", AM33XX_PIN_OUTPUT, },
 129         { }
 130 };
 131
 132 static const struct pinmux_config ehrpwm0_gpio_pin_mux[] = {
 133         { "mcasp0_aclkx.gpio3_14", AM33XX_PIN_OUTPUT, },
 134         { }
 135 };
 136
 137 static struct lcd_ctrl_config lcd_cfg = {
 138         &disp_panel,
 139         .ac_bias = 255,
 140         .ac_bias_intrpt = 0,
 141         .dma_burst_sz = 16,
 142         .bpp = 32,
 143         .fdd = 0x80,
 144         .tft_alt_mode = 0,
 145         .stn_565_mode = 0,
 146         .mono_8bit_mode = 0,
 147         .invert_line_clock = 1,
 148         .invert_frm_clock = 1,
 149         .invert_pixel_clock = 1,
 150         .sync_edge = 0,
 151         .sync_ctrl = 1,
 152         .raster_order = 0,
 153 };
 154
 155 static struct da8xx_lcdc_platform_data stk5_lcdc_pdata = {
 156         .controller_data = &lcd_cfg,
 157 };
 158
 159 /* TSc controller */
 160 static struct tsc_data stk5_touchscreen_data = {
 161         .wires = 4,
 162         .x_plate_resistance = 200,
 163         .steps_to_configure = 5,
 164 };
 165
 166 static struct adc_data stk5_adc_data = {
 167         .adc_channels = 4,
 168 };
 169
 170 static struct mfd_tscadc_board tscadc = {
 171         .tsc_init = &stk5_touchscreen_data,
 172         .adc_init = &stk5_adc_data,
 173 };
 174
 175 static u8 stk5_iis_serializer_direction1[] = {
 176         INACTIVE_MODE,  INACTIVE_MODE,  TX_MODE,        RX_MODE,
 177         INACTIVE_MODE,  INACTIVE_MODE,  INACTIVE_MODE,  INACTIVE_MODE,
 178         INACTIVE_MODE,  INACTIVE_MODE,  INACTIVE_MODE,  INACTIVE_MODE,
 179         INACTIVE_MODE,  INACTIVE_MODE,  INACTIVE_MODE,  INACTIVE_MODE,
 180 };
 181
 182 static struct snd_platform_data stk5_snd_data1 = {
 183         .tx_dma_offset = 0x46400000,    /* McASP1 */
 184         .rx_dma_offset = 0x46400000,
 185         .op_mode = DAVINCI_MCASP_IIS_MODE,
 186         .tdm_slots = 2,
 187         .serial_dir = stk5_iis_serializer_direction1,
 188         .num_serializer = ARRAY_SIZE(stk5_iis_serializer_direction1),
 189         .asp_chan_q = EVENTQ_2,
 190         .version = MCASP_VERSION_3,
 191         .txnumevt = 32,
 192         .rxnumevt = 32,
 193         .get_context_loss_count =
 194                         omap_pm_get_dev_context_loss_count,
 195 };
 196
 197 static struct omap2_hsmmc_info stk5_mmc[] __initdata = {
 198         {
 199                 .mmc = 2,
 200                 .caps = MMC_CAP_4_BIT_DATA,
 201                 .gpio_cd = GPIO_TO_PIN(3, 15),
 202                 .ocr_mask = MMC_VDD_32_33 | MMC_VDD_33_34, /* 3V3 */
 203         },
 204         { /* Terminator */ }
 205 };
 206
 207 /* Module pin mux for LCDC */
 208 static const struct pinmux_config lcdc_pin_mux[] __initconst = {
 209         { "lcd_data0.lcd_data0", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 210         { "lcd_data1.lcd_data1", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 211         { "lcd_data2.lcd_data2", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 212         { "lcd_data3.lcd_data3", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 213         { "lcd_data4.lcd_data4", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 214         { "lcd_data5.lcd_data5", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 215         { "lcd_data6.lcd_data6", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 216         { "lcd_data7.lcd_data7", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 217         { "lcd_data8.lcd_data8", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 218         { "lcd_data9.lcd_data9", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 219         { "lcd_data10.lcd_data10", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 220         { "lcd_data11.lcd_data11", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 221         { "lcd_data12.lcd_data12", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 222         { "lcd_data13.lcd_data13", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 223         { "lcd_data14.lcd_data14", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 224         { "lcd_data15.lcd_data15", AM33XX_PIN_OUTPUT | AM33XX_PULL_DISA, },
 225         { "gpmc_ad8.lcd_data16", AM33XX_PIN_OUTPUT, },
 226         { "gpmc_ad9.lcd_data17", AM33XX_PIN_OUTPUT, },
 227         { "gpmc_ad10.lcd_data18", AM33XX_PIN_OUTPUT, },
 228         { "gpmc_ad11.lcd_data19", AM33XX_PIN_OUTPUT, },
 229         { "gpmc_ad12.lcd_data20", AM33XX_PIN_OUTPUT, },
 230         { "gpmc_ad13.lcd_data21", AM33XX_PIN_OUTPUT, },
 231         { "gpmc_ad14.lcd_data22", AM33XX_PIN_OUTPUT, },
 232         { "gpmc_ad15.lcd_data23", AM33XX_PIN_OUTPUT, },
 233         { "lcd_vsync.lcd_vsync", AM33XX_PIN_OUTPUT, },
 234         { "lcd_hsync.lcd_hsync", AM33XX_PIN_OUTPUT, },
 235         { "lcd_pclk.lcd_pclk", AM33XX_PIN_OUTPUT, },
 236         { "lcd_ac_bias_en.lcd_ac_bias_en", AM33XX_PIN_OUTPUT, },
 237         { "gpmc_a3.gpio1_19", AM33XX_PIN_OUTPUT, }, /* LCD RESET */
 238         { "gpmc_a6.gpio1_22", AM33XX_PIN_OUTPUT, }, /* LCD POWER */
 239         { }
 240 };
 241
 242 /* Pin mux for nand flash module */
 243 static const struct pinmux_config nand_pin_mux[] __initconst = {
 244         { "gpmc_ad0.gpmc_ad0", AM33XX_PIN_INPUT_PULLUP, },
 245         { "gpmc_ad1.gpmc_ad1", AM33XX_PIN_INPUT_PULLUP, },
 246         { "gpmc_ad2.gpmc_ad2", AM33XX_PIN_INPUT_PULLUP, },
 247         { "gpmc_ad3.gpmc_ad3", AM33XX_PIN_INPUT_PULLUP, },
 248         { "gpmc_ad4.gpmc_ad4", AM33XX_PIN_INPUT_PULLUP, },
 249         { "gpmc_ad5.gpmc_ad5", AM33XX_PIN_INPUT_PULLUP, },
 250         { "gpmc_ad6.gpmc_ad6", AM33XX_PIN_INPUT_PULLUP, },
 251         { "gpmc_ad7.gpmc_ad7", AM33XX_PIN_INPUT_PULLUP, },
 252         { "gpmc_wait0.gpmc_wait0", AM33XX_PIN_INPUT_PULLUP, },
 253         { "gpmc_wpn.gpmc_wpn", AM33XX_PIN_INPUT_PULLUP, },
 254         { "gpmc_csn0.gpmc_csn0", AM33XX_PIN_OUTPUT_PULLUP, },
 255         { "gpmc_advn_ale.gpmc_advn_ale", AM33XX_PULL_DISA, },
 256         { "gpmc_oen_ren.gpmc_oen_ren", AM33XX_PULL_DISA, },
 257         { "gpmc_wen.gpmc_wen", AM33XX_PULL_DISA, },
 258         { "gpmc_ben0_cle.gpmc_ben0_cle", AM33XX_PULL_DISA, },
 259         { }
 260 };
 261
 262 /* Module pin mux for SPI */
 263 static const struct pinmux_config spi0_pin_mux[] __initconst = {
 264         { "spi0_sclk.spi0_sclk", AM33XX_PULL_ENBL | AM33XX_INPUT_EN, },
 265         { "spi0_d0.spi0_d0", AM33XX_PIN_INPUT_PULLUP, },
 266         { "spi0_d1.spi0_d1", AM33XX_PULL_ENBL | AM33XX_INPUT_EN, },
 267         { "spi0_cs0.spi0_cs0", AM33XX_PIN_INPUT_PULLUP, },
 268         { }
 269 };
 270
 271 /* Module pin mux for rmii1 */
 272 static const struct pinmux_config rmii1_pin_mux[] __initconst = {
 273         { "gmii1_crs.rmii1_crs_dv", AM33XX_PIN_INPUT_PULLDOWN, },
 274         { "gmii1_rxerr.rmii1_rxerr", AM33XX_PIN_INPUT_PULLDOWN, },
 275         { "gmii1_txen.rmii1_txen", AM33XX_PIN_OUTPUT, },
 276         { "gmii1_txd1.rmii1_txd1", AM33XX_PIN_OUTPUT, },
 277         { "gmii1_txd0.rmii1_txd0", AM33XX_PIN_OUTPUT, },
 278         { "gmii1_rxd1.rmii1_rxd1", AM33XX_PIN_INPUT_PULLUP, },
 279         { "gmii1_rxd0.rmii1_rxd0", AM33XX_PIN_INPUT_PULLUP, },
 280         { "rmii1_refclk.rmii1_refclk", AM33XX_PIN_INPUT, },
 281         { "mdio_data.mdio_data", AM33XX_PIN_INPUT_PULLUP, },
 282         { "mdio_clk.mdio_clk", AM33XX_PIN_OUTPUT_PULLUP, },
 283         { "emu0.gpio3_7", AM33XX_PIN_INPUT_PULLUP, }, /* nINT */
 284         { "emu1.gpio3_8", AM33XX_PIN_OUTPUT_PULLUP, }, /* nRST */
 285         { }
 286 };
 287
 288 /* Module pin mux for mcasp1 */
 289 static const struct pinmux_config mcasp1_pin_mux[] __initconst = {
 290         { "mcasp0_aclkr.mcasp1_aclkx", AM33XX_PIN_INPUT_PULLDOWN, },
 291         { "mcasp0_fsr.mcasp1_fsx", AM33XX_PIN_INPUT_PULLDOWN, },
 292         { "mcasp0_axr1.mcasp1_axr0", AM33XX_PIN_INPUT_PULLDOWN, },
 293         { "mcasp0_ahclk.mcasp1_axr1", AM33XX_PIN_INPUT_PULLDOWN, },
 294         { }
 295 };
 296
 297
 298 /* Module pin mux for mmc1 */
 299 #define MMC_CD_GPIO
 300 static const struct pinmux_config mmc1_pin_mux[] __initconst = {
 301 #ifdef MMC_CD_GPIO
 302         { "mcasp0_fsx.gpio3_15", AM33XX_PIN_INPUT_PULLUP, },
 303 #else
 304         { "mcasp0_fsx.mmc1_sdcd", AM33XX_PIN_INPUT_PULLUP, },
 305 #endif
 306         { "gmii1_txclk.mmc1_dat0", AM33XX_PIN_INPUT_PULLUP, },
 307         { "gmii1_rxclk.mmc1_dat1", AM33XX_PIN_INPUT_PULLUP, },
 308         { "gmii1_rxd3.mmc1_dat2", AM33XX_PIN_INPUT_PULLUP, },
 309         { "gmii1_rxd2.mmc1_dat3", AM33XX_PIN_INPUT_PULLUP, },
 310         { "gpmc_csn2.mmc1_cmd", AM33XX_PIN_INPUT_PULLUP, },
 311         { "gpmc_csn1.mmc1_clk", AM33XX_PIN_INPUT_PULLUP, },
 312         { }
 313 };
 314
 315 /* pinmux for led device */
 316 static const struct pinmux_config gpio_led_mux[] __initconst = {
 317         { "gpmc_a10.gpio1_26", AM33XX_PIN_INPUT, },
 318         { }
 319 };
 320
 321 /* Matrix GPIO Keypad Support */
 322 /* pinmux for keypad device */
 323 static const struct pinmux_config matrix_keypad_pin_mux[] __initconst = {
 324         /* keypad row gpios */
 325         { "xdma_event_intr0.gpio0_19", AM33XX_PIN_INPUT_PULLDOWN, },
 326         { "xdma_event_intr1.gpio0_20", AM33XX_PIN_INPUT_PULLDOWN, },
 327         { "gpmc_clk.gpio2_1", AM33XX_PIN_INPUT_PULLDOWN, },
 328         { "gpmc_csn3.gpio2_0", AM33XX_PIN_INPUT_PULLDOWN, },
 329         /* keypad col gpios */
 330         { "mmc0_dat3.gpio2_26", AM33XX_PIN_OUTPUT, },
 331         { "mcasp0_ahclkr.gpio3_17", AM33XX_PIN_OUTPUT, },
 332         { "ecap0_in_pwm0_out.gpio0_7", AM33XX_PIN_OUTPUT, },
 333         { "gpmc_ben1.gpio1_28", AM33XX_PIN_OUTPUT, },
 334         { }
 335 };
 336
 337 /* Keys mapping */
 338 static const uint32_t stk5_matrix_keys[] = {
 339         KEY(0, 0, KEY_POWER),
 340 };
 341
 342 static const struct matrix_keymap_data stk5_keymap_data = {
 343         .keymap = stk5_matrix_keys,
 344         .keymap_size = ARRAY_SIZE(stk5_matrix_keys),
 345 };
 346
 347 static const unsigned int stk5_keypad_row_gpios[] = {
 348         GPIO_TO_PIN(0, 19),
 349         GPIO_TO_PIN(0, 20),
 350         GPIO_TO_PIN(2, 1),
 351         GPIO_TO_PIN(2, 0),
 352 };
 353
 354 static const unsigned int stk5_keypad_col_gpios[] = {
 355         GPIO_TO_PIN(2, 26),
 356         GPIO_TO_PIN(3, 17),
 357         GPIO_TO_PIN(0, 7),
 358         GPIO_TO_PIN(1, 28),
 359 };
 360
 361 static struct matrix_keypad_platform_data stk5_keypad_platform_data = {
 362         .keymap_data = &stk5_keymap_data,
 363         .row_gpios = stk5_keypad_row_gpios,
 364         .num_row_gpios = ARRAY_SIZE(stk5_keypad_row_gpios),
 365         .col_gpios = stk5_keypad_col_gpios,
 366         .num_col_gpios = ARRAY_SIZE(stk5_keypad_col_gpios),
 367         .debounce_ms = 5,
 368         .col_scan_delay_us = 2,
 369         .wakeup = 1,
 370 };
 371
 372 static struct platform_device stk5_keyboard = {
 373         .name = "matrix-keypad",
 374         .id = -1,
 375         .dev = {
 376                 .platform_data = &stk5_keypad_platform_data,
 377         },
 378 };
 379
 380 static void __init matrix_keypad_init(void)
 381 {
 382         int err;
 383
 384         setup_pin_mux(matrix_keypad_pin_mux);
 385         err = platform_device_register(&stk5_keyboard);
 386         if (err)
 387                 pr_err("failed to register matrix keypad (%ux%u) device\n",
 388                         ARRAY_SIZE(stk5_keypad_col_gpios),
 389                         ARRAY_SIZE(stk5_keypad_row_gpios));
 390 }
 391
 392 /* pinmux for usb0 drvvbus */
 393 static const struct pinmux_config usb0_pin_mux[] __initconst = {
 394         { "usb0_drvvbus.usb0_drvvbus", AM33XX_PIN_OUTPUT, },
 395         { }
 396 };
 397
 398 /* pinmux for usb1 drvvbus */
 399 static const struct pinmux_config usb1_pin_mux[] __initconst = {
 400         { "usb1_drvvbus.usb1_drvvbus", AM33XX_PIN_OUTPUT, },
 401         { }
 402 };
 403
 404 static bool backlight_enable;
 405
 406 static void __init enable_ehrpwm0(void)
 407 {
 408         backlight_enable = true;
 409         setup_pin_mux(ehrpwm0_pin_mux);
 410 }
 411
 412 /* Setup pwm-backlight */
 413 static struct platform_pwm_backlight_data stk5_backlight_data = {
 414         .pwm_id = "ehrpwm.0",
 415         .ch = 0,
 416         .lth_brightness = 0,
 417         .max_brightness = STK5_BACKLIGHT_MAX_BRIGHTNESS,
 418         .dft_brightness = STK5_BACKLIGHT_DEFAULT_BRIGHTNESS,
 419         .pwm_period_ns  = 50000,
 420 };
 421
 422 static struct platform_device stk5_backlight = {
 423         .name = "pwm-backlight",
 424         .id = -1,
 425         .dev = {
 426                 .platform_data = &stk5_backlight_data,
 427         },
 428 };
 429
 430 static struct pwmss_platform_data pwm_pdata = {
 431         .version = PWM_VERSION_1,
 432 };
 433
 434 static int __init backlight_init(void)
 435 {
 436         int status = 0;
 437
 438         if (backlight_enable) {
 439                 struct pwm_device *pwm;
 440                 struct platform_pwm_backlight_data *bd = &stk5_backlight_data;
 441
 442                 am33xx_register_ehrpwm(0, &pwm_pdata);
 443                 pwm = pwm_request(bd->pwm_id, bd->ch, "backlight");
 444                 if (IS_ERR(pwm))
 445                         return PTR_ERR(pwm);
 446
 447                 pwm_set_polarity(pwm, 1);
 448                 pwm_release(pwm);
 449                 status = platform_device_register(&stk5_backlight);
 450         }
 451         return status;
 452 }
 453 late_initcall(backlight_init);
 454
 455 static int __init conf_disp_pll(int rate)
 456 {
 457         struct clk *disp_pll;
 458         int ret = -EINVAL;
 459
 460         disp_pll = clk_get(NULL, "dpll_disp_ck");
 461         if (IS_ERR(disp_pll)) {
 462                 pr_err("Cannot clk_get disp_pll\n");
 463                 goto out;
 464         }
 465
 466         ret = clk_set_rate(disp_pll, rate);
 467         clk_put(disp_pll);
 468 out:
 469         return ret;
 470 }
 471
 472 static const struct gpio stk5_lcdc_gpios[] __initconst = {
 473         { GPIO_TO_PIN(1, 19), GPIOF_OUT_INIT_HIGH, "LCD reset", },
 474         { GPIO_TO_PIN(1, 22), GPIOF_OUT_INIT_HIGH, "LCD power", },
 475 };
 476
 477 static void __init lcdc_init(void)
 478 {
 479         setup_pin_mux(lcdc_pin_mux);
 480
 481         if (conf_disp_pll(300000000)) {
 482                 pr_err("Failed configure display PLL, not attempting to register LCDC\n");
 483                 return;
 484         }
 485         gpio_request_array(stk5_lcdc_gpios, ARRAY_SIZE(stk5_lcdc_gpios));
 486
 487         stk5_lcdc_pdata.get_context_loss_count = omap_pm_get_dev_context_loss_count;
 488         if (am33xx_register_lcdc(&stk5_lcdc_pdata))
 489                 pr_err("Failed to register LCDC device\n");
 490 }
 491
 492 static void __init mfd_tscadc_init(void)
 493 {
 494         int err;
 495
 496         err = am33xx_register_mfd_tscadc(&tscadc);
 497         if (err)
 498                 pr_err("failed to register touchscreen device\n");
 499 }
 500
 501 static void __init rmii1_init(void)
 502 {
 503         setup_pin_mux(rmii1_pin_mux);
 504 }
 505
 506 static void __init usb0_init(void)
 507 {
 508         setup_pin_mux(usb0_pin_mux);
 509 }
 510
 511 static void __init usb1_init(void)
 512 {
 513         setup_pin_mux(usb1_pin_mux);
 514 }
 515
 516 /* setup uart pins */
 517 /* Module pin mux for uart0 */
 518 static const struct pinmux_config uart0_pin_mux[] __initconst = {
 519         { "uart0_rxd.uart0_rxd", AM33XX_SLEWCTRL_SLOW |
 520           AM33XX_PIN_INPUT_PULLUP, },
 521         { "uart0_txd.uart0_txd", AM33XX_PULL_UP | AM33XX_PULL_DISA |
 522           AM33XX_SLEWCTRL_SLOW, },
 523         { "uart0_rtsn.uart0_rtsn", AM33XX_SLEWCTRL_SLOW |
 524           AM33XX_PIN_INPUT_PULLUP, },
 525         { "uart0_ctsn.uart0_ctsn", AM33XX_PULL_UP | AM33XX_PULL_DISA |
 526           AM33XX_SLEWCTRL_SLOW, },
 527         { }
 528 };
 529
 530 static const struct pinmux_config uart1_pin_mux[] __initconst = {
 531         { "uart1_rxd.uart1_rxd", AM33XX_SLEWCTRL_SLOW |
 532           AM33XX_PIN_INPUT_PULLUP, },
 533         { "uart1_txd.uart1_txd", AM33XX_PULL_UP | AM33XX_PULL_DISA |
 534           AM33XX_SLEWCTRL_SLOW, },
 535         { "uart1_rtsn.uart1_rtsn", AM33XX_SLEWCTRL_SLOW |
 536           AM33XX_PIN_INPUT_PULLUP, },
 537         { "uart1_ctsn.uart1_ctsn", AM33XX_PULL_UP | AM33XX_PULL_DISA |
 538           AM33XX_SLEWCTRL_SLOW, },
 539         { }
 540 };
 541
 542 static const struct pinmux_config uart5_pin_mux[] __initconst = {
 543         { "gmii1_col.uart5_rxd", AM33XX_PIN_INPUT_PULLUP, },
 544         { "gmii1_rxdv.uart5_txd", AM33XX_PULL_ENBL, },
 545         { "mmc0_dat0.uart5_rtsn", AM33XX_PIN_INPUT_PULLUP, },
 546         { "mmc0_dat1.uart5_ctsn", AM33XX_PULL_ENBL, },
 547         { }
 548 };
 549
 550 static void __init uart0_init(void)
 551 {
 552         setup_pin_mux(uart0_pin_mux);
 553 }
 554
 555 static void __init uart1_init(void)
 556 {
 557         setup_pin_mux(uart1_pin_mux);
 558 }
 559
 560 static void __init uart5_init(void)
 561 {
 562         setup_pin_mux(uart5_pin_mux);
 563 }
 564
 565 static struct spi_board_info stk5_spi0_slave_info[] = {
 566         {
 567                 .modalias = "spidev",
 568                 .max_speed_hz = 24000000,
 569                 .bus_num = 1,
 570                 .chip_select = 0,
 571         },
 572         {
 573                 .modalias = "spidev",
 574                 .max_speed_hz = 24000000,
 575                 .bus_num = 1,
 576                 .chip_select = 1,
 577         },
 578 };
 579
 580 static struct gpmc_timings stk5_nand_timings = {
 581         .sync_clk = 0,
 582
 583         .cs_on = 0,
 584         .cs_rd_off = 44,
 585         .cs_wr_off = 44,
 586
 587         .adv_on = 6,
 588         .adv_rd_off = 34,
 589         .adv_wr_off = 44,
 590         .we_off = 40,
 591         .oe_off = 54,
 592
 593         .access = 64,
 594         .rd_cycle = 82,
 595         .wr_cycle = 82,
 596
 597         .wr_access = 40,
 598         .wr_data_mux_bus = 0,
 599 };
 600
 601 static void __init tx48_nand_init(void)
 602 {
 603         struct omap_nand_platform_data *pdata;
 604         struct gpmc_devices_info gpmc_device[2] = { };
 605
 606         setup_pin_mux(nand_pin_mux);
 607         pdata = omap_nand_init(NULL, 0, 0, 0, &stk5_nand_timings);
 608         if (!pdata)
 609                 return;
 610         pdata->ecc_opt = OMAP_ECC_BCH8_CODE_HW;
 611         pdata->elm_used = true;
 612         pdata->use_flash_bbt = true;
 613         gpmc_device[0].pdata = pdata;
 614         gpmc_device[0].flag = GPMC_DEVICE_NAND;
 615
 616         omap_init_gpmc(gpmc_device, sizeof(gpmc_device));
 617         omap_init_elm();
 618 }
 619
 620 static const struct pinmux_config tsc2007_pin_mux[] = {
 621         { "mcasp0_axr0.gpio3_16", AM33XX_PIN_INPUT_PULLUP |
 622           AM33XX_SLEWCTRL_SLOW, },
 623         { }
 624 };
 625
 626 #define TSC2007_PENDOWN_GPIO    GPIO_TO_PIN(3, 16)
 627
 628 static int tsc2007_get_pendown_state(void)
 629 {
 630         int pd = !gpio_get_value(TSC2007_PENDOWN_GPIO);
 631         printk(KERN_DEBUG "Pen is %s\n", pd ? "down" : "up");
 632         return pd;
 633 }
 634
 635 static int tsc2007_init_hw(void)
 636 {
 637         int ret;
 638
 639         setup_pin_mux(tsc2007_pin_mux);
 640
 641         ret = gpio_request_one(TSC2007_PENDOWN_GPIO, GPIOF_IN, "TSC2007 pendown");
 642         if (ret)
 643                 return ret;
 644         return 0;
 645 }
 646
 647 static void tsc2007_exit_hw(void)
 648 {
 649         gpio_free(TSC2007_PENDOWN_GPIO);
 650 }
 651
 652 static struct tsc2007_platform_data tsc2007_pdata = {
 653         .x_plate_ohms = 660,
 654         .get_pendown_state = tsc2007_get_pendown_state,
 655         .init_platform_hw = tsc2007_init_hw,
 656         .exit_platform_hw = tsc2007_exit_hw,
 657 };
 658
 659 static const struct pinmux_config i2c0_pin_mux[] __initconst = {
 660         { "i2c0_sda.i2c0_sda", AM33XX_SLEWCTRL_SLOW | AM33XX_PIN_INPUT_PULLUP, },
 661         { "i2c0_scl.i2c0_scl", AM33XX_SLEWCTRL_SLOW | AM33XX_PIN_INPUT_PULLUP, },
 662         { }
 663 };
 664
 665 static struct i2c_board_info stk5_i2c0_boardinfo[] = {
 666         {
 667                 I2C_BOARD_INFO("tsc2007", 0x48),
 668                 .irq = 0, /* setup at runtime by i2c0_init() */
 669                 .platform_data = &tsc2007_pdata,
 670         },
 671         {
 672                 I2C_BOARD_INFO("sgtl5000", 0x0a),
 673         },
 674         {
 675                 I2C_BOARD_INFO("ds1339", 0x68),
 676         },
 677 };
 678
 679 static void __init i2c0_init(void)
 680 {
 681         setup_pin_mux(i2c0_pin_mux);
 682         stk5_i2c0_boardinfo[0].irq = gpio_to_irq(TSC2007_PENDOWN_GPIO);
 683         omap_register_i2c_bus(1, 100, stk5_i2c0_boardinfo,
 684                         ARRAY_SIZE(stk5_i2c0_boardinfo));
 685 }
 686
 687 /* Setup McASP 1 */
 688 static void __init mcasp1_init(void)
 689 {
 690         /* Configure McASP */
 691         setup_pin_mux(mcasp1_pin_mux);
 692         am335x_register_mcasp(&stk5_snd_data1, 1);
 693 }
 694
 695 static const struct pinmux_config d_can0_pin_mux[] __initconst = {
 696         { "gmii1_txd3.d_can0_tx", AM33XX_PULL_ENBL, },
 697         { "gmii1_txd2.d_can0_rx", AM33XX_PIN_INPUT_PULLUP, },
 698         { }
 699 };
 700
 701 static const struct pinmux_config d_can1_pin_mux[] __initconst = {
 702         { "mmc0_clk.d_can1_tx", AM33XX_PULL_ENBL, },
 703         { "mmc0_cmd.d_can1_rx", AM33XX_PIN_INPUT_PULLUP, },
 704         { }
 705 };
 706
 707 static const struct pinmux_config can_xcvr_pin_mux[] __initconst = {
 708         { "gpmc_ad8.gpio0_22", AM33XX_PIN_OUTPUT_PULLUP, },
 709         { }
 710 };
 711
 712 static int __init d_can_init(int id)
 713 {
 714         switch (id) {
 715         case 0:
 716                 setup_pin_mux(d_can0_pin_mux);
 717                 break;
 718         case 1:
 719                 setup_pin_mux(d_can1_pin_mux);
 720                 break;
 721
 722         default:
 723                 return -EINVAL;
 724         }
 725
 726         if (tx48_baseboard == STK5_V5) {
 727                 setup_pin_mux(can_xcvr_pin_mux);
 728                 gpio_request_one(GPIO_TO_PIN(0, 0), GPIOF_OUT_INIT_LOW, "CAN xcvr");
 729         }
 730
 731         am33xx_d_can_init(id);
 732         return 0;
 733 }
 734
 735 static void __init mmc1_init(void)
 736 {
 737         setup_pin_mux(mmc1_pin_mux);
 738         omap2_hsmmc_init(stk5_mmc);
 739 }
 740
 741 static struct gpio_led gpio_leds[] = {
 742         {
 743                 .name = "heartbeat",
 744                 .gpio = GPIO_TO_PIN(1, 26),
 745                 .default_trigger = "heartbeat",
 746         },
 747 };
 748
 749 static struct gpio_led_platform_data gpio_led_info = {
 750         .leds = gpio_leds,
 751         .num_leds = ARRAY_SIZE(gpio_leds),
 752 };
 753
 754 static struct platform_device leds_gpio = {
 755         .name = "leds-gpio",
 756         .id = -1,
 757         .dev = {
 758                 .platform_data = &gpio_led_info,
 759         },
 760 };
 761
 762 static void __init gpio_led_init(void)
 763 {
 764         int err;
 765
 766         setup_pin_mux(gpio_led_mux);
 767         err = platform_device_register(&leds_gpio);
 768         if (err)
 769                 pr_err("failed to register gpio led device\n");
 770 }
 771
 772 /* setup spi0 */
 773 static void __init spi0_init(void)
 774 {
 775         setup_pin_mux(spi0_pin_mux);
 776         spi_register_board_info(stk5_spi0_slave_info,
 777                         ARRAY_SIZE(stk5_spi0_slave_info));
 778 }
 779
 780 static struct omap_rtc_pdata stk5_rtc_info = {
 781         .wakeup_capable = 1,
 782 };
 783
 784 static int __init stk5_rtc_init(void)
 785 {
 786         int ret;
 787         void __iomem *base;
 788         struct clk *clk;
 789         struct omap_hwmod *oh;
 790         struct platform_device *pdev;
 791         char *dev_name = "am33xx-rtc";
 792
 793         clk = clk_get_sys(dev_name, "rtc_fck");
 794         if (IS_ERR(clk)) {
 795                 pr_err("rtc: Failed to get RTC clock\n");
 796                 return PTR_ERR(clk);
 797         }
 798
 799         ret = clk_enable(clk);
 800         if (ret) {
 801                 pr_err("rtc: Clock enable failed: %d\n", ret);
 802                 return ret;
 803         }
 804
 805         base = ioremap(AM33XX_RTC_BASE, SZ_4K);
 806         if (WARN_ON(!base))
 807                 return -ENOMEM;
 808
 809         /* Unlock the rtc's registers */
 810         writel(0x83e70b13, base + 0x6c);
 811         writel(0x95a4f1e0, base + 0x70);
 812
 813         /*
 814          * Enable the 32K OSc
 815          * TODO: Need a better way to handle this
 816          * Since we want the clock to be running before mmc init
 817          * we need to do it before the rtc probe happens
 818          */
 819         writel(0x48, base + 0x54);
 820
 821         iounmap(base);
 822
 823         clk_disable(clk);
 824         clk_put(clk);
 825
 826         if (omap_rev() < AM335X_REV_ES2_0)
 827                 stk5_rtc_info.wakeup_capable = 0;
 828
 829         oh = omap_hwmod_lookup("rtc");
 830         if (!oh) {
 831                 pr_err("could not look up %s\n", "rtc");
 832                 return -ENOENT;
 833         }
 834
 835         pdev = omap_device_build(dev_name, -1, oh, &stk5_rtc_info,
 836                         sizeof(struct omap_rtc_pdata), NULL, 0, 0);
 837         if (WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s.\n",
 838                         dev_name, oh->name))
 839                 return PTR_ERR(pdev);
 840         return 0;
 841 }
 842
 843 static struct omap_musb_board_data musb_board_data = {
 844         .interface_type = MUSB_INTERFACE_ULPI,
 845         /*
 846          * mode[0:3] = USB0PORT's mode
 847          * mode[4:7] = USB1PORT's mode
 848          * TX48 has USB0 in OTG mode and USB1 in host mode.
 849          */
 850         .mode = (MUSB_HOST << 4) | MUSB_OTG,
 851         .power = 500,
 852         .instances = 1,
 853 };
 854
 855 static void __iomem *am33xx_emif_base;
 856
 857 static void __iomem *__init am33xx_get_mem_ctlr(void)
 858 {
 859         am33xx_emif_base = ioremap(AM33XX_EMIF0_BASE, SZ_32K);
 860
 861         if (!am33xx_emif_base)
 862                 pr_warning("%s: Unable to map DDR2 controller", __func__);
 863
 864         return am33xx_emif_base;
 865 }
 866
 867 static struct resource am33xx_cpuidle_resources[] = {
 868         {
 869                 .start = AM33XX_EMIF0_BASE,
 870                 .end = AM33XX_EMIF0_BASE + SZ_32K - 1,
 871                 .flags = IORESOURCE_MEM,
 872         },
 873 };
 874
 875 /* AM33XX devices support DDR2 power down */
 876 static struct am33xx_cpuidle_config am33xx_cpuidle_pdata = {
 877 };
 878
 879 static struct platform_device am33xx_cpuidle_device = {
 880         .name = "cpuidle-am33xx",
 881         .num_resources = ARRAY_SIZE(am33xx_cpuidle_resources),
 882         .resource = am33xx_cpuidle_resources,
 883         .dev = {
 884                 .platform_data = &am33xx_cpuidle_pdata,
 885         },
 886 };
 887
 888 static void __init am33xx_cpuidle_init(void)
 889 {
 890         int ret;
 891
 892         am33xx_cpuidle_pdata.emif_base = am33xx_get_mem_ctlr();
 893
 894         ret = platform_device_register(&am33xx_cpuidle_device);
 895         if (ret)
 896                 pr_warning("AM33XX cpuidle registration failed\n");
 897
 898 }
 899
 900 static void __init am335x_tx48_init(void)
 901 {
 902         am33xx_cpuidle_init();
 903         am33xx_mux_init(NULL);
 904         omap_serial_init();
 905         uart0_init();
 906         uart1_init();
 907         uart5_init();
 908         tx48_nand_init();
 909         gpio_led_init();
 910         i2c0_init();
 911         stk5_rtc_init();
 912         rmii1_init();
 913         am33xx_cpsw_init(AM33XX_CPSW_MODE_RMII, NULL, NULL);
 914         omap_sdrc_init(NULL, NULL);
 915         enable_ehrpwm0();
 916         lcdc_init();
 917         mfd_tscadc_init();
 918         usb0_init();
 919         usb1_init();
 920         usb_musb_init(&musb_board_data);
 921         mmc1_init();
 922         mcasp1_init();
 923         d_can_init(0);
 924         d_can_init(1);
 925         spi0_init();
 926         matrix_keypad_init();
 927         /* Create an alias for icss clock */
 928         if (clk_add_alias("pruss", NULL, "pruss_uart_gclk", NULL))
 929                 pr_warn("failed to create an alias: icss_uart_gclk --> pruss\n");
 930         /* Create an alias for gfx/sgx clock */
 931         if (clk_add_alias("sgx_ck", NULL, "gfx_fclk", NULL))
 932                 pr_warn("failed to create an alias: gfx_fclk --> sgx_ck\n");
 933 }
 934
 935 static void __init am335x_tx48_map_io(void)
 936 {
 937         omap2_set_globals_am33xx();
 938         omapam33xx_map_common_io();
 939 }
 940
 941 MACHINE_START(TX48, "am335x-tx48")
 942         /* Maintainer: Ka-Ro electronics GmbH */
 943         .map_io         = am335x_tx48_map_io,
 944         .init_early     = am33xx_init_early,
 945         .init_irq       = ti81xx_init_irq,
 946         .handle_irq     = omap3_intc_handle_irq,
 947         .timer          = &omap3_am33xx_timer,
 948         .init_machine   = am335x_tx48_init,
 949 MACHINE_END