[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;
		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) {
			if (child->n_intrs) {
				u32 *id =
				    (u32 *) get_property(child, "reg", NULL);
				mdio_data.irq[*id] = child->intrs[0].line;
			}
		}

		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;
		unsigned int *id;
		char *model;
		void *mac_addr;
		phandle *ph;

		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 = np->intrs[0].line;
		r[1].end = np->intrs[0].line;
		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 = np->intrs[1].line;
			r[2].end = np->intrs[1].line;
			r[2].flags = IORESOURCE_IRQ;

			r[3].name = gfar_err_intr;
			r[3].start = np->intrs[2].line;
			r[3].end = np->intrs[2].line;
			r[3].flags = IORESOURCE_IRQ;
		}

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

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

		mac_addr = get_property(np, "address", NULL);
		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 = (phandle *) 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 = (u32 *) 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;
		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 = np->intrs[0].line;
		r[1].end = np->intrs[0].line;
		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;
	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 = (unsigned int *)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(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;
		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 = np->intrs[0].line;
		r[1].end = np->intrs[0].line;
		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;
		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 = np->intrs[0].line;
		r[1].end = np->intrs[0].line;
		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 KG	43	unsigned int size;
	44	void *prop = get_property(soc, "reg", &size);
	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) {
	88	if (child->n_intrs) {
2fb07d77 KG	89	u32 *id =
2fb07d77 KG	90	(u32 *) get_property(child, "reg", NULL);
eed32001 KG	91	mdio_data.irq[*id] = child->intrs[0].line;
	92	}
	93	}
	94
2fb07d77 KG	95	ret =
	96	platform_device_add_data(mdio_dev, &mdio_data,
	97	sizeof(struct gianfar_mdio_data));
eed32001	98	if (ret)
2fb07d77	99	goto unreg;
eed32001 KG	100	}
eed32001 KG	101
2fb07d77 KG	102	return 0;
	103
	104	unreg:
	105	platform_device_unregister(mdio_dev);
	106	err:
	107	return ret;
	108	}
	109
	110	arch_initcall(gfar_mdio_of_init);
	111
	112	static const char *gfar_tx_intr = "tx";
	113	static const char *gfar_rx_intr = "rx";
	114	static const char *gfar_err_intr = "error";
	115
	116	static int __init gfar_of_init(void)
	117	{
	118	struct device_node *np;
	119	unsigned int i;
	120	struct platform_device *gfar_dev;
	121	struct resource res;
	122	int ret;
	123
	124	for (np = NULL, i = 0;
	125	(np = of_find_compatible_node(np, "network", "gianfar")) != NULL;
	126	i++) {
eed32001 KG	127	struct resource r[4];
	128	struct device_node phy, mdio;
	129	struct gianfar_platform_data gfar_data;
	130	unsigned int *id;
	131	char *model;
	132	void *mac_addr;
	133	phandle *ph;
	134
	135	memset(r, 0, sizeof(r));
	136	memset(&gfar_data, 0, sizeof(gfar_data));
	137
	138	ret = of_address_to_resource(np, 0, &r[0]);
	139	if (ret)
2fb07d77	140	goto err;
eed32001 KG	141
	142	r[1].start = np->intrs[0].line;
	143	r[1].end = np->intrs[0].line;
	144	r[1].flags = IORESOURCE_IRQ;
	145
	146	model = get_property(np, "model", NULL);
	147
	148	/* If we aren't the FEC we have multiple interrupts */
	149	if (model && strcasecmp(model, "FEC")) {
	150	r[1].name = gfar_tx_intr;
	151
	152	r[2].name = gfar_rx_intr;
	153	r[2].start = np->intrs[1].line;
	154	r[2].end = np->intrs[1].line;
	155	r[2].flags = IORESOURCE_IRQ;
	156
	157	r[3].name = gfar_err_intr;
	158	r[3].start = np->intrs[2].line;
	159	r[3].end = np->intrs[2].line;
	160	r[3].flags = IORESOURCE_IRQ;
	161	}
	162
2fb07d77 KG	163	gfar_dev =
	164	platform_device_register_simple("fsl-gianfar", i, &r[0],
	165	np->n_intrs + 1);
eed32001 KG	166
	167	if (IS_ERR(gfar_dev)) {
	168	ret = PTR_ERR(gfar_dev);
2fb07d77	169	goto err;
eed32001 KG	170	}
	171
	172	mac_addr = get_property(np, "address", NULL);
	173	memcpy(gfar_data.mac_addr, mac_addr, 6);
	174
	175	if (model && !strcasecmp(model, "TSEC"))
	176	gfar_data.device_flags =
2fb07d77 KG	177	FSL_GIANFAR_DEV_HAS_GIGABIT \|
	178	FSL_GIANFAR_DEV_HAS_COALESCE \|
	179	FSL_GIANFAR_DEV_HAS_RMON \|
	180	FSL_GIANFAR_DEV_HAS_MULTI_INTR;
eed32001 KG	181	if (model && !strcasecmp(model, "eTSEC"))
eed32001 KG	182	gfar_data.device_flags =
2fb07d77 KG	183	FSL_GIANFAR_DEV_HAS_GIGABIT \|
	184	FSL_GIANFAR_DEV_HAS_COALESCE \|
	185	FSL_GIANFAR_DEV_HAS_RMON \|
	186	FSL_GIANFAR_DEV_HAS_MULTI_INTR \|
	187	FSL_GIANFAR_DEV_HAS_CSUM \|
	188	FSL_GIANFAR_DEV_HAS_VLAN \|
	189	FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;
eed32001 KG	190
	191	ph = (phandle *) get_property(np, "phy-handle", NULL);
	192	phy = of_find_node_by_phandle(*ph);
	193
	194	if (phy == NULL) {
	195	ret = -ENODEV;
2fb07d77	196	goto unreg;
eed32001 KG	197	}
	198
	199	mdio = of_get_parent(phy);
	200
	201	id = (u32 *) get_property(phy, "reg", NULL);
	202	ret = of_address_to_resource(mdio, 0, &res);
	203	if (ret) {
	204	of_node_put(phy);
	205	of_node_put(mdio);
2fb07d77	206	goto unreg;
eed32001 KG	207	}
	208
	209	gfar_data.phy_id = *id;
	210	gfar_data.bus_id = res.start;
	211
	212	of_node_put(phy);
	213	of_node_put(mdio);
	214
2fb07d77 KG	215	ret =
	216	platform_device_add_data(gfar_dev, &gfar_data,
	217	sizeof(struct
	218	gianfar_platform_data));
eed32001	219	if (ret)
2fb07d77	220	goto unreg;
eed32001 KG	221	}
	222
	223	return 0;
	224
2fb07d77	225	unreg:
eed32001	226	platform_device_unregister(gfar_dev);
2fb07d77	227	err:
eed32001 KG	228	return ret;
eed32001 KG	229	}
2fb07d77	230
eed32001 KG	231	arch_initcall(gfar_of_init);
	232
	233	static int __init fsl_i2c_of_init(void)
	234	{
	235	struct device_node *np;
	236	unsigned int i;
	237	struct platform_device *i2c_dev;
	238	int ret;
	239
2fb07d77 KG	240	for (np = NULL, i = 0;
	241	(np = of_find_compatible_node(np, "i2c", "fsl-i2c")) != NULL;
	242	i++) {
eed32001 KG	243	struct resource r[2];
eed32001 KG	244	struct fsl_i2c_platform_data i2c_data;
2fb07d77	245	unsigned char *flags = NULL;
eed32001 KG	246
	247	memset(&r, 0, sizeof(r));
	248	memset(&i2c_data, 0, sizeof(i2c_data));
	249
	250	ret = of_address_to_resource(np, 0, &r[0]);
	251	if (ret)
2fb07d77	252	goto err;
eed32001 KG	253
	254	r[1].start = np->intrs[0].line;
	255	r[1].end = np->intrs[0].line;
	256	r[1].flags = IORESOURCE_IRQ;
	257
	258	i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2);
	259	if (IS_ERR(i2c_dev)) {
	260	ret = PTR_ERR(i2c_dev);
2fb07d77	261	goto err;
eed32001 KG	262	}
	263
	264	i2c_data.device_flags = 0;
	265	flags = get_property(np, "dfsrr", NULL);
	266	if (flags)
	267	i2c_data.device_flags \|= FSL_I2C_DEV_SEPARATE_DFSRR;
	268
	269	flags = get_property(np, "fsl5200-clocking", NULL);
	270	if (flags)
	271	i2c_data.device_flags \|= FSL_I2C_DEV_CLOCK_5200;
	272
2fb07d77 KG	273	ret =
	274	platform_device_add_data(i2c_dev, &i2c_data,
	275	sizeof(struct
	276	fsl_i2c_platform_data));
eed32001	277	if (ret)
2fb07d77	278	goto unreg;
eed32001 KG	279	}
	280
	281	return 0;
	282
2fb07d77	283	unreg:
eed32001	284	platform_device_unregister(i2c_dev);
2fb07d77	285	err:
eed32001 KG	286	return ret;
eed32001 KG	287	}
2fb07d77	288
eed32001 KG	289	arch_initcall(fsl_i2c_of_init);
	290
	291	#ifdef CONFIG_PPC_83xx
	292	static int __init mpc83xx_wdt_init(void)
	293	{
	294	struct resource r;
	295	struct device_node soc, np;
	296	struct platform_device *dev;
	297	unsigned int *freq;
	298	int ret;
	299
	300	np = of_find_compatible_node(NULL, "watchdog", "mpc83xx_wdt");
	301
	302	if (!np) {
	303	ret = -ENODEV;
2fb07d77	304	goto nodev;
eed32001 KG	305	}
	306
	307	soc = of_find_node_by_type(NULL, "soc");
	308
	309	if (!soc) {
	310	ret = -ENODEV;
2fb07d77	311	goto nosoc;
eed32001 KG	312	}
	313
	314	freq = (unsigned int *)get_property(soc, "bus-frequency", NULL);
	315	if (!freq) {
	316	ret = -ENODEV;
2fb07d77	317	goto err;
eed32001 KG	318	}
	319
	320	memset(&r, 0, sizeof(r));
	321
	322	ret = of_address_to_resource(np, 0, &r);
	323	if (ret)
2fb07d77	324	goto err;
eed32001 KG	325
	326	dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1);
	327	if (IS_ERR(dev)) {
	328	ret = PTR_ERR(dev);
2fb07d77	329	goto err;
eed32001 KG	330	}
	331
	332	ret = platform_device_add_data(dev, freq, sizeof(int));
	333	if (ret)
2fb07d77	334	goto unreg;
eed32001 KG	335
	336	of_node_put(soc);
	337	of_node_put(np);
	338
	339	return 0;
	340
2fb07d77	341	unreg:
eed32001	342	platform_device_unregister(dev);
2fb07d77	343	err:
eed32001	344	of_node_put(soc);
2fb07d77	345	nosoc:
eed32001	346	of_node_put(np);
2fb07d77	347	nodev:
eed32001 KG	348	return ret;
eed32001 KG	349	}
2fb07d77	350
eed32001 KG	351	arch_initcall(mpc83xx_wdt_init);
eed32001 KG	352	#endif
4b10cfd4 KG	353
	354	static enum fsl_usb2_phy_modes determine_usb_phy(char * phy_type)
	355	{
	356	if (!phy_type)
	357	return FSL_USB2_PHY_NONE;
	358	if (!strcasecmp(phy_type, "ulpi"))
	359	return FSL_USB2_PHY_ULPI;
	360	if (!strcasecmp(phy_type, "utmi"))
	361	return FSL_USB2_PHY_UTMI;
	362	if (!strcasecmp(phy_type, "utmi_wide"))
	363	return FSL_USB2_PHY_UTMI_WIDE;
	364	if (!strcasecmp(phy_type, "serial"))
	365	return FSL_USB2_PHY_SERIAL;
	366
	367	return FSL_USB2_PHY_NONE;
	368	}
	369
	370	static int __init fsl_usb_of_init(void)
	371	{
	372	struct device_node *np;
	373	unsigned int i;
01cced25	374	struct platform_device usb_dev_mph = NULL, usb_dev_dr = NULL;
4b10cfd4 KG	375	int ret;
	376
	377	for (np = NULL, i = 0;
	378	(np = of_find_compatible_node(np, "usb", "fsl-usb2-mph")) != NULL;
	379	i++) {
	380	struct resource r[2];
	381	struct fsl_usb2_platform_data usb_data;
	382	unsigned char *prop = NULL;
	383
	384	memset(&r, 0, sizeof(r));
	385	memset(&usb_data, 0, sizeof(usb_data));
	386
	387	ret = of_address_to_resource(np, 0, &r[0]);
	388	if (ret)
	389	goto err;
	390
	391	r[1].start = np->intrs[0].line;
	392	r[1].end = np->intrs[0].line;
	393	r[1].flags = IORESOURCE_IRQ;
	394
01cced25 KG	395	usb_dev_mph =
	396	platform_device_register_simple("fsl-ehci", i, r, 2);
	397	if (IS_ERR(usb_dev_mph)) {
	398	ret = PTR_ERR(usb_dev_mph);
4b10cfd4 KG	399	goto err;
	400	}
	401
01cced25 KG	402	usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL;
01cced25 KG	403	usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask;
4b10cfd4 KG	404
	405	usb_data.operating_mode = FSL_USB2_MPH_HOST;
	406
	407	prop = get_property(np, "port0", NULL);
	408	if (prop)
	409	usb_data.port_enables \|= FSL_USB2_PORT0_ENABLED;
	410
	411	prop = get_property(np, "port1", NULL);
	412	if (prop)
	413	usb_data.port_enables \|= FSL_USB2_PORT1_ENABLED;
	414
	415	prop = get_property(np, "phy_type", NULL);
	416	usb_data.phy_mode = determine_usb_phy(prop);
	417
	418	ret =
01cced25	419	platform_device_add_data(usb_dev_mph, &usb_data,
4b10cfd4 KG	420	sizeof(struct
	421	fsl_usb2_platform_data));
	422	if (ret)
01cced25	423	goto unreg_mph;
4b10cfd4 KG	424	}
4b10cfd4 KG	425
01cced25	426	for (np = NULL;
4b10cfd4 KG	427	(np = of_find_compatible_node(np, "usb", "fsl-usb2-dr")) != NULL;
	428	i++) {
	429	struct resource r[2];
	430	struct fsl_usb2_platform_data usb_data;
	431	unsigned char *prop = NULL;
	432
	433	memset(&r, 0, sizeof(r));
	434	memset(&usb_data, 0, sizeof(usb_data));
	435
	436	ret = of_address_to_resource(np, 0, &r[0]);
	437	if (ret)
01cced25	438	goto unreg_mph;
4b10cfd4 KG	439
	440	r[1].start = np->intrs[0].line;
	441	r[1].end = np->intrs[0].line;
	442	r[1].flags = IORESOURCE_IRQ;
	443
01cced25 KG	444	usb_dev_dr =
	445	platform_device_register_simple("fsl-ehci", i, r, 2);
	446	if (IS_ERR(usb_dev_dr)) {
	447	ret = PTR_ERR(usb_dev_dr);
4b10cfd4 KG	448	goto err;
	449	}
	450
01cced25 KG	451	usb_dev_dr->dev.coherent_dma_mask = 0xffffffffUL;
01cced25 KG	452	usb_dev_dr->dev.dma_mask = &usb_dev_dr->dev.coherent_dma_mask;
4b10cfd4 KG	453
	454	usb_data.operating_mode = FSL_USB2_DR_HOST;
	455
	456	prop = get_property(np, "phy_type", NULL);
	457	usb_data.phy_mode = determine_usb_phy(prop);
	458
	459	ret =
01cced25	460	platform_device_add_data(usb_dev_dr, &usb_data,
4b10cfd4 KG	461	sizeof(struct
	462	fsl_usb2_platform_data));
	463	if (ret)
01cced25	464	goto unreg_dr;
4b10cfd4	465	}
4b10cfd4 KG	466	return 0;
4b10cfd4 KG	467
01cced25 KG	468	unreg_dr:
	469	if (usb_dev_dr)
	470	platform_device_unregister(usb_dev_dr);
	471	unreg_mph:
	472	if (usb_dev_mph)
	473	platform_device_unregister(usb_dev_mph);
4b10cfd4 KG	474	err:
	475	return ret;
	476	}
	477
01cced25	478	arch_initcall(fsl_usb_of_init);