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,
84 struct ftmac100_rxdes *rxdes, gfp_t gfp);
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)
97 #define INT_MASK_ALL_DISABLED 0
99 static void ftmac100_enable_all_int(struct ftmac100 *priv)
101 iowrite32(INT_MASK_ALL_ENABLED, priv->base + FTMAC100_OFFSET_IMR);
104 static void ftmac100_disable_all_int(struct ftmac100 *priv)
106 iowrite32(INT_MASK_ALL_DISABLED, priv->base + FTMAC100_OFFSET_IMR);
109 static void ftmac100_set_rx_ring_base(struct ftmac100 *priv, dma_addr_t addr)
111 iowrite32(addr, priv->base + FTMAC100_OFFSET_RXR_BADR);
114 static void ftmac100_set_tx_ring_base(struct ftmac100 *priv, dma_addr_t addr)
116 iowrite32(addr, priv->base + FTMAC100_OFFSET_TXR_BADR);
119 static void ftmac100_txdma_start_polling(struct ftmac100 *priv)
121 iowrite32(1, priv->base + FTMAC100_OFFSET_TXPD);
124 static int ftmac100_reset(struct ftmac100 *priv)
126 struct net_device *netdev = priv->netdev;
129 /* NOTE: reset clears all registers */
130 iowrite32(FTMAC100_MACCR_SW_RST, priv->base + FTMAC100_OFFSET_MACCR);
132 for (i = 0; i < 5; i++) {
135 maccr = ioread32(priv->base + FTMAC100_OFFSET_MACCR);
136 if (!(maccr & FTMAC100_MACCR_SW_RST)) {
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.
149 netdev_err(netdev, "software reset failed\n");
153 static void ftmac100_set_mac(struct ftmac100 *priv, const unsigned char *mac)
155 unsigned int maddr = mac[0] << 8 | mac[1];
156 unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
158 iowrite32(maddr, priv->base + FTMAC100_OFFSET_MAC_MADR);
159 iowrite32(laddr, priv->base + FTMAC100_OFFSET_MAC_LADR);
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)
171 static int ftmac100_start_hw(struct ftmac100 *priv)
173 struct net_device *netdev = priv->netdev;
175 if (ftmac100_reset(priv))
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));
186 iowrite32(FTMAC100_APTC_RXPOLL_CNT(1), priv->base + FTMAC100_OFFSET_APTC);
188 ftmac100_set_mac(priv, netdev->dev_addr);
190 iowrite32(MACCR_ENABLE_ALL, priv->base + FTMAC100_OFFSET_MACCR);
194 static void ftmac100_stop_hw(struct ftmac100 *priv)
196 iowrite32(0, priv->base + FTMAC100_OFFSET_MACCR);
199 /******************************************************************************
200 * internal functions (receive descriptor)
201 *****************************************************************************/
202 static bool ftmac100_rxdes_first_segment(struct ftmac100_rxdes *rxdes)
204 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_FRS);
207 static bool ftmac100_rxdes_last_segment(struct ftmac100_rxdes *rxdes)
209 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_LRS);
212 static bool ftmac100_rxdes_owned_by_dma(struct ftmac100_rxdes *rxdes)
214 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RXDMA_OWN);
217 static void ftmac100_rxdes_set_dma_own(struct ftmac100_rxdes *rxdes)
219 /* clear status bits */
220 rxdes->rxdes0 = cpu_to_le32(FTMAC100_RXDES0_RXDMA_OWN);
223 static bool ftmac100_rxdes_rx_error(struct ftmac100_rxdes *rxdes)
225 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RX_ERR);
228 static bool ftmac100_rxdes_crc_error(struct ftmac100_rxdes *rxdes)
230 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_CRC_ERR);
233 static bool ftmac100_rxdes_frame_too_long(struct ftmac100_rxdes *rxdes)
235 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_FTL);
238 static bool ftmac100_rxdes_runt(struct ftmac100_rxdes *rxdes)
240 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RUNT);
243 static bool ftmac100_rxdes_odd_nibble(struct ftmac100_rxdes *rxdes)
245 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_RX_ODD_NB);
248 static unsigned int ftmac100_rxdes_frame_length(struct ftmac100_rxdes *rxdes)
250 return le32_to_cpu(rxdes->rxdes0) & FTMAC100_RXDES0_RFL;
253 static bool ftmac100_rxdes_multicast(struct ftmac100_rxdes *rxdes)
255 return rxdes->rxdes0 & cpu_to_le32(FTMAC100_RXDES0_MULTICAST);
258 static void ftmac100_rxdes_set_buffer_size(struct ftmac100_rxdes *rxdes,
261 rxdes->rxdes1 &= cpu_to_le32(FTMAC100_RXDES1_EDORR);
262 rxdes->rxdes1 |= cpu_to_le32(FTMAC100_RXDES1_RXBUF_SIZE(size));
265 static void ftmac100_rxdes_set_end_of_ring(struct ftmac100_rxdes *rxdes)
267 rxdes->rxdes1 |= cpu_to_le32(FTMAC100_RXDES1_EDORR);
270 static void ftmac100_rxdes_set_dma_addr(struct ftmac100_rxdes *rxdes,
273 rxdes->rxdes2 = cpu_to_le32(addr);
276 static dma_addr_t ftmac100_rxdes_get_dma_addr(struct ftmac100_rxdes *rxdes)
278 return le32_to_cpu(rxdes->rxdes2);
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().
285 static void ftmac100_rxdes_set_page(struct ftmac100_rxdes *rxdes, struct page *page)
287 rxdes->rxdes3 = (unsigned int)page;
290 static struct page *ftmac100_rxdes_get_page(struct ftmac100_rxdes *rxdes)
292 return (struct page *)rxdes->rxdes3;
295 /******************************************************************************
296 * internal functions (receive)
297 *****************************************************************************/
298 static int ftmac100_next_rx_pointer(int pointer)
300 return (pointer + 1) & (RX_QUEUE_ENTRIES - 1);
303 static void ftmac100_rx_pointer_advance(struct ftmac100 *priv)
305 priv->rx_pointer = ftmac100_next_rx_pointer(priv->rx_pointer);
308 static struct ftmac100_rxdes *ftmac100_current_rxdes(struct ftmac100 *priv)
310 return &priv->descs->rxdes[priv->rx_pointer];
313 static struct ftmac100_rxdes *
314 ftmac100_rx_locate_first_segment(struct ftmac100 *priv)
316 struct ftmac100_rxdes *rxdes = ftmac100_current_rxdes(priv);
318 while (!ftmac100_rxdes_owned_by_dma(rxdes)) {
319 if (ftmac100_rxdes_first_segment(rxdes))
322 ftmac100_rxdes_set_dma_own(rxdes);
323 ftmac100_rx_pointer_advance(priv);
324 rxdes = ftmac100_current_rxdes(priv);
330 static bool ftmac100_rx_packet_error(struct ftmac100 *priv,
331 struct ftmac100_rxdes *rxdes)
333 struct net_device *netdev = priv->netdev;
336 if (unlikely(ftmac100_rxdes_rx_error(rxdes))) {
338 netdev_info(netdev, "rx err\n");
340 netdev->stats.rx_errors++;
344 if (unlikely(ftmac100_rxdes_crc_error(rxdes))) {
346 netdev_info(netdev, "rx crc err\n");
348 netdev->stats.rx_crc_errors++;
352 if (unlikely(ftmac100_rxdes_frame_too_long(rxdes))) {
354 netdev_info(netdev, "rx frame too long\n");
356 netdev->stats.rx_length_errors++;
358 } else if (unlikely(ftmac100_rxdes_runt(rxdes))) {
360 netdev_info(netdev, "rx runt\n");
362 netdev->stats.rx_length_errors++;
364 } else if (unlikely(ftmac100_rxdes_odd_nibble(rxdes))) {
366 netdev_info(netdev, "rx odd nibble\n");
368 netdev->stats.rx_length_errors++;
375 static void ftmac100_rx_drop_packet(struct ftmac100 *priv)
377 struct net_device *netdev = priv->netdev;
378 struct ftmac100_rxdes *rxdes = ftmac100_current_rxdes(priv);
382 netdev_dbg(netdev, "drop packet %p\n", rxdes);
385 if (ftmac100_rxdes_last_segment(rxdes))
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));
393 netdev->stats.rx_dropped++;
396 static bool ftmac100_rx_packet(struct ftmac100 *priv, int *processed)
398 struct net_device *netdev = priv->netdev;
399 struct ftmac100_rxdes *rxdes;
405 rxdes = ftmac100_rx_locate_first_segment(priv);
409 if (unlikely(ftmac100_rx_packet_error(priv, rxdes))) {
410 ftmac100_rx_drop_packet(priv);
415 * It is impossible to get multi-segment packets
416 * because we always provide big enough receive buffers.
418 if (unlikely(!ftmac100_rxdes_last_segment(rxdes)))
421 /* start processing */
422 skb = netdev_alloc_skb_ip_align(netdev, 128);
423 if (unlikely(!skb)) {
425 netdev_err(netdev, "rx skb alloc failed\n");
427 ftmac100_rx_drop_packet(priv);
431 if (unlikely(ftmac100_rxdes_multicast(rxdes)))
432 netdev->stats.multicast++;
434 map = ftmac100_rxdes_get_dma_addr(rxdes);
435 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
437 length = ftmac100_rxdes_frame_length(rxdes);
438 page = ftmac100_rxdes_get_page(rxdes);
439 skb_fill_page_desc(skb, 0, page, 0, length);
441 skb->data_len += length;
443 /* page might be freed in __pskb_pull_tail() */
445 skb->truesize += PAGE_SIZE;
446 __pskb_pull_tail(skb, min(length, 64));
448 ftmac100_alloc_rx_page(priv, rxdes, GFP_ATOMIC);
450 ftmac100_rx_pointer_advance(priv);
452 skb->protocol = eth_type_trans(skb, netdev);
454 netdev->stats.rx_packets++;
455 netdev->stats.rx_bytes += skb->len;
457 /* push packet to protocol stack */
458 netif_receive_skb(skb);
464 /******************************************************************************
465 * internal functions (transmit descriptor)
466 *****************************************************************************/
467 static void ftmac100_txdes_reset(struct ftmac100_txdes *txdes)
469 /* clear all except end of ring bit */
471 txdes->txdes1 &= cpu_to_le32(FTMAC100_TXDES1_EDOTR);
476 static bool ftmac100_txdes_owned_by_dma(struct ftmac100_txdes *txdes)
478 return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXDMA_OWN);
481 static void ftmac100_txdes_set_dma_own(struct ftmac100_txdes *txdes)
484 * Make sure dma own bit will not be set before any other
488 txdes->txdes0 |= cpu_to_le32(FTMAC100_TXDES0_TXDMA_OWN);
491 static bool ftmac100_txdes_excessive_collision(struct ftmac100_txdes *txdes)
493 return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXPKT_EXSCOL);
496 static bool ftmac100_txdes_late_collision(struct ftmac100_txdes *txdes)
498 return txdes->txdes0 & cpu_to_le32(FTMAC100_TXDES0_TXPKT_LATECOL);
501 static void ftmac100_txdes_set_end_of_ring(struct ftmac100_txdes *txdes)
503 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_EDOTR);
506 static void ftmac100_txdes_set_first_segment(struct ftmac100_txdes *txdes)
508 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_FTS);
511 static void ftmac100_txdes_set_last_segment(struct ftmac100_txdes *txdes)
513 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_LTS);
516 static void ftmac100_txdes_set_txint(struct ftmac100_txdes *txdes)
518 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_TXIC);
521 static void ftmac100_txdes_set_buffer_size(struct ftmac100_txdes *txdes,
524 txdes->txdes1 |= cpu_to_le32(FTMAC100_TXDES1_TXBUF_SIZE(len));
527 static void ftmac100_txdes_set_dma_addr(struct ftmac100_txdes *txdes,
530 txdes->txdes2 = cpu_to_le32(addr);
533 static dma_addr_t ftmac100_txdes_get_dma_addr(struct ftmac100_txdes *txdes)
535 return le32_to_cpu(txdes->txdes2);
539 * txdes3 is not used by hardware. We use it to keep track of socket buffer.
540 * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
542 static void ftmac100_txdes_set_skb(struct ftmac100_txdes *txdes, struct sk_buff *skb)
544 txdes->txdes3 = (unsigned int)skb;
547 static struct sk_buff *ftmac100_txdes_get_skb(struct ftmac100_txdes *txdes)
549 return (struct sk_buff *)txdes->txdes3;
552 /******************************************************************************
553 * internal functions (transmit)
554 *****************************************************************************/
555 static int ftmac100_next_tx_pointer(int pointer)
557 return (pointer + 1) & (TX_QUEUE_ENTRIES - 1);
560 static void ftmac100_tx_pointer_advance(struct ftmac100 *priv)
562 priv->tx_pointer = ftmac100_next_tx_pointer(priv->tx_pointer);
565 static void ftmac100_tx_clean_pointer_advance(struct ftmac100 *priv)
567 priv->tx_clean_pointer = ftmac100_next_tx_pointer(priv->tx_clean_pointer);
570 static struct ftmac100_txdes *ftmac100_current_txdes(struct ftmac100 *priv)
572 return &priv->descs->txdes[priv->tx_pointer];
575 static struct ftmac100_txdes *ftmac100_current_clean_txdes(struct ftmac100 *priv)
577 return &priv->descs->txdes[priv->tx_clean_pointer];
580 static bool ftmac100_tx_complete_packet(struct ftmac100 *priv)
582 struct net_device *netdev = priv->netdev;
583 struct ftmac100_txdes *txdes;
587 if (priv->tx_pending == 0)
590 txdes = ftmac100_current_clean_txdes(priv);
592 if (ftmac100_txdes_owned_by_dma(txdes))
595 skb = ftmac100_txdes_get_skb(txdes);
596 map = ftmac100_txdes_get_dma_addr(txdes);
598 if (unlikely(ftmac100_txdes_excessive_collision(txdes) ||
599 ftmac100_txdes_late_collision(txdes))) {
601 * packet transmitted to ethernet lost due to late collision
602 * or excessive collision
604 netdev->stats.tx_aborted_errors++;
606 netdev->stats.tx_packets++;
607 netdev->stats.tx_bytes += skb->len;
610 dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
613 ftmac100_txdes_reset(txdes);
615 ftmac100_tx_clean_pointer_advance(priv);
617 spin_lock(&priv->tx_lock);
619 spin_unlock(&priv->tx_lock);
620 netif_wake_queue(netdev);
625 static void ftmac100_tx_complete(struct ftmac100 *priv)
627 while (ftmac100_tx_complete_packet(priv))
631 static int ftmac100_xmit(struct ftmac100 *priv, struct sk_buff *skb,
634 struct net_device *netdev = priv->netdev;
635 struct ftmac100_txdes *txdes;
636 unsigned int len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
638 txdes = ftmac100_current_txdes(priv);
639 ftmac100_tx_pointer_advance(priv);
641 /* setup TX descriptor */
642 ftmac100_txdes_set_skb(txdes, skb);
643 ftmac100_txdes_set_dma_addr(txdes, map);
645 ftmac100_txdes_set_first_segment(txdes);
646 ftmac100_txdes_set_last_segment(txdes);
647 ftmac100_txdes_set_txint(txdes);
648 ftmac100_txdes_set_buffer_size(txdes, len);
650 spin_lock(&priv->tx_lock);
652 if (priv->tx_pending == TX_QUEUE_ENTRIES)
653 netif_stop_queue(netdev);
656 ftmac100_txdes_set_dma_own(txdes);
657 spin_unlock(&priv->tx_lock);
659 ftmac100_txdma_start_polling(priv);
663 /******************************************************************************
664 * internal functions (buffer)
665 *****************************************************************************/
666 static int ftmac100_alloc_rx_page(struct ftmac100 *priv,
667 struct ftmac100_rxdes *rxdes, gfp_t gfp)
669 struct net_device *netdev = priv->netdev;
673 page = alloc_page(gfp);
676 netdev_err(netdev, "failed to allocate rx page\n");
680 map = dma_map_page(priv->dev, page, 0, RX_BUF_SIZE, DMA_FROM_DEVICE);
681 if (unlikely(dma_mapping_error(priv->dev, map))) {
683 netdev_err(netdev, "failed to map rx page\n");
688 ftmac100_rxdes_set_page(rxdes, page);
689 ftmac100_rxdes_set_dma_addr(rxdes, map);
690 ftmac100_rxdes_set_buffer_size(rxdes, RX_BUF_SIZE);
691 ftmac100_rxdes_set_dma_own(rxdes);
695 static void ftmac100_free_buffers(struct ftmac100 *priv)
699 for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
700 struct ftmac100_rxdes *rxdes = &priv->descs->rxdes[i];
701 struct page *page = ftmac100_rxdes_get_page(rxdes);
702 dma_addr_t map = ftmac100_rxdes_get_dma_addr(rxdes);
707 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
711 for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
712 struct ftmac100_txdes *txdes = &priv->descs->txdes[i];
713 struct sk_buff *skb = ftmac100_txdes_get_skb(txdes);
714 dma_addr_t map = ftmac100_txdes_get_dma_addr(txdes);
719 dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
723 dma_free_coherent(priv->dev, sizeof(struct ftmac100_descs),
724 priv->descs, priv->descs_dma_addr);
727 static int ftmac100_alloc_buffers(struct ftmac100 *priv)
731 priv->descs = dma_alloc_coherent(priv->dev, sizeof(struct ftmac100_descs),
732 &priv->descs_dma_addr, GFP_KERNEL);
736 memset(priv->descs, 0, sizeof(struct ftmac100_descs));
738 /* initialize RX ring */
739 ftmac100_rxdes_set_end_of_ring(&priv->descs->rxdes[RX_QUEUE_ENTRIES - 1]);
741 for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
742 struct ftmac100_rxdes *rxdes = &priv->descs->rxdes[i];
744 if (ftmac100_alloc_rx_page(priv, rxdes, GFP_KERNEL))
748 /* initialize TX ring */
749 ftmac100_txdes_set_end_of_ring(&priv->descs->txdes[TX_QUEUE_ENTRIES - 1]);
753 ftmac100_free_buffers(priv);
757 /******************************************************************************
758 * struct mii_if_info functions
759 *****************************************************************************/
760 static int ftmac100_mdio_read(struct net_device *netdev, int phy_id, int reg)
762 struct ftmac100 *priv = netdev_priv(netdev);
766 phycr = FTMAC100_PHYCR_PHYAD(phy_id) |
767 FTMAC100_PHYCR_REGAD(reg) |
768 FTMAC100_PHYCR_MIIRD;
770 iowrite32(phycr, priv->base + FTMAC100_OFFSET_PHYCR);
772 for (i = 0; i < 10; i++) {
773 phycr = ioread32(priv->base + FTMAC100_OFFSET_PHYCR);
775 if ((phycr & FTMAC100_PHYCR_MIIRD) == 0)
776 return phycr & FTMAC100_PHYCR_MIIRDATA;
781 netdev_err(netdev, "mdio read timed out\n");
785 static void ftmac100_mdio_write(struct net_device *netdev, int phy_id, int reg,
788 struct ftmac100 *priv = netdev_priv(netdev);
792 phycr = FTMAC100_PHYCR_PHYAD(phy_id) |
793 FTMAC100_PHYCR_REGAD(reg) |
794 FTMAC100_PHYCR_MIIWR;
796 data = FTMAC100_PHYWDATA_MIIWDATA(data);
798 iowrite32(data, priv->base + FTMAC100_OFFSET_PHYWDATA);
799 iowrite32(phycr, priv->base + FTMAC100_OFFSET_PHYCR);
801 for (i = 0; i < 10; i++) {
802 phycr = ioread32(priv->base + FTMAC100_OFFSET_PHYCR);
804 if ((phycr & FTMAC100_PHYCR_MIIWR) == 0)
810 netdev_err(netdev, "mdio write timed out\n");
813 /******************************************************************************
814 * struct ethtool_ops functions
815 *****************************************************************************/
816 static void ftmac100_get_drvinfo(struct net_device *netdev,
817 struct ethtool_drvinfo *info)
819 strcpy(info->driver, DRV_NAME);
820 strcpy(info->version, DRV_VERSION);
821 strcpy(info->bus_info, dev_name(&netdev->dev));
824 static int ftmac100_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
826 struct ftmac100 *priv = netdev_priv(netdev);
827 return mii_ethtool_gset(&priv->mii, cmd);
830 static int ftmac100_set_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
832 struct ftmac100 *priv = netdev_priv(netdev);
833 return mii_ethtool_sset(&priv->mii, cmd);
836 static int ftmac100_nway_reset(struct net_device *netdev)
838 struct ftmac100 *priv = netdev_priv(netdev);
839 return mii_nway_restart(&priv->mii);
842 static u32 ftmac100_get_link(struct net_device *netdev)
844 struct ftmac100 *priv = netdev_priv(netdev);
845 return mii_link_ok(&priv->mii);
848 static const struct ethtool_ops ftmac100_ethtool_ops = {
849 .set_settings = ftmac100_set_settings,
850 .get_settings = ftmac100_get_settings,
851 .get_drvinfo = ftmac100_get_drvinfo,
852 .nway_reset = ftmac100_nway_reset,
853 .get_link = ftmac100_get_link,
856 /******************************************************************************
858 *****************************************************************************/
859 static irqreturn_t ftmac100_interrupt(int irq, void *dev_id)
861 struct net_device *netdev = dev_id;
862 struct ftmac100 *priv = netdev_priv(netdev);
864 if (likely(netif_running(netdev))) {
865 /* Disable interrupts for polling */
866 ftmac100_disable_all_int(priv);
867 napi_schedule(&priv->napi);
873 /******************************************************************************
874 * struct napi_struct functions
875 *****************************************************************************/
876 static int ftmac100_poll(struct napi_struct *napi, int budget)
878 struct ftmac100 *priv = container_of(napi, struct ftmac100, napi);
879 struct net_device *netdev = priv->netdev;
881 bool completed = true;
884 status = ioread32(priv->base + FTMAC100_OFFSET_ISR);
886 if (status & (FTMAC100_INT_RPKT_FINISH | FTMAC100_INT_NORXBUF)) {
888 * FTMAC100_INT_RPKT_FINISH:
889 * RX DMA has received packets into RX buffer successfully
891 * FTMAC100_INT_NORXBUF:
892 * RX buffer unavailable
897 retry = ftmac100_rx_packet(priv, &rx);
898 } while (retry && rx < budget);
900 if (retry && rx == budget)
904 if (status & (FTMAC100_INT_XPKT_OK | FTMAC100_INT_XPKT_LOST)) {
906 * FTMAC100_INT_XPKT_OK:
907 * packet transmitted to ethernet successfully
909 * FTMAC100_INT_XPKT_LOST:
910 * packet transmitted to ethernet lost due to late
911 * collision or excessive collision
913 ftmac100_tx_complete(priv);
916 if (status & (FTMAC100_INT_NORXBUF | FTMAC100_INT_RPKT_LOST |
917 FTMAC100_INT_AHB_ERR | FTMAC100_INT_PHYSTS_CHG)) {
919 netdev_info(netdev, "[ISR] = 0x%x: %s%s%s%s\n", status,
920 status & FTMAC100_INT_NORXBUF ? "NORXBUF " : "",
921 status & FTMAC100_INT_RPKT_LOST ? "RPKT_LOST " : "",
922 status & FTMAC100_INT_AHB_ERR ? "AHB_ERR " : "",
923 status & FTMAC100_INT_PHYSTS_CHG ? "PHYSTS_CHG" : "");
925 if (status & FTMAC100_INT_NORXBUF) {
926 /* RX buffer unavailable */
927 netdev->stats.rx_over_errors++;
930 if (status & FTMAC100_INT_RPKT_LOST) {
931 /* received packet lost due to RX FIFO full */
932 netdev->stats.rx_fifo_errors++;
935 if (status & FTMAC100_INT_PHYSTS_CHG) {
936 /* PHY link status change */
937 mii_check_link(&priv->mii);
944 ftmac100_enable_all_int(priv);
950 /******************************************************************************
951 * struct net_device_ops functions
952 *****************************************************************************/
953 static int ftmac100_open(struct net_device *netdev)
955 struct ftmac100 *priv = netdev_priv(netdev);
958 err = ftmac100_alloc_buffers(priv);
960 netdev_err(netdev, "failed to allocate buffers\n");
964 err = request_irq(priv->irq, ftmac100_interrupt, 0, netdev->name, netdev);
966 netdev_err(netdev, "failed to request irq %d\n", priv->irq);
970 priv->rx_pointer = 0;
971 priv->tx_clean_pointer = 0;
972 priv->tx_pointer = 0;
973 priv->tx_pending = 0;
975 err = ftmac100_start_hw(priv);
979 napi_enable(&priv->napi);
980 netif_start_queue(netdev);
982 ftmac100_enable_all_int(priv);
987 free_irq(priv->irq, netdev);
989 ftmac100_free_buffers(priv);
994 static int ftmac100_stop(struct net_device *netdev)
996 struct ftmac100 *priv = netdev_priv(netdev);
998 ftmac100_disable_all_int(priv);
999 netif_stop_queue(netdev);
1000 napi_disable(&priv->napi);
1001 ftmac100_stop_hw(priv);
1002 free_irq(priv->irq, netdev);
1003 ftmac100_free_buffers(priv);
1008 static int ftmac100_hard_start_xmit(struct sk_buff *skb, struct net_device *netdev)
1010 struct ftmac100 *priv = netdev_priv(netdev);
1013 if (unlikely(skb->len > MAX_PKT_SIZE)) {
1014 if (net_ratelimit())
1015 netdev_dbg(netdev, "tx packet too big\n");
1017 netdev->stats.tx_dropped++;
1019 return NETDEV_TX_OK;
1022 map = dma_map_single(priv->dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);
1023 if (unlikely(dma_mapping_error(priv->dev, map))) {
1025 if (net_ratelimit())
1026 netdev_err(netdev, "map socket buffer failed\n");
1028 netdev->stats.tx_dropped++;
1030 return NETDEV_TX_OK;
1033 return ftmac100_xmit(priv, skb, map);
1037 static int ftmac100_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1039 struct ftmac100 *priv = netdev_priv(netdev);
1040 struct mii_ioctl_data *data = if_mii(ifr);
1042 return generic_mii_ioctl(&priv->mii, data, cmd, NULL);
1045 static const struct net_device_ops ftmac100_netdev_ops = {
1046 .ndo_open = ftmac100_open,
1047 .ndo_stop = ftmac100_stop,
1048 .ndo_start_xmit = ftmac100_hard_start_xmit,
1049 .ndo_set_mac_address = eth_mac_addr,
1050 .ndo_validate_addr = eth_validate_addr,
1051 .ndo_do_ioctl = ftmac100_do_ioctl,
1054 /******************************************************************************
1055 * struct platform_driver functions
1056 *****************************************************************************/
1057 static int ftmac100_probe(struct platform_device *pdev)
1059 struct resource *res;
1061 struct net_device *netdev;
1062 struct ftmac100 *priv;
1068 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1072 irq = platform_get_irq(pdev, 0);
1076 /* setup net_device */
1077 netdev = alloc_etherdev(sizeof(*priv));
1080 goto err_alloc_etherdev;
1083 SET_NETDEV_DEV(netdev, &pdev->dev);
1084 SET_ETHTOOL_OPS(netdev, &ftmac100_ethtool_ops);
1085 netdev->netdev_ops = &ftmac100_netdev_ops;
1087 platform_set_drvdata(pdev, netdev);
1089 /* setup private data */
1090 priv = netdev_priv(netdev);
1091 priv->netdev = netdev;
1092 priv->dev = &pdev->dev;
1094 spin_lock_init(&priv->tx_lock);
1096 /* initialize NAPI */
1097 netif_napi_add(netdev, &priv->napi, ftmac100_poll, 64);
1100 priv->res = request_mem_region(res->start, resource_size(res),
1101 dev_name(&pdev->dev));
1103 dev_err(&pdev->dev, "Could not reserve memory region\n");
1108 priv->base = ioremap(res->start, resource_size(res));
1110 dev_err(&pdev->dev, "Failed to ioremap ethernet registers\n");
1117 /* initialize struct mii_if_info */
1118 priv->mii.phy_id = 0;
1119 priv->mii.phy_id_mask = 0x1f;
1120 priv->mii.reg_num_mask = 0x1f;
1121 priv->mii.dev = netdev;
1122 priv->mii.mdio_read = ftmac100_mdio_read;
1123 priv->mii.mdio_write = ftmac100_mdio_write;
1125 /* register network device */
1126 err = register_netdev(netdev);
1128 dev_err(&pdev->dev, "Failed to register netdev\n");
1129 goto err_register_netdev;
1132 netdev_info(netdev, "irq %d, mapped at %p\n", priv->irq, priv->base);
1134 if (!is_valid_ether_addr(netdev->dev_addr)) {
1135 random_ether_addr(netdev->dev_addr);
1136 netdev_info(netdev, "generated random MAC address %pM\n",
1142 err_register_netdev:
1143 iounmap(priv->base);
1145 release_resource(priv->res);
1147 netif_napi_del(&priv->napi);
1148 platform_set_drvdata(pdev, NULL);
1149 free_netdev(netdev);
1154 static int __exit ftmac100_remove(struct platform_device *pdev)
1156 struct net_device *netdev;
1157 struct ftmac100 *priv;
1159 netdev = platform_get_drvdata(pdev);
1160 priv = netdev_priv(netdev);
1162 unregister_netdev(netdev);
1164 iounmap(priv->base);
1165 release_resource(priv->res);
1167 netif_napi_del(&priv->napi);
1168 platform_set_drvdata(pdev, NULL);
1169 free_netdev(netdev);
1173 static struct platform_driver ftmac100_driver = {
1174 .probe = ftmac100_probe,
1175 .remove = __exit_p(ftmac100_remove),
1178 .owner = THIS_MODULE,
1182 /******************************************************************************
1183 * initialization / finalization
1184 *****************************************************************************/
1185 static int __init ftmac100_init(void)
1187 pr_info("Loading version " DRV_VERSION " ...\n");
1188 return platform_driver_register(&ftmac100_driver);
1191 static void __exit ftmac100_exit(void)
1193 platform_driver_unregister(&ftmac100_driver);
1196 module_init(ftmac100_init);
1197 module_exit(ftmac100_exit);
1199 MODULE_AUTHOR("Po-Yu Chuang <ratbert@faraday-tech.com>");
1200 MODULE_DESCRIPTION("FTMAC100 driver");
1201 MODULE_LICENSE("GPL");