mpc85xx_mds.c 8.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 * Copyright (C) Freescale Semicondutor, Inc. 2006-2007. All rights reserved.
 *
 * Author: Andy Fleming <afleming@freescale.com>
 *
 * Based on 83xx/mpc8360e_pb.c by:
 *	   Li Yang <LeoLi@freescale.com>
 *	   Yin Olivia <Hong-hua.Yin@freescale.com>
 *
 * Description:
11
 * MPC85xx MDS board specific routines.
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
 *
 * 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/reboot.h>
#include <linux/pci.h>
#include <linux/kdev_t.h>
#include <linux/major.h>
#include <linux/console.h>
#include <linux/delay.h>
#include <linux/seq_file.h>
#include <linux/initrd.h>
#include <linux/module.h>
#include <linux/fsl_devices.h>
33 34
#include <linux/of_platform.h>
#include <linux/of_device.h>
35
#include <linux/phy.h>
36
#include <linux/lmb.h>
37 38 39 40 41 42 43 44 45 46 47 48

#include <asm/system.h>
#include <asm/atomic.h>
#include <asm/time.h>
#include <asm/io.h>
#include <asm/machdep.h>
#include <asm/pci-bridge.h>
#include <asm/irq.h>
#include <mm/mmu_decl.h>
#include <asm/prom.h>
#include <asm/udbg.h>
#include <sysdev/fsl_soc.h>
49
#include <sysdev/fsl_pci.h>
50
#include <sysdev/simple_gpio.h>
51 52 53
#include <asm/qe.h>
#include <asm/qe_ic.h>
#include <asm/mpic.h>
54
#include <asm/swiotlb.h>
55 56 57 58 59 60 61 62

#undef DEBUG
#ifdef DEBUG
#define DBG(fmt...) udbg_printf(fmt)
#else
#define DBG(fmt...)
#endif

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
#define MV88E1111_SCR	0x10
#define MV88E1111_SCR_125CLK	0x0010
static int mpc8568_fixup_125_clock(struct phy_device *phydev)
{
	int scr;
	int err;

	/* Workaround for the 125 CLK Toggle */
	scr = phy_read(phydev, MV88E1111_SCR);

	if (scr < 0)
		return scr;

	err = phy_write(phydev, MV88E1111_SCR, scr & ~(MV88E1111_SCR_125CLK));

	if (err)
		return err;

	err = phy_write(phydev, MII_BMCR, BMCR_RESET);

	if (err)
		return err;

	scr = phy_read(phydev, MV88E1111_SCR);

	if (scr < 0)
		return err;

	err = phy_write(phydev, MV88E1111_SCR, scr | 0x0008);

	return err;
}

static int mpc8568_mds_phy_fixups(struct phy_device *phydev)
{
	int temp;
	int err;

	/* Errata */
	err = phy_write(phydev,29, 0x0006);

	if (err)
		return err;

	temp = phy_read(phydev, 30);

	if (temp < 0)
		return temp;

	temp = (temp & (~0x8000)) | 0x4000;
	err = phy_write(phydev,30, temp);

	if (err)
		return err;

	err = phy_write(phydev,29, 0x000a);

	if (err)
		return err;

	temp = phy_read(phydev, 30);

	if (temp < 0)
		return temp;

	temp = phy_read(phydev, 30);

	if (temp < 0)
		return temp;

	temp &= ~0x0020;

	err = phy_write(phydev,30,temp);

	if (err)
		return err;

	/* Disable automatic MDI/MDIX selection */
	temp = phy_read(phydev, 16);

	if (temp < 0)
		return temp;

	temp &= ~0x0060;
	err = phy_write(phydev,16,temp);

	return err;
}

152 153 154 155 156
/* ************************************************************************
 *
 * Setup the architecture
 *
 */
157
static void __init mpc85xx_mds_setup_arch(void)
158 159
{
	struct device_node *np;
160
	static u8 __iomem *bcsr_regs = NULL;
161 162 163 164
#ifdef CONFIG_PCI
	struct pci_controller *hose;
#endif
	dma_addr_t max = 0xffffffff;
165 166

	if (ppc_md.progress)
167
		ppc_md.progress("mpc85xx_mds_setup_arch()", 0);
168 169 170 171 172 173 174 175 176 177 178 179

	/* Map BCSR area */
	np = of_find_node_by_name(NULL, "bcsr");
	if (np != NULL) {
		struct resource res;

		of_address_to_resource(np, 0, &res);
		bcsr_regs = ioremap(res.start, res.end - res.start +1);
		of_node_put(np);
	}

#ifdef CONFIG_PCI
180 181 182 183 184 185 186 187 188
	for_each_node_by_type(np, "pci") {
		if (of_device_is_compatible(np, "fsl,mpc8540-pci") ||
		    of_device_is_compatible(np, "fsl,mpc8548-pcie")) {
			struct resource rsrc;
			of_address_to_resource(np, 0, &rsrc);
			if ((rsrc.start & 0xfffff) == 0x8000)
				fsl_add_bridge(np, 1);
			else
				fsl_add_bridge(np, 0);
189 190 191 192

			hose = pci_find_hose_for_OF_device(np);
			max = min(max, hose->dma_window_base_cur +
					hose->dma_window_size);
193 194
		}
	}
195 196 197
#endif

#ifdef CONFIG_QUICC_ENGINE
198 199 200 201 202
	np = of_find_compatible_node(NULL, NULL, "fsl,qe");
	if (!np) {
		np = of_find_node_by_name(NULL, "qe");
		if (!np)
			return;
203 204
	}

205 206 207 208 209 210
	qe_reset();
	of_node_put(np);

	np = of_find_node_by_name(NULL, "par_io");
	if (np) {
		struct device_node *ucc;
211 212 213 214

		par_io_init(np);
		of_node_put(np);

215
		for_each_node_by_name(ucc, "ucc")
216 217 218 219
			par_io_of_config(ucc);
	}

	if (bcsr_regs) {
220
		if (machine_is(mpc8568_mds)) {
221 222 223 224 225
#define BCSR_UCC1_GETH_EN	(0x1 << 7)
#define BCSR_UCC2_GETH_EN	(0x1 << 7)
#define BCSR_UCC1_MODE_MSK	(0x3 << 4)
#define BCSR_UCC2_MODE_MSK	(0x3 << 0)

226 227 228
			/* Turn off UCC1 & UCC2 */
			clrbits8(&bcsr_regs[8], BCSR_UCC1_GETH_EN);
			clrbits8(&bcsr_regs[9], BCSR_UCC2_GETH_EN);
229

230 231 232
			/* Mode is RGMII, all bits clear */
			clrbits8(&bcsr_regs[11], BCSR_UCC1_MODE_MSK |
						 BCSR_UCC2_MODE_MSK);
233

234 235 236
			/* Turn UCC1 & UCC2 on */
			setbits8(&bcsr_regs[8], BCSR_UCC1_GETH_EN);
			setbits8(&bcsr_regs[9], BCSR_UCC2_GETH_EN);
237 238 239 240 241 242 243 244 245 246 247 248 249
		} else if (machine_is(mpc8569_mds)) {
#define BCSR7_UCC12_GETHnRST	(0x1 << 2)
#define BCSR8_UEM_MARVELL_RST	(0x1 << 1)
			/*
			 * U-Boot mangles interrupt polarity for Marvell PHYs,
			 * so reset built-in and UEM Marvell PHYs, this puts
			 * the PHYs into their normal state.
			 */
			clrbits8(&bcsr_regs[7], BCSR7_UCC12_GETHnRST);
			setbits8(&bcsr_regs[8], BCSR8_UEM_MARVELL_RST);

			setbits8(&bcsr_regs[7], BCSR7_UCC12_GETHnRST);
			clrbits8(&bcsr_regs[8], BCSR8_UEM_MARVELL_RST);
250
		}
251 252 253
		iounmap(bcsr_regs);
	}
#endif	/* CONFIG_QUICC_ENGINE */
254 255 256 257 258 259 260

#ifdef CONFIG_SWIOTLB
	if (lmb_end_of_DRAM() > max) {
		ppc_swiotlb_enable = 1;
		set_pci_dma_ops(&swiotlb_pci_dma_ops);
	}
#endif
261 262
}

263 264 265

static int __init board_fixups(void)
{
266
	char phy_id[20];
267 268 269 270 271 272 273 274 275
	char *compstrs[2] = {"fsl,gianfar-mdio", "fsl,ucc-mdio"};
	struct device_node *mdio;
	struct resource res;
	int i;

	for (i = 0; i < ARRAY_SIZE(compstrs); i++) {
		mdio = of_find_compatible_node(NULL, NULL, compstrs[i]);

		of_address_to_resource(mdio, 0, &res);
276
		snprintf(phy_id, sizeof(phy_id), "%llx:%02x",
277
			(unsigned long long)res.start, 1);
278 279 280 281 282

		phy_register_fixup_for_id(phy_id, mpc8568_fixup_125_clock);
		phy_register_fixup_for_id(phy_id, mpc8568_mds_phy_fixups);

		/* Register a workaround for errata */
283
		snprintf(phy_id, sizeof(phy_id), "%llx:%02x",
284
			(unsigned long long)res.start, 7);
285 286 287 288 289 290 291
		phy_register_fixup_for_id(phy_id, mpc8568_mds_phy_fixups);

		of_node_put(mdio);
	}

	return 0;
}
292
machine_arch_initcall(mpc8568_mds, board_fixups);
293
machine_arch_initcall(mpc8569_mds, board_fixups);
294

295
static struct of_device_id mpc85xx_ids[] = {
296 297
	{ .type = "soc", },
	{ .compatible = "soc", },
298
	{ .compatible = "simple-bus", },
299
	{ .type = "qe", },
300
	{ .compatible = "fsl,qe", },
301
	{ .compatible = "gianfar", },
302
	{ .compatible = "fsl,rapidio-delta", },
303 304 305
	{},
};

306
static int __init mpc85xx_publish_devices(void)
307
{
308 309 310
	if (machine_is(mpc8569_mds))
		simple_gpiochip_init("fsl,mpc8569mds-bcsr-gpio");

311
	/* Publish the QE devices */
312
	of_platform_bus_probe(NULL, mpc85xx_ids, NULL);
313 314 315

	return 0;
}
316
machine_device_initcall(mpc8568_mds, mpc85xx_publish_devices);
317
machine_device_initcall(mpc8569_mds, mpc85xx_publish_devices);
318

319 320 321
machine_arch_initcall(mpc8568_mds, swiotlb_setup_bus_notifier);
machine_arch_initcall(mpc8569_mds, swiotlb_setup_bus_notifier);

322
static void __init mpc85xx_mds_pic_init(void)
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
{
	struct mpic *mpic;
	struct resource r;
	struct device_node *np = NULL;

	np = of_find_node_by_type(NULL, "open-pic");
	if (!np)
		return;

	if (of_address_to_resource(np, 0, &r)) {
		printk(KERN_ERR "Failed to map mpic register space\n");
		of_node_put(np);
		return;
	}

	mpic = mpic_alloc(np, r.start,
			MPIC_PRIMARY | MPIC_WANTS_RESET | MPIC_BIG_ENDIAN,
340
			0, 256, " OpenPIC  ");
341 342 343 344 345 346
	BUG_ON(mpic == NULL);
	of_node_put(np);

	mpic_init(mpic);

#ifdef CONFIG_QUICC_ENGINE
347 348 349 350 351 352
	np = of_find_compatible_node(NULL, NULL, "fsl,qe-ic");
	if (!np) {
		np = of_find_node_by_type(NULL, "qeic");
		if (!np)
			return;
	}
353
	qe_ic_init(np, 0, qe_ic_cascade_muxed_mpic, NULL);
354 355 356 357
	of_node_put(np);
#endif				/* CONFIG_QUICC_ENGINE */
}

358
static int __init mpc85xx_mds_probe(void)
359
{
360
        unsigned long root = of_get_flat_dt_root();
361

362
        return of_flat_dt_is_compatible(root, "MPC85xxMDS");
363 364
}

365 366
define_machine(mpc8568_mds) {
	.name		= "MPC8568 MDS",
367 368 369
	.probe		= mpc85xx_mds_probe,
	.setup_arch	= mpc85xx_mds_setup_arch,
	.init_IRQ	= mpc85xx_mds_pic_init,
370
	.get_irq	= mpic_get_irq,
371
	.restart	= fsl_rstcr_restart,
372 373
	.calibrate_decr	= generic_calibrate_decr,
	.progress	= udbg_progress,
374
#ifdef CONFIG_PCI
375
	.pcibios_fixup_bus	= fsl_pcibios_fixup_bus,
376
#endif
377
};
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398

static int __init mpc8569_mds_probe(void)
{
	unsigned long root = of_get_flat_dt_root();

	return of_flat_dt_is_compatible(root, "fsl,MPC8569EMDS");
}

define_machine(mpc8569_mds) {
	.name		= "MPC8569 MDS",
	.probe		= mpc8569_mds_probe,
	.setup_arch	= mpc85xx_mds_setup_arch,
	.init_IRQ	= mpc85xx_mds_pic_init,
	.get_irq	= mpic_get_irq,
	.restart	= fsl_rstcr_restart,
	.calibrate_decr	= generic_calibrate_decr,
	.progress	= udbg_progress,
#ifdef CONFIG_PCI
	.pcibios_fixup_bus	= fsl_pcibios_fixup_bus,
#endif
};