2 * Copyright (C) 2015 Mans Rullgard <mans@mansr.com>
4 * Mostly rewritten, based on driver from Sigma Designs. Original
5 * copyright notice below.
8 * Driver for tangox SMP864x/SMP865x/SMP867x/SMP868x builtin Ethernet Mac.
10 * Copyright (C) 2005 Maxime Bizon <mbizon@freebox.fr>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
23 #include <linux/module.h>
24 #include <linux/etherdevice.h>
25 #include <linux/delay.h>
26 #include <linux/ethtool.h>
27 #include <linux/interrupt.h>
28 #include <linux/platform_device.h>
29 #include <linux/of_device.h>
30 #include <linux/of_mdio.h>
31 #include <linux/of_net.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/phy.h>
34 #include <linux/cache.h>
35 #include <linux/jiffies.h>
37 #include <linux/iopoll.h>
38 #include <asm/barrier.h>
42 static void nb8800_tx_done(struct net_device *dev);
43 static int nb8800_dma_stop(struct net_device *dev);
45 static inline u8 nb8800_readb(struct nb8800_priv *priv, int reg)
47 return readb_relaxed(priv->base + reg);
50 static inline u32 nb8800_readl(struct nb8800_priv *priv, int reg)
52 return readl_relaxed(priv->base + reg);
55 static inline void nb8800_writeb(struct nb8800_priv *priv, int reg, u8 val)
57 writeb_relaxed(val, priv->base + reg);
60 static inline void nb8800_writew(struct nb8800_priv *priv, int reg, u16 val)
62 writew_relaxed(val, priv->base + reg);
65 static inline void nb8800_writel(struct nb8800_priv *priv, int reg, u32 val)
67 writel_relaxed(val, priv->base + reg);
70 static inline void nb8800_maskb(struct nb8800_priv *priv, int reg,
73 u32 old = nb8800_readb(priv, reg);
74 u32 new = (old & ~mask) | (val & mask);
77 nb8800_writeb(priv, reg, new);
80 static inline void nb8800_maskl(struct nb8800_priv *priv, int reg,
83 u32 old = nb8800_readl(priv, reg);
84 u32 new = (old & ~mask) | (val & mask);
87 nb8800_writel(priv, reg, new);
90 static inline void nb8800_modb(struct nb8800_priv *priv, int reg, u8 bits,
93 nb8800_maskb(priv, reg, bits, set ? bits : 0);
96 static inline void nb8800_setb(struct nb8800_priv *priv, int reg, u8 bits)
98 nb8800_maskb(priv, reg, bits, bits);
101 static inline void nb8800_clearb(struct nb8800_priv *priv, int reg, u8 bits)
103 nb8800_maskb(priv, reg, bits, 0);
106 static inline void nb8800_modl(struct nb8800_priv *priv, int reg, u32 bits,
109 nb8800_maskl(priv, reg, bits, set ? bits : 0);
112 static inline void nb8800_setl(struct nb8800_priv *priv, int reg, u32 bits)
114 nb8800_maskl(priv, reg, bits, bits);
117 static inline void nb8800_clearl(struct nb8800_priv *priv, int reg, u32 bits)
119 nb8800_maskl(priv, reg, bits, 0);
122 static int nb8800_mdio_wait(struct mii_bus *bus)
124 struct nb8800_priv *priv = bus->priv;
127 return readl_poll_timeout_atomic(priv->base + NB8800_MDIO_CMD,
128 val, !(val & MDIO_CMD_GO), 1, 1000);
131 static int nb8800_mdio_cmd(struct mii_bus *bus, u32 cmd)
133 struct nb8800_priv *priv = bus->priv;
136 err = nb8800_mdio_wait(bus);
140 nb8800_writel(priv, NB8800_MDIO_CMD, cmd);
142 nb8800_writel(priv, NB8800_MDIO_CMD, cmd | MDIO_CMD_GO);
144 return nb8800_mdio_wait(bus);
147 static int nb8800_mdio_read(struct mii_bus *bus, int phy_id, int reg)
149 struct nb8800_priv *priv = bus->priv;
153 err = nb8800_mdio_cmd(bus, MDIO_CMD_ADDR(phy_id) | MDIO_CMD_REG(reg));
157 val = nb8800_readl(priv, NB8800_MDIO_STS);
158 if (val & MDIO_STS_ERR)
164 static int nb8800_mdio_write(struct mii_bus *bus, int phy_id, int reg, u16 val)
166 u32 cmd = MDIO_CMD_ADDR(phy_id) | MDIO_CMD_REG(reg) |
167 MDIO_CMD_DATA(val) | MDIO_CMD_WR;
169 return nb8800_mdio_cmd(bus, cmd);
172 static void nb8800_mac_tx(struct net_device *dev, bool enable)
174 struct nb8800_priv *priv = netdev_priv(dev);
176 while (nb8800_readl(priv, NB8800_TXC_CR) & TCR_EN)
179 nb8800_modb(priv, NB8800_TX_CTL1, TX_EN, enable);
182 static void nb8800_mac_rx(struct net_device *dev, bool enable)
184 nb8800_modb(netdev_priv(dev), NB8800_RX_CTL, RX_EN, enable);
187 static void nb8800_mac_af(struct net_device *dev, bool enable)
189 nb8800_modb(netdev_priv(dev), NB8800_RX_CTL, RX_AF_EN, enable);
192 static void nb8800_start_rx(struct net_device *dev)
194 nb8800_setl(netdev_priv(dev), NB8800_RXC_CR, RCR_EN);
197 static int nb8800_alloc_rx(struct net_device *dev, unsigned int i, bool napi)
199 struct nb8800_priv *priv = netdev_priv(dev);
200 struct nb8800_rx_desc *rxd = &priv->rx_descs[i];
201 struct nb8800_rx_buf *rxb = &priv->rx_bufs[i];
202 int size = L1_CACHE_ALIGN(RX_BUF_SIZE);
205 unsigned long offset;
208 data = napi ? napi_alloc_frag(size) : netdev_alloc_frag(size);
212 page = virt_to_head_page(data);
213 offset = data - page_address(page);
215 dma_addr = dma_map_page(&dev->dev, page, offset, RX_BUF_SIZE,
218 if (dma_mapping_error(&dev->dev, dma_addr)) {
224 rxb->offset = offset;
225 rxd->desc.s_addr = dma_addr;
230 static void nb8800_receive(struct net_device *dev, unsigned int i,
233 struct nb8800_priv *priv = netdev_priv(dev);
234 struct nb8800_rx_desc *rxd = &priv->rx_descs[i];
235 struct page *page = priv->rx_bufs[i].page;
236 int offset = priv->rx_bufs[i].offset;
237 void *data = page_address(page) + offset;
238 dma_addr_t dma = rxd->desc.s_addr;
243 size = len <= RX_COPYBREAK ? len : RX_COPYHDR;
245 skb = napi_alloc_skb(&priv->napi, size);
247 netdev_err(dev, "rx skb allocation failed\n");
248 dev->stats.rx_dropped++;
252 if (len <= RX_COPYBREAK) {
253 dma_sync_single_for_cpu(&dev->dev, dma, len, DMA_FROM_DEVICE);
254 skb_put_data(skb, data, len);
255 dma_sync_single_for_device(&dev->dev, dma, len,
258 err = nb8800_alloc_rx(dev, i, true);
260 netdev_err(dev, "rx buffer allocation failed\n");
261 dev->stats.rx_dropped++;
266 dma_unmap_page(&dev->dev, dma, RX_BUF_SIZE, DMA_FROM_DEVICE);
267 skb_put_data(skb, data, RX_COPYHDR);
268 skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page,
269 offset + RX_COPYHDR, len - RX_COPYHDR,
273 skb->protocol = eth_type_trans(skb, dev);
274 napi_gro_receive(&priv->napi, skb);
277 static void nb8800_rx_error(struct net_device *dev, u32 report)
279 if (report & RX_LENGTH_ERR)
280 dev->stats.rx_length_errors++;
282 if (report & RX_FCS_ERR)
283 dev->stats.rx_crc_errors++;
285 if (report & RX_FIFO_OVERRUN)
286 dev->stats.rx_fifo_errors++;
288 if (report & RX_ALIGNMENT_ERROR)
289 dev->stats.rx_frame_errors++;
291 dev->stats.rx_errors++;
294 static int nb8800_poll(struct napi_struct *napi, int budget)
296 struct net_device *dev = napi->dev;
297 struct nb8800_priv *priv = netdev_priv(dev);
298 struct nb8800_rx_desc *rxd;
299 unsigned int last = priv->rx_eoc;
309 next = (last + 1) % RX_DESC_COUNT;
311 rxd = &priv->rx_descs[next];
316 len = RX_BYTES_TRANSFERRED(rxd->report);
318 if (IS_RX_ERROR(rxd->report))
319 nb8800_rx_error(dev, rxd->report);
321 nb8800_receive(dev, next, len);
323 dev->stats.rx_packets++;
324 dev->stats.rx_bytes += len;
326 if (rxd->report & RX_MULTICAST_PKT)
327 dev->stats.multicast++;
332 } while (work < budget);
335 priv->rx_descs[last].desc.config |= DESC_EOC;
336 wmb(); /* ensure new EOC is written before clearing old */
337 priv->rx_descs[priv->rx_eoc].desc.config &= ~DESC_EOC;
339 nb8800_start_rx(dev);
343 nb8800_writel(priv, NB8800_RX_ITR, priv->rx_itr_irq);
345 /* If a packet arrived after we last checked but
346 * before writing RX_ITR, the interrupt will be
347 * delayed, so we retrieve it now.
349 if (priv->rx_descs[next].report)
352 napi_complete_done(napi, work);
358 static void __nb8800_tx_dma_start(struct net_device *dev)
360 struct nb8800_priv *priv = netdev_priv(dev);
361 struct nb8800_tx_buf *txb;
364 txb = &priv->tx_bufs[priv->tx_queue];
368 txc_cr = nb8800_readl(priv, NB8800_TXC_CR);
372 nb8800_writel(priv, NB8800_TX_DESC_ADDR, txb->dma_desc);
373 wmb(); /* ensure desc addr is written before starting DMA */
374 nb8800_writel(priv, NB8800_TXC_CR, txc_cr | TCR_EN);
376 priv->tx_queue = (priv->tx_queue + txb->chain_len) % TX_DESC_COUNT;
379 static void nb8800_tx_dma_start(struct net_device *dev)
381 struct nb8800_priv *priv = netdev_priv(dev);
383 spin_lock_irq(&priv->tx_lock);
384 __nb8800_tx_dma_start(dev);
385 spin_unlock_irq(&priv->tx_lock);
388 static void nb8800_tx_dma_start_irq(struct net_device *dev)
390 struct nb8800_priv *priv = netdev_priv(dev);
392 spin_lock(&priv->tx_lock);
393 __nb8800_tx_dma_start(dev);
394 spin_unlock(&priv->tx_lock);
397 static int nb8800_xmit(struct sk_buff *skb, struct net_device *dev)
399 struct nb8800_priv *priv = netdev_priv(dev);
400 struct nb8800_tx_desc *txd;
401 struct nb8800_tx_buf *txb;
402 struct nb8800_dma_desc *desc;
404 unsigned int dma_len;
408 if (atomic_read(&priv->tx_free) <= NB8800_DESC_LOW) {
409 netif_stop_queue(dev);
410 return NETDEV_TX_BUSY;
413 align = (8 - (uintptr_t)skb->data) & 7;
415 dma_len = skb->len - align;
416 dma_addr = dma_map_single(&dev->dev, skb->data + align,
417 dma_len, DMA_TO_DEVICE);
419 if (dma_mapping_error(&dev->dev, dma_addr)) {
420 netdev_err(dev, "tx dma mapping error\n");
422 dev->stats.tx_dropped++;
426 if (atomic_dec_return(&priv->tx_free) <= NB8800_DESC_LOW) {
427 netif_stop_queue(dev);
431 next = priv->tx_next;
432 txb = &priv->tx_bufs[next];
433 txd = &priv->tx_descs[next];
434 desc = &txd->desc[0];
436 next = (next + 1) % TX_DESC_COUNT;
439 memcpy(txd->buf, skb->data, align);
442 txb->dma_desc + offsetof(struct nb8800_tx_desc, buf);
443 desc->n_addr = txb->dma_desc + sizeof(txd->desc[0]);
444 desc->config = DESC_BTS(2) | DESC_DS | align;
449 desc->s_addr = dma_addr;
450 desc->n_addr = priv->tx_bufs[next].dma_desc;
451 desc->config = DESC_BTS(2) | DESC_DS | DESC_EOF | dma_len;
454 desc->config |= DESC_EOC;
457 txb->dma_addr = dma_addr;
458 txb->dma_len = dma_len;
460 if (!priv->tx_chain) {
462 priv->tx_chain = txb;
464 priv->tx_chain->chain_len++;
467 netdev_sent_queue(dev, skb->len);
469 priv->tx_next = next;
471 if (!skb->xmit_more) {
473 priv->tx_chain->ready = true;
474 priv->tx_chain = NULL;
475 nb8800_tx_dma_start(dev);
481 static void nb8800_tx_error(struct net_device *dev, u32 report)
483 if (report & TX_LATE_COLLISION)
484 dev->stats.collisions++;
486 if (report & TX_PACKET_DROPPED)
487 dev->stats.tx_dropped++;
489 if (report & TX_FIFO_UNDERRUN)
490 dev->stats.tx_fifo_errors++;
492 dev->stats.tx_errors++;
495 static void nb8800_tx_done(struct net_device *dev)
497 struct nb8800_priv *priv = netdev_priv(dev);
498 unsigned int limit = priv->tx_next;
499 unsigned int done = priv->tx_done;
500 unsigned int packets = 0;
501 unsigned int len = 0;
503 while (done != limit) {
504 struct nb8800_tx_desc *txd = &priv->tx_descs[done];
505 struct nb8800_tx_buf *txb = &priv->tx_bufs[done];
514 dma_unmap_single(&dev->dev, txb->dma_addr, txb->dma_len,
517 if (IS_TX_ERROR(txd->report)) {
518 nb8800_tx_error(dev, txd->report);
524 dev->stats.tx_packets++;
525 dev->stats.tx_bytes += TX_BYTES_TRANSFERRED(txd->report);
526 dev->stats.collisions += TX_EARLY_COLLISIONS(txd->report);
532 done = (done + 1) % TX_DESC_COUNT;
537 smp_mb__before_atomic();
538 atomic_add(packets, &priv->tx_free);
539 netdev_completed_queue(dev, packets, len);
540 netif_wake_queue(dev);
541 priv->tx_done = done;
545 static irqreturn_t nb8800_irq(int irq, void *dev_id)
547 struct net_device *dev = dev_id;
548 struct nb8800_priv *priv = netdev_priv(dev);
549 irqreturn_t ret = IRQ_NONE;
553 val = nb8800_readl(priv, NB8800_TXC_SR);
555 nb8800_writel(priv, NB8800_TXC_SR, val);
558 nb8800_tx_dma_start_irq(dev);
561 napi_schedule_irqoff(&priv->napi);
563 if (unlikely(val & TSR_DE))
564 netdev_err(dev, "TX DMA error\n");
566 /* should never happen with automatic status retrieval */
567 if (unlikely(val & TSR_TO))
568 netdev_err(dev, "TX Status FIFO overflow\n");
574 val = nb8800_readl(priv, NB8800_RXC_SR);
576 nb8800_writel(priv, NB8800_RXC_SR, val);
578 if (likely(val & (RSR_RI | RSR_DI))) {
579 nb8800_writel(priv, NB8800_RX_ITR, priv->rx_itr_poll);
580 napi_schedule_irqoff(&priv->napi);
583 if (unlikely(val & RSR_DE))
584 netdev_err(dev, "RX DMA error\n");
586 /* should never happen with automatic status retrieval */
587 if (unlikely(val & RSR_RO))
588 netdev_err(dev, "RX Status FIFO overflow\n");
596 static void nb8800_mac_config(struct net_device *dev)
598 struct nb8800_priv *priv = netdev_priv(dev);
599 bool gigabit = priv->speed == SPEED_1000;
600 u32 mac_mode_mask = RGMII_MODE | HALF_DUPLEX | GMAC_MODE;
607 mac_mode |= HALF_DUPLEX;
610 if (phy_interface_is_rgmii(dev->phydev))
611 mac_mode |= RGMII_MODE;
613 mac_mode |= GMAC_MODE;
616 /* Should be 512 but register is only 8 bits */
623 ict = DIV_ROUND_UP(phy_clk, clk_get_rate(priv->clk));
625 nb8800_writeb(priv, NB8800_IC_THRESHOLD, ict);
626 nb8800_writeb(priv, NB8800_SLOT_TIME, slot_time);
627 nb8800_maskb(priv, NB8800_MAC_MODE, mac_mode_mask, mac_mode);
630 static void nb8800_pause_config(struct net_device *dev)
632 struct nb8800_priv *priv = netdev_priv(dev);
633 struct phy_device *phydev = dev->phydev;
636 if (priv->pause_aneg) {
637 if (!phydev || !phydev->link)
640 priv->pause_rx = phydev->pause;
641 priv->pause_tx = phydev->pause ^ phydev->asym_pause;
644 nb8800_modb(priv, NB8800_RX_CTL, RX_PAUSE_EN, priv->pause_rx);
646 rxcr = nb8800_readl(priv, NB8800_RXC_CR);
647 if (!!(rxcr & RCR_FL) == priv->pause_tx)
650 if (netif_running(dev)) {
651 napi_disable(&priv->napi);
652 netif_tx_lock_bh(dev);
653 nb8800_dma_stop(dev);
654 nb8800_modl(priv, NB8800_RXC_CR, RCR_FL, priv->pause_tx);
655 nb8800_start_rx(dev);
656 netif_tx_unlock_bh(dev);
657 napi_enable(&priv->napi);
659 nb8800_modl(priv, NB8800_RXC_CR, RCR_FL, priv->pause_tx);
663 static void nb8800_link_reconfigure(struct net_device *dev)
665 struct nb8800_priv *priv = netdev_priv(dev);
666 struct phy_device *phydev = dev->phydev;
670 if (phydev->speed != priv->speed) {
671 priv->speed = phydev->speed;
675 if (phydev->duplex != priv->duplex) {
676 priv->duplex = phydev->duplex;
681 nb8800_mac_config(dev);
683 nb8800_pause_config(dev);
686 if (phydev->link != priv->link) {
687 priv->link = phydev->link;
692 phy_print_status(phydev);
695 static void nb8800_update_mac_addr(struct net_device *dev)
697 struct nb8800_priv *priv = netdev_priv(dev);
700 for (i = 0; i < ETH_ALEN; i++)
701 nb8800_writeb(priv, NB8800_SRC_ADDR(i), dev->dev_addr[i]);
703 for (i = 0; i < ETH_ALEN; i++)
704 nb8800_writeb(priv, NB8800_UC_ADDR(i), dev->dev_addr[i]);
707 static int nb8800_set_mac_address(struct net_device *dev, void *addr)
709 struct sockaddr *sock = addr;
711 if (netif_running(dev))
714 ether_addr_copy(dev->dev_addr, sock->sa_data);
715 nb8800_update_mac_addr(dev);
720 static void nb8800_mc_init(struct net_device *dev, int val)
722 struct nb8800_priv *priv = netdev_priv(dev);
724 nb8800_writeb(priv, NB8800_MC_INIT, val);
725 readb_poll_timeout_atomic(priv->base + NB8800_MC_INIT, val, !val,
729 static void nb8800_set_rx_mode(struct net_device *dev)
731 struct nb8800_priv *priv = netdev_priv(dev);
732 struct netdev_hw_addr *ha;
735 if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
736 nb8800_mac_af(dev, false);
740 nb8800_mac_af(dev, true);
741 nb8800_mc_init(dev, 0);
743 netdev_for_each_mc_addr(ha, dev) {
744 for (i = 0; i < ETH_ALEN; i++)
745 nb8800_writeb(priv, NB8800_MC_ADDR(i), ha->addr[i]);
747 nb8800_mc_init(dev, 0xff);
751 #define RX_DESC_SIZE (RX_DESC_COUNT * sizeof(struct nb8800_rx_desc))
752 #define TX_DESC_SIZE (TX_DESC_COUNT * sizeof(struct nb8800_tx_desc))
754 static void nb8800_dma_free(struct net_device *dev)
756 struct nb8800_priv *priv = netdev_priv(dev);
760 for (i = 0; i < RX_DESC_COUNT; i++)
761 if (priv->rx_bufs[i].page)
762 put_page(priv->rx_bufs[i].page);
764 kfree(priv->rx_bufs);
765 priv->rx_bufs = NULL;
769 for (i = 0; i < TX_DESC_COUNT; i++)
770 kfree_skb(priv->tx_bufs[i].skb);
772 kfree(priv->tx_bufs);
773 priv->tx_bufs = NULL;
776 if (priv->rx_descs) {
777 dma_free_coherent(dev->dev.parent, RX_DESC_SIZE, priv->rx_descs,
779 priv->rx_descs = NULL;
782 if (priv->tx_descs) {
783 dma_free_coherent(dev->dev.parent, TX_DESC_SIZE, priv->tx_descs,
785 priv->tx_descs = NULL;
789 static void nb8800_dma_reset(struct net_device *dev)
791 struct nb8800_priv *priv = netdev_priv(dev);
792 struct nb8800_rx_desc *rxd;
793 struct nb8800_tx_desc *txd;
796 for (i = 0; i < RX_DESC_COUNT; i++) {
797 dma_addr_t rx_dma = priv->rx_desc_dma + i * sizeof(*rxd);
799 rxd = &priv->rx_descs[i];
800 rxd->desc.n_addr = rx_dma + sizeof(*rxd);
802 rx_dma + offsetof(struct nb8800_rx_desc, report);
803 rxd->desc.config = priv->rx_dma_config;
807 rxd->desc.n_addr = priv->rx_desc_dma;
808 rxd->desc.config |= DESC_EOC;
810 priv->rx_eoc = RX_DESC_COUNT - 1;
812 for (i = 0; i < TX_DESC_COUNT; i++) {
813 struct nb8800_tx_buf *txb = &priv->tx_bufs[i];
814 dma_addr_t r_dma = txb->dma_desc +
815 offsetof(struct nb8800_tx_desc, report);
817 txd = &priv->tx_descs[i];
818 txd->desc[0].r_addr = r_dma;
819 txd->desc[1].r_addr = r_dma;
826 atomic_set(&priv->tx_free, TX_DESC_COUNT);
828 nb8800_writel(priv, NB8800_RX_DESC_ADDR, priv->rx_desc_dma);
830 wmb(); /* ensure all setup is written before starting */
833 static int nb8800_dma_init(struct net_device *dev)
835 struct nb8800_priv *priv = netdev_priv(dev);
836 unsigned int n_rx = RX_DESC_COUNT;
837 unsigned int n_tx = TX_DESC_COUNT;
841 priv->rx_descs = dma_alloc_coherent(dev->dev.parent, RX_DESC_SIZE,
842 &priv->rx_desc_dma, GFP_KERNEL);
846 priv->rx_bufs = kcalloc(n_rx, sizeof(*priv->rx_bufs), GFP_KERNEL);
850 for (i = 0; i < n_rx; i++) {
851 err = nb8800_alloc_rx(dev, i, false);
856 priv->tx_descs = dma_alloc_coherent(dev->dev.parent, TX_DESC_SIZE,
857 &priv->tx_desc_dma, GFP_KERNEL);
861 priv->tx_bufs = kcalloc(n_tx, sizeof(*priv->tx_bufs), GFP_KERNEL);
865 for (i = 0; i < n_tx; i++)
866 priv->tx_bufs[i].dma_desc =
867 priv->tx_desc_dma + i * sizeof(struct nb8800_tx_desc);
869 nb8800_dma_reset(dev);
874 nb8800_dma_free(dev);
879 static int nb8800_dma_stop(struct net_device *dev)
881 struct nb8800_priv *priv = netdev_priv(dev);
882 struct nb8800_tx_buf *txb = &priv->tx_bufs[0];
883 struct nb8800_tx_desc *txd = &priv->tx_descs[0];
890 /* wait for tx to finish */
891 err = readl_poll_timeout_atomic(priv->base + NB8800_TXC_CR, txcr,
893 priv->tx_done == priv->tx_next,
898 /* The rx DMA only stops if it reaches the end of chain.
899 * To make this happen, we set the EOC flag on all rx
900 * descriptors, put the device in loopback mode, and send
901 * a few dummy frames. The interrupt handler will ignore
902 * these since NAPI is disabled and no real frames are in
906 for (i = 0; i < RX_DESC_COUNT; i++)
907 priv->rx_descs[i].desc.config |= DESC_EOC;
909 txd->desc[0].s_addr =
910 txb->dma_desc + offsetof(struct nb8800_tx_desc, buf);
911 txd->desc[0].config = DESC_BTS(2) | DESC_DS | DESC_EOF | DESC_EOC | 8;
912 memset(txd->buf, 0, sizeof(txd->buf));
914 nb8800_mac_af(dev, false);
915 nb8800_setb(priv, NB8800_MAC_MODE, LOOPBACK_EN);
918 nb8800_writel(priv, NB8800_TX_DESC_ADDR, txb->dma_desc);
920 nb8800_writel(priv, NB8800_TXC_CR, txcr | TCR_EN);
922 err = readl_poll_timeout_atomic(priv->base + NB8800_RXC_CR,
923 rxcr, !(rxcr & RCR_EN),
925 } while (err && --retry);
927 nb8800_mac_af(dev, true);
928 nb8800_clearb(priv, NB8800_MAC_MODE, LOOPBACK_EN);
929 nb8800_dma_reset(dev);
931 return retry ? 0 : -ETIMEDOUT;
934 static void nb8800_pause_adv(struct net_device *dev)
936 struct nb8800_priv *priv = netdev_priv(dev);
937 struct phy_device *phydev = dev->phydev;
944 adv |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
946 adv ^= ADVERTISED_Asym_Pause;
948 phydev->supported |= adv;
949 phydev->advertising |= adv;
952 static int nb8800_open(struct net_device *dev)
954 struct nb8800_priv *priv = netdev_priv(dev);
955 struct phy_device *phydev;
958 /* clear any pending interrupts */
959 nb8800_writel(priv, NB8800_RXC_SR, 0xf);
960 nb8800_writel(priv, NB8800_TXC_SR, 0xf);
962 err = nb8800_dma_init(dev);
966 err = request_irq(dev->irq, nb8800_irq, 0, dev_name(&dev->dev), dev);
970 nb8800_mac_rx(dev, true);
971 nb8800_mac_tx(dev, true);
973 phydev = of_phy_connect(dev, priv->phy_node,
974 nb8800_link_reconfigure, 0,
981 nb8800_pause_adv(dev);
983 netdev_reset_queue(dev);
984 napi_enable(&priv->napi);
985 netif_start_queue(dev);
987 nb8800_start_rx(dev);
993 free_irq(dev->irq, dev);
995 nb8800_dma_free(dev);
1000 static int nb8800_stop(struct net_device *dev)
1002 struct nb8800_priv *priv = netdev_priv(dev);
1003 struct phy_device *phydev = dev->phydev;
1007 netif_stop_queue(dev);
1008 napi_disable(&priv->napi);
1010 nb8800_dma_stop(dev);
1011 nb8800_mac_rx(dev, false);
1012 nb8800_mac_tx(dev, false);
1014 phy_disconnect(phydev);
1016 free_irq(dev->irq, dev);
1018 nb8800_dma_free(dev);
1023 static int nb8800_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1025 return phy_mii_ioctl(dev->phydev, rq, cmd);
1028 static const struct net_device_ops nb8800_netdev_ops = {
1029 .ndo_open = nb8800_open,
1030 .ndo_stop = nb8800_stop,
1031 .ndo_start_xmit = nb8800_xmit,
1032 .ndo_set_mac_address = nb8800_set_mac_address,
1033 .ndo_set_rx_mode = nb8800_set_rx_mode,
1034 .ndo_do_ioctl = nb8800_ioctl,
1035 .ndo_validate_addr = eth_validate_addr,
1038 static void nb8800_get_pauseparam(struct net_device *dev,
1039 struct ethtool_pauseparam *pp)
1041 struct nb8800_priv *priv = netdev_priv(dev);
1043 pp->autoneg = priv->pause_aneg;
1044 pp->rx_pause = priv->pause_rx;
1045 pp->tx_pause = priv->pause_tx;
1048 static int nb8800_set_pauseparam(struct net_device *dev,
1049 struct ethtool_pauseparam *pp)
1051 struct nb8800_priv *priv = netdev_priv(dev);
1052 struct phy_device *phydev = dev->phydev;
1054 priv->pause_aneg = pp->autoneg;
1055 priv->pause_rx = pp->rx_pause;
1056 priv->pause_tx = pp->tx_pause;
1058 nb8800_pause_adv(dev);
1060 if (!priv->pause_aneg)
1061 nb8800_pause_config(dev);
1063 phy_start_aneg(phydev);
1068 static const char nb8800_stats_names[][ETH_GSTRING_LEN] = {
1071 "rx_undersize_frames",
1072 "rx_fragment_frames",
1073 "rx_64_byte_frames",
1074 "rx_127_byte_frames",
1075 "rx_255_byte_frames",
1076 "rx_511_byte_frames",
1077 "rx_1023_byte_frames",
1078 "rx_max_size_frames",
1079 "rx_oversize_frames",
1080 "rx_bad_fcs_frames",
1081 "rx_broadcast_frames",
1082 "rx_multicast_frames",
1083 "rx_control_frames",
1085 "rx_unsup_control_frames",
1086 "rx_align_error_frames",
1087 "rx_overrun_frames",
1094 "tx_64_byte_frames",
1095 "tx_127_byte_frames",
1096 "tx_255_byte_frames",
1097 "tx_511_byte_frames",
1098 "tx_1023_byte_frames",
1099 "tx_max_size_frames",
1100 "tx_oversize_frames",
1101 "tx_broadcast_frames",
1102 "tx_multicast_frames",
1103 "tx_control_frames",
1105 "tx_underrun_frames",
1106 "tx_single_collision_frames",
1107 "tx_multi_collision_frames",
1108 "tx_deferred_collision_frames",
1109 "tx_late_collision_frames",
1110 "tx_excessive_collision_frames",
1116 #define NB8800_NUM_STATS ARRAY_SIZE(nb8800_stats_names)
1118 static int nb8800_get_sset_count(struct net_device *dev, int sset)
1120 if (sset == ETH_SS_STATS)
1121 return NB8800_NUM_STATS;
1126 static void nb8800_get_strings(struct net_device *dev, u32 sset, u8 *buf)
1128 if (sset == ETH_SS_STATS)
1129 memcpy(buf, &nb8800_stats_names, sizeof(nb8800_stats_names));
1132 static u32 nb8800_read_stat(struct net_device *dev, int index)
1134 struct nb8800_priv *priv = netdev_priv(dev);
1136 nb8800_writeb(priv, NB8800_STAT_INDEX, index);
1138 return nb8800_readl(priv, NB8800_STAT_DATA);
1141 static void nb8800_get_ethtool_stats(struct net_device *dev,
1142 struct ethtool_stats *estats, u64 *st)
1147 for (i = 0; i < NB8800_NUM_STATS / 2; i++) {
1148 rx = nb8800_read_stat(dev, i);
1149 tx = nb8800_read_stat(dev, i | 0x80);
1151 st[i + NB8800_NUM_STATS / 2] = tx;
1155 static const struct ethtool_ops nb8800_ethtool_ops = {
1156 .nway_reset = phy_ethtool_nway_reset,
1157 .get_link = ethtool_op_get_link,
1158 .get_pauseparam = nb8800_get_pauseparam,
1159 .set_pauseparam = nb8800_set_pauseparam,
1160 .get_sset_count = nb8800_get_sset_count,
1161 .get_strings = nb8800_get_strings,
1162 .get_ethtool_stats = nb8800_get_ethtool_stats,
1163 .get_link_ksettings = phy_ethtool_get_link_ksettings,
1164 .set_link_ksettings = phy_ethtool_set_link_ksettings,
1167 static int nb8800_hw_init(struct net_device *dev)
1169 struct nb8800_priv *priv = netdev_priv(dev);
1172 val = TX_RETRY_EN | TX_PAD_EN | TX_APPEND_FCS;
1173 nb8800_writeb(priv, NB8800_TX_CTL1, val);
1175 /* Collision retry count */
1176 nb8800_writeb(priv, NB8800_TX_CTL2, 5);
1178 val = RX_PAD_STRIP | RX_AF_EN;
1179 nb8800_writeb(priv, NB8800_RX_CTL, val);
1181 /* Chosen by fair dice roll */
1182 nb8800_writeb(priv, NB8800_RANDOM_SEED, 4);
1184 /* TX cycles per deferral period */
1185 nb8800_writeb(priv, NB8800_TX_SDP, 12);
1187 /* The following three threshold values have been
1188 * experimentally determined for good results.
1191 /* RX/TX FIFO threshold for partial empty (64-bit entries) */
1192 nb8800_writeb(priv, NB8800_PE_THRESHOLD, 0);
1194 /* RX/TX FIFO threshold for partial full (64-bit entries) */
1195 nb8800_writeb(priv, NB8800_PF_THRESHOLD, 255);
1197 /* Buffer size for transmit (64-bit entries) */
1198 nb8800_writeb(priv, NB8800_TX_BUFSIZE, 64);
1200 /* Configure tx DMA */
1202 val = nb8800_readl(priv, NB8800_TXC_CR);
1203 val &= TCR_LE; /* keep endian setting */
1204 val |= TCR_DM; /* DMA descriptor mode */
1205 val |= TCR_RS; /* automatically store tx status */
1206 val |= TCR_DIE; /* interrupt on DMA chain completion */
1207 val |= TCR_TFI(7); /* interrupt after 7 frames transmitted */
1208 val |= TCR_BTS(2); /* 32-byte bus transaction size */
1209 nb8800_writel(priv, NB8800_TXC_CR, val);
1211 /* TX complete interrupt after 10 ms or 7 frames (see above) */
1212 val = clk_get_rate(priv->clk) / 100;
1213 nb8800_writel(priv, NB8800_TX_ITR, val);
1215 /* Configure rx DMA */
1217 val = nb8800_readl(priv, NB8800_RXC_CR);
1218 val &= RCR_LE; /* keep endian setting */
1219 val |= RCR_DM; /* DMA descriptor mode */
1220 val |= RCR_RS; /* automatically store rx status */
1221 val |= RCR_DIE; /* interrupt at end of DMA chain */
1222 val |= RCR_RFI(7); /* interrupt after 7 frames received */
1223 val |= RCR_BTS(2); /* 32-byte bus transaction size */
1224 nb8800_writel(priv, NB8800_RXC_CR, val);
1226 /* The rx interrupt can fire before the DMA has completed
1227 * unless a small delay is added. 50 us is hopefully enough.
1229 priv->rx_itr_irq = clk_get_rate(priv->clk) / 20000;
1231 /* In NAPI poll mode we want to disable interrupts, but the
1232 * hardware does not permit this. Delay 10 ms instead.
1234 priv->rx_itr_poll = clk_get_rate(priv->clk) / 100;
1236 nb8800_writel(priv, NB8800_RX_ITR, priv->rx_itr_irq);
1238 priv->rx_dma_config = RX_BUF_SIZE | DESC_BTS(2) | DESC_DS | DESC_EOF;
1240 /* Flow control settings */
1242 /* Pause time of 0.1 ms */
1244 nb8800_writeb(priv, NB8800_PQ1, val >> 8);
1245 nb8800_writeb(priv, NB8800_PQ2, val & 0xff);
1247 /* Auto-negotiate by default */
1248 priv->pause_aneg = true;
1249 priv->pause_rx = true;
1250 priv->pause_tx = true;
1252 nb8800_mc_init(dev, 0);
1257 static int nb8800_tangox_init(struct net_device *dev)
1259 struct nb8800_priv *priv = netdev_priv(dev);
1260 u32 pad_mode = PAD_MODE_MII;
1262 switch (priv->phy_mode) {
1263 case PHY_INTERFACE_MODE_MII:
1264 case PHY_INTERFACE_MODE_GMII:
1265 pad_mode = PAD_MODE_MII;
1268 case PHY_INTERFACE_MODE_RGMII:
1269 case PHY_INTERFACE_MODE_RGMII_ID:
1270 case PHY_INTERFACE_MODE_RGMII_RXID:
1271 case PHY_INTERFACE_MODE_RGMII_TXID:
1272 pad_mode = PAD_MODE_RGMII;
1276 dev_err(dev->dev.parent, "unsupported phy mode %s\n",
1277 phy_modes(priv->phy_mode));
1281 nb8800_writeb(priv, NB8800_TANGOX_PAD_MODE, pad_mode);
1286 static int nb8800_tangox_reset(struct net_device *dev)
1288 struct nb8800_priv *priv = netdev_priv(dev);
1291 nb8800_writeb(priv, NB8800_TANGOX_RESET, 0);
1292 usleep_range(1000, 10000);
1293 nb8800_writeb(priv, NB8800_TANGOX_RESET, 1);
1295 wmb(); /* ensure reset is cleared before proceeding */
1297 clk_div = DIV_ROUND_UP(clk_get_rate(priv->clk), 2 * MAX_MDC_CLOCK);
1298 nb8800_writew(priv, NB8800_TANGOX_MDIO_CLKDIV, clk_div);
1303 static const struct nb8800_ops nb8800_tangox_ops = {
1304 .init = nb8800_tangox_init,
1305 .reset = nb8800_tangox_reset,
1308 static int nb8800_tango4_init(struct net_device *dev)
1310 struct nb8800_priv *priv = netdev_priv(dev);
1313 err = nb8800_tangox_init(dev);
1317 /* On tango4 interrupt on DMA completion per frame works and gives
1318 * better performance despite generating more rx interrupts.
1321 /* Disable unnecessary interrupt on rx completion */
1322 nb8800_clearl(priv, NB8800_RXC_CR, RCR_RFI(7));
1324 /* Request interrupt on descriptor DMA completion */
1325 priv->rx_dma_config |= DESC_ID;
1330 static const struct nb8800_ops nb8800_tango4_ops = {
1331 .init = nb8800_tango4_init,
1332 .reset = nb8800_tangox_reset,
1335 static const struct of_device_id nb8800_dt_ids[] = {
1337 .compatible = "aurora,nb8800",
1340 .compatible = "sigma,smp8642-ethernet",
1341 .data = &nb8800_tangox_ops,
1344 .compatible = "sigma,smp8734-ethernet",
1345 .data = &nb8800_tango4_ops,
1349 MODULE_DEVICE_TABLE(of, nb8800_dt_ids);
1351 static int nb8800_probe(struct platform_device *pdev)
1353 const struct of_device_id *match;
1354 const struct nb8800_ops *ops = NULL;
1355 struct nb8800_priv *priv;
1356 struct resource *res;
1357 struct net_device *dev;
1358 struct mii_bus *bus;
1359 const unsigned char *mac;
1364 match = of_match_device(nb8800_dt_ids, &pdev->dev);
1368 irq = platform_get_irq(pdev, 0);
1370 dev_err(&pdev->dev, "No IRQ\n");
1374 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1375 base = devm_ioremap_resource(&pdev->dev, res);
1377 return PTR_ERR(base);
1379 dev_dbg(&pdev->dev, "AU-NB8800 Ethernet at %pa\n", &res->start);
1381 dev = alloc_etherdev(sizeof(*priv));
1385 platform_set_drvdata(pdev, dev);
1386 SET_NETDEV_DEV(dev, &pdev->dev);
1388 priv = netdev_priv(dev);
1391 priv->phy_mode = of_get_phy_mode(pdev->dev.of_node);
1392 if (priv->phy_mode < 0)
1393 priv->phy_mode = PHY_INTERFACE_MODE_RGMII;
1395 priv->clk = devm_clk_get(&pdev->dev, NULL);
1396 if (IS_ERR(priv->clk)) {
1397 dev_err(&pdev->dev, "failed to get clock\n");
1398 ret = PTR_ERR(priv->clk);
1402 ret = clk_prepare_enable(priv->clk);
1406 spin_lock_init(&priv->tx_lock);
1408 if (ops && ops->reset) {
1409 ret = ops->reset(dev);
1411 goto err_disable_clk;
1414 bus = devm_mdiobus_alloc(&pdev->dev);
1417 goto err_disable_clk;
1420 bus->name = "nb8800-mii";
1421 bus->read = nb8800_mdio_read;
1422 bus->write = nb8800_mdio_write;
1423 bus->parent = &pdev->dev;
1424 snprintf(bus->id, MII_BUS_ID_SIZE, "%lx.nb8800-mii",
1425 (unsigned long)res->start);
1428 ret = of_mdiobus_register(bus, pdev->dev.of_node);
1430 dev_err(&pdev->dev, "failed to register MII bus\n");
1431 goto err_disable_clk;
1434 if (of_phy_is_fixed_link(pdev->dev.of_node)) {
1435 ret = of_phy_register_fixed_link(pdev->dev.of_node);
1437 dev_err(&pdev->dev, "bad fixed-link spec\n");
1440 priv->phy_node = of_node_get(pdev->dev.of_node);
1443 if (!priv->phy_node)
1444 priv->phy_node = of_parse_phandle(pdev->dev.of_node,
1447 if (!priv->phy_node) {
1448 dev_err(&pdev->dev, "no PHY specified\n");
1453 priv->mii_bus = bus;
1455 ret = nb8800_hw_init(dev);
1457 goto err_deregister_fixed_link;
1459 if (ops && ops->init) {
1460 ret = ops->init(dev);
1462 goto err_deregister_fixed_link;
1465 dev->netdev_ops = &nb8800_netdev_ops;
1466 dev->ethtool_ops = &nb8800_ethtool_ops;
1467 dev->flags |= IFF_MULTICAST;
1470 mac = of_get_mac_address(pdev->dev.of_node);
1472 ether_addr_copy(dev->dev_addr, mac);
1474 if (!is_valid_ether_addr(dev->dev_addr))
1475 eth_hw_addr_random(dev);
1477 nb8800_update_mac_addr(dev);
1479 netif_carrier_off(dev);
1481 ret = register_netdev(dev);
1483 netdev_err(dev, "failed to register netdev\n");
1487 netif_napi_add(dev, &priv->napi, nb8800_poll, NAPI_POLL_WEIGHT);
1489 netdev_info(dev, "MAC address %pM\n", dev->dev_addr);
1494 nb8800_dma_free(dev);
1495 err_deregister_fixed_link:
1496 if (of_phy_is_fixed_link(pdev->dev.of_node))
1497 of_phy_deregister_fixed_link(pdev->dev.of_node);
1499 of_node_put(priv->phy_node);
1500 mdiobus_unregister(bus);
1502 clk_disable_unprepare(priv->clk);
1509 static int nb8800_remove(struct platform_device *pdev)
1511 struct net_device *ndev = platform_get_drvdata(pdev);
1512 struct nb8800_priv *priv = netdev_priv(ndev);
1514 unregister_netdev(ndev);
1515 if (of_phy_is_fixed_link(pdev->dev.of_node))
1516 of_phy_deregister_fixed_link(pdev->dev.of_node);
1517 of_node_put(priv->phy_node);
1519 mdiobus_unregister(priv->mii_bus);
1521 clk_disable_unprepare(priv->clk);
1523 nb8800_dma_free(ndev);
1529 static struct platform_driver nb8800_driver = {
1532 .of_match_table = nb8800_dt_ids,
1534 .probe = nb8800_probe,
1535 .remove = nb8800_remove,
1538 module_platform_driver(nb8800_driver);
1540 MODULE_DESCRIPTION("Aurora AU-NB8800 Ethernet driver");
1541 MODULE_AUTHOR("Mans Rullgard <mans@mansr.com>");
1542 MODULE_LICENSE("GPL");