Changeset 9251


Ignore:
Timestamp:
2007-10-11T03:21:32+02:00 (9 years ago)
Author:
ejka
Message:

locking rework, drop non-napi rx, multiqueue tx, misc cleanups

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar7/files/drivers/net/cpmac.c

    r9098 r9251  
    3939#include <asm/gpio.h> 
    4040 
    41 MODULE_AUTHOR("Eugene Konev"); 
     41MODULE_AUTHOR("Eugene Konev <ejka@imfi.kspu.ru>"); 
    4242MODULE_DESCRIPTION("TI AR7 ethernet driver (CPMAC)"); 
    4343MODULE_LICENSE("GPL"); 
    4444 
    45 static int disable_napi; 
    4645static int debug_level = 8; 
    4746static int dumb_switch; 
    4847 
    49 module_param(disable_napi, int, 0644); 
    5048/* Next 2 are only used in cpmac_probe, so it's pointless to change them */ 
    5149module_param(debug_level, int, 0444); 
    5250module_param(dumb_switch, int, 0444); 
    5351 
    54 MODULE_PARM_DESC(disable_napi, "Disable NAPI polling"); 
    5552MODULE_PARM_DESC(debug_level, "Number of NETIF_MSG bits to enable"); 
    5653MODULE_PARM_DESC(dumb_switch, "Assume switch is not connected to MDIO bus"); 
    5754 
     55#define CPMAC_VERSION "0.5.0" 
    5856/* stolen from net/ieee80211.h */ 
    5957#ifndef MAC_FMT 
     
    6462/* frame size + 802.1q tag */ 
    6563#define CPMAC_SKB_SIZE          (ETH_FRAME_LEN + 4) 
    66 #define CPMAC_TX_RING_SIZE      8 
     64#define CPMAC_QUEUES    8 
    6765 
    6866/* Ethernet registers */ 
     
    200198struct cpmac_priv { 
    201199        spinlock_t lock; 
     200        spinlock_t rx_lock; 
    202201        struct cpmac_desc *rx_head; 
    203         int tx_head, tx_tail; 
    204202        int ring_size; 
    205203        struct cpmac_desc *desc_ring; 
     
    211209        int oldlink, oldspeed, oldduplex; 
    212210        u32 msg_enable; 
     211        struct net_device *dev; 
     212        struct work_struct reset_work; 
    213213        struct platform_device *pdev; 
    214214}; 
    215215 
    216216static irqreturn_t cpmac_irq(int, void *); 
    217 static void cpmac_reset(struct net_device *dev); 
    218 static void cpmac_hw_init(struct net_device *dev); 
     217static void cpmac_hw_start(struct net_device *dev); 
     218static void cpmac_hw_stop(struct net_device *dev); 
    219219static int cpmac_stop(struct net_device *dev); 
    220220static int cpmac_open(struct net_device *dev); 
     
    367367                                    struct cpmac_desc *desc) 
    368368{ 
    369         unsigned long flags; 
    370369        struct sk_buff *skb, *result = NULL; 
    371370 
     
    381380 
    382381        skb = netdev_alloc_skb(dev, CPMAC_SKB_SIZE); 
    383         spin_lock_irqsave(&priv->lock, flags); 
    384382        if (likely(skb)) { 
    385383                skb_reserve(skb, 2); 
     
    407405                dev->stats.rx_dropped++; 
    408406        } 
    409         spin_unlock_irqrestore(&priv->lock, flags); 
    410407 
    411408        desc->buflen = CPMAC_SKB_SIZE; 
     
    413410 
    414411        return result; 
    415 } 
    416  
    417 static void cpmac_rx(struct net_device *dev) 
    418 { 
    419         struct sk_buff *skb; 
    420         struct cpmac_desc *desc; 
    421         struct cpmac_priv *priv = netdev_priv(dev); 
    422  
    423         spin_lock(&priv->lock); 
    424         if (unlikely(!priv->rx_head)) { 
    425                 spin_unlock(&priv->lock); 
    426                 return; 
    427         } 
    428  
    429         desc = priv->rx_head; 
    430  
    431         while ((desc->dataflags & CPMAC_OWN) == 0) { 
    432                 skb = cpmac_rx_one(dev, priv, desc); 
    433                 if (likely(skb)) 
    434                         netif_rx(skb); 
    435                 desc = desc->next; 
    436         } 
    437  
    438         priv->rx_head = desc; 
    439         cpmac_write(priv->regs, CPMAC_RX_PTR(0), (u32)desc->mapping); 
    440         spin_unlock(&priv->lock); 
    441412} 
    442413 
     
    448419        struct cpmac_priv *priv = netdev_priv(dev); 
    449420 
     421        spin_lock(&priv->rx_lock); 
    450422        if (unlikely(!priv->rx_head)) { 
    451423                if (netif_msg_rx_err(priv) && net_ratelimit()) 
     
    457429 
    458430        desc = priv->rx_head; 
    459  
    460431        while ((received < quota) && ((desc->dataflags & CPMAC_OWN) == 0)) { 
    461432                skb = cpmac_rx_one(dev, priv, desc); 
     
    468439 
    469440        priv->rx_head = desc; 
     441        spin_unlock(&priv->rx_lock); 
    470442        *budget -= received; 
    471443        dev->quota -= received; 
     
    485457static int cpmac_start_xmit(struct sk_buff *skb, struct net_device *dev) 
    486458{ 
    487         unsigned long flags; 
    488         int channel, len; 
     459        int queue, len; 
    489460        struct cpmac_desc *desc; 
    490461        struct cpmac_priv *priv = netdev_priv(dev); 
     
    492463        if (unlikely(skb_padto(skb, ETH_ZLEN))) { 
    493464                if (netif_msg_tx_err(priv) && net_ratelimit()) 
    494                         printk(KERN_WARNING"%s: tx: padding failed, dropping\n", 
    495                                dev->name); 
    496                 spin_lock_irqsave(&priv->lock, flags); 
     465                        printk(KERN_WARNING 
     466                               "%s: tx: padding failed, dropping\n", dev->name); 
     467                spin_lock(&priv->lock); 
    497468                dev->stats.tx_dropped++; 
    498                 spin_unlock_irqrestore(&priv->lock, flags); 
     469                spin_unlock(&priv->lock); 
    499470                return -ENOMEM; 
    500471        } 
    501472 
    502473        len = max(skb->len, ETH_ZLEN); 
    503         spin_lock_irqsave(&priv->lock, flags); 
    504         channel = priv->tx_tail++; 
    505         priv->tx_tail %= CPMAC_TX_RING_SIZE; 
    506         if (priv->tx_tail == priv->tx_head) 
    507                 netif_stop_queue(dev); 
    508  
    509         desc = &priv->desc_ring[channel]; 
    510         if (desc->dataflags & CPMAC_OWN) { 
     474        queue = skb->queue_mapping; 
     475        netif_stop_subqueue(dev, queue); 
     476 
     477        desc = &priv->desc_ring[queue]; 
     478        if (unlikely(desc->dataflags & CPMAC_OWN)) { 
    511479                if (netif_msg_tx_err(priv) && net_ratelimit()) 
    512480                        printk(KERN_WARNING "%s: tx dma ring full, dropping\n", 
    513481                               dev->name); 
     482                spin_lock(&priv->lock); 
    514483                dev->stats.tx_dropped++; 
    515                 spin_unlock_irqrestore(&priv->lock, flags); 
     484                spin_unlock(&priv->lock); 
    516485                dev_kfree_skb_any(skb); 
    517486                return -ENOMEM; 
    518487        } 
    519488 
     489        spin_lock(&priv->lock); 
    520490        dev->trans_start = jiffies; 
    521         spin_unlock_irqrestore(&priv->lock, flags); 
     491        spin_unlock(&priv->lock); 
    522492        desc->dataflags = CPMAC_SOP | CPMAC_EOP | CPMAC_OWN; 
    523493        desc->skb = skb; 
     
    534504        if (unlikely(netif_msg_pktdata(priv))) 
    535505                cpmac_dump_skb(dev, skb); 
    536         cpmac_write(priv->regs, CPMAC_TX_PTR(channel), (u32)desc->mapping); 
     506        cpmac_write(priv->regs, CPMAC_TX_PTR(queue), (u32)desc->mapping); 
    537507 
    538508        return 0; 
    539509} 
    540510 
    541 static void cpmac_end_xmit(struct net_device *dev, int channel) 
     511static void cpmac_end_xmit(struct net_device *dev, int queue) 
    542512{ 
    543513        struct cpmac_desc *desc; 
    544514        struct cpmac_priv *priv = netdev_priv(dev); 
    545515 
    546         spin_lock(&priv->lock); 
    547         desc = &priv->desc_ring[channel]; 
    548         cpmac_write(priv->regs, CPMAC_TX_ACK(channel), (u32)desc->mapping); 
     516        desc = &priv->desc_ring[queue]; 
     517        cpmac_write(priv->regs, CPMAC_TX_ACK(queue), (u32)desc->mapping); 
    549518        if (likely(desc->skb)) { 
     519                spin_lock(&priv->lock); 
    550520                dev->stats.tx_packets++; 
    551521                dev->stats.tx_bytes += desc->skb->len; 
     522                spin_unlock(&priv->lock); 
    552523                dma_unmap_single(&dev->dev, desc->data_mapping, desc->skb->len, 
    553524                                 DMA_TO_DEVICE); 
     
    558529 
    559530                dev_kfree_skb_irq(desc->skb); 
    560                 if (netif_queue_stopped(dev)) 
    561                         netif_wake_queue(dev); 
    562         } else 
     531                desc->skb = NULL; 
     532                if (netif_subqueue_stopped(dev, queue)) 
     533                        netif_wake_subqueue(dev, queue); 
     534        } else { 
    563535                if (netif_msg_tx_err(priv) && net_ratelimit()) 
    564536                        printk(KERN_WARNING 
    565537                               "%s: end_xmit: spurious interrupt\n", dev->name); 
    566         spin_unlock(&priv->lock); 
    567 } 
    568  
    569 static void cpmac_reset(struct net_device *dev) 
     538                if (netif_subqueue_stopped(dev, queue)) 
     539                        netif_wake_subqueue(dev, queue); 
     540        } 
     541} 
     542 
     543static void cpmac_hw_stop(struct net_device *dev) 
    570544{ 
    571545        int i; 
     
    582556                cpmac_write(priv->regs, CPMAC_RX_PTR(i), 0); 
    583557        } 
     558        cpmac_write(priv->regs, CPMAC_UNICAST_CLEAR, 0xff); 
     559        cpmac_write(priv->regs, CPMAC_RX_INT_CLEAR, 0xff); 
     560        cpmac_write(priv->regs, CPMAC_TX_INT_CLEAR, 0xff); 
     561        cpmac_write(priv->regs, CPMAC_MAC_INT_CLEAR, 0xff); 
    584562        cpmac_write(priv->regs, CPMAC_MAC_CONTROL, 
    585563                    cpmac_read(priv->regs, CPMAC_MAC_CONTROL) & ~MAC_MII); 
    586564} 
    587565 
    588 static inline void cpmac_free_rx_ring(struct net_device *dev) 
    589 { 
     566static void cpmac_hw_start(struct net_device *dev) 
     567{ 
     568        int i; 
     569        struct cpmac_priv *priv = netdev_priv(dev); 
     570        struct plat_cpmac_data *pdata = priv->pdev->dev.platform_data; 
     571 
     572        ar7_device_reset(pdata->reset_bit); 
     573        for (i = 0; i < 8; i++) { 
     574                cpmac_write(priv->regs, CPMAC_TX_PTR(i), 0); 
     575                cpmac_write(priv->regs, CPMAC_RX_PTR(i), 0); 
     576        } 
     577        cpmac_write(priv->regs, CPMAC_RX_PTR(0), priv->rx_head->mapping); 
     578 
     579        cpmac_write(priv->regs, CPMAC_MBP, MBP_RXSHORT | MBP_RXBCAST | 
     580                    MBP_RXMCAST); 
     581        cpmac_write(priv->regs, CPMAC_BUFFER_OFFSET, 0); 
     582        for (i = 0; i < 8; i++) 
     583                cpmac_write(priv->regs, CPMAC_MAC_ADDR_LO(i), dev->dev_addr[5]); 
     584        cpmac_write(priv->regs, CPMAC_MAC_ADDR_MID, dev->dev_addr[4]); 
     585        cpmac_write(priv->regs, CPMAC_MAC_ADDR_HI, dev->dev_addr[0] | 
     586                    (dev->dev_addr[1] << 8) | (dev->dev_addr[2] << 16) | 
     587                    (dev->dev_addr[3] << 24)); 
     588        cpmac_write(priv->regs, CPMAC_MAX_LENGTH, CPMAC_SKB_SIZE); 
     589        cpmac_write(priv->regs, CPMAC_UNICAST_CLEAR, 0xff); 
     590        cpmac_write(priv->regs, CPMAC_RX_INT_CLEAR, 0xff); 
     591        cpmac_write(priv->regs, CPMAC_TX_INT_CLEAR, 0xff); 
     592        cpmac_write(priv->regs, CPMAC_MAC_INT_CLEAR, 0xff); 
     593        cpmac_write(priv->regs, CPMAC_UNICAST_ENABLE, 1); 
     594        cpmac_write(priv->regs, CPMAC_RX_INT_ENABLE, 1); 
     595        cpmac_write(priv->regs, CPMAC_TX_INT_ENABLE, 0xff); 
     596        cpmac_write(priv->regs, CPMAC_MAC_INT_ENABLE, 3); 
     597 
     598        cpmac_write(priv->regs, CPMAC_RX_CONTROL, 
     599                    cpmac_read(priv->regs, CPMAC_RX_CONTROL) | 1); 
     600        cpmac_write(priv->regs, CPMAC_TX_CONTROL, 
     601                    cpmac_read(priv->regs, CPMAC_TX_CONTROL) | 1); 
     602        cpmac_write(priv->regs, CPMAC_MAC_CONTROL, 
     603                    cpmac_read(priv->regs, CPMAC_MAC_CONTROL) | MAC_MII | 
     604                    MAC_FDX); 
     605} 
     606 
     607static void cpmac_clear_rx(struct net_device *dev) 
     608{ 
     609        struct cpmac_priv *priv = netdev_priv(dev); 
    590610        struct cpmac_desc *desc; 
    591611        int i; 
    592         struct cpmac_priv *priv = netdev_priv(dev); 
    593  
    594612        if (unlikely(!priv->rx_head)) 
    595613                return; 
    596  
    597614        desc = priv->rx_head; 
    598  
    599615        for (i = 0; i < priv->ring_size; i++) { 
    600                 desc->buflen = CPMAC_SKB_SIZE; 
    601616                if ((desc->dataflags & CPMAC_OWN) == 0) { 
    602617                        if (netif_msg_rx_err(priv) && net_ratelimit()) 
     
    612627} 
    613628 
     629static void cpmac_clear_tx(struct net_device *dev) 
     630{ 
     631        struct cpmac_priv *priv = netdev_priv(dev); 
     632        int i; 
     633        if (unlikely(!priv->desc_ring)) 
     634                return; 
     635        for (i = 0; i < CPMAC_QUEUES; i++) 
     636                if (priv->desc_ring[i].skb) { 
     637                        dev_kfree_skb_any(priv->desc_ring[i].skb); 
     638                        if (netif_subqueue_stopped(dev, i)) 
     639                            netif_wake_subqueue(dev, i); 
     640                } 
     641} 
     642 
     643static void cpmac_hw_error(struct work_struct *work) 
     644{ 
     645        struct cpmac_priv *priv = 
     646                container_of(work, struct cpmac_priv, reset_work); 
     647 
     648        spin_lock(&priv->rx_lock); 
     649        cpmac_clear_rx(priv->dev); 
     650        spin_unlock(&priv->rx_lock); 
     651        cpmac_clear_tx(priv->dev); 
     652        cpmac_hw_start(priv->dev); 
     653        netif_start_queue(priv->dev); 
     654} 
     655 
    614656static irqreturn_t cpmac_irq(int irq, void *dev_id) 
    615657{ 
    616658        struct net_device *dev = dev_id; 
    617659        struct cpmac_priv *priv; 
     660        int queue; 
    618661        u32 status; 
    619662 
     
    633676 
    634677        if (status & MAC_INT_RX) { 
    635                 if (disable_napi) 
    636                         cpmac_rx(dev); 
    637                 else { 
    638                         cpmac_write(priv->regs, CPMAC_RX_INT_CLEAR, 1); 
    639                         netif_rx_schedule(dev); 
    640                 } 
     678                queue = (status >> 8) & 7; 
     679                netif_rx_schedule(dev); 
     680                cpmac_write(priv->regs, CPMAC_RX_INT_CLEAR, 1 << queue); 
    641681        } 
    642682 
     
    647687                        printk(KERN_ERR "%s: hw error, resetting...\n", 
    648688                               dev->name); 
     689                netif_stop_queue(dev); 
     690                cpmac_hw_stop(dev); 
     691                schedule_work(&priv->reset_work); 
    649692                if (unlikely(netif_msg_hw(priv))) 
    650693                        cpmac_dump_regs(dev); 
    651                 spin_lock(&priv->lock); 
    652                 phy_stop(priv->phy); 
    653                 cpmac_reset(dev); 
    654                 cpmac_free_rx_ring(dev); 
    655                 cpmac_hw_init(dev); 
    656                 spin_unlock(&priv->lock); 
    657694        } 
    658695 
     
    663700{ 
    664701        struct cpmac_priv *priv = netdev_priv(dev); 
    665         struct cpmac_desc *desc; 
    666  
     702        int i; 
     703 
     704        spin_lock(&priv->lock); 
    667705        dev->stats.tx_errors++; 
    668         desc = &priv->desc_ring[priv->tx_head++]; 
    669         priv->tx_head %= 8; 
     706        spin_unlock(&priv->lock); 
    670707        if (netif_msg_tx_err(priv) && net_ratelimit()) 
    671708                printk(KERN_WARNING "%s: transmit timeout\n", dev->name); 
    672         if (desc->skb) 
    673                 dev_kfree_skb_any(desc->skb); 
    674         netif_wake_queue(dev); 
     709        /*  
     710         * FIXME: waking up random queue is not the best thing to 
     711         * do... on the other hand why we got here at all? 
     712         */ 
     713        for (i = 0; i < CPMAC_QUEUES; i++) 
     714                if (priv->desc_ring[i].skb) { 
     715                        dev_kfree_skb_any(priv->desc_ring[i].skb); 
     716                        netif_wake_subqueue(dev, i); 
     717                        break; 
     718                } 
    675719} 
    676720 
     
    686730                return phy_mii_ioctl(priv->phy, if_mii(ifr), cmd); 
    687731 
    688         return -EINVAL; 
     732        return -EOPNOTSUPP; 
    689733} 
    690734 
     
    741785{ 
    742786        strcpy(info->driver, "cpmac"); 
    743         strcpy(info->version, "0.0.3"); 
     787        strcpy(info->version, CPMAC_VERSION); 
    744788        info->fw_version[0] = '\0'; 
    745789        sprintf(info->bus_info, "%s", "cpmac"); 
     
    759803{ 
    760804        struct cpmac_priv *priv = netdev_priv(dev); 
    761         unsigned long flags; 
    762805        int new_state = 0; 
    763806 
    764         spin_lock_irqsave(&priv->lock, flags); 
     807        spin_lock(&priv->lock); 
    765808        if (priv->phy->link) { 
     809                netif_start_queue(dev); 
    766810                if (priv->phy->duplex != priv->oldduplex) { 
    767811                        new_state = 1; 
     
    780824                } 
    781825        } else if (priv->oldlink) { 
     826                netif_stop_queue(dev); 
    782827                new_state = 1; 
    783828                priv->oldlink = 0; 
     
    789834                phy_print_status(priv->phy); 
    790835 
    791         spin_unlock_irqrestore(&priv->lock, flags); 
    792 } 
    793  
    794 static void cpmac_hw_init(struct net_device *dev) 
    795 { 
    796         int i; 
    797         struct cpmac_priv *priv = netdev_priv(dev); 
    798  
    799         for (i = 0; i < 8; i++) { 
    800                 cpmac_write(priv->regs, CPMAC_TX_PTR(i), 0); 
    801                 cpmac_write(priv->regs, CPMAC_RX_PTR(i), 0); 
    802         } 
    803         cpmac_write(priv->regs, CPMAC_RX_PTR(0), priv->rx_head->mapping); 
    804  
    805         cpmac_write(priv->regs, CPMAC_MBP, MBP_RXSHORT | MBP_RXBCAST | 
    806                     MBP_RXMCAST); 
    807         cpmac_write(priv->regs, CPMAC_UNICAST_ENABLE, 1); 
    808         cpmac_write(priv->regs, CPMAC_UNICAST_CLEAR, 0xfe); 
    809         cpmac_write(priv->regs, CPMAC_BUFFER_OFFSET, 0); 
    810         for (i = 0; i < 8; i++) 
    811                 cpmac_write(priv->regs, CPMAC_MAC_ADDR_LO(i), dev->dev_addr[5]); 
    812         cpmac_write(priv->regs, CPMAC_MAC_ADDR_MID, dev->dev_addr[4]); 
    813         cpmac_write(priv->regs, CPMAC_MAC_ADDR_HI, dev->dev_addr[0] | 
    814                     (dev->dev_addr[1] << 8) | (dev->dev_addr[2] << 16) | 
    815                     (dev->dev_addr[3] << 24)); 
    816         cpmac_write(priv->regs, CPMAC_MAX_LENGTH, CPMAC_SKB_SIZE); 
    817         cpmac_write(priv->regs, CPMAC_RX_INT_CLEAR, 0xff); 
    818         cpmac_write(priv->regs, CPMAC_TX_INT_CLEAR, 0xff); 
    819         cpmac_write(priv->regs, CPMAC_MAC_INT_CLEAR, 0xff); 
    820         cpmac_write(priv->regs, CPMAC_RX_INT_ENABLE, 1); 
    821         cpmac_write(priv->regs, CPMAC_TX_INT_ENABLE, 0xff); 
    822         cpmac_write(priv->regs, CPMAC_MAC_INT_ENABLE, 3); 
    823  
    824         cpmac_write(priv->regs, CPMAC_RX_CONTROL, 
    825                     cpmac_read(priv->regs, CPMAC_RX_CONTROL) | 1); 
    826         cpmac_write(priv->regs, CPMAC_TX_CONTROL, 
    827                     cpmac_read(priv->regs, CPMAC_TX_CONTROL) | 1); 
    828         cpmac_write(priv->regs, CPMAC_MAC_CONTROL, 
    829                     cpmac_read(priv->regs, CPMAC_MAC_CONTROL) | MAC_MII | 
    830                     MAC_FDX); 
    831  
    832         priv->phy->state = PHY_CHANGELINK; 
    833         phy_start(priv->phy); 
     836        spin_unlock(&priv->lock); 
    834837} 
    835838 
     
    869872        } 
    870873 
    871         priv->rx_head = NULL; 
    872         size = priv->ring_size + CPMAC_TX_RING_SIZE; 
     874        size = priv->ring_size + CPMAC_QUEUES; 
    873875        priv->desc_ring = dma_alloc_coherent(&dev->dev, 
    874876                                             sizeof(struct cpmac_desc) * size, 
     
    880882        } 
    881883 
    882         priv->rx_head = &priv->desc_ring[CPMAC_TX_RING_SIZE]; 
    883884        for (i = 0; i < size; i++) 
    884885                priv->desc_ring[i].mapping = priv->dma_ring + sizeof(*desc) * i; 
    885886 
    886         for (i = 0, desc = &priv->rx_head[i]; i < priv->ring_size; i++, desc++) { 
     887        priv->rx_head = &priv->desc_ring[CPMAC_QUEUES]; 
     888        for (i = 0, desc = priv->rx_head; i < priv->ring_size; i++, desc++) { 
    887889                skb = netdev_alloc_skb(dev, CPMAC_SKB_SIZE); 
    888890                if (unlikely(!skb)) { 
     
    910912        } 
    911913 
    912         cpmac_reset(dev); 
    913         cpmac_hw_init(dev); 
    914  
    915         netif_start_queue(dev); 
     914        INIT_WORK(&priv->reset_work, cpmac_hw_error); 
     915        cpmac_hw_start(dev); 
     916 
     917        priv->phy->state = PHY_CHANGELINK; 
     918        phy_start(priv->phy); 
     919 
    916920        return 0; 
    917921 
     
    920924        for (i = 0; i < priv->ring_size; i++) { 
    921925                if (priv->rx_head[i].skb) { 
    922                         kfree_skb(priv->rx_head[i].skb); 
    923926                        dma_unmap_single(&dev->dev, 
    924927                                         priv->rx_head[i].data_mapping, 
    925928                                         CPMAC_SKB_SIZE, 
    926929                                         DMA_FROM_DEVICE); 
     930                        kfree_skb(priv->rx_head[i].skb); 
    927931                } 
    928932        } 
     
    948952        netif_stop_queue(dev); 
    949953 
     954        cancel_work_sync(&priv->reset_work); 
    950955        phy_stop(priv->phy); 
    951956        phy_disconnect(priv->phy); 
    952957        priv->phy = NULL; 
    953958 
    954         cpmac_reset(dev); 
     959        cpmac_hw_stop(dev); 
    955960 
    956961        for (i = 0; i < 8; i++) 
     
    963968        mem = platform_get_resource_byname(priv->pdev, IORESOURCE_MEM, "regs"); 
    964969        release_mem_region(mem->start, mem->end - mem->start); 
    965         priv->rx_head = &priv->desc_ring[CPMAC_TX_RING_SIZE]; 
     970        priv->rx_head = &priv->desc_ring[CPMAC_QUEUES]; 
    966971        for (i = 0; i < priv->ring_size; i++) { 
    967972                if (priv->rx_head[i].skb) { 
    968                         kfree_skb(priv->rx_head[i].skb); 
    969973                        dma_unmap_single(&dev->dev, 
    970974                                         priv->rx_head[i].data_mapping, 
    971975                                         CPMAC_SKB_SIZE, 
    972976                                         DMA_FROM_DEVICE); 
     977                        kfree_skb(priv->rx_head[i].skb); 
    973978                } 
    974979        } 
    975980 
    976981        dma_free_coherent(&dev->dev, sizeof(struct cpmac_desc) * 
    977                           (CPMAC_TX_RING_SIZE + priv->ring_size), 
     982                          (CPMAC_QUEUES + priv->ring_size), 
    978983                          priv->desc_ring, priv->dma_ring); 
    979984        return 0; 
     
    10091014        } 
    10101015 
    1011         dev = alloc_etherdev(sizeof(struct cpmac_priv)); 
     1016        dev = alloc_etherdev_mq(sizeof(*priv), CPMAC_QUEUES); 
    10121017 
    10131018        if (!dev) { 
     
    10361041        dev->tx_timeout         = cpmac_tx_timeout; 
    10371042        dev->ethtool_ops        = &cpmac_ethtool_ops; 
    1038         if (!disable_napi) { 
    1039                 dev->poll = cpmac_poll; 
    1040                 dev->weight = 64; 
    1041         } 
     1043        dev->poll = cpmac_poll; 
     1044        dev->weight = 64; 
     1045        dev->features |= NETIF_F_MULTI_QUEUE; 
    10421046 
    10431047        spin_lock_init(&priv->lock); 
     1048        spin_lock_init(&priv->rx_lock); 
     1049        priv->dev = dev; 
     1050        priv->ring_size = 64; 
    10441051        priv->msg_enable = netif_msg_init(debug_level, 0xff); 
    1045         priv->ring_size = 64; 
    10461052        memcpy(dev->dev_addr, pdata->dev_addr, sizeof(dev->dev_addr)); 
    10471053        if (phy_id == 31) { 
    10481054                snprintf(priv->phy_name, BUS_ID_SIZE, PHY_ID_FMT, 
    10491055                         cpmac_mii.id, phy_id); 
    1050 /*              cpmac_write(cpmac_mii.priv, CPMAC_MDIO_PHYSEL(0), PHYSEL_LINKSEL 
    1051                 | PHYSEL_LINKINT | phy_id);*/ 
    10521056        } else 
    10531057                snprintf(priv->phy_name, BUS_ID_SIZE, "fixed@%d:%d", 100, 1); 
Note: See TracChangeset for help on using the changeset viewer.