26 #include <linux/module.h>
30 #include <linux/netdevice.h>
32 #include <linux/ethtool.h>
36 #include <linux/mii.h>
39 #include <linux/slab.h>
40 #include <asm/cacheflush.h>
41 #include <asm/byteorder.h>
44 #include <asm/idprom.h>
49 #define GRETH_DEF_MSG_ENABLE \
58 static int greth_debug = -1;
60 MODULE_PARM_DESC(greth_debug,
"GRETH bitmapped debugging message enable value");
67 static int greth_edcl = 1;
69 MODULE_PARM_DESC(greth_edcl,
"GRETH EDCL usage indicator. Set to 1 if EDCL is used.");
85 #define GRETH_REGLOAD(a) (be32_to_cpu(__raw_readl(&(a))))
86 #define GRETH_REGSAVE(a, v) (__raw_writel(cpu_to_be32(v), &(a)))
87 #define GRETH_REGORIN(a, v) (GRETH_REGSAVE(a, (GRETH_REGLOAD(a) | (v))))
88 #define GRETH_REGANDIN(a, v) (GRETH_REGSAVE(a, (GRETH_REGLOAD(a) & (v))))
90 #define NEXT_TX(N) (((N) + 1) & GRETH_TXBD_NUM_MASK)
91 #define SKIP_TX(N, C) (((N) + C) & GRETH_TXBD_NUM_MASK)
92 #define NEXT_RX(N) (((N) + 1) & GRETH_RXBD_NUM_MASK)
94 static void greth_print_rx_packet(
void *
addr,
int len)
100 static void greth_print_tx_packet(
struct sk_buff *
skb)
105 if (skb_shinfo(skb)->nr_frags == 0)
108 length = skb_headlen(skb);
111 skb->
data, length,
true);
113 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
116 skb_frag_address(&skb_shinfo(skb)->frags[i]),
117 skb_shinfo(skb)->frags[i].
size,
true);
121 static inline void greth_enable_tx(
struct greth_private *greth)
127 static inline void greth_disable_tx(
struct greth_private *greth)
132 static inline void greth_enable_rx(
struct greth_private *greth)
138 static inline void greth_disable_rx(
struct greth_private *greth)
143 static inline void greth_enable_irqs(
struct greth_private *greth)
148 static inline void greth_disable_irqs(
struct greth_private *greth)
153 static inline void greth_write_bd(
u32 *bd,
u32 val)
158 static inline u32 greth_read_bd(
u32 *bd)
176 greth_read_bd(&rx_bdp->
addr),
186 int nr_frags = skb_shinfo(skb)->nr_frags;
191 greth_read_bd(&tx_bdp->
addr),
195 for (i = 0; i < nr_frags; i++) {
200 greth_read_bd(&tx_bdp->
addr),
216 greth_read_bd(&rx_bdp->
addr),
223 greth_read_bd(&tx_bdp->
addr),
247 dev_err(greth->
dev,
"Error allocating DMA ring.\n");
258 dev_err(greth->
dev,
"Could not create initial DMA mapping\n");
262 greth_write_bd(&rx_bd[i].
addr, dma_addr);
275 dev_err(greth->
dev,
"Error allocating DMA ring.\n");
286 dev_err(greth->
dev,
"Could not create initial DMA mapping\n");
289 greth_write_bd(&rx_bd[i].
addr, dma_addr);
298 dev_err(greth->
dev,
"Error allocating DMA ring.\n");
309 dev_err(greth->
dev,
"Could not create initial DMA mapping\n");
312 greth_write_bd(&tx_bd[i].
addr, dma_addr);
313 greth_write_bd(&tx_bd[i].
stat, 0);
316 greth_write_bd(&rx_bd[GRETH_RXBD_NUM - 1].
stat,
332 greth_clean_rings(greth);
341 err = greth_init_rings(greth);
344 dev_err(&dev->
dev,
"Could not allocate memory for DMA rings\n");
348 err =
request_irq(greth->
irq, greth_interrupt, 0,
"eth", (
void *) dev);
351 dev_err(&dev->
dev,
"Could not allocate interrupt %d\n", dev->
irq);
352 greth_clean_rings(greth);
358 netif_start_queue(dev);
362 napi_enable(&greth->
napi);
364 greth_enable_irqs(greth);
365 greth_enable_tx(greth);
366 greth_enable_rx(greth);
371 static int greth_close(
struct net_device *dev)
375 napi_disable(&greth->
napi);
377 greth_disable_irqs(greth);
378 greth_disable_tx(greth);
379 greth_disable_rx(greth);
381 netif_stop_queue(dev);
385 greth_clean_rings(greth);
400 greth_clean_tx(greth->
netdev);
408 netif_stop_queue(dev);
409 spin_unlock_irqrestore(&greth->
devlock, flags);
414 greth_print_tx_packet(skb);
418 dev->
stats.tx_errors++;
423 dma_addr = greth_read_bd(&bdp->
addr);
441 greth_write_bd(&bdp->
stat, status);
443 greth_enable_tx(greth);
444 spin_unlock_irqrestore(&greth->
devlock, flags);
461 nr_frags = skb_shinfo(skb)->nr_frags;
464 greth_clean_tx_gbit(dev);
466 if (greth->
tx_free < nr_frags + 1) {
472 netif_stop_queue(dev);
473 spin_unlock_irqrestore(&greth->
devlock, flags);
479 greth_print_tx_packet(skb);
482 dev->
stats.tx_errors++;
501 greth_write_bd(&bdp->
stat, status);
507 greth_write_bd(&bdp->
addr, dma_addr);
512 for (i = 0; i < nr_frags; i++) {
527 if (i < nr_frags - 1)
532 greth_write_bd(&bdp->
stat, status);
534 dma_addr = skb_frag_dma_map(greth->
dev, frag, 0, skb_frag_size(frag),
540 greth_write_bd(&bdp->
addr, dma_addr);
551 greth->
tx_free -= nr_frags + 1;
556 greth_enable_tx(greth);
557 spin_unlock_irqrestore(&greth->
devlock, flags);
563 for (i = 0; greth->
tx_next + i != curr_tx; i++) {
566 greth_read_bd(&bdp->
addr),
569 greth_write_bd(&bdp->
stat, 0);
573 dev_warn(greth->
dev,
"Could not create TX DMA mapping\n");
586 greth = netdev_priv(dev);
605 greth_disable_irqs(greth);
606 napi_schedule(&greth->
napi);
615 static void greth_clean_tx(
struct net_device *dev)
621 greth = netdev_priv(dev);
627 stat = greth_read_bd(&bdp->
stat);
632 if (greth->
tx_free == GRETH_TXBD_NUM)
637 dev->
stats.tx_errors++;
639 dev->
stats.tx_aborted_errors++;
641 dev->
stats.tx_fifo_errors++;
643 dev->
stats.tx_packets++;
650 netif_wake_queue(dev);
655 static inline void greth_update_tx_stats(
struct net_device *dev,
u32 stat)
658 if (
unlikely(stat & GRETH_TXBD_STATUS)) {
659 dev->
stats.tx_errors++;
661 dev->
stats.tx_aborted_errors++;
663 dev->
stats.tx_fifo_errors++;
665 dev->
stats.tx_aborted_errors++;
667 dev->
stats.tx_packets++;
670 static void greth_clean_tx_gbit(
struct net_device *dev)
673 struct greth_bd *bdp, *bdp_last_frag;
678 greth = netdev_priv(dev);
680 while (greth->
tx_free < GRETH_TXBD_NUM) {
684 nr_frags = skb_shinfo(skb)->nr_frags;
691 stat = greth_read_bd(&bdp_last_frag->
stat);
693 if (stat & GRETH_BD_EN)
698 greth_update_tx_stats(dev, stat);
706 greth_read_bd(&bdp->
addr),
710 for (i = 0; i < nr_frags; i++) {
715 greth_read_bd(&bdp->
addr),
726 netif_wake_queue(dev);
739 greth = netdev_priv(dev);
746 status = greth_read_bd(&bdp->
stat);
748 if (
unlikely(status & GRETH_BD_EN)) {
752 dma_addr = greth_read_bd(&bdp->
addr);
758 dev->
stats.rx_length_errors++;
762 dev->
stats.rx_frame_errors++;
766 dev->
stats.rx_crc_errors++;
771 dev->
stats.rx_errors++;
782 dev_warn(&dev->
dev,
"low on memory - " "packet dropped\n");
784 dev->
stats.rx_dropped++;
801 dev->
stats.rx_packets++;
812 greth_write_bd(&bdp->
stat, status);
817 greth_enable_rx(greth);
818 spin_unlock_irqrestore(&greth->
devlock, flags);
826 static inline int hw_checksummed(
u32 status)
844 static int greth_rx_gbit(
struct net_device *dev,
int limit)
854 greth = netdev_priv(dev);
862 status = greth_read_bd(&bdp->
stat);
865 if (status & GRETH_BD_EN)
869 if (
unlikely(status & GRETH_RXBD_STATUS)) {
871 if (status & GRETH_RXBD_ERR_FT) {
872 dev->
stats.rx_length_errors++;
876 dev->
stats.rx_frame_errors++;
879 dev->
stats.rx_crc_errors++;
899 greth_read_bd(&bdp->
addr),
911 skb_checksum_none_assert(skb);
914 dev->
stats.rx_packets++;
919 greth_write_bd(&bdp->
addr, dma_addr);
922 dev_warn(greth->
dev,
"Could not create DMA mapping, dropping packet\n");
923 dev_kfree_skb(newskb);
925 dev->
stats.rx_dropped++;
929 dev->
stats.rx_dropped++;
938 dev_warn(greth->
dev,
"Could not allocate SKB, dropping packet\n");
940 dev->
stats.rx_dropped++;
949 greth_write_bd(&bdp->
stat, status);
951 greth_enable_rx(greth);
952 spin_unlock_irqrestore(&greth->
devlock, flags);
969 if (netif_queue_stopped(greth->
netdev)) {
971 greth_clean_tx_gbit(greth->
netdev);
973 greth_clean_tx(greth->
netdev);
977 work_done += greth_rx_gbit(greth->
netdev, budget - work_done);
979 work_done += greth_rx(greth->
netdev, budget - work_done);
982 if (work_done < budget) {
987 if (netif_queue_stopped(greth->
netdev)) {
999 spin_unlock_irqrestore(&greth->
devlock, flags);
1000 goto restart_txrx_poll;
1003 spin_unlock_irqrestore(&greth->
devlock, flags);
1010 static int greth_set_mac_add(
struct net_device *dev,
void *
p)
1016 greth = netdev_priv(dev);
1019 if (!is_valid_ether_addr(addr->
sa_data))
1030 static u32 greth_hash_get_index(
__u8 *addr)
1035 static void greth_set_hash_filter(
struct net_device *dev)
1043 mc_filter[0] = mc_filter[1] = 0;
1046 bitnr = greth_hash_get_index(ha->
addr);
1047 mc_filter[bitnr >> 5] |= 1 << (bitnr & 31);
1054 static void greth_set_multicast_list(
struct net_device *dev)
1082 greth_set_hash_filter(dev);
1121 static int greth_get_regs_len(
struct net_device *dev)
1145 for (i = 0; i <
sizeof(
struct greth_regs) /
sizeof(
u32); i++)
1146 buff[i] = greth_read_bd(&greth_regs[i]);
1149 static const struct ethtool_ops greth_ethtool_ops = {
1150 .get_msglevel = greth_get_msglevel,
1151 .set_msglevel = greth_set_msglevel,
1152 .get_settings = greth_get_settings,
1153 .set_settings = greth_set_settings,
1154 .get_drvinfo = greth_get_drvinfo,
1155 .get_regs_len = greth_get_regs_len,
1156 .get_regs = greth_get_regs,
1161 .ndo_open = greth_open,
1162 .ndo_stop = greth_close,
1163 .ndo_start_xmit = greth_start_xmit,
1164 .ndo_set_mac_address = greth_set_mac_add,
1168 static inline int wait_for_mdio(
struct greth_private *greth)
1178 static int greth_mdio_read(
struct mii_bus *
bus,
int phy,
int reg)
1183 if (!wait_for_mdio(greth))
1186 GRETH_REGSAVE(greth->
regs->mdio, ((phy & 0x1F) << 11) | ((reg & 0x1F) << 6) | 2);
1188 if (!wait_for_mdio(greth))
1200 static int greth_mdio_write(
struct mii_bus *bus,
int phy,
int reg,
u16 val)
1204 if (!wait_for_mdio(greth))
1208 ((val & 0xFFFF) << 16) | ((phy & 0x1F) << 11) | ((reg & 0x1F) << 6) | 1);
1210 if (!wait_for_mdio(greth))
1216 static int greth_mdio_reset(
struct mii_bus *bus)
1221 static void greth_link_change(
struct net_device *dev)
1225 unsigned long flags;
1226 int status_change = 0;
1253 if (!phydev->
link) {
1262 spin_unlock_irqrestore(&greth->
devlock, flags);
1264 if (status_change) {
1274 static int greth_mdio_probe(
struct net_device *dev)
1295 dev_err(&dev->
dev,
"could not attach to PHY\n");
1314 static inline int phy_aneg_done(
struct phy_device *phydev)
1326 unsigned long timeout;
1328 greth->
mdio = mdiobus_alloc();
1333 greth->
mdio->name =
"greth-mdio";
1335 greth->
mdio->read = greth_mdio_read;
1336 greth->
mdio->write = greth_mdio_write;
1337 greth->
mdio->reset = greth_mdio_reset;
1338 greth->
mdio->priv = greth;
1350 ret = greth_mdio_probe(greth->
netdev);
1360 if (greth->
edcl && greth_edcl == 1) {
1363 while (!phy_aneg_done(greth->
phy) &&
time_before(jiffies, timeout)) {
1366 greth_link_change(greth->
netdev);
1383 struct greth_regs *
regs;
1388 unsigned long timeout;
1395 greth = netdev_priv(dev);
1397 greth->
dev = &ofdev->
dev;
1399 if (greth_debug > 0)
1407 resource_size(&ofdev->
resource[0]),
1408 "grlib-greth regs");
1424 dev_dbg(greth->
dev,
"resetting controller.\n");
1435 dev_err(greth->
dev,
"timeout when waiting for reset.\n");
1450 greth->
edcl = (tmp >> 31) & 1;
1454 if (greth->
edcl != 0)
1460 err = greth_mdio_init(greth);
1463 dev_err(greth->
dev,
"failed to register MDIO bus\n");
1475 dev_err(&dev->
dev,
"could not allocate descriptor memory.\n");
1490 dev_err(greth->
dev,
"could not allocate descriptor memory.\n");
1498 for (i = 0; i < 6; i++) {
1503 const unsigned char *
addr;
1507 if (addr !=
NULL && len == 6) {
1508 for (i = 0; i < 6; i++)
1509 macaddr[i] = (
unsigned int) addr[
i];
1512 for (i = 0; i < 6; i++)
1518 for (i = 0; i < 6; i++)
1523 if (!is_valid_ether_addr(&dev->
dev_addr[0])) {
1525 dev_err(greth->
dev,
"no valid ethernet address, aborting.\n");
1557 dev_err(greth->
dev,
"netdevice registration failed.\n");
1605 .name =
"GAISLER_ETHMAC",
1617 .name =
"grlib-greth",
1619 .of_match_table = greth_of_match,
1621 .probe = greth_of_probe,