blob: 65ee506f9eb79ec117c65f648d25c24814892003 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
3 * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
4 *
Greg Ungerer7dd6a2a2005-09-12 11:18:10 +10005 * Right now, I am very wasteful with the buffers. I allocate memory
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * pages and then divide them into 2K frame buffers. This way I know I
7 * have buffers large enough to hold one frame within one buffer descriptor.
8 * Once I get this working, I will use 64 or 128 byte CPM buffers, which
9 * will be much more memory efficient and will easily handle lots of
10 * small packets.
11 *
12 * Much better multiple PHY support by Magnus Damm.
13 * Copyright (c) 2000 Ericsson Radio Systems AB.
14 *
Greg Ungerer562d2f82005-11-07 14:09:50 +100015 * Support for FEC controller of ColdFire processors.
16 * Copyright (c) 2001-2005 Greg Ungerer (gerg@snapgear.com)
Greg Ungerer7dd6a2a2005-09-12 11:18:10 +100017 *
18 * Bug fixes and cleanup by Philippe De Muyter (phdm@macqel.be)
Philippe De Muyter677177c2006-06-27 13:05:33 +100019 * Copyright (c) 2004-2006 Macq Electronique SA.
Shawn Guob5680e02011-01-05 21:13:13 +000020 *
Shawn Guo230dec62011-09-23 02:12:48 +000021 * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 */
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/module.h>
25#include <linux/kernel.h>
26#include <linux/string.h>
27#include <linux/ptrace.h>
28#include <linux/errno.h>
29#include <linux/ioport.h>
30#include <linux/slab.h>
31#include <linux/interrupt.h>
32#include <linux/pci.h>
33#include <linux/init.h>
34#include <linux/delay.h>
35#include <linux/netdevice.h>
36#include <linux/etherdevice.h>
37#include <linux/skbuff.h>
38#include <linux/spinlock.h>
39#include <linux/workqueue.h>
40#include <linux/bitops.h>
Sascha Hauer6f501b12009-01-28 23:03:05 +000041#include <linux/io.h>
42#include <linux/irq.h>
Sascha Hauer196719e2009-01-28 23:03:10 +000043#include <linux/clk.h>
Sascha Haueread73182009-01-28 23:03:11 +000044#include <linux/platform_device.h>
Bryan Wue6b043d2010-03-31 02:10:44 +000045#include <linux/phy.h>
Baruch Siach5eb32bd2010-05-24 00:36:13 -070046#include <linux/fec.h>
Shawn Guoca2cc332011-06-25 02:04:35 +080047#include <linux/of.h>
48#include <linux/of_device.h>
49#include <linux/of_gpio.h>
50#include <linux/of_net.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Greg Ungerer080853a2007-07-30 16:28:46 +100052#include <asm/cacheflush.h>
Sascha Hauer196719e2009-01-28 23:03:10 +000053
Shawn Guob5680e02011-01-05 21:13:13 +000054#ifndef CONFIG_ARM
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include <asm/coldfire.h>
56#include <asm/mcfsim.h>
Sascha Hauer196719e2009-01-28 23:03:10 +000057#endif
Sascha Hauer6f501b12009-01-28 23:03:05 +000058
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include "fec.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Uwe Kleine-König085e79e2011-01-17 09:52:18 +010061#if defined(CONFIG_ARM)
Sascha Hauer196719e2009-01-28 23:03:10 +000062#define FEC_ALIGNMENT 0xf
63#else
64#define FEC_ALIGNMENT 0x3
65#endif
66
Shawn Guob5680e02011-01-05 21:13:13 +000067#define DRIVER_NAME "fec"
68
69/* Controller is ENET-MAC */
70#define FEC_QUIRK_ENET_MAC (1 << 0)
71/* Controller needs driver to swap frame */
72#define FEC_QUIRK_SWAP_FRAME (1 << 1)
Shawn Guo0ca1e292011-07-01 18:11:22 +080073/* Controller uses gasket */
74#define FEC_QUIRK_USE_GASKET (1 << 2)
Shawn Guo230dec62011-09-23 02:12:48 +000075/* Controller has GBIT support */
76#define FEC_QUIRK_HAS_GBIT (1 << 3)
Shawn Guob5680e02011-01-05 21:13:13 +000077
78static struct platform_device_id fec_devtype[] = {
79 {
Shawn Guo0ca1e292011-07-01 18:11:22 +080080 /* keep it for coldfire */
Shawn Guob5680e02011-01-05 21:13:13 +000081 .name = DRIVER_NAME,
82 .driver_data = 0,
83 }, {
Shawn Guo0ca1e292011-07-01 18:11:22 +080084 .name = "imx25-fec",
85 .driver_data = FEC_QUIRK_USE_GASKET,
86 }, {
87 .name = "imx27-fec",
88 .driver_data = 0,
89 }, {
Shawn Guob5680e02011-01-05 21:13:13 +000090 .name = "imx28-fec",
91 .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME,
Shawn Guo0ca1e292011-07-01 18:11:22 +080092 }, {
Shawn Guo230dec62011-09-23 02:12:48 +000093 .name = "imx6q-fec",
94 .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT,
95 }, {
Shawn Guo0ca1e292011-07-01 18:11:22 +080096 /* sentinel */
97 }
Shawn Guob5680e02011-01-05 21:13:13 +000098};
Shawn Guo0ca1e292011-07-01 18:11:22 +080099MODULE_DEVICE_TABLE(platform, fec_devtype);
Shawn Guob5680e02011-01-05 21:13:13 +0000100
Shawn Guoca2cc332011-06-25 02:04:35 +0800101enum imx_fec_type {
Lothar Waßmanna7dd3212011-12-07 21:59:25 +0000102 IMX25_FEC = 1, /* runs on i.mx25/50/53 */
Shawn Guoca2cc332011-06-25 02:04:35 +0800103 IMX27_FEC, /* runs on i.mx27/35/51 */
104 IMX28_FEC,
Shawn Guo230dec62011-09-23 02:12:48 +0000105 IMX6Q_FEC,
Shawn Guoca2cc332011-06-25 02:04:35 +0800106};
107
108static const struct of_device_id fec_dt_ids[] = {
109 { .compatible = "fsl,imx25-fec", .data = &fec_devtype[IMX25_FEC], },
110 { .compatible = "fsl,imx27-fec", .data = &fec_devtype[IMX27_FEC], },
111 { .compatible = "fsl,imx28-fec", .data = &fec_devtype[IMX28_FEC], },
Shawn Guo230dec62011-09-23 02:12:48 +0000112 { .compatible = "fsl,imx6q-fec", .data = &fec_devtype[IMX6Q_FEC], },
Shawn Guoca2cc332011-06-25 02:04:35 +0800113 { /* sentinel */ }
114};
115MODULE_DEVICE_TABLE(of, fec_dt_ids);
116
Shawn Guo49da97d2011-01-05 21:13:11 +0000117static unsigned char macaddr[ETH_ALEN];
118module_param_array(macaddr, byte, NULL, 0);
119MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
120
Greg Ungerer87f4abb2008-06-06 15:55:36 +1000121#if defined(CONFIG_M5272)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122/*
123 * Some hardware gets it MAC address out of local flash memory.
124 * if this is non-zero then assume it is the address to get MAC from.
125 */
126#if defined(CONFIG_NETtel)
127#define FEC_FLASHMAC 0xf0006006
128#elif defined(CONFIG_GILBARCONAP) || defined(CONFIG_SCALES)
129#define FEC_FLASHMAC 0xf0006000
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130#elif defined(CONFIG_CANCam)
131#define FEC_FLASHMAC 0xf0020000
Greg Ungerer7dd6a2a2005-09-12 11:18:10 +1000132#elif defined (CONFIG_M5272C3)
133#define FEC_FLASHMAC (0xffe04000 + 4)
134#elif defined(CONFIG_MOD5272)
Lothar Waßmanna7dd3212011-12-07 21:59:25 +0000135#define FEC_FLASHMAC 0xffc0406b
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136#else
137#define FEC_FLASHMAC 0
138#endif
Greg Ungerer43be6362009-02-26 22:42:51 -0800139#endif /* CONFIG_M5272 */
Sascha Haueread73182009-01-28 23:03:11 +0000140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141/* The number of Tx and Rx buffers. These are allocated from the page
142 * pool. The code may assume these are power of two, so it it best
143 * to keep them that size.
144 * We don't need to allocate pages for the transmitter. We just use
145 * the skbuffer directly.
146 */
147#define FEC_ENET_RX_PAGES 8
148#define FEC_ENET_RX_FRSIZE 2048
149#define FEC_ENET_RX_FRPPG (PAGE_SIZE / FEC_ENET_RX_FRSIZE)
150#define RX_RING_SIZE (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
151#define FEC_ENET_TX_FRSIZE 2048
152#define FEC_ENET_TX_FRPPG (PAGE_SIZE / FEC_ENET_TX_FRSIZE)
153#define TX_RING_SIZE 16 /* Must be power of two */
154#define TX_RING_MOD_MASK 15 /* for this to work */
155
Greg Ungerer562d2f82005-11-07 14:09:50 +1000156#if (((RX_RING_SIZE + TX_RING_SIZE) * 8) > PAGE_SIZE)
Matt Waddel6b265292006-06-27 13:10:56 +1000157#error "FEC: descriptor ring size constants too large"
Greg Ungerer562d2f82005-11-07 14:09:50 +1000158#endif
159
Sascha Hauer22f6b862009-04-15 01:32:18 +0000160/* Interrupt events/masks. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161#define FEC_ENET_HBERR ((uint)0x80000000) /* Heartbeat error */
162#define FEC_ENET_BABR ((uint)0x40000000) /* Babbling receiver */
163#define FEC_ENET_BABT ((uint)0x20000000) /* Babbling transmitter */
164#define FEC_ENET_GRA ((uint)0x10000000) /* Graceful stop complete */
165#define FEC_ENET_TXF ((uint)0x08000000) /* Full frame transmitted */
166#define FEC_ENET_TXB ((uint)0x04000000) /* A buffer was transmitted */
167#define FEC_ENET_RXF ((uint)0x02000000) /* Full frame received */
168#define FEC_ENET_RXB ((uint)0x01000000) /* A buffer was received */
169#define FEC_ENET_MII ((uint)0x00800000) /* MII interrupt */
170#define FEC_ENET_EBERR ((uint)0x00400000) /* SDMA bus error */
171
Wolfram Sang4bee1f92010-07-21 02:51:13 +0000172#define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII)
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174/* The FEC stores dest/src/type, data, and checksum for receive packets.
175 */
176#define PKT_MAXBUF_SIZE 1518
177#define PKT_MINBUF_SIZE 64
178#define PKT_MAXBLR_SIZE 1520
179
Xiao Jiangc7c83d12011-09-29 02:15:56 +0000180/* This device has up to three irqs on some platforms */
181#define FEC_IRQ_NUM 3
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
183/*
Matt Waddel6b265292006-06-27 13:10:56 +1000184 * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 * size bits. Other FEC hardware does not, so we need to take that into
186 * account when setting it.
187 */
Greg Ungerer562d2f82005-11-07 14:09:50 +1000188#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
Uwe Kleine-König085e79e2011-01-17 09:52:18 +0100189 defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190#define OPT_FRAME_SIZE (PKT_MAXBUF_SIZE << 16)
191#else
192#define OPT_FRAME_SIZE 0
193#endif
194
195/* The FEC buffer descriptors track the ring buffers. The rx_bd_base and
196 * tx_bd_base always point to the base of the buffer descriptors. The
197 * cur_rx and cur_tx point to the currently available buffer.
198 * The dirty_tx tracks the current buffer that is being sent by the
199 * controller. The cur_tx and dirty_tx are equal under both completely
200 * empty and completely full conditions. The empty/ready indicator in
201 * the buffer descriptor determines the actual condition.
202 */
203struct fec_enet_private {
204 /* Hardware registers of the FEC device */
Sascha Hauerf44d6302009-04-15 03:11:30 +0000205 void __iomem *hwp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Greg Ungerercb84d6e2007-07-30 16:29:09 +1000207 struct net_device *netdev;
208
Sascha Haueread73182009-01-28 23:03:11 +0000209 struct clk *clk;
210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 /* The saved address of a sent-in-place packet/buffer, for skfree(). */
212 unsigned char *tx_bounce[TX_RING_SIZE];
213 struct sk_buff* tx_skbuff[TX_RING_SIZE];
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000214 struct sk_buff* rx_skbuff[RX_RING_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 ushort skb_cur;
216 ushort skb_dirty;
217
Sascha Hauer22f6b862009-04-15 01:32:18 +0000218 /* CPM dual port RAM relative addresses */
Sascha Hauer4661e752009-01-28 23:03:07 +0000219 dma_addr_t bd_dma;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000220 /* Address of Rx and Tx buffers */
Sascha Hauer2e285322009-04-15 01:32:16 +0000221 struct bufdesc *rx_bd_base;
222 struct bufdesc *tx_bd_base;
223 /* The next free ring entry */
Uwe Kleine-Königdb8880b2011-01-19 20:26:39 +0100224 struct bufdesc *cur_rx, *cur_tx;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000225 /* The ring entries to be free()ed */
Sascha Hauer2e285322009-04-15 01:32:16 +0000226 struct bufdesc *dirty_tx;
227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 uint tx_full;
Sebastian Siewior3b2b74c2008-05-01 14:08:12 +1000229 /* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
230 spinlock_t hw_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Uwe Kleine-Königdb8880b2011-01-19 20:26:39 +0100232 struct platform_device *pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 int opened;
Bryan Wue6b043d2010-03-31 02:10:44 +0000235
236 /* Phylib and MDIO interface */
Uwe Kleine-Königdb8880b2011-01-19 20:26:39 +0100237 struct mii_bus *mii_bus;
238 struct phy_device *phy_dev;
239 int mii_timeout;
240 uint phy_speed;
Baruch Siach5eb32bd2010-05-24 00:36:13 -0700241 phy_interface_t phy_interface;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 int link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 int full_duplex;
Baruch Siach97b72e42010-07-11 21:12:51 +0000244 struct completion mdio_done;
Xiao Jiang7f5c6ad2011-09-29 02:15:57 +0000245 int irq[FEC_IRQ_NUM];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246};
247
Bryan Wue6b043d2010-03-31 02:10:44 +0000248/* FEC MII MMFR bits definition */
249#define FEC_MMFR_ST (1 << 30)
250#define FEC_MMFR_OP_READ (2 << 28)
251#define FEC_MMFR_OP_WRITE (1 << 28)
252#define FEC_MMFR_PA(v) ((v & 0x1f) << 23)
253#define FEC_MMFR_RA(v) ((v & 0x1f) << 18)
254#define FEC_MMFR_TA (2 << 16)
255#define FEC_MMFR_DATA(v) (v & 0xffff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Baruch Siach97b72e42010-07-11 21:12:51 +0000257#define FEC_MII_TIMEOUT 1000 /* us */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Sascha Hauer22f6b862009-04-15 01:32:18 +0000259/* Transmitter timeout */
260#define TX_TIMEOUT (2 * HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
Shawn Guob5680e02011-01-05 21:13:13 +0000262static void *swap_buffer(void *bufaddr, int len)
263{
264 int i;
265 unsigned int *buf = bufaddr;
266
267 for (i = 0; i < (len + 3) / 4; i++, buf++)
268 *buf = cpu_to_be32(*buf);
269
270 return bufaddr;
271}
272
Denis Kirjanovc7621cb2010-06-02 09:15:47 +0000273static netdev_tx_t
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100274fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100276 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guob5680e02011-01-05 21:13:13 +0000277 const struct platform_device_id *id_entry =
278 platform_get_device_id(fep->pdev);
Sascha Hauer2e285322009-04-15 01:32:16 +0000279 struct bufdesc *bdp;
Greg Ungerer9555b312009-08-06 17:58:18 +0000280 void *bufaddr;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000281 unsigned short status;
Sebastian Siewior3b2b74c2008-05-01 14:08:12 +1000282 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 if (!fep->link) {
285 /* Link is down or autonegotiation is in progress. */
Patrick McHardy5b548142009-06-12 06:22:29 +0000286 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 }
288
Sebastian Siewior3b2b74c2008-05-01 14:08:12 +1000289 spin_lock_irqsave(&fep->hw_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 /* Fill in a Tx ring entry */
291 bdp = fep->cur_tx;
292
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000293 status = bdp->cbd_sc;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000294
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000295 if (status & BD_ENET_TX_READY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 /* Ooops. All transmit buffers are full. Bail out.
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100297 * This should not happen, since ndev->tbusy should be set.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100299 printk("%s: tx queue full!.\n", ndev->name);
Sebastian Siewior3b2b74c2008-05-01 14:08:12 +1000300 spin_unlock_irqrestore(&fep->hw_lock, flags);
Patrick McHardy5b548142009-06-12 06:22:29 +0000301 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Sascha Hauer22f6b862009-04-15 01:32:18 +0000304 /* Clear all of the status flags */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000305 status &= ~BD_ENET_TX_STATS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Sascha Hauer22f6b862009-04-15 01:32:18 +0000307 /* Set buffer length and buffer pointer */
Greg Ungerer9555b312009-08-06 17:58:18 +0000308 bufaddr = skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 bdp->cbd_datlen = skb->len;
310
311 /*
Sascha Hauer22f6b862009-04-15 01:32:18 +0000312 * On some FEC implementations data must be aligned on
313 * 4-byte boundaries. Use bounce buffers to copy data
314 * and get it aligned. Ugh.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 */
Greg Ungerer9555b312009-08-06 17:58:18 +0000316 if (((unsigned long) bufaddr) & FEC_ALIGNMENT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 unsigned int index;
318 index = bdp - fep->tx_bd_base;
Uwe Kleine-König8a73b0b2011-01-13 21:34:31 +0100319 memcpy(fep->tx_bounce[index], skb->data, skb->len);
Greg Ungerer9555b312009-08-06 17:58:18 +0000320 bufaddr = fep->tx_bounce[index];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 }
322
Shawn Guob5680e02011-01-05 21:13:13 +0000323 /*
324 * Some design made an incorrect assumption on endian mode of
325 * the system that it's running on. As the result, driver has to
326 * swap every frame going to and coming from the controller.
327 */
328 if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
329 swap_buffer(bufaddr, skb->len);
330
Sascha Hauer22f6b862009-04-15 01:32:18 +0000331 /* Save skb pointer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 fep->tx_skbuff[fep->skb_cur] = skb;
333
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100334 ndev->stats.tx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 fep->skb_cur = (fep->skb_cur+1) & TX_RING_MOD_MASK;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400336
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 /* Push the data cache so the CPM does not get stale memory
338 * data.
339 */
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +0100340 bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, bufaddr,
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000341 FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000343 /* Send it on its way. Tell FEC it's ready, interrupt when done,
344 * it's the last BD of the frame, and to put the CRC on the end.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000346 status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 | BD_ENET_TX_LAST | BD_ENET_TX_TC);
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000348 bdp->cbd_sc = status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 /* Trigger transmission start */
Sascha Hauerf44d6302009-04-15 03:11:30 +0000351 writel(0, fep->hwp + FEC_X_DES_ACTIVE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Sascha Hauer22f6b862009-04-15 01:32:18 +0000353 /* If this was the last BD in the ring, start at the beginning again. */
354 if (status & BD_ENET_TX_WRAP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 bdp = fep->tx_bd_base;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000356 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 bdp++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
359 if (bdp == fep->dirty_tx) {
360 fep->tx_full = 1;
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100361 netif_stop_queue(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 }
363
Sascha Hauer2e285322009-04-15 01:32:16 +0000364 fep->cur_tx = bdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Richard Cochran18a03b92011-06-12 02:18:59 +0000366 skb_tx_timestamp(skb);
367
Richard Cochrana0087a32011-06-19 03:31:40 +0000368 spin_unlock_irqrestore(&fep->hw_lock, flags);
369
Patrick McHardy6ed10652009-06-23 06:03:08 +0000370 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372
Uwe Kleine-König45993652011-01-19 20:47:04 +0100373/* This function is called to start or restart the FEC during a link
374 * change. This only happens when switching between half and full
375 * duplex.
376 */
377static void
378fec_restart(struct net_device *ndev, int duplex)
379{
380 struct fec_enet_private *fep = netdev_priv(ndev);
381 const struct platform_device_id *id_entry =
382 platform_get_device_id(fep->pdev);
383 int i;
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100384 u32 temp_mac[2];
385 u32 rcntl = OPT_FRAME_SIZE | 0x04;
Shawn Guo230dec62011-09-23 02:12:48 +0000386 u32 ecntl = 0x2; /* ETHEREN */
Uwe Kleine-König45993652011-01-19 20:47:04 +0100387
388 /* Whack a reset. We should wait for this. */
389 writel(1, fep->hwp + FEC_ECNTRL);
390 udelay(10);
391
392 /*
393 * enet-mac reset will reset mac address registers too,
394 * so need to reconfigure it.
395 */
396 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
397 memcpy(&temp_mac, ndev->dev_addr, ETH_ALEN);
398 writel(cpu_to_be32(temp_mac[0]), fep->hwp + FEC_ADDR_LOW);
399 writel(cpu_to_be32(temp_mac[1]), fep->hwp + FEC_ADDR_HIGH);
400 }
401
402 /* Clear any outstanding interrupt. */
403 writel(0xffc00000, fep->hwp + FEC_IEVENT);
404
405 /* Reset all multicast. */
406 writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
407 writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
408#ifndef CONFIG_M5272
409 writel(0, fep->hwp + FEC_HASH_TABLE_HIGH);
410 writel(0, fep->hwp + FEC_HASH_TABLE_LOW);
411#endif
412
413 /* Set maximum receive buffer size. */
414 writel(PKT_MAXBLR_SIZE, fep->hwp + FEC_R_BUFF_SIZE);
415
416 /* Set receive and transmit descriptor base. */
417 writel(fep->bd_dma, fep->hwp + FEC_R_DES_START);
418 writel((unsigned long)fep->bd_dma + sizeof(struct bufdesc) * RX_RING_SIZE,
419 fep->hwp + FEC_X_DES_START);
420
421 fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
422 fep->cur_rx = fep->rx_bd_base;
423
424 /* Reset SKB transmit buffers. */
425 fep->skb_cur = fep->skb_dirty = 0;
426 for (i = 0; i <= TX_RING_MOD_MASK; i++) {
427 if (fep->tx_skbuff[i]) {
428 dev_kfree_skb_any(fep->tx_skbuff[i]);
429 fep->tx_skbuff[i] = NULL;
430 }
431 }
432
433 /* Enable MII mode */
434 if (duplex) {
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100435 /* FD enable */
Uwe Kleine-König45993652011-01-19 20:47:04 +0100436 writel(0x04, fep->hwp + FEC_X_CNTRL);
437 } else {
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100438 /* No Rcv on Xmit */
439 rcntl |= 0x02;
Uwe Kleine-König45993652011-01-19 20:47:04 +0100440 writel(0x0, fep->hwp + FEC_X_CNTRL);
441 }
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100442
Uwe Kleine-König45993652011-01-19 20:47:04 +0100443 fep->full_duplex = duplex;
444
445 /* Set MII speed */
446 writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
447
448 /*
449 * The phy interface and speed need to get configured
450 * differently on enet-mac.
451 */
452 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100453 /* Enable flow control and length check */
454 rcntl |= 0x40000000 | 0x00000020;
Uwe Kleine-König45993652011-01-19 20:47:04 +0100455
Shawn Guo230dec62011-09-23 02:12:48 +0000456 /* RGMII, RMII or MII */
457 if (fep->phy_interface == PHY_INTERFACE_MODE_RGMII)
458 rcntl |= (1 << 6);
459 else if (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100460 rcntl |= (1 << 8);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100461 else
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100462 rcntl &= ~(1 << 8);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100463
Shawn Guo230dec62011-09-23 02:12:48 +0000464 /* 1G, 100M or 10M */
465 if (fep->phy_dev) {
466 if (fep->phy_dev->speed == SPEED_1000)
467 ecntl |= (1 << 5);
468 else if (fep->phy_dev->speed == SPEED_100)
469 rcntl &= ~(1 << 9);
470 else
471 rcntl |= (1 << 9);
472 }
Uwe Kleine-König45993652011-01-19 20:47:04 +0100473 } else {
474#ifdef FEC_MIIGSK_ENR
Shawn Guo0ca1e292011-07-01 18:11:22 +0800475 if (id_entry->driver_data & FEC_QUIRK_USE_GASKET) {
Uwe Kleine-König45993652011-01-19 20:47:04 +0100476 /* disable the gasket and wait */
477 writel(0, fep->hwp + FEC_MIIGSK_ENR);
478 while (readl(fep->hwp + FEC_MIIGSK_ENR) & 4)
479 udelay(1);
480
481 /*
482 * configure the gasket:
483 * RMII, 50 MHz, no loopback, no echo
Shawn Guo0ca1e292011-07-01 18:11:22 +0800484 * MII, 25 MHz, no loopback, no echo
Uwe Kleine-König45993652011-01-19 20:47:04 +0100485 */
Shawn Guo0ca1e292011-07-01 18:11:22 +0800486 writel((fep->phy_interface == PHY_INTERFACE_MODE_RMII) ?
487 1 : 0, fep->hwp + FEC_MIIGSK_CFGR);
488
Uwe Kleine-König45993652011-01-19 20:47:04 +0100489
490 /* re-enable the gasket */
491 writel(2, fep->hwp + FEC_MIIGSK_ENR);
492 }
493#endif
494 }
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100495 writel(rcntl, fep->hwp + FEC_R_CNTRL);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100496
Shawn Guo230dec62011-09-23 02:12:48 +0000497 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
498 /* enable ENET endian swap */
499 ecntl |= (1 << 8);
500 /* enable ENET store and forward mode */
501 writel(1 << 8, fep->hwp + FEC_X_WMRK);
502 }
503
Uwe Kleine-König45993652011-01-19 20:47:04 +0100504 /* And last, enable the transmit and receive processing */
Shawn Guo230dec62011-09-23 02:12:48 +0000505 writel(ecntl, fep->hwp + FEC_ECNTRL);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100506 writel(0, fep->hwp + FEC_R_DES_ACTIVE);
507
508 /* Enable interrupts we wish to service */
509 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
510}
511
512static void
513fec_stop(struct net_device *ndev)
514{
515 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guo230dec62011-09-23 02:12:48 +0000516 const struct platform_device_id *id_entry =
517 platform_get_device_id(fep->pdev);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100518
519 /* We cannot expect a graceful transmit stop without link !!! */
520 if (fep->link) {
521 writel(1, fep->hwp + FEC_X_CNTRL); /* Graceful transmit stop */
522 udelay(10);
523 if (!(readl(fep->hwp + FEC_IEVENT) & FEC_ENET_GRA))
524 printk("fec_stop : Graceful transmit stop did not complete !\n");
525 }
526
527 /* Whack a reset. We should wait for this. */
528 writel(1, fep->hwp + FEC_ECNTRL);
529 udelay(10);
530 writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
531 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
Shawn Guo230dec62011-09-23 02:12:48 +0000532
533 /* We have to keep ENET enabled to have MII interrupt stay working */
534 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
535 writel(2, fep->hwp + FEC_ECNTRL);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100536}
537
538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539static void
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100540fec_timeout(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100542 struct fec_enet_private *fep = netdev_priv(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100544 ndev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100546 fec_restart(ndev, fep->full_duplex);
547 netif_wake_queue(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548}
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550static void
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100551fec_enet_tx(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552{
553 struct fec_enet_private *fep;
Sascha Hauer2e285322009-04-15 01:32:16 +0000554 struct bufdesc *bdp;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000555 unsigned short status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 struct sk_buff *skb;
557
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100558 fep = netdev_priv(ndev);
Uwe Kleine-König81538e72009-09-01 23:14:16 +0000559 spin_lock(&fep->hw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 bdp = fep->dirty_tx;
561
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000562 while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000563 if (bdp == fep->cur_tx && fep->tx_full == 0)
564 break;
565
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +0100566 dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
567 FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000568 bdp->cbd_bufaddr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 skb = fep->tx_skbuff[fep->skb_dirty];
571 /* Check for errors. */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000572 if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 BD_ENET_TX_RL | BD_ENET_TX_UN |
574 BD_ENET_TX_CSL)) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100575 ndev->stats.tx_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000576 if (status & BD_ENET_TX_HB) /* No heartbeat */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100577 ndev->stats.tx_heartbeat_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000578 if (status & BD_ENET_TX_LC) /* Late collision */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100579 ndev->stats.tx_window_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000580 if (status & BD_ENET_TX_RL) /* Retrans limit */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100581 ndev->stats.tx_aborted_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000582 if (status & BD_ENET_TX_UN) /* Underrun */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100583 ndev->stats.tx_fifo_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000584 if (status & BD_ENET_TX_CSL) /* Carrier lost */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100585 ndev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 } else {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100587 ndev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 }
589
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000590 if (status & BD_ENET_TX_READY)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 printk("HEY! Enet xmit interrupt and TX_READY.\n");
Sascha Hauer22f6b862009-04-15 01:32:18 +0000592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 /* Deferred means some collisions occurred during transmit,
594 * but we eventually sent the packet OK.
595 */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000596 if (status & BD_ENET_TX_DEF)
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100597 ndev->stats.collisions++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400598
Sascha Hauer22f6b862009-04-15 01:32:18 +0000599 /* Free the sk buffer associated with this last transmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 dev_kfree_skb_any(skb);
601 fep->tx_skbuff[fep->skb_dirty] = NULL;
602 fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400603
Sascha Hauer22f6b862009-04-15 01:32:18 +0000604 /* Update pointer to next buffer descriptor to be transmitted */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000605 if (status & BD_ENET_TX_WRAP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 bdp = fep->tx_bd_base;
607 else
608 bdp++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400609
Sascha Hauer22f6b862009-04-15 01:32:18 +0000610 /* Since we have freed up a buffer, the ring is no longer full
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 */
612 if (fep->tx_full) {
613 fep->tx_full = 0;
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100614 if (netif_queue_stopped(ndev))
615 netif_wake_queue(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 }
617 }
Sascha Hauer2e285322009-04-15 01:32:16 +0000618 fep->dirty_tx = bdp;
Uwe Kleine-König81538e72009-09-01 23:14:16 +0000619 spin_unlock(&fep->hw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620}
621
622
623/* During a receive, the cur_rx points to the current incoming buffer.
624 * When we update through the ring, if the next incoming buffer has
625 * not been given to the system, we just set the empty indicator,
626 * effectively tossing the packet.
627 */
628static void
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100629fec_enet_rx(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100631 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guob5680e02011-01-05 21:13:13 +0000632 const struct platform_device_id *id_entry =
633 platform_get_device_id(fep->pdev);
Sascha Hauer2e285322009-04-15 01:32:16 +0000634 struct bufdesc *bdp;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000635 unsigned short status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 struct sk_buff *skb;
637 ushort pkt_len;
638 __u8 *data;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400639
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000640#ifdef CONFIG_M532x
641 flush_cache_all();
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400642#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Uwe Kleine-König81538e72009-09-01 23:14:16 +0000644 spin_lock(&fep->hw_lock);
Sebastian Siewior3b2b74c2008-05-01 14:08:12 +1000645
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 /* First, grab all of the stats for the incoming packet.
647 * These get messed up if we get called due to a busy condition.
648 */
649 bdp = fep->cur_rx;
650
Sascha Hauer22f6b862009-04-15 01:32:18 +0000651 while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Sascha Hauer22f6b862009-04-15 01:32:18 +0000653 /* Since we have allocated space to hold a complete frame,
654 * the last indicator should be set.
655 */
656 if ((status & BD_ENET_RX_LAST) == 0)
657 printk("FEC ENET: rcv is not +last\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Sascha Hauer22f6b862009-04-15 01:32:18 +0000659 if (!fep->opened)
660 goto rx_processing_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Sascha Hauer22f6b862009-04-15 01:32:18 +0000662 /* Check for errors. */
663 if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 BD_ENET_RX_CR | BD_ENET_RX_OV)) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100665 ndev->stats.rx_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000666 if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
667 /* Frame too long or too short. */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100668 ndev->stats.rx_length_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000669 }
670 if (status & BD_ENET_RX_NO) /* Frame alignment */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100671 ndev->stats.rx_frame_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000672 if (status & BD_ENET_RX_CR) /* CRC Error */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100673 ndev->stats.rx_crc_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000674 if (status & BD_ENET_RX_OV) /* FIFO overrun */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100675 ndev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 }
Sascha Hauer22f6b862009-04-15 01:32:18 +0000677
678 /* Report late collisions as a frame error.
679 * On this error, the BD is closed, but we don't know what we
680 * have in the buffer. So, just drop this frame on the floor.
681 */
682 if (status & BD_ENET_RX_CL) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100683 ndev->stats.rx_errors++;
684 ndev->stats.rx_frame_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000685 goto rx_processing_done;
686 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Sascha Hauer22f6b862009-04-15 01:32:18 +0000688 /* Process the incoming frame. */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100689 ndev->stats.rx_packets++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000690 pkt_len = bdp->cbd_datlen;
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100691 ndev->stats.rx_bytes += pkt_len;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000692 data = (__u8*)__va(bdp->cbd_bufaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +0100694 dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
695 FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
Sascha Hauerccdc4f12009-01-28 23:03:09 +0000696
Shawn Guob5680e02011-01-05 21:13:13 +0000697 if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
698 swap_buffer(data, pkt_len);
699
Sascha Hauer22f6b862009-04-15 01:32:18 +0000700 /* This does 16 byte alignment, exactly what we need.
701 * The packet length includes FCS, but we don't want to
702 * include that when passing upstream as it messes up
703 * bridging applications.
704 */
Sascha Hauer85498892009-04-15 01:32:21 +0000705 skb = dev_alloc_skb(pkt_len - 4 + NET_IP_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
Sascha Hauer85498892009-04-15 01:32:21 +0000707 if (unlikely(!skb)) {
Sascha Hauer22f6b862009-04-15 01:32:18 +0000708 printk("%s: Memory squeeze, dropping packet.\n",
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100709 ndev->name);
710 ndev->stats.rx_dropped++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000711 } else {
Sascha Hauer85498892009-04-15 01:32:21 +0000712 skb_reserve(skb, NET_IP_ALIGN);
Sascha Hauer22f6b862009-04-15 01:32:18 +0000713 skb_put(skb, pkt_len - 4); /* Make room */
714 skb_copy_to_linear_data(skb, data, pkt_len - 4);
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100715 skb->protocol = eth_type_trans(skb, ndev);
Richard Cochran18a03b92011-06-12 02:18:59 +0000716 if (!skb_defer_rx_timestamp(skb))
717 netif_rx(skb);
Sascha Hauer22f6b862009-04-15 01:32:18 +0000718 }
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000719
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +0100720 bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, data,
721 FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
Sascha Hauer22f6b862009-04-15 01:32:18 +0000722rx_processing_done:
723 /* Clear the status flags for this buffer */
724 status &= ~BD_ENET_RX_STATS;
725
726 /* Mark the buffer empty */
727 status |= BD_ENET_RX_EMPTY;
728 bdp->cbd_sc = status;
729
730 /* Update BD pointer to next entry */
731 if (status & BD_ENET_RX_WRAP)
732 bdp = fep->rx_bd_base;
733 else
734 bdp++;
735 /* Doing this here will keep the FEC running while we process
736 * incoming frames. On a heavily loaded network, we should be
737 * able to keep up at the expense of system resources.
738 */
739 writel(0, fep->hwp + FEC_R_DES_ACTIVE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 }
Sascha Hauer2e285322009-04-15 01:32:16 +0000741 fep->cur_rx = bdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Uwe Kleine-König81538e72009-09-01 23:14:16 +0000743 spin_unlock(&fep->hw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744}
745
Uwe Kleine-König45993652011-01-19 20:47:04 +0100746static irqreturn_t
747fec_enet_interrupt(int irq, void *dev_id)
748{
749 struct net_device *ndev = dev_id;
750 struct fec_enet_private *fep = netdev_priv(ndev);
751 uint int_events;
752 irqreturn_t ret = IRQ_NONE;
753
754 do {
755 int_events = readl(fep->hwp + FEC_IEVENT);
756 writel(int_events, fep->hwp + FEC_IEVENT);
757
758 if (int_events & FEC_ENET_RXF) {
759 ret = IRQ_HANDLED;
760 fec_enet_rx(ndev);
761 }
762
763 /* Transmit OK, or non-fatal error. Update the buffer
764 * descriptors. FEC handles all errors, we just discover
765 * them as part of the transmit process.
766 */
767 if (int_events & FEC_ENET_TXF) {
768 ret = IRQ_HANDLED;
769 fec_enet_tx(ndev);
770 }
771
772 if (int_events & FEC_ENET_MII) {
773 ret = IRQ_HANDLED;
774 complete(&fep->mdio_done);
775 }
776 } while (int_events);
777
778 return ret;
779}
780
781
782
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783/* ------------------------------------------------------------------------- */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100784static void __inline__ fec_get_mac(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100786 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guo49da97d2011-01-05 21:13:11 +0000787 struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
Greg Ungerer7dd6a2a2005-09-12 11:18:10 +1000788 unsigned char *iap, tmpaddr[ETH_ALEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
Shawn Guo49da97d2011-01-05 21:13:11 +0000790 /*
791 * try to get mac address in following order:
792 *
793 * 1) module parameter via kernel command line in form
794 * fec.macaddr=0x00,0x04,0x9f,0x01,0x30,0xe0
795 */
796 iap = macaddr;
797
Shawn Guoca2cc332011-06-25 02:04:35 +0800798#ifdef CONFIG_OF
Shawn Guo49da97d2011-01-05 21:13:11 +0000799 /*
Shawn Guoca2cc332011-06-25 02:04:35 +0800800 * 2) from device tree data
801 */
802 if (!is_valid_ether_addr(iap)) {
803 struct device_node *np = fep->pdev->dev.of_node;
804 if (np) {
805 const char *mac = of_get_mac_address(np);
806 if (mac)
807 iap = (unsigned char *) mac;
808 }
809 }
810#endif
811
812 /*
813 * 3) from flash or fuse (via platform data)
Shawn Guo49da97d2011-01-05 21:13:11 +0000814 */
815 if (!is_valid_ether_addr(iap)) {
816#ifdef CONFIG_M5272
817 if (FEC_FLASHMAC)
818 iap = (unsigned char *)FEC_FLASHMAC;
819#else
820 if (pdata)
821 memcpy(iap, pdata->mac, ETH_ALEN);
822#endif
823 }
824
825 /*
Shawn Guoca2cc332011-06-25 02:04:35 +0800826 * 4) FEC mac registers set by bootloader
Shawn Guo49da97d2011-01-05 21:13:11 +0000827 */
828 if (!is_valid_ether_addr(iap)) {
829 *((unsigned long *) &tmpaddr[0]) =
830 be32_to_cpu(readl(fep->hwp + FEC_ADDR_LOW));
831 *((unsigned short *) &tmpaddr[4]) =
832 be16_to_cpu(readl(fep->hwp + FEC_ADDR_HIGH) >> 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 iap = &tmpaddr[0];
834 }
835
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100836 memcpy(ndev->dev_addr, iap, ETH_ALEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
Shawn Guo49da97d2011-01-05 21:13:11 +0000838 /* Adjust MAC if using macaddr */
839 if (iap == macaddr)
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100840 ndev->dev_addr[ETH_ALEN-1] = macaddr[ETH_ALEN-1] + fep->pdev->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
843/* ------------------------------------------------------------------------- */
844
Bryan Wue6b043d2010-03-31 02:10:44 +0000845/*
846 * Phy section
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100848static void fec_enet_adjust_link(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100850 struct fec_enet_private *fep = netdev_priv(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +0000851 struct phy_device *phy_dev = fep->phy_dev;
852 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Bryan Wue6b043d2010-03-31 02:10:44 +0000854 int status_change = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
Bryan Wue6b043d2010-03-31 02:10:44 +0000856 spin_lock_irqsave(&fep->hw_lock, flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400857
Bryan Wue6b043d2010-03-31 02:10:44 +0000858 /* Prevent a state halted on mii error */
859 if (fep->mii_timeout && phy_dev->state == PHY_HALTED) {
860 phy_dev->state = PHY_RESUMING;
861 goto spin_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 }
Bryan Wue6b043d2010-03-31 02:10:44 +0000863
864 /* Duplex link change */
865 if (phy_dev->link) {
866 if (fep->full_duplex != phy_dev->duplex) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100867 fec_restart(ndev, phy_dev->duplex);
Bryan Wue6b043d2010-03-31 02:10:44 +0000868 status_change = 1;
869 }
870 }
871
872 /* Link on or off change */
873 if (phy_dev->link != fep->link) {
874 fep->link = phy_dev->link;
875 if (phy_dev->link)
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100876 fec_restart(ndev, phy_dev->duplex);
Bryan Wue6b043d2010-03-31 02:10:44 +0000877 else
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100878 fec_stop(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +0000879 status_change = 1;
880 }
881
882spin_unlock:
883 spin_unlock_irqrestore(&fep->hw_lock, flags);
884
885 if (status_change)
886 phy_print_status(phy_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887}
888
Bryan Wue6b043d2010-03-31 02:10:44 +0000889static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890{
Bryan Wue6b043d2010-03-31 02:10:44 +0000891 struct fec_enet_private *fep = bus->priv;
Baruch Siach97b72e42010-07-11 21:12:51 +0000892 unsigned long time_left;
Bryan Wue6b043d2010-03-31 02:10:44 +0000893
894 fep->mii_timeout = 0;
Baruch Siach97b72e42010-07-11 21:12:51 +0000895 init_completion(&fep->mdio_done);
Bryan Wue6b043d2010-03-31 02:10:44 +0000896
897 /* start a read op */
898 writel(FEC_MMFR_ST | FEC_MMFR_OP_READ |
899 FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
900 FEC_MMFR_TA, fep->hwp + FEC_MII_DATA);
901
902 /* wait for end of transfer */
Baruch Siach97b72e42010-07-11 21:12:51 +0000903 time_left = wait_for_completion_timeout(&fep->mdio_done,
904 usecs_to_jiffies(FEC_MII_TIMEOUT));
905 if (time_left == 0) {
906 fep->mii_timeout = 1;
907 printk(KERN_ERR "FEC: MDIO read timeout\n");
908 return -ETIMEDOUT;
Bryan Wue6b043d2010-03-31 02:10:44 +0000909 }
910
911 /* return value */
912 return FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));
913}
914
915static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
916 u16 value)
917{
918 struct fec_enet_private *fep = bus->priv;
Baruch Siach97b72e42010-07-11 21:12:51 +0000919 unsigned long time_left;
Bryan Wue6b043d2010-03-31 02:10:44 +0000920
921 fep->mii_timeout = 0;
Baruch Siach97b72e42010-07-11 21:12:51 +0000922 init_completion(&fep->mdio_done);
Bryan Wue6b043d2010-03-31 02:10:44 +0000923
Shawn Guo862f0982011-01-05 21:13:09 +0000924 /* start a write op */
925 writel(FEC_MMFR_ST | FEC_MMFR_OP_WRITE |
Bryan Wue6b043d2010-03-31 02:10:44 +0000926 FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
927 FEC_MMFR_TA | FEC_MMFR_DATA(value),
928 fep->hwp + FEC_MII_DATA);
929
930 /* wait for end of transfer */
Baruch Siach97b72e42010-07-11 21:12:51 +0000931 time_left = wait_for_completion_timeout(&fep->mdio_done,
932 usecs_to_jiffies(FEC_MII_TIMEOUT));
933 if (time_left == 0) {
934 fep->mii_timeout = 1;
935 printk(KERN_ERR "FEC: MDIO write timeout\n");
936 return -ETIMEDOUT;
Bryan Wue6b043d2010-03-31 02:10:44 +0000937 }
938
939 return 0;
940}
941
942static int fec_enet_mdio_reset(struct mii_bus *bus)
943{
944 return 0;
945}
946
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100947static int fec_enet_mii_probe(struct net_device *ndev)
Bryan Wue6b043d2010-03-31 02:10:44 +0000948{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100949 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guo230dec62011-09-23 02:12:48 +0000950 const struct platform_device_id *id_entry =
951 platform_get_device_id(fep->pdev);
Bryan Wue6b043d2010-03-31 02:10:44 +0000952 struct phy_device *phy_dev = NULL;
Greg Ungerer6fcc0402010-10-11 21:03:05 +0000953 char mdio_bus_id[MII_BUS_ID_SIZE];
954 char phy_name[MII_BUS_ID_SIZE + 3];
955 int phy_id;
Shawn Guob5680e02011-01-05 21:13:13 +0000956 int dev_id = fep->pdev->id;
Bryan Wue6b043d2010-03-31 02:10:44 +0000957
Bryan Wu418bd0d2010-05-28 03:40:39 -0700958 fep->phy_dev = NULL;
959
Greg Ungerer6fcc0402010-10-11 21:03:05 +0000960 /* check for attached phy */
961 for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
962 if ((fep->mii_bus->phy_mask & (1 << phy_id)))
963 continue;
964 if (fep->mii_bus->phy_map[phy_id] == NULL)
965 continue;
966 if (fep->mii_bus->phy_map[phy_id]->phy_id == 0)
967 continue;
Shawn Guob5680e02011-01-05 21:13:13 +0000968 if (dev_id--)
969 continue;
Greg Ungerer6fcc0402010-10-11 21:03:05 +0000970 strncpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
971 break;
Bryan Wue6b043d2010-03-31 02:10:44 +0000972 }
973
Greg Ungerer6fcc0402010-10-11 21:03:05 +0000974 if (phy_id >= PHY_MAX_ADDR) {
Lothar Waßmanna7dd3212011-12-07 21:59:25 +0000975 printk(KERN_INFO
976 "%s: no PHY, assuming direct connection to switch\n",
977 ndev->name);
Greg Ungerer6fcc0402010-10-11 21:03:05 +0000978 strncpy(mdio_bus_id, "0", MII_BUS_ID_SIZE);
979 phy_id = 0;
980 }
981
982 snprintf(phy_name, MII_BUS_ID_SIZE, PHY_ID_FMT, mdio_bus_id, phy_id);
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100983 phy_dev = phy_connect(ndev, phy_name, &fec_enet_adjust_link, 0,
Shawn Guo230dec62011-09-23 02:12:48 +0000984 fep->phy_interface);
Greg Ungerer6fcc0402010-10-11 21:03:05 +0000985 if (IS_ERR(phy_dev)) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100986 printk(KERN_ERR "%s: could not attach to PHY\n", ndev->name);
Greg Ungerer6fcc0402010-10-11 21:03:05 +0000987 return PTR_ERR(phy_dev);
Bryan Wue6b043d2010-03-31 02:10:44 +0000988 }
989
990 /* mask with MAC supported features */
Shawn Guo230dec62011-09-23 02:12:48 +0000991 if (id_entry->driver_data & FEC_QUIRK_HAS_GBIT)
992 phy_dev->supported &= PHY_GBIT_FEATURES;
993 else
994 phy_dev->supported &= PHY_BASIC_FEATURES;
995
Bryan Wue6b043d2010-03-31 02:10:44 +0000996 phy_dev->advertising = phy_dev->supported;
997
998 fep->phy_dev = phy_dev;
999 fep->link = 0;
1000 fep->full_duplex = 0;
1001
Lothar Waßmanna7dd3212011-12-07 21:59:25 +00001002 printk(KERN_INFO
1003 "%s: Freescale FEC PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
1004 ndev->name,
Bryan Wu418bd0d2010-05-28 03:40:39 -07001005 fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),
1006 fep->phy_dev->irq);
1007
Bryan Wue6b043d2010-03-31 02:10:44 +00001008 return 0;
1009}
1010
1011static int fec_enet_mii_init(struct platform_device *pdev)
1012{
Shawn Guob5680e02011-01-05 21:13:13 +00001013 static struct mii_bus *fec0_mii_bus;
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001014 struct net_device *ndev = platform_get_drvdata(pdev);
1015 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guob5680e02011-01-05 21:13:13 +00001016 const struct platform_device_id *id_entry =
1017 platform_get_device_id(fep->pdev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001018 int err = -ENXIO, i;
1019
Shawn Guob5680e02011-01-05 21:13:13 +00001020 /*
1021 * The dual fec interfaces are not equivalent with enet-mac.
1022 * Here are the differences:
1023 *
1024 * - fec0 supports MII & RMII modes while fec1 only supports RMII
1025 * - fec0 acts as the 1588 time master while fec1 is slave
1026 * - external phys can only be configured by fec0
1027 *
1028 * That is to say fec1 can not work independently. It only works
1029 * when fec0 is working. The reason behind this design is that the
1030 * second interface is added primarily for Switch mode.
1031 *
1032 * Because of the last point above, both phys are attached on fec0
1033 * mdio interface in board design, and need to be configured by
1034 * fec0 mii_bus.
1035 */
Shawn Guoc8288272011-09-23 02:12:47 +00001036 if ((id_entry->driver_data & FEC_QUIRK_ENET_MAC) && pdev->id > 0) {
Shawn Guob5680e02011-01-05 21:13:13 +00001037 /* fec1 uses fec0 mii_bus */
1038 fep->mii_bus = fec0_mii_bus;
1039 return 0;
1040 }
1041
Bryan Wue6b043d2010-03-31 02:10:44 +00001042 fep->mii_timeout = 0;
1043
1044 /*
1045 * Set MII speed to 2.5 MHz (= clk_get_rate() / 2 * phy_speed)
Shawn Guo230dec62011-09-23 02:12:48 +00001046 *
1047 * The formula for FEC MDC is 'ref_freq / (MII_SPEED x 2)' while
1048 * for ENET-MAC is 'ref_freq / ((MII_SPEED + 1) x 2)'. The i.MX28
1049 * Reference Manual has an error on this, and gets fixed on i.MX6Q
1050 * document.
Bryan Wue6b043d2010-03-31 02:10:44 +00001051 */
Shawn Guo230dec62011-09-23 02:12:48 +00001052 fep->phy_speed = DIV_ROUND_UP(clk_get_rate(fep->clk), 5000000);
1053 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
1054 fep->phy_speed--;
1055 fep->phy_speed <<= 1;
Bryan Wue6b043d2010-03-31 02:10:44 +00001056 writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
1057
1058 fep->mii_bus = mdiobus_alloc();
1059 if (fep->mii_bus == NULL) {
1060 err = -ENOMEM;
1061 goto err_out;
1062 }
1063
1064 fep->mii_bus->name = "fec_enet_mii_bus";
1065 fep->mii_bus->read = fec_enet_mdio_read;
1066 fep->mii_bus->write = fec_enet_mdio_write;
1067 fep->mii_bus->reset = fec_enet_mdio_reset;
Greg Ungerer6fcc0402010-10-11 21:03:05 +00001068 snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id + 1);
Bryan Wue6b043d2010-03-31 02:10:44 +00001069 fep->mii_bus->priv = fep;
1070 fep->mii_bus->parent = &pdev->dev;
1071
1072 fep->mii_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
1073 if (!fep->mii_bus->irq) {
1074 err = -ENOMEM;
1075 goto err_out_free_mdiobus;
1076 }
1077
1078 for (i = 0; i < PHY_MAX_ADDR; i++)
1079 fep->mii_bus->irq[i] = PHY_POLL;
1080
Bryan Wue6b043d2010-03-31 02:10:44 +00001081 if (mdiobus_register(fep->mii_bus))
1082 goto err_out_free_mdio_irq;
1083
Shawn Guob5680e02011-01-05 21:13:13 +00001084 /* save fec0 mii_bus */
1085 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
1086 fec0_mii_bus = fep->mii_bus;
1087
Bryan Wue6b043d2010-03-31 02:10:44 +00001088 return 0;
1089
Bryan Wue6b043d2010-03-31 02:10:44 +00001090err_out_free_mdio_irq:
1091 kfree(fep->mii_bus->irq);
1092err_out_free_mdiobus:
1093 mdiobus_free(fep->mii_bus);
1094err_out:
1095 return err;
1096}
1097
1098static void fec_enet_mii_remove(struct fec_enet_private *fep)
1099{
1100 if (fep->phy_dev)
1101 phy_disconnect(fep->phy_dev);
1102 mdiobus_unregister(fep->mii_bus);
1103 kfree(fep->mii_bus->irq);
1104 mdiobus_free(fep->mii_bus);
1105}
1106
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001107static int fec_enet_get_settings(struct net_device *ndev,
Bryan Wue6b043d2010-03-31 02:10:44 +00001108 struct ethtool_cmd *cmd)
1109{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001110 struct fec_enet_private *fep = netdev_priv(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001111 struct phy_device *phydev = fep->phy_dev;
1112
1113 if (!phydev)
1114 return -ENODEV;
1115
1116 return phy_ethtool_gset(phydev, cmd);
1117}
1118
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001119static int fec_enet_set_settings(struct net_device *ndev,
Bryan Wue6b043d2010-03-31 02:10:44 +00001120 struct ethtool_cmd *cmd)
1121{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001122 struct fec_enet_private *fep = netdev_priv(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001123 struct phy_device *phydev = fep->phy_dev;
1124
1125 if (!phydev)
1126 return -ENODEV;
1127
1128 return phy_ethtool_sset(phydev, cmd);
1129}
1130
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001131static void fec_enet_get_drvinfo(struct net_device *ndev,
Bryan Wue6b043d2010-03-31 02:10:44 +00001132 struct ethtool_drvinfo *info)
1133{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001134 struct fec_enet_private *fep = netdev_priv(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135
Bryan Wue6b043d2010-03-31 02:10:44 +00001136 strcpy(info->driver, fep->pdev->dev.driver->name);
1137 strcpy(info->version, "Revision: 1.0");
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001138 strcpy(info->bus_info, dev_name(&ndev->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139}
Bryan Wue6b043d2010-03-31 02:10:44 +00001140
1141static struct ethtool_ops fec_enet_ethtool_ops = {
1142 .get_settings = fec_enet_get_settings,
1143 .set_settings = fec_enet_set_settings,
1144 .get_drvinfo = fec_enet_get_drvinfo,
1145 .get_link = ethtool_op_get_link,
1146};
1147
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001148static int fec_enet_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
Bryan Wue6b043d2010-03-31 02:10:44 +00001149{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001150 struct fec_enet_private *fep = netdev_priv(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001151 struct phy_device *phydev = fep->phy_dev;
1152
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001153 if (!netif_running(ndev))
Bryan Wue6b043d2010-03-31 02:10:44 +00001154 return -EINVAL;
1155
1156 if (!phydev)
1157 return -ENODEV;
1158
Richard Cochran28b04112010-07-17 08:48:55 +00001159 return phy_mii_ioctl(phydev, rq, cmd);
Bryan Wue6b043d2010-03-31 02:10:44 +00001160}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001162static void fec_enet_free_buffers(struct net_device *ndev)
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001163{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001164 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001165 int i;
1166 struct sk_buff *skb;
1167 struct bufdesc *bdp;
1168
1169 bdp = fep->rx_bd_base;
1170 for (i = 0; i < RX_RING_SIZE; i++) {
1171 skb = fep->rx_skbuff[i];
1172
1173 if (bdp->cbd_bufaddr)
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +01001174 dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001175 FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
1176 if (skb)
1177 dev_kfree_skb(skb);
1178 bdp++;
1179 }
1180
1181 bdp = fep->tx_bd_base;
1182 for (i = 0; i < TX_RING_SIZE; i++)
1183 kfree(fep->tx_bounce[i]);
1184}
1185
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001186static int fec_enet_alloc_buffers(struct net_device *ndev)
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001187{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001188 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001189 int i;
1190 struct sk_buff *skb;
1191 struct bufdesc *bdp;
1192
1193 bdp = fep->rx_bd_base;
1194 for (i = 0; i < RX_RING_SIZE; i++) {
1195 skb = dev_alloc_skb(FEC_ENET_RX_FRSIZE);
1196 if (!skb) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001197 fec_enet_free_buffers(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001198 return -ENOMEM;
1199 }
1200 fep->rx_skbuff[i] = skb;
1201
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +01001202 bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, skb->data,
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001203 FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
1204 bdp->cbd_sc = BD_ENET_RX_EMPTY;
1205 bdp++;
1206 }
1207
1208 /* Set the last buffer to wrap. */
1209 bdp--;
1210 bdp->cbd_sc |= BD_SC_WRAP;
1211
1212 bdp = fep->tx_bd_base;
1213 for (i = 0; i < TX_RING_SIZE; i++) {
1214 fep->tx_bounce[i] = kmalloc(FEC_ENET_TX_FRSIZE, GFP_KERNEL);
1215
1216 bdp->cbd_sc = 0;
1217 bdp->cbd_bufaddr = 0;
1218 bdp++;
1219 }
1220
1221 /* Set the last buffer to wrap. */
1222 bdp--;
1223 bdp->cbd_sc |= BD_SC_WRAP;
1224
1225 return 0;
1226}
1227
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228static int
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001229fec_enet_open(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001231 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001232 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
1234 /* I should reset the ring buffers here, but I don't yet know
1235 * a simple way to do that.
1236 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001238 ret = fec_enet_alloc_buffers(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001239 if (ret)
1240 return ret;
1241
Bryan Wu418bd0d2010-05-28 03:40:39 -07001242 /* Probe and connect to PHY when open the interface */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001243 ret = fec_enet_mii_probe(ndev);
Bryan Wu418bd0d2010-05-28 03:40:39 -07001244 if (ret) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001245 fec_enet_free_buffers(ndev);
Bryan Wu418bd0d2010-05-28 03:40:39 -07001246 return ret;
1247 }
Bryan Wue6b043d2010-03-31 02:10:44 +00001248 phy_start(fep->phy_dev);
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001249 netif_start_queue(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 fep->opened = 1;
Sascha Hauer22f6b862009-04-15 01:32:18 +00001251 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252}
1253
1254static int
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001255fec_enet_close(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001257 struct fec_enet_private *fep = netdev_priv(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258
Sascha Hauer22f6b862009-04-15 01:32:18 +00001259 /* Don't know what to do yet. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 fep->opened = 0;
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001261 netif_stop_queue(ndev);
1262 fec_stop(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
Uwe Kleine-Könige497ba82011-01-17 20:04:23 +01001264 if (fep->phy_dev) {
1265 phy_stop(fep->phy_dev);
Bryan Wu418bd0d2010-05-28 03:40:39 -07001266 phy_disconnect(fep->phy_dev);
Uwe Kleine-Könige497ba82011-01-17 20:04:23 +01001267 }
Bryan Wu418bd0d2010-05-28 03:40:39 -07001268
Uwe Kleine-Königdb8880b2011-01-19 20:26:39 +01001269 fec_enet_free_buffers(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001270
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 return 0;
1272}
1273
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274/* Set or clear the multicast filter for this adaptor.
1275 * Skeleton taken from sunlance driver.
1276 * The CPM Ethernet implementation allows Multicast as well as individual
1277 * MAC address filtering. Some of the drivers check to make sure it is
1278 * a group multicast address, and discard those that are not. I guess I
1279 * will do the same for now, but just remove the test if you want
1280 * individual filtering as well (do the upper net layers want or support
1281 * this kind of feature?).
1282 */
1283
1284#define HASH_BITS 6 /* #bits in hash */
1285#define CRC32_POLY 0xEDB88320
1286
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001287static void set_multicast_list(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001289 struct fec_enet_private *fep = netdev_priv(ndev);
Jiri Pirko22bedad32010-04-01 21:22:57 +00001290 struct netdev_hw_addr *ha;
Jiri Pirko48e2f182010-02-22 09:22:26 +00001291 unsigned int i, bit, data, crc, tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 unsigned char hash;
1293
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001294 if (ndev->flags & IFF_PROMISC) {
Sascha Hauerf44d6302009-04-15 03:11:30 +00001295 tmp = readl(fep->hwp + FEC_R_CNTRL);
1296 tmp |= 0x8;
1297 writel(tmp, fep->hwp + FEC_R_CNTRL);
Sascha Hauer4e831832009-04-15 01:32:19 +00001298 return;
1299 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
Sascha Hauer4e831832009-04-15 01:32:19 +00001301 tmp = readl(fep->hwp + FEC_R_CNTRL);
1302 tmp &= ~0x8;
1303 writel(tmp, fep->hwp + FEC_R_CNTRL);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001304
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001305 if (ndev->flags & IFF_ALLMULTI) {
Sascha Hauer4e831832009-04-15 01:32:19 +00001306 /* Catch all multicast addresses, so set the
1307 * filter to all 1's
1308 */
1309 writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
1310 writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311
Sascha Hauer4e831832009-04-15 01:32:19 +00001312 return;
1313 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001314
Sascha Hauer4e831832009-04-15 01:32:19 +00001315 /* Clear filter and add the addresses in hash register
1316 */
1317 writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
1318 writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001320 netdev_for_each_mc_addr(ha, ndev) {
Sascha Hauer4e831832009-04-15 01:32:19 +00001321 /* calculate crc32 value of mac address */
1322 crc = 0xffffffff;
1323
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001324 for (i = 0; i < ndev->addr_len; i++) {
Jiri Pirko22bedad32010-04-01 21:22:57 +00001325 data = ha->addr[i];
Sascha Hauer4e831832009-04-15 01:32:19 +00001326 for (bit = 0; bit < 8; bit++, data >>= 1) {
1327 crc = (crc >> 1) ^
1328 (((crc ^ data) & 1) ? CRC32_POLY : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 }
1330 }
Sascha Hauer4e831832009-04-15 01:32:19 +00001331
1332 /* only upper 6 bits (HASH_BITS) are used
1333 * which point to specific bit in he hash registers
1334 */
1335 hash = (crc >> (32 - HASH_BITS)) & 0x3f;
1336
1337 if (hash > 31) {
1338 tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
1339 tmp |= 1 << (hash - 32);
1340 writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
1341 } else {
1342 tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_LOW);
1343 tmp |= 1 << hash;
1344 writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
1345 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 }
1347}
1348
Sascha Hauer22f6b862009-04-15 01:32:18 +00001349/* Set a MAC change in hardware. */
Sascha Hauer009fda82009-04-15 01:32:23 +00001350static int
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001351fec_set_mac_address(struct net_device *ndev, void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001353 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Hauer009fda82009-04-15 01:32:23 +00001354 struct sockaddr *addr = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
Sascha Hauer009fda82009-04-15 01:32:23 +00001356 if (!is_valid_ether_addr(addr->sa_data))
1357 return -EADDRNOTAVAIL;
1358
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001359 memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
Sascha Hauer009fda82009-04-15 01:32:23 +00001360
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001361 writel(ndev->dev_addr[3] | (ndev->dev_addr[2] << 8) |
1362 (ndev->dev_addr[1] << 16) | (ndev->dev_addr[0] << 24),
Sascha Hauerf44d6302009-04-15 03:11:30 +00001363 fep->hwp + FEC_ADDR_LOW);
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001364 writel((ndev->dev_addr[5] << 16) | (ndev->dev_addr[4] << 24),
Mattias Walström7cff0942010-05-05 00:55:48 -07001365 fep->hwp + FEC_ADDR_HIGH);
Sascha Hauer009fda82009-04-15 01:32:23 +00001366 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367}
1368
Xiao Jiang7f5c6ad2011-09-29 02:15:57 +00001369#ifdef CONFIG_NET_POLL_CONTROLLER
1370/*
1371 * fec_poll_controller: FEC Poll controller function
1372 * @dev: The FEC network adapter
1373 *
1374 * Polled functionality used by netconsole and others in non interrupt mode
1375 *
1376 */
1377void fec_poll_controller(struct net_device *dev)
1378{
1379 int i;
1380 struct fec_enet_private *fep = netdev_priv(dev);
1381
1382 for (i = 0; i < FEC_IRQ_NUM; i++) {
1383 if (fep->irq[i] > 0) {
1384 disable_irq(fep->irq[i]);
1385 fec_enet_interrupt(fep->irq[i], dev);
1386 enable_irq(fep->irq[i]);
1387 }
1388 }
1389}
1390#endif
1391
Sascha Hauer009fda82009-04-15 01:32:23 +00001392static const struct net_device_ops fec_netdev_ops = {
1393 .ndo_open = fec_enet_open,
1394 .ndo_stop = fec_enet_close,
1395 .ndo_start_xmit = fec_enet_start_xmit,
Jiri Pirkoafc4b132011-08-16 06:29:01 +00001396 .ndo_set_rx_mode = set_multicast_list,
Ben Hutchings635ecaa2009-07-09 17:59:01 +00001397 .ndo_change_mtu = eth_change_mtu,
Sascha Hauer009fda82009-04-15 01:32:23 +00001398 .ndo_validate_addr = eth_validate_addr,
1399 .ndo_tx_timeout = fec_timeout,
1400 .ndo_set_mac_address = fec_set_mac_address,
Uwe Kleine-Königdb8880b2011-01-19 20:26:39 +01001401 .ndo_do_ioctl = fec_enet_ioctl,
Xiao Jiang7f5c6ad2011-09-29 02:15:57 +00001402#ifdef CONFIG_NET_POLL_CONTROLLER
1403 .ndo_poll_controller = fec_poll_controller,
1404#endif
Sascha Hauer009fda82009-04-15 01:32:23 +00001405};
1406
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 /*
1408 * XXX: We need to clean up on failure exits here.
Sascha Haueread73182009-01-28 23:03:11 +00001409 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001411static int fec_enet_init(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001413 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001414 struct bufdesc *cbd_base;
Rob Herring633e7532010-02-05 08:56:20 +00001415 struct bufdesc *bdp;
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001416 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
Sascha Hauer8d4dd5c2009-04-15 01:32:17 +00001418 /* Allocate memory for buffer descriptors. */
1419 cbd_base = dma_alloc_coherent(NULL, PAGE_SIZE, &fep->bd_dma,
1420 GFP_KERNEL);
1421 if (!cbd_base) {
Greg Ungerer562d2f82005-11-07 14:09:50 +10001422 printk("FEC: allocate descriptor memory failed?\n");
1423 return -ENOMEM;
1424 }
1425
Sebastian Siewior3b2b74c2008-05-01 14:08:12 +10001426 spin_lock_init(&fep->hw_lock);
Sebastian Siewior3b2b74c2008-05-01 14:08:12 +10001427
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001428 fep->netdev = ndev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
Shawn Guo49da97d2011-01-05 21:13:11 +00001430 /* Get the Ethernet address */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001431 fec_get_mac(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
Sascha Hauer8d4dd5c2009-04-15 01:32:17 +00001433 /* Set receive and transmit descriptor base. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 fep->rx_bd_base = cbd_base;
1435 fep->tx_bd_base = cbd_base + RX_RING_SIZE;
1436
Sascha Hauer22f6b862009-04-15 01:32:18 +00001437 /* The FEC Ethernet specific entries in the device structure */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001438 ndev->watchdog_timeo = TX_TIMEOUT;
1439 ndev->netdev_ops = &fec_netdev_ops;
1440 ndev->ethtool_ops = &fec_enet_ethtool_ops;
Rob Herring633e7532010-02-05 08:56:20 +00001441
1442 /* Initialize the receive buffer descriptors. */
1443 bdp = fep->rx_bd_base;
1444 for (i = 0; i < RX_RING_SIZE; i++) {
1445
1446 /* Initialize the BD for every fragment in the page. */
1447 bdp->cbd_sc = 0;
1448 bdp++;
1449 }
1450
1451 /* Set the last buffer to wrap */
1452 bdp--;
1453 bdp->cbd_sc |= BD_SC_WRAP;
1454
1455 /* ...and the same for transmit */
1456 bdp = fep->tx_bd_base;
1457 for (i = 0; i < TX_RING_SIZE; i++) {
1458
1459 /* Initialize the BD for every fragment in the page. */
1460 bdp->cbd_sc = 0;
1461 bdp->cbd_bufaddr = 0;
1462 bdp++;
1463 }
1464
1465 /* Set the last buffer to wrap */
1466 bdp--;
1467 bdp->cbd_sc |= BD_SC_WRAP;
1468
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001469 fec_restart(ndev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 return 0;
1472}
1473
Shawn Guoca2cc332011-06-25 02:04:35 +08001474#ifdef CONFIG_OF
1475static int __devinit fec_get_phy_mode_dt(struct platform_device *pdev)
1476{
1477 struct device_node *np = pdev->dev.of_node;
1478
1479 if (np)
1480 return of_get_phy_mode(np);
1481
1482 return -ENODEV;
1483}
1484
Shawn Guoa9b2c8e2011-09-23 02:12:46 +00001485static void __devinit fec_reset_phy(struct platform_device *pdev)
Shawn Guoca2cc332011-06-25 02:04:35 +08001486{
1487 int err, phy_reset;
1488 struct device_node *np = pdev->dev.of_node;
1489
1490 if (!np)
Shawn Guoa9b2c8e2011-09-23 02:12:46 +00001491 return;
Shawn Guoca2cc332011-06-25 02:04:35 +08001492
1493 phy_reset = of_get_named_gpio(np, "phy-reset-gpios", 0);
1494 err = gpio_request_one(phy_reset, GPIOF_OUT_INIT_LOW, "phy-reset");
1495 if (err) {
Shawn Guoa9b2c8e2011-09-23 02:12:46 +00001496 pr_debug("FEC: failed to get gpio phy-reset: %d\n", err);
1497 return;
Shawn Guoca2cc332011-06-25 02:04:35 +08001498 }
1499 msleep(1);
1500 gpio_set_value(phy_reset, 1);
Shawn Guoca2cc332011-06-25 02:04:35 +08001501}
1502#else /* CONFIG_OF */
1503static inline int fec_get_phy_mode_dt(struct platform_device *pdev)
1504{
1505 return -ENODEV;
1506}
1507
Shawn Guoa9b2c8e2011-09-23 02:12:46 +00001508static inline void fec_reset_phy(struct platform_device *pdev)
Shawn Guoca2cc332011-06-25 02:04:35 +08001509{
1510 /*
1511 * In case of platform probe, the reset has been done
1512 * by machine code.
1513 */
Shawn Guoca2cc332011-06-25 02:04:35 +08001514}
1515#endif /* CONFIG_OF */
1516
Sascha Haueread73182009-01-28 23:03:11 +00001517static int __devinit
1518fec_probe(struct platform_device *pdev)
1519{
1520 struct fec_enet_private *fep;
Baruch Siach5eb32bd2010-05-24 00:36:13 -07001521 struct fec_platform_data *pdata;
Sascha Haueread73182009-01-28 23:03:11 +00001522 struct net_device *ndev;
1523 int i, irq, ret = 0;
1524 struct resource *r;
Shawn Guoca2cc332011-06-25 02:04:35 +08001525 const struct of_device_id *of_id;
1526
1527 of_id = of_match_device(fec_dt_ids, &pdev->dev);
1528 if (of_id)
1529 pdev->id_entry = of_id->data;
Sascha Haueread73182009-01-28 23:03:11 +00001530
1531 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1532 if (!r)
1533 return -ENXIO;
1534
1535 r = request_mem_region(r->start, resource_size(r), pdev->name);
1536 if (!r)
1537 return -EBUSY;
1538
1539 /* Init network device */
1540 ndev = alloc_etherdev(sizeof(struct fec_enet_private));
Uwe Kleine-König28e21882011-01-13 21:44:18 +01001541 if (!ndev) {
1542 ret = -ENOMEM;
1543 goto failed_alloc_etherdev;
1544 }
Sascha Haueread73182009-01-28 23:03:11 +00001545
1546 SET_NETDEV_DEV(ndev, &pdev->dev);
1547
1548 /* setup board info structure */
1549 fep = netdev_priv(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001550
Uwe Kleine-König24e531b2011-01-13 22:29:05 +01001551 fep->hwp = ioremap(r->start, resource_size(r));
Bryan Wue6b043d2010-03-31 02:10:44 +00001552 fep->pdev = pdev;
Sascha Haueread73182009-01-28 23:03:11 +00001553
Uwe Kleine-König24e531b2011-01-13 22:29:05 +01001554 if (!fep->hwp) {
Sascha Haueread73182009-01-28 23:03:11 +00001555 ret = -ENOMEM;
1556 goto failed_ioremap;
1557 }
1558
1559 platform_set_drvdata(pdev, ndev);
1560
Shawn Guoca2cc332011-06-25 02:04:35 +08001561 ret = fec_get_phy_mode_dt(pdev);
1562 if (ret < 0) {
1563 pdata = pdev->dev.platform_data;
1564 if (pdata)
1565 fep->phy_interface = pdata->phy;
1566 else
1567 fep->phy_interface = PHY_INTERFACE_MODE_MII;
1568 } else {
1569 fep->phy_interface = ret;
1570 }
1571
1572 fec_reset_phy(pdev);
Baruch Siach5eb32bd2010-05-24 00:36:13 -07001573
Xiao Jiangc7c83d12011-09-29 02:15:56 +00001574 for (i = 0; i < FEC_IRQ_NUM; i++) {
Sascha Haueread73182009-01-28 23:03:11 +00001575 irq = platform_get_irq(pdev, i);
1576 if (i && irq < 0)
1577 break;
1578 ret = request_irq(irq, fec_enet_interrupt, IRQF_DISABLED, pdev->name, ndev);
1579 if (ret) {
Uwe Kleine-Königb2b09ad2011-01-13 21:49:05 +01001580 while (--i >= 0) {
Sascha Haueread73182009-01-28 23:03:11 +00001581 irq = platform_get_irq(pdev, i);
1582 free_irq(irq, ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001583 }
1584 goto failed_irq;
1585 }
1586 }
1587
Lothar Waßmann5b1436c2011-12-07 21:59:26 +00001588 fep->clk = clk_get(&pdev->dev, NULL);
Sascha Haueread73182009-01-28 23:03:11 +00001589 if (IS_ERR(fep->clk)) {
1590 ret = PTR_ERR(fep->clk);
1591 goto failed_clk;
1592 }
1593 clk_enable(fep->clk);
1594
Shawn Guo8649a232011-01-05 21:13:10 +00001595 ret = fec_enet_init(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001596 if (ret)
1597 goto failed_init;
1598
Bryan Wue6b043d2010-03-31 02:10:44 +00001599 ret = fec_enet_mii_init(pdev);
1600 if (ret)
1601 goto failed_mii_init;
1602
Oskar Schirmer03c698c2010-10-07 02:30:30 +00001603 /* Carrier starts down, phylib will bring it up */
1604 netif_carrier_off(ndev);
1605
Sascha Haueread73182009-01-28 23:03:11 +00001606 ret = register_netdev(ndev);
1607 if (ret)
1608 goto failed_register;
1609
1610 return 0;
1611
1612failed_register:
Bryan Wue6b043d2010-03-31 02:10:44 +00001613 fec_enet_mii_remove(fep);
1614failed_mii_init:
Sascha Haueread73182009-01-28 23:03:11 +00001615failed_init:
1616 clk_disable(fep->clk);
1617 clk_put(fep->clk);
1618failed_clk:
Xiao Jiangc7c83d12011-09-29 02:15:56 +00001619 for (i = 0; i < FEC_IRQ_NUM; i++) {
Sascha Haueread73182009-01-28 23:03:11 +00001620 irq = platform_get_irq(pdev, i);
1621 if (irq > 0)
1622 free_irq(irq, ndev);
1623 }
1624failed_irq:
Uwe Kleine-König24e531b2011-01-13 22:29:05 +01001625 iounmap(fep->hwp);
Sascha Haueread73182009-01-28 23:03:11 +00001626failed_ioremap:
1627 free_netdev(ndev);
Uwe Kleine-König28e21882011-01-13 21:44:18 +01001628failed_alloc_etherdev:
1629 release_mem_region(r->start, resource_size(r));
Sascha Haueread73182009-01-28 23:03:11 +00001630
1631 return ret;
1632}
1633
1634static int __devexit
1635fec_drv_remove(struct platform_device *pdev)
1636{
1637 struct net_device *ndev = platform_get_drvdata(pdev);
1638 struct fec_enet_private *fep = netdev_priv(ndev);
Uwe Kleine-König28e21882011-01-13 21:44:18 +01001639 struct resource *r;
Sascha Haueread73182009-01-28 23:03:11 +00001640
Sascha Haueread73182009-01-28 23:03:11 +00001641 fec_stop(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001642 fec_enet_mii_remove(fep);
Sascha Haueread73182009-01-28 23:03:11 +00001643 clk_disable(fep->clk);
1644 clk_put(fep->clk);
Uwe Kleine-König24e531b2011-01-13 22:29:05 +01001645 iounmap(fep->hwp);
Sascha Haueread73182009-01-28 23:03:11 +00001646 unregister_netdev(ndev);
1647 free_netdev(ndev);
Uwe Kleine-König28e21882011-01-13 21:44:18 +01001648
1649 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1650 BUG_ON(!r);
1651 release_mem_region(r->start, resource_size(r));
1652
Uwe Kleine-Königb3cde362011-01-25 18:03:37 +01001653 platform_set_drvdata(pdev, NULL);
1654
Sascha Haueread73182009-01-28 23:03:11 +00001655 return 0;
1656}
1657
Denis Kirjanov59d42892010-06-02 09:27:04 +00001658#ifdef CONFIG_PM
Sascha Haueread73182009-01-28 23:03:11 +00001659static int
Eric Benard87cad5c2010-06-18 04:19:54 +00001660fec_suspend(struct device *dev)
Sascha Haueread73182009-01-28 23:03:11 +00001661{
Eric Benard87cad5c2010-06-18 04:19:54 +00001662 struct net_device *ndev = dev_get_drvdata(dev);
Uwe Kleine-König04e52162011-01-13 21:53:40 +01001663 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001664
Uwe Kleine-König04e52162011-01-13 21:53:40 +01001665 if (netif_running(ndev)) {
1666 fec_stop(ndev);
1667 netif_device_detach(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001668 }
Uwe Kleine-König04e52162011-01-13 21:53:40 +01001669 clk_disable(fep->clk);
1670
Sascha Haueread73182009-01-28 23:03:11 +00001671 return 0;
1672}
1673
1674static int
Eric Benard87cad5c2010-06-18 04:19:54 +00001675fec_resume(struct device *dev)
Sascha Haueread73182009-01-28 23:03:11 +00001676{
Eric Benard87cad5c2010-06-18 04:19:54 +00001677 struct net_device *ndev = dev_get_drvdata(dev);
Uwe Kleine-König04e52162011-01-13 21:53:40 +01001678 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001679
Uwe Kleine-König04e52162011-01-13 21:53:40 +01001680 clk_enable(fep->clk);
1681 if (netif_running(ndev)) {
1682 fec_restart(ndev, fep->full_duplex);
1683 netif_device_attach(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001684 }
Uwe Kleine-König04e52162011-01-13 21:53:40 +01001685
Sascha Haueread73182009-01-28 23:03:11 +00001686 return 0;
1687}
1688
Denis Kirjanov59d42892010-06-02 09:27:04 +00001689static const struct dev_pm_ops fec_pm_ops = {
1690 .suspend = fec_suspend,
1691 .resume = fec_resume,
1692 .freeze = fec_suspend,
1693 .thaw = fec_resume,
1694 .poweroff = fec_suspend,
1695 .restore = fec_resume,
1696};
Eric Benard87cad5c2010-06-18 04:19:54 +00001697#endif
Denis Kirjanov59d42892010-06-02 09:27:04 +00001698
Sascha Haueread73182009-01-28 23:03:11 +00001699static struct platform_driver fec_driver = {
1700 .driver = {
Shawn Guob5680e02011-01-05 21:13:13 +00001701 .name = DRIVER_NAME,
Eric Benard87cad5c2010-06-18 04:19:54 +00001702 .owner = THIS_MODULE,
1703#ifdef CONFIG_PM
1704 .pm = &fec_pm_ops,
1705#endif
Shawn Guoca2cc332011-06-25 02:04:35 +08001706 .of_match_table = fec_dt_ids,
Sascha Haueread73182009-01-28 23:03:11 +00001707 },
Shawn Guob5680e02011-01-05 21:13:13 +00001708 .id_table = fec_devtype,
Eric Benard87cad5c2010-06-18 04:19:54 +00001709 .probe = fec_probe,
1710 .remove = __devexit_p(fec_drv_remove),
Sascha Haueread73182009-01-28 23:03:11 +00001711};
1712
1713static int __init
1714fec_enet_module_init(void)
1715{
1716 printk(KERN_INFO "FEC Ethernet Driver\n");
1717
1718 return platform_driver_register(&fec_driver);
1719}
1720
1721static void __exit
1722fec_enet_cleanup(void)
1723{
1724 platform_driver_unregister(&fec_driver);
1725}
1726
1727module_exit(fec_enet_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728module_init(fec_enet_module_init);
1729
1730MODULE_LICENSE("GPL");