[deliverable/linux.git] / arch / arm / mach-mxs / mach-mx28evk.c

/*
 * Copyright 2010 Freescale Semiconductor, Inc. All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/leds.h>
#include <linux/clk.h>
#include <linux/i2c.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/fixed.h>

#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/time.h>

#include <mach/common.h>
#include <mach/iomux-mx28.h>
#include <mach/digctl.h>

#include "devices-mx28.h"

#define MX28EVK_FLEXCAN_SWITCH	MXS_GPIO_NR(2, 13)
#define MX28EVK_FEC_PHY_POWER	MXS_GPIO_NR(2, 15)
#define MX28EVK_GPIO_LED	MXS_GPIO_NR(3, 5)
#define MX28EVK_BL_ENABLE	MXS_GPIO_NR(3, 18)
#define MX28EVK_LCD_ENABLE	MXS_GPIO_NR(3, 30)
#define MX28EVK_FEC_PHY_RESET	MXS_GPIO_NR(4, 13)

#define MX28EVK_MMC0_WRITE_PROTECT	MXS_GPIO_NR(2, 12)
#define MX28EVK_MMC1_WRITE_PROTECT	MXS_GPIO_NR(0, 28)
#define MX28EVK_MMC0_SLOT_POWER		MXS_GPIO_NR(3, 28)
#define MX28EVK_MMC1_SLOT_POWER		MXS_GPIO_NR(3, 29)

static const iomux_cfg_t mx28evk_pads[] __initconst = {
	/* duart */
	MX28_PAD_PWM0__DUART_RX | MXS_PAD_CTRL,
	MX28_PAD_PWM1__DUART_TX | MXS_PAD_CTRL,

	/* auart0 */
	MX28_PAD_AUART0_RX__AUART0_RX | MXS_PAD_CTRL,
	MX28_PAD_AUART0_TX__AUART0_TX | MXS_PAD_CTRL,
	MX28_PAD_AUART0_CTS__AUART0_CTS | MXS_PAD_CTRL,
	MX28_PAD_AUART0_RTS__AUART0_RTS | MXS_PAD_CTRL,
	/* auart3 */
	MX28_PAD_AUART3_RX__AUART3_RX | MXS_PAD_CTRL,
	MX28_PAD_AUART3_TX__AUART3_TX | MXS_PAD_CTRL,
	MX28_PAD_AUART3_CTS__AUART3_CTS | MXS_PAD_CTRL,
	MX28_PAD_AUART3_RTS__AUART3_RTS | MXS_PAD_CTRL,

#define MXS_PAD_FEC	(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP)
	/* fec0 */
	MX28_PAD_ENET0_MDC__ENET0_MDC | MXS_PAD_FEC,
	MX28_PAD_ENET0_MDIO__ENET0_MDIO | MXS_PAD_FEC,
	MX28_PAD_ENET0_RX_EN__ENET0_RX_EN | MXS_PAD_FEC,
	MX28_PAD_ENET0_RXD0__ENET0_RXD0 | MXS_PAD_FEC,
	MX28_PAD_ENET0_RXD1__ENET0_RXD1 | MXS_PAD_FEC,
	MX28_PAD_ENET0_TX_EN__ENET0_TX_EN | MXS_PAD_FEC,
	MX28_PAD_ENET0_TXD0__ENET0_TXD0 | MXS_PAD_FEC,
	MX28_PAD_ENET0_TXD1__ENET0_TXD1 | MXS_PAD_FEC,
	MX28_PAD_ENET_CLK__CLKCTRL_ENET | MXS_PAD_FEC,
	/* fec1 */
	MX28_PAD_ENET0_CRS__ENET1_RX_EN | MXS_PAD_FEC,
	MX28_PAD_ENET0_RXD2__ENET1_RXD0 | MXS_PAD_FEC,
	MX28_PAD_ENET0_RXD3__ENET1_RXD1 | MXS_PAD_FEC,
	MX28_PAD_ENET0_COL__ENET1_TX_EN | MXS_PAD_FEC,
	MX28_PAD_ENET0_TXD2__ENET1_TXD0 | MXS_PAD_FEC,
	MX28_PAD_ENET0_TXD3__ENET1_TXD1 | MXS_PAD_FEC,
	/* phy power line */
	MX28_PAD_SSP1_DATA3__GPIO_2_15 | MXS_PAD_CTRL,
	/* phy reset line */
	MX28_PAD_ENET0_RX_CLK__GPIO_4_13 | MXS_PAD_CTRL,

	/* flexcan0 */
	MX28_PAD_GPMI_RDY2__CAN0_TX,
	MX28_PAD_GPMI_RDY3__CAN0_RX,
	/* flexcan1 */
	MX28_PAD_GPMI_CE2N__CAN1_TX,
	MX28_PAD_GPMI_CE3N__CAN1_RX,
	/* transceiver power control */
	MX28_PAD_SSP1_CMD__GPIO_2_13,

	/* mxsfb (lcdif) */
	MX28_PAD_LCD_D00__LCD_D0 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D01__LCD_D1 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D02__LCD_D2 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D03__LCD_D3 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D04__LCD_D4 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D05__LCD_D5 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D06__LCD_D6 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D07__LCD_D7 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D08__LCD_D8 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D09__LCD_D9 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D10__LCD_D10 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D11__LCD_D11 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D12__LCD_D12 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D13__LCD_D13 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D14__LCD_D14 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D15__LCD_D15 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D16__LCD_D16 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D17__LCD_D17 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D18__LCD_D18 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D19__LCD_D19 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D20__LCD_D20 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D21__LCD_D21 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D22__LCD_D22 | MXS_PAD_CTRL,
	MX28_PAD_LCD_D23__LCD_D23 | MXS_PAD_CTRL,
	MX28_PAD_LCD_RD_E__LCD_VSYNC | MXS_PAD_CTRL,
	MX28_PAD_LCD_WR_RWN__LCD_HSYNC | MXS_PAD_CTRL,
	MX28_PAD_LCD_RS__LCD_DOTCLK | MXS_PAD_CTRL,
	MX28_PAD_LCD_CS__LCD_ENABLE | MXS_PAD_CTRL,
	/* LCD panel enable */
	MX28_PAD_LCD_RESET__GPIO_3_30 | MXS_PAD_CTRL,
	/* backlight control */
	MX28_PAD_PWM2__GPIO_3_18 | MXS_PAD_CTRL,
	/* mmc0 */
	MX28_PAD_SSP0_DATA0__SSP0_D0 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_DATA1__SSP0_D1 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_DATA2__SSP0_D2 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_DATA3__SSP0_D3 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_DATA4__SSP0_D4 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_DATA5__SSP0_D5 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_DATA6__SSP0_D6 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_DATA7__SSP0_D7 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_CMD__SSP0_CMD |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SSP0_DETECT__SSP0_CARD_DETECT |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_NOPULL),
	MX28_PAD_SSP0_SCK__SSP0_SCK |
		(MXS_PAD_12MA | MXS_PAD_3V3 | MXS_PAD_NOPULL),
	/* write protect */
	MX28_PAD_SSP1_SCK__GPIO_2_12 |
		(MXS_PAD_4MA | MXS_PAD_3V3 | MXS_PAD_NOPULL),
	/* slot power enable */
	MX28_PAD_PWM3__GPIO_3_28 |
		(MXS_PAD_4MA | MXS_PAD_3V3 | MXS_PAD_NOPULL),

	/* mmc1 */
	MX28_PAD_GPMI_D00__SSP1_D0 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_D01__SSP1_D1 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_D02__SSP1_D2 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_D03__SSP1_D3 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_D04__SSP1_D4 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_D05__SSP1_D5 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_D06__SSP1_D6 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_D07__SSP1_D7 |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_RDY1__SSP1_CMD |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_GPMI_RDY0__SSP1_CARD_DETECT |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_NOPULL),
	MX28_PAD_GPMI_WRN__SSP1_SCK |
		(MXS_PAD_12MA | MXS_PAD_3V3 | MXS_PAD_NOPULL),
	/* write protect */
	MX28_PAD_GPMI_RESETN__GPIO_0_28 |
		(MXS_PAD_4MA | MXS_PAD_3V3 | MXS_PAD_NOPULL),
	/* slot power enable */
	MX28_PAD_PWM4__GPIO_3_29 |
		(MXS_PAD_4MA | MXS_PAD_3V3 | MXS_PAD_NOPULL),

	/* led */
	MX28_PAD_AUART1_TX__GPIO_3_5 | MXS_PAD_CTRL,

	/* I2C */
	MX28_PAD_I2C0_SCL__I2C0_SCL |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_I2C0_SDA__I2C0_SDA |
		(MXS_PAD_8MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),

	/* saif0 & saif1 */
	MX28_PAD_SAIF0_MCLK__SAIF0_MCLK |
		(MXS_PAD_12MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SAIF0_LRCLK__SAIF0_LRCLK |
		(MXS_PAD_12MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SAIF0_BITCLK__SAIF0_BITCLK |
		(MXS_PAD_12MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SAIF0_SDATA0__SAIF0_SDATA0 |
		(MXS_PAD_12MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
	MX28_PAD_SAIF1_SDATA0__SAIF1_SDATA0 |
		(MXS_PAD_12MA | MXS_PAD_3V3 | MXS_PAD_PULLUP),
};

/* led */
static const struct gpio_led mx28evk_leds[] __initconst = {
	{
		.name = "GPIO-LED",
		.default_trigger = "heartbeat",
		.gpio = MX28EVK_GPIO_LED,
	},
};

static const struct gpio_led_platform_data mx28evk_led_data __initconst = {
	.leds = mx28evk_leds,
	.num_leds = ARRAY_SIZE(mx28evk_leds),
};

/* fec */
static void __init mx28evk_fec_reset(void)
{
	struct clk *clk;

	/* Enable fec phy clock */
	clk = clk_get_sys("enet_out", NULL);
	if (!IS_ERR(clk))
		clk_prepare_enable(clk);

	gpio_set_value(MX28EVK_FEC_PHY_RESET, 0);
	mdelay(1);
	gpio_set_value(MX28EVK_FEC_PHY_RESET, 1);
}

static struct fec_platform_data mx28_fec_pdata[] __initdata = {
	{
		/* fec0 */
		.phy = PHY_INTERFACE_MODE_RMII,
	}, {
		/* fec1 */
		.phy = PHY_INTERFACE_MODE_RMII,
	},
};

static int __init mx28evk_fec_get_mac(void)
{
	int i;
	u32 val;
	const u32 *ocotp = mxs_get_ocotp();

	if (!ocotp)
		return -ETIMEDOUT;

	/*
	 * OCOTP only stores the last 4 octets for each mac address,
	 * so hard-code Freescale OUI (00:04:9f) here.
	 */
	for (i = 0; i < 2; i++) {
		val = ocotp[i];
		mx28_fec_pdata[i].mac[0] = 0x00;
		mx28_fec_pdata[i].mac[1] = 0x04;
		mx28_fec_pdata[i].mac[2] = 0x9f;
		mx28_fec_pdata[i].mac[3] = (val >> 16) & 0xff;
		mx28_fec_pdata[i].mac[4] = (val >> 8) & 0xff;
		mx28_fec_pdata[i].mac[5] = (val >> 0) & 0xff;
	}

	return 0;
}

/*
 * MX28EVK_FLEXCAN_SWITCH is shared between both flexcan controllers
 */
static int flexcan0_en, flexcan1_en;

static void mx28evk_flexcan_switch(void)
{
	if (flexcan0_en || flexcan1_en)
		gpio_set_value(MX28EVK_FLEXCAN_SWITCH, 1);
	else
		gpio_set_value(MX28EVK_FLEXCAN_SWITCH, 0);
}

static void mx28evk_flexcan0_switch(int enable)
{
	flexcan0_en = enable;
	mx28evk_flexcan_switch();
}

static void mx28evk_flexcan1_switch(int enable)
{
	flexcan1_en = enable;
	mx28evk_flexcan_switch();
}

static const struct flexcan_platform_data
		mx28evk_flexcan_pdata[] __initconst = {
	{
		.transceiver_switch = mx28evk_flexcan0_switch,
	}, {
		.transceiver_switch = mx28evk_flexcan1_switch,
	}
};

/* mxsfb (lcdif) */
static struct fb_videomode mx28evk_video_modes[] = {
	{
		.name		= "Seiko-43WVF1G",
		.refresh	= 60,
		.xres		= 800,
		.yres		= 480,
		.pixclock	= 29851, /* picosecond (33.5 MHz) */
		.left_margin	= 89,
		.right_margin	= 164,
		.upper_margin	= 23,
		.lower_margin	= 10,
		.hsync_len	= 10,
		.vsync_len	= 10,
		.sync		= FB_SYNC_DATA_ENABLE_HIGH_ACT |
				  FB_SYNC_DOTCLK_FAILING_ACT,
	},
};

static const struct mxsfb_platform_data mx28evk_mxsfb_pdata __initconst = {
	.mode_list	= mx28evk_video_modes,
	.mode_count	= ARRAY_SIZE(mx28evk_video_modes),
	.default_bpp	= 32,
	.ld_intf_width	= STMLCDIF_24BIT,
};

static struct mxs_mmc_platform_data mx28evk_mmc_pdata[] __initdata = {
	{
		/* mmc0 */
		.wp_gpio = MX28EVK_MMC0_WRITE_PROTECT,
		.flags = SLOTF_8_BIT_CAPABLE,
	}, {
		/* mmc1 */
		.wp_gpio = MX28EVK_MMC1_WRITE_PROTECT,
		.flags = SLOTF_8_BIT_CAPABLE,
	},
};

static struct i2c_board_info mxs_i2c0_board_info[] __initdata = {
	{
		I2C_BOARD_INFO("sgtl5000", 0x0a),
	},
};

#if defined(CONFIG_REGULATOR_FIXED_VOLTAGE) || defined(CONFIG_REGULATOR_FIXED_VOLTAGE_MODULE)
static struct regulator_consumer_supply mx28evk_audio_consumer_supplies[] = {
	REGULATOR_SUPPLY("VDDA", "0-000a"),
	REGULATOR_SUPPLY("VDDIO", "0-000a"),
};

static struct regulator_init_data mx28evk_vdd_reg_init_data = {
	.constraints	= {
		.name	= "3V3",
		.always_on = 1,
	},
	.consumer_supplies = mx28evk_audio_consumer_supplies,
	.num_consumer_supplies = ARRAY_SIZE(mx28evk_audio_consumer_supplies),
};

static struct fixed_voltage_config mx28evk_vdd_pdata = {
	.supply_name	= "board-3V3",
	.microvolts	= 3300000,
	.gpio		= -EINVAL,
	.enabled_at_boot = 1,
	.init_data	= &mx28evk_vdd_reg_init_data,
};
static struct platform_device mx28evk_voltage_regulator = {
	.name		= "reg-fixed-voltage",
	.id		= -1,
	.num_resources	= 0,
	.dev		= {
		.platform_data	= &mx28evk_vdd_pdata,
	},
};
static void __init mx28evk_add_regulators(void)
{
	platform_device_register(&mx28evk_voltage_regulator);
}
#else
static void __init mx28evk_add_regulators(void) {}
#endif

static const struct gpio mx28evk_gpios[] __initconst = {
	{ MX28EVK_LCD_ENABLE, GPIOF_OUT_INIT_HIGH, "lcd-enable" },
	{ MX28EVK_BL_ENABLE, GPIOF_OUT_INIT_HIGH, "bl-enable" },
	{ MX28EVK_FLEXCAN_SWITCH, GPIOF_DIR_OUT, "flexcan-switch" },
	{ MX28EVK_MMC0_SLOT_POWER, GPIOF_OUT_INIT_LOW, "mmc0-slot-power" },
	{ MX28EVK_MMC1_SLOT_POWER, GPIOF_OUT_INIT_LOW, "mmc1-slot-power" },
	{ MX28EVK_FEC_PHY_POWER, GPIOF_OUT_INIT_LOW, "fec-phy-power" },
	{ MX28EVK_FEC_PHY_RESET, GPIOF_DIR_OUT, "fec-phy-reset" },
};

static const struct mxs_saif_platform_data
			mx28evk_mxs_saif_pdata[] __initconst = {
	/* working on EXTMSTR0 mode (saif0 master, saif1 slave) */
	{
		.master_mode = 1,
		.master_id = 0,
	}, {
		.master_mode = 0,
		.master_id = 0,
	},
};

static void __init mx28evk_init(void)
{
	int ret;

	mx28_soc_init();

	mxs_iomux_setup_multiple_pads(mx28evk_pads, ARRAY_SIZE(mx28evk_pads));

	mx28_add_duart();
	mx28_add_auart0();
	mx28_add_auart3();

	if (mx28evk_fec_get_mac())
		pr_warn("%s: failed on fec mac setup\n", __func__);

	ret = gpio_request_array(mx28evk_gpios, ARRAY_SIZE(mx28evk_gpios));
	if (ret)
		pr_err("One or more GPIOs failed to be requested: %d\n", ret);

	mx28evk_fec_reset();
	mx28_add_fec(0, &mx28_fec_pdata[0]);
	mx28_add_fec(1, &mx28_fec_pdata[1]);

	mx28_add_flexcan(0, &mx28evk_flexcan_pdata[0]);
	mx28_add_flexcan(1, &mx28evk_flexcan_pdata[1]);

	mx28_add_mxsfb(&mx28evk_mxsfb_pdata);

	mxs_saif_clkmux_select(MXS_DIGCTL_SAIF_CLKMUX_EXTMSTR0);
	mx28_add_saif(0, &mx28evk_mxs_saif_pdata[0]);
	mx28_add_saif(1, &mx28evk_mxs_saif_pdata[1]);

	mx28_add_mxs_i2c(0);
	i2c_register_board_info(0, mxs_i2c0_board_info,
				ARRAY_SIZE(mxs_i2c0_board_info));

	mx28evk_add_regulators();

	mxs_add_platform_device("mxs-sgtl5000", 0, NULL, 0,
			NULL, 0);

	mx28_add_mxs_mmc(0, &mx28evk_mmc_pdata[0]);
	mx28_add_mxs_mmc(1, &mx28evk_mmc_pdata[1]);

	mx28_add_rtc_stmp3xxx();

	gpio_led_register_device(0, &mx28evk_led_data);
}

static void __init mx28evk_timer_init(void)
{
	mx28_clocks_init();
}

static struct sys_timer mx28evk_timer = {
	.init	= mx28evk_timer_init,
};

MACHINE_START(MX28EVK, "Freescale MX28 EVK")
	/* Maintainer: Freescale Semiconductor, Inc. */
	.map_io		= mx28_map_io,
	.init_irq	= mx28_init_irq,
	.timer		= &mx28evk_timer,
	.init_machine	= mx28evk_init,
	.restart	= mxs_restart,
MACHINE_END
Commit	Line	Data
4afbbb7c SG	1	/*
	2	* Copyright 2010 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
	15	#include <linux/delay.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/gpio.h>
53b8ff9d	18	#include <linux/leds.h>
4afbbb7c	19	#include <linux/clk.h>
074c54f4	20	#include <linux/i2c.h>
e55e48ff WS	21	#include <linux/regulator/machine.h>
e55e48ff WS	22	#include <linux/regulator/fixed.h>
4afbbb7c SG	23
	24	#include <asm/mach-types.h>
	25	#include <asm/mach/arch.h>
	26	#include <asm/mach/time.h>
	27
	28	#include <mach/common.h>
	29	#include <mach/iomux-mx28.h>
4c0174c5	30	#include <mach/digctl.h>
4afbbb7c SG	31
4afbbb7c SG	32	#include "devices-mx28.h"
4afbbb7c	33
acc9cdca	34	#define MX28EVK_FLEXCAN_SWITCH MXS_GPIO_NR(2, 13)
4afbbb7c	35	#define MX28EVK_FEC_PHY_POWER MXS_GPIO_NR(2, 15)
53b8ff9d	36	#define MX28EVK_GPIO_LED MXS_GPIO_NR(3, 5)
0590a790 SG	37	#define MX28EVK_BL_ENABLE MXS_GPIO_NR(3, 18)
0590a790 SG	38	#define MX28EVK_LCD_ENABLE MXS_GPIO_NR(3, 30)
4afbbb7c SG	39	#define MX28EVK_FEC_PHY_RESET MXS_GPIO_NR(4, 13)
4afbbb7c SG	40
5bb2c828 SG	41	#define MX28EVK_MMC0_WRITE_PROTECT MXS_GPIO_NR(2, 12)
	42	#define MX28EVK_MMC1_WRITE_PROTECT MXS_GPIO_NR(0, 28)
	43	#define MX28EVK_MMC0_SLOT_POWER MXS_GPIO_NR(3, 28)
	44	#define MX28EVK_MMC1_SLOT_POWER MXS_GPIO_NR(3, 29)
	45
4afbbb7c SG	46	static const iomux_cfg_t mx28evk_pads[] __initconst = {
4afbbb7c SG	47	/* duart */
db63a493 SG	48	MX28_PAD_PWM0__DUART_RX \| MXS_PAD_CTRL,
db63a493 SG	49	MX28_PAD_PWM1__DUART_TX \| MXS_PAD_CTRL,
4afbbb7c	50
15808182	51	/* auart0 */
db63a493 SG	52	MX28_PAD_AUART0_RX__AUART0_RX \| MXS_PAD_CTRL,
	53	MX28_PAD_AUART0_TX__AUART0_TX \| MXS_PAD_CTRL,
	54	MX28_PAD_AUART0_CTS__AUART0_CTS \| MXS_PAD_CTRL,
	55	MX28_PAD_AUART0_RTS__AUART0_RTS \| MXS_PAD_CTRL,
15808182	56	/* auart3 */
db63a493 SG	57	MX28_PAD_AUART3_RX__AUART3_RX \| MXS_PAD_CTRL,
	58	MX28_PAD_AUART3_TX__AUART3_TX \| MXS_PAD_CTRL,
	59	MX28_PAD_AUART3_CTS__AUART3_CTS \| MXS_PAD_CTRL,
	60	MX28_PAD_AUART3_RTS__AUART3_RTS \| MXS_PAD_CTRL,
15808182	61
db63a493	62	#define MXS_PAD_FEC (MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP)
4afbbb7c	63	/* fec0 */
db63a493 SG	64	MX28_PAD_ENET0_MDC__ENET0_MDC \| MXS_PAD_FEC,
	65	MX28_PAD_ENET0_MDIO__ENET0_MDIO \| MXS_PAD_FEC,
	66	MX28_PAD_ENET0_RX_EN__ENET0_RX_EN \| MXS_PAD_FEC,
	67	MX28_PAD_ENET0_RXD0__ENET0_RXD0 \| MXS_PAD_FEC,
	68	MX28_PAD_ENET0_RXD1__ENET0_RXD1 \| MXS_PAD_FEC,
	69	MX28_PAD_ENET0_TX_EN__ENET0_TX_EN \| MXS_PAD_FEC,
	70	MX28_PAD_ENET0_TXD0__ENET0_TXD0 \| MXS_PAD_FEC,
	71	MX28_PAD_ENET0_TXD1__ENET0_TXD1 \| MXS_PAD_FEC,
	72	MX28_PAD_ENET_CLK__CLKCTRL_ENET \| MXS_PAD_FEC,
48f76ed1	73	/* fec1 */
db63a493 SG	74	MX28_PAD_ENET0_CRS__ENET1_RX_EN \| MXS_PAD_FEC,
	75	MX28_PAD_ENET0_RXD2__ENET1_RXD0 \| MXS_PAD_FEC,
	76	MX28_PAD_ENET0_RXD3__ENET1_RXD1 \| MXS_PAD_FEC,
	77	MX28_PAD_ENET0_COL__ENET1_TX_EN \| MXS_PAD_FEC,
	78	MX28_PAD_ENET0_TXD2__ENET1_TXD0 \| MXS_PAD_FEC,
	79	MX28_PAD_ENET0_TXD3__ENET1_TXD1 \| MXS_PAD_FEC,
4afbbb7c	80	/* phy power line */
db63a493	81	MX28_PAD_SSP1_DATA3__GPIO_2_15 \| MXS_PAD_CTRL,
4afbbb7c	82	/* phy reset line */
db63a493	83	MX28_PAD_ENET0_RX_CLK__GPIO_4_13 \| MXS_PAD_CTRL,
acc9cdca SG	84
	85	/* flexcan0 */
	86	MX28_PAD_GPMI_RDY2__CAN0_TX,
	87	MX28_PAD_GPMI_RDY3__CAN0_RX,
	88	/* flexcan1 */
	89	MX28_PAD_GPMI_CE2N__CAN1_TX,
	90	MX28_PAD_GPMI_CE3N__CAN1_RX,
	91	/* transceiver power control */
	92	MX28_PAD_SSP1_CMD__GPIO_2_13,
0590a790 SG	93
	94	/* mxsfb (lcdif) */
	95	MX28_PAD_LCD_D00__LCD_D0 \| MXS_PAD_CTRL,
	96	MX28_PAD_LCD_D01__LCD_D1 \| MXS_PAD_CTRL,
	97	MX28_PAD_LCD_D02__LCD_D2 \| MXS_PAD_CTRL,
	98	MX28_PAD_LCD_D03__LCD_D3 \| MXS_PAD_CTRL,
	99	MX28_PAD_LCD_D04__LCD_D4 \| MXS_PAD_CTRL,
	100	MX28_PAD_LCD_D05__LCD_D5 \| MXS_PAD_CTRL,
	101	MX28_PAD_LCD_D06__LCD_D6 \| MXS_PAD_CTRL,
	102	MX28_PAD_LCD_D07__LCD_D7 \| MXS_PAD_CTRL,
	103	MX28_PAD_LCD_D08__LCD_D8 \| MXS_PAD_CTRL,
	104	MX28_PAD_LCD_D09__LCD_D9 \| MXS_PAD_CTRL,
	105	MX28_PAD_LCD_D10__LCD_D10 \| MXS_PAD_CTRL,
	106	MX28_PAD_LCD_D11__LCD_D11 \| MXS_PAD_CTRL,
	107	MX28_PAD_LCD_D12__LCD_D12 \| MXS_PAD_CTRL,
	108	MX28_PAD_LCD_D13__LCD_D13 \| MXS_PAD_CTRL,
	109	MX28_PAD_LCD_D14__LCD_D14 \| MXS_PAD_CTRL,
	110	MX28_PAD_LCD_D15__LCD_D15 \| MXS_PAD_CTRL,
	111	MX28_PAD_LCD_D16__LCD_D16 \| MXS_PAD_CTRL,
	112	MX28_PAD_LCD_D17__LCD_D17 \| MXS_PAD_CTRL,
	113	MX28_PAD_LCD_D18__LCD_D18 \| MXS_PAD_CTRL,
	114	MX28_PAD_LCD_D19__LCD_D19 \| MXS_PAD_CTRL,
	115	MX28_PAD_LCD_D20__LCD_D20 \| MXS_PAD_CTRL,
	116	MX28_PAD_LCD_D21__LCD_D21 \| MXS_PAD_CTRL,
	117	MX28_PAD_LCD_D22__LCD_D22 \| MXS_PAD_CTRL,
	118	MX28_PAD_LCD_D23__LCD_D23 \| MXS_PAD_CTRL,
	119	MX28_PAD_LCD_RD_E__LCD_VSYNC \| MXS_PAD_CTRL,
	120	MX28_PAD_LCD_WR_RWN__LCD_HSYNC \| MXS_PAD_CTRL,
	121	MX28_PAD_LCD_RS__LCD_DOTCLK \| MXS_PAD_CTRL,
	122	MX28_PAD_LCD_CS__LCD_ENABLE \| MXS_PAD_CTRL,
	123	/* LCD panel enable */
	124	MX28_PAD_LCD_RESET__GPIO_3_30 \| MXS_PAD_CTRL,
	125	/* backlight control */
	126	MX28_PAD_PWM2__GPIO_3_18 \| MXS_PAD_CTRL,
5bb2c828 SG	127	/* mmc0 */
	128	MX28_PAD_SSP0_DATA0__SSP0_D0 \|
	129	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	130	MX28_PAD_SSP0_DATA1__SSP0_D1 \|
	131	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	132	MX28_PAD_SSP0_DATA2__SSP0_D2 \|
	133	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	134	MX28_PAD_SSP0_DATA3__SSP0_D3 \|
	135	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	136	MX28_PAD_SSP0_DATA4__SSP0_D4 \|
	137	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	138	MX28_PAD_SSP0_DATA5__SSP0_D5 \|
	139	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	140	MX28_PAD_SSP0_DATA6__SSP0_D6 \|
	141	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	142	MX28_PAD_SSP0_DATA7__SSP0_D7 \|
	143	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	144	MX28_PAD_SSP0_CMD__SSP0_CMD \|
	145	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	146	MX28_PAD_SSP0_DETECT__SSP0_CARD_DETECT \|
	147	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_NOPULL),
	148	MX28_PAD_SSP0_SCK__SSP0_SCK \|
	149	(MXS_PAD_12MA \| MXS_PAD_3V3 \| MXS_PAD_NOPULL),
	150	/* write protect */
	151	MX28_PAD_SSP1_SCK__GPIO_2_12 \|
	152	(MXS_PAD_4MA \| MXS_PAD_3V3 \| MXS_PAD_NOPULL),
	153	/* slot power enable */
	154	MX28_PAD_PWM3__GPIO_3_28 \|
	155	(MXS_PAD_4MA \| MXS_PAD_3V3 \| MXS_PAD_NOPULL),
	156
	157	/* mmc1 */
	158	MX28_PAD_GPMI_D00__SSP1_D0 \|
	159	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	160	MX28_PAD_GPMI_D01__SSP1_D1 \|
	161	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	162	MX28_PAD_GPMI_D02__SSP1_D2 \|
	163	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	164	MX28_PAD_GPMI_D03__SSP1_D3 \|
	165	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	166	MX28_PAD_GPMI_D04__SSP1_D4 \|
	167	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	168	MX28_PAD_GPMI_D05__SSP1_D5 \|
	169	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	170	MX28_PAD_GPMI_D06__SSP1_D6 \|
	171	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	172	MX28_PAD_GPMI_D07__SSP1_D7 \|
	173	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	174	MX28_PAD_GPMI_RDY1__SSP1_CMD \|
	175	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	176	MX28_PAD_GPMI_RDY0__SSP1_CARD_DETECT \|
	177	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_NOPULL),
	178	MX28_PAD_GPMI_WRN__SSP1_SCK \|
	179	(MXS_PAD_12MA \| MXS_PAD_3V3 \| MXS_PAD_NOPULL),
	180	/* write protect */
	181	MX28_PAD_GPMI_RESETN__GPIO_0_28 \|
	182	(MXS_PAD_4MA \| MXS_PAD_3V3 \| MXS_PAD_NOPULL),
	183	/* slot power enable */
	184	MX28_PAD_PWM4__GPIO_3_29 \|
	185	(MXS_PAD_4MA \| MXS_PAD_3V3 \| MXS_PAD_NOPULL),
53b8ff9d SG	186
	187	/* led */
	188	MX28_PAD_AUART1_TX__GPIO_3_5 \| MXS_PAD_CTRL,
c8ebcac8	189
074c54f4 DA	190	/* I2C */
	191	MX28_PAD_I2C0_SCL__I2C0_SCL \|
	192	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	193	MX28_PAD_I2C0_SDA__I2C0_SDA \|
	194	(MXS_PAD_8MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	195
c8ebcac8 DA	196	/* saif0 & saif1 */
	197	MX28_PAD_SAIF0_MCLK__SAIF0_MCLK \|
	198	(MXS_PAD_12MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	199	MX28_PAD_SAIF0_LRCLK__SAIF0_LRCLK \|
	200	(MXS_PAD_12MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	201	MX28_PAD_SAIF0_BITCLK__SAIF0_BITCLK \|
	202	(MXS_PAD_12MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	203	MX28_PAD_SAIF0_SDATA0__SAIF0_SDATA0 \|
	204	(MXS_PAD_12MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
	205	MX28_PAD_SAIF1_SDATA0__SAIF1_SDATA0 \|
	206	(MXS_PAD_12MA \| MXS_PAD_3V3 \| MXS_PAD_PULLUP),
53b8ff9d SG	207	};
	208
	209	/* led */
	210	static const struct gpio_led mx28evk_leds[] __initconst = {
	211	{
	212	.name = "GPIO-LED",
	213	.default_trigger = "heartbeat",
	214	.gpio = MX28EVK_GPIO_LED,
	215	},
	216	};
	217
	218	static const struct gpio_led_platform_data mx28evk_led_data __initconst = {
	219	.leds = mx28evk_leds,
	220	.num_leds = ARRAY_SIZE(mx28evk_leds),
4afbbb7c SG	221	};
	222
	223	/* fec */
	224	static void __init mx28evk_fec_reset(void)
	225	{
4afbbb7c SG	226	struct clk *clk;
	227
	228	/* Enable fec phy clock */
e80d76f8	229	clk = clk_get_sys("enet_out", NULL);
4afbbb7c	230	if (!IS_ERR(clk))
ae68f7af	231	clk_prepare_enable(clk);
4afbbb7c	232
c5f98794	233	gpio_set_value(MX28EVK_FEC_PHY_RESET, 0);
4afbbb7c SG	234	mdelay(1);
	235	gpio_set_value(MX28EVK_FEC_PHY_RESET, 1);
	236	}
	237
a320b279	238	static struct fec_platform_data mx28_fec_pdata[] __initdata = {
48f76ed1 SG	239	{
	240	/* fec0 */
	241	.phy = PHY_INTERFACE_MODE_RMII,
	242	}, {
	243	/* fec1 */
	244	.phy = PHY_INTERFACE_MODE_RMII,
	245	},
4afbbb7c SG	246	};
4afbbb7c SG	247
a320b279 SG	248	static int __init mx28evk_fec_get_mac(void)
	249	{
	250	int i;
	251	u32 val;
	252	const u32 *ocotp = mxs_get_ocotp();
	253
	254	if (!ocotp)
9250bc8b	255	return -ETIMEDOUT;
a320b279 SG	256
	257	/*
	258	* OCOTP only stores the last 4 octets for each mac address,
	259	* so hard-code Freescale OUI (00:04:9f) here.
	260	*/
	261	for (i = 0; i < 2; i++) {
5a91d7c8	262	val = ocotp[i];
a320b279 SG	263	mx28_fec_pdata[i].mac[0] = 0x00;
	264	mx28_fec_pdata[i].mac[1] = 0x04;
	265	mx28_fec_pdata[i].mac[2] = 0x9f;
	266	mx28_fec_pdata[i].mac[3] = (val >> 16) & 0xff;
	267	mx28_fec_pdata[i].mac[4] = (val >> 8) & 0xff;
	268	mx28_fec_pdata[i].mac[5] = (val >> 0) & 0xff;
	269	}
	270
	271	return 0;
a320b279 SG	272	}
a320b279 SG	273
acc9cdca SG	274	/*
	275	* MX28EVK_FLEXCAN_SWITCH is shared between both flexcan controllers
	276	*/
	277	static int flexcan0_en, flexcan1_en;
	278
	279	static void mx28evk_flexcan_switch(void)
	280	{
	281	if (flexcan0_en \|\| flexcan1_en)
	282	gpio_set_value(MX28EVK_FLEXCAN_SWITCH, 1);
	283	else
	284	gpio_set_value(MX28EVK_FLEXCAN_SWITCH, 0);
	285	}
	286
	287	static void mx28evk_flexcan0_switch(int enable)
	288	{
	289	flexcan0_en = enable;
	290	mx28evk_flexcan_switch();
	291	}
	292
	293	static void mx28evk_flexcan1_switch(int enable)
	294	{
	295	flexcan1_en = enable;
	296	mx28evk_flexcan_switch();
	297	}
	298
	299	static const struct flexcan_platform_data
	300	mx28evk_flexcan_pdata[] __initconst = {
	301	{
	302	.transceiver_switch = mx28evk_flexcan0_switch,
	303	}, {
	304	.transceiver_switch = mx28evk_flexcan1_switch,
	305	}
	306	};
	307
0590a790 SG	308	/* mxsfb (lcdif) */
	309	static struct fb_videomode mx28evk_video_modes[] = {
	310	{
	311	.name = "Seiko-43WVF1G",
	312	.refresh = 60,
	313	.xres = 800,
	314	.yres = 480,
	315	.pixclock = 29851, /* picosecond (33.5 MHz) */
	316	.left_margin = 89,
	317	.right_margin = 164,
	318	.upper_margin = 23,
	319	.lower_margin = 10,
	320	.hsync_len = 10,
	321	.vsync_len = 10,
	322	.sync = FB_SYNC_DATA_ENABLE_HIGH_ACT \|
	323	FB_SYNC_DOTCLK_FAILING_ACT,
	324	},
	325	};
	326
	327	static const struct mxsfb_platform_data mx28evk_mxsfb_pdata __initconst = {
	328	.mode_list = mx28evk_video_modes,
	329	.mode_count = ARRAY_SIZE(mx28evk_video_modes),
	330	.default_bpp = 32,
	331	.ld_intf_width = STMLCDIF_24BIT,
	332	};
	333
5bb2c828 SG	334	static struct mxs_mmc_platform_data mx28evk_mmc_pdata[] __initdata = {
	335	{
	336	/* mmc0 */
	337	.wp_gpio = MX28EVK_MMC0_WRITE_PROTECT,
	338	.flags = SLOTF_8_BIT_CAPABLE,
	339	}, {
	340	/* mmc1 */
	341	.wp_gpio = MX28EVK_MMC1_WRITE_PROTECT,
	342	.flags = SLOTF_8_BIT_CAPABLE,
	343	},
	344	};
	345
074c54f4 DA	346	static struct i2c_board_info mxs_i2c0_board_info[] __initdata = {
	347	{
	348	I2C_BOARD_INFO("sgtl5000", 0x0a),
	349	},
	350	};
	351
e55e48ff WS	352	#if defined(CONFIG_REGULATOR_FIXED_VOLTAGE) \|\| defined(CONFIG_REGULATOR_FIXED_VOLTAGE_MODULE)
	353	static struct regulator_consumer_supply mx28evk_audio_consumer_supplies[] = {
	354	REGULATOR_SUPPLY("VDDA", "0-000a"),
	355	REGULATOR_SUPPLY("VDDIO", "0-000a"),
	356	};
	357
	358	static struct regulator_init_data mx28evk_vdd_reg_init_data = {
	359	.constraints = {
	360	.name = "3V3",
	361	.always_on = 1,
	362	},
	363	.consumer_supplies = mx28evk_audio_consumer_supplies,
	364	.num_consumer_supplies = ARRAY_SIZE(mx28evk_audio_consumer_supplies),
	365	};
	366
	367	static struct fixed_voltage_config mx28evk_vdd_pdata = {
	368	.supply_name = "board-3V3",
	369	.microvolts = 3300000,
	370	.gpio = -EINVAL,
	371	.enabled_at_boot = 1,
	372	.init_data = &mx28evk_vdd_reg_init_data,
	373	};
	374	static struct platform_device mx28evk_voltage_regulator = {
	375	.name = "reg-fixed-voltage",
	376	.id = -1,
	377	.num_resources = 0,
	378	.dev = {
	379	.platform_data = &mx28evk_vdd_pdata,
	380	},
	381	};
	382	static void __init mx28evk_add_regulators(void)
	383	{
	384	platform_device_register(&mx28evk_voltage_regulator);
	385	}
	386	#else
	387	static void __init mx28evk_add_regulators(void) {}
	388	#endif
	389
c5f98794	390	static const struct gpio mx28evk_gpios[] __initconst = {
a35b9147 FE	391	{ MX28EVK_LCD_ENABLE, GPIOF_OUT_INIT_HIGH, "lcd-enable" },
a35b9147 FE	392	{ MX28EVK_BL_ENABLE, GPIOF_OUT_INIT_HIGH, "bl-enable" },
c5f98794 FE	393	{ MX28EVK_FLEXCAN_SWITCH, GPIOF_DIR_OUT, "flexcan-switch" },
	394	{ MX28EVK_MMC0_SLOT_POWER, GPIOF_OUT_INIT_LOW, "mmc0-slot-power" },
	395	{ MX28EVK_MMC1_SLOT_POWER, GPIOF_OUT_INIT_LOW, "mmc1-slot-power" },
	396	{ MX28EVK_FEC_PHY_POWER, GPIOF_OUT_INIT_LOW, "fec-phy-power" },
	397	{ MX28EVK_FEC_PHY_RESET, GPIOF_DIR_OUT, "fec-phy-reset" },
a35b9147 FE	398	};
a35b9147 FE	399
4c0174c5 DA	400	static const struct mxs_saif_platform_data
	401	mx28evk_mxs_saif_pdata[] __initconst = {
	402	/* working on EXTMSTR0 mode (saif0 master, saif1 slave) */
	403	{
	404	.master_mode = 1,
	405	.master_id = 0,
	406	}, {
	407	.master_mode = 0,
	408	.master_id = 0,
	409	},
	410	};
	411
4afbbb7c SG	412	static void __init mx28evk_init(void)
4afbbb7c SG	413	{
acc9cdca SG	414	int ret;
acc9cdca SG	415
d1654b80 SG	416	mx28_soc_init();
d1654b80 SG	417
4afbbb7c SG	418	mxs_iomux_setup_multiple_pads(mx28evk_pads, ARRAY_SIZE(mx28evk_pads));
	419
	420	mx28_add_duart();
15808182 SG	421	mx28_add_auart0();
15808182 SG	422	mx28_add_auart3();
4afbbb7c	423
a320b279 SG	424	if (mx28evk_fec_get_mac())
	425	pr_warn("%s: failed on fec mac setup\n", __func__);
	426
c5f98794 FE	427	ret = gpio_request_array(mx28evk_gpios, ARRAY_SIZE(mx28evk_gpios));
	428	if (ret)
	429	pr_err("One or more GPIOs failed to be requested: %d\n", ret);
	430
4afbbb7c	431	mx28evk_fec_reset();
48f76ed1 SG	432	mx28_add_fec(0, &mx28_fec_pdata[0]);
48f76ed1 SG	433	mx28_add_fec(1, &mx28_fec_pdata[1]);
acc9cdca	434
c5f98794 FE	435	mx28_add_flexcan(0, &mx28evk_flexcan_pdata[0]);
c5f98794 FE	436	mx28_add_flexcan(1, &mx28evk_flexcan_pdata[1]);
0590a790	437
c5f98794	438	mx28_add_mxsfb(&mx28evk_mxsfb_pdata);
5bb2c828	439
4c0174c5 DA	440	mxs_saif_clkmux_select(MXS_DIGCTL_SAIF_CLKMUX_EXTMSTR0);
	441	mx28_add_saif(0, &mx28evk_mxs_saif_pdata[0]);
	442	mx28_add_saif(1, &mx28evk_mxs_saif_pdata[1]);
c8ebcac8	443
074c54f4 DA	444	mx28_add_mxs_i2c(0);
	445	i2c_register_board_info(0, mxs_i2c0_board_info,
	446	ARRAY_SIZE(mxs_i2c0_board_info));
	447
e55e48ff WS	448	mx28evk_add_regulators();
e55e48ff WS	449
ce9b8e6f DA	450	mxs_add_platform_device("mxs-sgtl5000", 0, NULL, 0,
	451	NULL, 0);
	452
c5f98794 FE	453	mx28_add_mxs_mmc(0, &mx28evk_mmc_pdata[0]);
c5f98794 FE	454	mx28_add_mxs_mmc(1, &mx28evk_mmc_pdata[1]);
53b8ff9d	455
87d022cc	456	mx28_add_rtc_stmp3xxx();
53b8ff9d SG	457
53b8ff9d SG	458	gpio_led_register_device(0, &mx28evk_led_data);
4afbbb7c SG	459	}
	460
	461	static void __init mx28evk_timer_init(void)
	462	{
	463	mx28_clocks_init();
	464	}
	465
	466	static struct sys_timer mx28evk_timer = {
	467	.init = mx28evk_timer_init,
	468	};
	469
	470	MACHINE_START(MX28EVK, "Freescale MX28 EVK")
	471	/* Maintainer: Freescale Semiconductor, Inc. */
	472	.map_io = mx28_map_io,
	473	.init_irq = mx28_init_irq,
4afbbb7c	474	.timer = &mx28evk_timer,
2db3fcf1	475	.init_machine = mx28evk_init,
6f91c5a4	476	.restart = mxs_restart,
4afbbb7c	477	MACHINE_END