arch/arm/mach-mx6/board-mx6q_arm2.c

   1 /*
   2  * Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19
  20 #include <linux/types.h>
  21 #include <linux/sched.h>
  22 #include <linux/delay.h>
  23 #include <linux/pm.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/irq.h>
  26 #include <linux/init.h>
  27 #include <linux/input.h>
  28 #include <linux/nodemask.h>
  29 #include <linux/clk.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/fsl_devices.h>
  32 #include <linux/smsc911x.h>
  33 #include <linux/spi/spi.h>
  34 #include <linux/spi/flash.h>
  35 #include <linux/i2c.h>
  36 #include <linux/i2c/pca953x.h>
  37 #include <linux/ata.h>
  38 #include <linux/mtd/mtd.h>
  39 #include <linux/mtd/map.h>
  40 #include <linux/mtd/partitions.h>
  41 #include <linux/regulator/consumer.h>
  42 #include <linux/pmic_external.h>
  43 #include <linux/pmic_status.h>
  44 #include <linux/ipu.h>
  45 #include <linux/mxcfb.h>
  46 #include <linux/pwm_backlight.h>
  47 #include <linux/fec.h>
  48 #include <linux/memblock.h>
  49 #include <linux/gpio.h>
  50 #include <linux/etherdevice.h>
  51 #include <linux/regulator/anatop-regulator.h>
  52 #include <linux/regulator/consumer.h>
  53 #include <linux/regulator/machine.h>
  54 #include <linux/regulator/fixed.h>
  55
  56 #include <mach/common.h>
  57 #include <mach/hardware.h>
  58 #include <mach/mxc_dvfs.h>
  59 #include <mach/memory.h>
  60 #include <mach/iomux-mx6q.h>
  61 #include <mach/imx-uart.h>
  62 #include <mach/viv_gpu.h>
  63 #include <mach/ahci_sata.h>
  64 #include <mach/ipu-v3.h>
  65 #include <mach/mxc_hdmi.h>
  66 #include <mach/mxc_asrc.h>
  67 #include <mach/mipi_dsi.h>
  68
  69 #include <asm/irq.h>
  70 #include <asm/setup.h>
  71 #include <asm/mach-types.h>
  72 #include <asm/mach/arch.h>
  73 #include <asm/mach/time.h>
  74
  75 #include "usb.h"
  76 #include "devices-imx6q.h"
  77 #include "crm_regs.h"
  78 #include "cpu_op-mx6.h"
  79
  80 #define MX6Q_ARM2_LDB_BACKLIGHT IMX_GPIO_NR(1, 9)
  81 #define MX6Q_ARM2_ECSPI1_CS0    IMX_GPIO_NR(2, 30)
  82 #define MX6Q_ARM2_ECSPI1_CS1    IMX_GPIO_NR(3, 19)
  83 #define MX6Q_ARM2_DISP0_PWR     IMX_GPIO_NR(3, 24)
  84 #define MX6Q_ARM2_DISP0_I2C_EN  IMX_GPIO_NR(3, 28)
  85 #define MX6Q_ARM2_DISP0_DET_INT IMX_GPIO_NR(3, 31)
  86 #define MX6Q_ARM2_DISP0_RESET   IMX_GPIO_NR(5, 0)
  87 #define MX6Q_ARM2_SD3_CD        IMX_GPIO_NR(6, 11)
  88 #define MX6Q_ARM2_SD3_WP        IMX_GPIO_NR(6, 14)
  89 #define MX6Q_ARM2_USB_OTG_PWR   IMX_GPIO_NR(3, 22)
  90 #define MX6Q_ARM2_MAX7310_1_BASE_ADDR   IMX_GPIO_NR(8, 0)
  91 #define MX6Q_ARM2_MAX7310_2_BASE_ADDR   IMX_GPIO_NR(8, 8)
  92 #define MX6Q_ARM2_CAP_TCH_INT   IMX_GPIO_NR(3, 31)
  93
  94
  95 #define MX6Q_SMD_CSI0_RST               IMX_GPIO_NR(4, 5)
  96 #define MX6Q_SMD_CSI0_PWN               IMX_GPIO_NR(5, 23)
  97
  98 void __init early_console_setup(unsigned long base, struct clk *clk);
  99 static struct clk *sata_clk;
 100 static int esai_record;
 101
 102 extern struct regulator *(*get_cpu_regulator)(void);
 103 extern void (*put_cpu_regulator)(void);
 104 extern int (*set_cpu_voltage)(u32 volt);
 105 extern int mx6_set_cpu_voltage(u32 cpu_volt);
 106 static struct regulator *cpu_regulator;
 107 static char *gp_reg_id;
 108
 109 static iomux_v3_cfg_t mx6q_arm2_pads[] = {
 110
 111         /* UART4 for debug */
 112         MX6Q_PAD_KEY_COL0__UART4_TXD,
 113         MX6Q_PAD_KEY_ROW0__UART4_RXD,
 114
 115         /* ENET */
 116         MX6Q_PAD_KEY_COL1__ENET_MDIO,
 117         MX6Q_PAD_KEY_COL2__ENET_MDC,
 118         MX6Q_PAD_RGMII_TXC__ENET_RGMII_TXC,
 119         MX6Q_PAD_RGMII_TD0__ENET_RGMII_TD0,
 120         MX6Q_PAD_RGMII_TD1__ENET_RGMII_TD1,
 121         MX6Q_PAD_RGMII_TD2__ENET_RGMII_TD2,
 122         MX6Q_PAD_RGMII_TD3__ENET_RGMII_TD3,
 123         MX6Q_PAD_RGMII_TX_CTL__ENET_RGMII_TX_CTL,
 124         MX6Q_PAD_ENET_REF_CLK__ENET_TX_CLK,
 125         MX6Q_PAD_RGMII_RXC__ENET_RGMII_RXC,
 126         MX6Q_PAD_RGMII_RD0__ENET_RGMII_RD0,
 127         MX6Q_PAD_RGMII_RD1__ENET_RGMII_RD1,
 128         MX6Q_PAD_RGMII_RD2__ENET_RGMII_RD2,
 129         MX6Q_PAD_RGMII_RD3__ENET_RGMII_RD3,
 130         MX6Q_PAD_RGMII_RX_CTL__ENET_RGMII_RX_CTL,
 131         /* MCLK for csi0 */
 132         MX6Q_PAD_GPIO_0__CCM_CLKO,
 133         MX6Q_PAD_GPIO_3__CCM_CLKO2,
 134
 135         /* SD1 */
 136         MX6Q_PAD_SD1_CLK__USDHC1_CLK,
 137         MX6Q_PAD_SD1_CMD__USDHC1_CMD,
 138         MX6Q_PAD_SD1_DAT0__USDHC1_DAT0,
 139         MX6Q_PAD_SD1_DAT1__USDHC1_DAT1,
 140         MX6Q_PAD_SD1_DAT2__USDHC1_DAT2,
 141         MX6Q_PAD_SD1_DAT3__USDHC1_DAT3,
 142         /* SD2 */
 143         MX6Q_PAD_SD2_CLK__USDHC2_CLK,
 144         MX6Q_PAD_SD2_CMD__USDHC2_CMD,
 145         MX6Q_PAD_SD2_DAT0__USDHC2_DAT0,
 146         MX6Q_PAD_SD2_DAT1__USDHC2_DAT1,
 147         MX6Q_PAD_SD2_DAT2__USDHC2_DAT2,
 148         MX6Q_PAD_SD2_DAT3__USDHC2_DAT3,
 149         /* SD3 */
 150         MX6Q_PAD_SD3_CLK__USDHC3_CLK_50MHZ,
 151         MX6Q_PAD_SD3_CMD__USDHC3_CMD_50MHZ,
 152         MX6Q_PAD_SD3_DAT0__USDHC3_DAT0_50MHZ,
 153         MX6Q_PAD_SD3_DAT1__USDHC3_DAT1_50MHZ,
 154         MX6Q_PAD_SD3_DAT2__USDHC3_DAT2_50MHZ,
 155         MX6Q_PAD_SD3_DAT3__USDHC3_DAT3_50MHZ,
 156         MX6Q_PAD_SD3_DAT4__USDHC3_DAT4_50MHZ,
 157         MX6Q_PAD_SD3_DAT5__USDHC3_DAT5_50MHZ,
 158         MX6Q_PAD_SD3_DAT6__USDHC3_DAT6_50MHZ,
 159         MX6Q_PAD_SD3_DAT7__USDHC3_DAT7_50MHZ,
 160         MX6Q_PAD_SD3_RST__USDHC3_RST,
 161         /* SD3 VSelect */
 162         MX6Q_PAD_GPIO_18__USDHC3_VSELECT,
 163         /* SD3_CD and SD3_WP */
 164         MX6Q_PAD_NANDF_CS0__GPIO_6_11,
 165         MX6Q_PAD_NANDF_CS1__GPIO_6_14,
 166         /* SD4 */
 167         MX6Q_PAD_SD4_CLK__USDHC4_CLK_50MHZ,
 168         MX6Q_PAD_SD4_CMD__USDHC4_CMD_50MHZ,
 169         MX6Q_PAD_SD4_DAT0__USDHC4_DAT0_50MHZ,
 170         MX6Q_PAD_SD4_DAT1__USDHC4_DAT1_50MHZ,
 171         MX6Q_PAD_SD4_DAT2__USDHC4_DAT2_50MHZ,
 172         MX6Q_PAD_SD4_DAT3__USDHC4_DAT3_50MHZ,
 173         MX6Q_PAD_SD4_DAT4__USDHC4_DAT4_50MHZ,
 174         MX6Q_PAD_SD4_DAT5__USDHC4_DAT5_50MHZ,
 175         MX6Q_PAD_SD4_DAT6__USDHC4_DAT6_50MHZ,
 176         MX6Q_PAD_SD4_DAT7__USDHC4_DAT7_50MHZ,
 177         MX6Q_PAD_NANDF_ALE__USDHC4_RST,
 178         /* eCSPI1 */
 179         MX6Q_PAD_EIM_EB2__ECSPI1_SS0,
 180         MX6Q_PAD_EIM_D16__ECSPI1_SCLK,
 181         MX6Q_PAD_EIM_D17__ECSPI1_MISO,
 182         MX6Q_PAD_EIM_D18__ECSPI1_MOSI,
 183         MX6Q_PAD_EIM_D19__ECSPI1_SS1,
 184         MX6Q_PAD_EIM_EB2__GPIO_2_30,    /*SS0*/
 185         MX6Q_PAD_EIM_D19__GPIO_3_19,    /*SS1*/
 186
 187         /* ESAI */
 188         MX6Q_PAD_ENET_RXD0__ESAI1_HCKT,
 189         MX6Q_PAD_ENET_CRS_DV__ESAI1_SCKT,
 190         MX6Q_PAD_ENET_RXD1__ESAI1_FST,
 191         MX6Q_PAD_ENET_TX_EN__ESAI1_TX3_RX2,
 192         MX6Q_PAD_ENET_TXD1__ESAI1_TX2_RX3,
 193         MX6Q_PAD_ENET_TXD0__ESAI1_TX4_RX1,
 194         MX6Q_PAD_ENET_MDC__ESAI1_TX5_RX0,
 195         MX6Q_PAD_NANDF_CS2__ESAI1_TX0,
 196         MX6Q_PAD_NANDF_CS3__ESAI1_TX1,
 197
 198         /* I2C1 */
 199         MX6Q_PAD_CSI0_DAT8__I2C1_SDA,
 200         MX6Q_PAD_CSI0_DAT9__I2C1_SCL,
 201
 202         /* I2C2 */
 203         MX6Q_PAD_KEY_COL3__I2C2_SCL,
 204         MX6Q_PAD_KEY_ROW3__I2C2_SDA,
 205
 206         /* DISPLAY */
 207         MX6Q_PAD_DI0_DISP_CLK__IPU1_DI0_DISP_CLK,
 208         MX6Q_PAD_DI0_PIN15__IPU1_DI0_PIN15,
 209         MX6Q_PAD_DI0_PIN2__IPU1_DI0_PIN2,
 210         MX6Q_PAD_DI0_PIN3__IPU1_DI0_PIN3,
 211         MX6Q_PAD_DISP0_DAT0__IPU1_DISP0_DAT_0,
 212         MX6Q_PAD_DISP0_DAT1__IPU1_DISP0_DAT_1,
 213         MX6Q_PAD_DISP0_DAT2__IPU1_DISP0_DAT_2,
 214         MX6Q_PAD_DISP0_DAT3__IPU1_DISP0_DAT_3,
 215         MX6Q_PAD_DISP0_DAT4__IPU1_DISP0_DAT_4,
 216         MX6Q_PAD_DISP0_DAT5__IPU1_DISP0_DAT_5,
 217         MX6Q_PAD_DISP0_DAT6__IPU1_DISP0_DAT_6,
 218         MX6Q_PAD_DISP0_DAT7__IPU1_DISP0_DAT_7,
 219         MX6Q_PAD_DISP0_DAT8__IPU1_DISP0_DAT_8,
 220         MX6Q_PAD_DISP0_DAT9__IPU1_DISP0_DAT_9,
 221         MX6Q_PAD_DISP0_DAT10__IPU1_DISP0_DAT_10,
 222         MX6Q_PAD_DISP0_DAT11__IPU1_DISP0_DAT_11,
 223         MX6Q_PAD_DISP0_DAT12__IPU1_DISP0_DAT_12,
 224         MX6Q_PAD_DISP0_DAT13__IPU1_DISP0_DAT_13,
 225         MX6Q_PAD_DISP0_DAT14__IPU1_DISP0_DAT_14,
 226         MX6Q_PAD_DISP0_DAT15__IPU1_DISP0_DAT_15,
 227         MX6Q_PAD_DISP0_DAT16__IPU1_DISP0_DAT_16,
 228         MX6Q_PAD_DISP0_DAT17__IPU1_DISP0_DAT_17,
 229         MX6Q_PAD_DISP0_DAT18__IPU1_DISP0_DAT_18,
 230         MX6Q_PAD_DISP0_DAT19__IPU1_DISP0_DAT_19,
 231         MX6Q_PAD_DISP0_DAT20__IPU1_DISP0_DAT_20,
 232         MX6Q_PAD_DISP0_DAT21__IPU1_DISP0_DAT_21,
 233         MX6Q_PAD_DISP0_DAT22__IPU1_DISP0_DAT_22,
 234         MX6Q_PAD_DISP0_DAT23__IPU1_DISP0_DAT_23,
 235
 236         /* ipu1 csi0 */
 237         MX6Q_PAD_CSI0_DAT12__IPU1_CSI0_D_12,
 238         MX6Q_PAD_CSI0_DAT13__IPU1_CSI0_D_13,
 239         MX6Q_PAD_CSI0_DAT14__IPU1_CSI0_D_14,
 240         MX6Q_PAD_CSI0_DAT15__IPU1_CSI0_D_15,
 241         MX6Q_PAD_CSI0_DAT16__IPU1_CSI0_D_16,
 242         MX6Q_PAD_CSI0_DAT17__IPU1_CSI0_D_17,
 243         MX6Q_PAD_CSI0_DAT18__IPU1_CSI0_D_18,
 244         MX6Q_PAD_CSI0_DAT19__IPU1_CSI0_D_19,
 245         MX6Q_PAD_CSI0_VSYNC__IPU1_CSI0_VSYNC,
 246         MX6Q_PAD_CSI0_MCLK__IPU1_CSI0_HSYNC,
 247         MX6Q_PAD_CSI0_PIXCLK__IPU1_CSI0_PIXCLK,
 248         /* camera reset */
 249         MX6Q_PAD_GPIO_19__GPIO_4_5,
 250         /* camera powerdown */
 251         MX6Q_PAD_CSI0_DAT5__GPIO_5_23,
 252
 253         MX6Q_PAD_EIM_D24__GPIO_3_24,
 254
 255         /* PWM1 */
 256         MX6Q_PAD_GPIO_9__PWM1_PWMO,
 257
 258         /* DISP0 I2C ENABLE*/
 259         MX6Q_PAD_EIM_D28__GPIO_3_28,
 260
 261         /* DISP0 DET */
 262         MX6Q_PAD_EIM_D31__GPIO_3_31,
 263
 264         /* DISP0 RESET */
 265         MX6Q_PAD_EIM_WAIT__GPIO_5_0,
 266
 267         /* I2C3 */
 268         MX6Q_PAD_GPIO_5__I2C3_SCL,
 269         MX6Q_PAD_GPIO_16__I2C3_SDA,
 270
 271         /* HDMI */
 272         MX6Q_PAD_EIM_A25__HDMI_TX_CEC_LINE,
 273         MX6Q_PAD_SD1_DAT1__HDMI_TX_OPHYDTB_0,
 274         MX6Q_PAD_SD1_DAT0__HDMI_TX_OPHYDTB_1,
 275
 276         /* USBOTG ID pin */
 277         MX6Q_PAD_GPIO_1__USBOTG_ID,
 278
 279         /* SPDIF */
 280         MX6Q_PAD_GPIO_16__SPDIF_IN1,
 281         MX6Q_PAD_GPIO_17__SPDIF_OUT1,
 282 };
 283
 284 static iomux_v3_cfg_t mx6q_arm2_esai_record_pads[] = {
 285         MX6Q_PAD_ENET_RX_ER__ESAI1_HCKR,
 286         MX6Q_PAD_ENET_MDIO__ESAI1_SCKR,
 287         MX6Q_PAD_ENET_REF_CLK__ESAI1_FSR,
 288 };
 289
 290 #define MX6Q_USDHC_PAD_SETTING(id, speed)       \
 291 mx6q_sd##id##_##speed##mhz[] = {                \
 292         MX6Q_PAD_SD##id##_CLK__USDHC##id##_CLK_##speed##MHZ,    \
 293         MX6Q_PAD_SD##id##_CMD__USDHC##id##_CMD_##speed##MHZ,    \
 294         MX6Q_PAD_SD##id##_DAT0__USDHC##id##_DAT0_##speed##MHZ,  \
 295         MX6Q_PAD_SD##id##_DAT1__USDHC##id##_DAT1_##speed##MHZ,  \
 296         MX6Q_PAD_SD##id##_DAT2__USDHC##id##_DAT2_##speed##MHZ,  \
 297         MX6Q_PAD_SD##id##_DAT3__USDHC##id##_DAT3_##speed##MHZ,  \
 298         MX6Q_PAD_SD##id##_DAT4__USDHC##id##_DAT4_##speed##MHZ,  \
 299         MX6Q_PAD_SD##id##_DAT5__USDHC##id##_DAT5_##speed##MHZ,  \
 300         MX6Q_PAD_SD##id##_DAT6__USDHC##id##_DAT6_##speed##MHZ,  \
 301         MX6Q_PAD_SD##id##_DAT7__USDHC##id##_DAT7_##speed##MHZ,  \
 302 }
 303
 304 static iomux_v3_cfg_t MX6Q_USDHC_PAD_SETTING(3, 50);
 305 static iomux_v3_cfg_t MX6Q_USDHC_PAD_SETTING(3, 100);
 306 static iomux_v3_cfg_t MX6Q_USDHC_PAD_SETTING(3, 200);
 307 static iomux_v3_cfg_t MX6Q_USDHC_PAD_SETTING(4, 50);
 308 static iomux_v3_cfg_t MX6Q_USDHC_PAD_SETTING(4, 100);
 309 static iomux_v3_cfg_t MX6Q_USDHC_PAD_SETTING(4, 200);
 310
 311 enum sd_pad_mode {
 312         SD_PAD_MODE_LOW_SPEED,
 313         SD_PAD_MODE_MED_SPEED,
 314         SD_PAD_MODE_HIGH_SPEED,
 315 };
 316
 317 static int plt_sd3_pad_change(int clock)
 318 {
 319         static enum sd_pad_mode pad_mode = SD_PAD_MODE_LOW_SPEED;
 320
 321         if (clock > 100000000) {
 322                 if (pad_mode == SD_PAD_MODE_HIGH_SPEED)
 323                         return 0;
 324
 325                 pad_mode = SD_PAD_MODE_HIGH_SPEED;
 326                 return mxc_iomux_v3_setup_multiple_pads(mx6q_sd3_200mhz,
 327                                         ARRAY_SIZE(mx6q_sd3_200mhz));
 328         } else if (clock > 52000000) {
 329                 if (pad_mode == SD_PAD_MODE_MED_SPEED)
 330                         return 0;
 331
 332                 pad_mode = SD_PAD_MODE_MED_SPEED;
 333                 return mxc_iomux_v3_setup_multiple_pads(mx6q_sd3_100mhz,
 334                                         ARRAY_SIZE(mx6q_sd3_100mhz));
 335         } else {
 336                 if (pad_mode == SD_PAD_MODE_LOW_SPEED)
 337                         return 0;
 338
 339                 pad_mode = SD_PAD_MODE_LOW_SPEED;
 340                 return mxc_iomux_v3_setup_multiple_pads(mx6q_sd3_50mhz,
 341                                         ARRAY_SIZE(mx6q_sd3_50mhz));
 342         }
 343 }
 344
 345 static int plt_sd4_pad_change(int clock)
 346 {
 347         static enum sd_pad_mode pad_mode = SD_PAD_MODE_LOW_SPEED;
 348
 349         if (clock > 100000000) {
 350                 if (pad_mode == SD_PAD_MODE_HIGH_SPEED)
 351                         return 0;
 352
 353                 pad_mode = SD_PAD_MODE_HIGH_SPEED;
 354                 return mxc_iomux_v3_setup_multiple_pads(mx6q_sd4_200mhz,
 355                                         ARRAY_SIZE(mx6q_sd4_200mhz));
 356         } else if (clock > 52000000) {
 357                 if (pad_mode == SD_PAD_MODE_MED_SPEED)
 358                         return 0;
 359
 360                 pad_mode = SD_PAD_MODE_MED_SPEED;
 361                 return mxc_iomux_v3_setup_multiple_pads(mx6q_sd4_100mhz,
 362                                         ARRAY_SIZE(mx6q_sd4_100mhz));
 363         } else {
 364                 if (pad_mode == SD_PAD_MODE_LOW_SPEED)
 365                         return 0;
 366
 367                 pad_mode = SD_PAD_MODE_LOW_SPEED;
 368                 return mxc_iomux_v3_setup_multiple_pads(mx6q_sd4_50mhz,
 369                                         ARRAY_SIZE(mx6q_sd4_50mhz));
 370         }
 371 }
 372
 373 static const struct esdhc_platform_data mx6q_arm2_sd3_data __initconst = {
 374         .cd_gpio = MX6Q_ARM2_SD3_CD,
 375         .wp_gpio = MX6Q_ARM2_SD3_WP,
 376         .support_18v = 1,
 377         .support_8bit = 1,
 378         .delay_line = 0,
 379         .platform_pad_change = plt_sd3_pad_change,
 380 };
 381
 382 /* No card detect signal for SD4 */
 383 static const struct esdhc_platform_data mx6q_arm2_sd4_data __initconst = {
 384         .always_present = 1,
 385         .support_8bit = 1,
 386         .platform_pad_change = plt_sd4_pad_change,
 387 };
 388
 389 /* The GPMI is conflicted with SD3, so init this in the driver. */
 390 static iomux_v3_cfg_t mx6q_gpmi_nand[] __initdata = {
 391         MX6Q_PAD_NANDF_CLE__RAWNAND_CLE,
 392         MX6Q_PAD_NANDF_ALE__RAWNAND_ALE,
 393         MX6Q_PAD_NANDF_CS0__RAWNAND_CE0N,
 394         MX6Q_PAD_NANDF_CS1__RAWNAND_CE1N,
 395         MX6Q_PAD_NANDF_CS2__RAWNAND_CE2N,
 396         MX6Q_PAD_NANDF_CS3__RAWNAND_CE3N,
 397         MX6Q_PAD_NANDF_RB0__RAWNAND_READY0,
 398         MX6Q_PAD_SD4_DAT0__RAWNAND_DQS,
 399         MX6Q_PAD_NANDF_D0__RAWNAND_D0,
 400         MX6Q_PAD_NANDF_D1__RAWNAND_D1,
 401         MX6Q_PAD_NANDF_D2__RAWNAND_D2,
 402         MX6Q_PAD_NANDF_D3__RAWNAND_D3,
 403         MX6Q_PAD_NANDF_D4__RAWNAND_D4,
 404         MX6Q_PAD_NANDF_D5__RAWNAND_D5,
 405         MX6Q_PAD_NANDF_D6__RAWNAND_D6,
 406         MX6Q_PAD_NANDF_D7__RAWNAND_D7,
 407         MX6Q_PAD_SD4_CMD__RAWNAND_RDN,
 408         MX6Q_PAD_SD4_CLK__RAWNAND_WRN,
 409         MX6Q_PAD_NANDF_WP_B__RAWNAND_RESETN,
 410 };
 411
 412 static int gpmi_nfc_platform_init(void)
 413 {
 414         return mxc_iomux_v3_setup_multiple_pads(mx6q_gpmi_nand,
 415                                         ARRAY_SIZE(mx6q_gpmi_nand));
 416 }
 417
 418 static const struct gpmi_nfc_platform_data
 419 mx6q_gpmi_nfc_platform_data __initconst = {
 420         .platform_init           = gpmi_nfc_platform_init,
 421         .min_prop_delay_in_ns    = 5,
 422         .max_prop_delay_in_ns    = 9,
 423         .max_chip_count          = 1,
 424 };
 425
 426 static const struct anatop_thermal_platform_data
 427         mx6q_arm2_anatop_thermal_data __initconst = {
 428         .name = "anatop_thermal",
 429 };
 430
 431 static inline void mx6q_arm2_init_uart(void)
 432 {
 433         imx6q_add_imx_uart(0, NULL);
 434         imx6q_add_imx_uart(1, NULL);
 435         imx6q_add_imx_uart(3, NULL);
 436 }
 437
 438 static int mx6q_arm2_fec_phy_init(struct phy_device *phydev)
 439 {
 440         unsigned short val;
 441
 442         /* To enable AR8031 ouput a 125MHz clk from CLK_25M */
 443         phy_write(phydev, 0xd, 0x7);
 444         phy_write(phydev, 0xe, 0x8016);
 445         phy_write(phydev, 0xd, 0x4007);
 446         val = phy_read(phydev, 0xe);
 447
 448         val &= 0xffe3;
 449         val |= 0x18;
 450         phy_write(phydev, 0xe, val);
 451
 452         /* introduce tx clock delay */
 453         phy_write(phydev, 0x1d, 0x5);
 454         val = phy_read(phydev, 0x1e);
 455         val |= 0x0100;
 456         phy_write(phydev, 0x1e, val);
 457
 458         return 0;
 459 }
 460
 461 static struct fec_platform_data fec_data __initdata = {
 462         .init = mx6q_arm2_fec_phy_init,
 463         .phy = PHY_INTERFACE_MODE_RGMII,
 464 };
 465
 466 static inline void imx6q_init_fec(void)
 467 {
 468         random_ether_addr(fec_data.mac);
 469         imx6q_add_fec(&fec_data);
 470 }
 471
 472 static int mx6q_arm2_spi_cs[] = {
 473         MX6Q_ARM2_ECSPI1_CS0,
 474         MX6Q_ARM2_ECSPI1_CS1,
 475 };
 476
 477 static const struct spi_imx_master mx6q_arm2_spi_data __initconst = {
 478         .chipselect     = mx6q_arm2_spi_cs,
 479         .num_chipselect = ARRAY_SIZE(mx6q_arm2_spi_cs),
 480 };
 481
 482 #if defined(CONFIG_MTD_M25P80) || defined(CONFIG_MTD_M25P80_MODULE)
 483 static struct mtd_partition m25p32_partitions[] = {
 484         {
 485                 .name = "bootloader",
 486                 .offset = 0,
 487                 .size = 0x00040000,
 488         },
 489         {
 490                 .name = "kernel",
 491                 .offset = MTDPART_OFS_APPEND,
 492                 .size = MTDPART_SIZ_FULL,
 493         },
 494 };
 495
 496 static struct flash_platform_data m25p32_spi_flash_data = {
 497         .name = "m25p32",
 498         .parts = m25p32_partitions,
 499         .nr_parts = ARRAY_SIZE(m25p32_partitions),
 500         .type = "m25p32",
 501 };
 502 #endif
 503
 504 static struct spi_board_info m25p32_spi0_board_info[] __initdata = {
 505 #if defined(CONFIG_MTD_M25P80)
 506         {
 507                 /* The modalias must be the same as spi device driver name */
 508                 .modalias = "m25p80",
 509                 .max_speed_hz = 20000000,
 510                 .bus_num = 0,
 511                 .chip_select = 1,
 512                 .platform_data = &m25p32_spi_flash_data,
 513         },
 514 #endif
 515 };
 516
 517 static void spi_device_init(void)
 518 {
 519         spi_register_board_info(m25p32_spi0_board_info,
 520                                 ARRAY_SIZE(m25p32_spi0_board_info));
 521 }
 522
 523 static int max7310_1_setup(struct i2c_client *client,
 524         unsigned gpio_base, unsigned ngpio,
 525         void *context)
 526 {
 527         int max7310_gpio_value[] = {
 528                 0, 1, 0, 1, 0, 0, 0, 0,
 529         };
 530
 531         int n;
 532
 533          for (n = 0; n < ARRAY_SIZE(max7310_gpio_value); ++n) {
 534                 gpio_request(gpio_base + n, "MAX7310 1 GPIO Expander");
 535                 if (max7310_gpio_value[n] < 0)
 536                         gpio_direction_input(gpio_base + n);
 537                 else
 538                         gpio_direction_output(gpio_base + n,
 539                                                 max7310_gpio_value[n]);
 540                 gpio_export(gpio_base + n, 0);
 541         }
 542
 543         return 0;
 544 }
 545
 546 static struct pca953x_platform_data max7310_platdata = {
 547         .gpio_base      = MX6Q_ARM2_MAX7310_1_BASE_ADDR,
 548         .invert         = 0,
 549         .setup          = max7310_1_setup,
 550 };
 551
 552 static int max7310_u48_setup(struct i2c_client *client,
 553         unsigned gpio_base, unsigned ngpio,
 554         void *context)
 555 {
 556         int max7310_gpio_value[] = {
 557                 0, 1, 1, 1, 0, 0, 0, 0,
 558         };
 559
 560         int n;
 561
 562          for (n = 0; n < ARRAY_SIZE(max7310_gpio_value); ++n) {
 563                 gpio_request(gpio_base + n, "MAX7310 U48 GPIO Expander");
 564                 if (max7310_gpio_value[n] < 0)
 565                         gpio_direction_input(gpio_base + n);
 566                 else
 567                         gpio_direction_output(gpio_base + n,
 568                                                 max7310_gpio_value[n]);
 569                 gpio_export(gpio_base + n, 0);
 570         }
 571
 572         return 0;
 573 }
 574
 575 static struct pca953x_platform_data max7310_u48_platdata = {
 576         .gpio_base      = MX6Q_ARM2_MAX7310_2_BASE_ADDR,
 577         .invert         = 0,
 578         .setup          = max7310_u48_setup,
 579 };
 580
 581 static void ddc_dvi_init(void)
 582 {
 583         /* enable DVI I2C */
 584         gpio_set_value(MX6Q_ARM2_DISP0_I2C_EN, 1);
 585 }
 586
 587 static int ddc_dvi_update(void)
 588 {
 589         /* DVI cable state */
 590         if (gpio_get_value(MX6Q_ARM2_DISP0_DET_INT) == 1)
 591                 return 1;
 592         else
 593                 return 0;
 594 }
 595
 596 static struct fsl_mxc_dvi_platform_data sabr_ddc_dvi_data = {
 597         .ipu_id = 0,
 598         .disp_id = 0,
 599         .init = ddc_dvi_init,
 600         .update = ddc_dvi_update,
 601 };
 602
 603 static struct fsl_mxc_camera_platform_data camera_data = {
 604         .analog_regulator = "DA9052_LDO7",
 605         .core_regulator = "DA9052_LDO9",
 606         .mclk = 24000000,
 607         .csi = 0,
 608 };
 609
 610 static struct i2c_board_info mxc_i2c0_board_info[] __initdata = {
 611         {
 612                 I2C_BOARD_INFO("cs42888", 0x48),
 613         },
 614         {
 615                 I2C_BOARD_INFO("ov3640", 0x3c),
 616                 .platform_data = (void *)&camera_data,
 617         },
 618 };
 619
 620 static struct imxi2c_platform_data mx6q_arm2_i2c_data = {
 621         .bitrate = 400000,
 622 };
 623
 624 static struct imxi2c_platform_data mx6q_arm2_i2c0_data = {
 625         .bitrate = 100000,
 626 };
 627
 628 static struct i2c_board_info mxc_i2c2_board_info[] __initdata = {
 629         {
 630                 I2C_BOARD_INFO("max7310", 0x1F),
 631                 .platform_data = &max7310_platdata,
 632         },
 633         {
 634                 I2C_BOARD_INFO("max7310", 0x1B),
 635                 .platform_data = &max7310_u48_platdata,
 636         },
 637         {
 638                 I2C_BOARD_INFO("mxc_dvi", 0x50),
 639                 .platform_data = &sabr_ddc_dvi_data,
 640                 .irq = gpio_to_irq(MX6Q_ARM2_DISP0_DET_INT),
 641         },
 642         {
 643                 I2C_BOARD_INFO("egalax_ts", 0x4),
 644                 .irq = gpio_to_irq(MX6Q_ARM2_CAP_TCH_INT),
 645         },
 646
 647 };
 648
 649 static struct i2c_board_info mxc_i2c1_board_info[] __initdata = {
 650         {
 651                 I2C_BOARD_INFO("egalax_ts", 0x4),
 652                 .irq = gpio_to_irq(MX6Q_ARM2_CAP_TCH_INT),
 653         },
 654         {
 655                 I2C_BOARD_INFO("mxc_hdmi_i2c", 0x50),
 656         },
 657 };
 658
 659 static void imx6q_arm2_usbotg_vbus(bool on)
 660 {
 661         if (on)
 662                 gpio_set_value(MX6Q_ARM2_USB_OTG_PWR, 1);
 663         else
 664                 gpio_set_value(MX6Q_ARM2_USB_OTG_PWR, 0);
 665 }
 666
 667 static void __init imx6q_arm2_init_usb(void)
 668 {
 669         int ret = 0;
 670
 671         imx_otg_base = MX6_IO_ADDRESS(MX6Q_USB_OTG_BASE_ADDR);
 672         /* disable external charger detect,
 673          * or it will affect signal quality at dp.
 674          */
 675
 676         ret = gpio_request(MX6Q_ARM2_USB_OTG_PWR, "usb-pwr");
 677         if (ret) {
 678                 printk(KERN_ERR"failed to get GPIO MX6Q_ARM2_USB_OTG_PWR:"
 679                         " %d\n", ret);
 680                 return;
 681         }
 682         gpio_direction_output(MX6Q_ARM2_USB_OTG_PWR, 0);
 683         mxc_iomux_set_gpr_register(1, 13, 1, 1);
 684
 685         mx6_set_otghost_vbus_func(imx6q_arm2_usbotg_vbus);
 686         mx6_usb_dr_init();
 687         mx6_usb_h1_init();
 688 }
 689 static struct viv_gpu_platform_data imx6q_gpu_pdata __initdata = {
 690         .reserved_mem_size = SZ_128M,
 691 };
 692
 693 /* HW Initialization, if return 0, initialization is successful. */
 694 static int mx6q_arm2_sata_init(struct device *dev, void __iomem *addr)
 695 {
 696         u32 tmpdata;
 697         int ret = 0;
 698         struct clk *clk;
 699
 700         /* Enable SATA PWR CTRL_0 of MAX7310 */
 701         gpio_request(MX6Q_ARM2_MAX7310_1_BASE_ADDR, "SATA_PWR_EN");
 702         gpio_direction_output(MX6Q_ARM2_MAX7310_1_BASE_ADDR, 1);
 703
 704         sata_clk = clk_get(dev, "imx_sata_clk");
 705         if (IS_ERR(sata_clk)) {
 706                 dev_err(dev, "no sata clock.\n");
 707                 return PTR_ERR(sata_clk);
 708         }
 709         ret = clk_enable(sata_clk);
 710         if (ret) {
 711                 dev_err(dev, "can't enable sata clock.\n");
 712                 goto put_sata_clk;
 713         }
 714
 715         /* Set PHY Paremeters, two steps to configure the GPR13,
 716          * one write for rest of parameters, mask of first write is 0x07FFFFFD,
 717          * and the other one write for setting the mpll_clk_off_b
 718          *.rx_eq_val_0(iomuxc_gpr13[26:24]),
 719          *.los_lvl(iomuxc_gpr13[23:19]),
 720          *.rx_dpll_mode_0(iomuxc_gpr13[18:16]),
 721          *.sata_speed(iomuxc_gpr13[15]),
 722          *.mpll_ss_en(iomuxc_gpr13[14]),
 723          *.tx_atten_0(iomuxc_gpr13[13:11]),
 724          *.tx_boost_0(iomuxc_gpr13[10:7]),
 725          *.tx_lvl(iomuxc_gpr13[6:2]),
 726          *.mpll_ck_off(iomuxc_gpr13[1]),
 727          *.tx_edgerate_0(iomuxc_gpr13[0]),
 728          */
 729         tmpdata = readl(IOMUXC_GPR13);
 730         writel(((tmpdata & ~0x07FFFFFD) | 0x0593A044), IOMUXC_GPR13);
 731
 732         /* enable SATA_PHY PLL */
 733         tmpdata = readl(IOMUXC_GPR13);
 734         writel(((tmpdata & ~0x2) | 0x2), IOMUXC_GPR13);
 735
 736         /* Get the AHB clock rate, and configure the TIMER1MS reg later */
 737         clk = clk_get(NULL, "ahb");
 738         if (IS_ERR(clk)) {
 739                 dev_err(dev, "no ahb clock.\n");
 740                 ret = PTR_ERR(clk);
 741                 goto release_sata_clk;
 742         }
 743         tmpdata = clk_get_rate(clk) / 1000;
 744         clk_put(clk);
 745
 746         sata_init(addr, tmpdata);
 747
 748         return ret;
 749
 750 release_sata_clk:
 751         clk_disable(sata_clk);
 752 put_sata_clk:
 753         clk_put(sata_clk);
 754
 755         return ret;
 756 }
 757
 758 static void mx6q_arm2_sata_exit(struct device *dev)
 759 {
 760         clk_disable(sata_clk);
 761         clk_put(sata_clk);
 762
 763         /* Disable SATA PWR CTRL_0 of MAX7310 */
 764         gpio_request(MX6Q_ARM2_MAX7310_1_BASE_ADDR, "SATA_PWR_EN");
 765         gpio_direction_output(MX6Q_ARM2_MAX7310_1_BASE_ADDR, 0);
 766
 767 }
 768
 769 static struct ahci_platform_data mx6q_arm2_sata_data = {
 770         .init = mx6q_arm2_sata_init,
 771         .exit = mx6q_arm2_sata_exit,
 772 };
 773
 774 static struct imx_asrc_platform_data imx_asrc_data = {
 775         .channel_bits = 4,
 776         .clk_map_ver = 2,
 777 };
 778
 779 static void mx6q_sabreauto_reset_mipi_dsi(void)
 780 {
 781         gpio_set_value(MX6Q_ARM2_DISP0_PWR, 1);
 782         gpio_set_value(MX6Q_ARM2_DISP0_RESET, 1);
 783         udelay(10);
 784         gpio_set_value(MX6Q_ARM2_DISP0_RESET, 0);
 785         udelay(50);
 786         gpio_set_value(MX6Q_ARM2_DISP0_RESET, 1);
 787
 788         /*
 789          * it needs to delay 120ms minimum for reset complete
 790          */
 791         msleep(120);
 792 }
 793
 794 static struct mipi_dsi_platform_data mipi_dsi_pdata = {
 795         .ipu_id  = 0,
 796         .disp_id = 0,
 797         .lcd_panel = "TRULY-WVGA",
 798         .reset   = mx6q_sabreauto_reset_mipi_dsi,
 799 };
 800
 801 static struct ipuv3_fb_platform_data sabr_fb_data[] = {
 802         { /*fb0*/
 803         .disp_dev = "ldb",
 804         .interface_pix_fmt = IPU_PIX_FMT_RGB666,
 805         .mode_str = "LDB-XGA",
 806         .default_bpp = 16,
 807         .int_clk = false,
 808         }, {
 809         .disp_dev = "lcd",
 810         .interface_pix_fmt = IPU_PIX_FMT_RGB565,
 811         .mode_str = "CLAA-WVGA",
 812         .default_bpp = 16,
 813         .int_clk = false,
 814         }, {
 815         .disp_dev = "ldb",
 816         .interface_pix_fmt = IPU_PIX_FMT_RGB666,
 817         .mode_str = "LDB-XGA",
 818         .default_bpp = 16,
 819         .int_clk = false,
 820         },
 821 };
 822
 823 static void hdmi_init(int ipu_id, int disp_id)
 824 {
 825         int hdmi_mux_setting;
 826
 827         if ((ipu_id > 1) || (ipu_id < 0)) {
 828                 printk(KERN_ERR"Invalid IPU select for HDMI: %d. Set to 0\n",
 829                         ipu_id);
 830                 ipu_id = 0;
 831         }
 832
 833         if ((disp_id > 1) || (disp_id < 0)) {
 834                 printk(KERN_ERR"Invalid DI select for HDMI: %d. Set to 0\n",
 835                         disp_id);
 836                 disp_id = 0;
 837         }
 838
 839         /* Configure the connection between IPU1/2 and HDMI */
 840         hdmi_mux_setting = 2*ipu_id + disp_id;
 841
 842         /* GPR3, bits 2-3 = HDMI_MUX_CTL */
 843         mxc_iomux_set_gpr_register(3, 2, 2, hdmi_mux_setting);
 844 }
 845
 846 static struct fsl_mxc_hdmi_platform_data hdmi_data = {
 847         .init = hdmi_init,
 848 };
 849
 850 static struct fsl_mxc_hdmi_core_platform_data hdmi_core_data = {
 851         .ipu_id = 0,
 852         .disp_id = 0,
 853 };
 854
 855 static struct fsl_mxc_lcd_platform_data lcdif_data = {
 856         .ipu_id = 0,
 857         .disp_id = 0,
 858         .default_ifmt = IPU_PIX_FMT_RGB565,
 859 };
 860
 861 static struct fsl_mxc_ldb_platform_data ldb_data = {
 862         .ipu_id = 0,
 863         .disp_id = 1,
 864         .ext_ref = 1,
 865         .mode = LDB_SEP0,
 866         .sec_ipu_id = 1,
 867         .sec_disp_id = 1,
 868 };
 869
 870 static struct imx_ipuv3_platform_data ipu_data[] = {
 871         {
 872         .rev = 4,
 873         .csi_clk[0] = "ccm_clk0",
 874         }, {
 875         .rev = 4,
 876         .csi_clk[0] = "ccm_clk0",
 877         },
 878 };
 879
 880 static struct platform_pwm_backlight_data mx6_arm2_pwm_backlight_data = {
 881         .pwm_id = 0,
 882         .max_brightness = 255,
 883         .dft_brightness = 128,
 884         .pwm_period_ns = 50000,
 885 };
 886
 887 static void arm2_suspend_enter(void)
 888 {
 889         /* suspend preparation */
 890 }
 891
 892 static void arm2_suspend_exit(void)
 893 {
 894         /* resmue resore */
 895 }
 896 static const struct pm_platform_data mx6q_arm2_pm_data __initconst = {
 897         .name = "imx_pm",
 898         .suspend_enter = arm2_suspend_enter,
 899         .suspend_exit = arm2_suspend_exit,
 900 };
 901
 902 static struct mxc_audio_platform_data sab_audio_data = {
 903         .sysclk = 16934400,
 904 };
 905
 906 static struct platform_device sab_audio_device = {
 907         .name = "imx-cs42888",
 908 };
 909
 910 static struct imx_esai_platform_data sab_esai_pdata = {
 911         .flags = IMX_ESAI_NET,
 912 };
 913
 914 static struct regulator_consumer_supply arm2_vmmc_consumers[] = {
 915         REGULATOR_SUPPLY("vmmc", "sdhci-esdhc-imx.1"),
 916         REGULATOR_SUPPLY("vmmc", "sdhci-esdhc-imx.2"),
 917         REGULATOR_SUPPLY("vmmc", "sdhci-esdhc-imx.3"),
 918 };
 919
 920 static struct regulator_init_data arm2_vmmc_init = {
 921         .num_consumer_supplies = ARRAY_SIZE(arm2_vmmc_consumers),
 922         .consumer_supplies = arm2_vmmc_consumers,
 923 };
 924
 925 static struct fixed_voltage_config arm2_vmmc_reg_config = {
 926         .supply_name            = "vmmc",
 927         .microvolts             = 3300000,
 928         .gpio                   = -1,
 929         .init_data              = &arm2_vmmc_init,
 930 };
 931
 932 static struct platform_device arm2_vmmc_reg_devices = {
 933         .name   = "reg-fixed-voltage",
 934         .id     = 0,
 935         .dev    = {
 936                 .platform_data = &arm2_vmmc_reg_config,
 937         },
 938 };
 939
 940 #ifdef CONFIG_SND_SOC_CS42888
 941
 942 static struct regulator_consumer_supply cs42888_arm2_consumer_va = {
 943         .supply = "VA",
 944         .dev_name = "0-0048",
 945 };
 946
 947 static struct regulator_consumer_supply cs42888_arm2_consumer_vd = {
 948         .supply = "VD",
 949         .dev_name = "0-0048",
 950 };
 951
 952 static struct regulator_consumer_supply cs42888_arm2_consumer_vls = {
 953         .supply = "VLS",
 954         .dev_name = "0-0048",
 955 };
 956
 957 static struct regulator_consumer_supply cs42888_arm2_consumer_vlc = {
 958         .supply = "VLC",
 959         .dev_name = "0-0048",
 960 };
 961
 962 static struct regulator_init_data cs42888_arm2_va_reg_initdata = {
 963         .num_consumer_supplies = 1,
 964         .consumer_supplies = &cs42888_arm2_consumer_va,
 965 };
 966
 967 static struct regulator_init_data cs42888_arm2_vd_reg_initdata = {
 968         .num_consumer_supplies = 1,
 969         .consumer_supplies = &cs42888_arm2_consumer_vd,
 970 };
 971
 972 static struct regulator_init_data cs42888_arm2_vls_reg_initdata = {
 973         .num_consumer_supplies = 1,
 974         .consumer_supplies = &cs42888_arm2_consumer_vls,
 975 };
 976
 977 static struct regulator_init_data cs42888_arm2_vlc_reg_initdata = {
 978         .num_consumer_supplies = 1,
 979         .consumer_supplies = &cs42888_arm2_consumer_vlc,
 980 };
 981
 982 static struct fixed_voltage_config cs42888_arm2_va_reg_config = {
 983         .supply_name            = "VA",
 984         .microvolts             = 2800000,
 985         .gpio                   = -1,
 986         .init_data              = &cs42888_arm2_va_reg_initdata,
 987 };
 988
 989 static struct fixed_voltage_config cs42888_arm2_vd_reg_config = {
 990         .supply_name            = "VD",
 991         .microvolts             = 2800000,
 992         .gpio                   = -1,
 993         .init_data              = &cs42888_arm2_vd_reg_initdata,
 994 };
 995
 996 static struct fixed_voltage_config cs42888_arm2_vls_reg_config = {
 997         .supply_name            = "VLS",
 998         .microvolts             = 2800000,
 999         .gpio                   = -1,
1000         .init_data              = &cs42888_arm2_vls_reg_initdata,
1001 };
1002
1003 static struct fixed_voltage_config cs42888_arm2_vlc_reg_config = {
1004         .supply_name            = "VLC",
1005         .microvolts             = 2800000,
1006         .gpio                   = -1,
1007         .init_data              = &cs42888_arm2_vlc_reg_initdata,
1008 };
1009
1010 static struct platform_device cs42888_arm2_va_reg_devices = {
1011         .name   = "reg-fixed-voltage",
1012         .id     = 3,
1013         .dev    = {
1014                 .platform_data = &cs42888_arm2_va_reg_config,
1015         },
1016 };
1017
1018 static struct platform_device cs42888_arm2_vd_reg_devices = {
1019         .name   = "reg-fixed-voltage",
1020         .id     = 4,
1021         .dev    = {
1022                 .platform_data = &cs42888_arm2_vd_reg_config,
1023         },
1024 };
1025
1026 static struct platform_device cs42888_arm2_vls_reg_devices = {
1027         .name   = "reg-fixed-voltage",
1028         .id     = 5,
1029         .dev    = {
1030                 .platform_data = &cs42888_arm2_vls_reg_config,
1031         },
1032 };
1033
1034 static struct platform_device cs42888_arm2_vlc_reg_devices = {
1035         .name   = "reg-fixed-voltage",
1036         .id     = 6,
1037         .dev    = {
1038                 .platform_data = &cs42888_arm2_vlc_reg_config,
1039         },
1040 };
1041
1042 #endif /* CONFIG_SND_SOC_CS42888 */
1043
1044 #ifdef CONFIG_SND_SOC_SGTL5000
1045
1046 static struct regulator_consumer_supply sgtl5000_arm2_consumer_vdda = {
1047         .supply = "VDDA",
1048         .dev_name = "0-000a",
1049 };
1050
1051 static struct regulator_consumer_supply sgtl5000_arm2_consumer_vddio = {
1052         .supply = "VDDIO",
1053         .dev_name = "0-000a",
1054 };
1055
1056 static struct regulator_consumer_supply sgtl5000_arm2_consumer_vddd = {
1057         .supply = "VDDD",
1058         .dev_name = "0-000a",
1059 };
1060
1061 static struct regulator_init_data sgtl5000_arm2_vdda_reg_initdata = {
1062         .num_consumer_supplies = 1,
1063         .consumer_supplies = &sgtl5000_arm2_consumer_vdda,
1064 };
1065
1066 static struct regulator_init_data sgtl5000_arm2_vddio_reg_initdata = {
1067         .num_consumer_supplies = 1,
1068         .consumer_supplies = &sgtl5000_arm2_consumer_vddio,
1069 };
1070
1071 static struct regulator_init_data sgtl5000_arm2_vddd_reg_initdata = {
1072         .num_consumer_supplies = 1,
1073         .consumer_supplies = &sgtl5000_arm2_consumer_vddd,
1074 };
1075
1076 static struct fixed_voltage_config sgtl5000_arm2_vdda_reg_config = {
1077         .supply_name            = "VDDA",
1078         .microvolts             = 1800000,
1079         .gpio                   = -1,
1080         .init_data              = &sgtl5000_arm2_vdda_reg_initdata,
1081 };
1082
1083 static struct fixed_voltage_config sgtl5000_arm2_vddio_reg_config = {
1084         .supply_name            = "VDDIO",
1085         .microvolts             = 3300000,
1086         .gpio                   = -1,
1087         .init_data              = &sgtl5000_arm2_vddio_reg_initdata,
1088 };
1089
1090 static struct fixed_voltage_config sgtl5000_arm2_vddd_reg_config = {
1091         .supply_name            = "VDDD",
1092         .microvolts             = 0,
1093         .gpio                   = -1,
1094         .init_data              = &sgtl5000_arm2_vddd_reg_initdata,
1095 };
1096
1097 static struct platform_device sgtl5000_arm2_vdda_reg_devices = {
1098         .name   = "reg-fixed-voltage",
1099         .id     = 7,
1100         .dev    = {
1101                 .platform_data = &sgtl5000_arm2_vdda_reg_config,
1102         },
1103 };
1104
1105 static struct platform_device sgtl5000_arm2_vddio_reg_devices = {
1106         .name   = "reg-fixed-voltage",
1107         .id     = 8,
1108         .dev    = {
1109                 .platform_data = &sgtl5000_arm2_vddio_reg_config,
1110         },
1111 };
1112
1113 static struct platform_device sgtl5000_arm2_vddd_reg_devices = {
1114         .name   = "reg-fixed-voltage",
1115         .id     = 9,
1116         .dev    = {
1117                 .platform_data = &sgtl5000_arm2_vddd_reg_config,
1118         },
1119 };
1120
1121 #endif /* CONFIG_SND_SOC_SGTL5000 */
1122
1123 static int imx6q_init_audio(void)
1124 {
1125         struct clk *pll3_pfd, *esai_clk;
1126         mxc_register_device(&sab_audio_device, &sab_audio_data);
1127         imx6q_add_imx_esai(0, &sab_esai_pdata);
1128
1129         esai_clk = clk_get(NULL, "esai_clk");
1130         if (IS_ERR(esai_clk))
1131                 return PTR_ERR(esai_clk);
1132
1133         pll3_pfd = clk_get(NULL, "pll3_pfd_508M");
1134         if (IS_ERR(pll3_pfd))
1135                 return PTR_ERR(pll3_pfd);
1136
1137         clk_set_parent(esai_clk, pll3_pfd);
1138         clk_set_rate(esai_clk, 101647058);
1139
1140 #ifdef CONFIG_SND_SOC_SGTL5000
1141         platform_device_register(&sgtl5000_arm2_vdda_reg_devices);
1142         platform_device_register(&sgtl5000_arm2_vddio_reg_devices);
1143         platform_device_register(&sgtl5000_arm2_vddd_reg_devices);
1144 #endif
1145
1146 #ifdef CONFIG_SND_SOC_CS42888
1147         platform_device_register(&cs42888_arm2_va_reg_devices);
1148         platform_device_register(&cs42888_arm2_vd_reg_devices);
1149         platform_device_register(&cs42888_arm2_vls_reg_devices);
1150         platform_device_register(&cs42888_arm2_vlc_reg_devices);
1151 #endif
1152         return 0;
1153 }
1154
1155 static int __init early_use_esai_record(char *p)
1156 {
1157         esai_record = 1;
1158         return 0;
1159 }
1160
1161 early_param("esai_record", early_use_esai_record);
1162
1163 static struct mxc_dvfs_platform_data arm2_dvfscore_data = {
1164         .reg_id = "cpu_vddgp",
1165         .clk1_id = "cpu_clk",
1166         .clk2_id = "gpc_dvfs_clk",
1167         .gpc_cntr_offset = MXC_GPC_CNTR_OFFSET,
1168         .ccm_cdcr_offset = MXC_CCM_CDCR_OFFSET,
1169         .ccm_cacrr_offset = MXC_CCM_CACRR_OFFSET,
1170         .ccm_cdhipr_offset = MXC_CCM_CDHIPR_OFFSET,
1171         .prediv_mask = 0x1F800,
1172         .prediv_offset = 11,
1173         .prediv_val = 3,
1174         .div3ck_mask = 0xE0000000,
1175         .div3ck_offset = 29,
1176         .div3ck_val = 2,
1177         .emac_val = 0x08,
1178         .upthr_val = 25,
1179         .dnthr_val = 9,
1180         .pncthr_val = 33,
1181         .upcnt_val = 10,
1182         .dncnt_val = 10,
1183         .delay_time = 80,
1184 };
1185
1186 static int mx6_arm2_set_cpu_voltage(u32 cpu_volt)
1187 {
1188         int ret = -EINVAL;
1189
1190         if (cpu_regulator == NULL)
1191                 cpu_regulator = regulator_get(NULL, gp_reg_id);
1192
1193         if (!IS_ERR(cpu_regulator))
1194                 ret = regulator_set_voltage(cpu_regulator,
1195                                                     cpu_volt, cpu_volt);
1196         return ret;
1197 }
1198
1199 static void __init fixup_mxc_board(struct machine_desc *desc, struct tag *tags,
1200                                    char **cmdline, struct meminfo *mi)
1201 {
1202         set_cpu_voltage = mx6_arm2_set_cpu_voltage;
1203 }
1204
1205 static inline void __init mx6q_csi0_io_init(void)
1206 {
1207         /* Camera reset */
1208         gpio_request(MX6Q_SMD_CSI0_RST, "cam-reset");
1209         gpio_direction_output(MX6Q_SMD_CSI0_RST, 1);
1210
1211         /* Camera power down */
1212         gpio_request(MX6Q_SMD_CSI0_PWN, "cam-pwdn");
1213         gpio_direction_output(MX6Q_SMD_CSI0_PWN, 1);
1214         msleep(1);
1215         gpio_set_value(MX6Q_SMD_CSI0_PWN, 0);
1216         mxc_iomux_set_gpr_register(1, 19, 1, 1);
1217 }
1218
1219 static int spdif_clk_set_rate(struct clk *clk, unsigned long rate)
1220 {
1221         unsigned long rate_actual;
1222         rate_actual = clk_round_rate(clk, rate);
1223         clk_set_rate(clk, rate_actual);
1224         return 0;
1225 }
1226
1227 static struct mxc_spdif_platform_data mxc_spdif_data = {
1228         .spdif_tx = 1,          /* enable tx */
1229         .spdif_rx = 1,          /* enable rx */
1230         /*
1231          * spdif0_clk will be 454.7MHz divided by ccm dividers.
1232          *
1233          * 44.1KHz: 454.7MHz / 7 (ccm) / 23 (spdif) = 44,128 Hz ~ 0.06% error
1234          * 48KHz:   454.7MHz / 4 (ccm) / 37 (spdif) = 48,004 Hz ~ 0.01% error
1235          * 32KHz:   454.7MHz / 6 (ccm) / 37 (spdif) = 32,003 Hz ~ 0.01% error
1236          */
1237         .spdif_clk_44100 = 1,   /* tx clk from spdif0_clk_root */
1238         .spdif_clk_48000 = 1,   /* tx clk from spdif0_clk_root */
1239         .spdif_div_44100 = 23,
1240         .spdif_div_48000 = 37,
1241         .spdif_div_32000 = 37,
1242         .spdif_rx_clk = 0,      /* rx clk from spdif stream */
1243         .spdif_clk_set_rate = spdif_clk_set_rate,
1244         .spdif_clk = NULL,      /* spdif bus clk */
1245 };
1246
1247 /*!
1248  * Board specific initialization.
1249  */
1250 static void __init mx6_board_init(void)
1251 {
1252         int i;
1253
1254         mxc_iomux_v3_setup_multiple_pads(mx6q_arm2_pads,
1255                                         ARRAY_SIZE(mx6q_arm2_pads));
1256
1257         if (esai_record)
1258             mxc_iomux_v3_setup_multiple_pads(mx6q_arm2_esai_record_pads,
1259                         ARRAY_SIZE(mx6q_arm2_esai_record_pads));
1260
1261         gp_reg_id = arm2_dvfscore_data.reg_id;
1262         mx6q_arm2_init_uart();
1263         imx6q_add_mxc_hdmi_core(&hdmi_core_data);
1264
1265         imx6q_add_ipuv3(0, &ipu_data[0]);
1266         imx6q_add_ipuv3(1, &ipu_data[1]);
1267
1268         for (i = 0; i < ARRAY_SIZE(sabr_fb_data); i++)
1269                 imx6q_add_ipuv3fb(i, &sabr_fb_data[i]);
1270
1271         imx6q_add_mipi_dsi(&mipi_dsi_pdata);
1272         imx6q_add_lcdif(&lcdif_data);
1273         imx6q_add_ldb(&ldb_data);
1274         imx6q_add_v4l2_output(0);
1275         imx6q_add_v4l2_capture(0);
1276
1277         imx6q_add_imx_snvs_rtc();
1278
1279         imx6q_add_imx_i2c(0, &mx6q_arm2_i2c0_data);
1280         imx6q_add_imx_i2c(1, &mx6q_arm2_i2c_data);
1281         imx6q_add_imx_i2c(2, &mx6q_arm2_i2c_data);
1282         i2c_register_board_info(0, mxc_i2c0_board_info,
1283                         ARRAY_SIZE(mxc_i2c0_board_info));
1284         i2c_register_board_info(1, mxc_i2c1_board_info,
1285                         ARRAY_SIZE(mxc_i2c1_board_info));
1286         i2c_register_board_info(2, mxc_i2c2_board_info,
1287                         ARRAY_SIZE(mxc_i2c2_board_info));
1288
1289         /* SPI */
1290         imx6q_add_ecspi(0, &mx6q_arm2_spi_data);
1291         spi_device_init();
1292
1293         imx6q_add_mxc_hdmi(&hdmi_data);
1294
1295         imx6q_add_anatop_thermal_imx(1, &mx6q_arm2_anatop_thermal_data);
1296
1297         if (!esai_record)
1298                 imx6q_init_fec();
1299
1300         imx6q_add_pm_imx(0, &mx6q_arm2_pm_data);
1301         imx6q_add_sdhci_usdhc_imx(3, &mx6q_arm2_sd4_data);
1302         imx6q_add_sdhci_usdhc_imx(2, &mx6q_arm2_sd3_data);
1303         imx_add_viv_gpu(&imx6_gpu_data, &imx6q_gpu_pdata);
1304         imx6q_arm2_init_usb();
1305         imx6q_add_ahci(0, &mx6q_arm2_sata_data);
1306         imx6q_add_vpu();
1307         imx6q_init_audio();
1308         platform_device_register(&arm2_vmmc_reg_devices);
1309         imx_asrc_data.asrc_core_clk = clk_get(NULL, "asrc_clk");
1310         imx_asrc_data.asrc_audio_clk = clk_get(NULL, "asrc_serial_clk");
1311         imx6q_add_asrc(&imx_asrc_data);
1312
1313         mx6q_csi0_io_init();
1314         /* DISP0 Detect */
1315         gpio_request(MX6Q_ARM2_DISP0_DET_INT, "disp0-detect");
1316         gpio_direction_input(MX6Q_ARM2_DISP0_DET_INT);
1317
1318         /* DISP0 Reset - Assert for i2c disabled mode */
1319         gpio_request(MX6Q_ARM2_DISP0_RESET, "disp0-reset");
1320         gpio_direction_output(MX6Q_ARM2_DISP0_RESET, 0);
1321
1322         /* DISP0 I2C enable */
1323         gpio_request(MX6Q_ARM2_DISP0_I2C_EN, "disp0-i2c");
1324         gpio_direction_output(MX6Q_ARM2_DISP0_I2C_EN, 0);
1325
1326         gpio_request(MX6Q_ARM2_DISP0_PWR, "disp0-pwr");
1327         gpio_direction_output(MX6Q_ARM2_DISP0_PWR, 1);
1328
1329         gpio_request(MX6Q_ARM2_LDB_BACKLIGHT, "ldb-backlight");
1330         gpio_direction_output(MX6Q_ARM2_LDB_BACKLIGHT, 1);
1331         imx6q_add_otp();
1332         imx6q_add_viim();
1333         imx6q_add_imx2_wdt(0, NULL);
1334         imx6q_add_dma();
1335         imx6q_add_gpmi(&mx6q_gpmi_nfc_platform_data);
1336
1337         imx6q_add_dvfs_core(&arm2_dvfscore_data);
1338
1339         imx6q_add_mxc_pwm(0);
1340         imx6q_add_mxc_pwm_backlight(0, &mx6_arm2_pwm_backlight_data);
1341
1342         mxc_spdif_data.spdif_core_clk = clk_get_sys("mxc_spdif.0", NULL);
1343         clk_put(mxc_spdif_data.spdif_core_clk);
1344         imx6q_add_spdif(&mxc_spdif_data);
1345         imx6q_add_spdif_dai();
1346         imx6q_add_spdif_audio_device();
1347
1348         imx6q_add_hdmi_soc();
1349         imx6q_add_hdmi_soc_dai();
1350 }
1351
1352 extern void __iomem *twd_base;
1353 static void __init mx6_timer_init(void)
1354 {
1355         struct clk *uart_clk;
1356 #ifdef CONFIG_LOCAL_TIMERS
1357         twd_base = ioremap(LOCAL_TWD_ADDR, SZ_256);
1358         BUG_ON(!twd_base);
1359 #endif
1360         mx6_clocks_init(32768, 24000000, 0, 0);
1361
1362         uart_clk = clk_get_sys("imx-uart.0", NULL);
1363         early_console_setup(UART4_BASE_ADDR, uart_clk);
1364 }
1365
1366 static struct sys_timer mxc_timer = {
1367         .init   = mx6_timer_init,
1368 };
1369
1370 static void __init mx6q_reserve(void)
1371 {
1372         phys_addr_t phys;
1373
1374         if (imx6q_gpu_pdata.reserved_mem_size) {
1375                 phys = memblock_alloc_base(imx6q_gpu_pdata.reserved_mem_size,
1376                         SZ_4K, SZ_2G);
1377                 memblock_free(phys, imx6q_gpu_pdata.reserved_mem_size);
1378                 memblock_remove(phys, imx6q_gpu_pdata.reserved_mem_size);
1379                 imx6q_gpu_pdata.reserved_mem_base = phys;
1380         }
1381 }
1382
1383 /*
1384  * initialize __mach_desc_MX6Q_ARM2 data structure.
1385  */
1386 MACHINE_START(MX6Q_ARM2, "Freescale i.MX 6Quad Armadillo2 Board")
1387         /* Maintainer: Freescale Semiconductor, Inc. */
1388         .boot_params = MX6_PHYS_OFFSET + 0x100,
1389         .fixup = fixup_mxc_board,
1390         .map_io = mx6_map_io,
1391         .init_irq = mx6_init_irq,
1392         .init_machine = mx6_board_init,
1393         .timer = &mxc_timer,
1394         .reserve = mx6q_reserve,
1395 MACHINE_END