[linux-2.6-block.git] / arch / arm / mach-davinci / board-dm646x-evm.c

/*
 * TI DaVinci DM646X EVM board
 *
 * Derived from: arch/arm/mach-davinci/board-evm.c
 * Copyright (C) 2006 Texas Instruments.
 *
 * (C) 2007-2008, MontaVista Software, Inc.
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 *
 */

/**************************************************************************
 * Included Files
 **************************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/major.h>
#include <linux/root_dev.h>
#include <linux/dma-mapping.h>
#include <linux/serial.h>
#include <linux/serial_8250.h>
#include <linux/leds.h>
#include <linux/gpio.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/i2c.h>
#include <linux/i2c/at24.h>
#include <linux/i2c/pcf857x.h>
#include <linux/etherdevice.h>

#include <asm/setup.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/flash.h>

#include <mach/dm646x.h>
#include <mach/common.h>
#include <mach/psc.h>
#include <mach/serial.h>
#include <mach/i2c.h>
#include <mach/mmc.h>
#include <mach/emac.h>
#include <mach/common.h>

#define DM646X_EVM_PHY_MASK		(0x2)
#define DM646X_EVM_MDIO_FREQUENCY	(2200000) /* PHY bus frequency */

static struct davinci_uart_config uart_config __initdata = {
	.enabled_uarts = (1 << 0),
};

/* LEDS */

static struct gpio_led evm_leds[] = {
	{ .name = "DS1", .active_low = 1, },
	{ .name = "DS2", .active_low = 1, },
	{ .name = "DS3", .active_low = 1, },
	{ .name = "DS4", .active_low = 1, },
};

static __initconst struct gpio_led_platform_data evm_led_data = {
	.num_leds = ARRAY_SIZE(evm_leds),
	.leds     = evm_leds,
};

static struct platform_device *evm_led_dev;

static int evm_led_setup(struct i2c_client *client, int gpio,
			unsigned int ngpio, void *c)
{
	struct gpio_led *leds = evm_leds;
	int status;

	while (ngpio--) {
		leds->gpio = gpio++;
		leds++;
	};

	evm_led_dev = platform_device_alloc("leds-gpio", 0);
	platform_device_add_data(evm_led_dev, &evm_led_data,
				sizeof(evm_led_data));

	evm_led_dev->dev.parent = &client->dev;
	status = platform_device_add(evm_led_dev);
	if (status < 0) {
		platform_device_put(evm_led_dev);
		evm_led_dev = NULL;
	}
	return status;
}

static int evm_led_teardown(struct i2c_client *client, int gpio,
				unsigned ngpio, void *c)
{
	if (evm_led_dev) {
		platform_device_unregister(evm_led_dev);
		evm_led_dev = NULL;
	}
	return 0;
}

static int evm_sw_gpio[4] = { -EINVAL, -EINVAL, -EINVAL, -EINVAL };

static int evm_sw_setup(struct i2c_client *client, int gpio,
			unsigned ngpio, void *c)
{
	int status;
	int i;
	char label[10];

	for (i = 0; i < 4; ++i) {
		snprintf(label, 10, "user_sw%d", i);
		status = gpio_request(gpio, label);
		if (status)
			goto out_free;
		evm_sw_gpio[i] = gpio++;

		status = gpio_direction_input(evm_sw_gpio[i]);
		if (status) {
			gpio_free(evm_sw_gpio[i]);
			evm_sw_gpio[i] = -EINVAL;
			goto out_free;
		}

		status = gpio_export(evm_sw_gpio[i], 0);
		if (status) {
			gpio_free(evm_sw_gpio[i]);
			evm_sw_gpio[i] = -EINVAL;
			goto out_free;
		}
	}
	return status;
out_free:
	for (i = 0; i < 4; ++i) {
		if (evm_sw_gpio[i] != -EINVAL) {
			gpio_free(evm_sw_gpio[i]);
			evm_sw_gpio[i] = -EINVAL;
		}
	}
	return status;
}

static int evm_sw_teardown(struct i2c_client *client, int gpio,
			unsigned ngpio, void *c)
{
	int i;

	for (i = 0; i < 4; ++i) {
		if (evm_sw_gpio[i] != -EINVAL) {
			gpio_unexport(evm_sw_gpio[i]);
			gpio_free(evm_sw_gpio[i]);
			evm_sw_gpio[i] = -EINVAL;
		}
	}
	return 0;
}

static int evm_pcf_setup(struct i2c_client *client, int gpio,
			unsigned int ngpio, void *c)
{
	int status;

	if (ngpio < 8)
		return -EINVAL;

	status = evm_sw_setup(client, gpio, 4, c);
	if (status)
		return status;

	return evm_led_setup(client, gpio+4, 4, c);
}

static int evm_pcf_teardown(struct i2c_client *client, int gpio,
			unsigned int ngpio, void *c)
{
	BUG_ON(ngpio < 8);

	evm_sw_teardown(client, gpio, 4, c);
	evm_led_teardown(client, gpio+4, 4, c);

	return 0;
}

static struct pcf857x_platform_data pcf_data = {
	.gpio_base	= DAVINCI_N_GPIO+1,
	.setup		= evm_pcf_setup,
	.teardown	= evm_pcf_teardown,
};

/* Most of this EEPROM is unused, but U-Boot uses some data:
 *  - 0x7f00, 6 bytes Ethernet Address
 *  - ... newer boards may have more
 */
static struct memory_accessor *at24_mem_acc;

static void at24_setup(struct memory_accessor *mem_acc, void *context)
{
	char mac_addr[ETH_ALEN];
	struct davinci_soc_info *soc_info = &davinci_soc_info;

	at24_mem_acc = mem_acc;

	/* Read MAC addr from EEPROM */
	if (at24_mem_acc->read(at24_mem_acc, mac_addr, 0x7f00, ETH_ALEN) ==
	    ETH_ALEN) {
		pr_info("Read MAC addr from EEPROM: %pM\n", mac_addr);
		memcpy(soc_info->emac_pdata->mac_addr, mac_addr, ETH_ALEN);
	}
}

static struct at24_platform_data eeprom_info = {
	.byte_len       = (256*1024) / 8,
	.page_size      = 64,
	.flags          = AT24_FLAG_ADDR16,
	.setup          = at24_setup,
};

static struct i2c_board_info __initdata i2c_info[] =  {
	{
		I2C_BOARD_INFO("24c256", 0x50),
		.platform_data  = &eeprom_info,
	},
	{
		I2C_BOARD_INFO("pcf8574a", 0x38),
		.platform_data	= &pcf_data,
	},
};

static struct davinci_i2c_platform_data i2c_pdata = {
	.bus_freq       = 100 /* kHz */,
	.bus_delay      = 0 /* usec */,
};

static void __init evm_init_i2c(void)
{
	davinci_init_i2c(&i2c_pdata);
	i2c_register_board_info(1, i2c_info, ARRAY_SIZE(i2c_info));
}

static void __init davinci_map_io(void)
{
	dm646x_init();
}

static __init void evm_init(void)
{
	struct davinci_soc_info *soc_info = &davinci_soc_info;

	evm_init_i2c();
	davinci_serial_init(&uart_config);

	soc_info->emac_pdata->phy_mask = DM646X_EVM_PHY_MASK;
	soc_info->emac_pdata->mdio_max_freq = DM646X_EVM_MDIO_FREQUENCY;
	dm646x_init_emac(soc_info->emac_pdata);
}

static __init void davinci_dm646x_evm_irq_init(void)
{
	davinci_irq_init();
}

MACHINE_START(DAVINCI_DM6467_EVM, "DaVinci DM646x EVM")
	.phys_io      = IO_PHYS,
	.io_pg_offst  = (__IO_ADDRESS(IO_PHYS) >> 18) & 0xfffc,
	.boot_params  = (0x80000100),
	.map_io       = davinci_map_io,
	.init_irq     = davinci_dm646x_evm_irq_init,
	.timer        = &davinci_timer,
	.init_machine = evm_init,
MACHINE_END
Commit	Line	Data
e38d92fd KH	1	/*
	2	* TI DaVinci DM646X EVM board
	3	*
	4	* Derived from: arch/arm/mach-davinci/board-evm.c
	5	* Copyright (C) 2006 Texas Instruments.
	6	*
	7	* (C) 2007-2008, MontaVista Software, Inc.
	8	*
	9	* This file is licensed under the terms of the GNU General Public License
	10	* version 2. This program is licensed "as is" without any warranty of any
	11	* kind, whether express or implied.
	12	*
	13	*/
	14
	15	/**************************************************************************
	16	* Included Files
	17	**************************************************************************/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/init.h>
	22	#include <linux/fs.h>
	23	#include <linux/major.h>
	24	#include <linux/root_dev.h>
	25	#include <linux/dma-mapping.h>
	26	#include <linux/serial.h>
	27	#include <linux/serial_8250.h>
	28	#include <linux/leds.h>
	29	#include <linux/gpio.h>
	30	#include <linux/io.h>
	31	#include <linux/platform_device.h>
	32	#include <linux/i2c.h>
	33	#include <linux/i2c/at24.h>
	34	#include <linux/i2c/pcf857x.h>
	35	#include <linux/etherdevice.h>
	36
	37	#include <asm/setup.h>
	38	#include <asm/mach-types.h>
	39	#include <asm/mach/arch.h>
	40	#include <asm/mach/map.h>
	41	#include <asm/mach/flash.h>
	42
	43	#include <mach/dm646x.h>
	44	#include <mach/common.h>
	45	#include <mach/psc.h>
	46	#include <mach/serial.h>
	47	#include <mach/i2c.h>
ac7b75b5 KH	48	#include <mach/mmc.h>
ac7b75b5 KH	49	#include <mach/emac.h>
79c3c0b7	50	#include <mach/common.h>
ac7b75b5 KH	51
	52	#define DM646X_EVM_PHY_MASK (0x2)
	53	#define DM646X_EVM_MDIO_FREQUENCY (2200000) /* PHY bus frequency */
	54
e38d92fd KH	55	static struct davinci_uart_config uart_config __initdata = {
	56	.enabled_uarts = (1 << 0),
	57	};
	58
	59	/* LEDS */
	60
	61	static struct gpio_led evm_leds[] = {
	62	{ .name = "DS1", .active_low = 1, },
	63	{ .name = "DS2", .active_low = 1, },
	64	{ .name = "DS3", .active_low = 1, },
	65	{ .name = "DS4", .active_low = 1, },
	66	};
	67
	68	static __initconst struct gpio_led_platform_data evm_led_data = {
	69	.num_leds = ARRAY_SIZE(evm_leds),
	70	.leds = evm_leds,
	71	};
	72
	73	static struct platform_device *evm_led_dev;
	74
	75	static int evm_led_setup(struct i2c_client *client, int gpio,
	76	unsigned int ngpio, void *c)
	77	{
	78	struct gpio_led *leds = evm_leds;
	79	int status;
	80
	81	while (ngpio--) {
	82	leds->gpio = gpio++;
	83	leds++;
	84	};
	85
	86	evm_led_dev = platform_device_alloc("leds-gpio", 0);
	87	platform_device_add_data(evm_led_dev, &evm_led_data,
	88	sizeof(evm_led_data));
	89
	90	evm_led_dev->dev.parent = &client->dev;
	91	status = platform_device_add(evm_led_dev);
	92	if (status < 0) {
	93	platform_device_put(evm_led_dev);
	94	evm_led_dev = NULL;
	95	}
	96	return status;
	97	}
	98
	99	static int evm_led_teardown(struct i2c_client *client, int gpio,
	100	unsigned ngpio, void *c)
	101	{
	102	if (evm_led_dev) {
	103	platform_device_unregister(evm_led_dev);
	104	evm_led_dev = NULL;
	105	}
	106	return 0;
	107	}
	108
	109	static int evm_sw_gpio[4] = { -EINVAL, -EINVAL, -EINVAL, -EINVAL };
	110
	111	static int evm_sw_setup(struct i2c_client *client, int gpio,
	112	unsigned ngpio, void *c)
	113	{
	114	int status;
	115	int i;
	116	char label[10];
	117
	118	for (i = 0; i < 4; ++i) {
119	snprintf(label, 10, "user_sw%d", i);
120	status = gpio_request(gpio, label);
121	if (status)
122	goto out_free;
123	evm_sw_gpio[i] = gpio++;
124
125	status = gpio_direction_input(evm_sw_gpio[i]);
126	if (status) {
127	gpio_free(evm_sw_gpio[i]);
128	evm_sw_gpio[i] = -EINVAL;
129	goto out_free;
130	}
131
132	status = gpio_export(evm_sw_gpio[i], 0);
133	if (status) {
134	gpio_free(evm_sw_gpio[i]);
135	evm_sw_gpio[i] = -EINVAL;
136	goto out_free;
137	}
138	}
139	return status;
140	out_free:
141	for (i = 0; i < 4; ++i) {
142	if (evm_sw_gpio[i] != -EINVAL) {
143	gpio_free(evm_sw_gpio[i]);
144	evm_sw_gpio[i] = -EINVAL;
145	}
146	}
147	return status;
148	}
149
150	static int evm_sw_teardown(struct i2c_client *client, int gpio,
151	unsigned ngpio, void *c)
152	{
153	int i;
154
155	for (i = 0; i < 4; ++i) {
156	if (evm_sw_gpio[i] != -EINVAL) {
157	gpio_unexport(evm_sw_gpio[i]);
158	gpio_free(evm_sw_gpio[i]);
159	evm_sw_gpio[i] = -EINVAL;
160	}
161	}
162	return 0;
163	}
164
165	static int evm_pcf_setup(struct i2c_client *client, int gpio,
166	unsigned int ngpio, void *c)
167	{
168	int status;
169
170	if (ngpio < 8)
171	return -EINVAL;
172
173	status = evm_sw_setup(client, gpio, 4, c);
174	if (status)
175	return status;
176
177	return evm_led_setup(client, gpio+4, 4, c);
178	}
179
180	static int evm_pcf_teardown(struct i2c_client *client, int gpio,
181	unsigned int ngpio, void *c)
182	{
183	BUG_ON(ngpio < 8);
184
185	evm_sw_teardown(client, gpio, 4, c);
186	evm_led_teardown(client, gpio+4, 4, c);
187
188	return 0;
189	}
190
191	static struct pcf857x_platform_data pcf_data = {
192	.gpio_base = DAVINCI_N_GPIO+1,
193	.setup = evm_pcf_setup,
194	.teardown = evm_pcf_teardown,
195	};
196
197	/* Most of this EEPROM is unused, but U-Boot uses some data:
198	* - 0x7f00, 6 bytes Ethernet Address
199	* - ... newer boards may have more
200	*/
201	static struct memory_accessor *at24_mem_acc;
202
203	static void at24_setup(struct memory_accessor mem_acc, void context)
204	{
ac7b75b5	205	char mac_addr[ETH_ALEN];
972412b6	206	struct davinci_soc_info *soc_info = &davinci_soc_info;
e38d92fd KH	207
	208	at24_mem_acc = mem_acc;
	209
	210	/* Read MAC addr from EEPROM */
	211	if (at24_mem_acc->read(at24_mem_acc, mac_addr, 0x7f00, ETH_ALEN) ==
ac7b75b5	212	ETH_ALEN) {
e38d92fd	213	pr_info("Read MAC addr from EEPROM: %pM\n", mac_addr);
972412b6	214	memcpy(soc_info->emac_pdata->mac_addr, mac_addr, ETH_ALEN);
ac7b75b5	215	}
e38d92fd KH	216	}
	217
	218	static struct at24_platform_data eeprom_info = {
	219	.byte_len = (256*1024) / 8,
	220	.page_size = 64,
	221	.flags = AT24_FLAG_ADDR16,
	222	.setup = at24_setup,
	223	};
	224
e38d92fd KH	225	static struct i2c_board_info __initdata i2c_info[] = {
	226	{
	227	I2C_BOARD_INFO("24c256", 0x50),
	228	.platform_data = &eeprom_info,
	229	},
	230	{
	231	I2C_BOARD_INFO("pcf8574a", 0x38),
	232	.platform_data = &pcf_data,
	233	},
	234	};
	235
	236	static struct davinci_i2c_platform_data i2c_pdata = {
	237	.bus_freq = 100 /* kHz */,
	238	.bus_delay = 0 /* usec */,
	239	};
	240
	241	static void __init evm_init_i2c(void)
	242	{
	243	davinci_init_i2c(&i2c_pdata);
	244	i2c_register_board_info(1, i2c_info, ARRAY_SIZE(i2c_info));
	245	}
	246
	247	static void __init davinci_map_io(void)
	248	{
e38d92fd KH	249	dm646x_init();
	250	}
	251
	252	static __init void evm_init(void)
	253	{
972412b6 MG	254	struct davinci_soc_info *soc_info = &davinci_soc_info;
972412b6 MG	255
e38d92fd KH	256	evm_init_i2c();
e38d92fd KH	257	davinci_serial_init(&uart_config);
972412b6 MG	258
	259	soc_info->emac_pdata->phy_mask = DM646X_EVM_PHY_MASK;
	260	soc_info->emac_pdata->mdio_max_freq = DM646X_EVM_MDIO_FREQUENCY;
	261	dm646x_init_emac(soc_info->emac_pdata);
e38d92fd KH	262	}
	263
	264	static __init void davinci_dm646x_evm_irq_init(void)
	265	{
	266	davinci_irq_init();
	267	}
	268
	269	MACHINE_START(DAVINCI_DM6467_EVM, "DaVinci DM646x EVM")
	270	.phys_io = IO_PHYS,
	271	.io_pg_offst = (__IO_ADDRESS(IO_PHYS) >> 18) & 0xfffc,
	272	.boot_params = (0x80000100),
	273	.map_io = davinci_map_io,
	274	.init_irq = davinci_dm646x_evm_irq_init,
	275	.timer = &davinci_timer,
	276	.init_machine = evm_init,
	277	MACHINE_END
	278