blob: d48099f03b7f619b15959a4f4fd2b4db2b491805 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/init.h>
33#include <linux/delay.h>
34#include <linux/netdevice.h>
35#include <linux/etherdevice.h>
36#include <linux/skbuff.h>
Jim Baxter4c09eed2013-04-19 08:10:49 +000037#include <linux/in.h>
38#include <linux/ip.h>
39#include <net/ip.h>
40#include <linux/tcp.h>
41#include <linux/udp.h>
42#include <linux/icmp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/spinlock.h>
44#include <linux/workqueue.h>
45#include <linux/bitops.h>
Sascha Hauer6f501b12009-01-28 23:03:05 +000046#include <linux/io.h>
47#include <linux/irq.h>
Sascha Hauer196719e2009-01-28 23:03:10 +000048#include <linux/clk.h>
Sascha Haueread73182009-01-28 23:03:11 +000049#include <linux/platform_device.h>
Bryan Wue6b043d2010-03-31 02:10:44 +000050#include <linux/phy.h>
Baruch Siach5eb32bd2010-05-24 00:36:13 -070051#include <linux/fec.h>
Shawn Guoca2cc332011-06-25 02:04:35 +080052#include <linux/of.h>
53#include <linux/of_device.h>
54#include <linux/of_gpio.h>
55#include <linux/of_net.h>
Shawn Guob2bccee2012-05-06 20:24:04 +080056#include <linux/pinctrl/consumer.h>
Shawn Guo5fa9c0f2012-06-27 03:45:21 +000057#include <linux/regulator/consumer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Greg Ungerer080853a2007-07-30 16:28:46 +100059#include <asm/cacheflush.h>
Sascha Hauer196719e2009-01-28 23:03:10 +000060
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include "fec.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Uwe Kleine-König085e79e2011-01-17 09:52:18 +010063#if defined(CONFIG_ARM)
Sascha Hauer196719e2009-01-28 23:03:10 +000064#define FEC_ALIGNMENT 0xf
65#else
66#define FEC_ALIGNMENT 0x3
67#endif
68
Shawn Guob5680e02011-01-05 21:13:13 +000069#define DRIVER_NAME "fec"
Frank Lidc975382013-01-28 18:31:42 +000070#define FEC_NAPI_WEIGHT 64
Shawn Guob5680e02011-01-05 21:13:13 +000071
Frank Libaa70a52013-01-16 16:55:58 +000072/* Pause frame feild and FIFO threshold */
73#define FEC_ENET_FCE (1 << 5)
74#define FEC_ENET_RSEM_V 0x84
75#define FEC_ENET_RSFL_V 16
76#define FEC_ENET_RAEM_V 0x8
77#define FEC_ENET_RAFL_V 0x8
78#define FEC_ENET_OPD_V 0xFFF0
79
Shawn Guob5680e02011-01-05 21:13:13 +000080/* Controller is ENET-MAC */
81#define FEC_QUIRK_ENET_MAC (1 << 0)
82/* Controller needs driver to swap frame */
83#define FEC_QUIRK_SWAP_FRAME (1 << 1)
Shawn Guo0ca1e292011-07-01 18:11:22 +080084/* Controller uses gasket */
85#define FEC_QUIRK_USE_GASKET (1 << 2)
Shawn Guo230dec62011-09-23 02:12:48 +000086/* Controller has GBIT support */
87#define FEC_QUIRK_HAS_GBIT (1 << 3)
Frank Liff43da82013-01-03 16:04:23 +000088/* Controller has extend desc buffer */
89#define FEC_QUIRK_HAS_BUFDESC_EX (1 << 4)
Shawn Guo48496252013-05-08 21:08:22 +000090/* Controller has hardware checksum support */
91#define FEC_QUIRK_HAS_CSUM (1 << 5)
Shawn Guob5680e02011-01-05 21:13:13 +000092
93static struct platform_device_id fec_devtype[] = {
94 {
Shawn Guo0ca1e292011-07-01 18:11:22 +080095 /* keep it for coldfire */
Shawn Guob5680e02011-01-05 21:13:13 +000096 .name = DRIVER_NAME,
97 .driver_data = 0,
98 }, {
Shawn Guo0ca1e292011-07-01 18:11:22 +080099 .name = "imx25-fec",
100 .driver_data = FEC_QUIRK_USE_GASKET,
101 }, {
102 .name = "imx27-fec",
103 .driver_data = 0,
104 }, {
Shawn Guob5680e02011-01-05 21:13:13 +0000105 .name = "imx28-fec",
106 .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME,
Shawn Guo0ca1e292011-07-01 18:11:22 +0800107 }, {
Shawn Guo230dec62011-09-23 02:12:48 +0000108 .name = "imx6q-fec",
Frank Liff43da82013-01-03 16:04:23 +0000109 .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
Shawn Guo48496252013-05-08 21:08:22 +0000110 FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM,
Shawn Guo230dec62011-09-23 02:12:48 +0000111 }, {
Shawn Guo36803542013-05-19 04:38:46 +0000112 .name = "mvf600-fec",
Jingchang Luca7c4a42013-04-11 21:12:45 +0000113 .driver_data = FEC_QUIRK_ENET_MAC,
114 }, {
Shawn Guo0ca1e292011-07-01 18:11:22 +0800115 /* sentinel */
116 }
Shawn Guob5680e02011-01-05 21:13:13 +0000117};
Shawn Guo0ca1e292011-07-01 18:11:22 +0800118MODULE_DEVICE_TABLE(platform, fec_devtype);
Shawn Guob5680e02011-01-05 21:13:13 +0000119
Shawn Guoca2cc332011-06-25 02:04:35 +0800120enum imx_fec_type {
Lothar Waßmanna7dd3212011-12-07 21:59:25 +0000121 IMX25_FEC = 1, /* runs on i.mx25/50/53 */
Shawn Guoca2cc332011-06-25 02:04:35 +0800122 IMX27_FEC, /* runs on i.mx27/35/51 */
123 IMX28_FEC,
Shawn Guo230dec62011-09-23 02:12:48 +0000124 IMX6Q_FEC,
Shawn Guo36803542013-05-19 04:38:46 +0000125 MVF600_FEC,
Shawn Guoca2cc332011-06-25 02:04:35 +0800126};
127
128static const struct of_device_id fec_dt_ids[] = {
129 { .compatible = "fsl,imx25-fec", .data = &fec_devtype[IMX25_FEC], },
130 { .compatible = "fsl,imx27-fec", .data = &fec_devtype[IMX27_FEC], },
131 { .compatible = "fsl,imx28-fec", .data = &fec_devtype[IMX28_FEC], },
Shawn Guo230dec62011-09-23 02:12:48 +0000132 { .compatible = "fsl,imx6q-fec", .data = &fec_devtype[IMX6Q_FEC], },
Shawn Guo36803542013-05-19 04:38:46 +0000133 { .compatible = "fsl,mvf600-fec", .data = &fec_devtype[MVF600_FEC], },
Shawn Guoca2cc332011-06-25 02:04:35 +0800134 { /* sentinel */ }
135};
136MODULE_DEVICE_TABLE(of, fec_dt_ids);
137
Shawn Guo49da97d2011-01-05 21:13:11 +0000138static unsigned char macaddr[ETH_ALEN];
139module_param_array(macaddr, byte, NULL, 0);
140MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
141
Greg Ungerer87f4abb2008-06-06 15:55:36 +1000142#if defined(CONFIG_M5272)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143/*
144 * Some hardware gets it MAC address out of local flash memory.
145 * if this is non-zero then assume it is the address to get MAC from.
146 */
147#if defined(CONFIG_NETtel)
148#define FEC_FLASHMAC 0xf0006006
149#elif defined(CONFIG_GILBARCONAP) || defined(CONFIG_SCALES)
150#define FEC_FLASHMAC 0xf0006000
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#elif defined(CONFIG_CANCam)
152#define FEC_FLASHMAC 0xf0020000
Greg Ungerer7dd6a2a2005-09-12 11:18:10 +1000153#elif defined (CONFIG_M5272C3)
154#define FEC_FLASHMAC (0xffe04000 + 4)
155#elif defined(CONFIG_MOD5272)
Lothar Waßmanna7dd3212011-12-07 21:59:25 +0000156#define FEC_FLASHMAC 0xffc0406b
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157#else
158#define FEC_FLASHMAC 0
159#endif
Greg Ungerer43be6362009-02-26 22:42:51 -0800160#endif /* CONFIG_M5272 */
Sascha Haueread73182009-01-28 23:03:11 +0000161
Frank Liff43da82013-01-03 16:04:23 +0000162#if (((RX_RING_SIZE + TX_RING_SIZE) * 32) > PAGE_SIZE)
Matt Waddel6b265292006-06-27 13:10:56 +1000163#error "FEC: descriptor ring size constants too large"
Greg Ungerer562d2f82005-11-07 14:09:50 +1000164#endif
165
Sascha Hauer22f6b862009-04-15 01:32:18 +0000166/* Interrupt events/masks. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167#define FEC_ENET_HBERR ((uint)0x80000000) /* Heartbeat error */
168#define FEC_ENET_BABR ((uint)0x40000000) /* Babbling receiver */
169#define FEC_ENET_BABT ((uint)0x20000000) /* Babbling transmitter */
170#define FEC_ENET_GRA ((uint)0x10000000) /* Graceful stop complete */
171#define FEC_ENET_TXF ((uint)0x08000000) /* Full frame transmitted */
172#define FEC_ENET_TXB ((uint)0x04000000) /* A buffer was transmitted */
173#define FEC_ENET_RXF ((uint)0x02000000) /* Full frame received */
174#define FEC_ENET_RXB ((uint)0x01000000) /* A buffer was received */
175#define FEC_ENET_MII ((uint)0x00800000) /* MII interrupt */
176#define FEC_ENET_EBERR ((uint)0x00400000) /* SDMA bus error */
177
Wolfram Sang4bee1f92010-07-21 02:51:13 +0000178#define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII)
Frank Lidc975382013-01-28 18:31:42 +0000179#define FEC_RX_DISABLED_IMASK (FEC_DEFAULT_IMASK & (~FEC_ENET_RXF))
Wolfram Sang4bee1f92010-07-21 02:51:13 +0000180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181/* The FEC stores dest/src/type, data, and checksum for receive packets.
182 */
183#define PKT_MAXBUF_SIZE 1518
184#define PKT_MINBUF_SIZE 64
185#define PKT_MAXBLR_SIZE 1520
186
Jim Baxter4c09eed2013-04-19 08:10:49 +0000187/* FEC receive acceleration */
188#define FEC_RACC_IPDIS (1 << 1)
189#define FEC_RACC_PRODIS (1 << 2)
190#define FEC_RACC_OPTIONS (FEC_RACC_IPDIS | FEC_RACC_PRODIS)
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192/*
Matt Waddel6b265292006-06-27 13:10:56 +1000193 * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 * size bits. Other FEC hardware does not, so we need to take that into
195 * account when setting it.
196 */
Greg Ungerer562d2f82005-11-07 14:09:50 +1000197#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
Uwe Kleine-König085e79e2011-01-17 09:52:18 +0100198 defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199#define OPT_FRAME_SIZE (PKT_MAXBUF_SIZE << 16)
200#else
201#define OPT_FRAME_SIZE 0
202#endif
203
Bryan Wue6b043d2010-03-31 02:10:44 +0000204/* FEC MII MMFR bits definition */
205#define FEC_MMFR_ST (1 << 30)
206#define FEC_MMFR_OP_READ (2 << 28)
207#define FEC_MMFR_OP_WRITE (1 << 28)
208#define FEC_MMFR_PA(v) ((v & 0x1f) << 23)
209#define FEC_MMFR_RA(v) ((v & 0x1f) << 18)
210#define FEC_MMFR_TA (2 << 16)
211#define FEC_MMFR_DATA(v) (v & 0xffff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
Rogerio Pimentelc3b084c2011-12-27 14:07:37 -0500213#define FEC_MII_TIMEOUT 30000 /* us */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Sascha Hauer22f6b862009-04-15 01:32:18 +0000215/* Transmitter timeout */
216#define TX_TIMEOUT (2 * HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Frank Libaa70a52013-01-16 16:55:58 +0000218#define FEC_PAUSE_FLAG_AUTONEG 0x1
219#define FEC_PAUSE_FLAG_ENABLE 0x2
220
Lothar Waßmanne163cc92011-12-07 21:59:31 +0000221static int mii_cnt;
222
Frank Liff43da82013-01-03 16:04:23 +0000223static struct bufdesc *fec_enet_get_nextdesc(struct bufdesc *bdp, int is_ex)
224{
225 struct bufdesc_ex *ex = (struct bufdesc_ex *)bdp;
226 if (is_ex)
227 return (struct bufdesc *)(ex + 1);
228 else
229 return bdp + 1;
230}
231
232static struct bufdesc *fec_enet_get_prevdesc(struct bufdesc *bdp, int is_ex)
233{
234 struct bufdesc_ex *ex = (struct bufdesc_ex *)bdp;
235 if (is_ex)
236 return (struct bufdesc *)(ex - 1);
237 else
238 return bdp - 1;
239}
240
Shawn Guob5680e02011-01-05 21:13:13 +0000241static void *swap_buffer(void *bufaddr, int len)
242{
243 int i;
244 unsigned int *buf = bufaddr;
245
246 for (i = 0; i < (len + 3) / 4; i++, buf++)
247 *buf = cpu_to_be32(*buf);
248
249 return bufaddr;
250}
251
Jim Baxter4c09eed2013-04-19 08:10:49 +0000252static int
253fec_enet_clear_csum(struct sk_buff *skb, struct net_device *ndev)
254{
255 /* Only run for packets requiring a checksum. */
256 if (skb->ip_summed != CHECKSUM_PARTIAL)
257 return 0;
258
259 if (unlikely(skb_cow_head(skb, 0)))
260 return -1;
261
262 *(__sum16 *)(skb->head + skb->csum_start + skb->csum_offset) = 0;
263
264 return 0;
265}
266
Denis Kirjanovc7621cb2010-06-02 09:15:47 +0000267static netdev_tx_t
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100268fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100270 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guob5680e02011-01-05 21:13:13 +0000271 const struct platform_device_id *id_entry =
272 platform_get_device_id(fep->pdev);
Sascha Hauer2e285322009-04-15 01:32:16 +0000273 struct bufdesc *bdp;
Greg Ungerer9555b312009-08-06 17:58:18 +0000274 void *bufaddr;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000275 unsigned short status;
Frank Lide5fb0a2013-03-03 17:34:25 +0000276 unsigned int index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 if (!fep->link) {
Jim Baxter4c09eed2013-04-19 08:10:49 +0000279 /* Link is down or auto-negotiation is in progress. */
Patrick McHardy5b548142009-06-12 06:22:29 +0000280 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 }
282
283 /* Fill in a Tx ring entry */
284 bdp = fep->cur_tx;
285
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000286 status = bdp->cbd_sc;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000287
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000288 if (status & BD_ENET_TX_READY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 /* Ooops. All transmit buffers are full. Bail out.
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100290 * This should not happen, since ndev->tbusy should be set.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 */
Joe Perches31b77202013-04-13 19:03:17 +0000292 netdev_err(ndev, "tx queue full!\n");
Patrick McHardy5b548142009-06-12 06:22:29 +0000293 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Jim Baxter4c09eed2013-04-19 08:10:49 +0000296 /* Protocol checksum off-load for TCP and UDP. */
297 if (fec_enet_clear_csum(skb, ndev)) {
298 kfree_skb(skb);
299 return NETDEV_TX_OK;
300 }
301
Sascha Hauer22f6b862009-04-15 01:32:18 +0000302 /* Clear all of the status flags */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000303 status &= ~BD_ENET_TX_STATS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Sascha Hauer22f6b862009-04-15 01:32:18 +0000305 /* Set buffer length and buffer pointer */
Greg Ungerer9555b312009-08-06 17:58:18 +0000306 bufaddr = skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 bdp->cbd_datlen = skb->len;
308
309 /*
Sascha Hauer22f6b862009-04-15 01:32:18 +0000310 * On some FEC implementations data must be aligned on
311 * 4-byte boundaries. Use bounce buffers to copy data
312 * and get it aligned. Ugh.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 */
Frank Lide5fb0a2013-03-03 17:34:25 +0000314 if (fep->bufdesc_ex)
315 index = (struct bufdesc_ex *)bdp -
316 (struct bufdesc_ex *)fep->tx_bd_base;
317 else
318 index = bdp - fep->tx_bd_base;
319
Greg Ungerer9555b312009-08-06 17:58:18 +0000320 if (((unsigned long) bufaddr) & FEC_ALIGNMENT) {
Uwe Kleine-König8a73b0b2011-01-13 21:34:31 +0100321 memcpy(fep->tx_bounce[index], skb->data, skb->len);
Greg Ungerer9555b312009-08-06 17:58:18 +0000322 bufaddr = fep->tx_bounce[index];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 }
324
Shawn Guob5680e02011-01-05 21:13:13 +0000325 /*
326 * Some design made an incorrect assumption on endian mode of
327 * the system that it's running on. As the result, driver has to
328 * swap every frame going to and coming from the controller.
329 */
330 if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
331 swap_buffer(bufaddr, skb->len);
332
Sascha Hauer22f6b862009-04-15 01:32:18 +0000333 /* Save skb pointer */
Frank Lide5fb0a2013-03-03 17:34:25 +0000334 fep->tx_skbuff[index] = skb;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 /* Push the data cache so the CPM does not get stale memory
337 * data.
338 */
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +0100339 bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, bufaddr,
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000340 FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000342 /* Send it on its way. Tell FEC it's ready, interrupt when done,
343 * it's the last BD of the frame, and to put the CRC on the end.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000345 status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 | BD_ENET_TX_LAST | BD_ENET_TX_TC);
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000347 bdp->cbd_sc = status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Frank Liff43da82013-01-03 16:04:23 +0000349 if (fep->bufdesc_ex) {
Frank Li6605b732012-10-30 18:25:31 +0000350
Frank Liff43da82013-01-03 16:04:23 +0000351 struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
352 ebdp->cbd_bdu = 0;
353 if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
354 fep->hwts_tx_en)) {
355 ebdp->cbd_esc = (BD_ENET_TX_TS | BD_ENET_TX_INT);
356 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
357 } else {
Frank Liff43da82013-01-03 16:04:23 +0000358 ebdp->cbd_esc = BD_ENET_TX_INT;
Jim Baxter4c09eed2013-04-19 08:10:49 +0000359
360 /* Enable protocol checksum flags
361 * We do not bother with the IP Checksum bits as they
362 * are done by the kernel
363 */
364 if (skb->ip_summed == CHECKSUM_PARTIAL)
365 ebdp->cbd_esc |= BD_ENET_TX_PINS;
Frank Liff43da82013-01-03 16:04:23 +0000366 }
Frank Li6605b732012-10-30 18:25:31 +0000367 }
Sascha Hauer22f6b862009-04-15 01:32:18 +0000368 /* If this was the last BD in the ring, start at the beginning again. */
369 if (status & BD_ENET_TX_WRAP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 bdp = fep->tx_bd_base;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000371 else
Frank Liff43da82013-01-03 16:04:23 +0000372 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Sascha Hauer2e285322009-04-15 01:32:16 +0000374 fep->cur_tx = bdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Frank Lide5fb0a2013-03-03 17:34:25 +0000376 if (fep->cur_tx == fep->dirty_tx)
377 netif_stop_queue(ndev);
Richard Cochran18a03b92011-06-12 02:18:59 +0000378
Frank Lide5fb0a2013-03-03 17:34:25 +0000379 /* Trigger transmission start */
380 writel(0, fep->hwp + FEC_X_DES_ACTIVE);
381
382 skb_tx_timestamp(skb);
Richard Cochrana0087a32011-06-19 03:31:40 +0000383
Patrick McHardy6ed10652009-06-23 06:03:08 +0000384 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385}
386
Frank Li14109a52013-03-26 16:12:03 +0000387/* Init RX & TX buffer descriptors
388 */
389static void fec_enet_bd_init(struct net_device *dev)
390{
391 struct fec_enet_private *fep = netdev_priv(dev);
392 struct bufdesc *bdp;
393 unsigned int i;
394
395 /* Initialize the receive buffer descriptors. */
396 bdp = fep->rx_bd_base;
397 for (i = 0; i < RX_RING_SIZE; i++) {
398
399 /* Initialize the BD for every fragment in the page. */
400 if (bdp->cbd_bufaddr)
401 bdp->cbd_sc = BD_ENET_RX_EMPTY;
402 else
403 bdp->cbd_sc = 0;
404 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
405 }
406
407 /* Set the last buffer to wrap */
408 bdp = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
409 bdp->cbd_sc |= BD_SC_WRAP;
410
411 fep->cur_rx = fep->rx_bd_base;
412
413 /* ...and the same for transmit */
414 bdp = fep->tx_bd_base;
415 fep->cur_tx = bdp;
416 for (i = 0; i < TX_RING_SIZE; i++) {
417
418 /* Initialize the BD for every fragment in the page. */
419 bdp->cbd_sc = 0;
420 if (bdp->cbd_bufaddr && fep->tx_skbuff[i]) {
421 dev_kfree_skb_any(fep->tx_skbuff[i]);
422 fep->tx_skbuff[i] = NULL;
423 }
424 bdp->cbd_bufaddr = 0;
425 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
426 }
427
428 /* Set the last buffer to wrap */
429 bdp = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
430 bdp->cbd_sc |= BD_SC_WRAP;
431 fep->dirty_tx = bdp;
432}
433
Uwe Kleine-König45993652011-01-19 20:47:04 +0100434/* This function is called to start or restart the FEC during a link
435 * change. This only happens when switching between half and full
436 * duplex.
437 */
438static void
439fec_restart(struct net_device *ndev, int duplex)
440{
441 struct fec_enet_private *fep = netdev_priv(ndev);
442 const struct platform_device_id *id_entry =
443 platform_get_device_id(fep->pdev);
444 int i;
Jim Baxter4c09eed2013-04-19 08:10:49 +0000445 u32 val;
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100446 u32 temp_mac[2];
447 u32 rcntl = OPT_FRAME_SIZE | 0x04;
Shawn Guo230dec62011-09-23 02:12:48 +0000448 u32 ecntl = 0x2; /* ETHEREN */
Uwe Kleine-König45993652011-01-19 20:47:04 +0100449
Frank Li54309fa2013-05-07 14:08:44 +0000450 if (netif_running(ndev)) {
451 netif_device_detach(ndev);
452 napi_disable(&fep->napi);
453 netif_stop_queue(ndev);
Fabio Estevam31691342013-05-15 07:06:26 +0000454 netif_tx_lock_bh(ndev);
Frank Li54309fa2013-05-07 14:08:44 +0000455 }
456
Uwe Kleine-König45993652011-01-19 20:47:04 +0100457 /* Whack a reset. We should wait for this. */
458 writel(1, fep->hwp + FEC_ECNTRL);
459 udelay(10);
460
461 /*
462 * enet-mac reset will reset mac address registers too,
463 * so need to reconfigure it.
464 */
465 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
466 memcpy(&temp_mac, ndev->dev_addr, ETH_ALEN);
467 writel(cpu_to_be32(temp_mac[0]), fep->hwp + FEC_ADDR_LOW);
468 writel(cpu_to_be32(temp_mac[1]), fep->hwp + FEC_ADDR_HIGH);
469 }
470
471 /* Clear any outstanding interrupt. */
472 writel(0xffc00000, fep->hwp + FEC_IEVENT);
473
474 /* Reset all multicast. */
475 writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
476 writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
477#ifndef CONFIG_M5272
478 writel(0, fep->hwp + FEC_HASH_TABLE_HIGH);
479 writel(0, fep->hwp + FEC_HASH_TABLE_LOW);
480#endif
481
482 /* Set maximum receive buffer size. */
483 writel(PKT_MAXBLR_SIZE, fep->hwp + FEC_R_BUFF_SIZE);
484
Frank Li14109a52013-03-26 16:12:03 +0000485 fec_enet_bd_init(ndev);
486
Uwe Kleine-König45993652011-01-19 20:47:04 +0100487 /* Set receive and transmit descriptor base. */
488 writel(fep->bd_dma, fep->hwp + FEC_R_DES_START);
Frank Liff43da82013-01-03 16:04:23 +0000489 if (fep->bufdesc_ex)
490 writel((unsigned long)fep->bd_dma + sizeof(struct bufdesc_ex)
491 * RX_RING_SIZE, fep->hwp + FEC_X_DES_START);
492 else
493 writel((unsigned long)fep->bd_dma + sizeof(struct bufdesc)
494 * RX_RING_SIZE, fep->hwp + FEC_X_DES_START);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100495
Uwe Kleine-König45993652011-01-19 20:47:04 +0100496
Uwe Kleine-König45993652011-01-19 20:47:04 +0100497 for (i = 0; i <= TX_RING_MOD_MASK; i++) {
498 if (fep->tx_skbuff[i]) {
499 dev_kfree_skb_any(fep->tx_skbuff[i]);
500 fep->tx_skbuff[i] = NULL;
501 }
502 }
503
504 /* Enable MII mode */
505 if (duplex) {
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100506 /* FD enable */
Uwe Kleine-König45993652011-01-19 20:47:04 +0100507 writel(0x04, fep->hwp + FEC_X_CNTRL);
508 } else {
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100509 /* No Rcv on Xmit */
510 rcntl |= 0x02;
Uwe Kleine-König45993652011-01-19 20:47:04 +0100511 writel(0x0, fep->hwp + FEC_X_CNTRL);
512 }
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100513
Uwe Kleine-König45993652011-01-19 20:47:04 +0100514 fep->full_duplex = duplex;
515
516 /* Set MII speed */
517 writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
518
Guenter Roeckd1391932013-06-18 10:04:59 -0700519#if !defined(CONFIG_M5272)
Jim Baxter4c09eed2013-04-19 08:10:49 +0000520 /* set RX checksum */
521 val = readl(fep->hwp + FEC_RACC);
522 if (fep->csum_flags & FLAG_RX_CSUM_ENABLED)
523 val |= FEC_RACC_OPTIONS;
524 else
525 val &= ~FEC_RACC_OPTIONS;
526 writel(val, fep->hwp + FEC_RACC);
Guenter Roeckd1391932013-06-18 10:04:59 -0700527#endif
Jim Baxter4c09eed2013-04-19 08:10:49 +0000528
Uwe Kleine-König45993652011-01-19 20:47:04 +0100529 /*
530 * The phy interface and speed need to get configured
531 * differently on enet-mac.
532 */
533 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100534 /* Enable flow control and length check */
535 rcntl |= 0x40000000 | 0x00000020;
Uwe Kleine-König45993652011-01-19 20:47:04 +0100536
Shawn Guo230dec62011-09-23 02:12:48 +0000537 /* RGMII, RMII or MII */
538 if (fep->phy_interface == PHY_INTERFACE_MODE_RGMII)
539 rcntl |= (1 << 6);
540 else if (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100541 rcntl |= (1 << 8);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100542 else
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100543 rcntl &= ~(1 << 8);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100544
Shawn Guo230dec62011-09-23 02:12:48 +0000545 /* 1G, 100M or 10M */
546 if (fep->phy_dev) {
547 if (fep->phy_dev->speed == SPEED_1000)
548 ecntl |= (1 << 5);
549 else if (fep->phy_dev->speed == SPEED_100)
550 rcntl &= ~(1 << 9);
551 else
552 rcntl |= (1 << 9);
553 }
Uwe Kleine-König45993652011-01-19 20:47:04 +0100554 } else {
555#ifdef FEC_MIIGSK_ENR
Shawn Guo0ca1e292011-07-01 18:11:22 +0800556 if (id_entry->driver_data & FEC_QUIRK_USE_GASKET) {
Eric Benard8d82f212012-01-12 06:10:28 +0000557 u32 cfgr;
Uwe Kleine-König45993652011-01-19 20:47:04 +0100558 /* disable the gasket and wait */
559 writel(0, fep->hwp + FEC_MIIGSK_ENR);
560 while (readl(fep->hwp + FEC_MIIGSK_ENR) & 4)
561 udelay(1);
562
563 /*
564 * configure the gasket:
565 * RMII, 50 MHz, no loopback, no echo
Shawn Guo0ca1e292011-07-01 18:11:22 +0800566 * MII, 25 MHz, no loopback, no echo
Uwe Kleine-König45993652011-01-19 20:47:04 +0100567 */
Eric Benard8d82f212012-01-12 06:10:28 +0000568 cfgr = (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
569 ? BM_MIIGSK_CFGR_RMII : BM_MIIGSK_CFGR_MII;
570 if (fep->phy_dev && fep->phy_dev->speed == SPEED_10)
571 cfgr |= BM_MIIGSK_CFGR_FRCONT_10M;
572 writel(cfgr, fep->hwp + FEC_MIIGSK_CFGR);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100573
574 /* re-enable the gasket */
575 writel(2, fep->hwp + FEC_MIIGSK_ENR);
576 }
577#endif
578 }
Frank Libaa70a52013-01-16 16:55:58 +0000579
Guenter Roeckd1391932013-06-18 10:04:59 -0700580#if !defined(CONFIG_M5272)
Frank Libaa70a52013-01-16 16:55:58 +0000581 /* enable pause frame*/
582 if ((fep->pause_flag & FEC_PAUSE_FLAG_ENABLE) ||
583 ((fep->pause_flag & FEC_PAUSE_FLAG_AUTONEG) &&
584 fep->phy_dev && fep->phy_dev->pause)) {
585 rcntl |= FEC_ENET_FCE;
586
Jim Baxter4c09eed2013-04-19 08:10:49 +0000587 /* set FIFO threshold parameter to reduce overrun */
Frank Libaa70a52013-01-16 16:55:58 +0000588 writel(FEC_ENET_RSEM_V, fep->hwp + FEC_R_FIFO_RSEM);
589 writel(FEC_ENET_RSFL_V, fep->hwp + FEC_R_FIFO_RSFL);
590 writel(FEC_ENET_RAEM_V, fep->hwp + FEC_R_FIFO_RAEM);
591 writel(FEC_ENET_RAFL_V, fep->hwp + FEC_R_FIFO_RAFL);
592
593 /* OPD */
594 writel(FEC_ENET_OPD_V, fep->hwp + FEC_OPD);
595 } else {
596 rcntl &= ~FEC_ENET_FCE;
597 }
Guenter Roeckd1391932013-06-18 10:04:59 -0700598#endif /* !defined(CONFIG_M5272) */
Frank Libaa70a52013-01-16 16:55:58 +0000599
Uwe Kleine-Königcd1f4022011-01-25 22:11:25 +0100600 writel(rcntl, fep->hwp + FEC_R_CNTRL);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100601
Shawn Guo230dec62011-09-23 02:12:48 +0000602 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
603 /* enable ENET endian swap */
604 ecntl |= (1 << 8);
605 /* enable ENET store and forward mode */
606 writel(1 << 8, fep->hwp + FEC_X_WMRK);
607 }
608
Frank Liff43da82013-01-03 16:04:23 +0000609 if (fep->bufdesc_ex)
610 ecntl |= (1 << 4);
Frank Li6605b732012-10-30 18:25:31 +0000611
Uwe Kleine-König45993652011-01-19 20:47:04 +0100612 /* And last, enable the transmit and receive processing */
Shawn Guo230dec62011-09-23 02:12:48 +0000613 writel(ecntl, fep->hwp + FEC_ECNTRL);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100614 writel(0, fep->hwp + FEC_R_DES_ACTIVE);
615
Frank Liff43da82013-01-03 16:04:23 +0000616 if (fep->bufdesc_ex)
617 fec_ptp_start_cyclecounter(ndev);
618
Uwe Kleine-König45993652011-01-19 20:47:04 +0100619 /* Enable interrupts we wish to service */
620 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
Frank Li54309fa2013-05-07 14:08:44 +0000621
622 if (netif_running(ndev)) {
Fabio Estevam31691342013-05-15 07:06:26 +0000623 netif_tx_unlock_bh(ndev);
Fabio Estevam1ed0d562013-05-15 07:06:27 +0000624 netif_wake_queue(ndev);
625 napi_enable(&fep->napi);
626 netif_device_attach(ndev);
Frank Li54309fa2013-05-07 14:08:44 +0000627 }
Uwe Kleine-König45993652011-01-19 20:47:04 +0100628}
629
630static void
631fec_stop(struct net_device *ndev)
632{
633 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guo230dec62011-09-23 02:12:48 +0000634 const struct platform_device_id *id_entry =
635 platform_get_device_id(fep->pdev);
Lothar Waßmann42431dc2011-12-07 21:59:30 +0000636 u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100637
638 /* We cannot expect a graceful transmit stop without link !!! */
639 if (fep->link) {
640 writel(1, fep->hwp + FEC_X_CNTRL); /* Graceful transmit stop */
641 udelay(10);
642 if (!(readl(fep->hwp + FEC_IEVENT) & FEC_ENET_GRA))
Joe Perches31b77202013-04-13 19:03:17 +0000643 netdev_err(ndev, "Graceful transmit stop did not complete!\n");
Uwe Kleine-König45993652011-01-19 20:47:04 +0100644 }
645
646 /* Whack a reset. We should wait for this. */
647 writel(1, fep->hwp + FEC_ECNTRL);
648 udelay(10);
649 writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
650 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
Shawn Guo230dec62011-09-23 02:12:48 +0000651
652 /* We have to keep ENET enabled to have MII interrupt stay working */
Lothar Waßmann42431dc2011-12-07 21:59:30 +0000653 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
Shawn Guo230dec62011-09-23 02:12:48 +0000654 writel(2, fep->hwp + FEC_ECNTRL);
Lothar Waßmann42431dc2011-12-07 21:59:30 +0000655 writel(rmii_mode, fep->hwp + FEC_R_CNTRL);
656 }
Uwe Kleine-König45993652011-01-19 20:47:04 +0100657}
658
659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660static void
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100661fec_timeout(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100663 struct fec_enet_private *fep = netdev_priv(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100665 ndev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
Frank Li54309fa2013-05-07 14:08:44 +0000667 fep->delay_work.timeout = true;
668 schedule_delayed_work(&(fep->delay_work.delay_work), 0);
669}
670
671static void fec_enet_work(struct work_struct *work)
672{
673 struct fec_enet_private *fep =
674 container_of(work,
675 struct fec_enet_private,
676 delay_work.delay_work.work);
677
678 if (fep->delay_work.timeout) {
679 fep->delay_work.timeout = false;
680 fec_restart(fep->netdev, fep->full_duplex);
681 netif_wake_queue(fep->netdev);
682 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683}
684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685static void
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100686fec_enet_tx(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687{
688 struct fec_enet_private *fep;
Sascha Hauer2e285322009-04-15 01:32:16 +0000689 struct bufdesc *bdp;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000690 unsigned short status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 struct sk_buff *skb;
Frank Lide5fb0a2013-03-03 17:34:25 +0000692 int index = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100694 fep = netdev_priv(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 bdp = fep->dirty_tx;
696
Frank Lide5fb0a2013-03-03 17:34:25 +0000697 /* get next bdp of dirty_tx */
698 if (bdp->cbd_sc & BD_ENET_TX_WRAP)
699 bdp = fep->tx_bd_base;
700 else
701 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
702
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000703 while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
Frank Lide5fb0a2013-03-03 17:34:25 +0000704
705 /* current queue is empty */
706 if (bdp == fep->cur_tx)
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000707 break;
708
Frank Lide5fb0a2013-03-03 17:34:25 +0000709 if (fep->bufdesc_ex)
710 index = (struct bufdesc_ex *)bdp -
711 (struct bufdesc_ex *)fep->tx_bd_base;
712 else
713 index = bdp - fep->tx_bd_base;
714
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +0100715 dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
716 FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000717 bdp->cbd_bufaddr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
Frank Lide5fb0a2013-03-03 17:34:25 +0000719 skb = fep->tx_skbuff[index];
720
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 /* Check for errors. */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000722 if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 BD_ENET_TX_RL | BD_ENET_TX_UN |
724 BD_ENET_TX_CSL)) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100725 ndev->stats.tx_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000726 if (status & BD_ENET_TX_HB) /* No heartbeat */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100727 ndev->stats.tx_heartbeat_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000728 if (status & BD_ENET_TX_LC) /* Late collision */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100729 ndev->stats.tx_window_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000730 if (status & BD_ENET_TX_RL) /* Retrans limit */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100731 ndev->stats.tx_aborted_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000732 if (status & BD_ENET_TX_UN) /* Underrun */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100733 ndev->stats.tx_fifo_errors++;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000734 if (status & BD_ENET_TX_CSL) /* Carrier lost */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100735 ndev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 } else {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100737 ndev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 }
739
Frank Liff43da82013-01-03 16:04:23 +0000740 if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS) &&
741 fep->bufdesc_ex) {
Frank Li6605b732012-10-30 18:25:31 +0000742 struct skb_shared_hwtstamps shhwtstamps;
743 unsigned long flags;
Frank Liff43da82013-01-03 16:04:23 +0000744 struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
Frank Li6605b732012-10-30 18:25:31 +0000745
746 memset(&shhwtstamps, 0, sizeof(shhwtstamps));
747 spin_lock_irqsave(&fep->tmreg_lock, flags);
748 shhwtstamps.hwtstamp = ns_to_ktime(
Frank Liff43da82013-01-03 16:04:23 +0000749 timecounter_cyc2time(&fep->tc, ebdp->ts));
Frank Li6605b732012-10-30 18:25:31 +0000750 spin_unlock_irqrestore(&fep->tmreg_lock, flags);
751 skb_tstamp_tx(skb, &shhwtstamps);
752 }
Frank Liff43da82013-01-03 16:04:23 +0000753
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000754 if (status & BD_ENET_TX_READY)
Joe Perches31b77202013-04-13 19:03:17 +0000755 netdev_err(ndev, "HEY! Enet xmit interrupt and TX_READY\n");
Sascha Hauer22f6b862009-04-15 01:32:18 +0000756
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 /* Deferred means some collisions occurred during transmit,
758 * but we eventually sent the packet OK.
759 */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000760 if (status & BD_ENET_TX_DEF)
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100761 ndev->stats.collisions++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400762
Sascha Hauer22f6b862009-04-15 01:32:18 +0000763 /* Free the sk buffer associated with this last transmit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 dev_kfree_skb_any(skb);
Frank Lide5fb0a2013-03-03 17:34:25 +0000765 fep->tx_skbuff[index] = NULL;
766
767 fep->dirty_tx = bdp;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400768
Sascha Hauer22f6b862009-04-15 01:32:18 +0000769 /* Update pointer to next buffer descriptor to be transmitted */
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000770 if (status & BD_ENET_TX_WRAP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 bdp = fep->tx_bd_base;
772 else
Frank Liff43da82013-01-03 16:04:23 +0000773 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400774
Sascha Hauer22f6b862009-04-15 01:32:18 +0000775 /* Since we have freed up a buffer, the ring is no longer full
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 */
Frank Lide5fb0a2013-03-03 17:34:25 +0000777 if (fep->dirty_tx != fep->cur_tx) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100778 if (netif_queue_stopped(ndev))
779 netif_wake_queue(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 }
781 }
Frank Lide5fb0a2013-03-03 17:34:25 +0000782 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783}
784
785
786/* During a receive, the cur_rx points to the current incoming buffer.
787 * When we update through the ring, if the next incoming buffer has
788 * not been given to the system, we just set the empty indicator,
789 * effectively tossing the packet.
790 */
Frank Lidc975382013-01-28 18:31:42 +0000791static int
792fec_enet_rx(struct net_device *ndev, int budget)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100794 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guob5680e02011-01-05 21:13:13 +0000795 const struct platform_device_id *id_entry =
796 platform_get_device_id(fep->pdev);
Sascha Hauer2e285322009-04-15 01:32:16 +0000797 struct bufdesc *bdp;
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000798 unsigned short status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 struct sk_buff *skb;
800 ushort pkt_len;
801 __u8 *data;
Frank Lidc975382013-01-28 18:31:42 +0000802 int pkt_received = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400803
Greg Ungerer0e702ab2006-06-27 13:19:33 +1000804#ifdef CONFIG_M532x
805 flush_cache_all();
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400806#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 /* First, grab all of the stats for the incoming packet.
809 * These get messed up if we get called due to a busy condition.
810 */
811 bdp = fep->cur_rx;
812
Sascha Hauer22f6b862009-04-15 01:32:18 +0000813 while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Frank Lidc975382013-01-28 18:31:42 +0000815 if (pkt_received >= budget)
816 break;
817 pkt_received++;
818
Sascha Hauer22f6b862009-04-15 01:32:18 +0000819 /* Since we have allocated space to hold a complete frame,
820 * the last indicator should be set.
821 */
822 if ((status & BD_ENET_RX_LAST) == 0)
Joe Perches31b77202013-04-13 19:03:17 +0000823 netdev_err(ndev, "rcv is not +last\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
Sascha Hauer22f6b862009-04-15 01:32:18 +0000825 if (!fep->opened)
826 goto rx_processing_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Sascha Hauer22f6b862009-04-15 01:32:18 +0000828 /* Check for errors. */
829 if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 BD_ENET_RX_CR | BD_ENET_RX_OV)) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100831 ndev->stats.rx_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000832 if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
833 /* Frame too long or too short. */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100834 ndev->stats.rx_length_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000835 }
836 if (status & BD_ENET_RX_NO) /* Frame alignment */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100837 ndev->stats.rx_frame_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000838 if (status & BD_ENET_RX_CR) /* CRC Error */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100839 ndev->stats.rx_crc_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000840 if (status & BD_ENET_RX_OV) /* FIFO overrun */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100841 ndev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 }
Sascha Hauer22f6b862009-04-15 01:32:18 +0000843
844 /* Report late collisions as a frame error.
845 * On this error, the BD is closed, but we don't know what we
846 * have in the buffer. So, just drop this frame on the floor.
847 */
848 if (status & BD_ENET_RX_CL) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100849 ndev->stats.rx_errors++;
850 ndev->stats.rx_frame_errors++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000851 goto rx_processing_done;
852 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Sascha Hauer22f6b862009-04-15 01:32:18 +0000854 /* Process the incoming frame. */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100855 ndev->stats.rx_packets++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000856 pkt_len = bdp->cbd_datlen;
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100857 ndev->stats.rx_bytes += pkt_len;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000858 data = (__u8*)__va(bdp->cbd_bufaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +0100860 dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
861 FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
Sascha Hauerccdc4f12009-01-28 23:03:09 +0000862
Shawn Guob5680e02011-01-05 21:13:13 +0000863 if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
864 swap_buffer(data, pkt_len);
865
Sascha Hauer22f6b862009-04-15 01:32:18 +0000866 /* This does 16 byte alignment, exactly what we need.
867 * The packet length includes FCS, but we don't want to
868 * include that when passing upstream as it messes up
869 * bridging applications.
870 */
Fabio Estevamb72061a2012-02-07 08:27:31 +0000871 skb = netdev_alloc_skb(ndev, pkt_len - 4 + NET_IP_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872
Sascha Hauer85498892009-04-15 01:32:21 +0000873 if (unlikely(!skb)) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100874 ndev->stats.rx_dropped++;
Sascha Hauer22f6b862009-04-15 01:32:18 +0000875 } else {
Sascha Hauer85498892009-04-15 01:32:21 +0000876 skb_reserve(skb, NET_IP_ALIGN);
Sascha Hauer22f6b862009-04-15 01:32:18 +0000877 skb_put(skb, pkt_len - 4); /* Make room */
878 skb_copy_to_linear_data(skb, data, pkt_len - 4);
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100879 skb->protocol = eth_type_trans(skb, ndev);
Frank Liff43da82013-01-03 16:04:23 +0000880
Frank Li6605b732012-10-30 18:25:31 +0000881 /* Get receive timestamp from the skb */
Frank Liff43da82013-01-03 16:04:23 +0000882 if (fep->hwts_rx_en && fep->bufdesc_ex) {
Frank Li6605b732012-10-30 18:25:31 +0000883 struct skb_shared_hwtstamps *shhwtstamps =
884 skb_hwtstamps(skb);
885 unsigned long flags;
Frank Liff43da82013-01-03 16:04:23 +0000886 struct bufdesc_ex *ebdp =
887 (struct bufdesc_ex *)bdp;
Frank Li6605b732012-10-30 18:25:31 +0000888
889 memset(shhwtstamps, 0, sizeof(*shhwtstamps));
890
891 spin_lock_irqsave(&fep->tmreg_lock, flags);
892 shhwtstamps->hwtstamp = ns_to_ktime(
Frank Liff43da82013-01-03 16:04:23 +0000893 timecounter_cyc2time(&fep->tc, ebdp->ts));
Frank Li6605b732012-10-30 18:25:31 +0000894 spin_unlock_irqrestore(&fep->tmreg_lock, flags);
895 }
Frank Liff43da82013-01-03 16:04:23 +0000896
Jim Baxter4c09eed2013-04-19 08:10:49 +0000897 if (fep->bufdesc_ex &&
898 (fep->csum_flags & FLAG_RX_CSUM_ENABLED)) {
899 struct bufdesc_ex *ebdp =
900 (struct bufdesc_ex *)bdp;
901 if (!(ebdp->cbd_esc & FLAG_RX_CSUM_ERROR)) {
902 /* don't check it */
903 skb->ip_summed = CHECKSUM_UNNECESSARY;
904 } else {
905 skb_checksum_none_assert(skb);
906 }
907 }
908
Richard Cochran18a03b92011-06-12 02:18:59 +0000909 if (!skb_defer_rx_timestamp(skb))
Frank Lidc975382013-01-28 18:31:42 +0000910 napi_gro_receive(&fep->napi, skb);
Sascha Hauer22f6b862009-04-15 01:32:18 +0000911 }
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +0000912
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +0100913 bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, data,
914 FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
Sascha Hauer22f6b862009-04-15 01:32:18 +0000915rx_processing_done:
916 /* Clear the status flags for this buffer */
917 status &= ~BD_ENET_RX_STATS;
918
919 /* Mark the buffer empty */
920 status |= BD_ENET_RX_EMPTY;
921 bdp->cbd_sc = status;
922
Frank Liff43da82013-01-03 16:04:23 +0000923 if (fep->bufdesc_ex) {
924 struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
925
926 ebdp->cbd_esc = BD_ENET_RX_INT;
927 ebdp->cbd_prot = 0;
928 ebdp->cbd_bdu = 0;
929 }
Frank Li6605b732012-10-30 18:25:31 +0000930
Sascha Hauer22f6b862009-04-15 01:32:18 +0000931 /* Update BD pointer to next entry */
932 if (status & BD_ENET_RX_WRAP)
933 bdp = fep->rx_bd_base;
934 else
Frank Liff43da82013-01-03 16:04:23 +0000935 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
Sascha Hauer22f6b862009-04-15 01:32:18 +0000936 /* Doing this here will keep the FEC running while we process
937 * incoming frames. On a heavily loaded network, we should be
938 * able to keep up at the expense of system resources.
939 */
940 writel(0, fep->hwp + FEC_R_DES_ACTIVE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 }
Sascha Hauer2e285322009-04-15 01:32:16 +0000942 fep->cur_rx = bdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
Frank Lidc975382013-01-28 18:31:42 +0000944 return pkt_received;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945}
946
Uwe Kleine-König45993652011-01-19 20:47:04 +0100947static irqreturn_t
948fec_enet_interrupt(int irq, void *dev_id)
949{
950 struct net_device *ndev = dev_id;
951 struct fec_enet_private *fep = netdev_priv(ndev);
952 uint int_events;
953 irqreturn_t ret = IRQ_NONE;
954
955 do {
956 int_events = readl(fep->hwp + FEC_IEVENT);
957 writel(int_events, fep->hwp + FEC_IEVENT);
958
Frank Lide5fb0a2013-03-03 17:34:25 +0000959 if (int_events & (FEC_ENET_RXF | FEC_ENET_TXF)) {
Uwe Kleine-König45993652011-01-19 20:47:04 +0100960 ret = IRQ_HANDLED;
Frank Lidc975382013-01-28 18:31:42 +0000961
962 /* Disable the RX interrupt */
963 if (napi_schedule_prep(&fep->napi)) {
964 writel(FEC_RX_DISABLED_IMASK,
965 fep->hwp + FEC_IMASK);
966 __napi_schedule(&fep->napi);
967 }
Uwe Kleine-König45993652011-01-19 20:47:04 +0100968 }
969
Uwe Kleine-König45993652011-01-19 20:47:04 +0100970 if (int_events & FEC_ENET_MII) {
971 ret = IRQ_HANDLED;
972 complete(&fep->mdio_done);
973 }
974 } while (int_events);
975
976 return ret;
977}
978
Frank Lidc975382013-01-28 18:31:42 +0000979static int fec_enet_rx_napi(struct napi_struct *napi, int budget)
980{
981 struct net_device *ndev = napi->dev;
982 int pkts = fec_enet_rx(ndev, budget);
983 struct fec_enet_private *fep = netdev_priv(ndev);
Uwe Kleine-König45993652011-01-19 20:47:04 +0100984
Frank Lide5fb0a2013-03-03 17:34:25 +0000985 fec_enet_tx(ndev);
986
Frank Lidc975382013-01-28 18:31:42 +0000987 if (pkts < budget) {
988 napi_complete(napi);
989 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
990 }
991 return pkts;
992}
Uwe Kleine-König45993652011-01-19 20:47:04 +0100993
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994/* ------------------------------------------------------------------------- */
Fabio Estevam0c7768a2013-01-07 17:42:56 +0000995static void fec_get_mac(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +0100997 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guo49da97d2011-01-05 21:13:11 +0000998 struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
Greg Ungerer7dd6a2a2005-09-12 11:18:10 +1000999 unsigned char *iap, tmpaddr[ETH_ALEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
Shawn Guo49da97d2011-01-05 21:13:11 +00001001 /*
1002 * try to get mac address in following order:
1003 *
1004 * 1) module parameter via kernel command line in form
1005 * fec.macaddr=0x00,0x04,0x9f,0x01,0x30,0xe0
1006 */
1007 iap = macaddr;
1008
1009 /*
Shawn Guoca2cc332011-06-25 02:04:35 +08001010 * 2) from device tree data
1011 */
1012 if (!is_valid_ether_addr(iap)) {
1013 struct device_node *np = fep->pdev->dev.of_node;
1014 if (np) {
1015 const char *mac = of_get_mac_address(np);
1016 if (mac)
1017 iap = (unsigned char *) mac;
1018 }
1019 }
Shawn Guoca2cc332011-06-25 02:04:35 +08001020
1021 /*
1022 * 3) from flash or fuse (via platform data)
Shawn Guo49da97d2011-01-05 21:13:11 +00001023 */
1024 if (!is_valid_ether_addr(iap)) {
1025#ifdef CONFIG_M5272
1026 if (FEC_FLASHMAC)
1027 iap = (unsigned char *)FEC_FLASHMAC;
1028#else
1029 if (pdata)
Lothar Waßmann589efdc2011-12-07 21:59:29 +00001030 iap = (unsigned char *)&pdata->mac;
Shawn Guo49da97d2011-01-05 21:13:11 +00001031#endif
1032 }
1033
1034 /*
Shawn Guoca2cc332011-06-25 02:04:35 +08001035 * 4) FEC mac registers set by bootloader
Shawn Guo49da97d2011-01-05 21:13:11 +00001036 */
1037 if (!is_valid_ether_addr(iap)) {
1038 *((unsigned long *) &tmpaddr[0]) =
1039 be32_to_cpu(readl(fep->hwp + FEC_ADDR_LOW));
1040 *((unsigned short *) &tmpaddr[4]) =
1041 be16_to_cpu(readl(fep->hwp + FEC_ADDR_HIGH) >> 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 iap = &tmpaddr[0];
1043 }
1044
Lucas Stachff5b2fa2013-06-03 00:38:39 +00001045 /*
1046 * 5) random mac address
1047 */
1048 if (!is_valid_ether_addr(iap)) {
1049 /* Report it and use a random ethernet address instead */
1050 netdev_err(ndev, "Invalid MAC address: %pM\n", iap);
1051 eth_hw_addr_random(ndev);
1052 netdev_info(ndev, "Using random MAC address: %pM\n",
1053 ndev->dev_addr);
1054 return;
1055 }
1056
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001057 memcpy(ndev->dev_addr, iap, ETH_ALEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
Shawn Guo49da97d2011-01-05 21:13:11 +00001059 /* Adjust MAC if using macaddr */
1060 if (iap == macaddr)
Shawn Guo43af9402011-12-05 05:01:15 +00001061 ndev->dev_addr[ETH_ALEN-1] = macaddr[ETH_ALEN-1] + fep->dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
1064/* ------------------------------------------------------------------------- */
1065
Bryan Wue6b043d2010-03-31 02:10:44 +00001066/*
1067 * Phy section
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001069static void fec_enet_adjust_link(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001071 struct fec_enet_private *fep = netdev_priv(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001072 struct phy_device *phy_dev = fep->phy_dev;
Bryan Wue6b043d2010-03-31 02:10:44 +00001073 int status_change = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
Bryan Wue6b043d2010-03-31 02:10:44 +00001075 /* Prevent a state halted on mii error */
1076 if (fep->mii_timeout && phy_dev->state == PHY_HALTED) {
1077 phy_dev->state = PHY_RESUMING;
Frank Li54309fa2013-05-07 14:08:44 +00001078 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 }
Bryan Wue6b043d2010-03-31 02:10:44 +00001080
Bryan Wue6b043d2010-03-31 02:10:44 +00001081 if (phy_dev->link) {
Lucas Stachd97e7492013-03-14 05:12:01 +00001082 if (!fep->link) {
Lothar Waßmann6ea07222011-12-07 21:59:27 +00001083 fep->link = phy_dev->link;
Bryan Wue6b043d2010-03-31 02:10:44 +00001084 status_change = 1;
1085 }
Bryan Wue6b043d2010-03-31 02:10:44 +00001086
Lucas Stachd97e7492013-03-14 05:12:01 +00001087 if (fep->full_duplex != phy_dev->duplex)
1088 status_change = 1;
1089
1090 if (phy_dev->speed != fep->speed) {
1091 fep->speed = phy_dev->speed;
1092 status_change = 1;
1093 }
1094
1095 /* if any of the above changed restart the FEC */
1096 if (status_change)
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001097 fec_restart(ndev, phy_dev->duplex);
Lucas Stachd97e7492013-03-14 05:12:01 +00001098 } else {
1099 if (fep->link) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001100 fec_stop(ndev);
Lucas Stach8d7ed0f2013-04-16 00:42:42 +00001101 fep->link = phy_dev->link;
Lucas Stachd97e7492013-03-14 05:12:01 +00001102 status_change = 1;
1103 }
Bryan Wue6b043d2010-03-31 02:10:44 +00001104 }
1105
Bryan Wue6b043d2010-03-31 02:10:44 +00001106 if (status_change)
1107 phy_print_status(phy_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108}
1109
Bryan Wue6b043d2010-03-31 02:10:44 +00001110static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111{
Bryan Wue6b043d2010-03-31 02:10:44 +00001112 struct fec_enet_private *fep = bus->priv;
Baruch Siach97b72e42010-07-11 21:12:51 +00001113 unsigned long time_left;
Bryan Wue6b043d2010-03-31 02:10:44 +00001114
1115 fep->mii_timeout = 0;
Baruch Siach97b72e42010-07-11 21:12:51 +00001116 init_completion(&fep->mdio_done);
Bryan Wue6b043d2010-03-31 02:10:44 +00001117
1118 /* start a read op */
1119 writel(FEC_MMFR_ST | FEC_MMFR_OP_READ |
1120 FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
1121 FEC_MMFR_TA, fep->hwp + FEC_MII_DATA);
1122
1123 /* wait for end of transfer */
Baruch Siach97b72e42010-07-11 21:12:51 +00001124 time_left = wait_for_completion_timeout(&fep->mdio_done,
1125 usecs_to_jiffies(FEC_MII_TIMEOUT));
1126 if (time_left == 0) {
1127 fep->mii_timeout = 1;
Joe Perches31b77202013-04-13 19:03:17 +00001128 netdev_err(fep->netdev, "MDIO read timeout\n");
Baruch Siach97b72e42010-07-11 21:12:51 +00001129 return -ETIMEDOUT;
Bryan Wue6b043d2010-03-31 02:10:44 +00001130 }
1131
1132 /* return value */
1133 return FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));
1134}
1135
1136static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
1137 u16 value)
1138{
1139 struct fec_enet_private *fep = bus->priv;
Baruch Siach97b72e42010-07-11 21:12:51 +00001140 unsigned long time_left;
Bryan Wue6b043d2010-03-31 02:10:44 +00001141
1142 fep->mii_timeout = 0;
Baruch Siach97b72e42010-07-11 21:12:51 +00001143 init_completion(&fep->mdio_done);
Bryan Wue6b043d2010-03-31 02:10:44 +00001144
Shawn Guo862f0982011-01-05 21:13:09 +00001145 /* start a write op */
1146 writel(FEC_MMFR_ST | FEC_MMFR_OP_WRITE |
Bryan Wue6b043d2010-03-31 02:10:44 +00001147 FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
1148 FEC_MMFR_TA | FEC_MMFR_DATA(value),
1149 fep->hwp + FEC_MII_DATA);
1150
1151 /* wait for end of transfer */
Baruch Siach97b72e42010-07-11 21:12:51 +00001152 time_left = wait_for_completion_timeout(&fep->mdio_done,
1153 usecs_to_jiffies(FEC_MII_TIMEOUT));
1154 if (time_left == 0) {
1155 fep->mii_timeout = 1;
Joe Perches31b77202013-04-13 19:03:17 +00001156 netdev_err(fep->netdev, "MDIO write timeout\n");
Baruch Siach97b72e42010-07-11 21:12:51 +00001157 return -ETIMEDOUT;
Bryan Wue6b043d2010-03-31 02:10:44 +00001158 }
1159
1160 return 0;
1161}
1162
1163static int fec_enet_mdio_reset(struct mii_bus *bus)
1164{
1165 return 0;
1166}
1167
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001168static int fec_enet_mii_probe(struct net_device *ndev)
Bryan Wue6b043d2010-03-31 02:10:44 +00001169{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001170 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guo230dec62011-09-23 02:12:48 +00001171 const struct platform_device_id *id_entry =
1172 platform_get_device_id(fep->pdev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001173 struct phy_device *phy_dev = NULL;
Greg Ungerer6fcc0402010-10-11 21:03:05 +00001174 char mdio_bus_id[MII_BUS_ID_SIZE];
1175 char phy_name[MII_BUS_ID_SIZE + 3];
1176 int phy_id;
Shawn Guo43af9402011-12-05 05:01:15 +00001177 int dev_id = fep->dev_id;
Bryan Wue6b043d2010-03-31 02:10:44 +00001178
Bryan Wu418bd0d2010-05-28 03:40:39 -07001179 fep->phy_dev = NULL;
1180
Greg Ungerer6fcc0402010-10-11 21:03:05 +00001181 /* check for attached phy */
1182 for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
1183 if ((fep->mii_bus->phy_mask & (1 << phy_id)))
1184 continue;
1185 if (fep->mii_bus->phy_map[phy_id] == NULL)
1186 continue;
1187 if (fep->mii_bus->phy_map[phy_id]->phy_id == 0)
1188 continue;
Shawn Guob5680e02011-01-05 21:13:13 +00001189 if (dev_id--)
1190 continue;
Greg Ungerer6fcc0402010-10-11 21:03:05 +00001191 strncpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
1192 break;
Bryan Wue6b043d2010-03-31 02:10:44 +00001193 }
1194
Greg Ungerer6fcc0402010-10-11 21:03:05 +00001195 if (phy_id >= PHY_MAX_ADDR) {
Joe Perches31b77202013-04-13 19:03:17 +00001196 netdev_info(ndev, "no PHY, assuming direct connection to switch\n");
Florian Fainelliea51ade92012-02-13 01:23:22 +00001197 strncpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE);
Greg Ungerer6fcc0402010-10-11 21:03:05 +00001198 phy_id = 0;
1199 }
1200
Richard Zhaoa7ed07d2012-01-29 22:08:12 +00001201 snprintf(phy_name, sizeof(phy_name), PHY_ID_FMT, mdio_bus_id, phy_id);
Florian Fainellif9a8f832013-01-14 00:52:52 +00001202 phy_dev = phy_connect(ndev, phy_name, &fec_enet_adjust_link,
Shawn Guo230dec62011-09-23 02:12:48 +00001203 fep->phy_interface);
Greg Ungerer6fcc0402010-10-11 21:03:05 +00001204 if (IS_ERR(phy_dev)) {
Joe Perches31b77202013-04-13 19:03:17 +00001205 netdev_err(ndev, "could not attach to PHY\n");
Greg Ungerer6fcc0402010-10-11 21:03:05 +00001206 return PTR_ERR(phy_dev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001207 }
1208
1209 /* mask with MAC supported features */
Frank Libaa70a52013-01-16 16:55:58 +00001210 if (id_entry->driver_data & FEC_QUIRK_HAS_GBIT) {
Shawn Guo230dec62011-09-23 02:12:48 +00001211 phy_dev->supported &= PHY_GBIT_FEATURES;
Guenter Roeckd1391932013-06-18 10:04:59 -07001212#if !defined(CONFIG_M5272)
Frank Libaa70a52013-01-16 16:55:58 +00001213 phy_dev->supported |= SUPPORTED_Pause;
Guenter Roeckd1391932013-06-18 10:04:59 -07001214#endif
Frank Libaa70a52013-01-16 16:55:58 +00001215 }
Shawn Guo230dec62011-09-23 02:12:48 +00001216 else
1217 phy_dev->supported &= PHY_BASIC_FEATURES;
1218
Bryan Wue6b043d2010-03-31 02:10:44 +00001219 phy_dev->advertising = phy_dev->supported;
1220
1221 fep->phy_dev = phy_dev;
1222 fep->link = 0;
1223 fep->full_duplex = 0;
1224
Joe Perches31b77202013-04-13 19:03:17 +00001225 netdev_info(ndev, "Freescale FEC PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
1226 fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),
1227 fep->phy_dev->irq);
Bryan Wu418bd0d2010-05-28 03:40:39 -07001228
Bryan Wue6b043d2010-03-31 02:10:44 +00001229 return 0;
1230}
1231
1232static int fec_enet_mii_init(struct platform_device *pdev)
1233{
Shawn Guob5680e02011-01-05 21:13:13 +00001234 static struct mii_bus *fec0_mii_bus;
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001235 struct net_device *ndev = platform_get_drvdata(pdev);
1236 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guob5680e02011-01-05 21:13:13 +00001237 const struct platform_device_id *id_entry =
1238 platform_get_device_id(fep->pdev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001239 int err = -ENXIO, i;
1240
Shawn Guob5680e02011-01-05 21:13:13 +00001241 /*
1242 * The dual fec interfaces are not equivalent with enet-mac.
1243 * Here are the differences:
1244 *
1245 * - fec0 supports MII & RMII modes while fec1 only supports RMII
1246 * - fec0 acts as the 1588 time master while fec1 is slave
1247 * - external phys can only be configured by fec0
1248 *
1249 * That is to say fec1 can not work independently. It only works
1250 * when fec0 is working. The reason behind this design is that the
1251 * second interface is added primarily for Switch mode.
1252 *
1253 * Because of the last point above, both phys are attached on fec0
1254 * mdio interface in board design, and need to be configured by
1255 * fec0 mii_bus.
1256 */
Shawn Guo43af9402011-12-05 05:01:15 +00001257 if ((id_entry->driver_data & FEC_QUIRK_ENET_MAC) && fep->dev_id > 0) {
Shawn Guob5680e02011-01-05 21:13:13 +00001258 /* fec1 uses fec0 mii_bus */
Lothar Waßmanne163cc92011-12-07 21:59:31 +00001259 if (mii_cnt && fec0_mii_bus) {
1260 fep->mii_bus = fec0_mii_bus;
1261 mii_cnt++;
1262 return 0;
1263 }
1264 return -ENOENT;
Shawn Guob5680e02011-01-05 21:13:13 +00001265 }
1266
Bryan Wue6b043d2010-03-31 02:10:44 +00001267 fep->mii_timeout = 0;
1268
1269 /*
1270 * Set MII speed to 2.5 MHz (= clk_get_rate() / 2 * phy_speed)
Shawn Guo230dec62011-09-23 02:12:48 +00001271 *
1272 * The formula for FEC MDC is 'ref_freq / (MII_SPEED x 2)' while
1273 * for ENET-MAC is 'ref_freq / ((MII_SPEED + 1) x 2)'. The i.MX28
1274 * Reference Manual has an error on this, and gets fixed on i.MX6Q
1275 * document.
Bryan Wue6b043d2010-03-31 02:10:44 +00001276 */
Sascha Hauerf4d40de2012-03-07 09:30:49 +01001277 fep->phy_speed = DIV_ROUND_UP(clk_get_rate(fep->clk_ahb), 5000000);
Shawn Guo230dec62011-09-23 02:12:48 +00001278 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
1279 fep->phy_speed--;
1280 fep->phy_speed <<= 1;
Bryan Wue6b043d2010-03-31 02:10:44 +00001281 writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
1282
1283 fep->mii_bus = mdiobus_alloc();
1284 if (fep->mii_bus == NULL) {
1285 err = -ENOMEM;
1286 goto err_out;
1287 }
1288
1289 fep->mii_bus->name = "fec_enet_mii_bus";
1290 fep->mii_bus->read = fec_enet_mdio_read;
1291 fep->mii_bus->write = fec_enet_mdio_write;
1292 fep->mii_bus->reset = fec_enet_mdio_reset;
Florian Fainelli391420f2012-01-09 23:59:13 +00001293 snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
1294 pdev->name, fep->dev_id + 1);
Bryan Wue6b043d2010-03-31 02:10:44 +00001295 fep->mii_bus->priv = fep;
1296 fep->mii_bus->parent = &pdev->dev;
1297
1298 fep->mii_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
1299 if (!fep->mii_bus->irq) {
1300 err = -ENOMEM;
1301 goto err_out_free_mdiobus;
1302 }
1303
1304 for (i = 0; i < PHY_MAX_ADDR; i++)
1305 fep->mii_bus->irq[i] = PHY_POLL;
1306
Bryan Wue6b043d2010-03-31 02:10:44 +00001307 if (mdiobus_register(fep->mii_bus))
1308 goto err_out_free_mdio_irq;
1309
Lothar Waßmanne163cc92011-12-07 21:59:31 +00001310 mii_cnt++;
1311
Shawn Guob5680e02011-01-05 21:13:13 +00001312 /* save fec0 mii_bus */
1313 if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
1314 fec0_mii_bus = fep->mii_bus;
1315
Bryan Wue6b043d2010-03-31 02:10:44 +00001316 return 0;
1317
Bryan Wue6b043d2010-03-31 02:10:44 +00001318err_out_free_mdio_irq:
1319 kfree(fep->mii_bus->irq);
1320err_out_free_mdiobus:
1321 mdiobus_free(fep->mii_bus);
1322err_out:
1323 return err;
1324}
1325
1326static void fec_enet_mii_remove(struct fec_enet_private *fep)
1327{
Lothar Waßmanne163cc92011-12-07 21:59:31 +00001328 if (--mii_cnt == 0) {
1329 mdiobus_unregister(fep->mii_bus);
1330 kfree(fep->mii_bus->irq);
1331 mdiobus_free(fep->mii_bus);
1332 }
Bryan Wue6b043d2010-03-31 02:10:44 +00001333}
1334
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001335static int fec_enet_get_settings(struct net_device *ndev,
Bryan Wue6b043d2010-03-31 02:10:44 +00001336 struct ethtool_cmd *cmd)
1337{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001338 struct fec_enet_private *fep = netdev_priv(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001339 struct phy_device *phydev = fep->phy_dev;
1340
1341 if (!phydev)
1342 return -ENODEV;
1343
1344 return phy_ethtool_gset(phydev, cmd);
1345}
1346
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001347static int fec_enet_set_settings(struct net_device *ndev,
Bryan Wue6b043d2010-03-31 02:10:44 +00001348 struct ethtool_cmd *cmd)
1349{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001350 struct fec_enet_private *fep = netdev_priv(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001351 struct phy_device *phydev = fep->phy_dev;
1352
1353 if (!phydev)
1354 return -ENODEV;
1355
1356 return phy_ethtool_sset(phydev, cmd);
1357}
1358
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001359static void fec_enet_get_drvinfo(struct net_device *ndev,
Bryan Wue6b043d2010-03-31 02:10:44 +00001360 struct ethtool_drvinfo *info)
1361{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001362 struct fec_enet_private *fep = netdev_priv(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Jiri Pirko7826d432013-01-06 00:44:26 +00001364 strlcpy(info->driver, fep->pdev->dev.driver->name,
1365 sizeof(info->driver));
1366 strlcpy(info->version, "Revision: 1.0", sizeof(info->version));
1367 strlcpy(info->bus_info, dev_name(&ndev->dev), sizeof(info->bus_info));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368}
Bryan Wue6b043d2010-03-31 02:10:44 +00001369
Frank Li5ebae482013-01-06 16:25:07 +00001370static int fec_enet_get_ts_info(struct net_device *ndev,
1371 struct ethtool_ts_info *info)
1372{
1373 struct fec_enet_private *fep = netdev_priv(ndev);
1374
1375 if (fep->bufdesc_ex) {
1376
1377 info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
1378 SOF_TIMESTAMPING_RX_SOFTWARE |
1379 SOF_TIMESTAMPING_SOFTWARE |
1380 SOF_TIMESTAMPING_TX_HARDWARE |
1381 SOF_TIMESTAMPING_RX_HARDWARE |
1382 SOF_TIMESTAMPING_RAW_HARDWARE;
1383 if (fep->ptp_clock)
1384 info->phc_index = ptp_clock_index(fep->ptp_clock);
1385 else
1386 info->phc_index = -1;
1387
1388 info->tx_types = (1 << HWTSTAMP_TX_OFF) |
1389 (1 << HWTSTAMP_TX_ON);
1390
1391 info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
1392 (1 << HWTSTAMP_FILTER_ALL);
1393 return 0;
1394 } else {
1395 return ethtool_op_get_ts_info(ndev, info);
1396 }
1397}
1398
Guenter Roeckd1391932013-06-18 10:04:59 -07001399#if !defined(CONFIG_M5272)
1400
Frank Libaa70a52013-01-16 16:55:58 +00001401static void fec_enet_get_pauseparam(struct net_device *ndev,
1402 struct ethtool_pauseparam *pause)
1403{
1404 struct fec_enet_private *fep = netdev_priv(ndev);
1405
1406 pause->autoneg = (fep->pause_flag & FEC_PAUSE_FLAG_AUTONEG) != 0;
1407 pause->tx_pause = (fep->pause_flag & FEC_PAUSE_FLAG_ENABLE) != 0;
1408 pause->rx_pause = pause->tx_pause;
1409}
1410
1411static int fec_enet_set_pauseparam(struct net_device *ndev,
1412 struct ethtool_pauseparam *pause)
1413{
1414 struct fec_enet_private *fep = netdev_priv(ndev);
1415
1416 if (pause->tx_pause != pause->rx_pause) {
1417 netdev_info(ndev,
1418 "hardware only support enable/disable both tx and rx");
1419 return -EINVAL;
1420 }
1421
1422 fep->pause_flag = 0;
1423
1424 /* tx pause must be same as rx pause */
1425 fep->pause_flag |= pause->rx_pause ? FEC_PAUSE_FLAG_ENABLE : 0;
1426 fep->pause_flag |= pause->autoneg ? FEC_PAUSE_FLAG_AUTONEG : 0;
1427
1428 if (pause->rx_pause || pause->autoneg) {
1429 fep->phy_dev->supported |= ADVERTISED_Pause;
1430 fep->phy_dev->advertising |= ADVERTISED_Pause;
1431 } else {
1432 fep->phy_dev->supported &= ~ADVERTISED_Pause;
1433 fep->phy_dev->advertising &= ~ADVERTISED_Pause;
1434 }
1435
1436 if (pause->autoneg) {
1437 if (netif_running(ndev))
1438 fec_stop(ndev);
1439 phy_start_aneg(fep->phy_dev);
1440 }
1441 if (netif_running(ndev))
1442 fec_restart(ndev, 0);
1443
1444 return 0;
1445}
1446
Guenter Roeckd1391932013-06-18 10:04:59 -07001447#endif /* !defined(CONFIG_M5272) */
1448
stephen hemminger9b07be42012-01-04 12:59:49 +00001449static const struct ethtool_ops fec_enet_ethtool_ops = {
Guenter Roeckd1391932013-06-18 10:04:59 -07001450#if !defined(CONFIG_M5272)
Frank Libaa70a52013-01-16 16:55:58 +00001451 .get_pauseparam = fec_enet_get_pauseparam,
1452 .set_pauseparam = fec_enet_set_pauseparam,
Guenter Roeckd1391932013-06-18 10:04:59 -07001453#endif
Bryan Wue6b043d2010-03-31 02:10:44 +00001454 .get_settings = fec_enet_get_settings,
1455 .set_settings = fec_enet_set_settings,
1456 .get_drvinfo = fec_enet_get_drvinfo,
1457 .get_link = ethtool_op_get_link,
Frank Li5ebae482013-01-06 16:25:07 +00001458 .get_ts_info = fec_enet_get_ts_info,
Bryan Wue6b043d2010-03-31 02:10:44 +00001459};
1460
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001461static int fec_enet_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
Bryan Wue6b043d2010-03-31 02:10:44 +00001462{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001463 struct fec_enet_private *fep = netdev_priv(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00001464 struct phy_device *phydev = fep->phy_dev;
1465
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001466 if (!netif_running(ndev))
Bryan Wue6b043d2010-03-31 02:10:44 +00001467 return -EINVAL;
1468
1469 if (!phydev)
1470 return -ENODEV;
1471
Frank Liff43da82013-01-03 16:04:23 +00001472 if (cmd == SIOCSHWTSTAMP && fep->bufdesc_ex)
Frank Li6605b732012-10-30 18:25:31 +00001473 return fec_ptp_ioctl(ndev, rq, cmd);
Frank Liff43da82013-01-03 16:04:23 +00001474
Richard Cochran28b04112010-07-17 08:48:55 +00001475 return phy_mii_ioctl(phydev, rq, cmd);
Bryan Wue6b043d2010-03-31 02:10:44 +00001476}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001478static void fec_enet_free_buffers(struct net_device *ndev)
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001479{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001480 struct fec_enet_private *fep = netdev_priv(ndev);
Fabio Estevamda2191e2013-03-20 12:31:07 -03001481 unsigned int i;
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001482 struct sk_buff *skb;
1483 struct bufdesc *bdp;
1484
1485 bdp = fep->rx_bd_base;
1486 for (i = 0; i < RX_RING_SIZE; i++) {
1487 skb = fep->rx_skbuff[i];
1488
1489 if (bdp->cbd_bufaddr)
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +01001490 dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001491 FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
1492 if (skb)
1493 dev_kfree_skb(skb);
Frank Liff43da82013-01-03 16:04:23 +00001494 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001495 }
1496
1497 bdp = fep->tx_bd_base;
1498 for (i = 0; i < TX_RING_SIZE; i++)
1499 kfree(fep->tx_bounce[i]);
1500}
1501
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001502static int fec_enet_alloc_buffers(struct net_device *ndev)
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001503{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001504 struct fec_enet_private *fep = netdev_priv(ndev);
Fabio Estevamda2191e2013-03-20 12:31:07 -03001505 unsigned int i;
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001506 struct sk_buff *skb;
1507 struct bufdesc *bdp;
1508
1509 bdp = fep->rx_bd_base;
1510 for (i = 0; i < RX_RING_SIZE; i++) {
Fabio Estevamb72061a2012-02-07 08:27:31 +00001511 skb = netdev_alloc_skb(ndev, FEC_ENET_RX_FRSIZE);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001512 if (!skb) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001513 fec_enet_free_buffers(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001514 return -ENOMEM;
1515 }
1516 fep->rx_skbuff[i] = skb;
1517
Uwe Kleine-Königd1ab1f52011-01-20 09:26:38 +01001518 bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, skb->data,
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001519 FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
1520 bdp->cbd_sc = BD_ENET_RX_EMPTY;
Frank Liff43da82013-01-03 16:04:23 +00001521
1522 if (fep->bufdesc_ex) {
1523 struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
1524 ebdp->cbd_esc = BD_ENET_RX_INT;
1525 }
1526
1527 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001528 }
1529
1530 /* Set the last buffer to wrap. */
Frank Liff43da82013-01-03 16:04:23 +00001531 bdp = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001532 bdp->cbd_sc |= BD_SC_WRAP;
1533
1534 bdp = fep->tx_bd_base;
1535 for (i = 0; i < TX_RING_SIZE; i++) {
1536 fep->tx_bounce[i] = kmalloc(FEC_ENET_TX_FRSIZE, GFP_KERNEL);
1537
1538 bdp->cbd_sc = 0;
1539 bdp->cbd_bufaddr = 0;
Frank Li6605b732012-10-30 18:25:31 +00001540
Frank Liff43da82013-01-03 16:04:23 +00001541 if (fep->bufdesc_ex) {
1542 struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
Jim Baxter96d22222013-03-26 05:25:07 +00001543 ebdp->cbd_esc = BD_ENET_TX_INT;
Frank Liff43da82013-01-03 16:04:23 +00001544 }
1545
1546 bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001547 }
1548
1549 /* Set the last buffer to wrap. */
Frank Liff43da82013-01-03 16:04:23 +00001550 bdp = fec_enet_get_prevdesc(bdp, fep->bufdesc_ex);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001551 bdp->cbd_sc |= BD_SC_WRAP;
1552
1553 return 0;
1554}
1555
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556static int
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001557fec_enet_open(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001559 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001560 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
Frank Lidc975382013-01-28 18:31:42 +00001562 napi_enable(&fep->napi);
1563
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 /* I should reset the ring buffers here, but I don't yet know
1565 * a simple way to do that.
1566 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001568 ret = fec_enet_alloc_buffers(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001569 if (ret)
1570 return ret;
1571
Bryan Wu418bd0d2010-05-28 03:40:39 -07001572 /* Probe and connect to PHY when open the interface */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001573 ret = fec_enet_mii_probe(ndev);
Bryan Wu418bd0d2010-05-28 03:40:39 -07001574 if (ret) {
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001575 fec_enet_free_buffers(ndev);
Bryan Wu418bd0d2010-05-28 03:40:39 -07001576 return ret;
1577 }
Bryan Wue6b043d2010-03-31 02:10:44 +00001578 phy_start(fep->phy_dev);
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001579 netif_start_queue(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 fep->opened = 1;
Sascha Hauer22f6b862009-04-15 01:32:18 +00001581 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582}
1583
1584static int
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001585fec_enet_close(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001587 struct fec_enet_private *fep = netdev_priv(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Sascha Hauer22f6b862009-04-15 01:32:18 +00001589 /* Don't know what to do yet. */
Georg Hofmann3f104c32013-03-14 06:54:09 +00001590 napi_disable(&fep->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 fep->opened = 0;
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001592 netif_stop_queue(ndev);
1593 fec_stop(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Uwe Kleine-Könige497ba82011-01-17 20:04:23 +01001595 if (fep->phy_dev) {
1596 phy_stop(fep->phy_dev);
Bryan Wu418bd0d2010-05-28 03:40:39 -07001597 phy_disconnect(fep->phy_dev);
Uwe Kleine-Könige497ba82011-01-17 20:04:23 +01001598 }
Bryan Wu418bd0d2010-05-28 03:40:39 -07001599
Uwe Kleine-Königdb8880b2011-01-19 20:26:39 +01001600 fec_enet_free_buffers(ndev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001601
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 return 0;
1603}
1604
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605/* Set or clear the multicast filter for this adaptor.
1606 * Skeleton taken from sunlance driver.
1607 * The CPM Ethernet implementation allows Multicast as well as individual
1608 * MAC address filtering. Some of the drivers check to make sure it is
1609 * a group multicast address, and discard those that are not. I guess I
1610 * will do the same for now, but just remove the test if you want
1611 * individual filtering as well (do the upper net layers want or support
1612 * this kind of feature?).
1613 */
1614
1615#define HASH_BITS 6 /* #bits in hash */
1616#define CRC32_POLY 0xEDB88320
1617
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001618static void set_multicast_list(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001620 struct fec_enet_private *fep = netdev_priv(ndev);
Jiri Pirko22bedad2010-04-01 21:22:57 +00001621 struct netdev_hw_addr *ha;
Jiri Pirko48e2f182010-02-22 09:22:26 +00001622 unsigned int i, bit, data, crc, tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 unsigned char hash;
1624
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001625 if (ndev->flags & IFF_PROMISC) {
Sascha Hauerf44d6302009-04-15 03:11:30 +00001626 tmp = readl(fep->hwp + FEC_R_CNTRL);
1627 tmp |= 0x8;
1628 writel(tmp, fep->hwp + FEC_R_CNTRL);
Sascha Hauer4e831832009-04-15 01:32:19 +00001629 return;
1630 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
Sascha Hauer4e831832009-04-15 01:32:19 +00001632 tmp = readl(fep->hwp + FEC_R_CNTRL);
1633 tmp &= ~0x8;
1634 writel(tmp, fep->hwp + FEC_R_CNTRL);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001635
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001636 if (ndev->flags & IFF_ALLMULTI) {
Sascha Hauer4e831832009-04-15 01:32:19 +00001637 /* Catch all multicast addresses, so set the
1638 * filter to all 1's
1639 */
1640 writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
1641 writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
Sascha Hauer4e831832009-04-15 01:32:19 +00001643 return;
1644 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001645
Sascha Hauer4e831832009-04-15 01:32:19 +00001646 /* Clear filter and add the addresses in hash register
1647 */
1648 writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
1649 writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001651 netdev_for_each_mc_addr(ha, ndev) {
Sascha Hauer4e831832009-04-15 01:32:19 +00001652 /* calculate crc32 value of mac address */
1653 crc = 0xffffffff;
1654
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001655 for (i = 0; i < ndev->addr_len; i++) {
Jiri Pirko22bedad2010-04-01 21:22:57 +00001656 data = ha->addr[i];
Sascha Hauer4e831832009-04-15 01:32:19 +00001657 for (bit = 0; bit < 8; bit++, data >>= 1) {
1658 crc = (crc >> 1) ^
1659 (((crc ^ data) & 1) ? CRC32_POLY : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 }
1661 }
Sascha Hauer4e831832009-04-15 01:32:19 +00001662
1663 /* only upper 6 bits (HASH_BITS) are used
1664 * which point to specific bit in he hash registers
1665 */
1666 hash = (crc >> (32 - HASH_BITS)) & 0x3f;
1667
1668 if (hash > 31) {
1669 tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
1670 tmp |= 1 << (hash - 32);
1671 writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
1672 } else {
1673 tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_LOW);
1674 tmp |= 1 << hash;
1675 writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
1676 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 }
1678}
1679
Sascha Hauer22f6b862009-04-15 01:32:18 +00001680/* Set a MAC change in hardware. */
Sascha Hauer009fda82009-04-15 01:32:23 +00001681static int
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001682fec_set_mac_address(struct net_device *ndev, void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001684 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Hauer009fda82009-04-15 01:32:23 +00001685 struct sockaddr *addr = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
Sascha Hauer009fda82009-04-15 01:32:23 +00001687 if (!is_valid_ether_addr(addr->sa_data))
1688 return -EADDRNOTAVAIL;
1689
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001690 memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
Sascha Hauer009fda82009-04-15 01:32:23 +00001691
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001692 writel(ndev->dev_addr[3] | (ndev->dev_addr[2] << 8) |
1693 (ndev->dev_addr[1] << 16) | (ndev->dev_addr[0] << 24),
Sascha Hauerf44d6302009-04-15 03:11:30 +00001694 fep->hwp + FEC_ADDR_LOW);
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001695 writel((ndev->dev_addr[5] << 16) | (ndev->dev_addr[4] << 24),
Mattias Walström7cff0942010-05-05 00:55:48 -07001696 fep->hwp + FEC_ADDR_HIGH);
Sascha Hauer009fda82009-04-15 01:32:23 +00001697 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698}
1699
Xiao Jiang7f5c6ad2011-09-29 02:15:57 +00001700#ifdef CONFIG_NET_POLL_CONTROLLER
Ben Hutchings49ce9c22012-07-10 10:56:00 +00001701/**
1702 * fec_poll_controller - FEC Poll controller function
Xiao Jiang7f5c6ad2011-09-29 02:15:57 +00001703 * @dev: The FEC network adapter
1704 *
1705 * Polled functionality used by netconsole and others in non interrupt mode
1706 *
1707 */
Wei Yongjun47a52472013-03-20 05:06:11 +00001708static void fec_poll_controller(struct net_device *dev)
Xiao Jiang7f5c6ad2011-09-29 02:15:57 +00001709{
1710 int i;
1711 struct fec_enet_private *fep = netdev_priv(dev);
1712
1713 for (i = 0; i < FEC_IRQ_NUM; i++) {
1714 if (fep->irq[i] > 0) {
1715 disable_irq(fep->irq[i]);
1716 fec_enet_interrupt(fep->irq[i], dev);
1717 enable_irq(fep->irq[i]);
1718 }
1719 }
1720}
1721#endif
1722
Jim Baxter4c09eed2013-04-19 08:10:49 +00001723static int fec_set_features(struct net_device *netdev,
1724 netdev_features_t features)
1725{
1726 struct fec_enet_private *fep = netdev_priv(netdev);
1727 netdev_features_t changed = features ^ netdev->features;
1728
1729 netdev->features = features;
1730
1731 /* Receive checksum has been changed */
1732 if (changed & NETIF_F_RXCSUM) {
1733 if (features & NETIF_F_RXCSUM)
1734 fep->csum_flags |= FLAG_RX_CSUM_ENABLED;
1735 else
1736 fep->csum_flags &= ~FLAG_RX_CSUM_ENABLED;
1737
1738 if (netif_running(netdev)) {
1739 fec_stop(netdev);
1740 fec_restart(netdev, fep->phy_dev->duplex);
1741 netif_wake_queue(netdev);
1742 } else {
1743 fec_restart(netdev, fep->phy_dev->duplex);
1744 }
1745 }
1746
1747 return 0;
1748}
1749
Sascha Hauer009fda82009-04-15 01:32:23 +00001750static const struct net_device_ops fec_netdev_ops = {
1751 .ndo_open = fec_enet_open,
1752 .ndo_stop = fec_enet_close,
1753 .ndo_start_xmit = fec_enet_start_xmit,
Jiri Pirkoafc4b132011-08-16 06:29:01 +00001754 .ndo_set_rx_mode = set_multicast_list,
Ben Hutchings635ecaa2009-07-09 17:59:01 +00001755 .ndo_change_mtu = eth_change_mtu,
Sascha Hauer009fda82009-04-15 01:32:23 +00001756 .ndo_validate_addr = eth_validate_addr,
1757 .ndo_tx_timeout = fec_timeout,
1758 .ndo_set_mac_address = fec_set_mac_address,
Uwe Kleine-Königdb8880b2011-01-19 20:26:39 +01001759 .ndo_do_ioctl = fec_enet_ioctl,
Xiao Jiang7f5c6ad2011-09-29 02:15:57 +00001760#ifdef CONFIG_NET_POLL_CONTROLLER
1761 .ndo_poll_controller = fec_poll_controller,
1762#endif
Jim Baxter4c09eed2013-04-19 08:10:49 +00001763 .ndo_set_features = fec_set_features,
Sascha Hauer009fda82009-04-15 01:32:23 +00001764};
1765
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 /*
1767 * XXX: We need to clean up on failure exits here.
Sascha Haueread73182009-01-28 23:03:11 +00001768 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001770static int fec_enet_init(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771{
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001772 struct fec_enet_private *fep = netdev_priv(ndev);
Shawn Guo48496252013-05-08 21:08:22 +00001773 const struct platform_device_id *id_entry =
1774 platform_get_device_id(fep->pdev);
Sascha Hauerf0b3fbe2009-04-15 01:32:24 +00001775 struct bufdesc *cbd_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
Sascha Hauer8d4dd5c2009-04-15 01:32:17 +00001777 /* Allocate memory for buffer descriptors. */
1778 cbd_base = dma_alloc_coherent(NULL, PAGE_SIZE, &fep->bd_dma,
Joe Perchesd0320f72013-03-14 13:07:21 +00001779 GFP_KERNEL);
1780 if (!cbd_base)
Greg Ungerer562d2f82005-11-07 14:09:50 +10001781 return -ENOMEM;
Greg Ungerer562d2f82005-11-07 14:09:50 +10001782
Frank Li14109a52013-03-26 16:12:03 +00001783 memset(cbd_base, 0, PAGE_SIZE);
Sebastian Siewior3b2b74c2008-05-01 14:08:12 +10001784
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001785 fep->netdev = ndev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786
Shawn Guo49da97d2011-01-05 21:13:11 +00001787 /* Get the Ethernet address */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001788 fec_get_mac(ndev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Sascha Hauer8d4dd5c2009-04-15 01:32:17 +00001790 /* Set receive and transmit descriptor base. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 fep->rx_bd_base = cbd_base;
Frank Liff43da82013-01-03 16:04:23 +00001792 if (fep->bufdesc_ex)
1793 fep->tx_bd_base = (struct bufdesc *)
1794 (((struct bufdesc_ex *)cbd_base) + RX_RING_SIZE);
1795 else
1796 fep->tx_bd_base = cbd_base + RX_RING_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
Sascha Hauer22f6b862009-04-15 01:32:18 +00001798 /* The FEC Ethernet specific entries in the device structure */
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001799 ndev->watchdog_timeo = TX_TIMEOUT;
1800 ndev->netdev_ops = &fec_netdev_ops;
1801 ndev->ethtool_ops = &fec_enet_ethtool_ops;
Rob Herring633e7532010-02-05 08:56:20 +00001802
Frank Lidc975382013-01-28 18:31:42 +00001803 writel(FEC_RX_DISABLED_IMASK, fep->hwp + FEC_IMASK);
1804 netif_napi_add(ndev, &fep->napi, fec_enet_rx_napi, FEC_NAPI_WEIGHT);
1805
Shawn Guo48496252013-05-08 21:08:22 +00001806 if (id_entry->driver_data & FEC_QUIRK_HAS_CSUM) {
1807 /* enable hw accelerator */
1808 ndev->features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM
1809 | NETIF_F_RXCSUM);
1810 ndev->hw_features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM
1811 | NETIF_F_RXCSUM);
1812 fep->csum_flags |= FLAG_RX_CSUM_ENABLED;
1813 }
Jim Baxter4c09eed2013-04-19 08:10:49 +00001814
Uwe Kleine-Königc5561672011-01-19 11:58:12 +01001815 fec_restart(ndev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 return 0;
1818}
1819
Shawn Guoca2cc332011-06-25 02:04:35 +08001820#ifdef CONFIG_OF
Bill Pemberton33897cc2012-12-03 09:23:58 -05001821static void fec_reset_phy(struct platform_device *pdev)
Shawn Guoca2cc332011-06-25 02:04:35 +08001822{
1823 int err, phy_reset;
Shawn Guoa3caad02012-06-27 03:45:24 +00001824 int msec = 1;
Shawn Guoca2cc332011-06-25 02:04:35 +08001825 struct device_node *np = pdev->dev.of_node;
1826
1827 if (!np)
Shawn Guoa9b2c8e2011-09-23 02:12:46 +00001828 return;
Shawn Guoca2cc332011-06-25 02:04:35 +08001829
Shawn Guoa3caad02012-06-27 03:45:24 +00001830 of_property_read_u32(np, "phy-reset-duration", &msec);
1831 /* A sane reset duration should not be longer than 1s */
1832 if (msec > 1000)
1833 msec = 1;
1834
Shawn Guoca2cc332011-06-25 02:04:35 +08001835 phy_reset = of_get_named_gpio(np, "phy-reset-gpios", 0);
Fabio Estevam07dcf8e2013-02-18 10:20:31 +00001836 if (!gpio_is_valid(phy_reset))
1837 return;
1838
Shawn Guo119fc002012-06-27 03:45:22 +00001839 err = devm_gpio_request_one(&pdev->dev, phy_reset,
1840 GPIOF_OUT_INIT_LOW, "phy-reset");
Shawn Guoca2cc332011-06-25 02:04:35 +08001841 if (err) {
Fabio Estevam07dcf8e2013-02-18 10:20:31 +00001842 dev_err(&pdev->dev, "failed to get phy-reset-gpios: %d\n", err);
Shawn Guoa9b2c8e2011-09-23 02:12:46 +00001843 return;
Shawn Guoca2cc332011-06-25 02:04:35 +08001844 }
Shawn Guoa3caad02012-06-27 03:45:24 +00001845 msleep(msec);
Shawn Guoca2cc332011-06-25 02:04:35 +08001846 gpio_set_value(phy_reset, 1);
Shawn Guoca2cc332011-06-25 02:04:35 +08001847}
1848#else /* CONFIG_OF */
Fabio Estevam0c7768a2013-01-07 17:42:56 +00001849static void fec_reset_phy(struct platform_device *pdev)
Shawn Guoca2cc332011-06-25 02:04:35 +08001850{
1851 /*
1852 * In case of platform probe, the reset has been done
1853 * by machine code.
1854 */
Shawn Guoca2cc332011-06-25 02:04:35 +08001855}
1856#endif /* CONFIG_OF */
1857
Bill Pemberton33897cc2012-12-03 09:23:58 -05001858static int
Sascha Haueread73182009-01-28 23:03:11 +00001859fec_probe(struct platform_device *pdev)
1860{
1861 struct fec_enet_private *fep;
Baruch Siach5eb32bd2010-05-24 00:36:13 -07001862 struct fec_platform_data *pdata;
Sascha Haueread73182009-01-28 23:03:11 +00001863 struct net_device *ndev;
1864 int i, irq, ret = 0;
1865 struct resource *r;
Shawn Guoca2cc332011-06-25 02:04:35 +08001866 const struct of_device_id *of_id;
Shawn Guo43af9402011-12-05 05:01:15 +00001867 static int dev_id;
Shawn Guob2bccee2012-05-06 20:24:04 +08001868 struct pinctrl *pinctrl;
Shawn Guo5fa9c0f2012-06-27 03:45:21 +00001869 struct regulator *reg_phy;
Shawn Guoca2cc332011-06-25 02:04:35 +08001870
1871 of_id = of_match_device(fec_dt_ids, &pdev->dev);
1872 if (of_id)
1873 pdev->id_entry = of_id->data;
Sascha Haueread73182009-01-28 23:03:11 +00001874
1875 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1876 if (!r)
1877 return -ENXIO;
1878
Sascha Haueread73182009-01-28 23:03:11 +00001879 /* Init network device */
1880 ndev = alloc_etherdev(sizeof(struct fec_enet_private));
Fabio Estevam83e519b2013-03-11 07:32:55 +00001881 if (!ndev)
1882 return -ENOMEM;
Sascha Haueread73182009-01-28 23:03:11 +00001883
1884 SET_NETDEV_DEV(ndev, &pdev->dev);
1885
1886 /* setup board info structure */
1887 fep = netdev_priv(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001888
Guenter Roeckd1391932013-06-18 10:04:59 -07001889#if !defined(CONFIG_M5272)
Frank Libaa70a52013-01-16 16:55:58 +00001890 /* default enable pause frame auto negotiation */
1891 if (pdev->id_entry &&
1892 (pdev->id_entry->driver_data & FEC_QUIRK_HAS_GBIT))
1893 fep->pause_flag |= FEC_PAUSE_FLAG_AUTONEG;
Guenter Roeckd1391932013-06-18 10:04:59 -07001894#endif
Frank Libaa70a52013-01-16 16:55:58 +00001895
Fabio Estevam83e519b2013-03-11 07:32:55 +00001896 fep->hwp = devm_request_and_ioremap(&pdev->dev, r);
Bryan Wue6b043d2010-03-31 02:10:44 +00001897 fep->pdev = pdev;
Shawn Guo43af9402011-12-05 05:01:15 +00001898 fep->dev_id = dev_id++;
Sascha Haueread73182009-01-28 23:03:11 +00001899
Frank Liff43da82013-01-03 16:04:23 +00001900 fep->bufdesc_ex = 0;
1901
Uwe Kleine-König24e531b2011-01-13 22:29:05 +01001902 if (!fep->hwp) {
Sascha Haueread73182009-01-28 23:03:11 +00001903 ret = -ENOMEM;
1904 goto failed_ioremap;
1905 }
1906
1907 platform_set_drvdata(pdev, ndev);
1908
Guenter Roeck6c5f7802013-04-02 09:35:10 +00001909 ret = of_get_phy_mode(pdev->dev.of_node);
Shawn Guoca2cc332011-06-25 02:04:35 +08001910 if (ret < 0) {
1911 pdata = pdev->dev.platform_data;
1912 if (pdata)
1913 fep->phy_interface = pdata->phy;
1914 else
1915 fep->phy_interface = PHY_INTERFACE_MODE_MII;
1916 } else {
1917 fep->phy_interface = ret;
1918 }
1919
Fabio Estevame2f8d552013-02-22 06:40:45 +00001920 pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
1921 if (IS_ERR(pinctrl)) {
1922 ret = PTR_ERR(pinctrl);
1923 goto failed_pin;
1924 }
1925
1926 fep->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
1927 if (IS_ERR(fep->clk_ipg)) {
1928 ret = PTR_ERR(fep->clk_ipg);
1929 goto failed_clk;
1930 }
1931
1932 fep->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
1933 if (IS_ERR(fep->clk_ahb)) {
1934 ret = PTR_ERR(fep->clk_ahb);
1935 goto failed_clk;
1936 }
1937
Linus Torvalds38f56f32013-05-07 11:06:17 -07001938 /* enet_out is optional, depends on board */
1939 fep->clk_enet_out = devm_clk_get(&pdev->dev, "enet_out");
1940 if (IS_ERR(fep->clk_enet_out))
1941 fep->clk_enet_out = NULL;
1942
Fabio Estevame2f8d552013-02-22 06:40:45 +00001943 fep->clk_ptp = devm_clk_get(&pdev->dev, "ptp");
Fabio Estevam7f7d6c22013-02-21 09:21:50 +00001944 fep->bufdesc_ex =
1945 pdev->id_entry->driver_data & FEC_QUIRK_HAS_BUFDESC_EX;
Fabio Estevame2f8d552013-02-22 06:40:45 +00001946 if (IS_ERR(fep->clk_ptp)) {
Linus Torvalds38f56f32013-05-07 11:06:17 -07001947 fep->clk_ptp = NULL;
Fabio Estevame2f8d552013-02-22 06:40:45 +00001948 fep->bufdesc_ex = 0;
1949 }
1950
1951 clk_prepare_enable(fep->clk_ahb);
1952 clk_prepare_enable(fep->clk_ipg);
Linus Torvalds38f56f32013-05-07 11:06:17 -07001953 clk_prepare_enable(fep->clk_enet_out);
1954 clk_prepare_enable(fep->clk_ptp);
Fabio Estevame2f8d552013-02-22 06:40:45 +00001955
1956 reg_phy = devm_regulator_get(&pdev->dev, "phy");
1957 if (!IS_ERR(reg_phy)) {
1958 ret = regulator_enable(reg_phy);
1959 if (ret) {
1960 dev_err(&pdev->dev,
1961 "Failed to enable phy regulator: %d\n", ret);
1962 goto failed_regulator;
1963 }
1964 }
1965
1966 fec_reset_phy(pdev);
1967
Fabio Estevam7f7d6c22013-02-21 09:21:50 +00001968 if (fep->bufdesc_ex)
1969 fec_ptp_init(ndev, pdev);
1970
1971 ret = fec_enet_init(ndev);
1972 if (ret)
1973 goto failed_init;
1974
Xiao Jiangc7c83d12011-09-29 02:15:56 +00001975 for (i = 0; i < FEC_IRQ_NUM; i++) {
Sascha Haueread73182009-01-28 23:03:11 +00001976 irq = platform_get_irq(pdev, i);
Lothar Waßmann86f9f2c2011-12-07 21:59:28 +00001977 if (irq < 0) {
1978 if (i)
1979 break;
1980 ret = irq;
1981 goto failed_irq;
1982 }
Sascha Haueread73182009-01-28 23:03:11 +00001983 ret = request_irq(irq, fec_enet_interrupt, IRQF_DISABLED, pdev->name, ndev);
1984 if (ret) {
Uwe Kleine-Königb2b09ad2011-01-13 21:49:05 +01001985 while (--i >= 0) {
Sascha Haueread73182009-01-28 23:03:11 +00001986 irq = platform_get_irq(pdev, i);
1987 free_irq(irq, ndev);
Sascha Haueread73182009-01-28 23:03:11 +00001988 }
1989 goto failed_irq;
1990 }
1991 }
1992
Bryan Wue6b043d2010-03-31 02:10:44 +00001993 ret = fec_enet_mii_init(pdev);
1994 if (ret)
1995 goto failed_mii_init;
1996
Oskar Schirmer03c698c2010-10-07 02:30:30 +00001997 /* Carrier starts down, phylib will bring it up */
1998 netif_carrier_off(ndev);
1999
Sascha Haueread73182009-01-28 23:03:11 +00002000 ret = register_netdev(ndev);
2001 if (ret)
2002 goto failed_register;
2003
Fabio Estevameb1d0642013-04-13 07:25:36 +00002004 if (fep->bufdesc_ex && fep->ptp_clock)
2005 netdev_info(ndev, "registered PHC device %d\n", fep->dev_id);
2006
Frank Li54309fa2013-05-07 14:08:44 +00002007 INIT_DELAYED_WORK(&(fep->delay_work.delay_work), fec_enet_work);
Sascha Haueread73182009-01-28 23:03:11 +00002008 return 0;
2009
2010failed_register:
Bryan Wue6b043d2010-03-31 02:10:44 +00002011 fec_enet_mii_remove(fep);
2012failed_mii_init:
Fabio Estevame2f8d552013-02-22 06:40:45 +00002013failed_init:
2014 for (i = 0; i < FEC_IRQ_NUM; i++) {
2015 irq = platform_get_irq(pdev, i);
2016 if (irq > 0)
2017 free_irq(irq, ndev);
2018 }
2019failed_irq:
Shawn Guo5fa9c0f2012-06-27 03:45:21 +00002020failed_regulator:
Sascha Hauerf4d40de2012-03-07 09:30:49 +01002021 clk_disable_unprepare(fep->clk_ahb);
2022 clk_disable_unprepare(fep->clk_ipg);
Linus Torvalds38f56f32013-05-07 11:06:17 -07002023 clk_disable_unprepare(fep->clk_enet_out);
2024 clk_disable_unprepare(fep->clk_ptp);
Shawn Guob2bccee2012-05-06 20:24:04 +08002025failed_pin:
Sascha Haueread73182009-01-28 23:03:11 +00002026failed_clk:
Sascha Haueread73182009-01-28 23:03:11 +00002027failed_ioremap:
2028 free_netdev(ndev);
2029
2030 return ret;
2031}
2032
Bill Pemberton33897cc2012-12-03 09:23:58 -05002033static int
Sascha Haueread73182009-01-28 23:03:11 +00002034fec_drv_remove(struct platform_device *pdev)
2035{
2036 struct net_device *ndev = platform_get_drvdata(pdev);
2037 struct fec_enet_private *fep = netdev_priv(ndev);
Lothar Waßmanne163cc92011-12-07 21:59:31 +00002038 int i;
Sascha Haueread73182009-01-28 23:03:11 +00002039
Frank Li54309fa2013-05-07 14:08:44 +00002040 cancel_delayed_work_sync(&(fep->delay_work.delay_work));
Lothar Waßmanne163cc92011-12-07 21:59:31 +00002041 unregister_netdev(ndev);
Bryan Wue6b043d2010-03-31 02:10:44 +00002042 fec_enet_mii_remove(fep);
Frank Li6605b732012-10-30 18:25:31 +00002043 del_timer_sync(&fep->time_keep);
2044 clk_disable_unprepare(fep->clk_ptp);
2045 if (fep->ptp_clock)
2046 ptp_clock_unregister(fep->ptp_clock);
Linus Torvalds38f56f32013-05-07 11:06:17 -07002047 clk_disable_unprepare(fep->clk_enet_out);
Sascha Hauerf4d40de2012-03-07 09:30:49 +01002048 clk_disable_unprepare(fep->clk_ahb);
2049 clk_disable_unprepare(fep->clk_ipg);
Fabio Estevam7f7d6c22013-02-21 09:21:50 +00002050 for (i = 0; i < FEC_IRQ_NUM; i++) {
2051 int irq = platform_get_irq(pdev, i);
2052 if (irq > 0)
2053 free_irq(irq, ndev);
2054 }
Sascha Haueread73182009-01-28 23:03:11 +00002055 free_netdev(ndev);
Uwe Kleine-König28e21882011-01-13 21:44:18 +01002056
Uwe Kleine-Königb3cde362011-01-25 18:03:37 +01002057 platform_set_drvdata(pdev, NULL);
2058
Sascha Haueread73182009-01-28 23:03:11 +00002059 return 0;
2060}
2061
Fabio Estevambf7bfd72013-04-16 08:17:46 +00002062#ifdef CONFIG_PM_SLEEP
Sascha Haueread73182009-01-28 23:03:11 +00002063static int
Eric Benard87cad5c2010-06-18 04:19:54 +00002064fec_suspend(struct device *dev)
Sascha Haueread73182009-01-28 23:03:11 +00002065{
Eric Benard87cad5c2010-06-18 04:19:54 +00002066 struct net_device *ndev = dev_get_drvdata(dev);
Uwe Kleine-König04e52162011-01-13 21:53:40 +01002067 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00002068
Uwe Kleine-König04e52162011-01-13 21:53:40 +01002069 if (netif_running(ndev)) {
2070 fec_stop(ndev);
2071 netif_device_detach(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00002072 }
Linus Torvalds38f56f32013-05-07 11:06:17 -07002073 clk_disable_unprepare(fep->clk_enet_out);
Sascha Hauerf4d40de2012-03-07 09:30:49 +01002074 clk_disable_unprepare(fep->clk_ahb);
2075 clk_disable_unprepare(fep->clk_ipg);
Uwe Kleine-König04e52162011-01-13 21:53:40 +01002076
Sascha Haueread73182009-01-28 23:03:11 +00002077 return 0;
2078}
2079
2080static int
Eric Benard87cad5c2010-06-18 04:19:54 +00002081fec_resume(struct device *dev)
Sascha Haueread73182009-01-28 23:03:11 +00002082{
Eric Benard87cad5c2010-06-18 04:19:54 +00002083 struct net_device *ndev = dev_get_drvdata(dev);
Uwe Kleine-König04e52162011-01-13 21:53:40 +01002084 struct fec_enet_private *fep = netdev_priv(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00002085
Linus Torvalds38f56f32013-05-07 11:06:17 -07002086 clk_prepare_enable(fep->clk_enet_out);
Sascha Hauerf4d40de2012-03-07 09:30:49 +01002087 clk_prepare_enable(fep->clk_ahb);
2088 clk_prepare_enable(fep->clk_ipg);
Uwe Kleine-König04e52162011-01-13 21:53:40 +01002089 if (netif_running(ndev)) {
2090 fec_restart(ndev, fep->full_duplex);
2091 netif_device_attach(ndev);
Sascha Haueread73182009-01-28 23:03:11 +00002092 }
Uwe Kleine-König04e52162011-01-13 21:53:40 +01002093
Sascha Haueread73182009-01-28 23:03:11 +00002094 return 0;
2095}
Fabio Estevambf7bfd72013-04-16 08:17:46 +00002096#endif /* CONFIG_PM_SLEEP */
Sascha Haueread73182009-01-28 23:03:11 +00002097
Fabio Estevambf7bfd72013-04-16 08:17:46 +00002098static SIMPLE_DEV_PM_OPS(fec_pm_ops, fec_suspend, fec_resume);
Denis Kirjanov59d42892010-06-02 09:27:04 +00002099
Sascha Haueread73182009-01-28 23:03:11 +00002100static struct platform_driver fec_driver = {
2101 .driver = {
Shawn Guob5680e02011-01-05 21:13:13 +00002102 .name = DRIVER_NAME,
Eric Benard87cad5c2010-06-18 04:19:54 +00002103 .owner = THIS_MODULE,
Eric Benard87cad5c2010-06-18 04:19:54 +00002104 .pm = &fec_pm_ops,
Shawn Guoca2cc332011-06-25 02:04:35 +08002105 .of_match_table = fec_dt_ids,
Sascha Haueread73182009-01-28 23:03:11 +00002106 },
Shawn Guob5680e02011-01-05 21:13:13 +00002107 .id_table = fec_devtype,
Eric Benard87cad5c2010-06-18 04:19:54 +00002108 .probe = fec_probe,
Bill Pemberton33897cc2012-12-03 09:23:58 -05002109 .remove = fec_drv_remove,
Sascha Haueread73182009-01-28 23:03:11 +00002110};
2111
Fabio Estevamaaca2372012-01-23 16:44:50 +00002112module_platform_driver(fec_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
2114MODULE_LICENSE("GPL");