arm: tegra: comms: Enable autopm for RAW-IP network driver.
[linux-2.6.git] / drivers / net / ftmac100.c
1 /*
2  * Faraday FTMAC100 10/100 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/init.h>
28 #include <linux/io.h>
29 #include <linux/mii.h>
30 #include <linux/module.h>
31 #include <linux/netdevice.h>
32 #include <linux/platform_device.h>
33
34 #include "ftmac100.h"
35
36 #define DRV_NAME        "ftmac100"
37 #define DRV_VERSION     "0.2"
38
39 #define RX_QUEUE_ENTRIES        128     /* must be power of 2 */
40 #define TX_QUEUE_ENTRIES        16      /* must be power of 2 */
41
42 #define MAX_PKT_SIZE            1518
43 #define RX_BUF_SIZE             2044    /* must be smaller than 0x7ff */
44
45 #if MAX_PKT_SIZE > 0x7ff
46 #error invalid MAX_PKT_SIZE
47 #endif
48
49 #if RX_BUF_SIZE > 0x7ff || RX_BUF_SIZE > PAGE_SIZE
50 #error invalid RX_BUF_SIZE
51 #endif
52
53 /******************************************************************************
54  * private data
55  *****************************************************************************/
56 struct ftmac100_descs {
57         struct ftmac100_rxdes rxdes[RX_QUEUE_ENTRIES];
58         struct ftmac100_txdes txdes[TX_QUEUE_ENTRIES];
59 };
60
61 struct ftmac100 {
62         struct resource *res;
63         void __iomem *base;
64         int irq;
65
66         struct ftmac100_descs *descs;
67         dma_addr_t descs_dma_addr;
68
69         unsigned int rx_pointer;
70         unsigned int tx_clean_pointer;
71         unsigned int tx_pointer;
72         unsigned int tx_pending;
73
74         spinlock_t tx_lock;
75
76         struct net_device *netdev;
77         struct device *dev;
78         struct napi_struct napi;
79
80         struct mii_if_info mii;
81 };
82
83 static int ftmac100_alloc_rx_page(struct ftmac100 *priv,
84                                   struct ftmac100_rxdes *rxdes, gfp_t gfp);
85
86 /******************************************************************************
87  * internal functions (hardware register access)
88  *****************************************************************************/
89 #define INT_MASK_ALL_ENABLED    (FTMAC100_INT_RPKT_FINISH       | \
90                                  FTMAC100_INT_NORXBUF           | \
91                                  FTMAC100_INT_XPKT_OK           | \
92                                  FTMAC100_INT_XPKT_LOST         | \
93                                  FTMAC100_INT_RPKT_LOST         | \
94                                  FTMAC100_INT_AHB_ERR           | \
95                                  FTMAC100_INT_PHYSTS_CHG)
96
97 #define INT_MASK_ALL_DISABLED   0
98
99 static void ftmac100_enable_all_int(struct ftmac100 *priv)
100 {
101         iowrite32(INT_MASK_ALL_ENABLED, priv->base + FTMAC100_OFFSET_IMR);
102 }
103
104 static void ftmac100_disable_all_int(struct ftmac100 *priv)
105 {
106         iowrite32(INT_MASK_ALL_DISABLED, priv->base + FTMAC100_OFFSET_IMR);
107 }
108
109 static void ftmac100_set_rx_ring_base(struct ftmac100 *priv, dma_addr_t addr)
110 {
111         iowrite32(addr, priv->base + FTMAC100_OFFSET_RXR_BADR);
112 }
113
114 static void ftmac100_set_tx_ring_base(struct ftmac100 *priv, dma_addr_t addr)
115 {
116         iowrite32(addr, priv->base + FTMAC100_OFFSET_TXR_BADR);
117 }
118
119 static void ftmac100_txdma_start_polling(struct ftmac100 *priv)
120 {
121         iowrite32(1, priv->base + FTMAC100_OFFSET_TXPD);
122 }
123
124 static int ftmac100_reset(struct ftmac100 *priv)
125 {
126         struct net_device *netdev = priv->netdev;
127         int i;
128
129         /* NOTE: reset clears all registers */
130         iowrite32(FTMAC100_MACCR_SW_RST, priv->base + FTMAC100_OFFSET_MACCR);
131
132         for (i = 0; i < 5; i++) {
133                 unsigned int maccr;
134
135                 maccr = ioread32(priv->base + FTMAC100_OFFSET_MACCR);
136                 if (!(maccr & FTMAC100_MACCR_SW_RST)) {
137                         /*
138                          * FTMAC100_MACCR_SW_RST cleared does not indicate
139                          * that hardware reset completed (what the f*ck).
140                          * We still need to wait for a while.
141                          */
142                         udelay(500);
143                         return 0;
144                 }
145
146                 udelay(1000);
147         }
148
149         netdev_err(netdev, "software reset failed\n");
150         return -EIO;
151 }
152
153 static void ftmac100_set_mac(struct ftmac100 *priv, const unsigned char *mac)
154 {
155         unsigned int maddr = mac[0] << 8 | mac[1];
156         unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
157
158         iowrite32(maddr, priv->base + FTMAC100_OFFSET_MAC_MADR);
159         iowrite32(laddr, priv->base + FTMAC100_OFFSET_MAC_LADR);
160 }
161
162 #define MACCR_ENABLE_ALL        (FTMAC100_MACCR_XMT_EN  | \
163                                  FTMAC100_MACCR_RCV_EN  | \
164                                  FTMAC100_MACCR_XDMA_EN | \
165                                  FTMAC100_MACCR_RDMA_EN | \
166                                  FTMAC100_MACCR_CRC_APD | \
167                                  FTMAC100_MACCR_FULLDUP | \
168                                  FTMAC100_MACCR_RX_RUNT | \
169                                  FTMAC100_MACCR_RX_BROADPKT)
170
171 static int ftmac100_start_hw(struct ftmac100 *priv)
172 {
173         struct net_device *netdev = priv->netdev;
174
175         if (ftmac100_reset(priv))
176                 return -EIO;
177
178         /* setup ring buffer base registers */
179         ftmac100_set_rx_ring_base(priv,
180                                   priv->descs_dma_addr +
181                                   offsetof(struct ftmac100_descs, rxdes));
182         ftmac100_set_tx_ring_base(priv,
183                                   priv->descs_dma_addr +
184                                   offsetof(struct ftmac100_descs, txdes));
185
186         iowrite32(FTMAC100_APTC_RXPOLL_CNT(1), priv->base + FTMAC100_OFFSET_APTC);
187
188         ftmac100_set_mac(priv, netdev->dev_addr);
189
190         iowrite32(MACCR_ENABLE_ALL, priv->base + FTMAC100_OFFSET_MACCR);
191         return 0;
192 }
193
194 static void ftmac100_stop_hw(struct ftmac100 *priv)
195 {
196         iowrite32(0, priv->base + FTMAC100_OFFSET_MACCR);
197 }
198
199 /******************************************************************************
200  * internal functions (receive descriptor)
201  *****************************************************************************/
202 static bool ftmac100_rxdes_first_segment(struct ftmac100_rxdes *rxdes)
203 {
204         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_FRS);
205 }
206
207 static bool ftmac100_rxdes_last_segment(struct ftmac100_rxdes *rxdes)
208 {
209         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_LRS);
210 }
211
212 static bool ftmac100_rxdes_owned_by_dma(struct ftmac100_rxdes *rxdes)
213 {
214         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RXDMA_OWN);
215 }
216
217 static void ftmac100_rxdes_set_dma_own(struct ftmac100_rxdes *rxdes)
218 {
219         /* clear status bits */
220         rxdes->rxdes0 = cpu_to_le32(FTMAC100_RXDES0_RXDMA_OWN);
221 }
222
223 static bool ftmac100_rxdes_rx_error(struct ftmac100_rxdes *rxdes)
224 {
225         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RX_ERR);
226 }
227
228 static bool ftmac100_rxdes_crc_error(struct ftmac100_rxdes *rxdes)
229 {
230         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_CRC_ERR);
231 }
232
233 static bool ftmac100_rxdes_frame_too_long(struct ftmac100_rxdes *rxdes)
234 {
235         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_FTL);
236 }
237
238 static bool ftmac100_rxdes_runt(struct ftmac100_rxdes *rxdes)
239 {
240         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RUNT);
241 }
242
243 static bool ftmac100_rxdes_odd_nibble(struct ftmac100_rxdes *rxdes)
244 {
245         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RX_ODD_NB);
246 }
247
248 static unsigned int ftmac100_rxdes_frame_length(struct ftmac100_rxdes *rxdes)
249 {
250         return le32_to_cpu(rxdes->rxdes0) & FTMAC100_RXDES0_RFL;
251 }
252
253 static bool ftmac100_rxdes_multicast(struct ftmac100_rxdes *rxdes)
254 {
255         return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_MULTICAST);
256 }
257
258 static void ftmac100_rxdes_set_buffer_size(struct ftmac100_rxdes *rxdes,
259                                            unsigned int size)
260 {
261         rxdes->rxdes1 &= cpu_to_le32(FTMAC100_RXDES1_EDORR);
262         rxdes->rxdes1 |= cpu_to_le32(FTMAC100_RXDES1_RXBUF_SIZE(size));
263 }
264
265 static void ftmac100_rxdes_set_end_of_ring(struct ftmac100_rxdes *rxdes)
266 {
267         rxdes->rxdes1 |= cpu_to_le32(FTMAC100_RXDES1_EDORR);
268 }
269
270 static void ftmac100_rxdes_set_dma_addr(struct ftmac100_rxdes *rxdes,
271                                         dma_addr_t addr)
272 {
273         rxdes->rxdes2 = cpu_to_le32(addr);
274 }
275
276 static dma_addr_t ftmac100_rxdes_get_dma_addr(struct ftmac100_rxdes *rxdes)
277 {
278         return le32_to_cpu(rxdes->rxdes2);
279 }
280
281 /*
282  * rxdes3 is not used by hardware. We use it to keep track of page.
283  * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
284  */
285 static void ftmac100_rxdes_set_page(struct ftmac100_rxdes *rxdes, struct page *page)
286 {
287         rxdes->rxdes3 = (unsigned int)page;
288 }
289
290 static struct page *ftmac100_rxdes_get_page(struct ftmac100_rxdes *rxdes)
291 {
292         return (struct page *)rxdes->rxdes3;
293 }
294
295 /******************************************************************************
296  * internal functions (receive)
297  *****************************************************************************/
298 static int ftmac100_next_rx_pointer(int pointer)
299 {
300         return (pointer + 1) & (RX_QUEUE_ENTRIES - 1);
301 }
302
303 static void ftmac100_rx_pointer_advance(struct ftmac100 *priv)
304 {
305         priv->rx_pointer = ftmac100_next_rx_pointer(priv->rx_pointer);
306 }
307
308 static struct ftmac100_rxdes *ftmac100_current_rxdes(struct ftmac100 *priv)
309 {
310         return &priv->descs->rxdes[priv->rx_pointer];
311 }
312
313 static struct ftmac100_rxdes *
314 ftmac100_rx_locate_first_segment(struct ftmac100 *priv)
315 {
316         struct ftmac100_rxdes *rxdes = ftmac100_current_rxdes(priv);
317
318         while (!ftmac100_rxdes_owned_by_dma(rxdes)) {
319                 if (ftmac100_rxdes_first_segment(rxdes))
320                         return rxdes;
321
322                 ftmac100_rxdes_set_dma_own(rxdes);
323                 ftmac100_rx_pointer_advance(priv);
324                 rxdes = ftmac100_current_rxdes(priv);
325         }
326
327         return NULL;
328 }
329
330 static bool ftmac100_rx_packet_error(struct ftmac100 *priv,
331                                      struct ftmac100_rxdes *rxdes)
332 {
333         struct net_device *netdev = priv->netdev;
334         bool error = false;
335
336         if (unlikely(ftmac100_rxdes_rx_error(rxdes))) {
337                 if (net_ratelimit())
338                         netdev_info(netdev, "rx err\n");
339
340                 netdev->stats.rx_errors++;
341                 error = true;
342         }
343
344         if (unlikely(ftmac100_rxdes_crc_error(rxdes))) {
345                 if (net_ratelimit())
346                         netdev_info(netdev, "rx crc err\n");
347
348                 netdev->stats.rx_crc_errors++;
349                 error = true;
350         }
351
352         if (unlikely(ftmac100_rxdes_frame_too_long(rxdes))) {
353                 if (net_ratelimit())
354                         netdev_info(netdev, "rx frame too long\n");
355
356                 netdev->stats.rx_length_errors++;
357                 error = true;
358         } else if (unlikely(ftmac100_rxdes_runt(rxdes))) {
359                 if (net_ratelimit())
360                         netdev_info(netdev, "rx runt\n");
361
362                 netdev->stats.rx_length_errors++;
363                 error = true;
364         } else if (unlikely(ftmac100_rxdes_odd_nibble(rxdes))) {
365                 if (net_ratelimit())
366                         netdev_info(netdev, "rx odd nibble\n");
367
368                 netdev->stats.rx_length_errors++;
369                 error = true;
370         }
371
372         return error;
373 }
374
375 static void ftmac100_rx_drop_packet(struct ftmac100 *priv)
376 {
377         struct net_device *netdev = priv->netdev;
378         struct ftmac100_rxdes *rxdes = ftmac100_current_rxdes(priv);
379         bool done = false;
380
381         if (net_ratelimit())
382                 netdev_dbg(netdev, "drop packet %p\n", rxdes);
383
384         do {
385                 if (ftmac100_rxdes_last_segment(rxdes))
386                         done = true;
387
388                 ftmac100_rxdes_set_dma_own(rxdes);
389                 ftmac100_rx_pointer_advance(priv);
390                 rxdes = ftmac100_current_rxdes(priv);
391         } while (!done && !ftmac100_rxdes_owned_by_dma(rxdes));
392
393         netdev->stats.rx_dropped++;
394 }
395
396 static bool ftmac100_rx_packet(struct ftmac100 *priv, int *processed)
397 {
398         struct net_device *netdev = priv->netdev;
399         struct ftmac100_rxdes *rxdes;
400         struct sk_buff *skb;
401         struct page *page;
402         dma_addr_t map;
403         int length;
404
405         rxdes = ftmac100_rx_locate_first_segment(priv);
406         if (!rxdes)
407                 return false;
408
409         if (unlikely(ftmac100_rx_packet_error(priv, rxdes))) {
410                 ftmac100_rx_drop_packet(priv);
411                 return true;
412         }
413
414         /*
415          * It is impossible to get multi-segment packets
416          * because we always provide big enough receive buffers.
417          */
418         if (unlikely(!ftmac100_rxdes_last_segment(rxdes)))
419                 BUG();
420
421         /* start processing */
422         skb = netdev_alloc_skb_ip_align(netdev, 128);
423         if (unlikely(!skb)) {
424                 if (net_ratelimit())
425                         netdev_err(netdev, "rx skb alloc failed\n");
426
427                 ftmac100_rx_drop_packet(priv);
428                 return true;
429         }
430
431         if (unlikely(ftmac100_rxdes_multicast(rxdes)))
432                 netdev->stats.multicast++;
433
434         map = ftmac100_rxdes_get_dma_addr(rxdes);
435         dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
436
437         length = ftmac100_rxdes_frame_length(rxdes);
438         page = ftmac100_rxdes_get_page(rxdes);
439         skb_fill_page_desc(skb, 0, page, 0, length);
440         skb->len += length;
441         skb->data_len += length;
442         skb->truesize += length;
443         __pskb_pull_tail(skb, min(length, 64));
444
445         ftmac100_alloc_rx_page(priv, rxdes, GFP_ATOMIC);
446
447         ftmac100_rx_pointer_advance(priv);
448
449         skb->protocol = eth_type_trans(skb, netdev);
450
451         netdev->stats.rx_packets++;
452         netdev->stats.rx_bytes += skb->len;
453
454         /* push packet to protocol stack */
455         netif_receive_skb(skb);
456
457         (*processed)++;
458         return true;
459 }
460
461 /******************************************************************************
462  * internal functions (transmit descriptor)
463  *****************************************************************************/
464 static void ftmac100_txdes_reset(struct ftmac100_txdes *txdes)
465 {
466         /* clear all except end of ring bit */
467         txdes->txdes0 = 0;
468         txdes->txdes1 &= cpu_to_le32(FTMAC100_TXDES1_EDOTR);
469         txdes->txdes2 = 0;
470         txdes->txdes3 = 0;
471 }
472
473 static bool ftmac100_txdes_owned_by_dma(struct ftmac100_txdes *txdes)
474 {
475         return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXDMA_OWN);
476 }
477
478 static void ftmac100_txdes_set_dma_own(struct ftmac100_txdes *txdes)
479 {
480         /*
481          * Make sure dma own bit will not be set before any other
482          * descriptor fields.
483          */
484         wmb();
485         txdes->txdes0 |= cpu_to_le32(FTMAC100_TXDES0_TXDMA_OWN);
486 }
487
488 static bool ftmac100_txdes_excessive_collision(struct ftmac100_txdes *txdes)
489 {
490         return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXPKT_EXSCOL);
491 }
492
493 static bool ftmac100_txdes_late_collision(struct ftmac100_txdes *txdes)
494 {
495         return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXPKT_LATECOL);
496 }
497
498 static void ftmac100_txdes_set_end_of_ring(struct ftmac100_txdes *txdes)
499 {
500         txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_EDOTR);
501 }
502
503 static void ftmac100_txdes_set_first_segment(struct ftmac100_txdes *txdes)
504 {
505         txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_FTS);
506 }
507
508 static void ftmac100_txdes_set_last_segment(struct ftmac100_txdes *txdes)
509 {
510         txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_LTS);
511 }
512
513 static void ftmac100_txdes_set_txint(struct ftmac100_txdes *txdes)
514 {
515         txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_TXIC);
516 }
517
518 static void ftmac100_txdes_set_buffer_size(struct ftmac100_txdes *txdes,
519                                            unsigned int len)
520 {
521         txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_TXBUF_SIZE(len));
522 }
523
524 static void ftmac100_txdes_set_dma_addr(struct ftmac100_txdes *txdes,
525                                         dma_addr_t addr)
526 {
527         txdes->txdes2 = cpu_to_le32(addr);
528 }
529
530 static dma_addr_t ftmac100_txdes_get_dma_addr(struct ftmac100_txdes *txdes)
531 {
532         return le32_to_cpu(txdes->txdes2);
533 }
534
535 /*
536  * txdes3 is not used by hardware. We use it to keep track of socket buffer.
537  * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
538  */
539 static void ftmac100_txdes_set_skb(struct ftmac100_txdes *txdes, struct sk_buff *skb)
540 {
541         txdes->txdes3 = (unsigned int)skb;
542 }
543
544 static struct sk_buff *ftmac100_txdes_get_skb(struct ftmac100_txdes *txdes)
545 {
546         return (struct sk_buff *)txdes->txdes3;
547 }
548
549 /******************************************************************************
550  * internal functions (transmit)
551  *****************************************************************************/
552 static int ftmac100_next_tx_pointer(int pointer)
553 {
554         return (pointer + 1) & (TX_QUEUE_ENTRIES - 1);
555 }
556
557 static void ftmac100_tx_pointer_advance(struct ftmac100 *priv)
558 {
559         priv->tx_pointer = ftmac100_next_tx_pointer(priv->tx_pointer);
560 }
561
562 static void ftmac100_tx_clean_pointer_advance(struct ftmac100 *priv)
563 {
564         priv->tx_clean_pointer = ftmac100_next_tx_pointer(priv->tx_clean_pointer);
565 }
566
567 static struct ftmac100_txdes *ftmac100_current_txdes(struct ftmac100 *priv)
568 {
569         return &priv->descs->txdes[priv->tx_pointer];
570 }
571
572 static struct ftmac100_txdes *ftmac100_current_clean_txdes(struct ftmac100 *priv)
573 {
574         return &priv->descs->txdes[priv->tx_clean_pointer];
575 }
576
577 static bool ftmac100_tx_complete_packet(struct ftmac100 *priv)
578 {
579         struct net_device *netdev = priv->netdev;
580         struct ftmac100_txdes *txdes;
581         struct sk_buff *skb;
582         dma_addr_t map;
583
584         if (priv->tx_pending == 0)
585                 return false;
586
587         txdes = ftmac100_current_clean_txdes(priv);
588
589         if (ftmac100_txdes_owned_by_dma(txdes))
590                 return false;
591
592         skb = ftmac100_txdes_get_skb(txdes);
593         map = ftmac100_txdes_get_dma_addr(txdes);
594
595         if (unlikely(ftmac100_txdes_excessive_collision(txdes) ||
596                      ftmac100_txdes_late_collision(txdes))) {
597                 /*
598                  * packet transmitted to ethernet lost due to late collision
599                  * or excessive collision
600                  */
601                 netdev->stats.tx_aborted_errors++;
602         } else {
603                 netdev->stats.tx_packets++;
604                 netdev->stats.tx_bytes += skb->len;
605         }
606
607         dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
608         dev_kfree_skb(skb);
609
610         ftmac100_txdes_reset(txdes);
611
612         ftmac100_tx_clean_pointer_advance(priv);
613
614         spin_lock(&priv->tx_lock);
615         priv->tx_pending--;
616         spin_unlock(&priv->tx_lock);
617         netif_wake_queue(netdev);
618
619         return true;
620 }
621
622 static void ftmac100_tx_complete(struct ftmac100 *priv)
623 {
624         while (ftmac100_tx_complete_packet(priv))
625                 ;
626 }
627
628 static int ftmac100_xmit(struct ftmac100 *priv, struct sk_buff *skb,
629                          dma_addr_t map)
630 {
631         struct net_device *netdev = priv->netdev;
632         struct ftmac100_txdes *txdes;
633         unsigned int len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
634
635         txdes = ftmac100_current_txdes(priv);
636         ftmac100_tx_pointer_advance(priv);
637
638         /* setup TX descriptor */
639         ftmac100_txdes_set_skb(txdes, skb);
640         ftmac100_txdes_set_dma_addr(txdes, map);
641
642         ftmac100_txdes_set_first_segment(txdes);
643         ftmac100_txdes_set_last_segment(txdes);
644         ftmac100_txdes_set_txint(txdes);
645         ftmac100_txdes_set_buffer_size(txdes, len);
646
647         spin_lock(&priv->tx_lock);
648         priv->tx_pending++;
649         if (priv->tx_pending == TX_QUEUE_ENTRIES)
650                 netif_stop_queue(netdev);
651
652         /* start transmit */
653         ftmac100_txdes_set_dma_own(txdes);
654         spin_unlock(&priv->tx_lock);
655
656         ftmac100_txdma_start_polling(priv);
657         return NETDEV_TX_OK;
658 }
659
660 /******************************************************************************
661  * internal functions (buffer)
662  *****************************************************************************/
663 static int ftmac100_alloc_rx_page(struct ftmac100 *priv,
664                                   struct ftmac100_rxdes *rxdes, gfp_t gfp)
665 {
666         struct net_device *netdev = priv->netdev;
667         struct page *page;
668         dma_addr_t map;
669
670         page = alloc_page(gfp);
671         if (!page) {
672                 if (net_ratelimit())
673                         netdev_err(netdev, "failed to allocate rx page\n");
674                 return -ENOMEM;
675         }
676
677         map = dma_map_page(priv->dev, page, 0, RX_BUF_SIZE, DMA_FROM_DEVICE);
678         if (unlikely(dma_mapping_error(priv->dev, map))) {
679                 if (net_ratelimit())
680                         netdev_err(netdev, "failed to map rx page\n");
681                 __free_page(page);
682                 return -ENOMEM;
683         }
684
685         ftmac100_rxdes_set_page(rxdes, page);
686         ftmac100_rxdes_set_dma_addr(rxdes, map);
687         ftmac100_rxdes_set_buffer_size(rxdes, RX_BUF_SIZE);
688         ftmac100_rxdes_set_dma_own(rxdes);
689         return 0;
690 }
691
692 static void ftmac100_free_buffers(struct ftmac100 *priv)
693 {
694         int i;
695
696         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
697                 struct ftmac100_rxdes *rxdes = &priv->descs->rxdes[i];
698                 struct page *page = ftmac100_rxdes_get_page(rxdes);
699                 dma_addr_t map = ftmac100_rxdes_get_dma_addr(rxdes);
700
701                 if (!page)
702                         continue;
703
704                 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
705                 __free_page(page);
706         }
707
708         for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
709                 struct ftmac100_txdes *txdes = &priv->descs->txdes[i];
710                 struct sk_buff *skb = ftmac100_txdes_get_skb(txdes);
711                 dma_addr_t map = ftmac100_txdes_get_dma_addr(txdes);
712
713                 if (!skb)
714                         continue;
715
716                 dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
717                 dev_kfree_skb(skb);
718         }
719
720         dma_free_coherent(priv->dev, sizeof(struct ftmac100_descs),
721                           priv->descs, priv->descs_dma_addr);
722 }
723
724 static int ftmac100_alloc_buffers(struct ftmac100 *priv)
725 {
726         int i;
727
728         priv->descs = dma_alloc_coherent(priv->dev, sizeof(struct ftmac100_descs),
729                                          &priv->descs_dma_addr, GFP_KERNEL);
730         if (!priv->descs)
731                 return -ENOMEM;
732
733         memset(priv->descs, 0, sizeof(struct ftmac100_descs));
734
735         /* initialize RX ring */
736         ftmac100_rxdes_set_end_of_ring(&priv->descs->rxdes[RX_QUEUE_ENTRIES - 1]);
737
738         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
739                 struct ftmac100_rxdes *rxdes = &priv->descs->rxdes[i];
740
741                 if (ftmac100_alloc_rx_page(priv, rxdes, GFP_KERNEL))
742                         goto err;
743         }
744
745         /* initialize TX ring */
746         ftmac100_txdes_set_end_of_ring(&priv->descs->txdes[TX_QUEUE_ENTRIES - 1]);
747         return 0;
748
749 err:
750         ftmac100_free_buffers(priv);
751         return -ENOMEM;
752 }
753
754 /******************************************************************************
755  * struct mii_if_info functions
756  *****************************************************************************/
757 static int ftmac100_mdio_read(struct net_device *netdev, int phy_id, int reg)
758 {
759         struct ftmac100 *priv = netdev_priv(netdev);
760         unsigned int phycr;
761         int i;
762
763         phycr = FTMAC100_PHYCR_PHYAD(phy_id) |
764                 FTMAC100_PHYCR_REGAD(reg) |
765                 FTMAC100_PHYCR_MIIRD;
766
767         iowrite32(phycr, priv->base + FTMAC100_OFFSET_PHYCR);
768
769         for (i = 0; i < 10; i++) {
770                 phycr = ioread32(priv->base + FTMAC100_OFFSET_PHYCR);
771
772                 if ((phycr & FTMAC100_PHYCR_MIIRD) == 0)
773                         return phycr & FTMAC100_PHYCR_MIIRDATA;
774
775                 udelay(100);
776         }
777
778         netdev_err(netdev, "mdio read timed out\n");
779         return 0;
780 }
781
782 static void ftmac100_mdio_write(struct net_device *netdev, int phy_id, int reg,
783                                 int data)
784 {
785         struct ftmac100 *priv = netdev_priv(netdev);
786         unsigned int phycr;
787         int i;
788
789         phycr = FTMAC100_PHYCR_PHYAD(phy_id) |
790                 FTMAC100_PHYCR_REGAD(reg) |
791                 FTMAC100_PHYCR_MIIWR;
792
793         data = FTMAC100_PHYWDATA_MIIWDATA(data);
794
795         iowrite32(data, priv->base + FTMAC100_OFFSET_PHYWDATA);
796         iowrite32(phycr, priv->base + FTMAC100_OFFSET_PHYCR);
797
798         for (i = 0; i < 10; i++) {
799                 phycr = ioread32(priv->base + FTMAC100_OFFSET_PHYCR);
800
801                 if ((phycr & FTMAC100_PHYCR_MIIWR) == 0)
802                         return;
803
804                 udelay(100);
805         }
806
807         netdev_err(netdev, "mdio write timed out\n");
808 }
809
810 /******************************************************************************
811  * struct ethtool_ops functions
812  *****************************************************************************/
813 static void ftmac100_get_drvinfo(struct net_device *netdev,
814                                  struct ethtool_drvinfo *info)
815 {
816         strcpy(info->driver, DRV_NAME);
817         strcpy(info->version, DRV_VERSION);
818         strcpy(info->bus_info, dev_name(&netdev->dev));
819 }
820
821 static int ftmac100_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
822 {
823         struct ftmac100 *priv = netdev_priv(netdev);
824         return mii_ethtool_gset(&priv->mii, cmd);
825 }
826
827 static int ftmac100_set_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
828 {
829         struct ftmac100 *priv = netdev_priv(netdev);
830         return mii_ethtool_sset(&priv->mii, cmd);
831 }
832
833 static int ftmac100_nway_reset(struct net_device *netdev)
834 {
835         struct ftmac100 *priv = netdev_priv(netdev);
836         return mii_nway_restart(&priv->mii);
837 }
838
839 static u32 ftmac100_get_link(struct net_device *netdev)
840 {
841         struct ftmac100 *priv = netdev_priv(netdev);
842         return mii_link_ok(&priv->mii);
843 }
844
845 static const struct ethtool_ops ftmac100_ethtool_ops = {
846         .set_settings           = ftmac100_set_settings,
847         .get_settings           = ftmac100_get_settings,
848         .get_drvinfo            = ftmac100_get_drvinfo,
849         .nway_reset             = ftmac100_nway_reset,
850         .get_link               = ftmac100_get_link,
851 };
852
853 /******************************************************************************
854  * interrupt handler
855  *****************************************************************************/
856 static irqreturn_t ftmac100_interrupt(int irq, void *dev_id)
857 {
858         struct net_device *netdev = dev_id;
859         struct ftmac100 *priv = netdev_priv(netdev);
860
861         if (likely(netif_running(netdev))) {
862                 /* Disable interrupts for polling */
863                 ftmac100_disable_all_int(priv);
864                 napi_schedule(&priv->napi);
865         }
866
867         return IRQ_HANDLED;
868 }
869
870 /******************************************************************************
871  * struct napi_struct functions
872  *****************************************************************************/
873 static int ftmac100_poll(struct napi_struct *napi, int budget)
874 {
875         struct ftmac100 *priv = container_of(napi, struct ftmac100, napi);
876         struct net_device *netdev = priv->netdev;
877         unsigned int status;
878         bool completed = true;
879         int rx = 0;
880
881         status = ioread32(priv->base + FTMAC100_OFFSET_ISR);
882
883         if (status & (FTMAC100_INT_RPKT_FINISH | FTMAC100_INT_NORXBUF)) {
884                 /*
885                  * FTMAC100_INT_RPKT_FINISH:
886                  *      RX DMA has received packets into RX buffer successfully
887                  *
888                  * FTMAC100_INT_NORXBUF:
889                  *      RX buffer unavailable
890                  */
891                 bool retry;
892
893                 do {
894                         retry = ftmac100_rx_packet(priv, &rx);
895                 } while (retry && rx < budget);
896
897                 if (retry && rx == budget)
898                         completed = false;
899         }
900
901         if (status & (FTMAC100_INT_XPKT_OK | FTMAC100_INT_XPKT_LOST)) {
902                 /*
903                  * FTMAC100_INT_XPKT_OK:
904                  *      packet transmitted to ethernet successfully
905                  *
906                  * FTMAC100_INT_XPKT_LOST:
907                  *      packet transmitted to ethernet lost due to late
908                  *      collision or excessive collision
909                  */
910                 ftmac100_tx_complete(priv);
911         }
912
913         if (status & (FTMAC100_INT_NORXBUF | FTMAC100_INT_RPKT_LOST |
914                       FTMAC100_INT_AHB_ERR | FTMAC100_INT_PHYSTS_CHG)) {
915                 if (net_ratelimit())
916                         netdev_info(netdev, "[ISR] = 0x%x: %s%s%s%s\n", status,
917                                     status & FTMAC100_INT_NORXBUF ? "NORXBUF " : "",
918                                     status & FTMAC100_INT_RPKT_LOST ? "RPKT_LOST " : "",
919                                     status & FTMAC100_INT_AHB_ERR ? "AHB_ERR " : "",
920                                     status & FTMAC100_INT_PHYSTS_CHG ? "PHYSTS_CHG" : "");
921
922                 if (status & FTMAC100_INT_NORXBUF) {
923                         /* RX buffer unavailable */
924                         netdev->stats.rx_over_errors++;
925                 }
926
927                 if (status & FTMAC100_INT_RPKT_LOST) {
928                         /* received packet lost due to RX FIFO full */
929                         netdev->stats.rx_fifo_errors++;
930                 }
931
932                 if (status & FTMAC100_INT_PHYSTS_CHG) {
933                         /* PHY link status change */
934                         mii_check_link(&priv->mii);
935                 }
936         }
937
938         if (completed) {
939                 /* stop polling */
940                 napi_complete(napi);
941                 ftmac100_enable_all_int(priv);
942         }
943
944         return rx;
945 }
946
947 /******************************************************************************
948  * struct net_device_ops functions
949  *****************************************************************************/
950 static int ftmac100_open(struct net_device *netdev)
951 {
952         struct ftmac100 *priv = netdev_priv(netdev);
953         int err;
954
955         err = ftmac100_alloc_buffers(priv);
956         if (err) {
957                 netdev_err(netdev, "failed to allocate buffers\n");
958                 goto err_alloc;
959         }
960
961         err = request_irq(priv->irq, ftmac100_interrupt, 0, netdev->name, netdev);
962         if (err) {
963                 netdev_err(netdev, "failed to request irq %d\n", priv->irq);
964                 goto err_irq;
965         }
966
967         priv->rx_pointer = 0;
968         priv->tx_clean_pointer = 0;
969         priv->tx_pointer = 0;
970         priv->tx_pending = 0;
971
972         err = ftmac100_start_hw(priv);
973         if (err)
974                 goto err_hw;
975
976         napi_enable(&priv->napi);
977         netif_start_queue(netdev);
978
979         ftmac100_enable_all_int(priv);
980
981         return 0;
982
983 err_hw:
984         free_irq(priv->irq, netdev);
985 err_irq:
986         ftmac100_free_buffers(priv);
987 err_alloc:
988         return err;
989 }
990
991 static int ftmac100_stop(struct net_device *netdev)
992 {
993         struct ftmac100 *priv = netdev_priv(netdev);
994
995         ftmac100_disable_all_int(priv);
996         netif_stop_queue(netdev);
997         napi_disable(&priv->napi);
998         ftmac100_stop_hw(priv);
999         free_irq(priv->irq, netdev);
1000         ftmac100_free_buffers(priv);
1001
1002         return 0;
1003 }
1004
1005 static int ftmac100_hard_start_xmit(struct sk_buff *skb, struct net_device *netdev)
1006 {
1007         struct ftmac100 *priv = netdev_priv(netdev);
1008         dma_addr_t map;
1009
1010         if (unlikely(skb->len > MAX_PKT_SIZE)) {
1011                 if (net_ratelimit())
1012                         netdev_dbg(netdev, "tx packet too big\n");
1013
1014                 netdev->stats.tx_dropped++;
1015                 dev_kfree_skb(skb);
1016                 return NETDEV_TX_OK;
1017         }
1018
1019         map = dma_map_single(priv->dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);
1020         if (unlikely(dma_mapping_error(priv->dev, map))) {
1021                 /* drop packet */
1022                 if (net_ratelimit())
1023                         netdev_err(netdev, "map socket buffer failed\n");
1024
1025                 netdev->stats.tx_dropped++;
1026                 dev_kfree_skb(skb);
1027                 return NETDEV_TX_OK;
1028         }
1029
1030         return ftmac100_xmit(priv, skb, map);
1031 }
1032
1033 /* optional */
1034 static int ftmac100_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1035 {
1036         struct ftmac100 *priv = netdev_priv(netdev);
1037         struct mii_ioctl_data *data = if_mii(ifr);
1038
1039         return generic_mii_ioctl(&priv->mii, data, cmd, NULL);
1040 }
1041
1042 static const struct net_device_ops ftmac100_netdev_ops = {
1043         .ndo_open               = ftmac100_open,
1044         .ndo_stop               = ftmac100_stop,
1045         .ndo_start_xmit         = ftmac100_hard_start_xmit,
1046         .ndo_set_mac_address    = eth_mac_addr,
1047         .ndo_validate_addr      = eth_validate_addr,
1048         .ndo_do_ioctl           = ftmac100_do_ioctl,
1049 };
1050
1051 /******************************************************************************
1052  * struct platform_driver functions
1053  *****************************************************************************/
1054 static int ftmac100_probe(struct platform_device *pdev)
1055 {
1056         struct resource *res;
1057         int irq;
1058         struct net_device *netdev;
1059         struct ftmac100 *priv;
1060         int err;
1061
1062         if (!pdev)
1063                 return -ENODEV;
1064
1065         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1066         if (!res)
1067                 return -ENXIO;
1068
1069         irq = platform_get_irq(pdev, 0);
1070         if (irq < 0)
1071                 return irq;
1072
1073         /* setup net_device */
1074         netdev = alloc_etherdev(sizeof(*priv));
1075         if (!netdev) {
1076                 err = -ENOMEM;
1077                 goto err_alloc_etherdev;
1078         }
1079
1080         SET_NETDEV_DEV(netdev, &pdev->dev);
1081         SET_ETHTOOL_OPS(netdev, &ftmac100_ethtool_ops);
1082         netdev->netdev_ops = &ftmac100_netdev_ops;
1083
1084         platform_set_drvdata(pdev, netdev);
1085
1086         /* setup private data */
1087         priv = netdev_priv(netdev);
1088         priv->netdev = netdev;
1089         priv->dev = &pdev->dev;
1090
1091         spin_lock_init(&priv->tx_lock);
1092
1093         /* initialize NAPI */
1094         netif_napi_add(netdev, &priv->napi, ftmac100_poll, 64);
1095
1096         /* map io memory */
1097         priv->res = request_mem_region(res->start, resource_size(res),
1098                                        dev_name(&pdev->dev));
1099         if (!priv->res) {
1100                 dev_err(&pdev->dev, "Could not reserve memory region\n");
1101                 err = -ENOMEM;
1102                 goto err_req_mem;
1103         }
1104
1105         priv->base = ioremap(res->start, resource_size(res));
1106         if (!priv->base) {
1107                 dev_err(&pdev->dev, "Failed to ioremap ethernet registers\n");
1108                 err = -EIO;
1109                 goto err_ioremap;
1110         }
1111
1112         priv->irq = irq;
1113
1114         /* initialize struct mii_if_info */
1115         priv->mii.phy_id        = 0;
1116         priv->mii.phy_id_mask   = 0x1f;
1117         priv->mii.reg_num_mask  = 0x1f;
1118         priv->mii.dev           = netdev;
1119         priv->mii.mdio_read     = ftmac100_mdio_read;
1120         priv->mii.mdio_write    = ftmac100_mdio_write;
1121
1122         /* register network device */
1123         err = register_netdev(netdev);
1124         if (err) {
1125                 dev_err(&pdev->dev, "Failed to register netdev\n");
1126                 goto err_register_netdev;
1127         }
1128
1129         netdev_info(netdev, "irq %d, mapped at %p\n", priv->irq, priv->base);
1130
1131         if (!is_valid_ether_addr(netdev->dev_addr)) {
1132                 random_ether_addr(netdev->dev_addr);
1133                 netdev_info(netdev, "generated random MAC address %pM\n",
1134                             netdev->dev_addr);
1135         }
1136
1137         return 0;
1138
1139 err_register_netdev:
1140         iounmap(priv->base);
1141 err_ioremap:
1142         release_resource(priv->res);
1143 err_req_mem:
1144         netif_napi_del(&priv->napi);
1145         platform_set_drvdata(pdev, NULL);
1146         free_netdev(netdev);
1147 err_alloc_etherdev:
1148         return err;
1149 }
1150
1151 static int __exit ftmac100_remove(struct platform_device *pdev)
1152 {
1153         struct net_device *netdev;
1154         struct ftmac100 *priv;
1155
1156         netdev = platform_get_drvdata(pdev);
1157         priv = netdev_priv(netdev);
1158
1159         unregister_netdev(netdev);
1160
1161         iounmap(priv->base);
1162         release_resource(priv->res);
1163
1164         netif_napi_del(&priv->napi);
1165         platform_set_drvdata(pdev, NULL);
1166         free_netdev(netdev);
1167         return 0;
1168 }
1169
1170 static struct platform_driver ftmac100_driver = {
1171         .probe          = ftmac100_probe,
1172         .remove         = __exit_p(ftmac100_remove),
1173         .driver         = {
1174                 .name   = DRV_NAME,
1175                 .owner  = THIS_MODULE,
1176         },
1177 };
1178
1179 /******************************************************************************
1180  * initialization / finalization
1181  *****************************************************************************/
1182 static int __init ftmac100_init(void)
1183 {
1184         pr_info("Loading version " DRV_VERSION " ...\n");
1185         return platform_driver_register(&ftmac100_driver);
1186 }
1187
1188 static void __exit ftmac100_exit(void)
1189 {
1190         platform_driver_unregister(&ftmac100_driver);
1191 }
1192
1193 module_init(ftmac100_init);
1194 module_exit(ftmac100_exit);
1195
1196 MODULE_AUTHOR("Po-Yu Chuang <ratbert@faraday-tech.com>");
1197 MODULE_DESCRIPTION("FTMAC100 driver");
1198 MODULE_LICENSE("GPL");