[net-next-2.6.git] / arch / powerpc / sysdev / fsl_soc.c

/*
 * FSL SoC setup code
 *
 * Maintained by Kumar Gala (see MAINTAINERS for contact information)
 *
 * 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.
 */

#include <linux/stddef.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/major.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/fsl_devices.h>

#include <asm/system.h>
#include <asm/atomic.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/prom.h>
#include <sysdev/fsl_soc.h>
#include <mm/mmu_decl.h>

static phys_addr_t immrbase = -1;

phys_addr_t get_immrbase(void)
{
	struct device_node *soc;

	if (immrbase != -1)
		return immrbase;

	soc = of_find_node_by_type(NULL, "soc");
	if (soc) {
		unsigned int size;
		const void *prop = get_property(soc, "reg", &size);
		immrbase = of_translate_address(soc, prop);
		of_node_put(soc);
	};

	return immrbase;
}

EXPORT_SYMBOL(get_immrbase);

static int __init gfar_mdio_of_init(void)
{
	struct device_node *np;
	unsigned int i;
	struct platform_device *mdio_dev;
	struct resource res;
	int ret;

	for (np = NULL, i = 0;
	     (np = of_find_compatible_node(np, "mdio", "gianfar")) != NULL;
	     i++) {
		int k;
		struct device_node *child = NULL;
		struct gianfar_mdio_data mdio_data;

		memset(&res, 0, sizeof(res));
		memset(&mdio_data, 0, sizeof(mdio_data));

		ret = of_address_to_resource(np, 0, &res);
		if (ret)
			goto err;

		mdio_dev =
		    platform_device_register_simple("fsl-gianfar_mdio",
						    res.start, &res, 1);
		if (IS_ERR(mdio_dev)) {
			ret = PTR_ERR(mdio_dev);
			goto err;
		}

		for (k = 0; k < 32; k++)
			mdio_data.irq[k] = -1;

		while ((child = of_get_next_child(np, child)) != NULL) {
			const u32 *id = get_property(child, "reg", NULL);
			mdio_data.irq[*id] = irq_of_parse_and_map(child, 0);
		}

		ret =
		    platform_device_add_data(mdio_dev, &mdio_data,
					     sizeof(struct gianfar_mdio_data));
		if (ret)
			goto unreg;
	}

	return 0;

unreg:
	platform_device_unregister(mdio_dev);
err:
	return ret;
}

arch_initcall(gfar_mdio_of_init);

static const char *gfar_tx_intr = "tx";
static const char *gfar_rx_intr = "rx";
static const char *gfar_err_intr = "error";

static int __init gfar_of_init(void)
{
	struct device_node *np;
	unsigned int i;
	struct platform_device *gfar_dev;
	struct resource res;
	int ret;

	for (np = NULL, i = 0;
	     (np = of_find_compatible_node(np, "network", "gianfar")) != NULL;
	     i++) {
		struct resource r[4];
		struct device_node *phy, *mdio;
		struct gianfar_platform_data gfar_data;
		const unsigned int *id;
		const char *model;
		const void *mac_addr;
		const phandle *ph;
		int n_res = 1;

		memset(r, 0, sizeof(r));
		memset(&gfar_data, 0, sizeof(gfar_data));

		ret = of_address_to_resource(np, 0, &r[0]);
		if (ret)
			goto err;

		r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
		r[1].flags = IORESOURCE_IRQ;

		model = get_property(np, "model", NULL);

		/* If we aren't the FEC we have multiple interrupts */
		if (model && strcasecmp(model, "FEC")) {
			r[1].name = gfar_tx_intr;

			r[2].name = gfar_rx_intr;
			r[2].start = r[2].end = irq_of_parse_and_map(np, 1);
			r[2].flags = IORESOURCE_IRQ;

			r[3].name = gfar_err_intr;
			r[3].start = r[3].end = irq_of_parse_and_map(np, 2);
			r[3].flags = IORESOURCE_IRQ;

			n_res += 2;
		}

		gfar_dev =
		    platform_device_register_simple("fsl-gianfar", i, &r[0],
						    n_res + 1);

		if (IS_ERR(gfar_dev)) {
			ret = PTR_ERR(gfar_dev);
			goto err;
		}

		mac_addr = get_property(np, "local-mac-address", NULL);
		if (mac_addr == NULL)
			mac_addr = get_property(np, "mac-address", NULL);
		if (mac_addr == NULL) {
			/* Obsolete */
			mac_addr = get_property(np, "address", NULL);
		}

		if (mac_addr)
			memcpy(gfar_data.mac_addr, mac_addr, 6);

		if (model && !strcasecmp(model, "TSEC"))
			gfar_data.device_flags =
			    FSL_GIANFAR_DEV_HAS_GIGABIT |
			    FSL_GIANFAR_DEV_HAS_COALESCE |
			    FSL_GIANFAR_DEV_HAS_RMON |
			    FSL_GIANFAR_DEV_HAS_MULTI_INTR;
		if (model && !strcasecmp(model, "eTSEC"))
			gfar_data.device_flags =
			    FSL_GIANFAR_DEV_HAS_GIGABIT |
			    FSL_GIANFAR_DEV_HAS_COALESCE |
			    FSL_GIANFAR_DEV_HAS_RMON |
			    FSL_GIANFAR_DEV_HAS_MULTI_INTR |
			    FSL_GIANFAR_DEV_HAS_CSUM |
			    FSL_GIANFAR_DEV_HAS_VLAN |
			    FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;

		ph = get_property(np, "phy-handle", NULL);
		phy = of_find_node_by_phandle(*ph);

		if (phy == NULL) {
			ret = -ENODEV;
			goto unreg;
		}

		mdio = of_get_parent(phy);

		id = get_property(phy, "reg", NULL);
		ret = of_address_to_resource(mdio, 0, &res);
		if (ret) {
			of_node_put(phy);
			of_node_put(mdio);
			goto unreg;
		}

		gfar_data.phy_id = *id;
		gfar_data.bus_id = res.start;

		of_node_put(phy);
		of_node_put(mdio);

		ret =
		    platform_device_add_data(gfar_dev, &gfar_data,
					     sizeof(struct
						    gianfar_platform_data));
		if (ret)
			goto unreg;
	}

	return 0;

unreg:
	platform_device_unregister(gfar_dev);
err:
	return ret;
}

arch_initcall(gfar_of_init);

static int __init fsl_i2c_of_init(void)
{
	struct device_node *np;
	unsigned int i;
	struct platform_device *i2c_dev;
	int ret;

	for (np = NULL, i = 0;
	     (np = of_find_compatible_node(np, "i2c", "fsl-i2c")) != NULL;
	     i++) {
		struct resource r[2];
		struct fsl_i2c_platform_data i2c_data;
		const unsigned char *flags = NULL;

		memset(&r, 0, sizeof(r));
		memset(&i2c_data, 0, sizeof(i2c_data));

		ret = of_address_to_resource(np, 0, &r[0]);
		if (ret)
			goto err;

		r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
		r[1].flags = IORESOURCE_IRQ;

		i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2);
		if (IS_ERR(i2c_dev)) {
			ret = PTR_ERR(i2c_dev);
			goto err;
		}

		i2c_data.device_flags = 0;
		flags = get_property(np, "dfsrr", NULL);
		if (flags)
			i2c_data.device_flags |= FSL_I2C_DEV_SEPARATE_DFSRR;

		flags = get_property(np, "fsl5200-clocking", NULL);
		if (flags)
			i2c_data.device_flags |= FSL_I2C_DEV_CLOCK_5200;

		ret =
		    platform_device_add_data(i2c_dev, &i2c_data,
					     sizeof(struct
						    fsl_i2c_platform_data));
		if (ret)
			goto unreg;
	}

	return 0;

unreg:
	platform_device_unregister(i2c_dev);
err:
	return ret;
}

arch_initcall(fsl_i2c_of_init);

#ifdef CONFIG_PPC_83xx
static int __init mpc83xx_wdt_init(void)
{
	struct resource r;
	struct device_node *soc, *np;
	struct platform_device *dev;
	const unsigned int *freq;
	int ret;

	np = of_find_compatible_node(NULL, "watchdog", "mpc83xx_wdt");

	if (!np) {
		ret = -ENODEV;
		goto nodev;
	}

	soc = of_find_node_by_type(NULL, "soc");

	if (!soc) {
		ret = -ENODEV;
		goto nosoc;
	}

	freq = get_property(soc, "bus-frequency", NULL);
	if (!freq) {
		ret = -ENODEV;
		goto err;
	}

	memset(&r, 0, sizeof(r));

	ret = of_address_to_resource(np, 0, &r);
	if (ret)
		goto err;

	dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1);
	if (IS_ERR(dev)) {
		ret = PTR_ERR(dev);
		goto err;
	}

	ret = platform_device_add_data(dev, freq, sizeof(int));
	if (ret)
		goto unreg;

	of_node_put(soc);
	of_node_put(np);

	return 0;

unreg:
	platform_device_unregister(dev);
err:
	of_node_put(soc);
nosoc:
	of_node_put(np);
nodev:
	return ret;
}

arch_initcall(mpc83xx_wdt_init);
#endif

static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type)
{
	if (!phy_type)
		return FSL_USB2_PHY_NONE;
	if (!strcasecmp(phy_type, "ulpi"))
		return FSL_USB2_PHY_ULPI;
	if (!strcasecmp(phy_type, "utmi"))
		return FSL_USB2_PHY_UTMI;
	if (!strcasecmp(phy_type, "utmi_wide"))
		return FSL_USB2_PHY_UTMI_WIDE;
	if (!strcasecmp(phy_type, "serial"))
		return FSL_USB2_PHY_SERIAL;

	return FSL_USB2_PHY_NONE;
}

static int __init fsl_usb_of_init(void)
{
	struct device_node *np;
	unsigned int i;
	struct platform_device *usb_dev_mph = NULL, *usb_dev_dr = NULL;
	int ret;

	for (np = NULL, i = 0;
	     (np = of_find_compatible_node(np, "usb", "fsl-usb2-mph")) != NULL;
	     i++) {
		struct resource r[2];
		struct fsl_usb2_platform_data usb_data;
		const unsigned char *prop = NULL;

		memset(&r, 0, sizeof(r));
		memset(&usb_data, 0, sizeof(usb_data));

		ret = of_address_to_resource(np, 0, &r[0]);
		if (ret)
			goto err;

		r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
		r[1].flags = IORESOURCE_IRQ;

		usb_dev_mph =
		    platform_device_register_simple("fsl-ehci", i, r, 2);
		if (IS_ERR(usb_dev_mph)) {
			ret = PTR_ERR(usb_dev_mph);
			goto err;
		}

		usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL;
		usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask;

		usb_data.operating_mode = FSL_USB2_MPH_HOST;

		prop = get_property(np, "port0", NULL);
		if (prop)
			usb_data.port_enables |= FSL_USB2_PORT0_ENABLED;

		prop = get_property(np, "port1", NULL);
		if (prop)
			usb_data.port_enables |= FSL_USB2_PORT1_ENABLED;

		prop = get_property(np, "phy_type", NULL);
		usb_data.phy_mode = determine_usb_phy(prop);

		ret =
		    platform_device_add_data(usb_dev_mph, &usb_data,
					     sizeof(struct
						    fsl_usb2_platform_data));
		if (ret)
			goto unreg_mph;
	}

	for (np = NULL;
	     (np = of_find_compatible_node(np, "usb", "fsl-usb2-dr")) != NULL;
	     i++) {
		struct resource r[2];
		struct fsl_usb2_platform_data usb_data;
		const unsigned char *prop = NULL;

		memset(&r, 0, sizeof(r));
		memset(&usb_data, 0, sizeof(usb_data));

		ret = of_address_to_resource(np, 0, &r[0]);
		if (ret)
			goto unreg_mph;

		r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
		r[1].flags = IORESOURCE_IRQ;

		usb_dev_dr =
		    platform_device_register_simple("fsl-ehci", i, r, 2);
		if (IS_ERR(usb_dev_dr)) {
			ret = PTR_ERR(usb_dev_dr);
			goto err;
		}

		usb_dev_dr->dev.coherent_dma_mask = 0xffffffffUL;
		usb_dev_dr->dev.dma_mask = &usb_dev_dr->dev.coherent_dma_mask;

		usb_data.operating_mode = FSL_USB2_DR_HOST;

		prop = get_property(np, "phy_type", NULL);
		usb_data.phy_mode = determine_usb_phy(prop);

		ret =
		    platform_device_add_data(usb_dev_dr, &usb_data,
					     sizeof(struct
						    fsl_usb2_platform_data));
		if (ret)
			goto unreg_dr;
	}
	return 0;

unreg_dr:
	if (usb_dev_dr)
		platform_device_unregister(usb_dev_dr);
unreg_mph:
	if (usb_dev_mph)
		platform_device_unregister(usb_dev_mph);
err:
	return ret;
}

arch_initcall(fsl_usb_of_init);
Commit	Line	Data
eed32001 KG	1	/*
	2	* FSL SoC setup code
	3	*
	4	* Maintained by Kumar Gala (see MAINTAINERS for contact information)
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2 of the License, or (at your
	9	* option) any later version.
	10	*/
	11
eed32001 KG	12	#include <linux/stddef.h>
	13	#include <linux/kernel.h>
	14	#include <linux/init.h>
	15	#include <linux/errno.h>
	16	#include <linux/major.h>
	17	#include <linux/delay.h>
	18	#include <linux/irq.h>
	19	#include <linux/module.h>
	20	#include <linux/device.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/fsl_devices.h>
	23
	24	#include <asm/system.h>
	25	#include <asm/atomic.h>
	26	#include <asm/io.h>
	27	#include <asm/irq.h>
	28	#include <asm/prom.h>
	29	#include <sysdev/fsl_soc.h>
	30	#include <mm/mmu_decl.h>
	31
	32	static phys_addr_t immrbase = -1;
	33
	34	phys_addr_t get_immrbase(void)
	35	{
	36	struct device_node *soc;
	37
	38	if (immrbase != -1)
	39	return immrbase;
	40
	41	soc = of_find_node_by_type(NULL, "soc");
2fb07d77	42	if (soc) {
eed32001	43	unsigned int size;
a7f67bdf	44	const void *prop = get_property(soc, "reg", &size);
eed32001 KG	45	immrbase = of_translate_address(soc, prop);
	46	of_node_put(soc);
	47	};
	48
	49	return immrbase;
	50	}
eed32001	51
2fb07d77	52	EXPORT_SYMBOL(get_immrbase);
eed32001	53
2fb07d77	54	static int __init gfar_mdio_of_init(void)
eed32001 KG	55	{
	56	struct device_node *np;
	57	unsigned int i;
2fb07d77	58	struct platform_device *mdio_dev;
eed32001 KG	59	struct resource res;
	60	int ret;
	61
2fb07d77 KG	62	for (np = NULL, i = 0;
	63	(np = of_find_compatible_node(np, "mdio", "gianfar")) != NULL;
	64	i++) {
eed32001 KG	65	int k;
	66	struct device_node *child = NULL;
	67	struct gianfar_mdio_data mdio_data;
	68
	69	memset(&res, 0, sizeof(res));
	70	memset(&mdio_data, 0, sizeof(mdio_data));
	71
	72	ret = of_address_to_resource(np, 0, &res);
	73	if (ret)
2fb07d77	74	goto err;
eed32001	75
2fb07d77 KG	76	mdio_dev =
	77	platform_device_register_simple("fsl-gianfar_mdio",
	78	res.start, &res, 1);
eed32001 KG	79	if (IS_ERR(mdio_dev)) {
eed32001 KG	80	ret = PTR_ERR(mdio_dev);
2fb07d77	81	goto err;
eed32001 KG	82	}
	83
	84	for (k = 0; k < 32; k++)
	85	mdio_data.irq[k] = -1;
	86
	87	while ((child = of_get_next_child(np, child)) != NULL) {
919fede6 JL	88	const u32 *id = get_property(child, "reg", NULL);
919fede6 JL	89	mdio_data.irq[*id] = irq_of_parse_and_map(child, 0);
eed32001 KG	90	}
eed32001 KG	91
2fb07d77 KG	92	ret =
	93	platform_device_add_data(mdio_dev, &mdio_data,
	94	sizeof(struct gianfar_mdio_data));
eed32001	95	if (ret)
2fb07d77	96	goto unreg;
eed32001 KG	97	}
eed32001 KG	98
2fb07d77 KG	99	return 0;
	100
	101	unreg:
	102	platform_device_unregister(mdio_dev);
	103	err:
	104	return ret;
	105	}
	106
	107	arch_initcall(gfar_mdio_of_init);
	108
	109	static const char *gfar_tx_intr = "tx";
	110	static const char *gfar_rx_intr = "rx";
	111	static const char *gfar_err_intr = "error";
	112
	113	static int __init gfar_of_init(void)
	114	{
	115	struct device_node *np;
	116	unsigned int i;
	117	struct platform_device *gfar_dev;
	118	struct resource res;
	119	int ret;
	120
	121	for (np = NULL, i = 0;
	122	(np = of_find_compatible_node(np, "network", "gianfar")) != NULL;
	123	i++) {
eed32001 KG	124	struct resource r[4];
	125	struct device_node phy, mdio;
	126	struct gianfar_platform_data gfar_data;
a7f67bdf JK	127	const unsigned int *id;
	128	const char *model;
	129	const void *mac_addr;
	130	const phandle *ph;
919fede6	131	int n_res = 1;
eed32001 KG	132
	133	memset(r, 0, sizeof(r));
	134	memset(&gfar_data, 0, sizeof(gfar_data));
	135
	136	ret = of_address_to_resource(np, 0, &r[0]);
	137	if (ret)
2fb07d77	138	goto err;
eed32001	139
919fede6	140	r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
eed32001 KG	141	r[1].flags = IORESOURCE_IRQ;
	142
	143	model = get_property(np, "model", NULL);
	144
	145	/* If we aren't the FEC we have multiple interrupts */
	146	if (model && strcasecmp(model, "FEC")) {
	147	r[1].name = gfar_tx_intr;
	148
	149	r[2].name = gfar_rx_intr;
919fede6	150	r[2].start = r[2].end = irq_of_parse_and_map(np, 1);
eed32001 KG	151	r[2].flags = IORESOURCE_IRQ;
	152
	153	r[3].name = gfar_err_intr;
919fede6	154	r[3].start = r[3].end = irq_of_parse_and_map(np, 2);
eed32001	155	r[3].flags = IORESOURCE_IRQ;
919fede6 JL	156
919fede6 JL	157	n_res += 2;
eed32001 KG	158	}
eed32001 KG	159
2fb07d77 KG	160	gfar_dev =
2fb07d77 KG	161	platform_device_register_simple("fsl-gianfar", i, &r[0],
919fede6	162	n_res + 1);
eed32001 KG	163
	164	if (IS_ERR(gfar_dev)) {
	165	ret = PTR_ERR(gfar_dev);
2fb07d77	166	goto err;
eed32001 KG	167	}
eed32001 KG	168
f583165f JL	169	mac_addr = get_property(np, "local-mac-address", NULL);
	170	if (mac_addr == NULL)
	171	mac_addr = get_property(np, "mac-address", NULL);
	172	if (mac_addr == NULL) {
	173	/* Obsolete */
	174	mac_addr = get_property(np, "address", NULL);
	175	}
	176
	177	if (mac_addr)
	178	memcpy(gfar_data.mac_addr, mac_addr, 6);
eed32001 KG	179
	180	if (model && !strcasecmp(model, "TSEC"))
	181	gfar_data.device_flags =
2fb07d77 KG	182	FSL_GIANFAR_DEV_HAS_GIGABIT \|
	183	FSL_GIANFAR_DEV_HAS_COALESCE \|
	184	FSL_GIANFAR_DEV_HAS_RMON \|
	185	FSL_GIANFAR_DEV_HAS_MULTI_INTR;
eed32001 KG	186	if (model && !strcasecmp(model, "eTSEC"))
eed32001 KG	187	gfar_data.device_flags =
2fb07d77 KG	188	FSL_GIANFAR_DEV_HAS_GIGABIT \|
	189	FSL_GIANFAR_DEV_HAS_COALESCE \|
	190	FSL_GIANFAR_DEV_HAS_RMON \|
	191	FSL_GIANFAR_DEV_HAS_MULTI_INTR \|
	192	FSL_GIANFAR_DEV_HAS_CSUM \|
	193	FSL_GIANFAR_DEV_HAS_VLAN \|
	194	FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;
eed32001	195
a7f67bdf	196	ph = get_property(np, "phy-handle", NULL);
eed32001 KG	197	phy = of_find_node_by_phandle(*ph);
	198
	199	if (phy == NULL) {
	200	ret = -ENODEV;
2fb07d77	201	goto unreg;
eed32001 KG	202	}
	203
	204	mdio = of_get_parent(phy);
	205
a7f67bdf	206	id = get_property(phy, "reg", NULL);
eed32001 KG	207	ret = of_address_to_resource(mdio, 0, &res);
	208	if (ret) {
	209	of_node_put(phy);
	210	of_node_put(mdio);
2fb07d77	211	goto unreg;
eed32001 KG	212	}
	213
	214	gfar_data.phy_id = *id;
	215	gfar_data.bus_id = res.start;
	216
	217	of_node_put(phy);
	218	of_node_put(mdio);
	219
2fb07d77 KG	220	ret =
	221	platform_device_add_data(gfar_dev, &gfar_data,
	222	sizeof(struct
	223	gianfar_platform_data));
eed32001	224	if (ret)
2fb07d77	225	goto unreg;
eed32001 KG	226	}
	227
	228	return 0;
	229
2fb07d77	230	unreg:
eed32001	231	platform_device_unregister(gfar_dev);
2fb07d77	232	err:
eed32001 KG	233	return ret;
eed32001 KG	234	}
2fb07d77	235
eed32001 KG	236	arch_initcall(gfar_of_init);
	237
	238	static int __init fsl_i2c_of_init(void)
	239	{
	240	struct device_node *np;
	241	unsigned int i;
	242	struct platform_device *i2c_dev;
	243	int ret;
	244
2fb07d77 KG	245	for (np = NULL, i = 0;
	246	(np = of_find_compatible_node(np, "i2c", "fsl-i2c")) != NULL;
	247	i++) {
eed32001 KG	248	struct resource r[2];
eed32001 KG	249	struct fsl_i2c_platform_data i2c_data;
a7f67bdf	250	const unsigned char *flags = NULL;
eed32001 KG	251
	252	memset(&r, 0, sizeof(r));
	253	memset(&i2c_data, 0, sizeof(i2c_data));
	254
	255	ret = of_address_to_resource(np, 0, &r[0]);
	256	if (ret)
2fb07d77	257	goto err;
eed32001	258
919fede6	259	r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
eed32001 KG	260	r[1].flags = IORESOURCE_IRQ;
	261
	262	i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2);
	263	if (IS_ERR(i2c_dev)) {
	264	ret = PTR_ERR(i2c_dev);
2fb07d77	265	goto err;
eed32001 KG	266	}
	267
	268	i2c_data.device_flags = 0;
	269	flags = get_property(np, "dfsrr", NULL);
	270	if (flags)
	271	i2c_data.device_flags \|= FSL_I2C_DEV_SEPARATE_DFSRR;
	272
	273	flags = get_property(np, "fsl5200-clocking", NULL);
	274	if (flags)
	275	i2c_data.device_flags \|= FSL_I2C_DEV_CLOCK_5200;
	276
2fb07d77 KG	277	ret =
	278	platform_device_add_data(i2c_dev, &i2c_data,
	279	sizeof(struct
	280	fsl_i2c_platform_data));
eed32001	281	if (ret)
2fb07d77	282	goto unreg;
eed32001 KG	283	}
	284
	285	return 0;
	286
2fb07d77	287	unreg:
eed32001	288	platform_device_unregister(i2c_dev);
2fb07d77	289	err:
eed32001 KG	290	return ret;
eed32001 KG	291	}
2fb07d77	292
eed32001 KG	293	arch_initcall(fsl_i2c_of_init);
	294
	295	#ifdef CONFIG_PPC_83xx
	296	static int __init mpc83xx_wdt_init(void)
	297	{
	298	struct resource r;
	299	struct device_node soc, np;
	300	struct platform_device *dev;
a7f67bdf	301	const unsigned int *freq;
eed32001 KG	302	int ret;
	303
	304	np = of_find_compatible_node(NULL, "watchdog", "mpc83xx_wdt");
	305
	306	if (!np) {
	307	ret = -ENODEV;
2fb07d77	308	goto nodev;
eed32001 KG	309	}
	310
	311	soc = of_find_node_by_type(NULL, "soc");
	312
	313	if (!soc) {
	314	ret = -ENODEV;
2fb07d77	315	goto nosoc;
eed32001 KG	316	}
eed32001 KG	317
a7f67bdf	318	freq = get_property(soc, "bus-frequency", NULL);
eed32001 KG	319	if (!freq) {
eed32001 KG	320	ret = -ENODEV;
2fb07d77	321	goto err;
eed32001 KG	322	}
	323
	324	memset(&r, 0, sizeof(r));
	325
	326	ret = of_address_to_resource(np, 0, &r);
	327	if (ret)
2fb07d77	328	goto err;
eed32001 KG	329
	330	dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1);
	331	if (IS_ERR(dev)) {
	332	ret = PTR_ERR(dev);
2fb07d77	333	goto err;
eed32001 KG	334	}
	335
	336	ret = platform_device_add_data(dev, freq, sizeof(int));
	337	if (ret)
2fb07d77	338	goto unreg;
eed32001 KG	339
	340	of_node_put(soc);
	341	of_node_put(np);
	342
	343	return 0;
	344
2fb07d77	345	unreg:
eed32001	346	platform_device_unregister(dev);
2fb07d77	347	err:
eed32001	348	of_node_put(soc);
2fb07d77	349	nosoc:
eed32001	350	of_node_put(np);
2fb07d77	351	nodev:
eed32001 KG	352	return ret;
eed32001 KG	353	}
2fb07d77	354
eed32001 KG	355	arch_initcall(mpc83xx_wdt_init);
eed32001 KG	356	#endif
4b10cfd4	357
a7f67bdf	358	static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type)
4b10cfd4 KG	359	{
	360	if (!phy_type)
	361	return FSL_USB2_PHY_NONE;
	362	if (!strcasecmp(phy_type, "ulpi"))
	363	return FSL_USB2_PHY_ULPI;
	364	if (!strcasecmp(phy_type, "utmi"))
	365	return FSL_USB2_PHY_UTMI;
	366	if (!strcasecmp(phy_type, "utmi_wide"))
	367	return FSL_USB2_PHY_UTMI_WIDE;
	368	if (!strcasecmp(phy_type, "serial"))
	369	return FSL_USB2_PHY_SERIAL;
	370
	371	return FSL_USB2_PHY_NONE;
	372	}
	373
	374	static int __init fsl_usb_of_init(void)
	375	{
	376	struct device_node *np;
	377	unsigned int i;
01cced25	378	struct platform_device usb_dev_mph = NULL, usb_dev_dr = NULL;
4b10cfd4 KG	379	int ret;
	380
	381	for (np = NULL, i = 0;
	382	(np = of_find_compatible_node(np, "usb", "fsl-usb2-mph")) != NULL;
	383	i++) {
	384	struct resource r[2];
	385	struct fsl_usb2_platform_data usb_data;
a7f67bdf	386	const unsigned char *prop = NULL;
4b10cfd4 KG	387
	388	memset(&r, 0, sizeof(r));
	389	memset(&usb_data, 0, sizeof(usb_data));
	390
	391	ret = of_address_to_resource(np, 0, &r[0]);
	392	if (ret)
	393	goto err;
	394
919fede6	395	r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
4b10cfd4 KG	396	r[1].flags = IORESOURCE_IRQ;
4b10cfd4 KG	397
01cced25 KG	398	usb_dev_mph =
	399	platform_device_register_simple("fsl-ehci", i, r, 2);
	400	if (IS_ERR(usb_dev_mph)) {
	401	ret = PTR_ERR(usb_dev_mph);
4b10cfd4 KG	402	goto err;
	403	}
	404
01cced25 KG	405	usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL;
01cced25 KG	406	usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask;
4b10cfd4 KG	407
	408	usb_data.operating_mode = FSL_USB2_MPH_HOST;
	409
	410	prop = get_property(np, "port0", NULL);
	411	if (prop)
	412	usb_data.port_enables \|= FSL_USB2_PORT0_ENABLED;
	413
	414	prop = get_property(np, "port1", NULL);
	415	if (prop)
	416	usb_data.port_enables \|= FSL_USB2_PORT1_ENABLED;
	417
	418	prop = get_property(np, "phy_type", NULL);
	419	usb_data.phy_mode = determine_usb_phy(prop);
	420
	421	ret =
01cced25	422	platform_device_add_data(usb_dev_mph, &usb_data,
4b10cfd4 KG	423	sizeof(struct
	424	fsl_usb2_platform_data));
	425	if (ret)
01cced25	426	goto unreg_mph;
4b10cfd4 KG	427	}
4b10cfd4 KG	428
01cced25	429	for (np = NULL;
4b10cfd4 KG	430	(np = of_find_compatible_node(np, "usb", "fsl-usb2-dr")) != NULL;
	431	i++) {
	432	struct resource r[2];
	433	struct fsl_usb2_platform_data usb_data;
a7f67bdf	434	const unsigned char *prop = NULL;
4b10cfd4 KG	435
	436	memset(&r, 0, sizeof(r));
	437	memset(&usb_data, 0, sizeof(usb_data));
	438
	439	ret = of_address_to_resource(np, 0, &r[0]);
	440	if (ret)
01cced25	441	goto unreg_mph;
4b10cfd4	442
919fede6	443	r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
4b10cfd4 KG	444	r[1].flags = IORESOURCE_IRQ;
4b10cfd4 KG	445
01cced25 KG	446	usb_dev_dr =
	447	platform_device_register_simple("fsl-ehci", i, r, 2);
	448	if (IS_ERR(usb_dev_dr)) {
	449	ret = PTR_ERR(usb_dev_dr);
4b10cfd4 KG	450	goto err;
	451	}
	452
01cced25 KG	453	usb_dev_dr->dev.coherent_dma_mask = 0xffffffffUL;
01cced25 KG	454	usb_dev_dr->dev.dma_mask = &usb_dev_dr->dev.coherent_dma_mask;
4b10cfd4 KG	455
	456	usb_data.operating_mode = FSL_USB2_DR_HOST;
	457
	458	prop = get_property(np, "phy_type", NULL);
	459	usb_data.phy_mode = determine_usb_phy(prop);
	460
	461	ret =
01cced25	462	platform_device_add_data(usb_dev_dr, &usb_data,
4b10cfd4 KG	463	sizeof(struct
	464	fsl_usb2_platform_data));
	465	if (ret)
01cced25	466	goto unreg_dr;
4b10cfd4	467	}
4b10cfd4 KG	468	return 0;
4b10cfd4 KG	469
01cced25 KG	470	unreg_dr:
	471	if (usb_dev_dr)
	472	platform_device_unregister(usb_dev_dr);
	473	unreg_mph:
	474	if (usb_dev_mph)
	475	platform_device_unregister(usb_dev_mph);
4b10cfd4 KG	476	err:
	477	return ret;
	478	}
	479
01cced25	480	arch_initcall(fsl_usb_of_init);