X-Git-Url: http://git.openwrt.org/?p=openwrt%2Fopenwrt.git;a=blobdiff_plain;f=target%2Flinux%2Far71xx%2Ffiles%2Fdrivers%2Fnet%2Fethernet%2Fatheros%2Fag71xx%2Fag71xx_main.c;h=ae1bdf60662d805d891e18907ac663d443955d7b;hp=2eeb2694393b0bcdfcee4ea820445a64a9a4b6d1;hb=13e5e473699b92f171205e0f5c57c9ebe7922492;hpb=1dc2b6e8fa5a96d3667ed1eda6d5ecd30f310d32 diff --git a/target/linux/ar71xx/files/drivers/net/ethernet/atheros/ag71xx/ag71xx_main.c b/target/linux/ar71xx/files/drivers/net/ethernet/atheros/ag71xx/ag71xx_main.c index 2eeb269439..ae1bdf6066 100644 --- a/target/linux/ar71xx/files/drivers/net/ethernet/atheros/ag71xx/ag71xx_main.c +++ b/target/linux/ar71xx/files/drivers/net/ethernet/atheros/ag71xx/ag71xx_main.c @@ -13,6 +13,13 @@ #include "ag71xx.h" +#if LINUX_VERSION_CODE < KERNEL_VERSION(4,2,0) +static inline void skb_free_frag(void *data) +{ + put_page(virt_to_head_page(data)); +} +#endif + #define AG71XX_DEFAULT_MSG_ENABLE \ (NETIF_MSG_DRV \ | NETIF_MSG_PROBE \ @@ -28,6 +35,15 @@ static int ag71xx_msg_level = -1; module_param_named(msg_level, ag71xx_msg_level, int, 0); MODULE_PARM_DESC(msg_level, "Message level (-1=defaults,0=none,...,16=all)"); +#define ETH_SWITCH_HEADER_LEN 2 + +static int ag71xx_tx_packets(struct ag71xx *ag, bool flush); + +static inline unsigned int ag71xx_max_frame_len(unsigned int mtu) +{ + return ETH_SWITCH_HEADER_LEN + ETH_HLEN + VLAN_HLEN + mtu + ETH_FCS_LEN; +} + static void ag71xx_dump_dma_regs(struct ag71xx *ag) { DBG("%s: dma_tx_ctrl=%08x, dma_tx_desc=%08x, dma_tx_status=%08x\n", @@ -83,27 +99,20 @@ static inline void ag71xx_dump_intr(struct ag71xx *ag, char *label, u32 intr) static void ag71xx_ring_free(struct ag71xx_ring *ring) { + int ring_size = BIT(ring->order); kfree(ring->buf); if (ring->descs_cpu) - dma_free_coherent(NULL, ring->size * ring->desc_size, + dma_free_coherent(NULL, ring_size * AG71XX_DESC_SIZE, ring->descs_cpu, ring->descs_dma); } static int ag71xx_ring_alloc(struct ag71xx_ring *ring) { + int ring_size = BIT(ring->order); int err; - int i; - ring->desc_size = sizeof(struct ag71xx_desc); - if (ring->desc_size % cache_line_size()) { - DBG("ag71xx: ring %p, desc size %u rounded to %u\n", - ring, ring->desc_size, - roundup(ring->desc_size, cache_line_size())); - ring->desc_size = roundup(ring->desc_size, cache_line_size()); - } - - ring->descs_cpu = dma_alloc_coherent(NULL, ring->size * ring->desc_size, + ring->descs_cpu = dma_alloc_coherent(NULL, ring_size * AG71XX_DESC_SIZE, &ring->descs_dma, GFP_ATOMIC); if (!ring->descs_cpu) { err = -ENOMEM; @@ -111,19 +120,12 @@ static int ag71xx_ring_alloc(struct ag71xx_ring *ring) } - ring->buf = kzalloc(ring->size * sizeof(*ring->buf), GFP_KERNEL); + ring->buf = kzalloc(ring_size * sizeof(*ring->buf), GFP_KERNEL); if (!ring->buf) { err = -ENOMEM; goto err; } - for (i = 0; i < ring->size; i++) { - int idx = i * ring->desc_size; - ring->buf[i].desc = (struct ag71xx_desc *)&ring->descs_cpu[idx]; - DBG("ag71xx: ring %p, desc %d at %p\n", - ring, i, ring->buf[i].desc); - } - return 0; err: @@ -134,18 +136,21 @@ static void ag71xx_ring_tx_clean(struct ag71xx *ag) { struct ag71xx_ring *ring = &ag->tx_ring; struct net_device *dev = ag->dev; + int ring_mask = BIT(ring->order) - 1; u32 bytes_compl = 0, pkts_compl = 0; while (ring->curr != ring->dirty) { - u32 i = ring->dirty % ring->size; + struct ag71xx_desc *desc; + u32 i = ring->dirty & ring_mask; - if (!ag71xx_desc_empty(ring->buf[i].desc)) { - ring->buf[i].desc->ctrl = 0; + desc = ag71xx_ring_desc(ring, i); + if (!ag71xx_desc_empty(desc)) { + desc->ctrl = 0; dev->stats.tx_errors++; } if (ring->buf[i].skb) { - bytes_compl += ring->buf[i].skb->len; + bytes_compl += ring->buf[i].len; pkts_compl++; dev_kfree_skb_any(ring->buf[i].skb); } @@ -162,13 +167,17 @@ static void ag71xx_ring_tx_clean(struct ag71xx *ag) static void ag71xx_ring_tx_init(struct ag71xx *ag) { struct ag71xx_ring *ring = &ag->tx_ring; + int ring_size = BIT(ring->order); + int ring_mask = ring_size - 1; int i; - for (i = 0; i < ring->size; i++) { - ring->buf[i].desc->next = (u32) (ring->descs_dma + - ring->desc_size * ((i + 1) % ring->size)); + for (i = 0; i < ring_size; i++) { + struct ag71xx_desc *desc = ag71xx_ring_desc(ring, i); + + desc->next = (u32) (ring->descs_dma + + AG71XX_DESC_SIZE * ((i + 1) & ring_mask)); - ring->buf[i].desc->ctrl = DESC_EMPTY; + desc->ctrl = DESC_EMPTY; ring->buf[i].skb = NULL; } @@ -183,16 +192,17 @@ static void ag71xx_ring_tx_init(struct ag71xx *ag) static void ag71xx_ring_rx_clean(struct ag71xx *ag) { struct ag71xx_ring *ring = &ag->rx_ring; + int ring_size = BIT(ring->order); int i; if (!ring->buf) return; - for (i = 0; i < ring->size; i++) + for (i = 0; i < ring_size; i++) if (ring->buf[i].rx_buf) { dma_unmap_single(&ag->dev->dev, ring->buf[i].dma_addr, - AG71XX_RX_BUF_SIZE, DMA_FROM_DEVICE); - kfree(ring->buf[i].rx_buf); + ag->rx_buf_size, DMA_FROM_DEVICE); + skb_free_frag(ring->buf[i].rx_buf); } } @@ -212,48 +222,61 @@ static int ag71xx_buffer_offset(struct ag71xx *ag) return offset + NET_IP_ALIGN; } +static int ag71xx_buffer_size(struct ag71xx *ag) +{ + return ag->rx_buf_size + + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); +} + static bool ag71xx_fill_rx_buf(struct ag71xx *ag, struct ag71xx_buf *buf, - int offset) + int offset, + void *(*alloc)(unsigned int size)) { + struct ag71xx_ring *ring = &ag->rx_ring; + struct ag71xx_desc *desc = ag71xx_ring_desc(ring, buf - &ring->buf[0]); void *data; - data = kmalloc(AG71XX_RX_BUF_SIZE + - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)), - GFP_ATOMIC); + data = alloc(ag71xx_buffer_size(ag)); if (!data) return false; buf->rx_buf = data; - buf->dma_addr = dma_map_single(&ag->dev->dev, data, - AG71XX_RX_BUF_SIZE, DMA_FROM_DEVICE); - buf->desc->data = (u32) buf->dma_addr + offset; + buf->dma_addr = dma_map_single(&ag->dev->dev, data, ag->rx_buf_size, + DMA_FROM_DEVICE); + desc->data = (u32) buf->dma_addr + offset; return true; } static int ag71xx_ring_rx_init(struct ag71xx *ag) { struct ag71xx_ring *ring = &ag->rx_ring; + int ring_size = BIT(ring->order); + int ring_mask = BIT(ring->order) - 1; unsigned int i; int ret; int offset = ag71xx_buffer_offset(ag); ret = 0; - for (i = 0; i < ring->size; i++) { - ring->buf[i].desc->next = (u32) (ring->descs_dma + - ring->desc_size * ((i + 1) % ring->size)); + for (i = 0; i < ring_size; i++) { + struct ag71xx_desc *desc = ag71xx_ring_desc(ring, i); + + desc->next = (u32) (ring->descs_dma + + AG71XX_DESC_SIZE * ((i + 1) & ring_mask)); DBG("ag71xx: RX desc at %p, next is %08x\n", - ring->buf[i].desc, - ring->buf[i].desc->next); + desc, desc->next); } - for (i = 0; i < ring->size; i++) { - if (!ag71xx_fill_rx_buf(ag, &ring->buf[i], offset)) { + for (i = 0; i < ring_size; i++) { + struct ag71xx_desc *desc = ag71xx_ring_desc(ring, i); + + if (!ag71xx_fill_rx_buf(ag, &ring->buf[i], offset, + netdev_alloc_frag)) { ret = -ENOMEM; break; } - ring->buf[i].desc->ctrl = DESC_EMPTY; + desc->ctrl = DESC_EMPTY; } /* flush descriptors */ @@ -268,20 +291,24 @@ static int ag71xx_ring_rx_init(struct ag71xx *ag) static int ag71xx_ring_rx_refill(struct ag71xx *ag) { struct ag71xx_ring *ring = &ag->rx_ring; + int ring_mask = BIT(ring->order) - 1; unsigned int count; int offset = ag71xx_buffer_offset(ag); count = 0; for (; ring->curr - ring->dirty > 0; ring->dirty++) { + struct ag71xx_desc *desc; unsigned int i; - i = ring->dirty % ring->size; + i = ring->dirty & ring_mask; + desc = ag71xx_ring_desc(ring, i); if (!ring->buf[i].rx_buf && - !ag71xx_fill_rx_buf(ag, &ring->buf[i], offset)) + !ag71xx_fill_rx_buf(ag, &ring->buf[i], offset, + napi_alloc_frag)) break; - ring->buf[i].desc->ctrl = DESC_EMPTY; + desc->ctrl = DESC_EMPTY; count++; } @@ -426,15 +453,18 @@ static void ag71xx_hw_stop(struct ag71xx *ag) static void ag71xx_hw_setup(struct ag71xx *ag) { struct ag71xx_platform_data *pdata = ag71xx_get_pdata(ag); + u32 init = MAC_CFG1_INIT; /* setup MAC configuration registers */ - ag71xx_wr(ag, AG71XX_REG_MAC_CFG1, MAC_CFG1_INIT); + if (pdata->use_flow_control) + init |= MAC_CFG1_TFC | MAC_CFG1_RFC; + ag71xx_wr(ag, AG71XX_REG_MAC_CFG1, init); ag71xx_sb(ag, AG71XX_REG_MAC_CFG2, MAC_CFG2_PAD_CRC_EN | MAC_CFG2_LEN_CHECK); - /* setup max frame length */ - ag71xx_wr(ag, AG71XX_REG_MAC_MFL, AG71XX_TX_MTU_LEN); + /* setup max frame length to zero */ + ag71xx_wr(ag, AG71XX_REG_MAC_MFL, 0); /* setup FIFO configuration registers */ ag71xx_wr(ag, AG71XX_REG_FIFO_CFG0, FIFO_CFG0_INIT); @@ -463,18 +493,18 @@ static void ag71xx_hw_init(struct ag71xx *ag) reset_mask &= ~(AR71XX_RESET_GE0_PHY | AR71XX_RESET_GE1_PHY); ath79_device_reset_set(reset_phy); - mdelay(50); + msleep(50); ath79_device_reset_clear(reset_phy); - mdelay(200); + msleep(200); } ag71xx_sb(ag, AG71XX_REG_MAC_CFG1, MAC_CFG1_SR); udelay(20); ath79_device_reset_set(reset_mask); - mdelay(100); + msleep(100); ath79_device_reset_clear(reset_mask); - mdelay(200); + msleep(200); ag71xx_hw_setup(ag); @@ -486,14 +516,18 @@ static void ag71xx_fast_reset(struct ag71xx *ag) struct ag71xx_platform_data *pdata = ag71xx_get_pdata(ag); struct net_device *dev = ag->dev; u32 reset_mask = pdata->reset_bit; - u32 rx_ds, tx_ds; + u32 rx_ds; u32 mii_reg; reset_mask &= AR71XX_RESET_GE0_MAC | AR71XX_RESET_GE1_MAC; + ag71xx_hw_stop(ag); + wmb(); + mii_reg = ag71xx_rr(ag, AG71XX_REG_MII_CFG); rx_ds = ag71xx_rr(ag, AG71XX_REG_RX_DESC); - tx_ds = ag71xx_rr(ag, AG71XX_REG_TX_DESC); + + ag71xx_tx_packets(ag, true); ath79_device_reset_set(reset_mask); udelay(10); @@ -502,9 +536,16 @@ static void ag71xx_fast_reset(struct ag71xx *ag) ag71xx_dma_reset(ag); ag71xx_hw_setup(ag); + ag->tx_ring.curr = 0; + ag->tx_ring.dirty = 0; + netdev_reset_queue(ag->dev); + + /* setup max frame length */ + ag71xx_wr(ag, AG71XX_REG_MAC_MFL, + ag71xx_max_frame_len(ag->dev->mtu)); ag71xx_wr(ag, AG71XX_REG_RX_DESC, rx_ds); - ag71xx_wr(ag, AG71XX_REG_TX_DESC, tx_ds); + ag71xx_wr(ag, AG71XX_REG_TX_DESC, ag->tx_ring.descs_dma); ag71xx_wr(ag, AG71XX_REG_MII_CFG, mii_reg); ag71xx_hw_set_macaddr(ag, dev->dev_addr); @@ -517,16 +558,20 @@ static void ag71xx_hw_start(struct ag71xx *ag) /* enable interrupts */ ag71xx_wr(ag, AG71XX_REG_INT_ENABLE, AG71XX_INT_INIT); + + netif_wake_queue(ag->dev); } -void ag71xx_link_adjust(struct ag71xx *ag) +static void +__ag71xx_link_adjust(struct ag71xx *ag, bool update) { struct ag71xx_platform_data *pdata = ag71xx_get_pdata(ag); u32 cfg2; u32 ifctl; u32 fifo5; + u32 fifo3; - if (!ag->link) { + if (!ag->link && update) { ag71xx_hw_stop(ag); netif_carrier_off(ag->dev); if (netif_msg_link(ag)) @@ -565,13 +610,20 @@ void ag71xx_link_adjust(struct ag71xx *ag) } if (pdata->is_ar91xx) - ag71xx_wr(ag, AG71XX_REG_FIFO_CFG3, 0x00780fff); + fifo3 = 0x00780fff; else if (pdata->is_ar724x) - ag71xx_wr(ag, AG71XX_REG_FIFO_CFG3, pdata->fifo_cfg3); + fifo3 = pdata->fifo_cfg3; else - ag71xx_wr(ag, AG71XX_REG_FIFO_CFG3, 0x008001ff); + fifo3 = 0x008001ff; + + if (ag->tx_ring.desc_split) { + fifo3 &= 0xffff; + fifo3 |= ((2048 - ag->tx_ring.desc_split) / 4) << 16; + } - if (pdata->set_speed) + ag71xx_wr(ag, AG71XX_REG_FIFO_CFG3, fifo3); + + if (update && pdata->set_speed) pdata->set_speed(ag->speed); ag71xx_wr(ag, AG71XX_REG_MAC_CFG2, cfg2); @@ -580,7 +632,7 @@ void ag71xx_link_adjust(struct ag71xx *ag) ag71xx_hw_start(ag); netif_carrier_on(ag->dev); - if (netif_msg_link(ag)) + if (update && netif_msg_link(ag)) pr_info("%s: link up (%sMbps/%s duplex)\n", ag->dev->name, ag71xx_speed_str(ag), @@ -604,26 +656,65 @@ void ag71xx_link_adjust(struct ag71xx *ag) ag71xx_rr(ag, AG71XX_REG_MAC_IFCTL)); } -static int ag71xx_open(struct net_device *dev) +void ag71xx_link_adjust(struct ag71xx *ag) +{ + __ag71xx_link_adjust(ag, true); +} + +static int ag71xx_hw_enable(struct ag71xx *ag) { - struct ag71xx *ag = netdev_priv(dev); int ret; ret = ag71xx_rings_init(ag); if (ret) - goto err; + return ret; napi_enable(&ag->napi); - - netif_carrier_off(dev); - ag71xx_phy_start(ag); - ag71xx_wr(ag, AG71XX_REG_TX_DESC, ag->tx_ring.descs_dma); ag71xx_wr(ag, AG71XX_REG_RX_DESC, ag->rx_ring.descs_dma); + netif_start_queue(ag->dev); + + return 0; +} + +static void ag71xx_hw_disable(struct ag71xx *ag) +{ + unsigned long flags; + + spin_lock_irqsave(&ag->lock, flags); + + netif_stop_queue(ag->dev); + + ag71xx_hw_stop(ag); + ag71xx_dma_reset(ag); + + napi_disable(&ag->napi); + del_timer_sync(&ag->oom_timer); + spin_unlock_irqrestore(&ag->lock, flags); + + ag71xx_rings_cleanup(ag); +} + +static int ag71xx_open(struct net_device *dev) +{ + struct ag71xx *ag = netdev_priv(dev); + unsigned int max_frame_len; + int ret; + + netif_carrier_off(dev); + max_frame_len = ag71xx_max_frame_len(dev->mtu); + ag->rx_buf_size = SKB_DATA_ALIGN(max_frame_len + NET_SKB_PAD + NET_IP_ALIGN); + + /* setup max frame length */ + ag71xx_wr(ag, AG71XX_REG_MAC_MFL, max_frame_len); ag71xx_hw_set_macaddr(ag, dev->dev_addr); - netif_start_queue(dev); + ret = ag71xx_hw_enable(ag); + if (ret) + goto err; + + ag71xx_phy_start(ag); return 0; @@ -635,26 +726,61 @@ err: static int ag71xx_stop(struct net_device *dev) { struct ag71xx *ag = netdev_priv(dev); - unsigned long flags; netif_carrier_off(dev); ag71xx_phy_stop(ag); + ag71xx_hw_disable(ag); - spin_lock_irqsave(&ag->lock, flags); + return 0; +} - netif_stop_queue(dev); +static int ag71xx_fill_dma_desc(struct ag71xx_ring *ring, u32 addr, int len) +{ + int i; + struct ag71xx_desc *desc; + int ring_mask = BIT(ring->order) - 1; + int ndesc = 0; + int split = ring->desc_split; - ag71xx_hw_stop(ag); - ag71xx_dma_reset(ag); + if (!split) + split = len; - napi_disable(&ag->napi); - del_timer_sync(&ag->oom_timer); + while (len > 0) { + unsigned int cur_len = len; - spin_unlock_irqrestore(&ag->lock, flags); + i = (ring->curr + ndesc) & ring_mask; + desc = ag71xx_ring_desc(ring, i); - ag71xx_rings_cleanup(ag); + if (!ag71xx_desc_empty(desc)) + return -1; - return 0; + if (cur_len > split) { + cur_len = split; + + /* + * TX will hang if DMA transfers <= 4 bytes, + * make sure next segment is more than 4 bytes long. + */ + if (len <= split + 4) + cur_len -= 4; + } + + desc->data = addr; + addr += cur_len; + len -= cur_len; + + if (len > 0) + cur_len |= DESC_MORE; + + /* prevent early tx attempt of this descriptor */ + if (!ndesc) + cur_len |= DESC_EMPTY; + + desc->ctrl = cur_len; + ndesc++; + } + + return ndesc; } static netdev_tx_t ag71xx_hard_start_xmit(struct sk_buff *skb, @@ -662,20 +788,16 @@ static netdev_tx_t ag71xx_hard_start_xmit(struct sk_buff *skb, { struct ag71xx *ag = netdev_priv(dev); struct ag71xx_ring *ring = &ag->tx_ring; + int ring_mask = BIT(ring->order) - 1; + int ring_size = BIT(ring->order); struct ag71xx_desc *desc; dma_addr_t dma_addr; - int i; - - i = ring->curr % ring->size; - desc = ring->buf[i].desc; - - if (!ag71xx_desc_empty(desc)) - goto err_drop; + int i, n, ring_min; if (ag71xx_has_ar8216(ag)) ag71xx_add_ar8216_header(ag, skb); - if (skb->len <= 0) { + if (skb->len <= 4) { DBG("%s: packet len is too small\n", ag->dev->name); goto err_drop; } @@ -683,20 +805,35 @@ static netdev_tx_t ag71xx_hard_start_xmit(struct sk_buff *skb, dma_addr = dma_map_single(&dev->dev, skb->data, skb->len, DMA_TO_DEVICE); - netdev_sent_queue(dev, skb->len); + i = ring->curr & ring_mask; + desc = ag71xx_ring_desc(ring, i); + + /* setup descriptor fields */ + n = ag71xx_fill_dma_desc(ring, (u32) dma_addr, skb->len & ag->desc_pktlen_mask); + if (n < 0) + goto err_drop_unmap; + + i = (ring->curr + n - 1) & ring_mask; + ring->buf[i].len = skb->len; ring->buf[i].skb = skb; ring->buf[i].timestamp = jiffies; - /* setup descriptor fields */ - desc->data = (u32) dma_addr; - desc->ctrl = (skb->len & DESC_PKTLEN_M); + netdev_sent_queue(dev, skb->len); + + skb_tx_timestamp(skb); + + desc->ctrl &= ~DESC_EMPTY; + ring->curr += n; /* flush descriptor */ wmb(); - ring->curr++; - if (ring->curr == (ring->dirty + ring->size)) { - DBG("%s: tx queue full\n", ag->dev->name); + ring_min = 2; + if (ring->desc_split) + ring_min *= AG71XX_TX_RING_DS_PER_PKT; + + if (ring->curr - ring->dirty >= ring_size - ring_min) { + DBG("%s: tx queue full\n", dev->name); netif_stop_queue(dev); } @@ -707,6 +844,9 @@ static netdev_tx_t ag71xx_hard_start_xmit(struct sk_buff *skb, return NETDEV_TX_OK; +err_drop_unmap: + dma_unmap_single(&dev->dev, dma_addr, skb->len, DMA_TO_DEVICE); + err_drop: dev->stats.tx_dropped++; @@ -771,21 +911,19 @@ static void ag71xx_tx_timeout(struct net_device *dev) if (netif_msg_tx_err(ag)) pr_info("%s: tx timeout\n", ag->dev->name); - schedule_work(&ag->restart_work); + schedule_delayed_work(&ag->restart_work, 1); } static void ag71xx_restart_work_func(struct work_struct *work) { - struct ag71xx *ag = container_of(work, struct ag71xx, restart_work); - - if (ag71xx_get_pdata(ag)->is_ar724x) { - ag->link = 0; - ag71xx_link_adjust(ag); - return; - } - - ag71xx_stop(ag->dev); - ag71xx_open(ag->dev); + struct ag71xx *ag = container_of(work, struct ag71xx, restart_work.work); + + rtnl_lock(); + ag71xx_hw_disable(ag); + ag71xx_hw_enable(ag); + if (ag->link) + __ag71xx_link_adjust(ag, false); + rtnl_unlock(); } static bool ag71xx_check_dma_stuck(struct ag71xx *ag, unsigned long timestamp) @@ -811,46 +949,69 @@ static bool ag71xx_check_dma_stuck(struct ag71xx *ag, unsigned long timestamp) return false; } -static int ag71xx_tx_packets(struct ag71xx *ag) +static int ag71xx_tx_packets(struct ag71xx *ag, bool flush) { struct ag71xx_ring *ring = &ag->tx_ring; struct ag71xx_platform_data *pdata = ag71xx_get_pdata(ag); + bool dma_stuck = false; + int ring_mask = BIT(ring->order) - 1; + int ring_size = BIT(ring->order); int sent = 0; int bytes_compl = 0; + int n = 0; DBG("%s: processing TX ring\n", ag->dev->name); - while (ring->dirty != ring->curr) { - unsigned int i = ring->dirty % ring->size; - struct ag71xx_desc *desc = ring->buf[i].desc; + while (ring->dirty + n != ring->curr) { + unsigned int i = (ring->dirty + n) & ring_mask; + struct ag71xx_desc *desc = ag71xx_ring_desc(ring, i); struct sk_buff *skb = ring->buf[i].skb; - if (!ag71xx_desc_empty(desc)) { - if (pdata->is_ar7240 && - ag71xx_check_dma_stuck(ag, ring->buf[i].timestamp)) - schedule_work(&ag->restart_work); + if (!flush && !ag71xx_desc_empty(desc)) { + if (pdata->is_ar724x && + ag71xx_check_dma_stuck(ag, ring->buf[i].timestamp)) { + schedule_delayed_work(&ag->restart_work, HZ / 2); + dma_stuck = true; + } break; } - ag71xx_wr(ag, AG71XX_REG_TX_STATUS, TX_STATUS_PS); + if (flush) + desc->ctrl |= DESC_EMPTY; - bytes_compl += skb->len; - ag->dev->stats.tx_bytes += skb->len; - ag->dev->stats.tx_packets++; + n++; + if (!skb) + continue; dev_kfree_skb_any(skb); ring->buf[i].skb = NULL; - ring->dirty++; + bytes_compl += ring->buf[i].len; + sent++; + ring->dirty += n; + + while (n > 0) { + ag71xx_wr(ag, AG71XX_REG_TX_STATUS, TX_STATUS_PS); + n--; + } } DBG("%s: %d packets sent out\n", ag->dev->name, sent); + ag->dev->stats.tx_bytes += bytes_compl; + ag->dev->stats.tx_packets += sent; + + if (!sent) + return 0; + netdev_completed_queue(ag->dev, sent, bytes_compl); - if ((ring->curr - ring->dirty) < (ring->size * 3) / 4) + if ((ring->curr - ring->dirty) < (ring_size * 3) / 4) netif_wake_queue(ag->dev); + if (!dma_stuck) + cancel_delayed_work(&ag->restart_work); + return sent; } @@ -859,41 +1020,46 @@ static int ag71xx_rx_packets(struct ag71xx *ag, int limit) struct net_device *dev = ag->dev; struct ag71xx_ring *ring = &ag->rx_ring; int offset = ag71xx_buffer_offset(ag); + unsigned int pktlen_mask = ag->desc_pktlen_mask; + int ring_mask = BIT(ring->order) - 1; + int ring_size = BIT(ring->order); + struct sk_buff_head queue; + struct sk_buff *skb; int done = 0; DBG("%s: rx packets, limit=%d, curr=%u, dirty=%u\n", dev->name, limit, ring->curr, ring->dirty); + skb_queue_head_init(&queue); + while (done < limit) { - unsigned int i = ring->curr % ring->size; - struct ag71xx_desc *desc = ring->buf[i].desc; - struct sk_buff *skb; + unsigned int i = ring->curr & ring_mask; + struct ag71xx_desc *desc = ag71xx_ring_desc(ring, i); int pktlen; int err = 0; if (ag71xx_desc_empty(desc)) break; - if ((ring->dirty + ring->size) == ring->curr) { + if ((ring->dirty + ring_size) == ring->curr) { ag71xx_assert(0); break; } ag71xx_wr(ag, AG71XX_REG_RX_STATUS, RX_STATUS_PR); - pktlen = ag71xx_desc_pktlen(desc); + pktlen = desc->ctrl & pktlen_mask; pktlen -= ETH_FCS_LEN; dma_unmap_single(&dev->dev, ring->buf[i].dma_addr, - AG71XX_RX_BUF_SIZE, DMA_FROM_DEVICE); + ag->rx_buf_size, DMA_FROM_DEVICE); - dev->last_rx = jiffies; dev->stats.rx_packets++; dev->stats.rx_bytes += pktlen; - skb = build_skb(ring->buf[i].rx_buf, 0); + skb = build_skb(ring->buf[i].rx_buf, ag71xx_buffer_size(ag)); if (!skb) { - kfree(ring->buf[i].rx_buf); + skb_free_frag(ring->buf[i].rx_buf); goto next; } @@ -909,8 +1075,7 @@ static int ag71xx_rx_packets(struct ag71xx *ag, int limit) } else { skb->dev = dev; skb->ip_summed = CHECKSUM_NONE; - skb->protocol = eth_type_trans(skb, dev); - netif_receive_skb(skb); + __skb_queue_tail(&queue, skb); } next: @@ -922,6 +1087,11 @@ next: ag71xx_ring_rx_refill(ag); + while ((skb = __skb_dequeue(&queue)) != NULL) { + skb->protocol = eth_type_trans(skb, dev); + napi_gro_receive(&ag->napi, skb); + } + DBG("%s: rx finish, curr=%u, dirty=%u, done=%d\n", dev->name, ring->curr, ring->dirty, done); @@ -933,22 +1103,22 @@ static int ag71xx_poll(struct napi_struct *napi, int limit) struct ag71xx *ag = container_of(napi, struct ag71xx, napi); struct ag71xx_platform_data *pdata = ag71xx_get_pdata(ag); struct net_device *dev = ag->dev; - struct ag71xx_ring *rx_ring; + struct ag71xx_ring *rx_ring = &ag->rx_ring; + int rx_ring_size = BIT(rx_ring->order); unsigned long flags; u32 status; int tx_done; int rx_done; pdata->ddr_flush(); - tx_done = ag71xx_tx_packets(ag); + tx_done = ag71xx_tx_packets(ag, false); DBG("%s: processing RX ring\n", dev->name); rx_done = ag71xx_rx_packets(ag, limit); ag71xx_debugfs_update_napi_stats(ag, rx_done, tx_done); - rx_ring = &ag->rx_ring; - if (rx_ring->buf[rx_ring->dirty % rx_ring->size].rx_buf == NULL) + if (rx_ring->buf[rx_ring->dirty % rx_ring_size].rx_buf == NULL) goto oom; status = ag71xx_rr(ag, AG71XX_REG_RX_STATUS); @@ -971,7 +1141,7 @@ static int ag71xx_poll(struct napi_struct *napi, int limit) DBG("%s: disable polling mode, rx=%d, tx=%d,limit=%d\n", dev->name, rx_done, tx_done, limit); - napi_complete(napi); + napi_complete_done(napi, rx_done); /* enable interrupts */ spin_lock_irqsave(&ag->lock, flags); @@ -983,14 +1153,14 @@ static int ag71xx_poll(struct napi_struct *napi, int limit) more: DBG("%s: stay in polling mode, rx=%d, tx=%d, limit=%d\n", dev->name, rx_done, tx_done, limit); - return rx_done; + return limit; oom: if (netif_msg_rx_err(ag)) pr_info("%s: out of memory\n", dev->name); mod_timer(&ag->oom_timer, jiffies + AG71XX_OOM_REFILL); - napi_complete(napi); + napi_complete_done(napi, rx_done); return 0; } @@ -1042,13 +1212,29 @@ static void ag71xx_netpoll(struct net_device *dev) } #endif +static int ag71xx_change_mtu(struct net_device *dev, int new_mtu) +{ + struct ag71xx *ag = netdev_priv(dev); + unsigned int max_frame_len; + + max_frame_len = ag71xx_max_frame_len(new_mtu); + if (new_mtu < 68 || max_frame_len > ag->max_frame_len) + return -EINVAL; + + if (netif_running(dev)) + return -EBUSY; + + dev->mtu = new_mtu; + return 0; +} + static const struct net_device_ops ag71xx_netdev_ops = { .ndo_open = ag71xx_open, .ndo_stop = ag71xx_stop, .ndo_start_xmit = ag71xx_hard_start_xmit, .ndo_do_ioctl = ag71xx_do_ioctl, .ndo_tx_timeout = ag71xx_tx_timeout, - .ndo_change_mtu = eth_change_mtu, + .ndo_change_mtu = ag71xx_change_mtu, .ndo_set_mac_address = eth_mac_addr, .ndo_validate_addr = eth_validate_addr, #ifdef CONFIG_NET_POLL_CONTROLLER @@ -1056,7 +1242,7 @@ static const struct net_device_ops ag71xx_netdev_ops = { #endif }; -static __devinit const char *ag71xx_get_phy_if_mode_name(phy_interface_t mode) +static const char *ag71xx_get_phy_if_mode_name(phy_interface_t mode) { switch (mode) { case PHY_INTERFACE_MODE_MII: @@ -1077,13 +1263,13 @@ static __devinit const char *ag71xx_get_phy_if_mode_name(phy_interface_t mode) } -static int __devinit ag71xx_probe(struct platform_device *pdev) +static int ag71xx_probe(struct platform_device *pdev) { struct net_device *dev; struct resource *res; struct ag71xx *ag; struct ag71xx_platform_data *pdata; - int err; + int tx_size, err; pdata = pdev->dev.platform_data; if (!pdata) { @@ -1105,6 +1291,9 @@ static int __devinit ag71xx_probe(struct platform_device *pdev) goto err_out; } + if (!pdata->max_frame_len || !pdata->desc_pktlen_mask) + return -EINVAL; + SET_NETDEV_DEV(dev, &pdev->dev); ag = netdev_priv(dev); @@ -1130,7 +1319,7 @@ static int __devinit ag71xx_probe(struct platform_device *pdev) dev->irq = platform_get_irq(pdev, 0); err = request_irq(dev->irq, ag71xx_interrupt, - IRQF_DISABLED, + 0x0, dev->name, dev); if (err) { dev_err(&pdev->dev, "unable to request IRQ %d\n", dev->irq); @@ -1141,14 +1330,23 @@ static int __devinit ag71xx_probe(struct platform_device *pdev) dev->netdev_ops = &ag71xx_netdev_ops; dev->ethtool_ops = &ag71xx_ethtool_ops; - INIT_WORK(&ag->restart_work, ag71xx_restart_work_func); + INIT_DELAYED_WORK(&ag->restart_work, ag71xx_restart_work_func); init_timer(&ag->oom_timer); ag->oom_timer.data = (unsigned long) dev; ag->oom_timer.function = ag71xx_oom_timer_handler; - ag->tx_ring.size = AG71XX_TX_RING_SIZE_DEFAULT; - ag->rx_ring.size = AG71XX_RX_RING_SIZE_DEFAULT; + tx_size = AG71XX_TX_RING_SIZE_DEFAULT; + ag->rx_ring.order = ag71xx_ring_size_order(AG71XX_RX_RING_SIZE_DEFAULT); + + ag->max_frame_len = pdata->max_frame_len; + ag->desc_pktlen_mask = pdata->desc_pktlen_mask; + + if (!pdata->is_ar724x && !pdata->is_ar91xx) { + ag->tx_ring.desc_split = AG71XX_TX_RING_SPLIT; + tx_size *= AG71XX_TX_RING_DS_PER_PKT; + } + ag->tx_ring.order = ag71xx_ring_size_order(tx_size); ag->stop_desc = dma_alloc_coherent(NULL, sizeof(struct ag71xx_desc), &ag->stop_desc_dma, GFP_KERNEL); @@ -1164,16 +1362,6 @@ static int __devinit ag71xx_probe(struct platform_device *pdev) netif_napi_add(dev, &ag->napi, ag71xx_poll, AG71XX_NAPI_WEIGHT); - err = register_netdev(dev); - if (err) { - dev_err(&pdev->dev, "unable to register net device\n"); - goto err_free_desc; - } - - pr_info("%s: Atheros AG71xx at 0x%08lx, irq %d, mode:%s\n", - dev->name, dev->base_addr, dev->irq, - ag71xx_get_phy_if_mode_name(pdata->phy_if_mode)); - ag71xx_dump_regs(ag); ag71xx_hw_init(ag); @@ -1182,7 +1370,7 @@ static int __devinit ag71xx_probe(struct platform_device *pdev) err = ag71xx_phy_connect(ag); if (err) - goto err_unregister_netdev; + goto err_free_desc; err = ag71xx_debugfs_init(ag); if (err) @@ -1190,12 +1378,22 @@ static int __devinit ag71xx_probe(struct platform_device *pdev) platform_set_drvdata(pdev, dev); + err = register_netdev(dev); + if (err) { + dev_err(&pdev->dev, "unable to register net device\n"); + goto err_debugfs_exit; + } + + pr_info("%s: Atheros AG71xx at 0x%08lx, irq %d, mode:%s\n", + dev->name, dev->base_addr, dev->irq, + ag71xx_get_phy_if_mode_name(pdata->phy_if_mode)); + return 0; +err_debugfs_exit: + ag71xx_debugfs_exit(ag); err_phy_disconnect: ag71xx_phy_disconnect(ag); -err_unregister_netdev: - unregister_netdev(dev); err_free_desc: dma_free_coherent(NULL, sizeof(struct ag71xx_desc), ag->stop_desc, ag->stop_desc_dma); @@ -1210,7 +1408,7 @@ err_out: return err; } -static int __devexit ag71xx_remove(struct platform_device *pdev) +static int ag71xx_remove(struct platform_device *pdev) { struct net_device *dev = platform_get_drvdata(pdev); @@ -1231,7 +1429,7 @@ static int __devexit ag71xx_remove(struct platform_device *pdev) static struct platform_driver ag71xx_driver = { .probe = ag71xx_probe, - .remove = __exit_p(ag71xx_remove), + .remove = ag71xx_remove, .driver = { .name = AG71XX_DRV_NAME, }