Changeset 27040


Ignore:
Timestamp:
2011-06-01T00:53:09+02:00 (7 years ago)
Author:
juhosg
Message:

ar71xx: ag71xx: prepare to make ring sizes configurable

Location:
trunk/target/linux/ar71xx/files/drivers/net/ag71xx
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar71xx/files/drivers/net/ag71xx/ag71xx.h

    r27039 r27040  
    5555        (AG71XX_RX_PKT_RESERVE + ETH_FRAME_LEN + ETH_FCS_LEN + VLAN_HLEN) 
    5656 
    57 #define AG71XX_TX_RING_SIZE     64 
    58 #define AG71XX_TX_THRES_STOP    (AG71XX_TX_RING_SIZE - 4) 
    59 #define AG71XX_TX_THRES_WAKEUP  \ 
    60                 (AG71XX_TX_RING_SIZE - (AG71XX_TX_RING_SIZE / 4)) 
    61  
    62 #define AG71XX_RX_RING_SIZE     128 
     57#define AG71XX_TX_RING_SIZE_DEFAULT     64 
     58#define AG71XX_RX_RING_SIZE_DEFAULT     128 
    6359 
    6460#ifdef CONFIG_AG71XX_DEBUG 
  • trunk/target/linux/ar71xx/files/drivers/net/ag71xx/ag71xx_debugfs.c

    r26854 r27040  
    156156                              struct ag71xx *ag, 
    157157                              struct ag71xx_ring *ring, 
    158                               unsigned ring_size, 
    159158                              unsigned desc_reg) 
    160159{ 
     
    169168        int i; 
    170169 
    171         buflen = (ring_size * DESC_PRINT_LEN); 
     170        buflen = (ring->size * DESC_PRINT_LEN); 
    172171        buf = kmalloc(buflen, GFP_KERNEL); 
    173172        if (!buf) 
     
    180179        spin_lock_irqsave(&ag->lock, flags); 
    181180 
    182         curr = (ring->curr % ring_size); 
    183         dirty = (ring->dirty % ring_size); 
     181        curr = (ring->curr % ring->size); 
     182        dirty = (ring->dirty % ring->size); 
    184183        desc_hw = ag71xx_rr(ag, desc_reg); 
    185         for (i = 0; i < ring_size; i++) { 
     184        for (i = 0; i < ring->size; i++) { 
    186185                struct ag71xx_buf *ab = &ring->buf[i]; 
    187186                u32 desc_dma = ((u32) ring->descs_dma) + i * ring->desc_size; 
     
    215214 
    216215        return read_file_ring(file, user_buf, count, ppos, ag, &ag->tx_ring, 
    217                               AG71XX_TX_RING_SIZE, AG71XX_REG_TX_DESC); 
     216                              AG71XX_REG_TX_DESC); 
    218217} 
    219218 
     
    230229 
    231230        return read_file_ring(file, user_buf, count, ppos, ag, &ag->rx_ring, 
    232                               AG71XX_RX_RING_SIZE, AG71XX_REG_RX_DESC); 
     231                              AG71XX_REG_RX_DESC); 
    233232} 
    234233 
  • trunk/target/linux/ar71xx/files/drivers/net/ag71xx/ag71xx_main.c

    r27035 r27040  
    9191} 
    9292 
    93 static int ag71xx_ring_alloc(struct ag71xx_ring *ring, unsigned int size) 
     93static int ag71xx_ring_alloc(struct ag71xx_ring *ring) 
    9494{ 
    9595        int err; 
     
    104104        } 
    105105 
    106         ring->descs_cpu = dma_alloc_coherent(NULL, size * ring->desc_size, 
     106        ring->descs_cpu = dma_alloc_coherent(NULL, ring->size * ring->desc_size, 
    107107                                             &ring->descs_dma, GFP_ATOMIC); 
    108108        if (!ring->descs_cpu) { 
     
    111111        } 
    112112 
    113         ring->size = size; 
    114  
    115         ring->buf = kzalloc(size * sizeof(*ring->buf), GFP_KERNEL); 
     113 
     114        ring->buf = kzalloc(ring->size * sizeof(*ring->buf), GFP_KERNEL); 
    116115        if (!ring->buf) { 
    117116                err = -ENOMEM; 
     
    119118        } 
    120119 
    121         for (i = 0; i < size; i++) { 
     120        for (i = 0; i < ring->size; i++) { 
    122121                int idx = i * ring->desc_size; 
    123122                ring->buf[i].desc = (struct ag71xx_desc *)&ring->descs_cpu[idx]; 
     
    138137 
    139138        while (ring->curr != ring->dirty) { 
    140                 u32 i = ring->dirty % AG71XX_TX_RING_SIZE; 
     139                u32 i = ring->dirty % ring->size; 
    141140 
    142141                if (!ag71xx_desc_empty(ring->buf[i].desc)) { 
     
    163162        int i; 
    164163 
    165         for (i = 0; i < AG71XX_TX_RING_SIZE; i++) { 
     164        for (i = 0; i < ring->size; i++) { 
    166165                ring->buf[i].desc->next = (u32) (ring->descs_dma + 
    167                         ring->desc_size * ((i + 1) % AG71XX_TX_RING_SIZE)); 
     166                        ring->desc_size * ((i + 1) % ring->size)); 
    168167 
    169168                ring->buf[i].desc->ctrl = DESC_EMPTY; 
     
    186185                return; 
    187186 
    188         for (i = 0; i < AG71XX_RX_RING_SIZE; i++) 
     187        for (i = 0; i < ring->size; i++) 
    189188                if (ring->buf[i].skb) { 
    190189                        dma_unmap_single(&ag->dev->dev, ring->buf[i].dma_addr, 
     
    220219 
    221220        ret = 0; 
    222         for (i = 0; i < AG71XX_RX_RING_SIZE; i++) { 
     221        for (i = 0; i < ring->size; i++) { 
    223222                ring->buf[i].desc->next = (u32) (ring->descs_dma + 
    224                         ring->desc_size * ((i + 1) % AG71XX_RX_RING_SIZE)); 
     223                        ring->desc_size * ((i + 1) % ring->size)); 
    225224 
    226225                DBG("ag71xx: RX desc at %p, next is %08x\n", 
     
    229228        } 
    230229 
    231         for (i = 0; i < AG71XX_RX_RING_SIZE; i++) { 
     230        for (i = 0; i < ring->size; i++) { 
    232231                struct sk_buff *skb; 
    233232                dma_addr_t dma_addr; 
     
    270269                unsigned int i; 
    271270 
    272                 i = ring->dirty % AG71XX_RX_RING_SIZE; 
     271                i = ring->dirty % ring->size; 
    273272 
    274273                if (ring->buf[i].skb == NULL) { 
     
    308307        int ret; 
    309308 
    310         ret = ag71xx_ring_alloc(&ag->tx_ring, AG71XX_TX_RING_SIZE); 
     309        ret = ag71xx_ring_alloc(&ag->tx_ring); 
    311310        if (ret) 
    312311                return ret; 
     
    314313        ag71xx_ring_tx_init(ag); 
    315314 
    316         ret = ag71xx_ring_alloc(&ag->rx_ring, AG71XX_RX_RING_SIZE); 
     315        ret = ag71xx_ring_alloc(&ag->rx_ring); 
    317316        if (ret) 
    318317                return ret; 
     
    632631        int i; 
    633632 
    634         i = ring->curr % AG71XX_TX_RING_SIZE; 
     633        i = ring->curr % ring->size; 
    635634        desc = ring->buf[i].desc; 
    636635 
     
    660659 
    661660        ring->curr++; 
    662         if (ring->curr == (ring->dirty + AG71XX_TX_THRES_STOP)) { 
     661        if (ring->curr == (ring->dirty + ring->size)) { 
    663662                DBG("%s: tx queue full\n", ag->dev->name); 
    664663                netif_stop_queue(dev); 
     
    761760        sent = 0; 
    762761        while (ring->dirty != ring->curr) { 
    763                 unsigned int i = ring->dirty % AG71XX_TX_RING_SIZE; 
     762                unsigned int i = ring->dirty % ring->size; 
    764763                struct ag71xx_desc *desc = ring->buf[i].desc; 
    765764                struct sk_buff *skb = ring->buf[i].skb; 
     
    782781        DBG("%s: %d packets sent out\n", ag->dev->name, sent); 
    783782 
    784         if ((ring->curr - ring->dirty) < AG71XX_TX_THRES_WAKEUP) 
     783        if ((ring->curr - ring->dirty) < (ring->size * 3) / 4) 
    785784                netif_wake_queue(ag->dev); 
    786785 
     
    798797 
    799798        while (done < limit) { 
    800                 unsigned int i = ring->curr % AG71XX_RX_RING_SIZE; 
     799                unsigned int i = ring->curr % ring->size; 
    801800                struct ag71xx_desc *desc = ring->buf[i].desc; 
    802801                struct sk_buff *skb; 
     
    807806                        break; 
    808807 
    809                 if ((ring->dirty + AG71XX_RX_RING_SIZE) == ring->curr) { 
     808                if ((ring->dirty + ring->size) == ring->curr) { 
    810809                        ag71xx_assert(0); 
    811810                        break; 
     
    877876 
    878877        rx_ring = &ag->rx_ring; 
    879         if (rx_ring->buf[rx_ring->dirty % AG71XX_RX_RING_SIZE].skb == NULL) 
     878        if (rx_ring->buf[rx_ring->dirty % rx_ring->size].skb == NULL) 
    880879                goto oom; 
    881880 
     
    10741073        ag->oom_timer.data = (unsigned long) dev; 
    10751074        ag->oom_timer.function = ag71xx_oom_timer_handler; 
     1075 
     1076        ag->tx_ring.size = AG71XX_TX_RING_SIZE_DEFAULT; 
     1077        ag->rx_ring.size = AG71XX_RX_RING_SIZE_DEFAULT; 
    10761078 
    10771079        memcpy(dev->dev_addr, pdata->mac_addr, ETH_ALEN); 
Note: See TracChangeset for help on using the changeset viewer.