2 * Faraday FTMAC100 10/100 Ethernet
4 * (C) Copyright 2009-2011 Faraday Technology
5 * Po-Yu Chuang <ratbert@faraday-tech.com>
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.
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.
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.
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 #include <linux/dma-mapping.h>
25 #include <linux/etherdevice.h>
26 #include <linux/ethtool.h>
27 #include <linux/init.h>
29 #include <linux/mii.h>
30 #include <linux/module.h>
31 #include <linux/netdevice.h>
32 #include <linux/platform_device.h>
36 #define DRV_NAME "ftmac100"
37 #define DRV_VERSION "0.2"
39 #define RX_QUEUE_ENTRIES 128 /* must be power of 2 */
40 #define TX_QUEUE_ENTRIES 16 /* must be power of 2 */
42 #define MAX_PKT_SIZE 1518
43 #define RX_BUF_SIZE 2044 /* must be smaller than 0x7ff */
45 #if MAX_PKT_SIZE > 0x7ff
46 #error invalid MAX_PKT_SIZE
49 #if RX_BUF_SIZE > 0x7ff || RX_BUF_SIZE > PAGE_SIZE
50 #error invalid RX_BUF_SIZE
53 /******************************************************************************
55 *****************************************************************************/
56 struct ftmac100_descs {
57 struct ftmac100_rxdes rxdes[RX_QUEUE_ENTRIES];
58 struct ftmac100_txdes txdes[TX_QUEUE_ENTRIES];
66 struct ftmac100_descs *descs;
67 dma_addr_t descs_dma_addr;
69 unsigned int rx_pointer;
70 unsigned int tx_clean_pointer;
71 unsigned int tx_pointer;
72 unsigned int tx_pending;
76 struct net_device *netdev;
78 struct napi_struct napi;
80 struct mii_if_info mii;
83 static int ftmac100_alloc_rx_page(struct ftmac100 *priv, struct ftmac100_rxdes *rxdes);
85 /******************************************************************************
86 * internal functions (hardware register access)
87 *****************************************************************************/
88 #define INT_MASK_ALL_ENABLED (FTMAC100_INT_RPKT_FINISH | \
89 FTMAC100_INT_NORXBUF | \
90 FTMAC100_INT_XPKT_OK | \
91 FTMAC100_INT_XPKT_LOST | \
92 FTMAC100_INT_RPKT_LOST | \
93 FTMAC100_INT_AHB_ERR | \
94 FTMAC100_INT_PHYSTS_CHG)
96 #define INT_MASK_ALL_DISABLED 0
98 static void ftmac100_enable_all_int(struct ftmac100 *priv)
100 iowrite32(INT_MASK_ALL_ENABLED, priv->base + FTMAC100_OFFSET_IMR);
103 static void ftmac100_disable_all_int(struct ftmac100 *priv)
105 iowrite32(INT_MASK_ALL_DISABLED, priv->base + FTMAC100_OFFSET_IMR);
108 static void ftmac100_set_rx_ring_base(struct ftmac100 *priv, dma_addr_t addr)
110 iowrite32(addr, priv->base + FTMAC100_OFFSET_RXR_BADR);
113 static void ftmac100_set_tx_ring_base(struct ftmac100 *priv, dma_addr_t addr)
115 iowrite32(addr, priv->base + FTMAC100_OFFSET_TXR_BADR);
118 static void ftmac100_txdma_start_polling(struct ftmac100 *priv)
120 iowrite32(1, priv->base + FTMAC100_OFFSET_TXPD);
123 static int ftmac100_reset(struct ftmac100 *priv)
125 struct net_device *netdev = priv->netdev;
128 /* NOTE: reset clears all registers */
129 iowrite32(FTMAC100_MACCR_SW_RST, priv->base + FTMAC100_OFFSET_MACCR);
131 for (i = 0; i < 5; i++) {
134 maccr = ioread32(priv->base + FTMAC100_OFFSET_MACCR);
135 if (!(maccr & FTMAC100_MACCR_SW_RST)) {
137 * FTMAC100_MACCR_SW_RST cleared does not indicate
138 * that hardware reset completed (what the f*ck).
139 * We still need to wait for a while.
141 usleep_range(500, 1000);
145 usleep_range(1000, 10000);
148 netdev_err(netdev, "software reset failed\n");
152 static void ftmac100_set_mac(struct ftmac100 *priv, const unsigned char *mac)
154 unsigned int maddr = mac[0] << 8 | mac[1];
155 unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
157 iowrite32(maddr, priv->base + FTMAC100_OFFSET_MAC_MADR);
158 iowrite32(laddr, priv->base + FTMAC100_OFFSET_MAC_LADR);
161 #define MACCR_ENABLE_ALL (FTMAC100_MACCR_XMT_EN | \
162 FTMAC100_MACCR_RCV_EN | \
163 FTMAC100_MACCR_XDMA_EN | \
164 FTMAC100_MACCR_RDMA_EN | \
165 FTMAC100_MACCR_CRC_APD | \
166 FTMAC100_MACCR_FULLDUP | \
167 FTMAC100_MACCR_RX_RUNT | \
168 FTMAC100_MACCR_RX_BROADPKT)
170 static int ftmac100_start_hw(struct ftmac100 *priv)
172 struct net_device *netdev = priv->netdev;
174 if (ftmac100_reset(priv))
177 /* setup ring buffer base registers */
178 ftmac100_set_rx_ring_base(priv,
179 priv->descs_dma_addr +
180 offsetof(struct ftmac100_descs, rxdes));
181 ftmac100_set_tx_ring_base(priv,
182 priv->descs_dma_addr +
183 offsetof(struct ftmac100_descs, txdes));
185 iowrite32(FTMAC100_APTC_RXPOLL_CNT(1), priv->base + FTMAC100_OFFSET_APTC);
187 ftmac100_set_mac(priv, netdev->dev_addr);
189 iowrite32(MACCR_ENABLE_ALL, priv->base + FTMAC100_OFFSET_MACCR);
193 static void ftmac100_stop_hw(struct ftmac100 *priv)
195 iowrite32(0, priv->base + FTMAC100_OFFSET_MACCR);
198 /******************************************************************************
199 * internal functions (receive descriptor)
200 *****************************************************************************/
201 static bool ftmac100_rxdes_first_segment(struct ftmac100_rxdes *rxdes)
203 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_FRS);
206 static bool ftmac100_rxdes_last_segment(struct ftmac100_rxdes *rxdes)
208 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_LRS);
211 static bool ftmac100_rxdes_owned_by_dma(struct ftmac100_rxdes *rxdes)
213 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RXDMA_OWN);
216 static void ftmac100_rxdes_set_dma_own(struct ftmac100_rxdes *rxdes)
218 /* clear status bits */
219 rxdes->rxdes0 = cpu_to_le32(FTMAC100_RXDES0_RXDMA_OWN);
222 static bool ftmac100_rxdes_rx_error(struct ftmac100_rxdes *rxdes)
224 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RX_ERR);
227 static bool ftmac100_rxdes_crc_error(struct ftmac100_rxdes *rxdes)
229 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_CRC_ERR);
232 static bool ftmac100_rxdes_frame_too_long(struct ftmac100_rxdes *rxdes)
234 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_FTL);
237 static bool ftmac100_rxdes_runt(struct ftmac100_rxdes *rxdes)
239 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RUNT);
242 static bool ftmac100_rxdes_odd_nibble(struct ftmac100_rxdes *rxdes)
244 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RX_ODD_NB);
247 static unsigned int ftmac100_rxdes_frame_length(struct ftmac100_rxdes *rxdes)
249 return le32_to_cpu(rxdes->rxdes0) & FTMAC100_RXDES0_RFL;
252 static bool ftmac100_rxdes_multicast(struct ftmac100_rxdes *rxdes)
254 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_MULTICAST);
257 static void ftmac100_rxdes_set_buffer_size(struct ftmac100_rxdes *rxdes,
260 rxdes->rxdes1 &= cpu_to_le32(FTMAC100_RXDES1_EDORR);
261 rxdes->rxdes1 |= cpu_to_le32(FTMAC100_RXDES1_RXBUF_SIZE(size));
264 static void ftmac100_rxdes_set_end_of_ring(struct ftmac100_rxdes *rxdes)
266 rxdes->rxdes1 |= cpu_to_le32(FTMAC100_RXDES1_EDORR);
269 static void ftmac100_rxdes_set_dma_addr(struct ftmac100_rxdes *rxdes,
272 rxdes->rxdes2 = cpu_to_le32(addr);
275 static dma_addr_t ftmac100_rxdes_get_dma_addr(struct ftmac100_rxdes *rxdes)
277 return le32_to_cpu(rxdes->rxdes2);
281 * rxdes3 is not used by hardware. We use it to keep track of page.
282 * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
284 static void ftmac100_rxdes_set_page(struct ftmac100_rxdes *rxdes, struct page *page)
286 rxdes->rxdes3 = (unsigned int)page;
289 static struct page *ftmac100_rxdes_get_page(struct ftmac100_rxdes *rxdes)
291 return (struct page *)rxdes->rxdes3;
294 /******************************************************************************
295 * internal functions (receive)
296 *****************************************************************************/
297 static int ftmac100_next_rx_pointer(int pointer)
299 return (pointer + 1) & (RX_QUEUE_ENTRIES - 1);
302 static void ftmac100_rx_pointer_advance(struct ftmac100 *priv)
304 priv->rx_pointer = ftmac100_next_rx_pointer(priv->rx_pointer);
307 static struct ftmac100_rxdes *ftmac100_current_rxdes(struct ftmac100 *priv)
309 return &priv->descs->rxdes[priv->rx_pointer];
312 static struct ftmac100_rxdes *
313 ftmac100_rx_locate_first_segment(struct ftmac100 *priv)
315 struct ftmac100_rxdes *rxdes = ftmac100_current_rxdes(priv);
317 while (!ftmac100_rxdes_owned_by_dma(rxdes)) {
318 if (ftmac100_rxdes_first_segment(rxdes))
321 ftmac100_rxdes_set_dma_own(rxdes);
322 ftmac100_rx_pointer_advance(priv);
323 rxdes = ftmac100_current_rxdes(priv);
329 static bool ftmac100_rx_packet_error(struct ftmac100 *priv,
330 struct ftmac100_rxdes *rxdes)
332 struct net_device *netdev = priv->netdev;
335 if (unlikely(ftmac100_rxdes_rx_error(rxdes))) {
337 netdev_info(netdev, "rx err\n");
339 netdev->stats.rx_errors++;
343 if (unlikely(ftmac100_rxdes_crc_error(rxdes))) {
345 netdev_info(netdev, "rx crc err\n");
347 netdev->stats.rx_crc_errors++;
351 if (unlikely(ftmac100_rxdes_frame_too_long(rxdes))) {
353 netdev_info(netdev, "rx frame too long\n");
355 netdev->stats.rx_length_errors++;
357 } else if (unlikely(ftmac100_rxdes_runt(rxdes))) {
359 netdev_info(netdev, "rx runt\n");
361 netdev->stats.rx_length_errors++;
363 } else if (unlikely(ftmac100_rxdes_odd_nibble(rxdes))) {
365 netdev_info(netdev, "rx odd nibble\n");
367 netdev->stats.rx_length_errors++;
374 static void ftmac100_rx_drop_packet(struct ftmac100 *priv)
376 struct net_device *netdev = priv->netdev;
377 struct ftmac100_rxdes *rxdes = ftmac100_current_rxdes(priv);
381 netdev_dbg(netdev, "drop packet %p\n", rxdes);
384 if (ftmac100_rxdes_last_segment(rxdes))
387 ftmac100_rxdes_set_dma_own(rxdes);
388 ftmac100_rx_pointer_advance(priv);
389 rxdes = ftmac100_current_rxdes(priv);
390 } while (!done && !ftmac100_rxdes_owned_by_dma(rxdes));
392 netdev->stats.rx_dropped++;
395 static bool ftmac100_rx_packet(struct ftmac100 *priv, int *processed)
397 struct net_device *netdev = priv->netdev;
398 struct ftmac100_rxdes *rxdes;
404 rxdes = ftmac100_rx_locate_first_segment(priv);
408 if (unlikely(ftmac100_rx_packet_error(priv, rxdes))) {
409 ftmac100_rx_drop_packet(priv);
414 * It is impossible to get multi-segment packets
415 * because we always provide big enough receive buffers.
417 if (unlikely(!ftmac100_rxdes_last_segment(rxdes)))
420 /* start processing */
421 skb = netdev_alloc_skb_ip_align(netdev, 128);
422 if (unlikely(!skb)) {
424 netdev_err(netdev, "rx skb alloc failed\n");
426 ftmac100_rx_drop_packet(priv);
430 if (unlikely(ftmac100_rxdes_multicast(rxdes)))
431 netdev->stats.multicast++;
433 map = ftmac100_rxdes_get_dma_addr(rxdes);
434 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
436 length = ftmac100_rxdes_frame_length(rxdes);
437 page = ftmac100_rxdes_get_page(rxdes);
438 skb_fill_page_desc(skb, 0, page, 0, length);
440 skb->data_len += length;
441 skb->truesize += length;
442 __pskb_pull_tail(skb, min(length, 64));
444 ftmac100_alloc_rx_page(priv, rxdes);
446 ftmac100_rx_pointer_advance(priv);
448 skb->protocol = eth_type_trans(skb, netdev);
450 netdev->stats.rx_packets++;
451 netdev->stats.rx_bytes += skb->len;
453 /* push packet to protocol stack */
454 netif_receive_skb(skb);
460 /******************************************************************************
461 * internal functions (transmit descriptor)
462 *****************************************************************************/
463 static void ftmac100_txdes_reset(struct ftmac100_txdes *txdes)
465 /* clear all except end of ring bit */
467 txdes->txdes1 &= cpu_to_le32(FTMAC100_TXDES1_EDOTR);
472 static bool ftmac100_txdes_owned_by_dma(struct ftmac100_txdes *txdes)
474 return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXDMA_OWN);
477 static void ftmac100_txdes_set_dma_own(struct ftmac100_txdes *txdes)
480 * Make sure dma own bit will not be set before any other
484 txdes->txdes0 |= cpu_to_le32(FTMAC100_TXDES0_TXDMA_OWN);
487 static bool ftmac100_txdes_excessive_collision(struct ftmac100_txdes *txdes)
489 return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXPKT_EXSCOL);
492 static bool ftmac100_txdes_late_collision(struct ftmac100_txdes *txdes)
494 return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXPKT_LATECOL);
497 static void ftmac100_txdes_set_end_of_ring(struct ftmac100_txdes *txdes)
499 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_EDOTR);
502 static void ftmac100_txdes_set_first_segment(struct ftmac100_txdes *txdes)
504 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_FTS);
507 static void ftmac100_txdes_set_last_segment(struct ftmac100_txdes *txdes)
509 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_LTS);
512 static void ftmac100_txdes_set_txint(struct ftmac100_txdes *txdes)
514 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_TXIC);
517 static void ftmac100_txdes_set_buffer_size(struct ftmac100_txdes *txdes,
520 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_TXBUF_SIZE(len));
523 static void ftmac100_txdes_set_dma_addr(struct ftmac100_txdes *txdes,
526 txdes->txdes2 = cpu_to_le32(addr);
529 static dma_addr_t ftmac100_txdes_get_dma_addr(struct ftmac100_txdes *txdes)
531 return le32_to_cpu(txdes->txdes2);
535 * txdes3 is not used by hardware. We use it to keep track of socket buffer.
536 * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
538 static void ftmac100_txdes_set_skb(struct ftmac100_txdes *txdes, struct sk_buff *skb)
540 txdes->txdes3 = (unsigned int)skb;
543 static struct sk_buff *ftmac100_txdes_get_skb(struct ftmac100_txdes *txdes)
545 return (struct sk_buff *)txdes->txdes3;
548 /******************************************************************************
549 * internal functions (transmit)
550 *****************************************************************************/
551 static int ftmac100_next_tx_pointer(int pointer)
553 return (pointer + 1) & (TX_QUEUE_ENTRIES - 1);
556 static void ftmac100_tx_pointer_advance(struct ftmac100 *priv)
558 priv->tx_pointer = ftmac100_next_tx_pointer(priv->tx_pointer);
561 static void ftmac100_tx_clean_pointer_advance(struct ftmac100 *priv)
563 priv->tx_clean_pointer = ftmac100_next_tx_pointer(priv->tx_clean_pointer);
566 static struct ftmac100_txdes *ftmac100_current_txdes(struct ftmac100 *priv)
568 return &priv->descs->txdes[priv->tx_pointer];
571 static struct ftmac100_txdes *ftmac100_current_clean_txdes(struct ftmac100 *priv)
573 return &priv->descs->txdes[priv->tx_clean_pointer];
576 static bool ftmac100_tx_complete_packet(struct ftmac100 *priv)
578 struct net_device *netdev = priv->netdev;
579 struct ftmac100_txdes *txdes;
583 if (priv->tx_pending == 0)
586 txdes = ftmac100_current_clean_txdes(priv);
588 if (ftmac100_txdes_owned_by_dma(txdes))
591 skb = ftmac100_txdes_get_skb(txdes);
592 map = ftmac100_txdes_get_dma_addr(txdes);
594 if (unlikely(ftmac100_txdes_excessive_collision(txdes) ||
595 ftmac100_txdes_late_collision(txdes))) {
597 * packet transmitted to ethernet lost due to late collision
598 * or excessive collision
600 netdev->stats.tx_aborted_errors++;
602 netdev->stats.tx_packets++;
603 netdev->stats.tx_bytes += skb->len;
606 dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
609 ftmac100_txdes_reset(txdes);
611 ftmac100_tx_clean_pointer_advance(priv);
613 spin_lock(&priv->tx_lock);
615 spin_unlock(&priv->tx_lock);
616 netif_wake_queue(netdev);
621 static void ftmac100_tx_complete(struct ftmac100 *priv)
623 while (ftmac100_tx_complete_packet(priv))
627 static int ftmac100_xmit(struct ftmac100 *priv, struct sk_buff *skb,
630 struct net_device *netdev = priv->netdev;
631 struct ftmac100_txdes *txdes;
632 unsigned int len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
634 txdes = ftmac100_current_txdes(priv);
635 ftmac100_tx_pointer_advance(priv);
637 /* setup TX descriptor */
638 ftmac100_txdes_set_skb(txdes, skb);
639 ftmac100_txdes_set_dma_addr(txdes, map);
641 ftmac100_txdes_set_first_segment(txdes);
642 ftmac100_txdes_set_last_segment(txdes);
643 ftmac100_txdes_set_txint(txdes);
644 ftmac100_txdes_set_buffer_size(txdes, len);
646 spin_lock(&priv->tx_lock);
648 if (priv->tx_pending == TX_QUEUE_ENTRIES)
649 netif_stop_queue(netdev);
652 ftmac100_txdes_set_dma_own(txdes);
653 spin_unlock(&priv->tx_lock);
655 ftmac100_txdma_start_polling(priv);
659 /******************************************************************************
660 * internal functions (buffer)
661 *****************************************************************************/
662 static int ftmac100_alloc_rx_page(struct ftmac100 *priv, struct ftmac100_rxdes *rxdes)
664 struct net_device *netdev = priv->netdev;
668 page = alloc_page(GFP_KERNEL);
671 netdev_err(netdev, "failed to allocate rx page\n");
675 map = dma_map_page(priv->dev, page, 0, RX_BUF_SIZE, DMA_FROM_DEVICE);
676 if (unlikely(dma_mapping_error(priv->dev, map))) {
678 netdev_err(netdev, "failed to map rx page\n");
683 ftmac100_rxdes_set_page(rxdes, page);
684 ftmac100_rxdes_set_dma_addr(rxdes, map);
685 ftmac100_rxdes_set_buffer_size(rxdes, RX_BUF_SIZE);
686 ftmac100_rxdes_set_dma_own(rxdes);
690 static void ftmac100_free_buffers(struct ftmac100 *priv)
694 for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
695 struct ftmac100_rxdes *rxdes = &priv->descs->rxdes[i];
696 struct page *page = ftmac100_rxdes_get_page(rxdes);
697 dma_addr_t map = ftmac100_rxdes_get_dma_addr(rxdes);
702 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
706 for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
707 struct ftmac100_txdes *txdes = &priv->descs->txdes[i];
708 struct sk_buff *skb = ftmac100_txdes_get_skb(txdes);
709 dma_addr_t map = ftmac100_txdes_get_dma_addr(txdes);
714 dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
718 dma_free_coherent(priv->dev, sizeof(struct ftmac100_descs),
719 priv->descs, priv->descs_dma_addr);
722 static int ftmac100_alloc_buffers(struct ftmac100 *priv)
726 priv->descs = dma_alloc_coherent(priv->dev, sizeof(struct ftmac100_descs),
727 &priv->descs_dma_addr, GFP_KERNEL);
731 memset(priv->descs, 0, sizeof(struct ftmac100_descs));
733 /* initialize RX ring */
734 ftmac100_rxdes_set_end_of_ring(&priv->descs->rxdes[RX_QUEUE_ENTRIES - 1]);
736 for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
737 struct ftmac100_rxdes *rxdes = &priv->descs->rxdes[i];
739 if (ftmac100_alloc_rx_page(priv, rxdes))
743 /* initialize TX ring */
744 ftmac100_txdes_set_end_of_ring(&priv->descs->txdes[TX_QUEUE_ENTRIES - 1]);
748 ftmac100_free_buffers(priv);
752 /******************************************************************************
753 * struct mii_if_info functions
754 *****************************************************************************/
755 static int ftmac100_mdio_read(struct net_device *netdev, int phy_id, int reg)
757 struct ftmac100 *priv = netdev_priv(netdev);
761 phycr = FTMAC100_PHYCR_PHYAD(phy_id) |
762 FTMAC100_PHYCR_REGAD(reg) |
763 FTMAC100_PHYCR_MIIRD;
765 iowrite32(phycr, priv->base + FTMAC100_OFFSET_PHYCR);
767 for (i = 0; i < 10; i++) {
768 phycr = ioread32(priv->base + FTMAC100_OFFSET_PHYCR);
770 if ((phycr & FTMAC100_PHYCR_MIIRD) == 0)
771 return phycr & FTMAC100_PHYCR_MIIRDATA;
773 usleep_range(100, 1000);
776 netdev_err(netdev, "mdio read timed out\n");
780 static void ftmac100_mdio_write(struct net_device *netdev, int phy_id, int reg,
783 struct ftmac100 *priv = netdev_priv(netdev);
787 phycr = FTMAC100_PHYCR_PHYAD(phy_id) |
788 FTMAC100_PHYCR_REGAD(reg) |
789 FTMAC100_PHYCR_MIIWR;
791 data = FTMAC100_PHYWDATA_MIIWDATA(data);
793 iowrite32(data, priv->base + FTMAC100_OFFSET_PHYWDATA);
794 iowrite32(phycr, priv->base + FTMAC100_OFFSET_PHYCR);
796 for (i = 0; i < 10; i++) {
797 phycr = ioread32(priv->base + FTMAC100_OFFSET_PHYCR);
799 if ((phycr & FTMAC100_PHYCR_MIIWR) == 0)
802 usleep_range(100, 1000);
805 netdev_err(netdev, "mdio write timed out\n");
808 /******************************************************************************
809 * struct ethtool_ops functions
810 *****************************************************************************/
811 static void ftmac100_get_drvinfo(struct net_device *netdev,
812 struct ethtool_drvinfo *info)
814 strcpy(info->driver, DRV_NAME);
815 strcpy(info->version, DRV_VERSION);
816 strcpy(info->bus_info, dev_name(&netdev->dev));
819 static int ftmac100_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
821 struct ftmac100 *priv = netdev_priv(netdev);
822 return mii_ethtool_gset(&priv->mii, cmd);
825 static int ftmac100_set_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
827 struct ftmac100 *priv = netdev_priv(netdev);
828 return mii_ethtool_sset(&priv->mii, cmd);
831 static int ftmac100_nway_reset(struct net_device *netdev)
833 struct ftmac100 *priv = netdev_priv(netdev);
834 return mii_nway_restart(&priv->mii);
837 static u32 ftmac100_get_link(struct net_device *netdev)
839 struct ftmac100 *priv = netdev_priv(netdev);
840 return mii_link_ok(&priv->mii);
843 static const struct ethtool_ops ftmac100_ethtool_ops = {
844 .set_settings = ftmac100_set_settings,
845 .get_settings = ftmac100_get_settings,
846 .get_drvinfo = ftmac100_get_drvinfo,
847 .nway_reset = ftmac100_nway_reset,
848 .get_link = ftmac100_get_link,
851 /******************************************************************************
853 *****************************************************************************/
854 static irqreturn_t ftmac100_interrupt(int irq, void *dev_id)
856 struct net_device *netdev = dev_id;
857 struct ftmac100 *priv = netdev_priv(netdev);
859 if (likely(netif_running(netdev))) {
860 /* Disable interrupts for polling */
861 ftmac100_disable_all_int(priv);
862 napi_schedule(&priv->napi);
868 /******************************************************************************
869 * struct napi_struct functions
870 *****************************************************************************/
871 static int ftmac100_poll(struct napi_struct *napi, int budget)
873 struct ftmac100 *priv = container_of(napi, struct ftmac100, napi);
874 struct net_device *netdev = priv->netdev;
876 bool completed = true;
879 status = ioread32(priv->base + FTMAC100_OFFSET_ISR);
881 if (status & (FTMAC100_INT_RPKT_FINISH | FTMAC100_INT_NORXBUF)) {
883 * FTMAC100_INT_RPKT_FINISH:
884 * RX DMA has received packets into RX buffer successfully
886 * FTMAC100_INT_NORXBUF:
887 * RX buffer unavailable
892 retry = ftmac100_rx_packet(priv, &rx);
893 } while (retry && rx < budget);
895 if (retry && rx == budget)
899 if (status & (FTMAC100_INT_XPKT_OK | FTMAC100_INT_XPKT_LOST)) {
901 * FTMAC100_INT_XPKT_OK:
902 * packet transmitted to ethernet successfully
904 * FTMAC100_INT_XPKT_LOST:
905 * packet transmitted to ethernet lost due to late
906 * collision or excessive collision
908 ftmac100_tx_complete(priv);
911 if (status & (FTMAC100_INT_NORXBUF | FTMAC100_INT_RPKT_LOST |
912 FTMAC100_INT_AHB_ERR | FTMAC100_INT_PHYSTS_CHG)) {
914 netdev_info(netdev, "[ISR] = 0x%x: %s%s%s%s\n", status,
915 status & FTMAC100_INT_NORXBUF ? "NORXBUF " : "",
916 status & FTMAC100_INT_RPKT_LOST ? "RPKT_LOST " : "",
917 status & FTMAC100_INT_AHB_ERR ? "AHB_ERR " : "",
918 status & FTMAC100_INT_PHYSTS_CHG ? "PHYSTS_CHG" : "");
920 if (status & FTMAC100_INT_NORXBUF) {
921 /* RX buffer unavailable */
922 netdev->stats.rx_over_errors++;
925 if (status & FTMAC100_INT_RPKT_LOST) {
926 /* received packet lost due to RX FIFO full */
927 netdev->stats.rx_fifo_errors++;
930 if (status & FTMAC100_INT_PHYSTS_CHG) {
931 /* PHY link status change */
932 mii_check_link(&priv->mii);
939 ftmac100_enable_all_int(priv);
945 /******************************************************************************
946 * struct net_device_ops functions
947 *****************************************************************************/
948 static int ftmac100_open(struct net_device *netdev)
950 struct ftmac100 *priv = netdev_priv(netdev);
953 err = ftmac100_alloc_buffers(priv);
955 netdev_err(netdev, "failed to allocate buffers\n");
959 err = request_irq(priv->irq, ftmac100_interrupt, 0, netdev->name, netdev);
961 netdev_err(netdev, "failed to request irq %d\n", priv->irq);
965 priv->rx_pointer = 0;
966 priv->tx_clean_pointer = 0;
967 priv->tx_pointer = 0;
968 priv->tx_pending = 0;
970 err = ftmac100_start_hw(priv);
974 napi_enable(&priv->napi);
975 netif_start_queue(netdev);
977 ftmac100_enable_all_int(priv);
982 free_irq(priv->irq, netdev);
984 ftmac100_free_buffers(priv);
989 static int ftmac100_stop(struct net_device *netdev)
991 struct ftmac100 *priv = netdev_priv(netdev);
993 ftmac100_disable_all_int(priv);
994 netif_stop_queue(netdev);
995 napi_disable(&priv->napi);
996 ftmac100_stop_hw(priv);
997 free_irq(priv->irq, netdev);
998 ftmac100_free_buffers(priv);
1003 static int ftmac100_hard_start_xmit(struct sk_buff *skb, struct net_device *netdev)
1005 struct ftmac100 *priv = netdev_priv(netdev);
1008 if (unlikely(skb->len > MAX_PKT_SIZE)) {
1009 if (net_ratelimit())
1010 netdev_dbg(netdev, "tx packet too big\n");
1012 netdev->stats.tx_dropped++;
1014 return NETDEV_TX_OK;
1017 map = dma_map_single(priv->dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);
1018 if (unlikely(dma_mapping_error(priv->dev, map))) {
1020 if (net_ratelimit())
1021 netdev_err(netdev, "map socket buffer failed\n");
1023 netdev->stats.tx_dropped++;
1025 return NETDEV_TX_OK;
1028 return ftmac100_xmit(priv, skb, map);
1032 static int ftmac100_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1034 struct ftmac100 *priv = netdev_priv(netdev);
1035 struct mii_ioctl_data *data = if_mii(ifr);
1037 return generic_mii_ioctl(&priv->mii, data, cmd, NULL);
1040 static const struct net_device_ops ftmac100_netdev_ops = {
1041 .ndo_open = ftmac100_open,
1042 .ndo_stop = ftmac100_stop,
1043 .ndo_start_xmit = ftmac100_hard_start_xmit,
1044 .ndo_set_mac_address = eth_mac_addr,
1045 .ndo_validate_addr = eth_validate_addr,
1046 .ndo_do_ioctl = ftmac100_do_ioctl,
1049 /******************************************************************************
1050 * struct platform_driver functions
1051 *****************************************************************************/
1052 static int ftmac100_probe(struct platform_device *pdev)
1054 struct resource *res;
1056 struct net_device *netdev;
1057 struct ftmac100 *priv;
1063 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1067 irq = platform_get_irq(pdev, 0);
1071 /* setup net_device */
1072 netdev = alloc_etherdev(sizeof(*priv));
1075 goto err_alloc_etherdev;
1078 SET_NETDEV_DEV(netdev, &pdev->dev);
1079 SET_ETHTOOL_OPS(netdev, &ftmac100_ethtool_ops);
1080 netdev->netdev_ops = &ftmac100_netdev_ops;
1082 platform_set_drvdata(pdev, netdev);
1084 /* setup private data */
1085 priv = netdev_priv(netdev);
1086 priv->netdev = netdev;
1087 priv->dev = &pdev->dev;
1089 spin_lock_init(&priv->tx_lock);
1091 /* initialize NAPI */
1092 netif_napi_add(netdev, &priv->napi, ftmac100_poll, 64);
1095 priv->res = request_mem_region(res->start, resource_size(res),
1096 dev_name(&pdev->dev));
1098 dev_err(&pdev->dev, "Could not reserve memory region\n");
1103 priv->base = ioremap(res->start, res->end - res->start);
1105 dev_err(&pdev->dev, "Failed to ioremap ethernet registers\n");
1112 /* initialize struct mii_if_info */
1113 priv->mii.phy_id = 0;
1114 priv->mii.phy_id_mask = 0x1f;
1115 priv->mii.reg_num_mask = 0x1f;
1116 priv->mii.dev = netdev;
1117 priv->mii.mdio_read = ftmac100_mdio_read;
1118 priv->mii.mdio_write = ftmac100_mdio_write;
1120 /* register network device */
1121 err = register_netdev(netdev);
1123 dev_err(&pdev->dev, "Failed to register netdev\n");
1124 goto err_register_netdev;
1127 netdev_info(netdev, "irq %d, mapped at %p\n", priv->irq, priv->base);
1129 if (!is_valid_ether_addr(netdev->dev_addr)) {
1130 random_ether_addr(netdev->dev_addr);
1131 netdev_info(netdev, "generated random MAC address %pM\n",
1137 err_register_netdev:
1138 iounmap(priv->base);
1140 release_resource(priv->res);
1142 netif_napi_del(&priv->napi);
1143 platform_set_drvdata(pdev, NULL);
1144 free_netdev(netdev);
1149 static int __exit ftmac100_remove(struct platform_device *pdev)
1151 struct net_device *netdev;
1152 struct ftmac100 *priv;
1154 netdev = platform_get_drvdata(pdev);
1155 priv = netdev_priv(netdev);
1157 unregister_netdev(netdev);
1159 iounmap(priv->base);
1160 release_resource(priv->res);
1162 netif_napi_del(&priv->napi);
1163 platform_set_drvdata(pdev, NULL);
1164 free_netdev(netdev);
1168 static struct platform_driver ftmac100_driver = {
1169 .probe = ftmac100_probe,
1170 .remove = __exit_p(ftmac100_remove),
1173 .owner = THIS_MODULE,
1177 /******************************************************************************
1178 * initialization / finalization
1179 *****************************************************************************/
1180 static int __init ftmac100_init(void)
1182 pr_info("Loading version " DRV_VERSION " ...\n");
1183 return platform_driver_register(&ftmac100_driver);
1186 static void __exit ftmac100_exit(void)
1188 platform_driver_unregister(&ftmac100_driver);
1191 module_init(ftmac100_init);
1192 module_exit(ftmac100_exit);
1194 MODULE_AUTHOR("Po-Yu Chuang <ratbert@faraday-tech.com>");
1195 MODULE_DESCRIPTION("FTMAC100 driver");
1196 MODULE_LICENSE("GPL");