| /* |
| * Aeroflex Gaisler GRETH 10/100/1G Ethernet MAC. |
| * |
| * 2005-2009 (c) Aeroflex Gaisler AB |
| * |
| * This driver supports GRETH 10/100 and GRETH 10/100/1G Ethernet MACs |
| * available in the GRLIB VHDL IP core library. |
| * |
| * Full documentation of both cores can be found here: |
| * http://www.gaisler.com/products/grlib/grip.pdf |
| * |
| * The Gigabit version supports scatter/gather DMA, any alignment of |
| * buffers and checksum offloading. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation; either version 2 of the License, or (at your |
| * option) any later version. |
| * |
| * Contributors: Kristoffer Glembo |
| * Daniel Hellstrom |
| * Marko Isomaki |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/uaccess.h> |
| #include <linux/init.h> |
| #include <linux/netdevice.h> |
| #include <linux/etherdevice.h> |
| #include <linux/ethtool.h> |
| #include <linux/skbuff.h> |
| #include <linux/io.h> |
| #include <linux/crc32.h> |
| #include <linux/mii.h> |
| #include <linux/of_device.h> |
| #include <linux/of_platform.h> |
| #include <asm/cacheflush.h> |
| #include <asm/byteorder.h> |
| |
| #ifdef CONFIG_SPARC |
| #include <asm/idprom.h> |
| #endif |
| |
| #include "greth.h" |
| |
| #define GRETH_DEF_MSG_ENABLE \ |
| (NETIF_MSG_DRV | \ |
| NETIF_MSG_PROBE | \ |
| NETIF_MSG_LINK | \ |
| NETIF_MSG_IFDOWN | \ |
| NETIF_MSG_IFUP | \ |
| NETIF_MSG_RX_ERR | \ |
| NETIF_MSG_TX_ERR) |
| |
| static int greth_debug = -1; /* -1 == use GRETH_DEF_MSG_ENABLE as value */ |
| module_param(greth_debug, int, 0); |
| MODULE_PARM_DESC(greth_debug, "GRETH bitmapped debugging message enable value"); |
| |
| /* Accept MAC address of the form macaddr=0x08,0x00,0x20,0x30,0x40,0x50 */ |
| static int macaddr[6]; |
| module_param_array(macaddr, int, NULL, 0); |
| MODULE_PARM_DESC(macaddr, "GRETH Ethernet MAC address"); |
| |
| static int greth_edcl = 1; |
| module_param(greth_edcl, int, 0); |
| MODULE_PARM_DESC(greth_edcl, "GRETH EDCL usage indicator. Set to 1 if EDCL is used."); |
| |
| static int greth_open(struct net_device *dev); |
| static int greth_start_xmit(struct sk_buff *skb, struct net_device *dev); |
| static int greth_start_xmit_gbit(struct sk_buff *skb, struct net_device *dev); |
| static int greth_rx(struct net_device *dev, int limit); |
| static int greth_rx_gbit(struct net_device *dev, int limit); |
| static void greth_clean_tx(struct net_device *dev); |
| static void greth_clean_tx_gbit(struct net_device *dev); |
| static irqreturn_t greth_interrupt(int irq, void *dev_id); |
| static int greth_close(struct net_device *dev); |
| static int greth_set_mac_add(struct net_device *dev, void *p); |
| static void greth_set_multicast_list(struct net_device *dev); |
| |
| #define GRETH_REGLOAD(a) (be32_to_cpu(__raw_readl(&(a)))) |
| #define GRETH_REGSAVE(a, v) (__raw_writel(cpu_to_be32(v), &(a))) |
| #define GRETH_REGORIN(a, v) (GRETH_REGSAVE(a, (GRETH_REGLOAD(a) | (v)))) |
| #define GRETH_REGANDIN(a, v) (GRETH_REGSAVE(a, (GRETH_REGLOAD(a) & (v)))) |
| |
| #define NEXT_TX(N) (((N) + 1) & GRETH_TXBD_NUM_MASK) |
| #define SKIP_TX(N, C) (((N) + C) & GRETH_TXBD_NUM_MASK) |
| #define NEXT_RX(N) (((N) + 1) & GRETH_RXBD_NUM_MASK) |
| |
| static void greth_print_rx_packet(void *addr, int len) |
| { |
| print_hex_dump(KERN_DEBUG, "RX: ", DUMP_PREFIX_OFFSET, 16, 1, |
| addr, len, true); |
| } |
| |
| static void greth_print_tx_packet(struct sk_buff *skb) |
| { |
| int i; |
| int length; |
| |
| if (skb_shinfo(skb)->nr_frags == 0) |
| length = skb->len; |
| else |
| length = skb_headlen(skb); |
| |
| print_hex_dump(KERN_DEBUG, "TX: ", DUMP_PREFIX_OFFSET, 16, 1, |
| skb->data, length, true); |
| |
| for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { |
| |
| print_hex_dump(KERN_DEBUG, "TX: ", DUMP_PREFIX_OFFSET, 16, 1, |
| phys_to_virt(page_to_phys(skb_shinfo(skb)->frags[i].page)) + |
| skb_shinfo(skb)->frags[i].page_offset, |
| length, true); |
| } |
| } |
| |
| static inline void greth_enable_tx(struct greth_private *greth) |
| { |
| wmb(); |
| GRETH_REGORIN(greth->regs->control, GRETH_TXEN); |
| } |
| |
| static inline void greth_disable_tx(struct greth_private *greth) |
| { |
| GRETH_REGANDIN(greth->regs->control, ~GRETH_TXEN); |
| } |
| |
| static inline void greth_enable_rx(struct greth_private *greth) |
| { |
| wmb(); |
| GRETH_REGORIN(greth->regs->control, GRETH_RXEN); |
| } |
| |
| static inline void greth_disable_rx(struct greth_private *greth) |
| { |
| GRETH_REGANDIN(greth->regs->control, ~GRETH_RXEN); |
| } |
| |
| static inline void greth_enable_irqs(struct greth_private *greth) |
| { |
| GRETH_REGORIN(greth->regs->control, GRETH_RXI | GRETH_TXI); |
| } |
| |
| static inline void greth_disable_irqs(struct greth_private *greth) |
| { |
| GRETH_REGANDIN(greth->regs->control, ~(GRETH_RXI|GRETH_TXI)); |
| } |
| |
| static inline void greth_write_bd(u32 *bd, u32 val) |
| { |
| __raw_writel(cpu_to_be32(val), bd); |
| } |
| |
| static inline u32 greth_read_bd(u32 *bd) |
| { |
| return be32_to_cpu(__raw_readl(bd)); |
| } |
| |
| static void greth_clean_rings(struct greth_private *greth) |
| { |
| int i; |
| struct greth_bd *rx_bdp = greth->rx_bd_base; |
| struct greth_bd *tx_bdp = greth->tx_bd_base; |
| |
| if (greth->gbit_mac) { |
| |
| /* Free and unmap RX buffers */ |
| for (i = 0; i < GRETH_RXBD_NUM; i++, rx_bdp++) { |
| if (greth->rx_skbuff[i] != NULL) { |
| dev_kfree_skb(greth->rx_skbuff[i]); |
| dma_unmap_single(greth->dev, |
| greth_read_bd(&rx_bdp->addr), |
| MAX_FRAME_SIZE+NET_IP_ALIGN, |
| DMA_FROM_DEVICE); |
| } |
| } |
| |
| /* TX buffers */ |
| while (greth->tx_free < GRETH_TXBD_NUM) { |
| |
| struct sk_buff *skb = greth->tx_skbuff[greth->tx_last]; |
| int nr_frags = skb_shinfo(skb)->nr_frags; |
| tx_bdp = greth->tx_bd_base + greth->tx_last; |
| greth->tx_last = NEXT_TX(greth->tx_last); |
| |
| dma_unmap_single(greth->dev, |
| greth_read_bd(&tx_bdp->addr), |
| skb_headlen(skb), |
| DMA_TO_DEVICE); |
| |
| for (i = 0; i < nr_frags; i++) { |
| skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; |
| tx_bdp = greth->tx_bd_base + greth->tx_last; |
| |
| dma_unmap_page(greth->dev, |
| greth_read_bd(&tx_bdp->addr), |
| frag->size, |
| DMA_TO_DEVICE); |
| |
| greth->tx_last = NEXT_TX(greth->tx_last); |
| } |
| greth->tx_free += nr_frags+1; |
| dev_kfree_skb(skb); |
| } |
| |
| |
| } else { /* 10/100 Mbps MAC */ |
| |
| for (i = 0; i < GRETH_RXBD_NUM; i++, rx_bdp++) { |
| kfree(greth->rx_bufs[i]); |
| dma_unmap_single(greth->dev, |
| greth_read_bd(&rx_bdp->addr), |
| MAX_FRAME_SIZE, |
| DMA_FROM_DEVICE); |
| } |
| for (i = 0; i < GRETH_TXBD_NUM; i++, tx_bdp++) { |
| kfree(greth->tx_bufs[i]); |
| dma_unmap_single(greth->dev, |
| greth_read_bd(&tx_bdp->addr), |
| MAX_FRAME_SIZE, |
| DMA_TO_DEVICE); |
| } |
| } |
| } |
| |
| static int greth_init_rings(struct greth_private *greth) |
| { |
| struct sk_buff *skb; |
| struct greth_bd *rx_bd, *tx_bd; |
| u32 dma_addr; |
| int i; |
| |
| rx_bd = greth->rx_bd_base; |
| tx_bd = greth->tx_bd_base; |
| |
| /* Initialize descriptor rings and buffers */ |
| if (greth->gbit_mac) { |
| |
| for (i = 0; i < GRETH_RXBD_NUM; i++) { |
| skb = netdev_alloc_skb(greth->netdev, MAX_FRAME_SIZE+NET_IP_ALIGN); |
| if (skb == NULL) { |
| if (netif_msg_ifup(greth)) |
| dev_err(greth->dev, "Error allocating DMA ring.\n"); |
| goto cleanup; |
| } |
| skb_reserve(skb, NET_IP_ALIGN); |
| dma_addr = dma_map_single(greth->dev, |
| skb->data, |
| MAX_FRAME_SIZE+NET_IP_ALIGN, |
| DMA_FROM_DEVICE); |
| |
| if (dma_mapping_error(greth->dev, dma_addr)) { |
| if (netif_msg_ifup(greth)) |
| dev_err(greth->dev, "Could not create initial DMA mapping\n"); |
| goto cleanup; |
| } |
| greth->rx_skbuff[i] = skb; |
| greth_write_bd(&rx_bd[i].addr, dma_addr); |
| greth_write_bd(&rx_bd[i].stat, GRETH_BD_EN | GRETH_BD_IE); |
| } |
| |
| } else { |
| |
| /* 10/100 MAC uses a fixed set of buffers and copy to/from SKBs */ |
| for (i = 0; i < GRETH_RXBD_NUM; i++) { |
| |
| greth->rx_bufs[i] = kmalloc(MAX_FRAME_SIZE, GFP_KERNEL); |
| |
| if (greth->rx_bufs[i] == NULL) { |
| if (netif_msg_ifup(greth)) |
| dev_err(greth->dev, "Error allocating DMA ring.\n"); |
| goto cleanup; |
| } |
| |
| dma_addr = dma_map_single(greth->dev, |
| greth->rx_bufs[i], |
| MAX_FRAME_SIZE, |
| DMA_FROM_DEVICE); |
| |
| if (dma_mapping_error(greth->dev, dma_addr)) { |
| if (netif_msg_ifup(greth)) |
| dev_err(greth->dev, "Could not create initial DMA mapping\n"); |
| goto cleanup; |
| } |
| greth_write_bd(&rx_bd[i].addr, dma_addr); |
| greth_write_bd(&rx_bd[i].stat, GRETH_BD_EN | GRETH_BD_IE); |
| } |
| for (i = 0; i < GRETH_TXBD_NUM; i++) { |
| |
| greth->tx_bufs[i] = kmalloc(MAX_FRAME_SIZE, GFP_KERNEL); |
| |
| if (greth->tx_bufs[i] == NULL) { |
| if (netif_msg_ifup(greth)) |
| dev_err(greth->dev, "Error allocating DMA ring.\n"); |
| goto cleanup; |
| } |
| |
| dma_addr = dma_map_single(greth->dev, |
| greth->tx_bufs[i], |
| MAX_FRAME_SIZE, |
| DMA_TO_DEVICE); |
| |
| if (dma_mapping_error(greth->dev, dma_addr)) { |
| if (netif_msg_ifup(greth)) |
| dev_err(greth->dev, "Could not create initial DMA mapping\n"); |
| goto cleanup; |
| } |
| greth_write_bd(&tx_bd[i].addr, dma_addr); |
| greth_write_bd(&tx_bd[i].stat, 0); |
| } |
| } |
| greth_write_bd(&rx_bd[GRETH_RXBD_NUM - 1].stat, |
| greth_read_bd(&rx_bd[GRETH_RXBD_NUM - 1].stat) | GRETH_BD_WR); |
| |
| /* Initialize pointers. */ |
| greth->rx_cur = 0; |
| greth->tx_next = 0; |
| greth->tx_last = 0; |
| greth->tx_free = GRETH_TXBD_NUM; |
| |
| /* Initialize descriptor base address */ |
| GRETH_REGSAVE(greth->regs->tx_desc_p, greth->tx_bd_base_phys); |
| GRETH_REGSAVE(greth->regs->rx_desc_p, greth->rx_bd_base_phys); |
| |
| return 0; |
| |
| cleanup: |
| greth_clean_rings(greth); |
| return -ENOMEM; |
| } |
| |
| static int greth_open(struct net_device *dev) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| int err; |
| |
| err = greth_init_rings(greth); |
| if (err) { |
| if (netif_msg_ifup(greth)) |
| dev_err(&dev->dev, "Could not allocate memory for DMA rings\n"); |
| return err; |
| } |
| |
| err = request_irq(greth->irq, greth_interrupt, 0, "eth", (void *) dev); |
| if (err) { |
| if (netif_msg_ifup(greth)) |
| dev_err(&dev->dev, "Could not allocate interrupt %d\n", dev->irq); |
| greth_clean_rings(greth); |
| return err; |
| } |
| |
| if (netif_msg_ifup(greth)) |
| dev_dbg(&dev->dev, " starting queue\n"); |
| netif_start_queue(dev); |
| |
| napi_enable(&greth->napi); |
| |
| greth_enable_irqs(greth); |
| greth_enable_tx(greth); |
| greth_enable_rx(greth); |
| return 0; |
| |
| } |
| |
| static int greth_close(struct net_device *dev) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| |
| napi_disable(&greth->napi); |
| |
| greth_disable_tx(greth); |
| |
| netif_stop_queue(dev); |
| |
| free_irq(greth->irq, (void *) dev); |
| |
| greth_clean_rings(greth); |
| |
| return 0; |
| } |
| |
| static int greth_start_xmit(struct sk_buff *skb, struct net_device *dev) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| struct greth_bd *bdp; |
| int err = NETDEV_TX_OK; |
| u32 status, dma_addr; |
| |
| bdp = greth->tx_bd_base + greth->tx_next; |
| |
| if (unlikely(greth->tx_free <= 0)) { |
| netif_stop_queue(dev); |
| return NETDEV_TX_BUSY; |
| } |
| |
| if (netif_msg_pktdata(greth)) |
| greth_print_tx_packet(skb); |
| |
| |
| if (unlikely(skb->len > MAX_FRAME_SIZE)) { |
| dev->stats.tx_errors++; |
| goto out; |
| } |
| |
| dma_addr = greth_read_bd(&bdp->addr); |
| |
| memcpy((unsigned char *) phys_to_virt(dma_addr), skb->data, skb->len); |
| |
| dma_sync_single_for_device(greth->dev, dma_addr, skb->len, DMA_TO_DEVICE); |
| |
| status = GRETH_BD_EN | (skb->len & GRETH_BD_LEN); |
| |
| /* Wrap around descriptor ring */ |
| if (greth->tx_next == GRETH_TXBD_NUM_MASK) { |
| status |= GRETH_BD_WR; |
| } |
| |
| greth->tx_next = NEXT_TX(greth->tx_next); |
| greth->tx_free--; |
| |
| /* No more descriptors */ |
| if (unlikely(greth->tx_free == 0)) { |
| |
| /* Free transmitted descriptors */ |
| greth_clean_tx(dev); |
| |
| /* If nothing was cleaned, stop queue & wait for irq */ |
| if (unlikely(greth->tx_free == 0)) { |
| status |= GRETH_BD_IE; |
| netif_stop_queue(dev); |
| } |
| } |
| |
| /* Write descriptor control word and enable transmission */ |
| greth_write_bd(&bdp->stat, status); |
| greth_enable_tx(greth); |
| |
| out: |
| dev_kfree_skb(skb); |
| return err; |
| } |
| |
| |
| static int greth_start_xmit_gbit(struct sk_buff *skb, struct net_device *dev) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| struct greth_bd *bdp; |
| u32 status = 0, dma_addr; |
| int curr_tx, nr_frags, i, err = NETDEV_TX_OK; |
| |
| nr_frags = skb_shinfo(skb)->nr_frags; |
| |
| if (greth->tx_free < nr_frags + 1) { |
| netif_stop_queue(dev); |
| err = NETDEV_TX_BUSY; |
| goto out; |
| } |
| |
| if (netif_msg_pktdata(greth)) |
| greth_print_tx_packet(skb); |
| |
| if (unlikely(skb->len > MAX_FRAME_SIZE)) { |
| dev->stats.tx_errors++; |
| goto out; |
| } |
| |
| /* Save skb pointer. */ |
| greth->tx_skbuff[greth->tx_next] = skb; |
| |
| /* Linear buf */ |
| if (nr_frags != 0) |
| status = GRETH_TXBD_MORE; |
| |
| status |= GRETH_TXBD_CSALL; |
| status |= skb_headlen(skb) & GRETH_BD_LEN; |
| if (greth->tx_next == GRETH_TXBD_NUM_MASK) |
| status |= GRETH_BD_WR; |
| |
| |
| bdp = greth->tx_bd_base + greth->tx_next; |
| greth_write_bd(&bdp->stat, status); |
| dma_addr = dma_map_single(greth->dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE); |
| |
| if (unlikely(dma_mapping_error(greth->dev, dma_addr))) |
| goto map_error; |
| |
| greth_write_bd(&bdp->addr, dma_addr); |
| |
| curr_tx = NEXT_TX(greth->tx_next); |
| |
| /* Frags */ |
| for (i = 0; i < nr_frags; i++) { |
| skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; |
| greth->tx_skbuff[curr_tx] = NULL; |
| bdp = greth->tx_bd_base + curr_tx; |
| |
| status = GRETH_TXBD_CSALL; |
| status |= frag->size & GRETH_BD_LEN; |
| |
| /* Wrap around descriptor ring */ |
| if (curr_tx == GRETH_TXBD_NUM_MASK) |
| status |= GRETH_BD_WR; |
| |
| /* More fragments left */ |
| if (i < nr_frags - 1) |
| status |= GRETH_TXBD_MORE; |
| |
| /* ... last fragment, check if out of descriptors */ |
| else if (greth->tx_free - nr_frags - 1 < (MAX_SKB_FRAGS + 1)) { |
| |
| /* Enable interrupts and stop queue */ |
| status |= GRETH_BD_IE; |
| netif_stop_queue(dev); |
| } |
| |
| greth_write_bd(&bdp->stat, status); |
| |
| dma_addr = dma_map_page(greth->dev, |
| frag->page, |
| frag->page_offset, |
| frag->size, |
| DMA_TO_DEVICE); |
| |
| if (unlikely(dma_mapping_error(greth->dev, dma_addr))) |
| goto frag_map_error; |
| |
| greth_write_bd(&bdp->addr, dma_addr); |
| |
| curr_tx = NEXT_TX(curr_tx); |
| } |
| |
| wmb(); |
| |
| /* Enable the descriptors that we configured ... */ |
| for (i = 0; i < nr_frags + 1; i++) { |
| bdp = greth->tx_bd_base + greth->tx_next; |
| greth_write_bd(&bdp->stat, greth_read_bd(&bdp->stat) | GRETH_BD_EN); |
| greth->tx_next = NEXT_TX(greth->tx_next); |
| greth->tx_free--; |
| } |
| |
| greth_enable_tx(greth); |
| |
| return NETDEV_TX_OK; |
| |
| frag_map_error: |
| /* Unmap SKB mappings that succeeded */ |
| for (i = 0; greth->tx_next + i != curr_tx; i++) { |
| bdp = greth->tx_bd_base + greth->tx_next + i; |
| dma_unmap_single(greth->dev, |
| greth_read_bd(&bdp->addr), |
| greth_read_bd(&bdp->stat) & GRETH_BD_LEN, |
| DMA_TO_DEVICE); |
| } |
| map_error: |
| if (net_ratelimit()) |
| dev_warn(greth->dev, "Could not create TX DMA mapping\n"); |
| dev_kfree_skb(skb); |
| return NETDEV_TX_OK; |
| |
| out: |
| return err; |
| } |
| |
| |
| static irqreturn_t greth_interrupt(int irq, void *dev_id) |
| { |
| struct net_device *dev = dev_id; |
| struct greth_private *greth; |
| u32 status; |
| irqreturn_t retval = IRQ_NONE; |
| |
| greth = netdev_priv(dev); |
| |
| spin_lock(&greth->devlock); |
| |
| /* Get the interrupt events that caused us to be here. */ |
| status = GRETH_REGLOAD(greth->regs->status); |
| |
| /* Handle rx and tx interrupts through poll */ |
| if (status & (GRETH_INT_RX | GRETH_INT_TX)) { |
| |
| /* Clear interrupt status */ |
| GRETH_REGORIN(greth->regs->status, |
| status & (GRETH_INT_RX | GRETH_INT_TX)); |
| |
| retval = IRQ_HANDLED; |
| |
| /* Disable interrupts and schedule poll() */ |
| greth_disable_irqs(greth); |
| napi_schedule(&greth->napi); |
| } |
| |
| mmiowb(); |
| spin_unlock(&greth->devlock); |
| |
| return retval; |
| } |
| |
| static void greth_clean_tx(struct net_device *dev) |
| { |
| struct greth_private *greth; |
| struct greth_bd *bdp; |
| u32 stat; |
| |
| greth = netdev_priv(dev); |
| |
| while (1) { |
| bdp = greth->tx_bd_base + greth->tx_last; |
| stat = greth_read_bd(&bdp->stat); |
| |
| if (unlikely(stat & GRETH_BD_EN)) |
| break; |
| |
| if (greth->tx_free == GRETH_TXBD_NUM) |
| break; |
| |
| /* Check status for errors */ |
| if (unlikely(stat & GRETH_TXBD_STATUS)) { |
| dev->stats.tx_errors++; |
| if (stat & GRETH_TXBD_ERR_AL) |
| dev->stats.tx_aborted_errors++; |
| if (stat & GRETH_TXBD_ERR_UE) |
| dev->stats.tx_fifo_errors++; |
| } |
| dev->stats.tx_packets++; |
| greth->tx_last = NEXT_TX(greth->tx_last); |
| greth->tx_free++; |
| } |
| |
| if (greth->tx_free > 0) { |
| netif_wake_queue(dev); |
| } |
| |
| } |
| |
| static inline void greth_update_tx_stats(struct net_device *dev, u32 stat) |
| { |
| /* Check status for errors */ |
| if (unlikely(stat & GRETH_TXBD_STATUS)) { |
| dev->stats.tx_errors++; |
| if (stat & GRETH_TXBD_ERR_AL) |
| dev->stats.tx_aborted_errors++; |
| if (stat & GRETH_TXBD_ERR_UE) |
| dev->stats.tx_fifo_errors++; |
| if (stat & GRETH_TXBD_ERR_LC) |
| dev->stats.tx_aborted_errors++; |
| } |
| dev->stats.tx_packets++; |
| } |
| |
| static void greth_clean_tx_gbit(struct net_device *dev) |
| { |
| struct greth_private *greth; |
| struct greth_bd *bdp, *bdp_last_frag; |
| struct sk_buff *skb; |
| u32 stat; |
| int nr_frags, i; |
| |
| greth = netdev_priv(dev); |
| |
| while (greth->tx_free < GRETH_TXBD_NUM) { |
| |
| skb = greth->tx_skbuff[greth->tx_last]; |
| |
| nr_frags = skb_shinfo(skb)->nr_frags; |
| |
| /* We only clean fully completed SKBs */ |
| bdp_last_frag = greth->tx_bd_base + SKIP_TX(greth->tx_last, nr_frags); |
| stat = bdp_last_frag->stat; |
| |
| if (stat & GRETH_BD_EN) |
| break; |
| |
| greth->tx_skbuff[greth->tx_last] = NULL; |
| |
| greth_update_tx_stats(dev, stat); |
| |
| bdp = greth->tx_bd_base + greth->tx_last; |
| |
| greth->tx_last = NEXT_TX(greth->tx_last); |
| |
| dma_unmap_single(greth->dev, |
| greth_read_bd(&bdp->addr), |
| skb_headlen(skb), |
| DMA_TO_DEVICE); |
| |
| for (i = 0; i < nr_frags; i++) { |
| skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; |
| bdp = greth->tx_bd_base + greth->tx_last; |
| |
| dma_unmap_page(greth->dev, |
| greth_read_bd(&bdp->addr), |
| frag->size, |
| DMA_TO_DEVICE); |
| |
| greth->tx_last = NEXT_TX(greth->tx_last); |
| } |
| greth->tx_free += nr_frags+1; |
| dev_kfree_skb(skb); |
| } |
| if (greth->tx_free > (MAX_SKB_FRAGS + 1)) { |
| netif_wake_queue(dev); |
| } |
| } |
| |
| static int greth_pending_packets(struct greth_private *greth) |
| { |
| struct greth_bd *bdp; |
| u32 status; |
| bdp = greth->rx_bd_base + greth->rx_cur; |
| status = greth_read_bd(&bdp->stat); |
| if (status & GRETH_BD_EN) |
| return 0; |
| else |
| return 1; |
| } |
| |
| static int greth_rx(struct net_device *dev, int limit) |
| { |
| struct greth_private *greth; |
| struct greth_bd *bdp; |
| struct sk_buff *skb; |
| int pkt_len; |
| int bad, count; |
| u32 status, dma_addr; |
| |
| greth = netdev_priv(dev); |
| |
| for (count = 0; count < limit; ++count) { |
| |
| bdp = greth->rx_bd_base + greth->rx_cur; |
| status = greth_read_bd(&bdp->stat); |
| dma_addr = greth_read_bd(&bdp->addr); |
| bad = 0; |
| |
| if (unlikely(status & GRETH_BD_EN)) { |
| break; |
| } |
| |
| /* Check status for errors. */ |
| if (unlikely(status & GRETH_RXBD_STATUS)) { |
| if (status & GRETH_RXBD_ERR_FT) { |
| dev->stats.rx_length_errors++; |
| bad = 1; |
| } |
| if (status & (GRETH_RXBD_ERR_AE | GRETH_RXBD_ERR_OE)) { |
| dev->stats.rx_frame_errors++; |
| bad = 1; |
| } |
| if (status & GRETH_RXBD_ERR_CRC) { |
| dev->stats.rx_crc_errors++; |
| bad = 1; |
| } |
| } |
| if (unlikely(bad)) { |
| dev->stats.rx_errors++; |
| |
| } else { |
| |
| pkt_len = status & GRETH_BD_LEN; |
| |
| skb = netdev_alloc_skb(dev, pkt_len + NET_IP_ALIGN); |
| |
| if (unlikely(skb == NULL)) { |
| |
| if (net_ratelimit()) |
| dev_warn(&dev->dev, "low on memory - " "packet dropped\n"); |
| |
| dev->stats.rx_dropped++; |
| |
| } else { |
| skb_reserve(skb, NET_IP_ALIGN); |
| skb->dev = dev; |
| |
| dma_sync_single_for_cpu(greth->dev, |
| dma_addr, |
| pkt_len, |
| DMA_FROM_DEVICE); |
| |
| if (netif_msg_pktdata(greth)) |
| greth_print_rx_packet(phys_to_virt(dma_addr), pkt_len); |
| |
| memcpy(skb_put(skb, pkt_len), phys_to_virt(dma_addr), pkt_len); |
| |
| skb->protocol = eth_type_trans(skb, dev); |
| dev->stats.rx_packets++; |
| netif_receive_skb(skb); |
| } |
| } |
| |
| status = GRETH_BD_EN | GRETH_BD_IE; |
| if (greth->rx_cur == GRETH_RXBD_NUM_MASK) { |
| status |= GRETH_BD_WR; |
| } |
| |
| wmb(); |
| greth_write_bd(&bdp->stat, status); |
| |
| dma_sync_single_for_device(greth->dev, dma_addr, MAX_FRAME_SIZE, DMA_FROM_DEVICE); |
| |
| greth_enable_rx(greth); |
| |
| greth->rx_cur = NEXT_RX(greth->rx_cur); |
| } |
| |
| return count; |
| } |
| |
| static inline int hw_checksummed(u32 status) |
| { |
| |
| if (status & GRETH_RXBD_IP_FRAG) |
| return 0; |
| |
| if (status & GRETH_RXBD_IP && status & GRETH_RXBD_IP_CSERR) |
| return 0; |
| |
| if (status & GRETH_RXBD_UDP && status & GRETH_RXBD_UDP_CSERR) |
| return 0; |
| |
| if (status & GRETH_RXBD_TCP && status & GRETH_RXBD_TCP_CSERR) |
| return 0; |
| |
| return 1; |
| } |
| |
| static int greth_rx_gbit(struct net_device *dev, int limit) |
| { |
| struct greth_private *greth; |
| struct greth_bd *bdp; |
| struct sk_buff *skb, *newskb; |
| int pkt_len; |
| int bad, count = 0; |
| u32 status, dma_addr; |
| |
| greth = netdev_priv(dev); |
| |
| for (count = 0; count < limit; ++count) { |
| |
| bdp = greth->rx_bd_base + greth->rx_cur; |
| skb = greth->rx_skbuff[greth->rx_cur]; |
| status = greth_read_bd(&bdp->stat); |
| bad = 0; |
| |
| if (status & GRETH_BD_EN) |
| break; |
| |
| /* Check status for errors. */ |
| if (unlikely(status & GRETH_RXBD_STATUS)) { |
| |
| if (status & GRETH_RXBD_ERR_FT) { |
| dev->stats.rx_length_errors++; |
| bad = 1; |
| } else if (status & |
| (GRETH_RXBD_ERR_AE | GRETH_RXBD_ERR_OE | GRETH_RXBD_ERR_LE)) { |
| dev->stats.rx_frame_errors++; |
| bad = 1; |
| } else if (status & GRETH_RXBD_ERR_CRC) { |
| dev->stats.rx_crc_errors++; |
| bad = 1; |
| } |
| } |
| |
| /* Allocate new skb to replace current */ |
| newskb = netdev_alloc_skb(dev, MAX_FRAME_SIZE + NET_IP_ALIGN); |
| |
| if (!bad && newskb) { |
| skb_reserve(newskb, NET_IP_ALIGN); |
| |
| dma_addr = dma_map_single(greth->dev, |
| newskb->data, |
| MAX_FRAME_SIZE + NET_IP_ALIGN, |
| DMA_FROM_DEVICE); |
| |
| if (!dma_mapping_error(greth->dev, dma_addr)) { |
| /* Process the incoming frame. */ |
| pkt_len = status & GRETH_BD_LEN; |
| |
| dma_unmap_single(greth->dev, |
| greth_read_bd(&bdp->addr), |
| MAX_FRAME_SIZE + NET_IP_ALIGN, |
| DMA_FROM_DEVICE); |
| |
| if (netif_msg_pktdata(greth)) |
| greth_print_rx_packet(phys_to_virt(greth_read_bd(&bdp->addr)), pkt_len); |
| |
| skb_put(skb, pkt_len); |
| |
| if (greth->flags & GRETH_FLAG_RX_CSUM && hw_checksummed(status)) |
| skb->ip_summed = CHECKSUM_UNNECESSARY; |
| else |
| skb->ip_summed = CHECKSUM_NONE; |
| |
| skb->dev = dev; |
| skb->protocol = eth_type_trans(skb, dev); |
| dev->stats.rx_packets++; |
| netif_receive_skb(skb); |
| |
| greth->rx_skbuff[greth->rx_cur] = newskb; |
| greth_write_bd(&bdp->addr, dma_addr); |
| } else { |
| if (net_ratelimit()) |
| dev_warn(greth->dev, "Could not create DMA mapping, dropping packet\n"); |
| dev_kfree_skb(newskb); |
| dev->stats.rx_dropped++; |
| } |
| } else { |
| if (net_ratelimit()) |
| dev_warn(greth->dev, "Could not allocate SKB, dropping packet\n"); |
| dev->stats.rx_dropped++; |
| } |
| |
| status = GRETH_BD_EN | GRETH_BD_IE; |
| if (greth->rx_cur == GRETH_RXBD_NUM_MASK) { |
| status |= GRETH_BD_WR; |
| } |
| |
| wmb(); |
| greth_write_bd(&bdp->stat, status); |
| greth_enable_rx(greth); |
| greth->rx_cur = NEXT_RX(greth->rx_cur); |
| } |
| |
| return count; |
| |
| } |
| |
| static int greth_poll(struct napi_struct *napi, int budget) |
| { |
| struct greth_private *greth; |
| int work_done = 0; |
| greth = container_of(napi, struct greth_private, napi); |
| |
| if (greth->gbit_mac) { |
| greth_clean_tx_gbit(greth->netdev); |
| } else { |
| greth_clean_tx(greth->netdev); |
| } |
| |
| restart_poll: |
| if (greth->gbit_mac) { |
| work_done += greth_rx_gbit(greth->netdev, budget - work_done); |
| } else { |
| work_done += greth_rx(greth->netdev, budget - work_done); |
| } |
| |
| if (work_done < budget) { |
| |
| napi_complete(napi); |
| |
| if (greth_pending_packets(greth)) { |
| napi_reschedule(napi); |
| goto restart_poll; |
| } |
| } |
| |
| greth_enable_irqs(greth); |
| return work_done; |
| } |
| |
| static int greth_set_mac_add(struct net_device *dev, void *p) |
| { |
| struct sockaddr *addr = p; |
| struct greth_private *greth; |
| struct greth_regs *regs; |
| |
| greth = (struct greth_private *) netdev_priv(dev); |
| regs = (struct greth_regs *) greth->regs; |
| |
| if (!is_valid_ether_addr(addr->sa_data)) |
| return -EINVAL; |
| |
| memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); |
| |
| GRETH_REGSAVE(regs->esa_msb, addr->sa_data[0] << 8 | addr->sa_data[1]); |
| GRETH_REGSAVE(regs->esa_lsb, |
| addr->sa_data[2] << 24 | addr-> |
| sa_data[3] << 16 | addr->sa_data[4] << 8 | addr->sa_data[5]); |
| return 0; |
| } |
| |
| static u32 greth_hash_get_index(__u8 *addr) |
| { |
| return (ether_crc(6, addr)) & 0x3F; |
| } |
| |
| static void greth_set_hash_filter(struct net_device *dev) |
| { |
| struct dev_mc_list *curr; |
| struct greth_private *greth = (struct greth_private *) netdev_priv(dev); |
| struct greth_regs *regs = (struct greth_regs *) greth->regs; |
| u32 mc_filter[2]; |
| unsigned int i, bitnr; |
| |
| mc_filter[0] = mc_filter[1] = 0; |
| |
| curr = dev->mc_list; |
| |
| for (i = 0; i < dev->mc_count; i++, curr = curr->next) { |
| |
| if (!curr) |
| break; /* unexpected end of list */ |
| |
| bitnr = greth_hash_get_index(curr->dmi_addr); |
| mc_filter[bitnr >> 5] |= 1 << (bitnr & 31); |
| } |
| |
| GRETH_REGSAVE(regs->hash_msb, mc_filter[1]); |
| GRETH_REGSAVE(regs->hash_lsb, mc_filter[0]); |
| } |
| |
| static void greth_set_multicast_list(struct net_device *dev) |
| { |
| int cfg; |
| struct greth_private *greth = netdev_priv(dev); |
| struct greth_regs *regs = (struct greth_regs *) greth->regs; |
| |
| cfg = GRETH_REGLOAD(regs->control); |
| if (dev->flags & IFF_PROMISC) |
| cfg |= GRETH_CTRL_PR; |
| else |
| cfg &= ~GRETH_CTRL_PR; |
| |
| if (greth->multicast) { |
| if (dev->flags & IFF_ALLMULTI) { |
| GRETH_REGSAVE(regs->hash_msb, -1); |
| GRETH_REGSAVE(regs->hash_lsb, -1); |
| cfg |= GRETH_CTRL_MCEN; |
| GRETH_REGSAVE(regs->control, cfg); |
| return; |
| } |
| |
| if (dev->mc_count == 0) { |
| cfg &= ~GRETH_CTRL_MCEN; |
| GRETH_REGSAVE(regs->control, cfg); |
| return; |
| } |
| |
| /* Setup multicast filter */ |
| greth_set_hash_filter(dev); |
| cfg |= GRETH_CTRL_MCEN; |
| } |
| GRETH_REGSAVE(regs->control, cfg); |
| } |
| |
| static u32 greth_get_msglevel(struct net_device *dev) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| return greth->msg_enable; |
| } |
| |
| static void greth_set_msglevel(struct net_device *dev, u32 value) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| greth->msg_enable = value; |
| } |
| static int greth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| struct phy_device *phy = greth->phy; |
| |
| if (!phy) |
| return -ENODEV; |
| |
| return phy_ethtool_gset(phy, cmd); |
| } |
| |
| static int greth_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| struct phy_device *phy = greth->phy; |
| |
| if (!phy) |
| return -ENODEV; |
| |
| return phy_ethtool_sset(phy, cmd); |
| } |
| |
| static int greth_get_regs_len(struct net_device *dev) |
| { |
| return sizeof(struct greth_regs); |
| } |
| |
| static void greth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| |
| strncpy(info->driver, dev_driver_string(greth->dev), 32); |
| strncpy(info->version, "revision: 1.0", 32); |
| strncpy(info->bus_info, greth->dev->bus->name, 32); |
| strncpy(info->fw_version, "N/A", 32); |
| info->eedump_len = 0; |
| info->regdump_len = sizeof(struct greth_regs); |
| } |
| |
| static void greth_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p) |
| { |
| int i; |
| struct greth_private *greth = netdev_priv(dev); |
| u32 __iomem *greth_regs = (u32 __iomem *) greth->regs; |
| u32 *buff = p; |
| |
| for (i = 0; i < sizeof(struct greth_regs) / sizeof(u32); i++) |
| buff[i] = greth_read_bd(&greth_regs[i]); |
| } |
| |
| static u32 greth_get_rx_csum(struct net_device *dev) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| return (greth->flags & GRETH_FLAG_RX_CSUM) != 0; |
| } |
| |
| static int greth_set_rx_csum(struct net_device *dev, u32 data) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| |
| spin_lock_bh(&greth->devlock); |
| |
| if (data) |
| greth->flags |= GRETH_FLAG_RX_CSUM; |
| else |
| greth->flags &= ~GRETH_FLAG_RX_CSUM; |
| |
| spin_unlock_bh(&greth->devlock); |
| |
| return 0; |
| } |
| |
| static u32 greth_get_tx_csum(struct net_device *dev) |
| { |
| return (dev->features & NETIF_F_IP_CSUM) != 0; |
| } |
| |
| static int greth_set_tx_csum(struct net_device *dev, u32 data) |
| { |
| netif_tx_lock_bh(dev); |
| ethtool_op_set_tx_csum(dev, data); |
| netif_tx_unlock_bh(dev); |
| return 0; |
| } |
| |
| static const struct ethtool_ops greth_ethtool_ops = { |
| .get_msglevel = greth_get_msglevel, |
| .set_msglevel = greth_set_msglevel, |
| .get_settings = greth_get_settings, |
| .set_settings = greth_set_settings, |
| .get_drvinfo = greth_get_drvinfo, |
| .get_regs_len = greth_get_regs_len, |
| .get_regs = greth_get_regs, |
| .get_rx_csum = greth_get_rx_csum, |
| .set_rx_csum = greth_set_rx_csum, |
| .get_tx_csum = greth_get_tx_csum, |
| .set_tx_csum = greth_set_tx_csum, |
| .get_link = ethtool_op_get_link, |
| }; |
| |
| static struct net_device_ops greth_netdev_ops = { |
| .ndo_open = greth_open, |
| .ndo_stop = greth_close, |
| .ndo_start_xmit = greth_start_xmit, |
| .ndo_set_mac_address = greth_set_mac_add, |
| }; |
| |
| static inline int wait_for_mdio(struct greth_private *greth) |
| { |
| unsigned long timeout = jiffies + 4*HZ/100; |
| while (GRETH_REGLOAD(greth->regs->mdio) & GRETH_MII_BUSY) { |
| if (time_after(jiffies, timeout)) |
| return 0; |
| } |
| return 1; |
| } |
| |
| static int greth_mdio_read(struct mii_bus *bus, int phy, int reg) |
| { |
| struct greth_private *greth = bus->priv; |
| int data; |
| |
| if (!wait_for_mdio(greth)) |
| return -EBUSY; |
| |
| GRETH_REGSAVE(greth->regs->mdio, ((phy & 0x1F) << 11) | ((reg & 0x1F) << 6) | 2); |
| |
| if (!wait_for_mdio(greth)) |
| return -EBUSY; |
| |
| if (!(GRETH_REGLOAD(greth->regs->mdio) & GRETH_MII_NVALID)) { |
| data = (GRETH_REGLOAD(greth->regs->mdio) >> 16) & 0xFFFF; |
| return data; |
| |
| } else { |
| return -1; |
| } |
| } |
| |
| static int greth_mdio_write(struct mii_bus *bus, int phy, int reg, u16 val) |
| { |
| struct greth_private *greth = bus->priv; |
| |
| if (!wait_for_mdio(greth)) |
| return -EBUSY; |
| |
| GRETH_REGSAVE(greth->regs->mdio, |
| ((val & 0xFFFF) << 16) | ((phy & 0x1F) << 11) | ((reg & 0x1F) << 6) | 1); |
| |
| if (!wait_for_mdio(greth)) |
| return -EBUSY; |
| |
| return 0; |
| } |
| |
| static int greth_mdio_reset(struct mii_bus *bus) |
| { |
| return 0; |
| } |
| |
| static void greth_link_change(struct net_device *dev) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| struct phy_device *phydev = greth->phy; |
| unsigned long flags; |
| |
| int status_change = 0; |
| |
| spin_lock_irqsave(&greth->devlock, flags); |
| |
| if (phydev->link) { |
| |
| if ((greth->speed != phydev->speed) || (greth->duplex != phydev->duplex)) { |
| |
| GRETH_REGANDIN(greth->regs->control, |
| ~(GRETH_CTRL_FD | GRETH_CTRL_SP | GRETH_CTRL_GB)); |
| |
| if (phydev->duplex) |
| GRETH_REGORIN(greth->regs->control, GRETH_CTRL_FD); |
| |
| if (phydev->speed == SPEED_100) { |
| |
| GRETH_REGORIN(greth->regs->control, GRETH_CTRL_SP); |
| } |
| |
| else if (phydev->speed == SPEED_1000) |
| GRETH_REGORIN(greth->regs->control, GRETH_CTRL_GB); |
| |
| greth->speed = phydev->speed; |
| greth->duplex = phydev->duplex; |
| status_change = 1; |
| } |
| } |
| |
| if (phydev->link != greth->link) { |
| if (!phydev->link) { |
| greth->speed = 0; |
| greth->duplex = -1; |
| } |
| greth->link = phydev->link; |
| |
| status_change = 1; |
| } |
| |
| spin_unlock_irqrestore(&greth->devlock, flags); |
| |
| if (status_change) { |
| if (phydev->link) |
| pr_debug("%s: link up (%d/%s)\n", |
| dev->name, phydev->speed, |
| DUPLEX_FULL == phydev->duplex ? "Full" : "Half"); |
| else |
| pr_debug("%s: link down\n", dev->name); |
| } |
| } |
| |
| static int greth_mdio_probe(struct net_device *dev) |
| { |
| struct greth_private *greth = netdev_priv(dev); |
| struct phy_device *phy = NULL; |
| u32 interface; |
| int i; |
| |
| /* Find the first PHY */ |
| for (i = 0; i < PHY_MAX_ADDR; i++) { |
| if (greth->mdio->phy_map[i]) { |
| phy = greth->mdio->phy_map[i]; |
| break; |
| } |
| } |
| if (!phy) { |
| if (netif_msg_probe(greth)) |
| dev_err(&dev->dev, "no PHY found\n"); |
| return -ENXIO; |
| } |
| |
| if (greth->gbit_mac) |
| interface = PHY_INTERFACE_MODE_GMII; |
| else |
| interface = PHY_INTERFACE_MODE_MII; |
| |
| phy = phy_connect(dev, dev_name(&phy->dev), &greth_link_change, 0, interface); |
| |
| if (greth->gbit_mac) |
| phy->supported &= PHY_GBIT_FEATURES; |
| else |
| phy->supported &= PHY_BASIC_FEATURES; |
| |
| phy->advertising = phy->supported; |
| |
| if (IS_ERR(phy)) { |
| if (netif_msg_ifup(greth)) |
| dev_err(&dev->dev, "could not attach to PHY\n"); |
| return PTR_ERR(phy); |
| } |
| |
| greth->link = 0; |
| greth->speed = 0; |
| greth->duplex = -1; |
| greth->phy = phy; |
| |
| return 0; |
| } |
| |
| static inline int phy_aneg_done(struct phy_device *phydev) |
| { |
| int retval; |
| |
| retval = phy_read(phydev, MII_BMSR); |
| |
| return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE); |
| } |
| |
| static int greth_mdio_init(struct greth_private *greth) |
| { |
| int ret, phy; |
| unsigned long timeout; |
| |
| greth->mdio = mdiobus_alloc(); |
| if (!greth->mdio) { |
| return -ENOMEM; |
| } |
| |
| greth->mdio->name = "greth-mdio"; |
| snprintf(greth->mdio->id, MII_BUS_ID_SIZE, "%s-%d", greth->mdio->name, greth->irq); |
| greth->mdio->read = greth_mdio_read; |
| greth->mdio->write = greth_mdio_write; |
| greth->mdio->reset = greth_mdio_reset; |
| greth->mdio->priv = greth; |
| |
| greth->mdio->irq = greth->mdio_irqs; |
| |
| for (phy = 0; phy < PHY_MAX_ADDR; phy++) |
| greth->mdio->irq[phy] = PHY_POLL; |
| |
| ret = mdiobus_register(greth->mdio); |
| if (ret) { |
| goto error; |
| } |
| |
| ret = greth_mdio_probe(greth->netdev); |
| if (ret) { |
| if (netif_msg_probe(greth)) |
| dev_err(&greth->netdev->dev, "failed to probe MDIO bus\n"); |
| goto unreg_mdio; |
| } |
| |
| phy_start(greth->phy); |
| |
| /* If Ethernet debug link is used make autoneg happen right away */ |
| if (greth->edcl && greth_edcl == 1) { |
| phy_start_aneg(greth->phy); |
| timeout = jiffies + 6*HZ; |
| while (!phy_aneg_done(greth->phy) && time_before(jiffies, timeout)) { |
| } |
| genphy_read_status(greth->phy); |
| greth_link_change(greth->netdev); |
| } |
| |
| return 0; |
| |
| unreg_mdio: |
| mdiobus_unregister(greth->mdio); |
| error: |
| mdiobus_free(greth->mdio); |
| return ret; |
| } |
| |
| /* Initialize the GRETH MAC */ |
| static int __devinit greth_of_probe(struct of_device *ofdev, const struct of_device_id *match) |
| { |
| struct net_device *dev; |
| struct greth_private *greth; |
| struct greth_regs *regs; |
| |
| int i; |
| int err; |
| int tmp; |
| unsigned long timeout; |
| |
| dev = alloc_etherdev(sizeof(struct greth_private)); |
| |
| if (dev == NULL) |
| return -ENOMEM; |
| |
| greth = netdev_priv(dev); |
| greth->netdev = dev; |
| greth->dev = &ofdev->dev; |
| |
| if (greth_debug > 0) |
| greth->msg_enable = greth_debug; |
| else |
| greth->msg_enable = GRETH_DEF_MSG_ENABLE; |
| |
| spin_lock_init(&greth->devlock); |
| |
| greth->regs = of_ioremap(&ofdev->resource[0], 0, |
| resource_size(&ofdev->resource[0]), |
| "grlib-greth regs"); |
| |
| if (greth->regs == NULL) { |
| if (netif_msg_probe(greth)) |
| dev_err(greth->dev, "ioremap failure.\n"); |
| err = -EIO; |
| goto error1; |
| } |
| |
| regs = (struct greth_regs *) greth->regs; |
| greth->irq = ofdev->irqs[0]; |
| |
| dev_set_drvdata(greth->dev, dev); |
| SET_NETDEV_DEV(dev, greth->dev); |
| |
| if (netif_msg_probe(greth)) |
| dev_dbg(greth->dev, "reseting controller.\n"); |
| |
| /* Reset the controller. */ |
| GRETH_REGSAVE(regs->control, GRETH_RESET); |
| |
| /* Wait for MAC to reset itself */ |
| timeout = jiffies + HZ/100; |
| while (GRETH_REGLOAD(regs->control) & GRETH_RESET) { |
| if (time_after(jiffies, timeout)) { |
| err = -EIO; |
| if (netif_msg_probe(greth)) |
| dev_err(greth->dev, "timeout when waiting for reset.\n"); |
| goto error2; |
| } |
| } |
| |
| /* Get default PHY address */ |
| greth->phyaddr = (GRETH_REGLOAD(regs->mdio) >> 11) & 0x1F; |
| |
| /* Check if we have GBIT capable MAC */ |
| tmp = GRETH_REGLOAD(regs->control); |
| greth->gbit_mac = (tmp >> 27) & 1; |
| |
| /* Check for multicast capability */ |
| greth->multicast = (tmp >> 25) & 1; |
| |
| greth->edcl = (tmp >> 31) & 1; |
| |
| /* If we have EDCL we disable the EDCL speed-duplex FSM so |
| * it doesn't interfere with the software */ |
| if (greth->edcl != 0) |
| GRETH_REGORIN(regs->control, GRETH_CTRL_DISDUPLEX); |
| |
| /* Check if MAC can handle MDIO interrupts */ |
| greth->mdio_int_en = (tmp >> 26) & 1; |
| |
| err = greth_mdio_init(greth); |
| if (err) { |
| if (netif_msg_probe(greth)) |
| dev_err(greth->dev, "failed to register MDIO bus\n"); |
| goto error2; |
| } |
| |
| /* Allocate TX descriptor ring in coherent memory */ |
| greth->tx_bd_base = (struct greth_bd *) dma_alloc_coherent(greth->dev, |
| 1024, |
| &greth->tx_bd_base_phys, |
| GFP_KERNEL); |
| |
| if (!greth->tx_bd_base) { |
| if (netif_msg_probe(greth)) |
| dev_err(&dev->dev, "could not allocate descriptor memory.\n"); |
| err = -ENOMEM; |
| goto error3; |
| } |
| |
| memset(greth->tx_bd_base, 0, 1024); |
| |
| /* Allocate RX descriptor ring in coherent memory */ |
| greth->rx_bd_base = (struct greth_bd *) dma_alloc_coherent(greth->dev, |
| 1024, |
| &greth->rx_bd_base_phys, |
| GFP_KERNEL); |
| |
| if (!greth->rx_bd_base) { |
| if (netif_msg_probe(greth)) |
| dev_err(greth->dev, "could not allocate descriptor memory.\n"); |
| err = -ENOMEM; |
| goto error4; |
| } |
| |
| memset(greth->rx_bd_base, 0, 1024); |
| |
| /* Get MAC address from: module param, OF property or ID prom */ |
| for (i = 0; i < 6; i++) { |
| if (macaddr[i] != 0) |
| break; |
| } |
| if (i == 6) { |
| const unsigned char *addr; |
| int len; |
| addr = of_get_property(ofdev->node, "local-mac-address", &len); |
| if (addr != NULL && len == 6) { |
| for (i = 0; i < 6; i++) |
| macaddr[i] = (unsigned int) addr[i]; |
| } else { |
| #ifdef CONFIG_SPARC |
| for (i = 0; i < 6; i++) |
| macaddr[i] = (unsigned int) idprom->id_ethaddr[i]; |
| #endif |
| } |
| } |
| |
| for (i = 0; i < 6; i++) |
| dev->dev_addr[i] = macaddr[i]; |
| |
| macaddr[5]++; |
| |
| if (!is_valid_ether_addr(&dev->dev_addr[0])) { |
| if (netif_msg_probe(greth)) |
| dev_err(greth->dev, "no valid ethernet address, aborting.\n"); |
| err = -EINVAL; |
| goto error5; |
| } |
| |
| GRETH_REGSAVE(regs->esa_msb, dev->dev_addr[0] << 8 | dev->dev_addr[1]); |
| GRETH_REGSAVE(regs->esa_lsb, dev->dev_addr[2] << 24 | dev->dev_addr[3] << 16 | |
| dev->dev_addr[4] << 8 | dev->dev_addr[5]); |
| |
| /* Clear all pending interrupts except PHY irq */ |
| GRETH_REGSAVE(regs->status, 0xFF); |
| |
| if (greth->gbit_mac) { |
| dev->features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_HIGHDMA; |
| greth_netdev_ops.ndo_start_xmit = greth_start_xmit_gbit; |
| greth->flags = GRETH_FLAG_RX_CSUM; |
| } |
| |
| if (greth->multicast) { |
| greth_netdev_ops.ndo_set_multicast_list = greth_set_multicast_list; |
| dev->flags |= IFF_MULTICAST; |
| } else { |
| dev->flags &= ~IFF_MULTICAST; |
| } |
| |
| dev->netdev_ops = &greth_netdev_ops; |
| dev->ethtool_ops = &greth_ethtool_ops; |
| |
| if (register_netdev(dev)) { |
| if (netif_msg_probe(greth)) |
| dev_err(greth->dev, "netdevice registration failed.\n"); |
| err = -ENOMEM; |
| goto error5; |
| } |
| |
| /* setup NAPI */ |
| memset(&greth->napi, 0, sizeof(greth->napi)); |
| netif_napi_add(dev, &greth->napi, greth_poll, 64); |
| |
| return 0; |
| |
| error5: |
| dma_free_coherent(greth->dev, 1024, greth->rx_bd_base, greth->rx_bd_base_phys); |
| error4: |
| dma_free_coherent(greth->dev, 1024, greth->tx_bd_base, greth->tx_bd_base_phys); |
| error3: |
| mdiobus_unregister(greth->mdio); |
| error2: |
| of_iounmap(&ofdev->resource[0], greth->regs, resource_size(&ofdev->resource[0])); |
| error1: |
| free_netdev(dev); |
| return err; |
| } |
| |
| static int __devexit greth_of_remove(struct of_device *of_dev) |
| { |
| struct net_device *ndev = dev_get_drvdata(&of_dev->dev); |
| struct greth_private *greth = netdev_priv(ndev); |
| |
| /* Free descriptor areas */ |
| dma_free_coherent(&of_dev->dev, 1024, greth->rx_bd_base, greth->rx_bd_base_phys); |
| |
| dma_free_coherent(&of_dev->dev, 1024, greth->tx_bd_base, greth->tx_bd_base_phys); |
| |
| dev_set_drvdata(&of_dev->dev, NULL); |
| |
| if (greth->phy) |
| phy_stop(greth->phy); |
| mdiobus_unregister(greth->mdio); |
| |
| unregister_netdev(ndev); |
| free_netdev(ndev); |
| |
| of_iounmap(&of_dev->resource[0], greth->regs, resource_size(&of_dev->resource[0])); |
| |
| return 0; |
| } |
| |
| static struct of_device_id greth_of_match[] = { |
| { |
| .name = "GAISLER_ETHMAC", |
| }, |
| {}, |
| }; |
| |
| MODULE_DEVICE_TABLE(of, greth_of_match); |
| |
| static struct of_platform_driver greth_of_driver = { |
| .name = "grlib-greth", |
| .match_table = greth_of_match, |
| .probe = greth_of_probe, |
| .remove = __devexit_p(greth_of_remove), |
| .driver = { |
| .owner = THIS_MODULE, |
| .name = "grlib-greth", |
| }, |
| }; |
| |
| static int __init greth_init(void) |
| { |
| return of_register_platform_driver(&greth_of_driver); |
| } |
| |
| static void __exit greth_cleanup(void) |
| { |
| of_unregister_platform_driver(&greth_of_driver); |
| } |
| |
| module_init(greth_init); |
| module_exit(greth_cleanup); |
| |
| MODULE_AUTHOR("Aeroflex Gaisler AB."); |
| MODULE_DESCRIPTION("Aeroflex Gaisler Ethernet MAC driver"); |
| MODULE_LICENSE("GPL"); |