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=d7c27393a622e5a13a48956a82dc251b10a9493c;hp=a129a6f2918bd9d6b4926132a72db229b8cff38f;hb=26b8db253745b0591bfffa21f02323428f11a88f;hpb=9be1e508f98abad12d099b26e2087c5e95fe2d64 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 a129a6f291..d7c27393a6 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,13 +136,16 @@ 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++; } @@ -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); - ring->buf[i].desc->ctrl = DESC_EMPTY; + desc->next = (u32) (ring->descs_dma + + AG71XX_DESC_SIZE * ((i + 1) & ring_mask)); + + 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, ag->rx_buf_size, DMA_FROM_DEVICE); - kfree(ring->buf[i].rx_buf); + 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(ag->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, ag->rx_buf_size, DMA_FROM_DEVICE); - buf->desc->data = (u32) buf->dma_addr + offset; + 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->builtin_switch) + 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, ag->max_frame_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,16 @@ 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); ath79_device_reset_set(reset_mask); udelay(10); @@ -502,9 +534,17 @@ static void ag71xx_fast_reset(struct ag71xx *ag) ag71xx_dma_reset(ag); ag71xx_hw_setup(ag); + ag71xx_tx_packets(ag, true); + 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 +557,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 +609,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 +631,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,28 +655,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) { - struct ag71xx *ag = netdev_priv(dev); - int ret; + __ag71xx_link_adjust(ag, true); +} - ag->rx_buf_size = ag->max_frame_len + NET_SKB_PAD + NET_IP_ALIGN; +static int ag71xx_hw_enable(struct ag71xx *ag) +{ + 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; @@ -637,26 +725,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, @@ -664,20 +787,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; } @@ -685,21 +804,33 @@ 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 & ag->desc_pktlen_mask; + netdev_sent_queue(dev, skb->len); + + 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); } @@ -710,6 +841,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++; @@ -781,14 +915,12 @@ 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); + 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) @@ -814,48 +946,61 @@ 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); + 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; - int len = ring->buf[i].len; - if (!ag71xx_desc_empty(desc)) { - if (pdata->is_ar7240 && + if (!flush && !ag71xx_desc_empty(desc)) { + if (pdata->is_ar724x && ag71xx_check_dma_stuck(ag, ring->buf[i].timestamp)) schedule_work(&ag->restart_work); break; } - ag71xx_wr(ag, AG71XX_REG_TX_STATUS, TX_STATUS_PS); + if (flush) + desc->ctrl |= DESC_EMPTY; - bytes_compl += len; - ag->dev->stats.tx_bytes += 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); return sent; @@ -867,22 +1012,27 @@ static int ag71xx_rx_packets(struct ag71xx *ag, int limit) 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; } @@ -898,9 +1048,9 @@ static int ag71xx_rx_packets(struct ag71xx *ag, int limit) 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; } @@ -916,8 +1066,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: @@ -929,6 +1078,11 @@ next: ag71xx_ring_rx_refill(ag); + while ((skb = __skb_dequeue(&queue)) != NULL) { + skb->protocol = eth_type_trans(skb, dev); + netif_receive_skb(skb); + } + DBG("%s: rx finish, curr=%u, dirty=%u, done=%d\n", dev->name, ring->curr, ring->dirty, done); @@ -940,22 +1094,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); @@ -990,7 +1144,7 @@ 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)) @@ -1052,11 +1206,15 @@ static void ag71xx_netpoll(struct net_device *dev) static int ag71xx_change_mtu(struct net_device *dev, int new_mtu) { struct ag71xx *ag = netdev_priv(dev); + unsigned int max_frame_len; - if (new_mtu < 68 || - new_mtu > ag->max_frame_len - ETH_HLEN - ETH_FCS_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; } @@ -1102,7 +1260,7 @@ static int ag71xx_probe(struct platform_device *pdev) struct resource *res; struct ag71xx *ag; struct ag71xx_platform_data *pdata; - int err; + int tx_size, err; pdata = pdev->dev.platform_data; if (!pdata) { @@ -1124,6 +1282,9 @@ static int 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); @@ -1149,7 +1310,7 @@ static int 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); @@ -1166,11 +1327,17 @@ static int ag71xx_probe(struct platform_device *pdev) 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 = AG71XX_TX_MTU_LEN; - ag->desc_pktlen_mask = DESC_PKTLEN_MASK; + 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);