[deliverable/linux.git] / arch / arm / mach-omap2 / board-4430sdp.c

/*
 * Board support file for OMAP4430 SDP.
 *
 * Copyright (C) 2009 Texas Instruments
 *
 * Author: Santosh Shilimkar <santosh.shilimkar@ti.com>
 *
 * Based on mach-omap2/board-3430sdp.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/usb/otg.h>
#include <linux/spi/spi.h>
#include <linux/i2c/twl.h>
#include <linux/gpio_keys.h>
#include <linux/regulator/machine.h>
#include <linux/leds.h>
#include <linux/leds_pwm.h>

#include <mach/hardware.h>
#include <mach/omap4-common.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>

#include <plat/board.h>
#include <plat/common.h>
#include <plat/usb.h>
#include <plat/mmc.h>
#include <plat/omap4-keypad.h>

#include "mux.h"
#include "hsmmc.h"
#include "timer-gp.h"
#include "control.h"

#define ETH_KS8851_IRQ			34
#define ETH_KS8851_POWER_ON		48
#define ETH_KS8851_QUART		138
#define OMAP4_SFH7741_SENSOR_OUTPUT_GPIO	184
#define OMAP4_SFH7741_ENABLE_GPIO		188

static const int sdp4430_keymap[] = {
	KEY(0, 0, KEY_E),
	KEY(0, 1, KEY_R),
	KEY(0, 2, KEY_T),
	KEY(0, 3, KEY_HOME),
	KEY(0, 4, KEY_F5),
	KEY(0, 5, KEY_UNKNOWN),
	KEY(0, 6, KEY_I),
	KEY(0, 7, KEY_LEFTSHIFT),

	KEY(1, 0, KEY_D),
	KEY(1, 1, KEY_F),
	KEY(1, 2, KEY_G),
	KEY(1, 3, KEY_SEND),
	KEY(1, 4, KEY_F6),
	KEY(1, 5, KEY_UNKNOWN),
	KEY(1, 6, KEY_K),
	KEY(1, 7, KEY_ENTER),

	KEY(2, 0, KEY_X),
	KEY(2, 1, KEY_C),
	KEY(2, 2, KEY_V),
	KEY(2, 3, KEY_END),
	KEY(2, 4, KEY_F7),
	KEY(2, 5, KEY_UNKNOWN),
	KEY(2, 6, KEY_DOT),
	KEY(2, 7, KEY_CAPSLOCK),

	KEY(3, 0, KEY_Z),
	KEY(3, 1, KEY_KPPLUS),
	KEY(3, 2, KEY_B),
	KEY(3, 3, KEY_F1),
	KEY(3, 4, KEY_F8),
	KEY(3, 5, KEY_UNKNOWN),
	KEY(3, 6, KEY_O),
	KEY(3, 7, KEY_SPACE),

	KEY(4, 0, KEY_W),
	KEY(4, 1, KEY_Y),
	KEY(4, 2, KEY_U),
	KEY(4, 3, KEY_F2),
	KEY(4, 4, KEY_VOLUMEUP),
	KEY(4, 5, KEY_UNKNOWN),
	KEY(4, 6, KEY_L),
	KEY(4, 7, KEY_LEFT),

	KEY(5, 0, KEY_S),
	KEY(5, 1, KEY_H),
	KEY(5, 2, KEY_J),
	KEY(5, 3, KEY_F3),
	KEY(5, 4, KEY_F9),
	KEY(5, 5, KEY_VOLUMEDOWN),
	KEY(5, 6, KEY_M),
	KEY(5, 7, KEY_RIGHT),

	KEY(6, 0, KEY_Q),
	KEY(6, 1, KEY_A),
	KEY(6, 2, KEY_N),
	KEY(6, 3, KEY_BACK),
	KEY(6, 4, KEY_BACKSPACE),
	KEY(6, 5, KEY_UNKNOWN),
	KEY(6, 6, KEY_P),
	KEY(6, 7, KEY_UP),

	KEY(7, 0, KEY_PROG1),
	KEY(7, 1, KEY_PROG2),
	KEY(7, 2, KEY_PROG3),
	KEY(7, 3, KEY_PROG4),
	KEY(7, 4, KEY_F4),
	KEY(7, 5, KEY_UNKNOWN),
	KEY(7, 6, KEY_OK),
	KEY(7, 7, KEY_DOWN),
};

static struct matrix_keymap_data sdp4430_keymap_data = {
	.keymap			= sdp4430_keymap,
	.keymap_size		= ARRAY_SIZE(sdp4430_keymap),
};

static struct omap4_keypad_platform_data sdp4430_keypad_data = {
	.keymap_data		= &sdp4430_keymap_data,
	.rows			= 8,
	.cols			= 8,
};
static struct gpio_led sdp4430_gpio_leds[] = {
	{
		.name	= "omap4:green:debug0",
		.gpio	= 61,
	},
	{
		.name	= "omap4:green:debug1",
		.gpio	= 30,
	},
	{
		.name	= "omap4:green:debug2",
		.gpio	= 7,
	},
	{
		.name	= "omap4:green:debug3",
		.gpio	= 8,
	},
	{
		.name	= "omap4:green:debug4",
		.gpio	= 50,
	},
	{
		.name	= "omap4:blue:user",
		.gpio	= 169,
	},
	{
		.name	= "omap4:red:user",
		.gpio	= 170,
	},
	{
		.name	= "omap4:green:user",
		.gpio	= 139,
	},

};

static struct gpio_keys_button sdp4430_gpio_keys[] = {
	{
		.desc			= "Proximity Sensor",
		.type			= EV_SW,
		.code			= SW_FRONT_PROXIMITY,
		.gpio			= OMAP4_SFH7741_SENSOR_OUTPUT_GPIO,
		.active_low		= 0,
	}
};

static struct gpio_led_platform_data sdp4430_led_data = {
	.leds	= sdp4430_gpio_leds,
	.num_leds	= ARRAY_SIZE(sdp4430_gpio_leds),
};

static struct led_pwm sdp4430_pwm_leds[] = {
	{
		.name		= "omap4:green:chrg",
		.pwm_id		= 1,
		.max_brightness	= 255,
		.pwm_period_ns	= 7812500,
	},
};

static struct led_pwm_platform_data sdp4430_pwm_data = {
	.num_leds	= ARRAY_SIZE(sdp4430_pwm_leds),
	.leds		= sdp4430_pwm_leds,
};

static struct platform_device sdp4430_leds_pwm = {
	.name	= "leds_pwm",
	.id	= -1,
	.dev	= {
		.platform_data = &sdp4430_pwm_data,
	},
};

static int omap_prox_activate(struct device *dev)
{
	gpio_set_value(OMAP4_SFH7741_ENABLE_GPIO , 1);
	return 0;
}

static void omap_prox_deactivate(struct device *dev)
{
	gpio_set_value(OMAP4_SFH7741_ENABLE_GPIO , 0);
}

static struct gpio_keys_platform_data sdp4430_gpio_keys_data = {
	.buttons	= sdp4430_gpio_keys,
	.nbuttons	= ARRAY_SIZE(sdp4430_gpio_keys),
	.enable		= omap_prox_activate,
	.disable	= omap_prox_deactivate,
};

static struct platform_device sdp4430_gpio_keys_device = {
	.name	= "gpio-keys",
	.id	= -1,
	.dev	= {
		.platform_data	= &sdp4430_gpio_keys_data,
	},
};

static struct platform_device sdp4430_leds_gpio = {
	.name	= "leds-gpio",
	.id	= -1,
	.dev	= {
		.platform_data = &sdp4430_led_data,
	},
};
static struct spi_board_info sdp4430_spi_board_info[] __initdata = {
	{
		.modalias               = "ks8851",
		.bus_num                = 1,
		.chip_select            = 0,
		.max_speed_hz           = 24000000,
		.irq                    = ETH_KS8851_IRQ,
	},
};

static int omap_ethernet_init(void)
{
	int status;

	/* Request of GPIO lines */

	status = gpio_request(ETH_KS8851_POWER_ON, "eth_power");
	if (status) {
		pr_err("Cannot request GPIO %d\n", ETH_KS8851_POWER_ON);
		return status;
	}

	status = gpio_request(ETH_KS8851_QUART, "quart");
	if (status) {
		pr_err("Cannot request GPIO %d\n", ETH_KS8851_QUART);
		goto error1;
	}

	status = gpio_request(ETH_KS8851_IRQ, "eth_irq");
	if (status) {
		pr_err("Cannot request GPIO %d\n", ETH_KS8851_IRQ);
		goto error2;
	}

	/* Configuration of requested GPIO lines */

	status = gpio_direction_output(ETH_KS8851_POWER_ON, 1);
	if (status) {
		pr_err("Cannot set output GPIO %d\n", ETH_KS8851_IRQ);
		goto error3;
	}

	status = gpio_direction_output(ETH_KS8851_QUART, 1);
	if (status) {
		pr_err("Cannot set output GPIO %d\n", ETH_KS8851_QUART);
		goto error3;
	}

	status = gpio_direction_input(ETH_KS8851_IRQ);
	if (status) {
		pr_err("Cannot set input GPIO %d\n", ETH_KS8851_IRQ);
		goto error3;
	}

	return 0;

error3:
	gpio_free(ETH_KS8851_IRQ);
error2:
	gpio_free(ETH_KS8851_QUART);
error1:
	gpio_free(ETH_KS8851_POWER_ON);
	return status;
}

static struct platform_device sdp4430_lcd_device = {
	.name		= "sdp4430_lcd",
	.id		= -1,
};

static struct platform_device *sdp4430_devices[] __initdata = {
	&sdp4430_lcd_device,
	&sdp4430_gpio_keys_device,
	&sdp4430_leds_gpio,
	&sdp4430_leds_pwm,
};

static struct omap_lcd_config sdp4430_lcd_config __initdata = {
	.ctrl_name	= "internal",
};

static struct omap_board_config_kernel sdp4430_config[] __initdata = {
	{ OMAP_TAG_LCD,		&sdp4430_lcd_config },
};

static void __init omap_4430sdp_init_early(void)
{
	omap_board_config = sdp4430_config;
	omap_board_config_size = ARRAY_SIZE(sdp4430_config);
	omap2_init_common_infrastructure();
	omap2_init_common_devices(NULL, NULL);
#ifdef CONFIG_OMAP_32K_TIMER
	omap2_gp_clockevent_set_gptimer(1);
#endif
}

static struct omap_musb_board_data musb_board_data = {
	.interface_type		= MUSB_INTERFACE_UTMI,
	.mode			= MUSB_OTG,
	.power			= 100,
};

static struct twl4030_usb_data omap4_usbphy_data = {
	.phy_init	= omap4430_phy_init,
	.phy_exit	= omap4430_phy_exit,
	.phy_power	= omap4430_phy_power,
	.phy_set_clock	= omap4430_phy_set_clk,
};

static struct omap2_hsmmc_info mmc[] = {
	{
		.mmc		= 1,
		.caps		= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
		.gpio_wp	= -EINVAL,
	},
	{
		.mmc		= 2,
		.caps		=  MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
		.gpio_cd	= -EINVAL,
		.gpio_wp	= -EINVAL,
		.nonremovable   = true,
		.ocr_mask	= MMC_VDD_29_30,
	},
	{}	/* Terminator */
};

static struct regulator_consumer_supply sdp4430_vaux_supply[] = {
	{
		.supply = "vmmc",
		.dev_name = "mmci-omap-hs.1",
	},
};
static struct regulator_consumer_supply sdp4430_vmmc_supply[] = {
	{
		.supply = "vmmc",
		.dev_name = "mmci-omap-hs.0",
	},
};

static int omap4_twl6030_hsmmc_late_init(struct device *dev)
{
	int ret = 0;
	struct platform_device *pdev = container_of(dev,
				struct platform_device, dev);
	struct omap_mmc_platform_data *pdata = dev->platform_data;

	/* Setting MMC1 Card detect Irq */
	if (pdev->id == 0) {
		ret = twl6030_mmc_card_detect_config();
		if (ret)
			pr_err("Failed configuring MMC1 card detect\n");
		pdata->slots[0].card_detect_irq = TWL6030_IRQ_BASE +
						MMCDETECT_INTR_OFFSET;
		pdata->slots[0].card_detect = twl6030_mmc_card_detect;
	}
	return ret;
}

static __init void omap4_twl6030_hsmmc_set_late_init(struct device *dev)
{
	struct omap_mmc_platform_data *pdata;

	/* dev can be null if CONFIG_MMC_OMAP_HS is not set */
	if (!dev) {
		pr_err("Failed %s\n", __func__);
		return;
	}
	pdata = dev->platform_data;
	pdata->init =	omap4_twl6030_hsmmc_late_init;
}

static int __init omap4_twl6030_hsmmc_init(struct omap2_hsmmc_info *controllers)
{
	struct omap2_hsmmc_info *c;

	omap2_hsmmc_init(controllers);
	for (c = controllers; c->mmc; c++)
		omap4_twl6030_hsmmc_set_late_init(c->dev);

	return 0;
}

static struct regulator_init_data sdp4430_vaux1 = {
	.constraints = {
		.min_uV			= 1000000,
		.max_uV			= 3000000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies  = 1,
	.consumer_supplies      = sdp4430_vaux_supply,
};

static struct regulator_init_data sdp4430_vaux2 = {
	.constraints = {
		.min_uV			= 1200000,
		.max_uV			= 2800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data sdp4430_vaux3 = {
	.constraints = {
		.min_uV			= 1000000,
		.max_uV			= 3000000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

/* VMMC1 for MMC1 card */
static struct regulator_init_data sdp4430_vmmc = {
	.constraints = {
		.min_uV			= 1200000,
		.max_uV			= 3000000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies  = 1,
	.consumer_supplies      = sdp4430_vmmc_supply,
};

static struct regulator_init_data sdp4430_vpp = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 2500000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data sdp4430_vusim = {
	.constraints = {
		.min_uV			= 1200000,
		.max_uV			= 2900000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data sdp4430_vana = {
	.constraints = {
		.min_uV			= 2100000,
		.max_uV			= 2100000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data sdp4430_vcxio = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data sdp4430_vdac = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 = REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data sdp4430_vusb = {
	.constraints = {
		.min_uV			= 3300000,
		.max_uV			= 3300000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask	 =	REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct twl4030_platform_data sdp4430_twldata = {
	.irq_base	= TWL6030_IRQ_BASE,
	.irq_end	= TWL6030_IRQ_END,

	/* Regulators */
	.vmmc		= &sdp4430_vmmc,
	.vpp		= &sdp4430_vpp,
	.vusim		= &sdp4430_vusim,
	.vana		= &sdp4430_vana,
	.vcxio		= &sdp4430_vcxio,
	.vdac		= &sdp4430_vdac,
	.vusb		= &sdp4430_vusb,
	.vaux1		= &sdp4430_vaux1,
	.vaux2		= &sdp4430_vaux2,
	.vaux3		= &sdp4430_vaux3,
	.usb		= &omap4_usbphy_data
};

static struct i2c_board_info __initdata sdp4430_i2c_boardinfo[] = {
	{
		I2C_BOARD_INFO("twl6030", 0x48),
		.flags = I2C_CLIENT_WAKE,
		.irq = OMAP44XX_IRQ_SYS_1N,
		.platform_data = &sdp4430_twldata,
	},
};
static struct i2c_board_info __initdata sdp4430_i2c_3_boardinfo[] = {
	{
		I2C_BOARD_INFO("tmp105", 0x48),
	},
	{
		I2C_BOARD_INFO("bh1780", 0x29),
	},
};
static struct i2c_board_info __initdata sdp4430_i2c_4_boardinfo[] = {
	{
		I2C_BOARD_INFO("hmc5843", 0x1e),
	},
};
static int __init omap4_i2c_init(void)
{
	/*
	 * Phoenix Audio IC needs I2C1 to
	 * start with 400 KHz or less
	 */
	omap_register_i2c_bus(1, 400, sdp4430_i2c_boardinfo,
			ARRAY_SIZE(sdp4430_i2c_boardinfo));
	omap_register_i2c_bus(2, 400, NULL, 0);
	omap_register_i2c_bus(3, 400, sdp4430_i2c_3_boardinfo,
				ARRAY_SIZE(sdp4430_i2c_3_boardinfo));
	omap_register_i2c_bus(4, 400, sdp4430_i2c_4_boardinfo,
				ARRAY_SIZE(sdp4430_i2c_4_boardinfo));
	return 0;
}

static void __init omap_sfh7741prox_init(void)
{
	int  error;

	error = gpio_request(OMAP4_SFH7741_ENABLE_GPIO, "sfh7741");
	if (error < 0) {
		pr_err("%s:failed to request GPIO %d, error %d\n",
			__func__, OMAP4_SFH7741_ENABLE_GPIO, error);
		return;
	}

	error = gpio_direction_output(OMAP4_SFH7741_ENABLE_GPIO , 0);
	if (error < 0) {
		pr_err("%s: GPIO configuration failed: GPIO %d,error %d\n",
			 __func__, OMAP4_SFH7741_ENABLE_GPIO, error);
		gpio_free(OMAP4_SFH7741_ENABLE_GPIO);
	}
}

#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux board_mux[] __initdata = {
	OMAP4_MUX(USBB2_ULPITLL_CLK, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT),
	{ .reg_offset = OMAP_MUX_TERMINATOR },
};
#else
#define board_mux	NULL
#endif

static void __init omap_4430sdp_init(void)
{
	int status;
	int package = OMAP_PACKAGE_CBS;

	if (omap_rev() == OMAP4430_REV_ES1_0)
		package = OMAP_PACKAGE_CBL;
	omap4_mux_init(board_mux, package);

	omap4_i2c_init();
	omap_sfh7741prox_init();
	platform_add_devices(sdp4430_devices, ARRAY_SIZE(sdp4430_devices));
	omap_serial_init();
	omap4_twl6030_hsmmc_init(mmc);

	usb_musb_init(&musb_board_data);

	status = omap_ethernet_init();
	if (status) {
		pr_err("Ethernet initialization failed: %d\n", status);
	} else {
		sdp4430_spi_board_info[0].irq = gpio_to_irq(ETH_KS8851_IRQ);
		spi_register_board_info(sdp4430_spi_board_info,
				ARRAY_SIZE(sdp4430_spi_board_info));
	}

	status = omap4_keyboard_init(&sdp4430_keypad_data);
	if (status)
		pr_err("Keypad initialization failed: %d\n", status);
}

static void __init omap_4430sdp_map_io(void)
{
	omap2_set_globals_443x();
	omap44xx_map_common_io();
}

MACHINE_START(OMAP_4430SDP, "OMAP4430 4430SDP board")
	/* Maintainer: Santosh Shilimkar - Texas Instruments Inc */
	.boot_params	= 0x80000100,
	.reserve	= omap_reserve,
	.map_io		= omap_4430sdp_map_io,
	.init_early	= omap_4430sdp_init_early,
	.init_irq	= gic_init_irq,
	.init_machine	= omap_4430sdp_init,
	.timer		= &omap_timer,
MACHINE_END
Commit	Line	Data
46ba0abf SS	1	/*
	2	* Board support file for OMAP4430 SDP.
	3	*
	4	* Copyright (C) 2009 Texas Instruments
	5	*
	6	* Author: Santosh Shilimkar <santosh.shilimkar@ti.com>
	7	*
	8	* Based on mach-omap2/board-3430sdp.c
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/io.h>
	19	#include <linux/gpio.h>
bce06683	20	#include <linux/usb/otg.h>
b2aa5e57	21	#include <linux/spi/spi.h>
6e30a7db	22	#include <linux/i2c/twl.h>
94ce7a66	23	#include <linux/gpio_keys.h>
6e30a7db	24	#include <linux/regulator/machine.h>
509b6d93	25	#include <linux/leds.h>
f389f4cb	26	#include <linux/leds_pwm.h>
46ba0abf SS	27
46ba0abf SS	28	#include <mach/hardware.h>
fbc9be10	29	#include <mach/omap4-common.h>
46ba0abf SS	30	#include <asm/mach-types.h>
	31	#include <asm/mach/arch.h>
	32	#include <asm/mach/map.h>
	33
ce491cf8 TL	34	#include <plat/board.h>
ce491cf8 TL	35	#include <plat/common.h>
bce06683	36	#include <plat/usb.h>
717c1fbf	37	#include <plat/mmc.h>
59556765	38	#include <plat/omap4-keypad.h>
04aeae77	39
fb6bf632	40	#include "mux.h"
717c1fbf	41	#include "hsmmc.h"
04aeae77	42	#include "timer-gp.h"
4814ced5	43	#include "control.h"
46ba0abf	44
b2aa5e57 AA	45	#define ETH_KS8851_IRQ 34
	46	#define ETH_KS8851_POWER_ON 48
	47	#define ETH_KS8851_QUART 138
94ce7a66 SD	48	#define OMAP4_SFH7741_SENSOR_OUTPUT_GPIO 184
94ce7a66 SD	49	#define OMAP4_SFH7741_ENABLE_GPIO 188
b2aa5e57	50
59556765 SR	51	static const int sdp4430_keymap[] = {
	52	KEY(0, 0, KEY_E),
	53	KEY(0, 1, KEY_R),
	54	KEY(0, 2, KEY_T),
	55	KEY(0, 3, KEY_HOME),
	56	KEY(0, 4, KEY_F5),
	57	KEY(0, 5, KEY_UNKNOWN),
	58	KEY(0, 6, KEY_I),
	59	KEY(0, 7, KEY_LEFTSHIFT),
	60
	61	KEY(1, 0, KEY_D),
	62	KEY(1, 1, KEY_F),
	63	KEY(1, 2, KEY_G),
	64	KEY(1, 3, KEY_SEND),
	65	KEY(1, 4, KEY_F6),
	66	KEY(1, 5, KEY_UNKNOWN),
	67	KEY(1, 6, KEY_K),
	68	KEY(1, 7, KEY_ENTER),
	69
	70	KEY(2, 0, KEY_X),
	71	KEY(2, 1, KEY_C),
	72	KEY(2, 2, KEY_V),
	73	KEY(2, 3, KEY_END),
	74	KEY(2, 4, KEY_F7),
	75	KEY(2, 5, KEY_UNKNOWN),
	76	KEY(2, 6, KEY_DOT),
	77	KEY(2, 7, KEY_CAPSLOCK),
	78
	79	KEY(3, 0, KEY_Z),
	80	KEY(3, 1, KEY_KPPLUS),
	81	KEY(3, 2, KEY_B),
	82	KEY(3, 3, KEY_F1),
	83	KEY(3, 4, KEY_F8),
	84	KEY(3, 5, KEY_UNKNOWN),
	85	KEY(3, 6, KEY_O),
	86	KEY(3, 7, KEY_SPACE),
	87
	88	KEY(4, 0, KEY_W),
	89	KEY(4, 1, KEY_Y),
	90	KEY(4, 2, KEY_U),
	91	KEY(4, 3, KEY_F2),
	92	KEY(4, 4, KEY_VOLUMEUP),
	93	KEY(4, 5, KEY_UNKNOWN),
	94	KEY(4, 6, KEY_L),
	95	KEY(4, 7, KEY_LEFT),
	96
	97	KEY(5, 0, KEY_S),
	98	KEY(5, 1, KEY_H),
	99	KEY(5, 2, KEY_J),
	100	KEY(5, 3, KEY_F3),
	101	KEY(5, 4, KEY_F9),
	102	KEY(5, 5, KEY_VOLUMEDOWN),
	103	KEY(5, 6, KEY_M),
	104	KEY(5, 7, KEY_RIGHT),
	105
	106	KEY(6, 0, KEY_Q),
	107	KEY(6, 1, KEY_A),
	108	KEY(6, 2, KEY_N),
	109	KEY(6, 3, KEY_BACK),
	110	KEY(6, 4, KEY_BACKSPACE),
	111	KEY(6, 5, KEY_UNKNOWN),
	112	KEY(6, 6, KEY_P),
	113	KEY(6, 7, KEY_UP),
	114
115	KEY(7, 0, KEY_PROG1),
116	KEY(7, 1, KEY_PROG2),
117	KEY(7, 2, KEY_PROG3),
118	KEY(7, 3, KEY_PROG4),
119	KEY(7, 4, KEY_F4),
120	KEY(7, 5, KEY_UNKNOWN),
121	KEY(7, 6, KEY_OK),
122	KEY(7, 7, KEY_DOWN),
123	};
124
125	static struct matrix_keymap_data sdp4430_keymap_data = {
126	.keymap = sdp4430_keymap,
127	.keymap_size = ARRAY_SIZE(sdp4430_keymap),
128	};
129
130	static struct omap4_keypad_platform_data sdp4430_keypad_data = {
131	.keymap_data = &sdp4430_keymap_data,
132	.rows = 8,
133	.cols = 8,
134	};
509b6d93 H	135	static struct gpio_led sdp4430_gpio_leds[] = {
	136	{
	137	.name = "omap4:green:debug0",
	138	.gpio = 61,
	139	},
	140	{
	141	.name = "omap4:green:debug1",
	142	.gpio = 30,
	143	},
	144	{
	145	.name = "omap4:green:debug2",
	146	.gpio = 7,
	147	},
	148	{
	149	.name = "omap4:green:debug3",
	150	.gpio = 8,
	151	},
	152	{
	153	.name = "omap4:green:debug4",
	154	.gpio = 50,
	155	},
	156	{
	157	.name = "omap4:blue:user",
	158	.gpio = 169,
	159	},
	160	{
	161	.name = "omap4:red:user",
	162	.gpio = 170,
	163	},
	164	{
	165	.name = "omap4:green:user",
	166	.gpio = 139,
	167	},
	168
	169	};
	170
94ce7a66 SD	171	static struct gpio_keys_button sdp4430_gpio_keys[] = {
	172	{
	173	.desc = "Proximity Sensor",
	174	.type = EV_SW,
	175	.code = SW_FRONT_PROXIMITY,
	176	.gpio = OMAP4_SFH7741_SENSOR_OUTPUT_GPIO,
	177	.active_low = 0,
	178	}
	179	};
	180
509b6d93 H	181	static struct gpio_led_platform_data sdp4430_led_data = {
	182	.leds = sdp4430_gpio_leds,
	183	.num_leds = ARRAY_SIZE(sdp4430_gpio_leds),
	184	};
	185
f389f4cb H	186	static struct led_pwm sdp4430_pwm_leds[] = {
	187	{
	188	.name = "omap4:green:chrg",
	189	.pwm_id = 1,
	190	.max_brightness = 255,
	191	.pwm_period_ns = 7812500,
	192	},
	193	};
	194
	195	static struct led_pwm_platform_data sdp4430_pwm_data = {
	196	.num_leds = ARRAY_SIZE(sdp4430_pwm_leds),
	197	.leds = sdp4430_pwm_leds,
	198	};
	199
	200	static struct platform_device sdp4430_leds_pwm = {
	201	.name = "leds_pwm",
	202	.id = -1,
	203	.dev = {
	204	.platform_data = &sdp4430_pwm_data,
	205	},
	206	};
	207
94ce7a66 SD	208	static int omap_prox_activate(struct device *dev)
	209	{
	210	gpio_set_value(OMAP4_SFH7741_ENABLE_GPIO , 1);
	211	return 0;
	212	}
	213
	214	static void omap_prox_deactivate(struct device *dev)
	215	{
	216	gpio_set_value(OMAP4_SFH7741_ENABLE_GPIO , 0);
	217	}
	218
	219	static struct gpio_keys_platform_data sdp4430_gpio_keys_data = {
	220	.buttons = sdp4430_gpio_keys,
	221	.nbuttons = ARRAY_SIZE(sdp4430_gpio_keys),
	222	.enable = omap_prox_activate,
	223	.disable = omap_prox_deactivate,
	224	};
	225
	226	static struct platform_device sdp4430_gpio_keys_device = {
	227	.name = "gpio-keys",
	228	.id = -1,
	229	.dev = {
	230	.platform_data = &sdp4430_gpio_keys_data,
	231	},
	232	};
	233
509b6d93 H	234	static struct platform_device sdp4430_leds_gpio = {
	235	.name = "leds-gpio",
	236	.id = -1,
	237	.dev = {
	238	.platform_data = &sdp4430_led_data,
	239	},
	240	};
b2aa5e57 AA	241	static struct spi_board_info sdp4430_spi_board_info[] __initdata = {
	242	{
	243	.modalias = "ks8851",
	244	.bus_num = 1,
	245	.chip_select = 0,
	246	.max_speed_hz = 24000000,
	247	.irq = ETH_KS8851_IRQ,
	248	},
	249	};
	250
	251	static int omap_ethernet_init(void)
	252	{
	253	int status;
	254
	255	/* Request of GPIO lines */
	256
	257	status = gpio_request(ETH_KS8851_POWER_ON, "eth_power");
	258	if (status) {
	259	pr_err("Cannot request GPIO %d\n", ETH_KS8851_POWER_ON);
	260	return status;
	261	}
	262
	263	status = gpio_request(ETH_KS8851_QUART, "quart");
	264	if (status) {
	265	pr_err("Cannot request GPIO %d\n", ETH_KS8851_QUART);
	266	goto error1;
	267	}
	268
	269	status = gpio_request(ETH_KS8851_IRQ, "eth_irq");
	270	if (status) {
	271	pr_err("Cannot request GPIO %d\n", ETH_KS8851_IRQ);
	272	goto error2;
	273	}
	274
	275	/* Configuration of requested GPIO lines */
	276
	277	status = gpio_direction_output(ETH_KS8851_POWER_ON, 1);
	278	if (status) {
	279	pr_err("Cannot set output GPIO %d\n", ETH_KS8851_IRQ);
	280	goto error3;
	281	}
	282
	283	status = gpio_direction_output(ETH_KS8851_QUART, 1);
	284	if (status) {
	285	pr_err("Cannot set output GPIO %d\n", ETH_KS8851_QUART);
	286	goto error3;
	287	}
	288
	289	status = gpio_direction_input(ETH_KS8851_IRQ);
	290	if (status) {
	291	pr_err("Cannot set input GPIO %d\n", ETH_KS8851_IRQ);
	292	goto error3;
	293	}
	294
	295	return 0;
	296
	297	error3:
	298	gpio_free(ETH_KS8851_IRQ);
	299	error2:
	300	gpio_free(ETH_KS8851_QUART);
	301	error1:
	302	gpio_free(ETH_KS8851_POWER_ON);
	303	return status;
	304	}
305
46ba0abf SS	306	static struct platform_device sdp4430_lcd_device = {
	307	.name = "sdp4430_lcd",
	308	.id = -1,
	309	};
	310
	311	static struct platform_device *sdp4430_devices[] __initdata = {
	312	&sdp4430_lcd_device,
94ce7a66	313	&sdp4430_gpio_keys_device,
509b6d93	314	&sdp4430_leds_gpio,
f389f4cb	315	&sdp4430_leds_pwm,
46ba0abf SS	316	};
46ba0abf SS	317
46ba0abf SS	318	static struct omap_lcd_config sdp4430_lcd_config __initdata = {
	319	.ctrl_name = "internal",
	320	};
	321
	322	static struct omap_board_config_kernel sdp4430_config[] __initdata = {
46ba0abf SS	323	{ OMAP_TAG_LCD, &sdp4430_lcd_config },
	324	};
	325
3dc3bad6	326	static void __init omap_4430sdp_init_early(void)
46ba0abf	327	{
5b7815b5 SS	328	omap_board_config = sdp4430_config;
5b7815b5 SS	329	omap_board_config_size = ARRAY_SIZE(sdp4430_config);
4805734b PW	330	omap2_init_common_infrastructure();
4805734b PW	331	omap2_init_common_devices(NULL, NULL);
46ba0abf SS	332	#ifdef CONFIG_OMAP_32K_TIMER
	333	omap2_gp_clockevent_set_gptimer(1);
	334	#endif
46ba0abf SS	335	}
46ba0abf SS	336
bce06683 MM	337	static struct omap_musb_board_data musb_board_data = {
bce06683 MM	338	.interface_type = MUSB_INTERFACE_UTMI,
09e72002	339	.mode = MUSB_OTG,
bce06683 MM	340	.power = 100,
bce06683 MM	341	};
717c1fbf	342
e70357e3 HH	343	static struct twl4030_usb_data omap4_usbphy_data = {
	344	.phy_init = omap4430_phy_init,
	345	.phy_exit = omap4430_phy_exit,
	346	.phy_power = omap4430_phy_power,
	347	.phy_set_clock = omap4430_phy_set_clk,
	348	};
	349
717c1fbf	350	static struct omap2_hsmmc_info mmc[] = {
6e30a7db	351	{
717c1fbf	352	.mmc = 1,
3a63833e	353	.caps = MMC_CAP_4_BIT_DATA \| MMC_CAP_8_BIT_DATA,
717c1fbf	354	.gpio_wp = -EINVAL,
6e30a7db B	355	},
6e30a7db B	356	{
717c1fbf	357	.mmc = 2,
3a63833e	358	.caps = MMC_CAP_4_BIT_DATA \| MMC_CAP_8_BIT_DATA,
717c1fbf	359	.gpio_cd = -EINVAL,
	360	.gpio_wp = -EINVAL,
	361	.nonremovable = true,
64be9782	362	.ocr_mask = MMC_VDD_29_30,
6e30a7db	363	},
717c1fbf	364	{} /* Terminator */
	365	};
	366
5026391c	367	static struct regulator_consumer_supply sdp4430_vaux_supply[] = {
6e30a7db B	368	{
6e30a7db B	369	.supply = "vmmc",
5026391c	370	.dev_name = "mmci-omap-hs.1",
6e30a7db	371	},
5026391c SS	372	};
5026391c SS	373	static struct regulator_consumer_supply sdp4430_vmmc_supply[] = {
6e30a7db B	374	{
6e30a7db B	375	.supply = "vmmc",
5026391c	376	.dev_name = "mmci-omap-hs.0",
6e30a7db B	377	},
	378	};
	379
717c1fbf	380	static int omap4_twl6030_hsmmc_late_init(struct device *dev)
	381	{
	382	int ret = 0;
	383	struct platform_device *pdev = container_of(dev,
	384	struct platform_device, dev);
	385	struct omap_mmc_platform_data *pdata = dev->platform_data;
	386
	387	/* Setting MMC1 Card detect Irq */
72f2e2c7	388	if (pdev->id == 0) {
	389	ret = twl6030_mmc_card_detect_config();
	390	if (ret)
	391	pr_err("Failed configuring MMC1 card detect\n");
717c1fbf	392	pdata->slots[0].card_detect_irq = TWL6030_IRQ_BASE +
717c1fbf	393	MMCDETECT_INTR_OFFSET;
72f2e2c7	394	pdata->slots[0].card_detect = twl6030_mmc_card_detect;
72f2e2c7	395	}
717c1fbf	396	return ret;
	397	}
	398
	399	static __init void omap4_twl6030_hsmmc_set_late_init(struct device *dev)
	400	{
531c21ba	401	struct omap_mmc_platform_data *pdata;
717c1fbf	402
531c21ba BC	403	/* dev can be null if CONFIG_MMC_OMAP_HS is not set */
	404	if (!dev) {
	405	pr_err("Failed %s\n", __func__);
	406	return;
	407	}
	408	pdata = dev->platform_data;
717c1fbf	409	pdata->init = omap4_twl6030_hsmmc_late_init;
	410	}
	411
	412	static int __init omap4_twl6030_hsmmc_init(struct omap2_hsmmc_info *controllers)
	413	{
	414	struct omap2_hsmmc_info *c;
	415
	416	omap2_hsmmc_init(controllers);
	417	for (c = controllers; c->mmc; c++)
	418	omap4_twl6030_hsmmc_set_late_init(c->dev);
	419
	420	return 0;
	421	}
	422
6e30a7db B	423	static struct regulator_init_data sdp4430_vaux1 = {
	424	.constraints = {
	425	.min_uV = 1000000,
	426	.max_uV = 3000000,
	427	.apply_uV = true,
	428	.valid_modes_mask = REGULATOR_MODE_NORMAL
	429	\| REGULATOR_MODE_STANDBY,
	430	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	431	\| REGULATOR_CHANGE_MODE
	432	\| REGULATOR_CHANGE_STATUS,
	433	},
5026391c SS	434	.num_consumer_supplies = 1,
5026391c SS	435	.consumer_supplies = sdp4430_vaux_supply,
6e30a7db B	436	};
	437
	438	static struct regulator_init_data sdp4430_vaux2 = {
	439	.constraints = {
	440	.min_uV = 1200000,
	441	.max_uV = 2800000,
	442	.apply_uV = true,
	443	.valid_modes_mask = REGULATOR_MODE_NORMAL
	444	\| REGULATOR_MODE_STANDBY,
	445	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	446	\| REGULATOR_CHANGE_MODE
	447	\| REGULATOR_CHANGE_STATUS,
	448	},
	449	};
	450
	451	static struct regulator_init_data sdp4430_vaux3 = {
	452	.constraints = {
	453	.min_uV = 1000000,
	454	.max_uV = 3000000,
	455	.apply_uV = true,
	456	.valid_modes_mask = REGULATOR_MODE_NORMAL
	457	\| REGULATOR_MODE_STANDBY,
	458	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	459	\| REGULATOR_CHANGE_MODE
	460	\| REGULATOR_CHANGE_STATUS,
	461	},
	462	};
	463
	464	/* VMMC1 for MMC1 card */
	465	static struct regulator_init_data sdp4430_vmmc = {
	466	.constraints = {
	467	.min_uV = 1200000,
	468	.max_uV = 3000000,
	469	.apply_uV = true,
	470	.valid_modes_mask = REGULATOR_MODE_NORMAL
	471	\| REGULATOR_MODE_STANDBY,
	472	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	473	\| REGULATOR_CHANGE_MODE
	474	\| REGULATOR_CHANGE_STATUS,
	475	},
5026391c	476	.num_consumer_supplies = 1,
6e30a7db B	477	.consumer_supplies = sdp4430_vmmc_supply,
	478	};
	479
	480	static struct regulator_init_data sdp4430_vpp = {
	481	.constraints = {
	482	.min_uV = 1800000,
	483	.max_uV = 2500000,
	484	.apply_uV = true,
	485	.valid_modes_mask = REGULATOR_MODE_NORMAL
	486	\| REGULATOR_MODE_STANDBY,
	487	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	488	\| REGULATOR_CHANGE_MODE
	489	\| REGULATOR_CHANGE_STATUS,
	490	},
	491	};
	492
	493	static struct regulator_init_data sdp4430_vusim = {
	494	.constraints = {
	495	.min_uV = 1200000,
	496	.max_uV = 2900000,
	497	.apply_uV = true,
	498	.valid_modes_mask = REGULATOR_MODE_NORMAL
	499	\| REGULATOR_MODE_STANDBY,
	500	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	501	\| REGULATOR_CHANGE_MODE
	502	\| REGULATOR_CHANGE_STATUS,
	503	},
	504	};
	505
	506	static struct regulator_init_data sdp4430_vana = {
	507	.constraints = {
	508	.min_uV = 2100000,
	509	.max_uV = 2100000,
6e30a7db B	510	.valid_modes_mask = REGULATOR_MODE_NORMAL
	511	\| REGULATOR_MODE_STANDBY,
	512	.valid_ops_mask = REGULATOR_CHANGE_MODE
	513	\| REGULATOR_CHANGE_STATUS,
	514	},
	515	};
	516
	517	static struct regulator_init_data sdp4430_vcxio = {
	518	.constraints = {
	519	.min_uV = 1800000,
	520	.max_uV = 1800000,
6e30a7db B	521	.valid_modes_mask = REGULATOR_MODE_NORMAL
	522	\| REGULATOR_MODE_STANDBY,
	523	.valid_ops_mask = REGULATOR_CHANGE_MODE
	524	\| REGULATOR_CHANGE_STATUS,
	525	},
	526	};
	527
	528	static struct regulator_init_data sdp4430_vdac = {
	529	.constraints = {
	530	.min_uV = 1800000,
	531	.max_uV = 1800000,
6e30a7db B	532	.valid_modes_mask = REGULATOR_MODE_NORMAL
	533	\| REGULATOR_MODE_STANDBY,
	534	.valid_ops_mask = REGULATOR_CHANGE_MODE
	535	\| REGULATOR_CHANGE_STATUS,
	536	},
	537	};
	538
	539	static struct regulator_init_data sdp4430_vusb = {
	540	.constraints = {
	541	.min_uV = 3300000,
	542	.max_uV = 3300000,
	543	.apply_uV = true,
	544	.valid_modes_mask = REGULATOR_MODE_NORMAL
	545	\| REGULATOR_MODE_STANDBY,
	546	.valid_ops_mask = REGULATOR_CHANGE_MODE
	547	\| REGULATOR_CHANGE_STATUS,
	548	},
	549	};
	550
	551	static struct twl4030_platform_data sdp4430_twldata = {
	552	.irq_base = TWL6030_IRQ_BASE,
	553	.irq_end = TWL6030_IRQ_END,
	554
	555	/* Regulators */
	556	.vmmc = &sdp4430_vmmc,
	557	.vpp = &sdp4430_vpp,
	558	.vusim = &sdp4430_vusim,
	559	.vana = &sdp4430_vana,
	560	.vcxio = &sdp4430_vcxio,
	561	.vdac = &sdp4430_vdac,
	562	.vusb = &sdp4430_vusb,
	563	.vaux1 = &sdp4430_vaux1,
	564	.vaux2 = &sdp4430_vaux2,
	565	.vaux3 = &sdp4430_vaux3,
e70357e3	566	.usb = &omap4_usbphy_data
6e30a7db B	567	};
	568
	569	static struct i2c_board_info __initdata sdp4430_i2c_boardinfo[] = {
	570	{
	571	I2C_BOARD_INFO("twl6030", 0x48),
	572	.flags = I2C_CLIENT_WAKE,
	573	.irq = OMAP44XX_IRQ_SYS_1N,
	574	.platform_data = &sdp4430_twldata,
	575	},
	576	};
83078f9b SD	577	static struct i2c_board_info __initdata sdp4430_i2c_3_boardinfo[] = {
	578	{
	579	I2C_BOARD_INFO("tmp105", 0x48),
	580	},
d048aca2 H	581	{
	582	I2C_BOARD_INFO("bh1780", 0x29),
	583	},
83078f9b	584	};
0df891bb SD	585	static struct i2c_board_info __initdata sdp4430_i2c_4_boardinfo[] = {
	586	{
	587	I2C_BOARD_INFO("hmc5843", 0x1e),
	588	},
	589	};
baeb73e8 SS	590	static int __init omap4_i2c_init(void)
	591	{
	592	/*
	593	* Phoenix Audio IC needs I2C1 to
	594	* start with 400 KHz or less
	595	*/
6e30a7db B	596	omap_register_i2c_bus(1, 400, sdp4430_i2c_boardinfo,
6e30a7db B	597	ARRAY_SIZE(sdp4430_i2c_boardinfo));
baeb73e8	598	omap_register_i2c_bus(2, 400, NULL, 0);
83078f9b SD	599	omap_register_i2c_bus(3, 400, sdp4430_i2c_3_boardinfo,
83078f9b SD	600	ARRAY_SIZE(sdp4430_i2c_3_boardinfo));
0df891bb SD	601	omap_register_i2c_bus(4, 400, sdp4430_i2c_4_boardinfo,
0df891bb SD	602	ARRAY_SIZE(sdp4430_i2c_4_boardinfo));
baeb73e8 SS	603	return 0;
baeb73e8 SS	604	}
94ce7a66 SD	605
	606	static void __init omap_sfh7741prox_init(void)
	607	{
	608	int error;
	609
	610	error = gpio_request(OMAP4_SFH7741_ENABLE_GPIO, "sfh7741");
	611	if (error < 0) {
	612	pr_err("%s:failed to request GPIO %d, error %d\n",
	613	__func__, OMAP4_SFH7741_ENABLE_GPIO, error);
	614	return;
	615	}
	616
	617	error = gpio_direction_output(OMAP4_SFH7741_ENABLE_GPIO , 0);
	618	if (error < 0) {
	619	pr_err("%s: GPIO configuration failed: GPIO %d,error %d\n",
	620	__func__, OMAP4_SFH7741_ENABLE_GPIO, error);
	621	gpio_free(OMAP4_SFH7741_ENABLE_GPIO);
	622	}
	623	}
	624
fb6bf632 BC	625	#ifdef CONFIG_OMAP_MUX
fb6bf632 BC	626	static struct omap_board_mux board_mux[] __initdata = {
7d4ca85a	627	OMAP4_MUX(USBB2_ULPITLL_CLK, OMAP_MUX_MODE4 \| OMAP_PIN_OUTPUT),
fb6bf632 BC	628	{ .reg_offset = OMAP_MUX_TERMINATOR },
	629	};
	630	#else
	631	#define board_mux NULL
	632	#endif
	633
46ba0abf SS	634	static void __init omap_4430sdp_init(void)
46ba0abf SS	635	{
b2aa5e57	636	int status;
6fea7b0a BC	637	int package = OMAP_PACKAGE_CBS;
	638
	639	if (omap_rev() == OMAP4430_REV_ES1_0)
	640	package = OMAP_PACKAGE_CBL;
	641	omap4_mux_init(board_mux, package);
b2aa5e57	642
baeb73e8	643	omap4_i2c_init();
94ce7a66	644	omap_sfh7741prox_init();
46ba0abf	645	platform_add_devices(sdp4430_devices, ARRAY_SIZE(sdp4430_devices));
46ba0abf	646	omap_serial_init();
717c1fbf	647	omap4_twl6030_hsmmc_init(mmc);
6aa85a5a	648
46960847	649	usb_musb_init(&musb_board_data);
b2aa5e57 AA	650
	651	status = omap_ethernet_init();
	652	if (status) {
	653	pr_err("Ethernet initialization failed: %d\n", status);
	654	} else {
	655	sdp4430_spi_board_info[0].irq = gpio_to_irq(ETH_KS8851_IRQ);
	656	spi_register_board_info(sdp4430_spi_board_info,
	657	ARRAY_SIZE(sdp4430_spi_board_info));
	658	}
59556765 SR	659
	660	status = omap4_keyboard_init(&sdp4430_keypad_data);
	661	if (status)
	662	pr_err("Keypad initialization failed: %d\n", status);
46ba0abf SS	663	}
	664
	665	static void __init omap_4430sdp_map_io(void)
	666	{
	667	omap2_set_globals_443x();
6fbd55d0	668	omap44xx_map_common_io();
46ba0abf SS	669	}
	670
	671	MACHINE_START(OMAP_4430SDP, "OMAP4430 4430SDP board")
	672	/* Maintainer: Santosh Shilimkar - Texas Instruments Inc */
46ba0abf	673	.boot_params = 0x80000100,
71ee7dad	674	.reserve = omap_reserve,
3dc3bad6 RKAL	675	.map_io = omap_4430sdp_map_io,
	676	.init_early = omap_4430sdp_init_early,
	677	.init_irq = gic_init_irq,
46ba0abf SS	678	.init_machine = omap_4430sdp_init,
	679	.timer = &omap_timer,
	680	MACHINE_END