[deliverable/linux.git] / arch / powerpc / sysdev / mv64x60_dev.c

/*
 * Platform device setup for Marvell mv64360/mv64460 host bridges (Discovery)
 *
 * Author: Dale Farnsworth <dale@farnsworth.org>
 *
 * 2007 (c) 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.
 */

#include <linux/stddef.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/console.h>
#include <linux/mv643xx.h>
#include <linux/platform_device.h>

#include <asm/prom.h>

/*
 * These functions provide the necessary setup for the mv64x60 drivers.
 * These drivers are unusual in that they work on both the MIPS and PowerPC
 * architectures.  Because of that, the drivers do not support the normal
 * PowerPC of_platform_bus_type.  They support platform_bus_type instead.
 */

/*
 * Create MPSC platform devices
 */
static int __init mv64x60_mpsc_register_shared_pdev(struct device_node *np)
{
	struct platform_device *pdev;
	struct resource r[2];
	struct mpsc_shared_pdata pdata;
	const phandle *ph;
	struct device_node *mpscrouting, *mpscintr;
	int err;

	ph = of_get_property(np, "mpscrouting", NULL);
	mpscrouting = of_find_node_by_phandle(*ph);
	if (!mpscrouting)
		return -ENODEV;

	err = of_address_to_resource(mpscrouting, 0, &r[0]);
	of_node_put(mpscrouting);
	if (err)
		return err;

	ph = of_get_property(np, "mpscintr", NULL);
	mpscintr = of_find_node_by_phandle(*ph);
	if (!mpscintr)
		return -ENODEV;

	err = of_address_to_resource(mpscintr, 0, &r[1]);
	of_node_put(mpscintr);
	if (err)
		return err;

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

	pdev = platform_device_alloc(MPSC_SHARED_NAME, 0);
	if (!pdev)
		return -ENOMEM;

	err = platform_device_add_resources(pdev, r, 2);
	if (err)
		goto error;

	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	if (err)
		goto error;

	err = platform_device_add(pdev);
	if (err)
		goto error;

	return 0;

error:
	platform_device_put(pdev);
	return err;
}


static int __init mv64x60_mpsc_device_setup(struct device_node *np, int id)
{
	struct resource r[5];
	struct mpsc_pdata pdata;
	struct platform_device *pdev;
	const unsigned int *prop;
	const phandle *ph;
	struct device_node *sdma, *brg;
	int err;
	int port_number;

	/* only register the shared platform device the first time through */
	if (id == 0 && (err = mv64x60_mpsc_register_shared_pdev(np)))
		return err;

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

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

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

	ph = of_get_property(np, "sdma", NULL);
	sdma = of_find_node_by_phandle(*ph);
	if (!sdma)
		return -ENODEV;

	of_irq_to_resource(sdma, 0, &r[3]);
	err = of_address_to_resource(sdma, 0, &r[1]);
	of_node_put(sdma);
	if (err)
		return err;

	ph = of_get_property(np, "brg", NULL);
	brg = of_find_node_by_phandle(*ph);
	if (!brg)
		return -ENODEV;

	err = of_address_to_resource(brg, 0, &r[2]);
	of_node_put(brg);
	if (err)
		return err;

	prop = of_get_property(np, "cell-index", NULL);
	if (!prop)
		return -ENODEV;
	port_number = *(int *)prop;

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

	pdata.cache_mgmt = 1; /* All current revs need this set */

	pdata.max_idle = 40; /* default */
	prop = of_get_property(np, "max_idle", NULL);
	if (prop)
		pdata.max_idle = *prop;

	prop = of_get_property(brg, "current-speed", NULL);
	if (prop)
		pdata.default_baud = *prop;

	/* Default is 8 bits, no parity, no flow control */
	pdata.default_bits = 8;
	pdata.default_parity = 'n';
	pdata.default_flow = 'n';

	prop = of_get_property(np, "chr_1", NULL);
	if (prop)
		pdata.chr_1_val = *prop;

	prop = of_get_property(np, "chr_2", NULL);
	if (prop)
		pdata.chr_2_val = *prop;

	prop = of_get_property(np, "chr_10", NULL);
	if (prop)
		pdata.chr_10_val = *prop;

	prop = of_get_property(np, "mpcr", NULL);
	if (prop)
		pdata.mpcr_val = *prop;

	prop = of_get_property(brg, "bcr", NULL);
	if (prop)
		pdata.bcr_val = *prop;

	pdata.brg_can_tune = 1; /* All current revs need this set */

	prop = of_get_property(brg, "clock-src", NULL);
	if (prop)
		pdata.brg_clk_src = *prop;

	prop = of_get_property(brg, "clock-frequency", NULL);
	if (prop)
		pdata.brg_clk_freq = *prop;

	pdev = platform_device_alloc(MPSC_CTLR_NAME, port_number);
	if (!pdev)
		return -ENOMEM;

	err = platform_device_add_resources(pdev, r, 5);
	if (err)
		goto error;

	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	if (err)
		goto error;

	err = platform_device_add(pdev);
	if (err)
		goto error;

	return 0;

error:
	platform_device_put(pdev);
	return err;
}

/*
 * Create mv64x60_eth platform devices
 */
static struct platform_device * __init mv64x60_eth_register_shared_pdev(
						struct device_node *np, int id)
{
	struct platform_device *pdev;
	struct resource r[1];
	int err;

	err = of_address_to_resource(np, 0, &r[0]);
	if (err)
		return ERR_PTR(err);

	pdev = platform_device_register_simple(MV643XX_ETH_SHARED_NAME, id,
					       r, 1);
	return pdev;
}

static int __init mv64x60_eth_device_setup(struct device_node *np, int id,
					   struct platform_device *shared_pdev)
{
	struct resource r[1];
	struct mv643xx_eth_platform_data pdata;
	struct platform_device *pdev;
	struct device_node *phy;
	const u8 *mac_addr;
	const int *prop;
	const phandle *ph;
	int err;

	memset(r, 0, sizeof(r));
	of_irq_to_resource(np, 0, &r[0]);

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

	prop = of_get_property(np, "reg", NULL);
	if (!prop)
		return -ENODEV;
	pdata.port_number = *prop;

	mac_addr = of_get_mac_address(np);
	if (mac_addr)
		memcpy(pdata.mac_addr, mac_addr, 6);

	prop = of_get_property(np, "speed", NULL);
	if (prop)
		pdata.speed = *prop;

	prop = of_get_property(np, "tx_queue_size", NULL);
	if (prop)
		pdata.tx_queue_size = *prop;

	prop = of_get_property(np, "rx_queue_size", NULL);
	if (prop)
		pdata.rx_queue_size = *prop;

	prop = of_get_property(np, "tx_sram_addr", NULL);
	if (prop)
		pdata.tx_sram_addr = *prop;

	prop = of_get_property(np, "tx_sram_size", NULL);
	if (prop)
		pdata.tx_sram_size = *prop;

	prop = of_get_property(np, "rx_sram_addr", NULL);
	if (prop)
		pdata.rx_sram_addr = *prop;

	prop = of_get_property(np, "rx_sram_size", NULL);
	if (prop)
		pdata.rx_sram_size = *prop;

	ph = of_get_property(np, "phy", NULL);
	if (!ph)
		return -ENODEV;

	phy = of_find_node_by_phandle(*ph);
	if (phy == NULL)
		return -ENODEV;

	prop = of_get_property(phy, "reg", NULL);
	if (prop) {
		pdata.force_phy_addr = 1;
		pdata.phy_addr = *prop;
	}

	of_node_put(phy);

	pdev = platform_device_alloc(MV643XX_ETH_NAME, id);
	if (!pdev)
		return -ENOMEM;

	err = platform_device_add_resources(pdev, r, 1);
	if (err)
		goto error;

	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	if (err)
		goto error;

	err = platform_device_add(pdev);
	if (err)
		goto error;

	return 0;

error:
	platform_device_put(pdev);
	return err;
}

/*
 * Create mv64x60_i2c platform devices
 */
static int __init mv64x60_i2c_device_setup(struct device_node *np, int id)
{
	struct resource r[2];
	struct platform_device *pdev;
	struct mv64xxx_i2c_pdata pdata;
	const unsigned int *prop;
	int err;

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

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

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

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

	pdata.freq_m = 8;	/* default */
	prop = of_get_property(np, "freq_m", NULL);
	if (!prop)
		return -ENODEV;
	pdata.freq_m = *prop;

	pdata.freq_m = 3;	/* default */
	prop = of_get_property(np, "freq_n", NULL);
	if (!prop)
		return -ENODEV;
	pdata.freq_n = *prop;

	pdata.timeout = 1000;				/* default: 1 second */

	pdev = platform_device_alloc(MV64XXX_I2C_CTLR_NAME, id);
	if (!pdev)
		return -ENOMEM;

	err = platform_device_add_resources(pdev, r, 2);
	if (err)
		goto error;

	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	if (err)
		goto error;

	err = platform_device_add(pdev);
	if (err)
		goto error;

	return 0;

error:
	platform_device_put(pdev);
	return err;
}

/*
 * Create mv64x60_wdt platform devices
 */
static int __init mv64x60_wdt_device_setup(struct device_node *np, int id)
{
	struct resource r;
	struct platform_device *pdev;
	struct mv64x60_wdt_pdata pdata;
	const unsigned int *prop;
	int err;

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

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

	pdata.timeout = 10;			/* Default: 10 seconds */

	np = of_get_parent(np);
	if (!np)
		return -ENODEV;

	prop = of_get_property(np, "clock-frequency", NULL);
	of_node_put(np);
	if (!prop)
		return -ENODEV;
	pdata.bus_clk = *prop / 1000000; /* wdt driver wants freq in MHz */

	pdev = platform_device_alloc(MV64x60_WDT_NAME, id);
	if (!pdev)
		return -ENOMEM;

	err = platform_device_add_resources(pdev, &r, 1);
	if (err)
		goto error;

	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	if (err)
		goto error;

	err = platform_device_add(pdev);
	if (err)
		goto error;

	return 0;

error:
	platform_device_put(pdev);
	return err;
}

static int __init mv64x60_device_setup(void)
{
	struct device_node *np, *np2;
	struct platform_device *pdev;
	int id, id2;
	int err;

	id = 0;
	for_each_compatible_node(np, "serial", "marvell,mv64360-mpsc")
		if ((err = mv64x60_mpsc_device_setup(np, id++)))
			goto error;

	id = 0;
	id2 = 0;
	for_each_compatible_node(np, NULL, "marvell,mv64360-eth-group") {
		pdev = mv64x60_eth_register_shared_pdev(np, id++);
		if (IS_ERR(pdev)) {
			err = PTR_ERR(pdev);
			goto error;
		}
		for_each_child_of_node(np, np2) {
			if (!of_device_is_compatible(np2,
					"marvell,mv64360-eth"))
				continue;
			err = mv64x60_eth_device_setup(np2, id2++, pdev);
			if (err) {
				of_node_put(np2);
				goto error;
			}
		}
	}

	id = 0;
	for_each_compatible_node(np, "i2c", "marvell,mv64360-i2c")
		if ((err = mv64x60_i2c_device_setup(np, id++)))
			goto error;

	/* support up to one watchdog timer */
	np = of_find_compatible_node(np, NULL, "marvell,mv64360-wdt");
	if (np) {
		if ((err = mv64x60_wdt_device_setup(np, id)))
			goto error;
		of_node_put(np);
	}

	return 0;

error:
	of_node_put(np);
	return err;
}
arch_initcall(mv64x60_device_setup);

static int __init mv64x60_add_mpsc_console(void)
{
	struct device_node *np = NULL;
	const char *prop;

	prop = of_get_property(of_chosen, "linux,stdout-path", NULL);
	if (prop == NULL)
		goto not_mpsc;

	np = of_find_node_by_path(prop);
	if (!np)
		goto not_mpsc;

	if (!of_device_is_compatible(np, "marvell,mv64360-mpsc"))
		goto not_mpsc;

	prop = of_get_property(np, "cell-index", NULL);
	if (!prop)
		goto not_mpsc;

	add_preferred_console("ttyMM", *(int *)prop, NULL);

not_mpsc:
	return 0;
}
console_initcall(mv64x60_add_mpsc_console);
Commit	Line	Data
52d3aff9 DF	1	/*
	2	* Platform device setup for Marvell mv64360/mv64460 host bridges (Discovery)
	3	*
	4	* Author: Dale Farnsworth <dale@farnsworth.org>
	5	*
	6	* 2007 (c) MontaVista, Software, Inc. This file is licensed under
	7	* the terms of the GNU General Public License version 2. This program
	8	* is licensed "as is" without any warranty of any kind, whether express
	9	* or implied.
	10	*/
	11
	12	#include <linux/stddef.h>
	13	#include <linux/kernel.h>
	14	#include <linux/init.h>
542c98c0	15	#include <linux/console.h>
52d3aff9 DF	16	#include <linux/mv643xx.h>
	17	#include <linux/platform_device.h>
	18
	19	#include <asm/prom.h>
	20
	21	/*
	22	* These functions provide the necessary setup for the mv64x60 drivers.
	23	* These drivers are unusual in that they work on both the MIPS and PowerPC
	24	* architectures. Because of that, the drivers do not support the normal
	25	* PowerPC of_platform_bus_type. They support platform_bus_type instead.
	26	*/
	27
	28	/*
	29	* Create MPSC platform devices
	30	*/
	31	static int __init mv64x60_mpsc_register_shared_pdev(struct device_node *np)
	32	{
	33	struct platform_device *pdev;
	34	struct resource r[2];
	35	struct mpsc_shared_pdata pdata;
	36	const phandle *ph;
	37	struct device_node mpscrouting, mpscintr;
	38	int err;
	39
	40	ph = of_get_property(np, "mpscrouting", NULL);
	41	mpscrouting = of_find_node_by_phandle(*ph);
	42	if (!mpscrouting)
	43	return -ENODEV;
	44
	45	err = of_address_to_resource(mpscrouting, 0, &r[0]);
	46	of_node_put(mpscrouting);
	47	if (err)
	48	return err;
	49
	50	ph = of_get_property(np, "mpscintr", NULL);
	51	mpscintr = of_find_node_by_phandle(*ph);
	52	if (!mpscintr)
	53	return -ENODEV;
	54
	55	err = of_address_to_resource(mpscintr, 0, &r[1]);
	56	of_node_put(mpscintr);
	57	if (err)
	58	return err;
	59
	60	memset(&pdata, 0, sizeof(pdata));
	61
	62	pdev = platform_device_alloc(MPSC_SHARED_NAME, 0);
	63	if (!pdev)
	64	return -ENOMEM;
	65
	66	err = platform_device_add_resources(pdev, r, 2);
	67	if (err)
	68	goto error;
	69
	70	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	71	if (err)
	72	goto error;
	73
	74	err = platform_device_add(pdev);
	75	if (err)
	76	goto error;
	77
	78	return 0;
	79
80	error:
81	platform_device_put(pdev);
82	return err;
83	}
84
85
86	static int __init mv64x60_mpsc_device_setup(struct device_node *np, int id)
87	{
88	struct resource r[5];
89	struct mpsc_pdata pdata;
90	struct platform_device *pdev;
91	const unsigned int *prop;
92	const phandle *ph;
93	struct device_node sdma, brg;
94	int err;
95	int port_number;
96
97	/* only register the shared platform device the first time through */
98	if (id == 0 && (err = mv64x60_mpsc_register_shared_pdev(np)))
99	return err;
100
101	memset(r, 0, sizeof(r));
102
103	err = of_address_to_resource(np, 0, &r[0]);
104	if (err)
105	return err;
106
107	of_irq_to_resource(np, 0, &r[4]);
108
109	ph = of_get_property(np, "sdma", NULL);
110	sdma = of_find_node_by_phandle(*ph);
111	if (!sdma)
112	return -ENODEV;
113
114	of_irq_to_resource(sdma, 0, &r[3]);
115	err = of_address_to_resource(sdma, 0, &r[1]);
116	of_node_put(sdma);
117	if (err)
118	return err;
119
120	ph = of_get_property(np, "brg", NULL);
121	brg = of_find_node_by_phandle(*ph);
122	if (!brg)
123	return -ENODEV;
124
125	err = of_address_to_resource(brg, 0, &r[2]);
126	of_node_put(brg);
127	if (err)
128	return err;
129
1791f91b	130	prop = of_get_property(np, "cell-index", NULL);
52d3aff9 DF	131	if (!prop)
	132	return -ENODEV;
	133	port_number = (int )prop;
	134
	135	memset(&pdata, 0, sizeof(pdata));
	136
	137	pdata.cache_mgmt = 1; /* All current revs need this set */
	138
1791f91b	139	pdata.max_idle = 40; /* default */
52d3aff9 DF	140	prop = of_get_property(np, "max_idle", NULL);
	141	if (prop)
	142	pdata.max_idle = *prop;
	143
	144	prop = of_get_property(brg, "current-speed", NULL);
	145	if (prop)
	146	pdata.default_baud = *prop;
	147
	148	/* Default is 8 bits, no parity, no flow control */
	149	pdata.default_bits = 8;
	150	pdata.default_parity = 'n';
	151	pdata.default_flow = 'n';
	152
	153	prop = of_get_property(np, "chr_1", NULL);
	154	if (prop)
	155	pdata.chr_1_val = *prop;
	156
	157	prop = of_get_property(np, "chr_2", NULL);
	158	if (prop)
	159	pdata.chr_2_val = *prop;
	160
	161	prop = of_get_property(np, "chr_10", NULL);
	162	if (prop)
	163	pdata.chr_10_val = *prop;
	164
	165	prop = of_get_property(np, "mpcr", NULL);
	166	if (prop)
	167	pdata.mpcr_val = *prop;
	168
	169	prop = of_get_property(brg, "bcr", NULL);
	170	if (prop)
	171	pdata.bcr_val = *prop;
	172
	173	pdata.brg_can_tune = 1; /* All current revs need this set */
	174
	175	prop = of_get_property(brg, "clock-src", NULL);
	176	if (prop)
	177	pdata.brg_clk_src = *prop;
	178
	179	prop = of_get_property(brg, "clock-frequency", NULL);
	180	if (prop)
	181	pdata.brg_clk_freq = *prop;
	182
	183	pdev = platform_device_alloc(MPSC_CTLR_NAME, port_number);
	184	if (!pdev)
	185	return -ENOMEM;
	186
	187	err = platform_device_add_resources(pdev, r, 5);
	188	if (err)
	189	goto error;
	190
	191	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	192	if (err)
	193	goto error;
	194
	195	err = platform_device_add(pdev);
	196	if (err)
	197	goto error;
	198
	199	return 0;
	200
	201	error:
	202	platform_device_put(pdev);
	203	return err;
204	}
205
649c8e02 DF	206	/*
	207	* Create mv64x60_eth platform devices
	208	*/
a0916bd6 DF	209	static struct platform_device * __init mv64x60_eth_register_shared_pdev(
a0916bd6 DF	210	struct device_node *np, int id)
649c8e02 DF	211	{
	212	struct platform_device *pdev;
	213	struct resource r[1];
	214	int err;
	215
649c8e02	216	err = of_address_to_resource(np, 0, &r[0]);
649c8e02	217	if (err)
a0916bd6	218	return ERR_PTR(err);
649c8e02	219
a0916bd6	220	pdev = platform_device_register_simple(MV643XX_ETH_SHARED_NAME, id,
649c8e02	221	r, 1);
a0916bd6	222	return pdev;
649c8e02 DF	223	}
649c8e02 DF	224
a0916bd6 DF	225	static int __init mv64x60_eth_device_setup(struct device_node *np, int id,
a0916bd6 DF	226	struct platform_device *shared_pdev)
649c8e02 DF	227	{
	228	struct resource r[1];
	229	struct mv643xx_eth_platform_data pdata;
	230	struct platform_device *pdev;
	231	struct device_node *phy;
	232	const u8 *mac_addr;
	233	const int *prop;
	234	const phandle *ph;
	235	int err;
	236
649c8e02 DF	237	memset(r, 0, sizeof(r));
	238	of_irq_to_resource(np, 0, &r[0]);
	239
	240	memset(&pdata, 0, sizeof(pdata));
	241
a0916bd6	242	prop = of_get_property(np, "reg", NULL);
649c8e02 DF	243	if (!prop)
	244	return -ENODEV;
	245	pdata.port_number = *prop;
	246
	247	mac_addr = of_get_mac_address(np);
	248	if (mac_addr)
	249	memcpy(pdata.mac_addr, mac_addr, 6);
	250
	251	prop = of_get_property(np, "speed", NULL);
	252	if (prop)
	253	pdata.speed = *prop;
	254
	255	prop = of_get_property(np, "tx_queue_size", NULL);
	256	if (prop)
	257	pdata.tx_queue_size = *prop;
	258
	259	prop = of_get_property(np, "rx_queue_size", NULL);
	260	if (prop)
	261	pdata.rx_queue_size = *prop;
	262
	263	prop = of_get_property(np, "tx_sram_addr", NULL);
	264	if (prop)
	265	pdata.tx_sram_addr = *prop;
	266
	267	prop = of_get_property(np, "tx_sram_size", NULL);
	268	if (prop)
	269	pdata.tx_sram_size = *prop;
	270
	271	prop = of_get_property(np, "rx_sram_addr", NULL);
	272	if (prop)
	273	pdata.rx_sram_addr = *prop;
	274
	275	prop = of_get_property(np, "rx_sram_size", NULL);
	276	if (prop)
	277	pdata.rx_sram_size = *prop;
	278
	279	ph = of_get_property(np, "phy", NULL);
	280	if (!ph)
	281	return -ENODEV;
	282
	283	phy = of_find_node_by_phandle(*ph);
	284	if (phy == NULL)
	285	return -ENODEV;
	286
	287	prop = of_get_property(phy, "reg", NULL);
	288	if (prop) {
	289	pdata.force_phy_addr = 1;
	290	pdata.phy_addr = *prop;
	291	}
	292
	293	of_node_put(phy);
	294
a0916bd6	295	pdev = platform_device_alloc(MV643XX_ETH_NAME, id);
649c8e02 DF	296	if (!pdev)
	297	return -ENOMEM;
	298
	299	err = platform_device_add_resources(pdev, r, 1);
	300	if (err)
	301	goto error;
	302
	303	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	304	if (err)
	305	goto error;
	306
	307	err = platform_device_add(pdev);
	308	if (err)
	309	goto error;
	310
	311	return 0;
	312
	313	error:
	314	platform_device_put(pdev);
	315	return err;
	316	}
	317
01f0e78e DF	318	/*
	319	* Create mv64x60_i2c platform devices
	320	*/
	321	static int __init mv64x60_i2c_device_setup(struct device_node *np, int id)
	322	{
	323	struct resource r[2];
	324	struct platform_device *pdev;
	325	struct mv64xxx_i2c_pdata pdata;
	326	const unsigned int *prop;
	327	int err;
	328
	329	memset(r, 0, sizeof(r));
	330
	331	err = of_address_to_resource(np, 0, &r[0]);
	332	if (err)
	333	return err;
	334
	335	of_irq_to_resource(np, 0, &r[1]);
	336
	337	memset(&pdata, 0, sizeof(pdata));
	338
1791f91b	339	pdata.freq_m = 8; /* default */
01f0e78e DF	340	prop = of_get_property(np, "freq_m", NULL);
	341	if (!prop)
	342	return -ENODEV;
	343	pdata.freq_m = *prop;
	344
1791f91b	345	pdata.freq_m = 3; /* default */
01f0e78e DF	346	prop = of_get_property(np, "freq_n", NULL);
	347	if (!prop)
	348	return -ENODEV;
	349	pdata.freq_n = *prop;
	350
1791f91b	351	pdata.timeout = 1000; /* default: 1 second */
01f0e78e	352
01f0e78e DF	353	pdev = platform_device_alloc(MV64XXX_I2C_CTLR_NAME, id);
	354	if (!pdev)
	355	return -ENOMEM;
	356
	357	err = platform_device_add_resources(pdev, r, 2);
	358	if (err)
	359	goto error;
	360
	361	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	362	if (err)
	363	goto error;
	364
	365	err = platform_device_add(pdev);
	366	if (err)
	367	goto error;
	368
	369	return 0;
	370
	371	error:
	372	platform_device_put(pdev);
	373	return err;
	374	}
	375
7e07a159 DF	376	/*
	377	* Create mv64x60_wdt platform devices
	378	*/
	379	static int __init mv64x60_wdt_device_setup(struct device_node *np, int id)
	380	{
	381	struct resource r;
	382	struct platform_device *pdev;
	383	struct mv64x60_wdt_pdata pdata;
	384	const unsigned int *prop;
	385	int err;
	386
	387	err = of_address_to_resource(np, 0, &r);
	388	if (err)
	389	return err;
	390
	391	memset(&pdata, 0, sizeof(pdata));
	392
1791f91b	393	pdata.timeout = 10; /* Default: 10 seconds */
7e07a159 DF	394
	395	np = of_get_parent(np);
	396	if (!np)
	397	return -ENODEV;
	398
	399	prop = of_get_property(np, "clock-frequency", NULL);
	400	of_node_put(np);
	401	if (!prop)
	402	return -ENODEV;
	403	pdata.bus_clk = prop / 1000000; / wdt driver wants freq in MHz */
	404
	405	pdev = platform_device_alloc(MV64x60_WDT_NAME, id);
	406	if (!pdev)
	407	return -ENOMEM;
	408
	409	err = platform_device_add_resources(pdev, &r, 1);
	410	if (err)
	411	goto error;
	412
	413	err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
	414	if (err)
	415	goto error;
	416
	417	err = platform_device_add(pdev);
	418	if (err)
	419	goto error;
	420
	421	return 0;
	422
	423	error:
	424	platform_device_put(pdev);
	425	return err;
	426	}
	427
52d3aff9 DF	428	static int __init mv64x60_device_setup(void)
52d3aff9 DF	429	{
a0916bd6 DF	430	struct device_node np, np2;
	431	struct platform_device *pdev;
	432	int id, id2;
52d3aff9 DF	433	int err;
52d3aff9 DF	434
26cb7d8b	435	id = 0;
a1810b44	436	for_each_compatible_node(np, "serial", "marvell,mv64360-mpsc")
26cb7d8b	437	if ((err = mv64x60_mpsc_device_setup(np, id++)))
52d3aff9 DF	438	goto error;
52d3aff9 DF	439
26cb7d8b	440	id = 0;
a0916bd6 DF	441	id2 = 0;
	442	for_each_compatible_node(np, NULL, "marvell,mv64360-eth-group") {
	443	pdev = mv64x60_eth_register_shared_pdev(np, id++);
	444	if (IS_ERR(pdev)) {
	445	err = PTR_ERR(pdev);
649c8e02	446	goto error;
a0916bd6 DF	447	}
	448	for_each_child_of_node(np, np2) {
	449	if (!of_device_is_compatible(np2,
	450	"marvell,mv64360-eth"))
	451	continue;
	452	err = mv64x60_eth_device_setup(np2, id2++, pdev);
	453	if (err) {
	454	of_node_put(np2);
	455	goto error;
	456	}
	457	}
	458	}
649c8e02	459
26cb7d8b	460	id = 0;
a1810b44	461	for_each_compatible_node(np, "i2c", "marvell,mv64360-i2c")
26cb7d8b	462	if ((err = mv64x60_i2c_device_setup(np, id++)))
01f0e78e DF	463	goto error;
01f0e78e DF	464
7e07a159	465	/* support up to one watchdog timer */
a1810b44	466	np = of_find_compatible_node(np, NULL, "marvell,mv64360-wdt");
7e07a159 DF	467	if (np) {
	468	if ((err = mv64x60_wdt_device_setup(np, id)))
	469	goto error;
	470	of_node_put(np);
	471	}
	472
52d3aff9 DF	473	return 0;
	474
	475	error:
	476	of_node_put(np);
	477	return err;
	478	}
	479	arch_initcall(mv64x60_device_setup);
542c98c0 MG	480
	481	static int __init mv64x60_add_mpsc_console(void)
	482	{
	483	struct device_node *np = NULL;
	484	const char *prop;
	485
	486	prop = of_get_property(of_chosen, "linux,stdout-path", NULL);
	487	if (prop == NULL)
	488	goto not_mpsc;
	489
	490	np = of_find_node_by_path(prop);
	491	if (!np)
	492	goto not_mpsc;
	493
a1810b44	494	if (!of_device_is_compatible(np, "marvell,mv64360-mpsc"))
542c98c0 MG	495	goto not_mpsc;
542c98c0 MG	496
1791f91b	497	prop = of_get_property(np, "cell-index", NULL);
542c98c0 MG	498	if (!prop)
	499	goto not_mpsc;
	500
	501	add_preferred_console("ttyMM", (int )prop, NULL);
	502
	503	not_mpsc:
	504	return 0;
	505	}
	506	console_initcall(mv64x60_add_mpsc_console);