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

/*
 * FSL SoC setup code
 *
 * Maintained by Kumar Gala (see MAINTAINERS for contact information)
 *
 * 2006 (c) MontaVista Software, Inc.
 * Vitaly Bordug <vbordug@ru.mvista.com>
 *
 * 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/of.h>
#include <linux/of_platform.h>
#include <linux/phy.h>
#include <linux/phy_fixed.h>
#include <linux/spi/spi.h>
#include <linux/fsl_devices.h>
#include <linux/fs_enet_pd.h>
#include <linux/fs_uart_pd.h>

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

extern void init_fcc_ioports(struct fs_platform_info*);
extern void init_fec_ioports(struct fs_platform_info*);
extern void init_smc_ioports(struct fs_uart_platform_info*);
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) {
		int size;
		u32 naddr;
		const u32 *prop = of_get_property(soc, "#address-cells", &size);

		if (prop && size == 4)
			naddr = *prop;
		else
			naddr = 2;

		prop = of_get_property(soc, "ranges", &size);
		if (prop)
			immrbase = of_translate_address(soc, prop + naddr);

		of_node_put(soc);
	}

	return immrbase;
}

EXPORT_SYMBOL(get_immrbase);

static u32 sysfreq = -1;

u32 fsl_get_sys_freq(void)
{
	struct device_node *soc;
	const u32 *prop;
	int size;

	if (sysfreq != -1)
		return sysfreq;

	soc = of_find_node_by_type(NULL, "soc");
	if (!soc)
		return -1;

	prop = of_get_property(soc, "clock-frequency", &size);
	if (!prop || size != sizeof(*prop) || *prop == 0)
		prop = of_get_property(soc, "bus-frequency", &size);

	if (prop && size == sizeof(*prop))
		sysfreq = *prop;

	of_node_put(soc);
	return sysfreq;
}
EXPORT_SYMBOL(fsl_get_sys_freq);

#if defined(CONFIG_CPM2) || defined(CONFIG_QUICC_ENGINE) || defined(CONFIG_8xx)

static u32 brgfreq = -1;

u32 get_brgfreq(void)
{
	struct device_node *node;
	const unsigned int *prop;
	int size;

	if (brgfreq != -1)
		return brgfreq;

	node = of_find_compatible_node(NULL, NULL, "fsl,cpm-brg");
	if (node) {
		prop = of_get_property(node, "clock-frequency", &size);
		if (prop && size == 4)
			brgfreq = *prop;

		of_node_put(node);
		return brgfreq;
	}

	/* Legacy device binding -- will go away when no users are left. */
	node = of_find_node_by_type(NULL, "cpm");
	if (!node)
		node = of_find_compatible_node(NULL, NULL, "fsl,qe");
	if (!node)
		node = of_find_node_by_type(NULL, "qe");

	if (node) {
		prop = of_get_property(node, "brg-frequency", &size);
		if (prop && size == 4)
			brgfreq = *prop;

		if (brgfreq == -1 || brgfreq == 0) {
			prop = of_get_property(node, "bus-frequency", &size);
			if (prop && size == 4)
				brgfreq = *prop / 2;
		}
		of_node_put(node);
	}

	return brgfreq;
}

EXPORT_SYMBOL(get_brgfreq);

static u32 fs_baudrate = -1;

u32 get_baudrate(void)
{
	struct device_node *node;

	if (fs_baudrate != -1)
		return fs_baudrate;

	node = of_find_node_by_type(NULL, "serial");
	if (node) {
		int size;
		const unsigned int *prop = of_get_property(node,
				"current-speed", &size);

		if (prop)
			fs_baudrate = *prop;
		of_node_put(node);
	}

	return fs_baudrate;
}

EXPORT_SYMBOL(get_baudrate);
#endif /* CONFIG_CPM2 */

#ifdef CONFIG_FIXED_PHY
static int __init of_add_fixed_phys(void)
{
	int ret;
	struct device_node *np;
	u32 *fixed_link;
	struct fixed_phy_status status = {};

	for_each_node_by_name(np, "ethernet") {
		fixed_link  = (u32 *)of_get_property(np, "fixed-link", NULL);
		if (!fixed_link)
			continue;

		status.link = 1;
		status.duplex = fixed_link[1];
		status.speed = fixed_link[2];
		status.pause = fixed_link[3];
		status.asym_pause = fixed_link[4];

		ret = fixed_phy_add(PHY_POLL, fixed_link[0], &status);
		if (ret) {
			of_node_put(np);
			return ret;
		}
	}

	return 0;
}
arch_initcall(of_add_fixed_phys);
#endif /* CONFIG_FIXED_PHY */

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 = 0;
	struct platform_device *usb_dev_mph = NULL, *usb_dev_dr_host = NULL,
		*usb_dev_dr_client = NULL;
	int ret;

	for_each_compatible_node(np, NULL, "fsl-usb2-mph") {
		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;

		of_irq_to_resource(np, 0, &r[1]);

		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 = of_get_property(np, "port0", NULL);
		if (prop)
			usb_data.port_enables |= FSL_USB2_PORT0_ENABLED;

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

		prop = of_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;
		i++;
	}

	for_each_compatible_node(np, NULL, "fsl-usb2-dr") {
		struct resource r[2];
		struct fsl_usb2_platform_data usb_data;
		const unsigned char *prop = NULL;

		if (!of_device_is_available(np))
			continue;

		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;

		of_irq_to_resource(np, 0, &r[1]);

		prop = of_get_property(np, "dr_mode", NULL);

		if (!prop || !strcmp(prop, "host")) {
			usb_data.operating_mode = FSL_USB2_DR_HOST;
			usb_dev_dr_host = platform_device_register_simple(
					"fsl-ehci", i, r, 2);
			if (IS_ERR(usb_dev_dr_host)) {
				ret = PTR_ERR(usb_dev_dr_host);
				goto err;
			}
		} else if (prop && !strcmp(prop, "peripheral")) {
			usb_data.operating_mode = FSL_USB2_DR_DEVICE;
			usb_dev_dr_client = platform_device_register_simple(
					"fsl-usb2-udc", i, r, 2);
			if (IS_ERR(usb_dev_dr_client)) {
				ret = PTR_ERR(usb_dev_dr_client);
				goto err;
			}
		} else if (prop && !strcmp(prop, "otg")) {
			usb_data.operating_mode = FSL_USB2_DR_OTG;
			usb_dev_dr_host = platform_device_register_simple(
					"fsl-ehci", i, r, 2);
			if (IS_ERR(usb_dev_dr_host)) {
				ret = PTR_ERR(usb_dev_dr_host);
				goto err;
			}
			usb_dev_dr_client = platform_device_register_simple(
					"fsl-usb2-udc", i, r, 2);
			if (IS_ERR(usb_dev_dr_client)) {
				ret = PTR_ERR(usb_dev_dr_client);
				goto err;
			}
		} else {
			ret = -EINVAL;
			goto err;
		}

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

		if (usb_dev_dr_host) {
			usb_dev_dr_host->dev.coherent_dma_mask = 0xffffffffUL;
			usb_dev_dr_host->dev.dma_mask = &usb_dev_dr_host->
				dev.coherent_dma_mask;
			if ((ret = platform_device_add_data(usb_dev_dr_host,
						&usb_data, sizeof(struct
						fsl_usb2_platform_data))))
				goto unreg_dr;
		}
		if (usb_dev_dr_client) {
			usb_dev_dr_client->dev.coherent_dma_mask = 0xffffffffUL;
			usb_dev_dr_client->dev.dma_mask = &usb_dev_dr_client->
				dev.coherent_dma_mask;
			if ((ret = platform_device_add_data(usb_dev_dr_client,
						&usb_data, sizeof(struct
						fsl_usb2_platform_data))))
				goto unreg_dr;
		}
		i++;
	}
	return 0;

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

arch_initcall(fsl_usb_of_init);

#if defined(CONFIG_FSL_SOC_BOOKE) || defined(CONFIG_PPC_86xx)
static __be32 __iomem *rstcr;

static int __init setup_rstcr(void)
{
	struct device_node *np;
	np = of_find_node_by_name(NULL, "global-utilities");
	if ((np && of_get_property(np, "fsl,has-rstcr", NULL))) {
		rstcr = of_iomap(np, 0) + 0xb0;
		if (!rstcr)
			printk (KERN_EMERG "Error: reset control register "
					"not mapped!\n");
	} else if (ppc_md.restart == fsl_rstcr_restart)
		printk(KERN_ERR "No RSTCR register, warm reboot won't work\n");

	if (np)
		of_node_put(np);
	return 0;
}

arch_initcall(setup_rstcr);

void fsl_rstcr_restart(char *cmd)
{
	local_irq_disable();
	if (rstcr)
		/* set reset control register */
		out_be32(rstcr, 0x2);	/* HRESET_REQ */

	while (1) ;
}
#endif

#if defined(CONFIG_FB_FSL_DIU) || defined(CONFIG_FB_FSL_DIU_MODULE)
struct platform_diu_data_ops diu_ops;
EXPORT_SYMBOL(diu_ops);
#endif
Commit	Line	Data
eed32001 KG	1	/*
	2	* FSL SoC setup code
	3	*
	4	* Maintained by Kumar Gala (see MAINTAINERS for contact information)
	5	*
fba43665 VB	6	* 2006 (c) MontaVista Software, Inc.
	7	* Vitaly Bordug <vbordug@ru.mvista.com>
	8	*
eed32001 KG	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation; either version 2 of the License, or (at your
	12	* option) any later version.
	13	*/
	14
eed32001 KG	15	#include <linux/stddef.h>
	16	#include <linux/kernel.h>
	17	#include <linux/init.h>
	18	#include <linux/errno.h>
	19	#include <linux/major.h>
	20	#include <linux/delay.h>
	21	#include <linux/irq.h>
	22	#include <linux/module.h>
	23	#include <linux/device.h>
	24	#include <linux/platform_device.h>
c026c987	25	#include <linux/of.h>
0af666fa	26	#include <linux/of_platform.h>
a9b14973	27	#include <linux/phy.h>
a21e282a	28	#include <linux/phy_fixed.h>
26f6cb99	29	#include <linux/spi/spi.h>
eed32001	30	#include <linux/fsl_devices.h>
fba43665 VB	31	#include <linux/fs_enet_pd.h>
fba43665 VB	32	#include <linux/fs_uart_pd.h>
eed32001 KG	33
	34	#include <asm/system.h>
	35	#include <asm/atomic.h>
	36	#include <asm/io.h>
	37	#include <asm/irq.h>
fba43665	38	#include <asm/time.h>
eed32001	39	#include <asm/prom.h>
46c4c229	40	#include <asm/machdep.h>
eed32001 KG	41	#include <sysdev/fsl_soc.h>
eed32001 KG	42	#include <mm/mmu_decl.h>
fba43665	43	#include <asm/cpm2.h>
eed32001	44
d3465c92	45	extern void init_fcc_ioports(struct fs_platform_info*);
88bdc6f0 VB	46	extern void init_fec_ioports(struct fs_platform_info*);
88bdc6f0 VB	47	extern void init_smc_ioports(struct fs_uart_platform_info*);
eed32001 KG	48	static phys_addr_t immrbase = -1;
	49
	50	phys_addr_t get_immrbase(void)
	51	{
	52	struct device_node *soc;
	53
	54	if (immrbase != -1)
	55	return immrbase;
	56
	57	soc = of_find_node_by_type(NULL, "soc");
2fb07d77	58	if (soc) {
f9234736	59	int size;
6c7e072b SW	60	u32 naddr;
6c7e072b SW	61	const u32 *prop = of_get_property(soc, "#address-cells", &size);
fba43665	62
6c7e072b SW	63	if (prop && size == 4)
	64	naddr = *prop;
	65	else
	66	naddr = 2;
	67
	68	prop = of_get_property(soc, "ranges", &size);
fba43665	69	if (prop)
6c7e072b SW	70	immrbase = of_translate_address(soc, prop + naddr);
6c7e072b SW	71
eed32001	72	of_node_put(soc);
f9234736	73	}
eed32001 KG	74
	75	return immrbase;
	76	}
eed32001	77
2fb07d77	78	EXPORT_SYMBOL(get_immrbase);
eed32001	79
38664095 SW	80	static u32 sysfreq = -1;
	81
	82	u32 fsl_get_sys_freq(void)
	83	{
	84	struct device_node *soc;
	85	const u32 *prop;
	86	int size;
	87
	88	if (sysfreq != -1)
	89	return sysfreq;
	90
	91	soc = of_find_node_by_type(NULL, "soc");
	92	if (!soc)
	93	return -1;
	94
	95	prop = of_get_property(soc, "clock-frequency", &size);
	96	if (!prop \|\| size != sizeof(prop) \|\| prop == 0)
	97	prop = of_get_property(soc, "bus-frequency", &size);
	98
	99	if (prop && size == sizeof(*prop))
	100	sysfreq = *prop;
	101
	102	of_node_put(soc);
	103	return sysfreq;
	104	}
	105	EXPORT_SYMBOL(fsl_get_sys_freq);
	106
59a0ea50	107	#if defined(CONFIG_CPM2) \|\| defined(CONFIG_QUICC_ENGINE) \|\| defined(CONFIG_8xx)
fba43665 VB	108
	109	static u32 brgfreq = -1;
	110
	111	u32 get_brgfreq(void)
	112	{
	113	struct device_node *node;
6d817aa7 SW	114	const unsigned int *prop;
6d817aa7 SW	115	int size;
fba43665 VB	116
	117	if (brgfreq != -1)
	118	return brgfreq;
	119
6d817aa7	120	node = of_find_compatible_node(NULL, NULL, "fsl,cpm-brg");
fba43665	121	if (node) {
6d817aa7 SW	122	prop = of_get_property(node, "clock-frequency", &size);
	123	if (prop && size == 4)
	124	brgfreq = *prop;
	125
	126	of_node_put(node);
	127	return brgfreq;
	128	}
fba43665	129
6d817aa7 SW	130	/* Legacy device binding -- will go away when no users are left. */
6d817aa7 SW	131	node = of_find_node_by_type(NULL, "cpm");
59a0ea50 AV	132	if (!node)
	133	node = of_find_compatible_node(NULL, NULL, "fsl,qe");
	134	if (!node)
	135	node = of_find_node_by_type(NULL, "qe");
	136
6d817aa7 SW	137	if (node) {
6d817aa7 SW	138	prop = of_get_property(node, "brg-frequency", &size);
f9234736	139	if (prop && size == 4)
fba43665	140	brgfreq = *prop;
f9234736	141
59a0ea50 AV	142	if (brgfreq == -1 \|\| brgfreq == 0) {
	143	prop = of_get_property(node, "bus-frequency", &size);
	144	if (prop && size == 4)
	145	brgfreq = *prop / 2;
	146	}
fba43665	147	of_node_put(node);
f9234736	148	}
fba43665 VB	149
	150	return brgfreq;
	151	}
	152
	153	EXPORT_SYMBOL(get_brgfreq);
	154
	155	static u32 fs_baudrate = -1;
	156
	157	u32 get_baudrate(void)
	158	{
	159	struct device_node *node;
	160
	161	if (fs_baudrate != -1)
	162	return fs_baudrate;
	163
	164	node = of_find_node_by_type(NULL, "serial");
	165	if (node) {
f9234736	166	int size;
e2eb6392 SR	167	const unsigned int *prop = of_get_property(node,
e2eb6392 SR	168	"current-speed", &size);
fba43665 VB	169
	170	if (prop)
	171	fs_baudrate = *prop;
	172	of_node_put(node);
f9234736	173	}
fba43665 VB	174
	175	return fs_baudrate;
	176	}
	177
	178	EXPORT_SYMBOL(get_baudrate);
	179	#endif /* CONFIG_CPM2 */
	180
a21e282a VB	181	#ifdef CONFIG_FIXED_PHY
	182	static int __init of_add_fixed_phys(void)
	183	{
	184	int ret;
	185	struct device_node *np;
	186	u32 *fixed_link;
	187	struct fixed_phy_status status = {};
	188
	189	for_each_node_by_name(np, "ethernet") {
	190	fixed_link = (u32 *)of_get_property(np, "fixed-link", NULL);
	191	if (!fixed_link)
	192	continue;
	193
	194	status.link = 1;
	195	status.duplex = fixed_link[1];
	196	status.speed = fixed_link[2];
	197	status.pause = fixed_link[3];
	198	status.asym_pause = fixed_link[4];
	199
	200	ret = fixed_phy_add(PHY_POLL, fixed_link[0], &status);
	201	if (ret) {
	202	of_node_put(np);
	203	return ret;
	204	}
	205	}
	206
	207	return 0;
	208	}
	209	arch_initcall(of_add_fixed_phys);
	210	#endif /* CONFIG_FIXED_PHY */
	211
a7f67bdf	212	static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type)
4b10cfd4 KG	213	{
	214	if (!phy_type)
	215	return FSL_USB2_PHY_NONE;
	216	if (!strcasecmp(phy_type, "ulpi"))
	217	return FSL_USB2_PHY_ULPI;
	218	if (!strcasecmp(phy_type, "utmi"))
	219	return FSL_USB2_PHY_UTMI;
	220	if (!strcasecmp(phy_type, "utmi_wide"))
	221	return FSL_USB2_PHY_UTMI_WIDE;
	222	if (!strcasecmp(phy_type, "serial"))
	223	return FSL_USB2_PHY_SERIAL;
	224
	225	return FSL_USB2_PHY_NONE;
	226	}
	227
	228	static int __init fsl_usb_of_init(void)
	229	{
	230	struct device_node *np;
866b6ddd	231	unsigned int i = 0;
97c5a20a LY	232	struct platform_device usb_dev_mph = NULL, usb_dev_dr_host = NULL,
97c5a20a LY	233	*usb_dev_dr_client = NULL;
4b10cfd4 KG	234	int ret;
4b10cfd4 KG	235
866b6ddd	236	for_each_compatible_node(np, NULL, "fsl-usb2-mph") {
4b10cfd4 KG	237	struct resource r[2];
4b10cfd4 KG	238	struct fsl_usb2_platform_data usb_data;
a7f67bdf	239	const unsigned char *prop = NULL;
4b10cfd4 KG	240
	241	memset(&r, 0, sizeof(r));
	242	memset(&usb_data, 0, sizeof(usb_data));
	243
	244	ret = of_address_to_resource(np, 0, &r[0]);
	245	if (ret)
	246	goto err;
	247
a9b14973	248	of_irq_to_resource(np, 0, &r[1]);
4b10cfd4	249
01cced25 KG	250	usb_dev_mph =
	251	platform_device_register_simple("fsl-ehci", i, r, 2);
	252	if (IS_ERR(usb_dev_mph)) {
	253	ret = PTR_ERR(usb_dev_mph);
4b10cfd4 KG	254	goto err;
	255	}
	256
01cced25 KG	257	usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL;
01cced25 KG	258	usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask;
4b10cfd4 KG	259
	260	usb_data.operating_mode = FSL_USB2_MPH_HOST;
	261
e2eb6392	262	prop = of_get_property(np, "port0", NULL);
4b10cfd4 KG	263	if (prop)
	264	usb_data.port_enables \|= FSL_USB2_PORT0_ENABLED;
	265
e2eb6392	266	prop = of_get_property(np, "port1", NULL);
4b10cfd4 KG	267	if (prop)
	268	usb_data.port_enables \|= FSL_USB2_PORT1_ENABLED;
	269
e2eb6392	270	prop = of_get_property(np, "phy_type", NULL);
4b10cfd4 KG	271	usb_data.phy_mode = determine_usb_phy(prop);
	272
	273	ret =
01cced25	274	platform_device_add_data(usb_dev_mph, &usb_data,
4b10cfd4 KG	275	sizeof(struct
	276	fsl_usb2_platform_data));
	277	if (ret)
01cced25	278	goto unreg_mph;
866b6ddd	279	i++;
4b10cfd4 KG	280	}
4b10cfd4 KG	281
866b6ddd	282	for_each_compatible_node(np, NULL, "fsl-usb2-dr") {
4b10cfd4 KG	283	struct resource r[2];
4b10cfd4 KG	284	struct fsl_usb2_platform_data usb_data;
a7f67bdf	285	const unsigned char *prop = NULL;
4b10cfd4	286
c026c987 AV	287	if (!of_device_is_available(np))
	288	continue;
	289
4b10cfd4 KG	290	memset(&r, 0, sizeof(r));
	291	memset(&usb_data, 0, sizeof(usb_data));
	292
	293	ret = of_address_to_resource(np, 0, &r[0]);
	294	if (ret)
01cced25	295	goto unreg_mph;
4b10cfd4	296
a9b14973	297	of_irq_to_resource(np, 0, &r[1]);
4b10cfd4	298
e2eb6392	299	prop = of_get_property(np, "dr_mode", NULL);
97c5a20a LY	300
	301	if (!prop \|\| !strcmp(prop, "host")) {
	302	usb_data.operating_mode = FSL_USB2_DR_HOST;
	303	usb_dev_dr_host = platform_device_register_simple(
	304	"fsl-ehci", i, r, 2);
	305	if (IS_ERR(usb_dev_dr_host)) {
	306	ret = PTR_ERR(usb_dev_dr_host);
	307	goto err;
	308	}
	309	} else if (prop && !strcmp(prop, "peripheral")) {
	310	usb_data.operating_mode = FSL_USB2_DR_DEVICE;
	311	usb_dev_dr_client = platform_device_register_simple(
	312	"fsl-usb2-udc", i, r, 2);
	313	if (IS_ERR(usb_dev_dr_client)) {
	314	ret = PTR_ERR(usb_dev_dr_client);
	315	goto err;
	316	}
	317	} else if (prop && !strcmp(prop, "otg")) {
	318	usb_data.operating_mode = FSL_USB2_DR_OTG;
	319	usb_dev_dr_host = platform_device_register_simple(
	320	"fsl-ehci", i, r, 2);
	321	if (IS_ERR(usb_dev_dr_host)) {
	322	ret = PTR_ERR(usb_dev_dr_host);
	323	goto err;
	324	}
	325	usb_dev_dr_client = platform_device_register_simple(
	326	"fsl-usb2-udc", i, r, 2);
	327	if (IS_ERR(usb_dev_dr_client)) {
	328	ret = PTR_ERR(usb_dev_dr_client);
	329	goto err;
	330	}
	331	} else {
	332	ret = -EINVAL;
4b10cfd4 KG	333	goto err;
	334	}
	335
e2eb6392	336	prop = of_get_property(np, "phy_type", NULL);
4b10cfd4 KG	337	usb_data.phy_mode = determine_usb_phy(prop);
4b10cfd4 KG	338
97c5a20a LY	339	if (usb_dev_dr_host) {
	340	usb_dev_dr_host->dev.coherent_dma_mask = 0xffffffffUL;
	341	usb_dev_dr_host->dev.dma_mask = &usb_dev_dr_host->
	342	dev.coherent_dma_mask;
	343	if ((ret = platform_device_add_data(usb_dev_dr_host,
	344	&usb_data, sizeof(struct
	345	fsl_usb2_platform_data))))
	346	goto unreg_dr;
	347	}
	348	if (usb_dev_dr_client) {
	349	usb_dev_dr_client->dev.coherent_dma_mask = 0xffffffffUL;
	350	usb_dev_dr_client->dev.dma_mask = &usb_dev_dr_client->
	351	dev.coherent_dma_mask;
	352	if ((ret = platform_device_add_data(usb_dev_dr_client,
	353	&usb_data, sizeof(struct
	354	fsl_usb2_platform_data))))
	355	goto unreg_dr;
	356	}
866b6ddd	357	i++;
4b10cfd4	358	}
4b10cfd4 KG	359	return 0;
4b10cfd4 KG	360
01cced25	361	unreg_dr:
97c5a20a LY	362	if (usb_dev_dr_host)
	363	platform_device_unregister(usb_dev_dr_host);
	364	if (usb_dev_dr_client)
	365	platform_device_unregister(usb_dev_dr_client);
01cced25 KG	366	unreg_mph:
	367	if (usb_dev_mph)
	368	platform_device_unregister(usb_dev_mph);
4b10cfd4 KG	369	err:
	370	return ret;
	371	}
	372
01cced25	373	arch_initcall(fsl_usb_of_init);
fba43665	374
5753c082	375	#if defined(CONFIG_FSL_SOC_BOOKE) \|\| defined(CONFIG_PPC_86xx)
e1c1575f KG	376	static __be32 __iomem *rstcr;
	377
	378	static int __init setup_rstcr(void)
	379	{
	380	struct device_node *np;
	381	np = of_find_node_by_name(NULL, "global-utilities");
	382	if ((np && of_get_property(np, "fsl,has-rstcr", NULL))) {
81db718d KG	383	rstcr = of_iomap(np, 0) + 0xb0;
	384	if (!rstcr)
	385	printk (KERN_EMERG "Error: reset control register "
	386	"not mapped!\n");
46c4c229 PG	387	} else if (ppc_md.restart == fsl_rstcr_restart)
	388	printk(KERN_ERR "No RSTCR register, warm reboot won't work\n");
	389
e1c1575f KG	390	if (np)
	391	of_node_put(np);
	392	return 0;
	393	}
	394
	395	arch_initcall(setup_rstcr);
	396
	397	void fsl_rstcr_restart(char *cmd)
	398	{
	399	local_irq_disable();
	400	if (rstcr)
	401	/* set reset control register */
	402	out_be32(rstcr, 0x2); /* HRESET_REQ */
	403
	404	while (1) ;
	405	}
	406	#endif
6f90a8bd YS	407
6f90a8bd YS	408	#if defined(CONFIG_FB_FSL_DIU) \|\| defined(CONFIG_FB_FSL_DIU_MODULE)
43c9f434	409	struct platform_diu_data_ops diu_ops;
6f90a8bd	410	EXPORT_SYMBOL(diu_ops);
6f90a8bd	411	#endif