]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/net/ethernet/faraday/ftgmac100.c
Merge branch 'next' into for-linus
[karo-tx-linux.git] / drivers / net / ethernet / faraday / ftgmac100.c
1 /*
2  * Faraday FTGMAC100 Gigabit Ethernet
3  *
4  * (C) Copyright 2009-2011 Faraday Technology
5  * Po-Yu Chuang <ratbert@faraday-tech.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
23
24 #include <linux/dma-mapping.h>
25 #include <linux/etherdevice.h>
26 #include <linux/ethtool.h>
27 #include <linux/interrupt.h>
28 #include <linux/io.h>
29 #include <linux/module.h>
30 #include <linux/netdevice.h>
31 #include <linux/phy.h>
32 #include <linux/platform_device.h>
33 #include <net/ip.h>
34 #include <net/ncsi.h>
35
36 #include "ftgmac100.h"
37
38 #define DRV_NAME        "ftgmac100"
39 #define DRV_VERSION     "0.7"
40
41 #define RX_QUEUE_ENTRIES        256     /* must be power of 2 */
42 #define TX_QUEUE_ENTRIES        512     /* must be power of 2 */
43
44 #define MAX_PKT_SIZE            1518
45 #define RX_BUF_SIZE             PAGE_SIZE       /* must be smaller than 0x3fff */
46
47 /******************************************************************************
48  * private data
49  *****************************************************************************/
50 struct ftgmac100_descs {
51         struct ftgmac100_rxdes rxdes[RX_QUEUE_ENTRIES];
52         struct ftgmac100_txdes txdes[TX_QUEUE_ENTRIES];
53 };
54
55 struct ftgmac100 {
56         struct resource *res;
57         void __iomem *base;
58         int irq;
59
60         struct ftgmac100_descs *descs;
61         dma_addr_t descs_dma_addr;
62
63         unsigned int rx_pointer;
64         unsigned int tx_clean_pointer;
65         unsigned int tx_pointer;
66         unsigned int tx_pending;
67
68         spinlock_t tx_lock;
69
70         struct net_device *netdev;
71         struct device *dev;
72         struct ncsi_dev *ndev;
73         struct napi_struct napi;
74
75         struct mii_bus *mii_bus;
76         int old_speed;
77         int int_mask_all;
78         bool use_ncsi;
79         bool enabled;
80 };
81
82 static int ftgmac100_alloc_rx_page(struct ftgmac100 *priv,
83                                    struct ftgmac100_rxdes *rxdes, gfp_t gfp);
84
85 /******************************************************************************
86  * internal functions (hardware register access)
87  *****************************************************************************/
88 static void ftgmac100_set_rx_ring_base(struct ftgmac100 *priv, dma_addr_t addr)
89 {
90         iowrite32(addr, priv->base + FTGMAC100_OFFSET_RXR_BADR);
91 }
92
93 static void ftgmac100_set_rx_buffer_size(struct ftgmac100 *priv,
94                 unsigned int size)
95 {
96         size = FTGMAC100_RBSR_SIZE(size);
97         iowrite32(size, priv->base + FTGMAC100_OFFSET_RBSR);
98 }
99
100 static void ftgmac100_set_normal_prio_tx_ring_base(struct ftgmac100 *priv,
101                                                    dma_addr_t addr)
102 {
103         iowrite32(addr, priv->base + FTGMAC100_OFFSET_NPTXR_BADR);
104 }
105
106 static void ftgmac100_txdma_normal_prio_start_polling(struct ftgmac100 *priv)
107 {
108         iowrite32(1, priv->base + FTGMAC100_OFFSET_NPTXPD);
109 }
110
111 static int ftgmac100_reset_hw(struct ftgmac100 *priv)
112 {
113         struct net_device *netdev = priv->netdev;
114         int i;
115
116         /* NOTE: reset clears all registers */
117         iowrite32(FTGMAC100_MACCR_SW_RST, priv->base + FTGMAC100_OFFSET_MACCR);
118         for (i = 0; i < 5; i++) {
119                 unsigned int maccr;
120
121                 maccr = ioread32(priv->base + FTGMAC100_OFFSET_MACCR);
122                 if (!(maccr & FTGMAC100_MACCR_SW_RST))
123                         return 0;
124
125                 udelay(1000);
126         }
127
128         netdev_err(netdev, "software reset failed\n");
129         return -EIO;
130 }
131
132 static void ftgmac100_set_mac(struct ftgmac100 *priv, const unsigned char *mac)
133 {
134         unsigned int maddr = mac[0] << 8 | mac[1];
135         unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
136
137         iowrite32(maddr, priv->base + FTGMAC100_OFFSET_MAC_MADR);
138         iowrite32(laddr, priv->base + FTGMAC100_OFFSET_MAC_LADR);
139 }
140
141 static void ftgmac100_setup_mac(struct ftgmac100 *priv)
142 {
143         u8 mac[ETH_ALEN];
144         unsigned int m;
145         unsigned int l;
146         void *addr;
147
148         addr = device_get_mac_address(priv->dev, mac, ETH_ALEN);
149         if (addr) {
150                 ether_addr_copy(priv->netdev->dev_addr, mac);
151                 dev_info(priv->dev, "Read MAC address %pM from device tree\n",
152                          mac);
153                 return;
154         }
155
156         m = ioread32(priv->base + FTGMAC100_OFFSET_MAC_MADR);
157         l = ioread32(priv->base + FTGMAC100_OFFSET_MAC_LADR);
158
159         mac[0] = (m >> 8) & 0xff;
160         mac[1] = m & 0xff;
161         mac[2] = (l >> 24) & 0xff;
162         mac[3] = (l >> 16) & 0xff;
163         mac[4] = (l >> 8) & 0xff;
164         mac[5] = l & 0xff;
165
166         if (is_valid_ether_addr(mac)) {
167                 ether_addr_copy(priv->netdev->dev_addr, mac);
168                 dev_info(priv->dev, "Read MAC address %pM from chip\n", mac);
169         } else {
170                 eth_hw_addr_random(priv->netdev);
171                 dev_info(priv->dev, "Generated random MAC address %pM\n",
172                          priv->netdev->dev_addr);
173         }
174 }
175
176 static int ftgmac100_set_mac_addr(struct net_device *dev, void *p)
177 {
178         int ret;
179
180         ret = eth_prepare_mac_addr_change(dev, p);
181         if (ret < 0)
182                 return ret;
183
184         eth_commit_mac_addr_change(dev, p);
185         ftgmac100_set_mac(netdev_priv(dev), dev->dev_addr);
186
187         return 0;
188 }
189
190 static void ftgmac100_init_hw(struct ftgmac100 *priv)
191 {
192         /* setup ring buffer base registers */
193         ftgmac100_set_rx_ring_base(priv,
194                                    priv->descs_dma_addr +
195                                    offsetof(struct ftgmac100_descs, rxdes));
196         ftgmac100_set_normal_prio_tx_ring_base(priv,
197                                                priv->descs_dma_addr +
198                                                offsetof(struct ftgmac100_descs, txdes));
199
200         ftgmac100_set_rx_buffer_size(priv, RX_BUF_SIZE);
201
202         iowrite32(FTGMAC100_APTC_RXPOLL_CNT(1), priv->base + FTGMAC100_OFFSET_APTC);
203
204         ftgmac100_set_mac(priv, priv->netdev->dev_addr);
205 }
206
207 #define MACCR_ENABLE_ALL        (FTGMAC100_MACCR_TXDMA_EN       | \
208                                  FTGMAC100_MACCR_RXDMA_EN       | \
209                                  FTGMAC100_MACCR_TXMAC_EN       | \
210                                  FTGMAC100_MACCR_RXMAC_EN       | \
211                                  FTGMAC100_MACCR_FULLDUP        | \
212                                  FTGMAC100_MACCR_CRC_APD        | \
213                                  FTGMAC100_MACCR_RX_RUNT        | \
214                                  FTGMAC100_MACCR_RX_BROADPKT)
215
216 static void ftgmac100_start_hw(struct ftgmac100 *priv, int speed)
217 {
218         int maccr = MACCR_ENABLE_ALL;
219
220         switch (speed) {
221         default:
222         case 10:
223                 break;
224
225         case 100:
226                 maccr |= FTGMAC100_MACCR_FAST_MODE;
227                 break;
228
229         case 1000:
230                 maccr |= FTGMAC100_MACCR_GIGA_MODE;
231                 break;
232         }
233
234         iowrite32(maccr, priv->base + FTGMAC100_OFFSET_MACCR);
235 }
236
237 static void ftgmac100_stop_hw(struct ftgmac100 *priv)
238 {
239         iowrite32(0, priv->base + FTGMAC100_OFFSET_MACCR);
240 }
241
242 /******************************************************************************
243  * internal functions (receive descriptor)
244  *****************************************************************************/
245 static bool ftgmac100_rxdes_first_segment(struct ftgmac100_rxdes *rxdes)
246 {
247         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_FRS);
248 }
249
250 static bool ftgmac100_rxdes_last_segment(struct ftgmac100_rxdes *rxdes)
251 {
252         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_LRS);
253 }
254
255 static bool ftgmac100_rxdes_packet_ready(struct ftgmac100_rxdes *rxdes)
256 {
257         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RXPKT_RDY);
258 }
259
260 static void ftgmac100_rxdes_set_dma_own(struct ftgmac100_rxdes *rxdes)
261 {
262         /* clear status bits */
263         rxdes->rxdes0 &= cpu_to_le32(FTGMAC100_RXDES0_EDORR);
264 }
265
266 static bool ftgmac100_rxdes_rx_error(struct ftgmac100_rxdes *rxdes)
267 {
268         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RX_ERR);
269 }
270
271 static bool ftgmac100_rxdes_crc_error(struct ftgmac100_rxdes *rxdes)
272 {
273         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_CRC_ERR);
274 }
275
276 static bool ftgmac100_rxdes_frame_too_long(struct ftgmac100_rxdes *rxdes)
277 {
278         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_FTL);
279 }
280
281 static bool ftgmac100_rxdes_runt(struct ftgmac100_rxdes *rxdes)
282 {
283         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RUNT);
284 }
285
286 static bool ftgmac100_rxdes_odd_nibble(struct ftgmac100_rxdes *rxdes)
287 {
288         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RX_ODD_NB);
289 }
290
291 static unsigned int ftgmac100_rxdes_data_length(struct ftgmac100_rxdes *rxdes)
292 {
293         return le32_to_cpu(rxdes->rxdes0) & FTGMAC100_RXDES0_VDBC;
294 }
295
296 static bool ftgmac100_rxdes_multicast(struct ftgmac100_rxdes *rxdes)
297 {
298         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_MULTICAST);
299 }
300
301 static void ftgmac100_rxdes_set_end_of_ring(struct ftgmac100_rxdes *rxdes)
302 {
303         rxdes->rxdes0 |= cpu_to_le32(FTGMAC100_RXDES0_EDORR);
304 }
305
306 static void ftgmac100_rxdes_set_dma_addr(struct ftgmac100_rxdes *rxdes,
307                                          dma_addr_t addr)
308 {
309         rxdes->rxdes3 = cpu_to_le32(addr);
310 }
311
312 static dma_addr_t ftgmac100_rxdes_get_dma_addr(struct ftgmac100_rxdes *rxdes)
313 {
314         return le32_to_cpu(rxdes->rxdes3);
315 }
316
317 static bool ftgmac100_rxdes_is_tcp(struct ftgmac100_rxdes *rxdes)
318 {
319         return (rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_PROT_MASK)) ==
320                cpu_to_le32(FTGMAC100_RXDES1_PROT_TCPIP);
321 }
322
323 static bool ftgmac100_rxdes_is_udp(struct ftgmac100_rxdes *rxdes)
324 {
325         return (rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_PROT_MASK)) ==
326                cpu_to_le32(FTGMAC100_RXDES1_PROT_UDPIP);
327 }
328
329 static bool ftgmac100_rxdes_tcpcs_err(struct ftgmac100_rxdes *rxdes)
330 {
331         return rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_TCP_CHKSUM_ERR);
332 }
333
334 static bool ftgmac100_rxdes_udpcs_err(struct ftgmac100_rxdes *rxdes)
335 {
336         return rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_UDP_CHKSUM_ERR);
337 }
338
339 static bool ftgmac100_rxdes_ipcs_err(struct ftgmac100_rxdes *rxdes)
340 {
341         return rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_IP_CHKSUM_ERR);
342 }
343
344 /*
345  * rxdes2 is not used by hardware. We use it to keep track of page.
346  * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
347  */
348 static void ftgmac100_rxdes_set_page(struct ftgmac100_rxdes *rxdes, struct page *page)
349 {
350         rxdes->rxdes2 = (unsigned int)page;
351 }
352
353 static struct page *ftgmac100_rxdes_get_page(struct ftgmac100_rxdes *rxdes)
354 {
355         return (struct page *)rxdes->rxdes2;
356 }
357
358 /******************************************************************************
359  * internal functions (receive)
360  *****************************************************************************/
361 static int ftgmac100_next_rx_pointer(int pointer)
362 {
363         return (pointer + 1) & (RX_QUEUE_ENTRIES - 1);
364 }
365
366 static void ftgmac100_rx_pointer_advance(struct ftgmac100 *priv)
367 {
368         priv->rx_pointer = ftgmac100_next_rx_pointer(priv->rx_pointer);
369 }
370
371 static struct ftgmac100_rxdes *ftgmac100_current_rxdes(struct ftgmac100 *priv)
372 {
373         return &priv->descs->rxdes[priv->rx_pointer];
374 }
375
376 static struct ftgmac100_rxdes *
377 ftgmac100_rx_locate_first_segment(struct ftgmac100 *priv)
378 {
379         struct ftgmac100_rxdes *rxdes = ftgmac100_current_rxdes(priv);
380
381         while (ftgmac100_rxdes_packet_ready(rxdes)) {
382                 if (ftgmac100_rxdes_first_segment(rxdes))
383                         return rxdes;
384
385                 ftgmac100_rxdes_set_dma_own(rxdes);
386                 ftgmac100_rx_pointer_advance(priv);
387                 rxdes = ftgmac100_current_rxdes(priv);
388         }
389
390         return NULL;
391 }
392
393 static bool ftgmac100_rx_packet_error(struct ftgmac100 *priv,
394                                       struct ftgmac100_rxdes *rxdes)
395 {
396         struct net_device *netdev = priv->netdev;
397         bool error = false;
398
399         if (unlikely(ftgmac100_rxdes_rx_error(rxdes))) {
400                 if (net_ratelimit())
401                         netdev_info(netdev, "rx err\n");
402
403                 netdev->stats.rx_errors++;
404                 error = true;
405         }
406
407         if (unlikely(ftgmac100_rxdes_crc_error(rxdes))) {
408                 if (net_ratelimit())
409                         netdev_info(netdev, "rx crc err\n");
410
411                 netdev->stats.rx_crc_errors++;
412                 error = true;
413         } else if (unlikely(ftgmac100_rxdes_ipcs_err(rxdes))) {
414                 if (net_ratelimit())
415                         netdev_info(netdev, "rx IP checksum err\n");
416
417                 error = true;
418         }
419
420         if (unlikely(ftgmac100_rxdes_frame_too_long(rxdes))) {
421                 if (net_ratelimit())
422                         netdev_info(netdev, "rx frame too long\n");
423
424                 netdev->stats.rx_length_errors++;
425                 error = true;
426         } else if (unlikely(ftgmac100_rxdes_runt(rxdes))) {
427                 if (net_ratelimit())
428                         netdev_info(netdev, "rx runt\n");
429
430                 netdev->stats.rx_length_errors++;
431                 error = true;
432         } else if (unlikely(ftgmac100_rxdes_odd_nibble(rxdes))) {
433                 if (net_ratelimit())
434                         netdev_info(netdev, "rx odd nibble\n");
435
436                 netdev->stats.rx_length_errors++;
437                 error = true;
438         }
439
440         return error;
441 }
442
443 static void ftgmac100_rx_drop_packet(struct ftgmac100 *priv)
444 {
445         struct net_device *netdev = priv->netdev;
446         struct ftgmac100_rxdes *rxdes = ftgmac100_current_rxdes(priv);
447         bool done = false;
448
449         if (net_ratelimit())
450                 netdev_dbg(netdev, "drop packet %p\n", rxdes);
451
452         do {
453                 if (ftgmac100_rxdes_last_segment(rxdes))
454                         done = true;
455
456                 ftgmac100_rxdes_set_dma_own(rxdes);
457                 ftgmac100_rx_pointer_advance(priv);
458                 rxdes = ftgmac100_current_rxdes(priv);
459         } while (!done && ftgmac100_rxdes_packet_ready(rxdes));
460
461         netdev->stats.rx_dropped++;
462 }
463
464 static bool ftgmac100_rx_packet(struct ftgmac100 *priv, int *processed)
465 {
466         struct net_device *netdev = priv->netdev;
467         struct ftgmac100_rxdes *rxdes;
468         struct sk_buff *skb;
469         bool done = false;
470
471         rxdes = ftgmac100_rx_locate_first_segment(priv);
472         if (!rxdes)
473                 return false;
474
475         if (unlikely(ftgmac100_rx_packet_error(priv, rxdes))) {
476                 ftgmac100_rx_drop_packet(priv);
477                 return true;
478         }
479
480         /* start processing */
481         skb = netdev_alloc_skb_ip_align(netdev, 128);
482         if (unlikely(!skb)) {
483                 if (net_ratelimit())
484                         netdev_err(netdev, "rx skb alloc failed\n");
485
486                 ftgmac100_rx_drop_packet(priv);
487                 return true;
488         }
489
490         if (unlikely(ftgmac100_rxdes_multicast(rxdes)))
491                 netdev->stats.multicast++;
492
493         /*
494          * It seems that HW does checksum incorrectly with fragmented packets,
495          * so we are conservative here - if HW checksum error, let software do
496          * the checksum again.
497          */
498         if ((ftgmac100_rxdes_is_tcp(rxdes) && !ftgmac100_rxdes_tcpcs_err(rxdes)) ||
499             (ftgmac100_rxdes_is_udp(rxdes) && !ftgmac100_rxdes_udpcs_err(rxdes)))
500                 skb->ip_summed = CHECKSUM_UNNECESSARY;
501
502         do {
503                 dma_addr_t map = ftgmac100_rxdes_get_dma_addr(rxdes);
504                 struct page *page = ftgmac100_rxdes_get_page(rxdes);
505                 unsigned int size;
506
507                 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
508
509                 size = ftgmac100_rxdes_data_length(rxdes);
510                 skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page, 0, size);
511
512                 skb->len += size;
513                 skb->data_len += size;
514                 skb->truesize += PAGE_SIZE;
515
516                 if (ftgmac100_rxdes_last_segment(rxdes))
517                         done = true;
518
519                 ftgmac100_alloc_rx_page(priv, rxdes, GFP_ATOMIC);
520
521                 ftgmac100_rx_pointer_advance(priv);
522                 rxdes = ftgmac100_current_rxdes(priv);
523         } while (!done);
524
525         /* Small frames are copied into linear part of skb to free one page */
526         if (skb->len <= 128) {
527                 skb->truesize -= PAGE_SIZE;
528                 __pskb_pull_tail(skb, skb->len);
529         } else {
530                 /* We pull the minimum amount into linear part */
531                 __pskb_pull_tail(skb, ETH_HLEN);
532         }
533         skb->protocol = eth_type_trans(skb, netdev);
534
535         netdev->stats.rx_packets++;
536         netdev->stats.rx_bytes += skb->len;
537
538         /* push packet to protocol stack */
539         napi_gro_receive(&priv->napi, skb);
540
541         (*processed)++;
542         return true;
543 }
544
545 /******************************************************************************
546  * internal functions (transmit descriptor)
547  *****************************************************************************/
548 static void ftgmac100_txdes_reset(struct ftgmac100_txdes *txdes)
549 {
550         /* clear all except end of ring bit */
551         txdes->txdes0 &= cpu_to_le32(FTGMAC100_TXDES0_EDOTR);
552         txdes->txdes1 = 0;
553         txdes->txdes2 = 0;
554         txdes->txdes3 = 0;
555 }
556
557 static bool ftgmac100_txdes_owned_by_dma(struct ftgmac100_txdes *txdes)
558 {
559         return txdes->txdes0 & cpu_to_le32(FTGMAC100_TXDES0_TXDMA_OWN);
560 }
561
562 static void ftgmac100_txdes_set_dma_own(struct ftgmac100_txdes *txdes)
563 {
564         /*
565          * Make sure dma own bit will not be set before any other
566          * descriptor fields.
567          */
568         wmb();
569         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_TXDMA_OWN);
570 }
571
572 static void ftgmac100_txdes_set_end_of_ring(struct ftgmac100_txdes *txdes)
573 {
574         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_EDOTR);
575 }
576
577 static void ftgmac100_txdes_set_first_segment(struct ftgmac100_txdes *txdes)
578 {
579         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_FTS);
580 }
581
582 static void ftgmac100_txdes_set_last_segment(struct ftgmac100_txdes *txdes)
583 {
584         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_LTS);
585 }
586
587 static void ftgmac100_txdes_set_buffer_size(struct ftgmac100_txdes *txdes,
588                                             unsigned int len)
589 {
590         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_TXBUF_SIZE(len));
591 }
592
593 static void ftgmac100_txdes_set_txint(struct ftgmac100_txdes *txdes)
594 {
595         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_TXIC);
596 }
597
598 static void ftgmac100_txdes_set_tcpcs(struct ftgmac100_txdes *txdes)
599 {
600         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_TCP_CHKSUM);
601 }
602
603 static void ftgmac100_txdes_set_udpcs(struct ftgmac100_txdes *txdes)
604 {
605         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_UDP_CHKSUM);
606 }
607
608 static void ftgmac100_txdes_set_ipcs(struct ftgmac100_txdes *txdes)
609 {
610         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_IP_CHKSUM);
611 }
612
613 static void ftgmac100_txdes_set_dma_addr(struct ftgmac100_txdes *txdes,
614                                          dma_addr_t addr)
615 {
616         txdes->txdes3 = cpu_to_le32(addr);
617 }
618
619 static dma_addr_t ftgmac100_txdes_get_dma_addr(struct ftgmac100_txdes *txdes)
620 {
621         return le32_to_cpu(txdes->txdes3);
622 }
623
624 /*
625  * txdes2 is not used by hardware. We use it to keep track of socket buffer.
626  * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
627  */
628 static void ftgmac100_txdes_set_skb(struct ftgmac100_txdes *txdes,
629                                     struct sk_buff *skb)
630 {
631         txdes->txdes2 = (unsigned int)skb;
632 }
633
634 static struct sk_buff *ftgmac100_txdes_get_skb(struct ftgmac100_txdes *txdes)
635 {
636         return (struct sk_buff *)txdes->txdes2;
637 }
638
639 /******************************************************************************
640  * internal functions (transmit)
641  *****************************************************************************/
642 static int ftgmac100_next_tx_pointer(int pointer)
643 {
644         return (pointer + 1) & (TX_QUEUE_ENTRIES - 1);
645 }
646
647 static void ftgmac100_tx_pointer_advance(struct ftgmac100 *priv)
648 {
649         priv->tx_pointer = ftgmac100_next_tx_pointer(priv->tx_pointer);
650 }
651
652 static void ftgmac100_tx_clean_pointer_advance(struct ftgmac100 *priv)
653 {
654         priv->tx_clean_pointer = ftgmac100_next_tx_pointer(priv->tx_clean_pointer);
655 }
656
657 static struct ftgmac100_txdes *ftgmac100_current_txdes(struct ftgmac100 *priv)
658 {
659         return &priv->descs->txdes[priv->tx_pointer];
660 }
661
662 static struct ftgmac100_txdes *
663 ftgmac100_current_clean_txdes(struct ftgmac100 *priv)
664 {
665         return &priv->descs->txdes[priv->tx_clean_pointer];
666 }
667
668 static bool ftgmac100_tx_complete_packet(struct ftgmac100 *priv)
669 {
670         struct net_device *netdev = priv->netdev;
671         struct ftgmac100_txdes *txdes;
672         struct sk_buff *skb;
673         dma_addr_t map;
674
675         if (priv->tx_pending == 0)
676                 return false;
677
678         txdes = ftgmac100_current_clean_txdes(priv);
679
680         if (ftgmac100_txdes_owned_by_dma(txdes))
681                 return false;
682
683         skb = ftgmac100_txdes_get_skb(txdes);
684         map = ftgmac100_txdes_get_dma_addr(txdes);
685
686         netdev->stats.tx_packets++;
687         netdev->stats.tx_bytes += skb->len;
688
689         dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
690
691         dev_kfree_skb(skb);
692
693         ftgmac100_txdes_reset(txdes);
694
695         ftgmac100_tx_clean_pointer_advance(priv);
696
697         spin_lock(&priv->tx_lock);
698         priv->tx_pending--;
699         spin_unlock(&priv->tx_lock);
700         netif_wake_queue(netdev);
701
702         return true;
703 }
704
705 static void ftgmac100_tx_complete(struct ftgmac100 *priv)
706 {
707         while (ftgmac100_tx_complete_packet(priv))
708                 ;
709 }
710
711 static int ftgmac100_xmit(struct ftgmac100 *priv, struct sk_buff *skb,
712                           dma_addr_t map)
713 {
714         struct net_device *netdev = priv->netdev;
715         struct ftgmac100_txdes *txdes;
716         unsigned int len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
717
718         txdes = ftgmac100_current_txdes(priv);
719         ftgmac100_tx_pointer_advance(priv);
720
721         /* setup TX descriptor */
722         ftgmac100_txdes_set_skb(txdes, skb);
723         ftgmac100_txdes_set_dma_addr(txdes, map);
724         ftgmac100_txdes_set_buffer_size(txdes, len);
725
726         ftgmac100_txdes_set_first_segment(txdes);
727         ftgmac100_txdes_set_last_segment(txdes);
728         ftgmac100_txdes_set_txint(txdes);
729         if (skb->ip_summed == CHECKSUM_PARTIAL) {
730                 __be16 protocol = skb->protocol;
731
732                 if (protocol == cpu_to_be16(ETH_P_IP)) {
733                         u8 ip_proto = ip_hdr(skb)->protocol;
734
735                         ftgmac100_txdes_set_ipcs(txdes);
736                         if (ip_proto == IPPROTO_TCP)
737                                 ftgmac100_txdes_set_tcpcs(txdes);
738                         else if (ip_proto == IPPROTO_UDP)
739                                 ftgmac100_txdes_set_udpcs(txdes);
740                 }
741         }
742
743         spin_lock(&priv->tx_lock);
744         priv->tx_pending++;
745         if (priv->tx_pending == TX_QUEUE_ENTRIES)
746                 netif_stop_queue(netdev);
747
748         /* start transmit */
749         ftgmac100_txdes_set_dma_own(txdes);
750         spin_unlock(&priv->tx_lock);
751
752         ftgmac100_txdma_normal_prio_start_polling(priv);
753
754         return NETDEV_TX_OK;
755 }
756
757 /******************************************************************************
758  * internal functions (buffer)
759  *****************************************************************************/
760 static int ftgmac100_alloc_rx_page(struct ftgmac100 *priv,
761                                    struct ftgmac100_rxdes *rxdes, gfp_t gfp)
762 {
763         struct net_device *netdev = priv->netdev;
764         struct page *page;
765         dma_addr_t map;
766
767         page = alloc_page(gfp);
768         if (!page) {
769                 if (net_ratelimit())
770                         netdev_err(netdev, "failed to allocate rx page\n");
771                 return -ENOMEM;
772         }
773
774         map = dma_map_page(priv->dev, page, 0, RX_BUF_SIZE, DMA_FROM_DEVICE);
775         if (unlikely(dma_mapping_error(priv->dev, map))) {
776                 if (net_ratelimit())
777                         netdev_err(netdev, "failed to map rx page\n");
778                 __free_page(page);
779                 return -ENOMEM;
780         }
781
782         ftgmac100_rxdes_set_page(rxdes, page);
783         ftgmac100_rxdes_set_dma_addr(rxdes, map);
784         ftgmac100_rxdes_set_dma_own(rxdes);
785         return 0;
786 }
787
788 static void ftgmac100_free_buffers(struct ftgmac100 *priv)
789 {
790         int i;
791
792         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
793                 struct ftgmac100_rxdes *rxdes = &priv->descs->rxdes[i];
794                 struct page *page = ftgmac100_rxdes_get_page(rxdes);
795                 dma_addr_t map = ftgmac100_rxdes_get_dma_addr(rxdes);
796
797                 if (!page)
798                         continue;
799
800                 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
801                 __free_page(page);
802         }
803
804         for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
805                 struct ftgmac100_txdes *txdes = &priv->descs->txdes[i];
806                 struct sk_buff *skb = ftgmac100_txdes_get_skb(txdes);
807                 dma_addr_t map = ftgmac100_txdes_get_dma_addr(txdes);
808
809                 if (!skb)
810                         continue;
811
812                 dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
813                 kfree_skb(skb);
814         }
815
816         dma_free_coherent(priv->dev, sizeof(struct ftgmac100_descs),
817                           priv->descs, priv->descs_dma_addr);
818 }
819
820 static int ftgmac100_alloc_buffers(struct ftgmac100 *priv)
821 {
822         int i;
823
824         priv->descs = dma_zalloc_coherent(priv->dev,
825                                           sizeof(struct ftgmac100_descs),
826                                           &priv->descs_dma_addr, GFP_KERNEL);
827         if (!priv->descs)
828                 return -ENOMEM;
829
830         /* initialize RX ring */
831         ftgmac100_rxdes_set_end_of_ring(&priv->descs->rxdes[RX_QUEUE_ENTRIES - 1]);
832
833         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
834                 struct ftgmac100_rxdes *rxdes = &priv->descs->rxdes[i];
835
836                 if (ftgmac100_alloc_rx_page(priv, rxdes, GFP_KERNEL))
837                         goto err;
838         }
839
840         /* initialize TX ring */
841         ftgmac100_txdes_set_end_of_ring(&priv->descs->txdes[TX_QUEUE_ENTRIES - 1]);
842         return 0;
843
844 err:
845         ftgmac100_free_buffers(priv);
846         return -ENOMEM;
847 }
848
849 /******************************************************************************
850  * internal functions (mdio)
851  *****************************************************************************/
852 static void ftgmac100_adjust_link(struct net_device *netdev)
853 {
854         struct ftgmac100 *priv = netdev_priv(netdev);
855         struct phy_device *phydev = netdev->phydev;
856         int ier;
857
858         if (phydev->speed == priv->old_speed)
859                 return;
860
861         priv->old_speed = phydev->speed;
862
863         ier = ioread32(priv->base + FTGMAC100_OFFSET_IER);
864
865         /* disable all interrupts */
866         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
867
868         netif_stop_queue(netdev);
869         ftgmac100_stop_hw(priv);
870
871         netif_start_queue(netdev);
872         ftgmac100_init_hw(priv);
873         ftgmac100_start_hw(priv, phydev->speed);
874
875         /* re-enable interrupts */
876         iowrite32(ier, priv->base + FTGMAC100_OFFSET_IER);
877 }
878
879 static int ftgmac100_mii_probe(struct ftgmac100 *priv)
880 {
881         struct net_device *netdev = priv->netdev;
882         struct phy_device *phydev;
883
884         phydev = phy_find_first(priv->mii_bus);
885         if (!phydev) {
886                 netdev_info(netdev, "%s: no PHY found\n", netdev->name);
887                 return -ENODEV;
888         }
889
890         phydev = phy_connect(netdev, phydev_name(phydev),
891                              &ftgmac100_adjust_link, PHY_INTERFACE_MODE_GMII);
892
893         if (IS_ERR(phydev)) {
894                 netdev_err(netdev, "%s: Could not attach to PHY\n", netdev->name);
895                 return PTR_ERR(phydev);
896         }
897
898         return 0;
899 }
900
901 /******************************************************************************
902  * struct mii_bus functions
903  *****************************************************************************/
904 static int ftgmac100_mdiobus_read(struct mii_bus *bus, int phy_addr, int regnum)
905 {
906         struct net_device *netdev = bus->priv;
907         struct ftgmac100 *priv = netdev_priv(netdev);
908         unsigned int phycr;
909         int i;
910
911         phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
912
913         /* preserve MDC cycle threshold */
914         phycr &= FTGMAC100_PHYCR_MDC_CYCTHR_MASK;
915
916         phycr |= FTGMAC100_PHYCR_PHYAD(phy_addr) |
917                  FTGMAC100_PHYCR_REGAD(regnum) |
918                  FTGMAC100_PHYCR_MIIRD;
919
920         iowrite32(phycr, priv->base + FTGMAC100_OFFSET_PHYCR);
921
922         for (i = 0; i < 10; i++) {
923                 phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
924
925                 if ((phycr & FTGMAC100_PHYCR_MIIRD) == 0) {
926                         int data;
927
928                         data = ioread32(priv->base + FTGMAC100_OFFSET_PHYDATA);
929                         return FTGMAC100_PHYDATA_MIIRDATA(data);
930                 }
931
932                 udelay(100);
933         }
934
935         netdev_err(netdev, "mdio read timed out\n");
936         return -EIO;
937 }
938
939 static int ftgmac100_mdiobus_write(struct mii_bus *bus, int phy_addr,
940                                    int regnum, u16 value)
941 {
942         struct net_device *netdev = bus->priv;
943         struct ftgmac100 *priv = netdev_priv(netdev);
944         unsigned int phycr;
945         int data;
946         int i;
947
948         phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
949
950         /* preserve MDC cycle threshold */
951         phycr &= FTGMAC100_PHYCR_MDC_CYCTHR_MASK;
952
953         phycr |= FTGMAC100_PHYCR_PHYAD(phy_addr) |
954                  FTGMAC100_PHYCR_REGAD(regnum) |
955                  FTGMAC100_PHYCR_MIIWR;
956
957         data = FTGMAC100_PHYDATA_MIIWDATA(value);
958
959         iowrite32(data, priv->base + FTGMAC100_OFFSET_PHYDATA);
960         iowrite32(phycr, priv->base + FTGMAC100_OFFSET_PHYCR);
961
962         for (i = 0; i < 10; i++) {
963                 phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
964
965                 if ((phycr & FTGMAC100_PHYCR_MIIWR) == 0)
966                         return 0;
967
968                 udelay(100);
969         }
970
971         netdev_err(netdev, "mdio write timed out\n");
972         return -EIO;
973 }
974
975 /******************************************************************************
976  * struct ethtool_ops functions
977  *****************************************************************************/
978 static void ftgmac100_get_drvinfo(struct net_device *netdev,
979                                   struct ethtool_drvinfo *info)
980 {
981         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
982         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
983         strlcpy(info->bus_info, dev_name(&netdev->dev), sizeof(info->bus_info));
984 }
985
986 static const struct ethtool_ops ftgmac100_ethtool_ops = {
987         .get_drvinfo            = ftgmac100_get_drvinfo,
988         .get_link               = ethtool_op_get_link,
989         .get_link_ksettings     = phy_ethtool_get_link_ksettings,
990         .set_link_ksettings     = phy_ethtool_set_link_ksettings,
991 };
992
993 /******************************************************************************
994  * interrupt handler
995  *****************************************************************************/
996 static irqreturn_t ftgmac100_interrupt(int irq, void *dev_id)
997 {
998         struct net_device *netdev = dev_id;
999         struct ftgmac100 *priv = netdev_priv(netdev);
1000
1001         /* When running in NCSI mode, the interface should be ready for
1002          * receiving or transmitting NCSI packets before it's opened.
1003          */
1004         if (likely(priv->use_ncsi || netif_running(netdev))) {
1005                 /* Disable interrupts for polling */
1006                 iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
1007                 napi_schedule(&priv->napi);
1008         }
1009
1010         return IRQ_HANDLED;
1011 }
1012
1013 /******************************************************************************
1014  * struct napi_struct functions
1015  *****************************************************************************/
1016 static int ftgmac100_poll(struct napi_struct *napi, int budget)
1017 {
1018         struct ftgmac100 *priv = container_of(napi, struct ftgmac100, napi);
1019         struct net_device *netdev = priv->netdev;
1020         unsigned int status;
1021         bool completed = true;
1022         int rx = 0;
1023
1024         status = ioread32(priv->base + FTGMAC100_OFFSET_ISR);
1025         iowrite32(status, priv->base + FTGMAC100_OFFSET_ISR);
1026
1027         if (status & (FTGMAC100_INT_RPKT_BUF | FTGMAC100_INT_NO_RXBUF)) {
1028                 /*
1029                  * FTGMAC100_INT_RPKT_BUF:
1030                  *      RX DMA has received packets into RX buffer successfully
1031                  *
1032                  * FTGMAC100_INT_NO_RXBUF:
1033                  *      RX buffer unavailable
1034                  */
1035                 bool retry;
1036
1037                 do {
1038                         retry = ftgmac100_rx_packet(priv, &rx);
1039                 } while (retry && rx < budget);
1040
1041                 if (retry && rx == budget)
1042                         completed = false;
1043         }
1044
1045         if (status & (FTGMAC100_INT_XPKT_ETH | FTGMAC100_INT_XPKT_LOST)) {
1046                 /*
1047                  * FTGMAC100_INT_XPKT_ETH:
1048                  *      packet transmitted to ethernet successfully
1049                  *
1050                  * FTGMAC100_INT_XPKT_LOST:
1051                  *      packet transmitted to ethernet lost due to late
1052                  *      collision or excessive collision
1053                  */
1054                 ftgmac100_tx_complete(priv);
1055         }
1056
1057         if (status & priv->int_mask_all & (FTGMAC100_INT_NO_RXBUF |
1058                         FTGMAC100_INT_RPKT_LOST | FTGMAC100_INT_AHB_ERR |
1059                         FTGMAC100_INT_PHYSTS_CHG)) {
1060                 if (net_ratelimit())
1061                         netdev_info(netdev, "[ISR] = 0x%x: %s%s%s%s\n", status,
1062                                     status & FTGMAC100_INT_NO_RXBUF ? "NO_RXBUF " : "",
1063                                     status & FTGMAC100_INT_RPKT_LOST ? "RPKT_LOST " : "",
1064                                     status & FTGMAC100_INT_AHB_ERR ? "AHB_ERR " : "",
1065                                     status & FTGMAC100_INT_PHYSTS_CHG ? "PHYSTS_CHG" : "");
1066
1067                 if (status & FTGMAC100_INT_NO_RXBUF) {
1068                         /* RX buffer unavailable */
1069                         netdev->stats.rx_over_errors++;
1070                 }
1071
1072                 if (status & FTGMAC100_INT_RPKT_LOST) {
1073                         /* received packet lost due to RX FIFO full */
1074                         netdev->stats.rx_fifo_errors++;
1075                 }
1076         }
1077
1078         if (completed) {
1079                 napi_complete(napi);
1080
1081                 /* enable all interrupts */
1082                 iowrite32(priv->int_mask_all,
1083                           priv->base + FTGMAC100_OFFSET_IER);
1084         }
1085
1086         return rx;
1087 }
1088
1089 /******************************************************************************
1090  * struct net_device_ops functions
1091  *****************************************************************************/
1092 static int ftgmac100_open(struct net_device *netdev)
1093 {
1094         struct ftgmac100 *priv = netdev_priv(netdev);
1095         int err;
1096
1097         err = ftgmac100_alloc_buffers(priv);
1098         if (err) {
1099                 netdev_err(netdev, "failed to allocate buffers\n");
1100                 goto err_alloc;
1101         }
1102
1103         err = request_irq(priv->irq, ftgmac100_interrupt, 0, netdev->name, netdev);
1104         if (err) {
1105                 netdev_err(netdev, "failed to request irq %d\n", priv->irq);
1106                 goto err_irq;
1107         }
1108
1109         priv->rx_pointer = 0;
1110         priv->tx_clean_pointer = 0;
1111         priv->tx_pointer = 0;
1112         priv->tx_pending = 0;
1113
1114         err = ftgmac100_reset_hw(priv);
1115         if (err)
1116                 goto err_hw;
1117
1118         ftgmac100_init_hw(priv);
1119         ftgmac100_start_hw(priv, priv->use_ncsi ? 100 : 10);
1120         if (netdev->phydev)
1121                 phy_start(netdev->phydev);
1122         else if (priv->use_ncsi)
1123                 netif_carrier_on(netdev);
1124
1125         napi_enable(&priv->napi);
1126         netif_start_queue(netdev);
1127
1128         /* enable all interrupts */
1129         iowrite32(priv->int_mask_all, priv->base + FTGMAC100_OFFSET_IER);
1130
1131         /* Start the NCSI device */
1132         if (priv->use_ncsi) {
1133                 err = ncsi_start_dev(priv->ndev);
1134                 if (err)
1135                         goto err_ncsi;
1136         }
1137
1138         priv->enabled = true;
1139
1140         return 0;
1141
1142 err_ncsi:
1143         napi_disable(&priv->napi);
1144         netif_stop_queue(netdev);
1145         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
1146 err_hw:
1147         free_irq(priv->irq, netdev);
1148 err_irq:
1149         ftgmac100_free_buffers(priv);
1150 err_alloc:
1151         return err;
1152 }
1153
1154 static int ftgmac100_stop(struct net_device *netdev)
1155 {
1156         struct ftgmac100 *priv = netdev_priv(netdev);
1157
1158         if (!priv->enabled)
1159                 return 0;
1160
1161         /* disable all interrupts */
1162         priv->enabled = false;
1163         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
1164
1165         netif_stop_queue(netdev);
1166         napi_disable(&priv->napi);
1167         if (netdev->phydev)
1168                 phy_stop(netdev->phydev);
1169
1170         ftgmac100_stop_hw(priv);
1171         free_irq(priv->irq, netdev);
1172         ftgmac100_free_buffers(priv);
1173
1174         return 0;
1175 }
1176
1177 static int ftgmac100_hard_start_xmit(struct sk_buff *skb,
1178                                      struct net_device *netdev)
1179 {
1180         struct ftgmac100 *priv = netdev_priv(netdev);
1181         dma_addr_t map;
1182
1183         if (unlikely(skb->len > MAX_PKT_SIZE)) {
1184                 if (net_ratelimit())
1185                         netdev_dbg(netdev, "tx packet too big\n");
1186
1187                 netdev->stats.tx_dropped++;
1188                 kfree_skb(skb);
1189                 return NETDEV_TX_OK;
1190         }
1191
1192         map = dma_map_single(priv->dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);
1193         if (unlikely(dma_mapping_error(priv->dev, map))) {
1194                 /* drop packet */
1195                 if (net_ratelimit())
1196                         netdev_err(netdev, "map socket buffer failed\n");
1197
1198                 netdev->stats.tx_dropped++;
1199                 kfree_skb(skb);
1200                 return NETDEV_TX_OK;
1201         }
1202
1203         return ftgmac100_xmit(priv, skb, map);
1204 }
1205
1206 /* optional */
1207 static int ftgmac100_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1208 {
1209         if (!netdev->phydev)
1210                 return -ENXIO;
1211
1212         return phy_mii_ioctl(netdev->phydev, ifr, cmd);
1213 }
1214
1215 static const struct net_device_ops ftgmac100_netdev_ops = {
1216         .ndo_open               = ftgmac100_open,
1217         .ndo_stop               = ftgmac100_stop,
1218         .ndo_start_xmit         = ftgmac100_hard_start_xmit,
1219         .ndo_set_mac_address    = ftgmac100_set_mac_addr,
1220         .ndo_validate_addr      = eth_validate_addr,
1221         .ndo_do_ioctl           = ftgmac100_do_ioctl,
1222 };
1223
1224 static int ftgmac100_setup_mdio(struct net_device *netdev)
1225 {
1226         struct ftgmac100 *priv = netdev_priv(netdev);
1227         struct platform_device *pdev = to_platform_device(priv->dev);
1228         int i, err = 0;
1229
1230         /* initialize mdio bus */
1231         priv->mii_bus = mdiobus_alloc();
1232         if (!priv->mii_bus)
1233                 return -EIO;
1234
1235         priv->mii_bus->name = "ftgmac100_mdio";
1236         snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%s-%d",
1237                  pdev->name, pdev->id);
1238         priv->mii_bus->priv = priv->netdev;
1239         priv->mii_bus->read = ftgmac100_mdiobus_read;
1240         priv->mii_bus->write = ftgmac100_mdiobus_write;
1241
1242         for (i = 0; i < PHY_MAX_ADDR; i++)
1243                 priv->mii_bus->irq[i] = PHY_POLL;
1244
1245         err = mdiobus_register(priv->mii_bus);
1246         if (err) {
1247                 dev_err(priv->dev, "Cannot register MDIO bus!\n");
1248                 goto err_register_mdiobus;
1249         }
1250
1251         err = ftgmac100_mii_probe(priv);
1252         if (err) {
1253                 dev_err(priv->dev, "MII Probe failed!\n");
1254                 goto err_mii_probe;
1255         }
1256
1257         return 0;
1258
1259 err_mii_probe:
1260         mdiobus_unregister(priv->mii_bus);
1261 err_register_mdiobus:
1262         mdiobus_free(priv->mii_bus);
1263         return err;
1264 }
1265
1266 static void ftgmac100_destroy_mdio(struct net_device *netdev)
1267 {
1268         struct ftgmac100 *priv = netdev_priv(netdev);
1269
1270         if (!netdev->phydev)
1271                 return;
1272
1273         phy_disconnect(netdev->phydev);
1274         mdiobus_unregister(priv->mii_bus);
1275         mdiobus_free(priv->mii_bus);
1276 }
1277
1278 static void ftgmac100_ncsi_handler(struct ncsi_dev *nd)
1279 {
1280         if (unlikely(nd->state != ncsi_dev_state_functional))
1281                 return;
1282
1283         netdev_info(nd->dev, "NCSI interface %s\n",
1284                     nd->link_up ? "up" : "down");
1285 }
1286
1287 /******************************************************************************
1288  * struct platform_driver functions
1289  *****************************************************************************/
1290 static int ftgmac100_probe(struct platform_device *pdev)
1291 {
1292         struct resource *res;
1293         int irq;
1294         struct net_device *netdev;
1295         struct ftgmac100 *priv;
1296         int err = 0;
1297
1298         if (!pdev)
1299                 return -ENODEV;
1300
1301         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1302         if (!res)
1303                 return -ENXIO;
1304
1305         irq = platform_get_irq(pdev, 0);
1306         if (irq < 0)
1307                 return irq;
1308
1309         /* setup net_device */
1310         netdev = alloc_etherdev(sizeof(*priv));
1311         if (!netdev) {
1312                 err = -ENOMEM;
1313                 goto err_alloc_etherdev;
1314         }
1315
1316         SET_NETDEV_DEV(netdev, &pdev->dev);
1317
1318         netdev->ethtool_ops = &ftgmac100_ethtool_ops;
1319         netdev->netdev_ops = &ftgmac100_netdev_ops;
1320
1321         platform_set_drvdata(pdev, netdev);
1322
1323         /* setup private data */
1324         priv = netdev_priv(netdev);
1325         priv->netdev = netdev;
1326         priv->dev = &pdev->dev;
1327
1328         spin_lock_init(&priv->tx_lock);
1329
1330         /* initialize NAPI */
1331         netif_napi_add(netdev, &priv->napi, ftgmac100_poll, 64);
1332
1333         /* map io memory */
1334         priv->res = request_mem_region(res->start, resource_size(res),
1335                                        dev_name(&pdev->dev));
1336         if (!priv->res) {
1337                 dev_err(&pdev->dev, "Could not reserve memory region\n");
1338                 err = -ENOMEM;
1339                 goto err_req_mem;
1340         }
1341
1342         priv->base = ioremap(res->start, resource_size(res));
1343         if (!priv->base) {
1344                 dev_err(&pdev->dev, "Failed to ioremap ethernet registers\n");
1345                 err = -EIO;
1346                 goto err_ioremap;
1347         }
1348
1349         priv->irq = irq;
1350
1351         /* MAC address from chip or random one */
1352         ftgmac100_setup_mac(priv);
1353
1354         priv->int_mask_all = (FTGMAC100_INT_RPKT_LOST |
1355                               FTGMAC100_INT_XPKT_ETH |
1356                               FTGMAC100_INT_XPKT_LOST |
1357                               FTGMAC100_INT_AHB_ERR |
1358                               FTGMAC100_INT_PHYSTS_CHG |
1359                               FTGMAC100_INT_RPKT_BUF |
1360                               FTGMAC100_INT_NO_RXBUF);
1361         if (pdev->dev.of_node &&
1362             of_get_property(pdev->dev.of_node, "use-ncsi", NULL)) {
1363                 if (!IS_ENABLED(CONFIG_NET_NCSI)) {
1364                         dev_err(&pdev->dev, "NCSI stack not enabled\n");
1365                         goto err_ncsi_dev;
1366                 }
1367
1368                 dev_info(&pdev->dev, "Using NCSI interface\n");
1369                 priv->use_ncsi = true;
1370                 priv->int_mask_all &= ~FTGMAC100_INT_PHYSTS_CHG;
1371                 priv->ndev = ncsi_register_dev(netdev, ftgmac100_ncsi_handler);
1372                 if (!priv->ndev)
1373                         goto err_ncsi_dev;
1374         } else {
1375                 priv->use_ncsi = false;
1376                 err = ftgmac100_setup_mdio(netdev);
1377                 if (err)
1378                         goto err_setup_mdio;
1379         }
1380
1381         /* We have to disable on-chip IP checksum functionality
1382          * when NCSI is enabled on the interface. It doesn't work
1383          * in that case.
1384          */
1385         netdev->features = NETIF_F_IP_CSUM | NETIF_F_GRO;
1386         if (priv->use_ncsi &&
1387             of_get_property(pdev->dev.of_node, "no-hw-checksum", NULL))
1388                 netdev->features &= ~NETIF_F_IP_CSUM;
1389
1390
1391         /* register network device */
1392         err = register_netdev(netdev);
1393         if (err) {
1394                 dev_err(&pdev->dev, "Failed to register netdev\n");
1395                 goto err_register_netdev;
1396         }
1397
1398         netdev_info(netdev, "irq %d, mapped at %p\n", priv->irq, priv->base);
1399
1400         return 0;
1401
1402 err_ncsi_dev:
1403 err_register_netdev:
1404         ftgmac100_destroy_mdio(netdev);
1405 err_setup_mdio:
1406         iounmap(priv->base);
1407 err_ioremap:
1408         release_resource(priv->res);
1409 err_req_mem:
1410         netif_napi_del(&priv->napi);
1411         free_netdev(netdev);
1412 err_alloc_etherdev:
1413         return err;
1414 }
1415
1416 static int __exit ftgmac100_remove(struct platform_device *pdev)
1417 {
1418         struct net_device *netdev;
1419         struct ftgmac100 *priv;
1420
1421         netdev = platform_get_drvdata(pdev);
1422         priv = netdev_priv(netdev);
1423
1424         unregister_netdev(netdev);
1425         ftgmac100_destroy_mdio(netdev);
1426
1427         iounmap(priv->base);
1428         release_resource(priv->res);
1429
1430         netif_napi_del(&priv->napi);
1431         free_netdev(netdev);
1432         return 0;
1433 }
1434
1435 static const struct of_device_id ftgmac100_of_match[] = {
1436         { .compatible = "faraday,ftgmac100" },
1437         { }
1438 };
1439 MODULE_DEVICE_TABLE(of, ftgmac100_of_match);
1440
1441 static struct platform_driver ftgmac100_driver = {
1442         .probe  = ftgmac100_probe,
1443         .remove = __exit_p(ftgmac100_remove),
1444         .driver = {
1445                 .name           = DRV_NAME,
1446                 .of_match_table = ftgmac100_of_match,
1447         },
1448 };
1449 module_platform_driver(ftgmac100_driver);
1450
1451 MODULE_AUTHOR("Po-Yu Chuang <ratbert@faraday-tech.com>");
1452 MODULE_DESCRIPTION("FTGMAC100 driver");
1453 MODULE_LICENSE("GPL");