fec.c 44.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4
/*
 * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
 * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
 *
5
 * Right now, I am very wasteful with the buffers.  I allocate memory
L
Linus Torvalds 已提交
6 7 8 9 10 11 12 13 14
 * pages and then divide them into 2K frame buffers.  This way I know I
 * have buffers large enough to hold one frame within one buffer descriptor.
 * Once I get this working, I will use 64 or 128 byte CPM buffers, which
 * will be much more memory efficient and will easily handle lots of
 * small packets.
 *
 * Much better multiple PHY support by Magnus Damm.
 * Copyright (c) 2000 Ericsson Radio Systems AB.
 *
15 16
 * Support for FEC controller of ColdFire processors.
 * Copyright (c) 2001-2005 Greg Ungerer (gerg@snapgear.com)
17 18
 *
 * Bug fixes and cleanup by Philippe De Muyter (phdm@macqel.be)
19
 * Copyright (c) 2004-2006 Macq Electronique SA.
20
 *
S
Shawn Guo 已提交
21
 * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
L
Linus Torvalds 已提交
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/bitops.h>
41 42
#include <linux/io.h>
#include <linux/irq.h>
43
#include <linux/clk.h>
44
#include <linux/platform_device.h>
45
#include <linux/phy.h>
46
#include <linux/fec.h>
47 48 49 50
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/of_net.h>
S
Shawn Guo 已提交
51
#include <linux/pinctrl/consumer.h>
52
#include <linux/regulator/consumer.h>
L
Linus Torvalds 已提交
53

54
#include <asm/cacheflush.h>
55

56
#ifndef CONFIG_ARM
L
Linus Torvalds 已提交
57 58
#include <asm/coldfire.h>
#include <asm/mcfsim.h>
59
#endif
60

L
Linus Torvalds 已提交
61 62
#include "fec.h"

63
#if defined(CONFIG_ARM)
64 65 66 67 68
#define FEC_ALIGNMENT	0xf
#else
#define FEC_ALIGNMENT	0x3
#endif

69 70 71 72 73 74
#define DRIVER_NAME	"fec"

/* Controller is ENET-MAC */
#define FEC_QUIRK_ENET_MAC		(1 << 0)
/* Controller needs driver to swap frame */
#define FEC_QUIRK_SWAP_FRAME		(1 << 1)
75 76
/* Controller uses gasket */
#define FEC_QUIRK_USE_GASKET		(1 << 2)
S
Shawn Guo 已提交
77 78
/* Controller has GBIT support */
#define FEC_QUIRK_HAS_GBIT		(1 << 3)
79 80 81

static struct platform_device_id fec_devtype[] = {
	{
82
		/* keep it for coldfire */
83 84
		.name = DRIVER_NAME,
		.driver_data = 0,
85 86 87 88 89 90
	}, {
		.name = "imx25-fec",
		.driver_data = FEC_QUIRK_USE_GASKET,
	}, {
		.name = "imx27-fec",
		.driver_data = 0,
91 92 93
	}, {
		.name = "imx28-fec",
		.driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME,
S
Shawn Guo 已提交
94 95 96
	}, {
		.name = "imx6q-fec",
		.driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT,
97 98 99
	}, {
		/* sentinel */
	}
100
};
101
MODULE_DEVICE_TABLE(platform, fec_devtype);
102

103
enum imx_fec_type {
L
Lothar Waßmann 已提交
104
	IMX25_FEC = 1,	/* runs on i.mx25/50/53 */
105 106
	IMX27_FEC,	/* runs on i.mx27/35/51 */
	IMX28_FEC,
S
Shawn Guo 已提交
107
	IMX6Q_FEC,
108 109 110 111 112 113
};

static const struct of_device_id fec_dt_ids[] = {
	{ .compatible = "fsl,imx25-fec", .data = &fec_devtype[IMX25_FEC], },
	{ .compatible = "fsl,imx27-fec", .data = &fec_devtype[IMX27_FEC], },
	{ .compatible = "fsl,imx28-fec", .data = &fec_devtype[IMX28_FEC], },
S
Shawn Guo 已提交
114
	{ .compatible = "fsl,imx6q-fec", .data = &fec_devtype[IMX6Q_FEC], },
115 116 117 118
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, fec_dt_ids);

119 120 121
static unsigned char macaddr[ETH_ALEN];
module_param_array(macaddr, byte, NULL, 0);
MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
L
Linus Torvalds 已提交
122

123
#if defined(CONFIG_M5272)
L
Linus Torvalds 已提交
124 125 126 127 128 129 130 131 132 133
/*
 * Some hardware gets it MAC address out of local flash memory.
 * if this is non-zero then assume it is the address to get MAC from.
 */
#if defined(CONFIG_NETtel)
#define	FEC_FLASHMAC	0xf0006006
#elif defined(CONFIG_GILBARCONAP) || defined(CONFIG_SCALES)
#define	FEC_FLASHMAC	0xf0006000
#elif defined(CONFIG_CANCam)
#define	FEC_FLASHMAC	0xf0020000
134 135 136
#elif defined (CONFIG_M5272C3)
#define	FEC_FLASHMAC	(0xffe04000 + 4)
#elif defined(CONFIG_MOD5272)
L
Lothar Waßmann 已提交
137
#define FEC_FLASHMAC	0xffc0406b
L
Linus Torvalds 已提交
138 139 140
#else
#define	FEC_FLASHMAC	0
#endif
141
#endif /* CONFIG_M5272 */
142

L
Linus Torvalds 已提交
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
/* The number of Tx and Rx buffers.  These are allocated from the page
 * pool.  The code may assume these are power of two, so it it best
 * to keep them that size.
 * We don't need to allocate pages for the transmitter.  We just use
 * the skbuffer directly.
 */
#define FEC_ENET_RX_PAGES	8
#define FEC_ENET_RX_FRSIZE	2048
#define FEC_ENET_RX_FRPPG	(PAGE_SIZE / FEC_ENET_RX_FRSIZE)
#define RX_RING_SIZE		(FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
#define FEC_ENET_TX_FRSIZE	2048
#define FEC_ENET_TX_FRPPG	(PAGE_SIZE / FEC_ENET_TX_FRSIZE)
#define TX_RING_SIZE		16	/* Must be power of two */
#define TX_RING_MOD_MASK	15	/*   for this to work */

158
#if (((RX_RING_SIZE + TX_RING_SIZE) * 8) > PAGE_SIZE)
159
#error "FEC: descriptor ring size constants too large"
160 161
#endif

S
Sascha Hauer 已提交
162
/* Interrupt events/masks. */
L
Linus Torvalds 已提交
163 164 165 166 167 168 169 170 171 172 173
#define FEC_ENET_HBERR	((uint)0x80000000)	/* Heartbeat error */
#define FEC_ENET_BABR	((uint)0x40000000)	/* Babbling receiver */
#define FEC_ENET_BABT	((uint)0x20000000)	/* Babbling transmitter */
#define FEC_ENET_GRA	((uint)0x10000000)	/* Graceful stop complete */
#define FEC_ENET_TXF	((uint)0x08000000)	/* Full frame transmitted */
#define FEC_ENET_TXB	((uint)0x04000000)	/* A buffer was transmitted */
#define FEC_ENET_RXF	((uint)0x02000000)	/* Full frame received */
#define FEC_ENET_RXB	((uint)0x01000000)	/* A buffer was received */
#define FEC_ENET_MII	((uint)0x00800000)	/* MII interrupt */
#define FEC_ENET_EBERR	((uint)0x00400000)	/* SDMA bus error */

174 175
#define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII)

L
Linus Torvalds 已提交
176 177 178 179 180 181
/* The FEC stores dest/src/type, data, and checksum for receive packets.
 */
#define PKT_MAXBUF_SIZE		1518
#define PKT_MINBUF_SIZE		64
#define PKT_MAXBLR_SIZE		1520

182 183
/* This device has up to three irqs on some platforms */
#define FEC_IRQ_NUM		3
L
Linus Torvalds 已提交
184 185

/*
186
 * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
L
Linus Torvalds 已提交
187 188 189
 * size bits. Other FEC hardware does not, so we need to take that into
 * account when setting it.
 */
190
#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
191
    defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
L
Linus Torvalds 已提交
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
#define	OPT_FRAME_SIZE	(PKT_MAXBUF_SIZE << 16)
#else
#define	OPT_FRAME_SIZE	0
#endif

/* The FEC buffer descriptors track the ring buffers.  The rx_bd_base and
 * tx_bd_base always point to the base of the buffer descriptors.  The
 * cur_rx and cur_tx point to the currently available buffer.
 * The dirty_tx tracks the current buffer that is being sent by the
 * controller.  The cur_tx and dirty_tx are equal under both completely
 * empty and completely full conditions.  The empty/ready indicator in
 * the buffer descriptor determines the actual condition.
 */
struct fec_enet_private {
	/* Hardware registers of the FEC device */
S
Sascha Hauer 已提交
207
	void __iomem *hwp;
L
Linus Torvalds 已提交
208

G
Greg Ungerer 已提交
209 210
	struct net_device *netdev;

211 212
	struct clk *clk_ipg;
	struct clk *clk_ahb;
213

L
Linus Torvalds 已提交
214 215 216
	/* The saved address of a sent-in-place packet/buffer, for skfree(). */
	unsigned char *tx_bounce[TX_RING_SIZE];
	struct	sk_buff* tx_skbuff[TX_RING_SIZE];
S
Sascha Hauer 已提交
217
	struct	sk_buff* rx_skbuff[RX_RING_SIZE];
L
Linus Torvalds 已提交
218 219 220
	ushort	skb_cur;
	ushort	skb_dirty;

S
Sascha Hauer 已提交
221
	/* CPM dual port RAM relative addresses */
222
	dma_addr_t	bd_dma;
S
Sascha Hauer 已提交
223
	/* Address of Rx and Tx buffers */
S
Sascha Hauer 已提交
224 225 226
	struct bufdesc	*rx_bd_base;
	struct bufdesc	*tx_bd_base;
	/* The next free ring entry */
227
	struct bufdesc	*cur_rx, *cur_tx;
S
Sascha Hauer 已提交
228
	/* The ring entries to be free()ed */
S
Sascha Hauer 已提交
229 230
	struct bufdesc	*dirty_tx;

L
Linus Torvalds 已提交
231
	uint	tx_full;
232 233
	/* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
	spinlock_t hw_lock;
L
Linus Torvalds 已提交
234

235
	struct	platform_device *pdev;
L
Linus Torvalds 已提交
236

237
	int	opened;
S
Shawn Guo 已提交
238
	int	dev_id;
L
Linus Torvalds 已提交
239

240
	/* Phylib and MDIO interface */
241 242 243 244
	struct	mii_bus *mii_bus;
	struct	phy_device *phy_dev;
	int	mii_timeout;
	uint	phy_speed;
245
	phy_interface_t	phy_interface;
L
Linus Torvalds 已提交
246 247
	int	link;
	int	full_duplex;
248
	struct	completion mdio_done;
249
	int	irq[FEC_IRQ_NUM];
L
Linus Torvalds 已提交
250 251
};

252 253 254 255 256 257 258 259
/* FEC MII MMFR bits definition */
#define FEC_MMFR_ST		(1 << 30)
#define FEC_MMFR_OP_READ	(2 << 28)
#define FEC_MMFR_OP_WRITE	(1 << 28)
#define FEC_MMFR_PA(v)		((v & 0x1f) << 23)
#define FEC_MMFR_RA(v)		((v & 0x1f) << 18)
#define FEC_MMFR_TA		(2 << 16)
#define FEC_MMFR_DATA(v)	(v & 0xffff)
L
Linus Torvalds 已提交
260

261
#define FEC_MII_TIMEOUT		30000 /* us */
L
Linus Torvalds 已提交
262

S
Sascha Hauer 已提交
263 264
/* Transmitter timeout */
#define TX_TIMEOUT (2 * HZ)
L
Linus Torvalds 已提交
265

L
Lothar Waßmann 已提交
266 267
static int mii_cnt;

268 269 270 271 272 273 274 275 276 277 278
static void *swap_buffer(void *bufaddr, int len)
{
	int i;
	unsigned int *buf = bufaddr;

	for (i = 0; i < (len + 3) / 4; i++, buf++)
		*buf = cpu_to_be32(*buf);

	return bufaddr;
}

279
static netdev_tx_t
280
fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
L
Linus Torvalds 已提交
281
{
282
	struct fec_enet_private *fep = netdev_priv(ndev);
283 284
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
S
Sascha Hauer 已提交
285
	struct bufdesc *bdp;
286
	void *bufaddr;
287
	unsigned short	status;
288
	unsigned long flags;
L
Linus Torvalds 已提交
289 290 291

	if (!fep->link) {
		/* Link is down or autonegotiation is in progress. */
292
		return NETDEV_TX_BUSY;
L
Linus Torvalds 已提交
293 294
	}

295
	spin_lock_irqsave(&fep->hw_lock, flags);
L
Linus Torvalds 已提交
296 297 298
	/* Fill in a Tx ring entry */
	bdp = fep->cur_tx;

299
	status = bdp->cbd_sc;
S
Sascha Hauer 已提交
300

301
	if (status & BD_ENET_TX_READY) {
L
Linus Torvalds 已提交
302
		/* Ooops.  All transmit buffers are full.  Bail out.
303
		 * This should not happen, since ndev->tbusy should be set.
L
Linus Torvalds 已提交
304
		 */
305
		printk("%s: tx queue full!.\n", ndev->name);
306
		spin_unlock_irqrestore(&fep->hw_lock, flags);
307
		return NETDEV_TX_BUSY;
L
Linus Torvalds 已提交
308 309
	}

S
Sascha Hauer 已提交
310
	/* Clear all of the status flags */
311
	status &= ~BD_ENET_TX_STATS;
L
Linus Torvalds 已提交
312

S
Sascha Hauer 已提交
313
	/* Set buffer length and buffer pointer */
314
	bufaddr = skb->data;
L
Linus Torvalds 已提交
315 316 317
	bdp->cbd_datlen = skb->len;

	/*
S
Sascha Hauer 已提交
318 319 320
	 * On some FEC implementations data must be aligned on
	 * 4-byte boundaries. Use bounce buffers to copy data
	 * and get it aligned. Ugh.
L
Linus Torvalds 已提交
321
	 */
322
	if (((unsigned long) bufaddr) & FEC_ALIGNMENT) {
L
Linus Torvalds 已提交
323 324
		unsigned int index;
		index = bdp - fep->tx_bd_base;
325
		memcpy(fep->tx_bounce[index], skb->data, skb->len);
326
		bufaddr = fep->tx_bounce[index];
L
Linus Torvalds 已提交
327 328
	}

329 330 331 332 333 334 335 336
	/*
	 * Some design made an incorrect assumption on endian mode of
	 * the system that it's running on. As the result, driver has to
	 * swap every frame going to and coming from the controller.
	 */
	if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
		swap_buffer(bufaddr, skb->len);

S
Sascha Hauer 已提交
337
	/* Save skb pointer */
L
Linus Torvalds 已提交
338 339
	fep->tx_skbuff[fep->skb_cur] = skb;

340
	ndev->stats.tx_bytes += skb->len;
L
Linus Torvalds 已提交
341
	fep->skb_cur = (fep->skb_cur+1) & TX_RING_MOD_MASK;
342

L
Linus Torvalds 已提交
343 344 345
	/* Push the data cache so the CPM does not get stale memory
	 * data.
	 */
346
	bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, bufaddr,
S
Sascha Hauer 已提交
347
			FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
L
Linus Torvalds 已提交
348

349 350
	/* Send it on its way.  Tell FEC it's ready, interrupt when done,
	 * it's the last BD of the frame, and to put the CRC on the end.
L
Linus Torvalds 已提交
351
	 */
352
	status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
L
Linus Torvalds 已提交
353
			| BD_ENET_TX_LAST | BD_ENET_TX_TC);
354
	bdp->cbd_sc = status;
L
Linus Torvalds 已提交
355 356

	/* Trigger transmission start */
S
Sascha Hauer 已提交
357
	writel(0, fep->hwp + FEC_X_DES_ACTIVE);
L
Linus Torvalds 已提交
358

S
Sascha Hauer 已提交
359 360
	/* If this was the last BD in the ring, start at the beginning again. */
	if (status & BD_ENET_TX_WRAP)
L
Linus Torvalds 已提交
361
		bdp = fep->tx_bd_base;
S
Sascha Hauer 已提交
362
	else
L
Linus Torvalds 已提交
363 364 365 366
		bdp++;

	if (bdp == fep->dirty_tx) {
		fep->tx_full = 1;
367
		netif_stop_queue(ndev);
L
Linus Torvalds 已提交
368 369
	}

S
Sascha Hauer 已提交
370
	fep->cur_tx = bdp;
L
Linus Torvalds 已提交
371

372 373
	skb_tx_timestamp(skb);

374 375
	spin_unlock_irqrestore(&fep->hw_lock, flags);

376
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
377 378
}

379 380 381 382
/* This function is called to start or restart the FEC during a link
 * change.  This only happens when switching between half and full
 * duplex.
 */
L
Linus Torvalds 已提交
383
static void
384
fec_restart(struct net_device *ndev, int duplex)
L
Linus Torvalds 已提交
385
{
386
	struct fec_enet_private *fep = netdev_priv(ndev);
387 388 389
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
	int i;
390 391
	u32 temp_mac[2];
	u32 rcntl = OPT_FRAME_SIZE | 0x04;
S
Shawn Guo 已提交
392
	u32 ecntl = 0x2; /* ETHEREN */
L
Linus Torvalds 已提交
393

394 395 396
	/* Whack a reset.  We should wait for this. */
	writel(1, fep->hwp + FEC_ECNTRL);
	udelay(10);
L
Linus Torvalds 已提交
397

398 399 400 401 402 403 404 405 406
	/*
	 * enet-mac reset will reset mac address registers too,
	 * so need to reconfigure it.
	 */
	if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
		memcpy(&temp_mac, ndev->dev_addr, ETH_ALEN);
		writel(cpu_to_be32(temp_mac[0]), fep->hwp + FEC_ADDR_LOW);
		writel(cpu_to_be32(temp_mac[1]), fep->hwp + FEC_ADDR_HIGH);
	}
L
Linus Torvalds 已提交
407

408 409
	/* Clear any outstanding interrupt. */
	writel(0xffc00000, fep->hwp + FEC_IEVENT);
L
Linus Torvalds 已提交
410

411 412 413 414 415 416 417
	/* Reset all multicast.	*/
	writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
	writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
#ifndef CONFIG_M5272
	writel(0, fep->hwp + FEC_HASH_TABLE_HIGH);
	writel(0, fep->hwp + FEC_HASH_TABLE_LOW);
#endif
L
Linus Torvalds 已提交
418

419 420
	/* Set maximum receive buffer size. */
	writel(PKT_MAXBLR_SIZE, fep->hwp + FEC_R_BUFF_SIZE);
L
Linus Torvalds 已提交
421

422 423 424 425 426 427 428 429 430 431 432 433 434 435
	/* Set receive and transmit descriptor base. */
	writel(fep->bd_dma, fep->hwp + FEC_R_DES_START);
	writel((unsigned long)fep->bd_dma + sizeof(struct bufdesc) * RX_RING_SIZE,
			fep->hwp + FEC_X_DES_START);

	fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
	fep->cur_rx = fep->rx_bd_base;

	/* Reset SKB transmit buffers. */
	fep->skb_cur = fep->skb_dirty = 0;
	for (i = 0; i <= TX_RING_MOD_MASK; i++) {
		if (fep->tx_skbuff[i]) {
			dev_kfree_skb_any(fep->tx_skbuff[i]);
			fep->tx_skbuff[i] = NULL;
L
Linus Torvalds 已提交
436
		}
437
	}
438

439 440
	/* Enable MII mode */
	if (duplex) {
441
		/* FD enable */
442 443
		writel(0x04, fep->hwp + FEC_X_CNTRL);
	} else {
444 445
		/* No Rcv on Xmit */
		rcntl |= 0x02;
446 447
		writel(0x0, fep->hwp + FEC_X_CNTRL);
	}
448

449 450 451 452 453 454 455 456 457 458
	fep->full_duplex = duplex;

	/* Set MII speed */
	writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);

	/*
	 * The phy interface and speed need to get configured
	 * differently on enet-mac.
	 */
	if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
459 460
		/* Enable flow control and length check */
		rcntl |= 0x40000000 | 0x00000020;
461

S
Shawn Guo 已提交
462 463 464 465
		/* RGMII, RMII or MII */
		if (fep->phy_interface == PHY_INTERFACE_MODE_RGMII)
			rcntl |= (1 << 6);
		else if (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
466
			rcntl |= (1 << 8);
467
		else
468
			rcntl &= ~(1 << 8);
469

S
Shawn Guo 已提交
470 471 472 473 474 475 476 477 478
		/* 1G, 100M or 10M */
		if (fep->phy_dev) {
			if (fep->phy_dev->speed == SPEED_1000)
				ecntl |= (1 << 5);
			else if (fep->phy_dev->speed == SPEED_100)
				rcntl &= ~(1 << 9);
			else
				rcntl |= (1 << 9);
		}
479 480
	} else {
#ifdef FEC_MIIGSK_ENR
481
		if (id_entry->driver_data & FEC_QUIRK_USE_GASKET) {
482
			u32 cfgr;
483 484 485 486 487 488 489 490
			/* disable the gasket and wait */
			writel(0, fep->hwp + FEC_MIIGSK_ENR);
			while (readl(fep->hwp + FEC_MIIGSK_ENR) & 4)
				udelay(1);

			/*
			 * configure the gasket:
			 *   RMII, 50 MHz, no loopback, no echo
491
			 *   MII, 25 MHz, no loopback, no echo
492
			 */
493 494 495 496 497
			cfgr = (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
				? BM_MIIGSK_CFGR_RMII : BM_MIIGSK_CFGR_MII;
			if (fep->phy_dev && fep->phy_dev->speed == SPEED_10)
				cfgr |= BM_MIIGSK_CFGR_FRCONT_10M;
			writel(cfgr, fep->hwp + FEC_MIIGSK_CFGR);
498 499 500

			/* re-enable the gasket */
			writel(2, fep->hwp + FEC_MIIGSK_ENR);
501
		}
502 503
#endif
	}
504
	writel(rcntl, fep->hwp + FEC_R_CNTRL);
505

S
Shawn Guo 已提交
506 507 508 509 510 511 512
	if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
		/* enable ENET endian swap */
		ecntl |= (1 << 8);
		/* enable ENET store and forward mode */
		writel(1 << 8, fep->hwp + FEC_X_WMRK);
	}

513
	/* And last, enable the transmit and receive processing */
S
Shawn Guo 已提交
514
	writel(ecntl, fep->hwp + FEC_ECNTRL);
515 516 517 518 519 520 521 522 523 524
	writel(0, fep->hwp + FEC_R_DES_ACTIVE);

	/* Enable interrupts we wish to service */
	writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
}

static void
fec_stop(struct net_device *ndev)
{
	struct fec_enet_private *fep = netdev_priv(ndev);
S
Shawn Guo 已提交
525 526
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
527
	u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8);
528 529 530 531 532 533 534 535 536 537 538 539 540 541

	/* We cannot expect a graceful transmit stop without link !!! */
	if (fep->link) {
		writel(1, fep->hwp + FEC_X_CNTRL); /* Graceful transmit stop */
		udelay(10);
		if (!(readl(fep->hwp + FEC_IEVENT) & FEC_ENET_GRA))
			printk("fec_stop : Graceful transmit stop did not complete !\n");
	}

	/* Whack a reset.  We should wait for this. */
	writel(1, fep->hwp + FEC_ECNTRL);
	udelay(10);
	writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
	writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
S
Shawn Guo 已提交
542 543

	/* We have to keep ENET enabled to have MII interrupt stay working */
544
	if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
S
Shawn Guo 已提交
545
		writel(2, fep->hwp + FEC_ECNTRL);
546 547
		writel(rmii_mode, fep->hwp + FEC_R_CNTRL);
	}
L
Linus Torvalds 已提交
548 549 550
}


551 552 553 554 555 556 557 558 559 560 561
static void
fec_timeout(struct net_device *ndev)
{
	struct fec_enet_private *fep = netdev_priv(ndev);

	ndev->stats.tx_errors++;

	fec_restart(ndev, fep->full_duplex);
	netif_wake_queue(ndev);
}

L
Linus Torvalds 已提交
562
static void
563
fec_enet_tx(struct net_device *ndev)
L
Linus Torvalds 已提交
564 565
{
	struct	fec_enet_private *fep;
S
Sascha Hauer 已提交
566
	struct bufdesc *bdp;
567
	unsigned short status;
L
Linus Torvalds 已提交
568 569
	struct	sk_buff	*skb;

570
	fep = netdev_priv(ndev);
571
	spin_lock(&fep->hw_lock);
L
Linus Torvalds 已提交
572 573
	bdp = fep->dirty_tx;

574
	while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
S
Sascha Hauer 已提交
575 576 577
		if (bdp == fep->cur_tx && fep->tx_full == 0)
			break;

578 579
		dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
				FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
S
Sascha Hauer 已提交
580
		bdp->cbd_bufaddr = 0;
L
Linus Torvalds 已提交
581 582 583

		skb = fep->tx_skbuff[fep->skb_dirty];
		/* Check for errors. */
584
		if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
L
Linus Torvalds 已提交
585 586
				   BD_ENET_TX_RL | BD_ENET_TX_UN |
				   BD_ENET_TX_CSL)) {
587
			ndev->stats.tx_errors++;
588
			if (status & BD_ENET_TX_HB)  /* No heartbeat */
589
				ndev->stats.tx_heartbeat_errors++;
590
			if (status & BD_ENET_TX_LC)  /* Late collision */
591
				ndev->stats.tx_window_errors++;
592
			if (status & BD_ENET_TX_RL)  /* Retrans limit */
593
				ndev->stats.tx_aborted_errors++;
594
			if (status & BD_ENET_TX_UN)  /* Underrun */
595
				ndev->stats.tx_fifo_errors++;
596
			if (status & BD_ENET_TX_CSL) /* Carrier lost */
597
				ndev->stats.tx_carrier_errors++;
L
Linus Torvalds 已提交
598
		} else {
599
			ndev->stats.tx_packets++;
L
Linus Torvalds 已提交
600 601
		}

602
		if (status & BD_ENET_TX_READY)
L
Linus Torvalds 已提交
603
			printk("HEY! Enet xmit interrupt and TX_READY.\n");
S
Sascha Hauer 已提交
604

L
Linus Torvalds 已提交
605 606 607
		/* Deferred means some collisions occurred during transmit,
		 * but we eventually sent the packet OK.
		 */
608
		if (status & BD_ENET_TX_DEF)
609
			ndev->stats.collisions++;
610

S
Sascha Hauer 已提交
611
		/* Free the sk buffer associated with this last transmit */
L
Linus Torvalds 已提交
612 613 614
		dev_kfree_skb_any(skb);
		fep->tx_skbuff[fep->skb_dirty] = NULL;
		fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
615

S
Sascha Hauer 已提交
616
		/* Update pointer to next buffer descriptor to be transmitted */
617
		if (status & BD_ENET_TX_WRAP)
L
Linus Torvalds 已提交
618 619 620
			bdp = fep->tx_bd_base;
		else
			bdp++;
621

S
Sascha Hauer 已提交
622
		/* Since we have freed up a buffer, the ring is no longer full
L
Linus Torvalds 已提交
623 624 625
		 */
		if (fep->tx_full) {
			fep->tx_full = 0;
626 627
			if (netif_queue_stopped(ndev))
				netif_wake_queue(ndev);
L
Linus Torvalds 已提交
628 629
		}
	}
S
Sascha Hauer 已提交
630
	fep->dirty_tx = bdp;
631
	spin_unlock(&fep->hw_lock);
L
Linus Torvalds 已提交
632 633 634 635 636 637 638 639 640
}


/* During a receive, the cur_rx points to the current incoming buffer.
 * When we update through the ring, if the next incoming buffer has
 * not been given to the system, we just set the empty indicator,
 * effectively tossing the packet.
 */
static void
641
fec_enet_rx(struct net_device *ndev)
L
Linus Torvalds 已提交
642
{
643
	struct fec_enet_private *fep = netdev_priv(ndev);
644 645
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
S
Sascha Hauer 已提交
646
	struct bufdesc *bdp;
647
	unsigned short status;
L
Linus Torvalds 已提交
648 649 650
	struct	sk_buff	*skb;
	ushort	pkt_len;
	__u8 *data;
651

652 653
#ifdef CONFIG_M532x
	flush_cache_all();
654
#endif
L
Linus Torvalds 已提交
655

656
	spin_lock(&fep->hw_lock);
657

L
Linus Torvalds 已提交
658 659 660 661 662
	/* First, grab all of the stats for the incoming packet.
	 * These get messed up if we get called due to a busy condition.
	 */
	bdp = fep->cur_rx;

S
Sascha Hauer 已提交
663
	while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
L
Linus Torvalds 已提交
664

S
Sascha Hauer 已提交
665 666 667 668 669
		/* Since we have allocated space to hold a complete frame,
		 * the last indicator should be set.
		 */
		if ((status & BD_ENET_RX_LAST) == 0)
			printk("FEC ENET: rcv is not +last\n");
L
Linus Torvalds 已提交
670

S
Sascha Hauer 已提交
671 672
		if (!fep->opened)
			goto rx_processing_done;
L
Linus Torvalds 已提交
673

S
Sascha Hauer 已提交
674 675
		/* Check for errors. */
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
L
Linus Torvalds 已提交
676
			   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
677
			ndev->stats.rx_errors++;
S
Sascha Hauer 已提交
678 679
			if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
				/* Frame too long or too short. */
680
				ndev->stats.rx_length_errors++;
S
Sascha Hauer 已提交
681 682
			}
			if (status & BD_ENET_RX_NO)	/* Frame alignment */
683
				ndev->stats.rx_frame_errors++;
S
Sascha Hauer 已提交
684
			if (status & BD_ENET_RX_CR)	/* CRC Error */
685
				ndev->stats.rx_crc_errors++;
S
Sascha Hauer 已提交
686
			if (status & BD_ENET_RX_OV)	/* FIFO overrun */
687
				ndev->stats.rx_fifo_errors++;
L
Linus Torvalds 已提交
688 689
		}

S
Sascha Hauer 已提交
690 691 692 693 694
		/* Report late collisions as a frame error.
		 * On this error, the BD is closed, but we don't know what we
		 * have in the buffer.  So, just drop this frame on the floor.
		 */
		if (status & BD_ENET_RX_CL) {
695 696
			ndev->stats.rx_errors++;
			ndev->stats.rx_frame_errors++;
S
Sascha Hauer 已提交
697 698
			goto rx_processing_done;
		}
L
Linus Torvalds 已提交
699

S
Sascha Hauer 已提交
700
		/* Process the incoming frame. */
701
		ndev->stats.rx_packets++;
S
Sascha Hauer 已提交
702
		pkt_len = bdp->cbd_datlen;
703
		ndev->stats.rx_bytes += pkt_len;
S
Sascha Hauer 已提交
704
		data = (__u8*)__va(bdp->cbd_bufaddr);
L
Linus Torvalds 已提交
705

706 707
		dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
				FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
708

709 710 711
		if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
			swap_buffer(data, pkt_len);

S
Sascha Hauer 已提交
712 713 714 715 716
		/* This does 16 byte alignment, exactly what we need.
		 * The packet length includes FCS, but we don't want to
		 * include that when passing upstream as it messes up
		 * bridging applications.
		 */
717
		skb = netdev_alloc_skb(ndev, pkt_len - 4 + NET_IP_ALIGN);
L
Linus Torvalds 已提交
718

S
Sascha Hauer 已提交
719
		if (unlikely(!skb)) {
S
Sascha Hauer 已提交
720
			printk("%s: Memory squeeze, dropping packet.\n",
721 722
					ndev->name);
			ndev->stats.rx_dropped++;
S
Sascha Hauer 已提交
723
		} else {
S
Sascha Hauer 已提交
724
			skb_reserve(skb, NET_IP_ALIGN);
S
Sascha Hauer 已提交
725 726
			skb_put(skb, pkt_len - 4);	/* Make room */
			skb_copy_to_linear_data(skb, data, pkt_len - 4);
727
			skb->protocol = eth_type_trans(skb, ndev);
728 729
			if (!skb_defer_rx_timestamp(skb))
				netif_rx(skb);
S
Sascha Hauer 已提交
730
		}
S
Sascha Hauer 已提交
731

732 733
		bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, data,
				FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
S
Sascha Hauer 已提交
734 735 736
rx_processing_done:
		/* Clear the status flags for this buffer */
		status &= ~BD_ENET_RX_STATS;
L
Linus Torvalds 已提交
737

S
Sascha Hauer 已提交
738 739 740
		/* Mark the buffer empty */
		status |= BD_ENET_RX_EMPTY;
		bdp->cbd_sc = status;
741

S
Sascha Hauer 已提交
742 743 744 745 746 747 748 749 750 751 752
		/* Update BD pointer to next entry */
		if (status & BD_ENET_RX_WRAP)
			bdp = fep->rx_bd_base;
		else
			bdp++;
		/* Doing this here will keep the FEC running while we process
		 * incoming frames.  On a heavily loaded network, we should be
		 * able to keep up at the expense of system resources.
		 */
		writel(0, fep->hwp + FEC_R_DES_ACTIVE);
	}
S
Sascha Hauer 已提交
753
	fep->cur_rx = bdp;
L
Linus Torvalds 已提交
754

755
	spin_unlock(&fep->hw_lock);
L
Linus Torvalds 已提交
756 757
}

758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
static irqreturn_t
fec_enet_interrupt(int irq, void *dev_id)
{
	struct net_device *ndev = dev_id;
	struct fec_enet_private *fep = netdev_priv(ndev);
	uint int_events;
	irqreturn_t ret = IRQ_NONE;

	do {
		int_events = readl(fep->hwp + FEC_IEVENT);
		writel(int_events, fep->hwp + FEC_IEVENT);

		if (int_events & FEC_ENET_RXF) {
			ret = IRQ_HANDLED;
			fec_enet_rx(ndev);
		}

		/* Transmit OK, or non-fatal error. Update the buffer
		 * descriptors. FEC handles all errors, we just discover
		 * them as part of the transmit process.
		 */
		if (int_events & FEC_ENET_TXF) {
			ret = IRQ_HANDLED;
			fec_enet_tx(ndev);
		}

		if (int_events & FEC_ENET_MII) {
			ret = IRQ_HANDLED;
			complete(&fep->mdio_done);
		}
	} while (int_events);

	return ret;
}



795
/* ------------------------------------------------------------------------- */
796
static void __inline__ fec_get_mac(struct net_device *ndev)
L
Linus Torvalds 已提交
797
{
798
	struct fec_enet_private *fep = netdev_priv(ndev);
799
	struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
800
	unsigned char *iap, tmpaddr[ETH_ALEN];
L
Linus Torvalds 已提交
801

802 803 804 805 806 807 808 809
	/*
	 * try to get mac address in following order:
	 *
	 * 1) module parameter via kernel command line in form
	 *    fec.macaddr=0x00,0x04,0x9f,0x01,0x30,0xe0
	 */
	iap = macaddr;

810 811 812 813 814 815 816 817 818 819 820 821 822 823
#ifdef CONFIG_OF
	/*
	 * 2) from device tree data
	 */
	if (!is_valid_ether_addr(iap)) {
		struct device_node *np = fep->pdev->dev.of_node;
		if (np) {
			const char *mac = of_get_mac_address(np);
			if (mac)
				iap = (unsigned char *) mac;
		}
	}
#endif

824
	/*
825
	 * 3) from flash or fuse (via platform data)
826 827 828 829 830 831 832
	 */
	if (!is_valid_ether_addr(iap)) {
#ifdef CONFIG_M5272
		if (FEC_FLASHMAC)
			iap = (unsigned char *)FEC_FLASHMAC;
#else
		if (pdata)
833
			iap = (unsigned char *)&pdata->mac;
834 835 836 837
#endif
	}

	/*
838
	 * 4) FEC mac registers set by bootloader
839 840 841 842 843 844
	 */
	if (!is_valid_ether_addr(iap)) {
		*((unsigned long *) &tmpaddr[0]) =
			be32_to_cpu(readl(fep->hwp + FEC_ADDR_LOW));
		*((unsigned short *) &tmpaddr[4]) =
			be16_to_cpu(readl(fep->hwp + FEC_ADDR_HIGH) >> 16);
845
		iap = &tmpaddr[0];
L
Linus Torvalds 已提交
846 847
	}

848
	memcpy(ndev->dev_addr, iap, ETH_ALEN);
L
Linus Torvalds 已提交
849

850 851
	/* Adjust MAC if using macaddr */
	if (iap == macaddr)
S
Shawn Guo 已提交
852
		 ndev->dev_addr[ETH_ALEN-1] = macaddr[ETH_ALEN-1] + fep->dev_id;
L
Linus Torvalds 已提交
853 854
}

855
/* ------------------------------------------------------------------------- */
L
Linus Torvalds 已提交
856

857 858 859
/*
 * Phy section
 */
860
static void fec_enet_adjust_link(struct net_device *ndev)
L
Linus Torvalds 已提交
861
{
862
	struct fec_enet_private *fep = netdev_priv(ndev);
863 864
	struct phy_device *phy_dev = fep->phy_dev;
	unsigned long flags;
L
Linus Torvalds 已提交
865

866
	int status_change = 0;
L
Linus Torvalds 已提交
867

868
	spin_lock_irqsave(&fep->hw_lock, flags);
L
Linus Torvalds 已提交
869

870 871 872 873 874
	/* Prevent a state halted on mii error */
	if (fep->mii_timeout && phy_dev->state == PHY_HALTED) {
		phy_dev->state = PHY_RESUMING;
		goto spin_unlock;
	}
L
Linus Torvalds 已提交
875

876 877 878
	/* Duplex link change */
	if (phy_dev->link) {
		if (fep->full_duplex != phy_dev->duplex) {
879
			fec_restart(ndev, phy_dev->duplex);
880 881
			/* prevent unnecessary second fec_restart() below */
			fep->link = phy_dev->link;
882 883 884
			status_change = 1;
		}
	}
L
Linus Torvalds 已提交
885

886 887 888 889
	/* Link on or off change */
	if (phy_dev->link != fep->link) {
		fep->link = phy_dev->link;
		if (phy_dev->link)
890
			fec_restart(ndev, phy_dev->duplex);
L
Linus Torvalds 已提交
891
		else
892
			fec_stop(ndev);
893
		status_change = 1;
L
Linus Torvalds 已提交
894
	}
895

896 897
spin_unlock:
	spin_unlock_irqrestore(&fep->hw_lock, flags);
L
Linus Torvalds 已提交
898

899 900 901
	if (status_change)
		phy_print_status(phy_dev);
}
L
Linus Torvalds 已提交
902

903
static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
L
Linus Torvalds 已提交
904
{
905
	struct fec_enet_private *fep = bus->priv;
906
	unsigned long time_left;
L
Linus Torvalds 已提交
907

908
	fep->mii_timeout = 0;
909
	init_completion(&fep->mdio_done);
910 911 912 913 914 915 916

	/* start a read op */
	writel(FEC_MMFR_ST | FEC_MMFR_OP_READ |
		FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
		FEC_MMFR_TA, fep->hwp + FEC_MII_DATA);

	/* wait for end of transfer */
917 918 919 920 921 922
	time_left = wait_for_completion_timeout(&fep->mdio_done,
			usecs_to_jiffies(FEC_MII_TIMEOUT));
	if (time_left == 0) {
		fep->mii_timeout = 1;
		printk(KERN_ERR "FEC: MDIO read timeout\n");
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
923 924
	}

925 926
	/* return value */
	return FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));
927
}
928

929 930
static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
			   u16 value)
L
Linus Torvalds 已提交
931
{
932
	struct fec_enet_private *fep = bus->priv;
933
	unsigned long time_left;
L
Linus Torvalds 已提交
934

935
	fep->mii_timeout = 0;
936
	init_completion(&fep->mdio_done);
L
Linus Torvalds 已提交
937

938 939
	/* start a write op */
	writel(FEC_MMFR_ST | FEC_MMFR_OP_WRITE |
940 941 942 943 944
		FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
		FEC_MMFR_TA | FEC_MMFR_DATA(value),
		fep->hwp + FEC_MII_DATA);

	/* wait for end of transfer */
945 946 947 948 949 950
	time_left = wait_for_completion_timeout(&fep->mdio_done,
			usecs_to_jiffies(FEC_MII_TIMEOUT));
	if (time_left == 0) {
		fep->mii_timeout = 1;
		printk(KERN_ERR "FEC: MDIO write timeout\n");
		return -ETIMEDOUT;
951
	}
L
Linus Torvalds 已提交
952

953 954
	return 0;
}
L
Linus Torvalds 已提交
955

956
static int fec_enet_mdio_reset(struct mii_bus *bus)
L
Linus Torvalds 已提交
957
{
958
	return 0;
L
Linus Torvalds 已提交
959 960
}

961
static int fec_enet_mii_probe(struct net_device *ndev)
962
{
963
	struct fec_enet_private *fep = netdev_priv(ndev);
S
Shawn Guo 已提交
964 965
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
966
	struct phy_device *phy_dev = NULL;
967 968 969
	char mdio_bus_id[MII_BUS_ID_SIZE];
	char phy_name[MII_BUS_ID_SIZE + 3];
	int phy_id;
S
Shawn Guo 已提交
970
	int dev_id = fep->dev_id;
971

972 973
	fep->phy_dev = NULL;

974 975 976 977 978 979 980 981
	/* check for attached phy */
	for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
		if ((fep->mii_bus->phy_mask & (1 << phy_id)))
			continue;
		if (fep->mii_bus->phy_map[phy_id] == NULL)
			continue;
		if (fep->mii_bus->phy_map[phy_id]->phy_id == 0)
			continue;
982 983
		if (dev_id--)
			continue;
984 985
		strncpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
		break;
986
	}
L
Linus Torvalds 已提交
987

988
	if (phy_id >= PHY_MAX_ADDR) {
L
Lothar Waßmann 已提交
989 990 991
		printk(KERN_INFO
			"%s: no PHY, assuming direct connection to switch\n",
			ndev->name);
992
		strncpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE);
993 994 995
		phy_id = 0;
	}

996
	snprintf(phy_name, sizeof(phy_name), PHY_ID_FMT, mdio_bus_id, phy_id);
997
	phy_dev = phy_connect(ndev, phy_name, &fec_enet_adjust_link, 0,
S
Shawn Guo 已提交
998
			      fep->phy_interface);
999
	if (IS_ERR(phy_dev)) {
1000
		printk(KERN_ERR "%s: could not attach to PHY\n", ndev->name);
1001
		return PTR_ERR(phy_dev);
1002
	}
L
Linus Torvalds 已提交
1003

1004
	/* mask with MAC supported features */
S
Shawn Guo 已提交
1005 1006 1007 1008 1009
	if (id_entry->driver_data & FEC_QUIRK_HAS_GBIT)
		phy_dev->supported &= PHY_GBIT_FEATURES;
	else
		phy_dev->supported &= PHY_BASIC_FEATURES;

1010
	phy_dev->advertising = phy_dev->supported;
L
Linus Torvalds 已提交
1011

1012 1013 1014
	fep->phy_dev = phy_dev;
	fep->link = 0;
	fep->full_duplex = 0;
L
Linus Torvalds 已提交
1015

L
Lothar Waßmann 已提交
1016 1017 1018
	printk(KERN_INFO
		"%s: Freescale FEC PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
		ndev->name,
1019 1020 1021
		fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),
		fep->phy_dev->irq);

1022
	return 0;
L
Linus Torvalds 已提交
1023 1024
}

1025
static int fec_enet_mii_init(struct platform_device *pdev)
1026
{
1027
	static struct mii_bus *fec0_mii_bus;
1028 1029
	struct net_device *ndev = platform_get_drvdata(pdev);
	struct fec_enet_private *fep = netdev_priv(ndev);
1030 1031
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
1032
	int err = -ENXIO, i;
1033

1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
	/*
	 * The dual fec interfaces are not equivalent with enet-mac.
	 * Here are the differences:
	 *
	 *  - fec0 supports MII & RMII modes while fec1 only supports RMII
	 *  - fec0 acts as the 1588 time master while fec1 is slave
	 *  - external phys can only be configured by fec0
	 *
	 * That is to say fec1 can not work independently. It only works
	 * when fec0 is working. The reason behind this design is that the
	 * second interface is added primarily for Switch mode.
	 *
	 * Because of the last point above, both phys are attached on fec0
	 * mdio interface in board design, and need to be configured by
	 * fec0 mii_bus.
	 */
S
Shawn Guo 已提交
1050
	if ((id_entry->driver_data & FEC_QUIRK_ENET_MAC) && fep->dev_id > 0) {
1051
		/* fec1 uses fec0 mii_bus */
L
Lothar Waßmann 已提交
1052 1053 1054 1055 1056 1057
		if (mii_cnt && fec0_mii_bus) {
			fep->mii_bus = fec0_mii_bus;
			mii_cnt++;
			return 0;
		}
		return -ENOENT;
1058 1059
	}

1060
	fep->mii_timeout = 0;
L
Linus Torvalds 已提交
1061

1062 1063
	/*
	 * Set MII speed to 2.5 MHz (= clk_get_rate() / 2 * phy_speed)
S
Shawn Guo 已提交
1064 1065 1066 1067 1068
	 *
	 * The formula for FEC MDC is 'ref_freq / (MII_SPEED x 2)' while
	 * for ENET-MAC is 'ref_freq / ((MII_SPEED + 1) x 2)'.  The i.MX28
	 * Reference Manual has an error on this, and gets fixed on i.MX6Q
	 * document.
1069
	 */
1070
	fep->phy_speed = DIV_ROUND_UP(clk_get_rate(fep->clk_ahb), 5000000);
S
Shawn Guo 已提交
1071 1072 1073
	if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
		fep->phy_speed--;
	fep->phy_speed <<= 1;
1074
	writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
L
Linus Torvalds 已提交
1075

1076 1077 1078 1079
	fep->mii_bus = mdiobus_alloc();
	if (fep->mii_bus == NULL) {
		err = -ENOMEM;
		goto err_out;
L
Linus Torvalds 已提交
1080 1081
	}

1082 1083 1084 1085
	fep->mii_bus->name = "fec_enet_mii_bus";
	fep->mii_bus->read = fec_enet_mdio_read;
	fep->mii_bus->write = fec_enet_mdio_write;
	fep->mii_bus->reset = fec_enet_mdio_reset;
1086 1087
	snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
		pdev->name, fep->dev_id + 1);
1088 1089 1090 1091 1092 1093 1094
	fep->mii_bus->priv = fep;
	fep->mii_bus->parent = &pdev->dev;

	fep->mii_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
	if (!fep->mii_bus->irq) {
		err = -ENOMEM;
		goto err_out_free_mdiobus;
L
Linus Torvalds 已提交
1095 1096
	}

1097 1098
	for (i = 0; i < PHY_MAX_ADDR; i++)
		fep->mii_bus->irq[i] = PHY_POLL;
L
Linus Torvalds 已提交
1099

1100 1101
	if (mdiobus_register(fep->mii_bus))
		goto err_out_free_mdio_irq;
L
Linus Torvalds 已提交
1102

L
Lothar Waßmann 已提交
1103 1104
	mii_cnt++;

1105 1106 1107 1108
	/* save fec0 mii_bus */
	if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
		fec0_mii_bus = fep->mii_bus;

1109
	return 0;
L
Linus Torvalds 已提交
1110

1111 1112 1113 1114 1115 1116
err_out_free_mdio_irq:
	kfree(fep->mii_bus->irq);
err_out_free_mdiobus:
	mdiobus_free(fep->mii_bus);
err_out:
	return err;
L
Linus Torvalds 已提交
1117 1118
}

1119
static void fec_enet_mii_remove(struct fec_enet_private *fep)
L
Linus Torvalds 已提交
1120
{
L
Lothar Waßmann 已提交
1121 1122 1123 1124 1125
	if (--mii_cnt == 0) {
		mdiobus_unregister(fep->mii_bus);
		kfree(fep->mii_bus->irq);
		mdiobus_free(fep->mii_bus);
	}
L
Linus Torvalds 已提交
1126 1127
}

1128
static int fec_enet_get_settings(struct net_device *ndev,
1129
				  struct ethtool_cmd *cmd)
L
Linus Torvalds 已提交
1130
{
1131
	struct fec_enet_private *fep = netdev_priv(ndev);
1132
	struct phy_device *phydev = fep->phy_dev;
L
Linus Torvalds 已提交
1133

1134 1135
	if (!phydev)
		return -ENODEV;
L
Linus Torvalds 已提交
1136

1137
	return phy_ethtool_gset(phydev, cmd);
L
Linus Torvalds 已提交
1138 1139
}

1140
static int fec_enet_set_settings(struct net_device *ndev,
1141
				 struct ethtool_cmd *cmd)
L
Linus Torvalds 已提交
1142
{
1143
	struct fec_enet_private *fep = netdev_priv(ndev);
1144
	struct phy_device *phydev = fep->phy_dev;
L
Linus Torvalds 已提交
1145

1146 1147
	if (!phydev)
		return -ENODEV;
L
Linus Torvalds 已提交
1148

1149
	return phy_ethtool_sset(phydev, cmd);
L
Linus Torvalds 已提交
1150 1151
}

1152
static void fec_enet_get_drvinfo(struct net_device *ndev,
1153
				 struct ethtool_drvinfo *info)
L
Linus Torvalds 已提交
1154
{
1155
	struct fec_enet_private *fep = netdev_priv(ndev);
1156

1157 1158
	strcpy(info->driver, fep->pdev->dev.driver->name);
	strcpy(info->version, "Revision: 1.0");
1159
	strcpy(info->bus_info, dev_name(&ndev->dev));
L
Linus Torvalds 已提交
1160 1161
}

S
stephen hemminger 已提交
1162
static const struct ethtool_ops fec_enet_ethtool_ops = {
1163 1164 1165 1166
	.get_settings		= fec_enet_get_settings,
	.set_settings		= fec_enet_set_settings,
	.get_drvinfo		= fec_enet_get_drvinfo,
	.get_link		= ethtool_op_get_link,
1167
	.get_ts_info		= ethtool_op_get_ts_info,
1168
};
L
Linus Torvalds 已提交
1169

1170
static int fec_enet_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
L
Linus Torvalds 已提交
1171
{
1172
	struct fec_enet_private *fep = netdev_priv(ndev);
1173
	struct phy_device *phydev = fep->phy_dev;
L
Linus Torvalds 已提交
1174

1175
	if (!netif_running(ndev))
1176
		return -EINVAL;
L
Linus Torvalds 已提交
1177

1178 1179 1180
	if (!phydev)
		return -ENODEV;

1181
	return phy_mii_ioctl(phydev, rq, cmd);
L
Linus Torvalds 已提交
1182 1183
}

1184
static void fec_enet_free_buffers(struct net_device *ndev)
S
Sascha Hauer 已提交
1185
{
1186
	struct fec_enet_private *fep = netdev_priv(ndev);
S
Sascha Hauer 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195
	int i;
	struct sk_buff *skb;
	struct bufdesc	*bdp;

	bdp = fep->rx_bd_base;
	for (i = 0; i < RX_RING_SIZE; i++) {
		skb = fep->rx_skbuff[i];

		if (bdp->cbd_bufaddr)
1196
			dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
S
Sascha Hauer 已提交
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
					FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
		if (skb)
			dev_kfree_skb(skb);
		bdp++;
	}

	bdp = fep->tx_bd_base;
	for (i = 0; i < TX_RING_SIZE; i++)
		kfree(fep->tx_bounce[i]);
}

1208
static int fec_enet_alloc_buffers(struct net_device *ndev)
S
Sascha Hauer 已提交
1209
{
1210
	struct fec_enet_private *fep = netdev_priv(ndev);
S
Sascha Hauer 已提交
1211 1212 1213 1214 1215 1216
	int i;
	struct sk_buff *skb;
	struct bufdesc	*bdp;

	bdp = fep->rx_bd_base;
	for (i = 0; i < RX_RING_SIZE; i++) {
1217
		skb = netdev_alloc_skb(ndev, FEC_ENET_RX_FRSIZE);
S
Sascha Hauer 已提交
1218
		if (!skb) {
1219
			fec_enet_free_buffers(ndev);
S
Sascha Hauer 已提交
1220 1221 1222 1223
			return -ENOMEM;
		}
		fep->rx_skbuff[i] = skb;

1224
		bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, skb->data,
S
Sascha Hauer 已提交
1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
				FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
		bdp->cbd_sc = BD_ENET_RX_EMPTY;
		bdp++;
	}

	/* Set the last buffer to wrap. */
	bdp--;
	bdp->cbd_sc |= BD_SC_WRAP;

	bdp = fep->tx_bd_base;
	for (i = 0; i < TX_RING_SIZE; i++) {
		fep->tx_bounce[i] = kmalloc(FEC_ENET_TX_FRSIZE, GFP_KERNEL);

		bdp->cbd_sc = 0;
		bdp->cbd_bufaddr = 0;
		bdp++;
	}

	/* Set the last buffer to wrap. */
	bdp--;
	bdp->cbd_sc |= BD_SC_WRAP;

	return 0;
}

L
Linus Torvalds 已提交
1250
static int
1251
fec_enet_open(struct net_device *ndev)
L
Linus Torvalds 已提交
1252
{
1253
	struct fec_enet_private *fep = netdev_priv(ndev);
S
Sascha Hauer 已提交
1254
	int ret;
L
Linus Torvalds 已提交
1255 1256 1257 1258 1259

	/* I should reset the ring buffers here, but I don't yet know
	 * a simple way to do that.
	 */

1260
	ret = fec_enet_alloc_buffers(ndev);
S
Sascha Hauer 已提交
1261 1262 1263
	if (ret)
		return ret;

1264
	/* Probe and connect to PHY when open the interface */
1265
	ret = fec_enet_mii_probe(ndev);
1266
	if (ret) {
1267
		fec_enet_free_buffers(ndev);
1268 1269
		return ret;
	}
1270
	phy_start(fep->phy_dev);
1271
	netif_start_queue(ndev);
L
Linus Torvalds 已提交
1272
	fep->opened = 1;
S
Sascha Hauer 已提交
1273
	return 0;
L
Linus Torvalds 已提交
1274 1275 1276
}

static int
1277
fec_enet_close(struct net_device *ndev)
L
Linus Torvalds 已提交
1278
{
1279
	struct fec_enet_private *fep = netdev_priv(ndev);
L
Linus Torvalds 已提交
1280

S
Sascha Hauer 已提交
1281
	/* Don't know what to do yet. */
L
Linus Torvalds 已提交
1282
	fep->opened = 0;
1283 1284
	netif_stop_queue(ndev);
	fec_stop(ndev);
L
Linus Torvalds 已提交
1285

1286 1287
	if (fep->phy_dev) {
		phy_stop(fep->phy_dev);
1288
		phy_disconnect(fep->phy_dev);
1289
	}
1290

1291
	fec_enet_free_buffers(ndev);
S
Sascha Hauer 已提交
1292

L
Linus Torvalds 已提交
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
	return 0;
}

/* Set or clear the multicast filter for this adaptor.
 * Skeleton taken from sunlance driver.
 * The CPM Ethernet implementation allows Multicast as well as individual
 * MAC address filtering.  Some of the drivers check to make sure it is
 * a group multicast address, and discard those that are not.  I guess I
 * will do the same for now, but just remove the test if you want
 * individual filtering as well (do the upper net layers want or support
 * this kind of feature?).
 */

#define HASH_BITS	6		/* #bits in hash */
#define CRC32_POLY	0xEDB88320

1309
static void set_multicast_list(struct net_device *ndev)
L
Linus Torvalds 已提交
1310
{
1311
	struct fec_enet_private *fep = netdev_priv(ndev);
1312
	struct netdev_hw_addr *ha;
1313
	unsigned int i, bit, data, crc, tmp;
L
Linus Torvalds 已提交
1314 1315
	unsigned char hash;

1316
	if (ndev->flags & IFF_PROMISC) {
S
Sascha Hauer 已提交
1317 1318 1319
		tmp = readl(fep->hwp + FEC_R_CNTRL);
		tmp |= 0x8;
		writel(tmp, fep->hwp + FEC_R_CNTRL);
1320 1321
		return;
	}
L
Linus Torvalds 已提交
1322

1323 1324 1325 1326
	tmp = readl(fep->hwp + FEC_R_CNTRL);
	tmp &= ~0x8;
	writel(tmp, fep->hwp + FEC_R_CNTRL);

1327
	if (ndev->flags & IFF_ALLMULTI) {
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
		/* Catch all multicast addresses, so set the
		 * filter to all 1's
		 */
		writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
		writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_LOW);

		return;
	}

	/* Clear filter and add the addresses in hash register
	 */
	writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
	writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);

1342
	netdev_for_each_mc_addr(ha, ndev) {
1343 1344 1345
		/* calculate crc32 value of mac address */
		crc = 0xffffffff;

1346
		for (i = 0; i < ndev->addr_len; i++) {
1347
			data = ha->addr[i];
1348 1349 1350
			for (bit = 0; bit < 8; bit++, data >>= 1) {
				crc = (crc >> 1) ^
				(((crc ^ data) & 1) ? CRC32_POLY : 0);
L
Linus Torvalds 已提交
1351 1352
			}
		}
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367

		/* only upper 6 bits (HASH_BITS) are used
		 * which point to specific bit in he hash registers
		 */
		hash = (crc >> (32 - HASH_BITS)) & 0x3f;

		if (hash > 31) {
			tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
			tmp |= 1 << (hash - 32);
			writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
		} else {
			tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_LOW);
			tmp |= 1 << hash;
			writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
		}
L
Linus Torvalds 已提交
1368 1369 1370
	}
}

S
Sascha Hauer 已提交
1371
/* Set a MAC change in hardware. */
S
Sascha Hauer 已提交
1372
static int
1373
fec_set_mac_address(struct net_device *ndev, void *p)
L
Linus Torvalds 已提交
1374
{
1375
	struct fec_enet_private *fep = netdev_priv(ndev);
S
Sascha Hauer 已提交
1376 1377 1378 1379 1380
	struct sockaddr *addr = p;

	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

1381
	memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
L
Linus Torvalds 已提交
1382

1383 1384
	writel(ndev->dev_addr[3] | (ndev->dev_addr[2] << 8) |
		(ndev->dev_addr[1] << 16) | (ndev->dev_addr[0] << 24),
S
Sascha Hauer 已提交
1385
		fep->hwp + FEC_ADDR_LOW);
1386
	writel((ndev->dev_addr[5] << 16) | (ndev->dev_addr[4] << 24),
1387
		fep->hwp + FEC_ADDR_HIGH);
S
Sascha Hauer 已提交
1388
	return 0;
L
Linus Torvalds 已提交
1389 1390
}

1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
#ifdef CONFIG_NET_POLL_CONTROLLER
/*
 * fec_poll_controller: FEC Poll controller function
 * @dev: The FEC network adapter
 *
 * Polled functionality used by netconsole and others in non interrupt mode
 *
 */
void fec_poll_controller(struct net_device *dev)
{
	int i;
	struct fec_enet_private *fep = netdev_priv(dev);

	for (i = 0; i < FEC_IRQ_NUM; i++) {
		if (fep->irq[i] > 0) {
			disable_irq(fep->irq[i]);
			fec_enet_interrupt(fep->irq[i], dev);
			enable_irq(fep->irq[i]);
		}
	}
}
#endif

S
Sascha Hauer 已提交
1414 1415 1416 1417
static const struct net_device_ops fec_netdev_ops = {
	.ndo_open		= fec_enet_open,
	.ndo_stop		= fec_enet_close,
	.ndo_start_xmit		= fec_enet_start_xmit,
1418
	.ndo_set_rx_mode	= set_multicast_list,
1419
	.ndo_change_mtu		= eth_change_mtu,
S
Sascha Hauer 已提交
1420 1421 1422
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_tx_timeout		= fec_timeout,
	.ndo_set_mac_address	= fec_set_mac_address,
1423
	.ndo_do_ioctl		= fec_enet_ioctl,
1424 1425 1426
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= fec_poll_controller,
#endif
S
Sascha Hauer 已提交
1427 1428
};

L
Linus Torvalds 已提交
1429 1430
 /*
  * XXX:  We need to clean up on failure exits here.
1431
  *
L
Linus Torvalds 已提交
1432
  */
1433
static int fec_enet_init(struct net_device *ndev)
L
Linus Torvalds 已提交
1434
{
1435
	struct fec_enet_private *fep = netdev_priv(ndev);
S
Sascha Hauer 已提交
1436
	struct bufdesc *cbd_base;
1437
	struct bufdesc *bdp;
S
Sascha Hauer 已提交
1438
	int i;
L
Linus Torvalds 已提交
1439

S
Sascha Hauer 已提交
1440 1441 1442 1443
	/* Allocate memory for buffer descriptors. */
	cbd_base = dma_alloc_coherent(NULL, PAGE_SIZE, &fep->bd_dma,
			GFP_KERNEL);
	if (!cbd_base) {
1444 1445 1446 1447
		printk("FEC: allocate descriptor memory failed?\n");
		return -ENOMEM;
	}

1448 1449
	spin_lock_init(&fep->hw_lock);

1450
	fep->netdev = ndev;
L
Linus Torvalds 已提交
1451

1452
	/* Get the Ethernet address */
1453
	fec_get_mac(ndev);
L
Linus Torvalds 已提交
1454

S
Sascha Hauer 已提交
1455
	/* Set receive and transmit descriptor base. */
L
Linus Torvalds 已提交
1456 1457 1458
	fep->rx_bd_base = cbd_base;
	fep->tx_bd_base = cbd_base + RX_RING_SIZE;

S
Sascha Hauer 已提交
1459
	/* The FEC Ethernet specific entries in the device structure */
1460 1461 1462
	ndev->watchdog_timeo = TX_TIMEOUT;
	ndev->netdev_ops = &fec_netdev_ops;
	ndev->ethtool_ops = &fec_enet_ethtool_ops;
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490

	/* Initialize the receive buffer descriptors. */
	bdp = fep->rx_bd_base;
	for (i = 0; i < RX_RING_SIZE; i++) {

		/* Initialize the BD for every fragment in the page. */
		bdp->cbd_sc = 0;
		bdp++;
	}

	/* Set the last buffer to wrap */
	bdp--;
	bdp->cbd_sc |= BD_SC_WRAP;

	/* ...and the same for transmit */
	bdp = fep->tx_bd_base;
	for (i = 0; i < TX_RING_SIZE; i++) {

		/* Initialize the BD for every fragment in the page. */
		bdp->cbd_sc = 0;
		bdp->cbd_bufaddr = 0;
		bdp++;
	}

	/* Set the last buffer to wrap */
	bdp--;
	bdp->cbd_sc |= BD_SC_WRAP;

1491
	fec_restart(ndev, 0);
L
Linus Torvalds 已提交
1492 1493 1494 1495

	return 0;
}

1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
#ifdef CONFIG_OF
static int __devinit fec_get_phy_mode_dt(struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.of_node;

	if (np)
		return of_get_phy_mode(np);

	return -ENODEV;
}

1507
static void __devinit fec_reset_phy(struct platform_device *pdev)
1508 1509 1510 1511 1512
{
	int err, phy_reset;
	struct device_node *np = pdev->dev.of_node;

	if (!np)
1513
		return;
1514 1515

	phy_reset = of_get_named_gpio(np, "phy-reset-gpios", 0);
1516 1517
	err = devm_gpio_request_one(&pdev->dev, phy_reset,
				    GPIOF_OUT_INIT_LOW, "phy-reset");
1518
	if (err) {
1519 1520
		pr_debug("FEC: failed to get gpio phy-reset: %d\n", err);
		return;
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
	}
	msleep(1);
	gpio_set_value(phy_reset, 1);
}
#else /* CONFIG_OF */
static inline int fec_get_phy_mode_dt(struct platform_device *pdev)
{
	return -ENODEV;
}

1531
static inline void fec_reset_phy(struct platform_device *pdev)
1532 1533 1534 1535 1536 1537 1538 1539
{
	/*
	 * In case of platform probe, the reset has been done
	 * by machine code.
	 */
}
#endif /* CONFIG_OF */

1540 1541 1542 1543
static int __devinit
fec_probe(struct platform_device *pdev)
{
	struct fec_enet_private *fep;
1544
	struct fec_platform_data *pdata;
1545 1546 1547
	struct net_device *ndev;
	int i, irq, ret = 0;
	struct resource *r;
1548
	const struct of_device_id *of_id;
S
Shawn Guo 已提交
1549
	static int dev_id;
S
Shawn Guo 已提交
1550
	struct pinctrl *pinctrl;
1551
	struct regulator *reg_phy;
1552 1553 1554 1555

	of_id = of_match_device(fec_dt_ids, &pdev->dev);
	if (of_id)
		pdev->id_entry = of_id->data;
1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!r)
		return -ENXIO;

	r = request_mem_region(r->start, resource_size(r), pdev->name);
	if (!r)
		return -EBUSY;

	/* Init network device */
	ndev = alloc_etherdev(sizeof(struct fec_enet_private));
1567 1568 1569 1570
	if (!ndev) {
		ret = -ENOMEM;
		goto failed_alloc_etherdev;
	}
1571 1572 1573 1574 1575 1576

	SET_NETDEV_DEV(ndev, &pdev->dev);

	/* setup board info structure */
	fep = netdev_priv(ndev);

1577
	fep->hwp = ioremap(r->start, resource_size(r));
1578
	fep->pdev = pdev;
S
Shawn Guo 已提交
1579
	fep->dev_id = dev_id++;
1580

1581
	if (!fep->hwp) {
1582 1583 1584 1585 1586 1587
		ret = -ENOMEM;
		goto failed_ioremap;
	}

	platform_set_drvdata(pdev, ndev);

1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
	ret = fec_get_phy_mode_dt(pdev);
	if (ret < 0) {
		pdata = pdev->dev.platform_data;
		if (pdata)
			fep->phy_interface = pdata->phy;
		else
			fep->phy_interface = PHY_INTERFACE_MODE_MII;
	} else {
		fep->phy_interface = ret;
	}

1599
	for (i = 0; i < FEC_IRQ_NUM; i++) {
1600
		irq = platform_get_irq(pdev, i);
1601 1602 1603 1604 1605 1606
		if (irq < 0) {
			if (i)
				break;
			ret = irq;
			goto failed_irq;
		}
1607 1608
		ret = request_irq(irq, fec_enet_interrupt, IRQF_DISABLED, pdev->name, ndev);
		if (ret) {
1609
			while (--i >= 0) {
1610 1611 1612 1613 1614 1615 1616
				irq = platform_get_irq(pdev, i);
				free_irq(irq, ndev);
			}
			goto failed_irq;
		}
	}

S
Shawn Guo 已提交
1617 1618 1619 1620 1621 1622
	pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
	if (IS_ERR(pinctrl)) {
		ret = PTR_ERR(pinctrl);
		goto failed_pin;
	}

1623 1624 1625
	fep->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
	if (IS_ERR(fep->clk_ipg)) {
		ret = PTR_ERR(fep->clk_ipg);
1626 1627
		goto failed_clk;
	}
1628 1629 1630 1631 1632 1633 1634 1635 1636

	fep->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
	if (IS_ERR(fep->clk_ahb)) {
		ret = PTR_ERR(fep->clk_ahb);
		goto failed_clk;
	}

	clk_prepare_enable(fep->clk_ahb);
	clk_prepare_enable(fep->clk_ipg);
1637

1638 1639 1640 1641 1642 1643 1644 1645 1646 1647
	reg_phy = devm_regulator_get(&pdev->dev, "phy");
	if (!IS_ERR(reg_phy)) {
		ret = regulator_enable(reg_phy);
		if (ret) {
			dev_err(&pdev->dev,
				"Failed to enable phy regulator: %d\n", ret);
			goto failed_regulator;
		}
	}

1648 1649
	fec_reset_phy(pdev);

1650
	ret = fec_enet_init(ndev);
1651 1652 1653
	if (ret)
		goto failed_init;

1654 1655 1656 1657
	ret = fec_enet_mii_init(pdev);
	if (ret)
		goto failed_mii_init;

1658 1659 1660
	/* Carrier starts down, phylib will bring it up */
	netif_carrier_off(ndev);

1661 1662 1663 1664 1665 1666 1667
	ret = register_netdev(ndev);
	if (ret)
		goto failed_register;

	return 0;

failed_register:
1668 1669
	fec_enet_mii_remove(fep);
failed_mii_init:
1670
failed_init:
1671
failed_regulator:
1672 1673
	clk_disable_unprepare(fep->clk_ahb);
	clk_disable_unprepare(fep->clk_ipg);
S
Shawn Guo 已提交
1674
failed_pin:
1675
failed_clk:
1676
	for (i = 0; i < FEC_IRQ_NUM; i++) {
1677 1678 1679 1680 1681
		irq = platform_get_irq(pdev, i);
		if (irq > 0)
			free_irq(irq, ndev);
	}
failed_irq:
1682
	iounmap(fep->hwp);
1683 1684
failed_ioremap:
	free_netdev(ndev);
1685 1686
failed_alloc_etherdev:
	release_mem_region(r->start, resource_size(r));
1687 1688 1689 1690 1691 1692 1693 1694 1695

	return ret;
}

static int __devexit
fec_drv_remove(struct platform_device *pdev)
{
	struct net_device *ndev = platform_get_drvdata(pdev);
	struct fec_enet_private *fep = netdev_priv(ndev);
1696
	struct resource *r;
L
Lothar Waßmann 已提交
1697
	int i;
1698

L
Lothar Waßmann 已提交
1699
	unregister_netdev(ndev);
1700
	fec_enet_mii_remove(fep);
L
Lothar Waßmann 已提交
1701 1702 1703 1704 1705
	for (i = 0; i < FEC_IRQ_NUM; i++) {
		int irq = platform_get_irq(pdev, i);
		if (irq > 0)
			free_irq(irq, ndev);
	}
1706 1707
	clk_disable_unprepare(fep->clk_ahb);
	clk_disable_unprepare(fep->clk_ipg);
1708
	iounmap(fep->hwp);
1709
	free_netdev(ndev);
1710 1711 1712 1713 1714

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	BUG_ON(!r);
	release_mem_region(r->start, resource_size(r));

1715 1716
	platform_set_drvdata(pdev, NULL);

1717 1718 1719
	return 0;
}

1720
#ifdef CONFIG_PM
1721
static int
E
Eric Benard 已提交
1722
fec_suspend(struct device *dev)
1723
{
E
Eric Benard 已提交
1724
	struct net_device *ndev = dev_get_drvdata(dev);
1725
	struct fec_enet_private *fep = netdev_priv(ndev);
1726

1727 1728 1729
	if (netif_running(ndev)) {
		fec_stop(ndev);
		netif_device_detach(ndev);
1730
	}
1731 1732
	clk_disable_unprepare(fep->clk_ahb);
	clk_disable_unprepare(fep->clk_ipg);
1733

1734 1735 1736 1737
	return 0;
}

static int
E
Eric Benard 已提交
1738
fec_resume(struct device *dev)
1739
{
E
Eric Benard 已提交
1740
	struct net_device *ndev = dev_get_drvdata(dev);
1741
	struct fec_enet_private *fep = netdev_priv(ndev);
1742

1743 1744
	clk_prepare_enable(fep->clk_ahb);
	clk_prepare_enable(fep->clk_ipg);
1745 1746 1747
	if (netif_running(ndev)) {
		fec_restart(ndev, fep->full_duplex);
		netif_device_attach(ndev);
1748
	}
1749

1750 1751 1752
	return 0;
}

1753 1754 1755 1756 1757 1758 1759 1760
static const struct dev_pm_ops fec_pm_ops = {
	.suspend	= fec_suspend,
	.resume		= fec_resume,
	.freeze		= fec_suspend,
	.thaw		= fec_resume,
	.poweroff	= fec_suspend,
	.restore	= fec_resume,
};
E
Eric Benard 已提交
1761
#endif
1762

1763 1764
static struct platform_driver fec_driver = {
	.driver	= {
1765
		.name	= DRIVER_NAME,
E
Eric Benard 已提交
1766 1767 1768 1769
		.owner	= THIS_MODULE,
#ifdef CONFIG_PM
		.pm	= &fec_pm_ops,
#endif
1770
		.of_match_table = fec_dt_ids,
1771
	},
1772
	.id_table = fec_devtype,
E
Eric Benard 已提交
1773 1774
	.probe	= fec_probe,
	.remove	= __devexit_p(fec_drv_remove),
1775 1776
};

1777
module_platform_driver(fec_driver);
L
Linus Torvalds 已提交
1778 1779

MODULE_LICENSE("GPL");