Changeset 11508


Ignore:
Timestamp:
2008-06-16T15:25:14+02:00 (10 years ago)
Author:
florian
Message:

his patch mainly fixes the huge delay when we ping from the RDC device to another host (160-230 ms).
r6040_rx() was rewritten.
Further changes:

  • fix a bug in hex2str(), which overwrote the source with a zero
  • removed rx_free_desc counter; allocate skb inside r6040_rx() on the fly
  • r6040_rx: don't take the error from the MLSR register (may be too late) but from the descriptor (we may have to allow these errors (via MCR0) there
  • r6040_alloc_rxbufs() may fail due to lack of skb, added a return value
  • changed some debugs
  • more defines
  • version: 0.18 -> 0.19

Signed-Off by Joerg Albert <jal2@…>

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/rdc/files/drivers/net/r6040.c

    r11507 r11508  
    5151 
    5252#define DRV_NAME        "r6040" 
    53 #define DRV_VERSION     "0.18" 
    54 #define DRV_RELDATE     "13Jun2008" 
     53#define DRV_VERSION     "0.19" 
     54#define DRV_RELDATE     "16Jun2008" 
    5555 
    5656/* define bits of a debug mask */ 
    57 #define DBG_PHY           (1<< 0) /*!< show PHY read/write */ 
    58 #define DBG_FREE_BUFS     (1<< 1) /*!< show calls to r6040_free_*bufs */ 
    59 #define DBG_RING          (1<< 2) /*!< debug init./freeing of descr rings */ 
    60 #define DBG_RX_BUF        (1<< 3) /*!< show alloc. of new rx buf (in IRQ context !) */ 
    61 #define DBG_TX_BUF        (1<< 4) /*!< show arrival of new tx buf */ 
    62 #define DBG_RX_IRQ        (1<< 5) /*!< show RX IRQ handling */ 
    63 #define DBG_TX_IRQ        (1<< 6) /*!< debug TX done IRQ */ 
    64 #define DBG_RX_DESCR      (1<< 7) /*!< debug rx descr to be processed */ 
    65 #define DBG_RX_DATA       (1<< 8) /*!< show some user data of incoming packet */ 
    66 #define DBG_EXIT          (1<< 9) /*!< show exit code calls */ 
    67 #define DBG_INIT          (1<<10) /*!< show init. code calls */ 
    68 #define DBG_TX_RING_DUMP  (1<<11) /*!< dump the tx ring after creation */ 
    69 #define DBG_RX_RING_DUMP  (1<<12) /*!< dump the rx ring after creation */ 
    70 #define DBG_TX_DESCR      (1<<13) /*!< dump the setting of a descr for tx */ 
    71 #define DBG_TX_DATA       (1<<14) /*!< dump some tx data */ 
    72 #define DBG_IRQ           (1<<15) /*!< print inside the irq handler */ 
    73 #define DBG_POLL          (1<<16) /*!< dump info on poll procedure */ 
    74 #define DBG_MAC_ADDR      (1<<17) /*!< debug mac address setting */ 
    75 #define DBG_OPEN          (1<<18) /*!< debug open proc. */ 
     57#define DBG_PHY           0x00000001 /*!< show PHY read/write */ 
     58#define DBG_FREE_BUFS     0x00000002 /*!< show calls to r6040_free_*bufs */ 
     59#define DBG_RING          0x00000004 /*!< debug init./freeing of descr rings */ 
     60#define DBG_RX_BUF        0x00000008 /*!< show alloc. of new rx buf (in IRQ context !) */ 
     61#define DBG_TX_BUF        0x00000010 /*!< show arrival of new tx buf */ 
     62#define DBG_TX_DONE       0x00000020 /*!< debug TX done */ 
     63#define DBG_RX_DESCR      0x00000040 /*!< debug rx descr to be processed */ 
     64#define DBG_RX_DATA       0x00000080 /*!< show some user data of incoming packet */ 
     65#define DBG_EXIT          0x00000100 /*!< show exit code calls */ 
     66#define DBG_INIT          0x00000200 /*!< show init. code calls */ 
     67#define DBG_TX_RING_DUMP  0x00000400 /*!< dump the tx ring after creation */ 
     68#define DBG_RX_RING_DUMP  0x00000800 /*!< dump the rx ring after creation */ 
     69#define DBG_TX_DESCR      0x00001000 /*!< dump the setting of a descr for tx */ 
     70#define DBG_TX_DATA       0x00002000 /*!< dump some tx data */ 
     71#define DBG_IRQ           0x00004000 /*!< print inside the irq handler */ 
     72#define DBG_POLL          0x00008000 /*!< dump info on poll procedure */ 
     73#define DBG_MAC_ADDR      0x00010000 /*!< debug mac address setting */ 
     74#define DBG_OPEN          0x00020000 /*!< debug open proc. */ 
    7675 
    7776static int debug = 0; 
     
    7978MODULE_PARM_DESC(debug, "debug mask (-1 for all)"); 
    8079 
    81 /* define wcd hich debugs are left in the code during compilation */ 
     80/* define which debugs are left in the code during compilation */ 
    8281#define DEBUG (-1) /* all debugs */ 
    8382 
     
    208207} __attribute__((aligned(32))); 
    209208 
     209/*! defines for the status field in the r6040_descriptor */ 
     210#define DESC_STATUS_OWNER_MAC       (1<<15) /*!< if set the MAC is the owner of this descriptor */ 
     211#define DESC_STATUS_RX_OK           (1<<14) /*!< rx was successful */ 
     212#define DESC_STATUS_RX_ERR          (1<<11) /*!< rx PHY error */ 
     213#define DESC_STATUS_RX_ERR_DRIBBLE  (1<<10) /*!< rx dribble packet */ 
     214#define DESC_STATUS_RX_ERR_BUFLEN   (1<< 9) /*!< rx length exceeded buffer size */ 
     215#define DESC_STATUS_RX_ERR_LONG     (1<< 8) /*!< rx length > maximum packet length */ 
     216#define DESC_STATUS_RX_ERR_RUNT     (1<< 7) /*!< rx: packet length < 64 byte */ 
     217#define DESC_STATUS_RX_ERR_CRC      (1<< 6) /*!< rx: crc error */ 
     218#define DESC_STATUS_RX_BROADCAST    (1<< 5) /*!< rx: broadcast (no error) */ 
     219#define DESC_STATUS_RX_MULTICAST    (1<< 4) /*!< rx: multicast (no error) */ 
     220#define DESC_STATUS_RX_MCH_HIT      (1<< 3) /*!< rx: multicast hit in hash table (no error) */ 
     221#define DESC_STATUS_RX_MIDH_HIT     (1<< 2) /*!< rx: MID table hit (no error) */ 
     222#define DESC_STATUS_RX_IDX_MID_MASK 3       /*!< rx: mask for the index of matched MIDx */ 
     223 
    210224struct r6040_private { 
    211225        spinlock_t lock;                /* driver lock */ 
     
    220234        dma_addr_t rx_ring_dma; 
    221235        dma_addr_t tx_ring_dma; 
    222         u16     tx_free_desc, rx_free_desc, phy_addr, phy_mode; 
     236        u16     tx_free_desc, phy_addr, phy_mode; 
    223237        u16     mcr0, mcr1; 
    224238        u16     switch_sig; 
     
    252266STATIC char *hex2str(void *addr, char *buf, int nr_bytes, int delim) 
    253267{ 
    254         unsigned char *dst = addr; 
     268        unsigned char *src = addr; 
    255269        char *outb = buf; 
    256270 
     
    258272 
    259273        while (nr_bytes > 0) { 
    260                 *outb++ = BIN2HEXDIGIT(*dst>>4); 
    261                 *outb++ = BIN2HEXDIGIT(*dst&0xf); 
     274                *outb++ = BIN2HEXDIGIT(*src>>4); 
     275                *outb++ = BIN2HEXDIGIT(*src&0xf); 
    262276                if (delim) 
    263277                        *outb++ = delim; 
    264278                nr_bytes--; 
    265                 dst++; 
     279                src++; 
    266280        } 
    267281 
    268282        if (delim) 
    269                 dst--; 
    270         *dst = '\0'; 
     283                outb--; 
     284        *outb = '\0'; 
    271285        return buf; 
    272286} 
     
    356370} 
    357371 
     372/*! unmap and free all rx skb */ 
    358373void r6040_free_rxbufs(struct net_device *dev) 
    359374{ 
     
    385400            desc_ring, desc_dma, size); 
    386401 
     402         
    387403        while (size-- > 0) { 
    388404                mapping += sizeof(*desc); 
     405                memset(desc, 0, sizeof(*desc)); 
    389406                desc->ndesc = cpu_to_le32(mapping); 
    390407                desc->vndescp = desc + 1; 
    391408                desc++; 
    392409        } 
     410 
     411        /* last descriptor points to first one to close the descriptor ring */ 
    393412        desc--; 
    394413        desc->ndesc = cpu_to_le32(desc_dma); 
    395414        desc->vndescp = desc_ring; 
    396 } 
    397  
    398 /* Allocate skb buffer for rx descriptor */ 
    399 STATIC void rx_buf_alloc(struct r6040_private *lp, struct net_device *dev) 
    400 { 
    401         struct r6040_descriptor *descptr; 
    402  
    403         dbg(DBG_RX_BUF, "rx_insert %p rx_free_desc x%x dev %p\n", 
    404             lp->rx_insert_ptr, lp->rx_free_desc, dev); 
    405  
    406         descptr = lp->rx_insert_ptr; 
    407         while (lp->rx_free_desc < RX_DCNT) { 
    408                 descptr->skb_ptr = netdev_alloc_skb(dev, MAX_BUF_SIZE); 
    409  
    410                 dbg(DBG_RX_BUF, "alloc'ed skb %p for rx descptr %p\n", 
    411                     descptr->skb_ptr, descptr); 
    412  
    413                 if (!descptr->skb_ptr) 
    414                         break; 
    415                 descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, 
    416                         descptr->skb_ptr->data, 
    417                         MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
    418                 descptr->status = 0x8000; 
    419                 /* debug before descptr goes to next ! */ 
    420                 dbg(DBG_RX_BUF, "descptr %p skb->data %p buf %08x rx_free_desc x%x\n", 
    421                     descptr, descptr->skb_ptr->data, descptr->buf, lp->rx_free_desc); 
    422                 descptr = descptr->vndescp; 
    423                 lp->rx_free_desc++; 
    424         } 
    425         lp->rx_insert_ptr = descptr; 
    426415} 
    427416 
     
    450439#endif /* #if (DEBUG & DBG_TX_RING_DUMP) */ 
    451440 
    452 void r6040_alloc_txbufs(struct net_device *dev) 
     441void r6040_init_txbufs(struct net_device *dev) 
    453442{ 
    454443        struct r6040_private *lp = netdev_priv(dev); 
     
    490479#endif /* #if (DEBUG & DBG_TX_RING_DUMP) */ 
    491480 
    492 void r6040_alloc_rxbufs(struct net_device *dev) 
    493 { 
    494         struct r6040_private *lp = netdev_priv(dev); 
    495  
    496         lp->rx_free_desc = 0; 
     481int r6040_alloc_rxbufs(struct net_device *dev) 
     482{ 
     483        struct r6040_private *lp = netdev_priv(dev); 
     484        struct r6040_descriptor *desc; 
     485        struct sk_buff *skb; 
     486        int rc; 
    497487 
    498488        lp->rx_remove_ptr = lp->rx_insert_ptr = lp->rx_ring; 
    499489        r6040_init_ring_desc(lp->rx_ring, lp->rx_ring_dma, RX_DCNT); 
    500490 
    501         rx_buf_alloc(lp, dev); 
     491        /* alloc skbs for the rx descriptors */ 
     492        desc = lp->rx_ring; 
     493        do { 
     494                if (!(skb=netdev_alloc_skb(dev, MAX_BUF_SIZE))) { 
     495                        err("failed to alloc skb for rx\n"); 
     496                        rc = -ENOMEM; 
     497                        goto err_exit; 
     498                } 
     499                desc->skb_ptr = skb; 
     500                desc->buf = cpu_to_le32(pci_map_single(lp->pdev, 
     501                                                       desc->skb_ptr->data, 
     502                                                       MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
     503                desc->status = DESC_STATUS_OWNER_MAC; 
     504                desc = desc->vndescp; 
     505        } while (desc != lp->rx_ring); 
    502506 
    503507#if (DEBUG & DBG_RX_RING_DUMP) 
     
    506510        } 
    507511#endif 
     512 
     513        return 0; 
     514 
     515err_exit: 
     516        /* dealloc all previously allocated skb */ 
     517        r6040_free_rxbufs(dev); 
     518        return rc; 
    508519} 
    509520 
     
    549560 
    550561        /* set interrupt waiting time and packet numbers */ 
    551         iowrite16(0x0F06, ioaddr + MT_ICR); 
    552         iowrite16(0x0F06, ioaddr + MR_ICR); 
     562        iowrite16(0, ioaddr + MT_ICR); 
     563        iowrite16(0, ioaddr + MR_ICR); 
    553564 
    554565        /* enable interrupts */ 
     
    638649        /* deleted timer */ 
    639650        del_timer_sync(&lp->timer); 
    640  
    641651        spin_lock_irq(&lp->lock); 
     652        napi_disable(&lp->napi); 
    642653        netif_stop_queue(dev); 
    643654        r6040_down(dev); 
     
    712723{ 
    713724        struct r6040_private *priv = netdev_priv(dev); 
    714         int count; 
    715         void __iomem *ioaddr = priv->base; 
    716         u16 err; 
    717  
    718         for (count = 0; count < limit; ++count) { 
    719                 struct r6040_descriptor *descptr = priv->rx_remove_ptr; 
    720                 struct sk_buff *skb_ptr; 
    721  
    722                 descptr = priv->rx_remove_ptr; 
    723  
     725        int count=0; 
     726        struct r6040_descriptor *descptr = priv->rx_remove_ptr; 
     727        struct sk_buff *skb_ptr, *new_skb; 
     728        char obuf[2*32+1] __attribute__ ((unused)); /* for debugging */ 
     729 
     730        while (count < limit && !(descptr->status & DESC_STATUS_OWNER_MAC)) { 
     731                /* limit not reached and the descriptor belongs to the CPU */ 
     732 
     733                dbg(DBG_RX_DESCR, "descptr %p status x%x data len x%x\n", 
     734                    descptr, descptr->status, descptr->len); 
     735                 
    724736                /* Check for errors */ 
    725                 err = ioread16(ioaddr + MLSR); 
    726                 if (err & 0x0400) 
     737                if (descptr->status & DESC_STATUS_RX_ERR) { 
     738                 
    727739                        dev->stats.rx_errors++; 
    728                 /* RX FIFO over-run */ 
    729                 if (err & 0x8000) 
    730                         dev->stats.rx_fifo_errors++; 
    731                 /* RX descriptor unavailable */ 
    732                 if (err & 0x0080) 
    733                         dev->stats.rx_frame_errors++; 
    734                 /* Received packet with length over buffer lenght */ 
    735                 if (err & 0x0020) 
    736                         dev->stats.rx_over_errors++; 
    737                 /* Received packet with too long or short */ 
    738                 if (err & (0x0010 | 0x0008)) 
    739                         dev->stats.rx_length_errors++; 
    740                 /* Received packet with CRC errors */ 
    741                 if (err & 0x0004) { 
    742                         spin_lock(&priv->lock); 
    743                         dev->stats.rx_crc_errors++; 
    744                         spin_unlock(&priv->lock); 
     740                         
     741                        if (descptr->status & (DESC_STATUS_RX_ERR_DRIBBLE| 
     742                                               DESC_STATUS_RX_ERR_BUFLEN| 
     743                                               DESC_STATUS_RX_ERR_LONG| 
     744                                               DESC_STATUS_RX_ERR_RUNT)) { 
     745                                /* packet too long or too short*/ 
     746                                dev->stats.rx_length_errors++; 
     747                        } 
     748 
     749                        if (descptr->status & DESC_STATUS_RX_ERR_CRC) { 
     750                                dev->stats.rx_crc_errors++; 
     751                        } 
     752                        goto next_descr; 
    745753                } 
    746  
    747                 dbg(DBG_RX_IRQ, "descptr %p status x%x err x%x\n",  
    748                     descptr, descptr->status, err); 
    749  
    750                 while (priv->rx_free_desc) { 
    751                         /* No RX packet */ 
    752                         if (descptr->status & 0x8000) 
    753                                 break; 
    754                         skb_ptr = descptr->skb_ptr; 
    755                         if (!skb_ptr) { 
    756                                 printk(KERN_ERR "%s: Inconsistent RX" 
    757                                         "descriptor chain\n", 
    758                                         dev->name); 
    759                                 break; 
    760                         } 
    761                         descptr->skb_ptr = NULL; 
    762                         skb_ptr->dev = priv->dev; 
    763                         /* Do not count the CRC */ 
    764                         skb_put(skb_ptr, descptr->len - 4); 
    765                         pci_unmap_single(priv->pdev, le32_to_cpu(descptr->buf), 
    766                                 MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    767                         skb_ptr->protocol = eth_type_trans(skb_ptr, priv->dev); 
    768  
    769                         dbg(DBG_RX_DESCR, "descptr %p status x%x err x%x data len x%x\n", 
    770                             descptr, descptr->status, err, descptr->len); 
    771  
    772                         { 
    773                                 char obuf[2*32+1] __attribute__ ((unused)); 
    774                                 dbg(DBG_RX_DATA, "rx len x%x: %s...\n", 
    775                                     descptr->len,  
    776                                     hex2str(skb_ptr->data, obuf, sizeof(obuf)/2, '\0')); 
    777                         } 
    778  
    779                         /* Send to upper layer */ 
    780                         netif_receive_skb(skb_ptr); 
    781                         dev->last_rx = jiffies; 
    782                         dev->stats.rx_packets++; 
    783                         dev->stats.rx_bytes += descptr->len; 
    784                         /* To next descriptor */ 
    785                         descptr = descptr->vndescp; 
    786                         priv->rx_free_desc--; 
     754                 
     755                /* successful received packet */ 
     756                 
     757                /* first try to allocate new skb. If this fails 
     758                   we drop the packet and leave the old skb there.*/ 
     759                new_skb = netdev_alloc_skb(dev, MAX_BUF_SIZE); 
     760                if (!new_skb) { 
     761                        dev->stats.rx_dropped++; 
     762                        goto next_descr; 
    787763                } 
    788                 priv->rx_remove_ptr = descptr; 
    789         } 
    790         /* Allocate new RX buffer */ 
    791         if (priv->rx_free_desc < RX_DCNT) 
    792                 rx_buf_alloc(priv, priv->dev); 
     764                skb_ptr = descptr->skb_ptr; 
     765                skb_ptr->dev = priv->dev; 
     766                /* Do not count the CRC */ 
     767                skb_put(skb_ptr, descptr->len - 4); 
     768                pci_unmap_single(priv->pdev, le32_to_cpu(descptr->buf), 
     769                                 MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
     770                skb_ptr->protocol = eth_type_trans(skb_ptr, priv->dev); 
     771 
     772                dbg(DBG_RX_DATA, "rx len x%x: %s...\n", 
     773                    descptr->len,  
     774                    hex2str(skb_ptr->data, obuf, sizeof(obuf)/2, '\0')); 
     775 
     776                /* Send to upper layer */ 
     777                netif_receive_skb(skb_ptr); 
     778                dev->last_rx = jiffies; 
     779                dev->stats.rx_packets++; 
     780                dev->stats.rx_bytes += (descptr->len-4); 
     781 
     782                /* put new skb into descriptor */ 
     783                descptr->skb_ptr = new_skb; 
     784                descptr->buf = cpu_to_le32(pci_map_single(priv->pdev, 
     785                        descptr->skb_ptr->data, 
     786                        MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
     787 
     788next_descr:              
     789                /* put the descriptor back to the MAC */ 
     790                descptr->status = DESC_STATUS_OWNER_MAC; 
     791                descptr = descptr->vndescp; 
     792                count++; /* shall we count errors and dropped packets as well? */ 
     793        } /* while (limit && !(descptr->status & DESC_STATUS_OWNER_MAC)) */ 
     794 
     795        /* remember next descriptor to check for rx */ 
     796        priv->rx_remove_ptr = descptr; 
    793797 
    794798        return count; 
     
    814818                        dev->stats.tx_carrier_errors++; 
    815819 
    816                 dbg(DBG_TX_IRQ, "descptr %p status x%x err x%x\n", 
    817                     descptr, descptr->status, err); 
     820                dbg(DBG_TX_DONE, "descptr %p status x%x err x%x jiffies %lu\n", 
     821                    descptr, descptr->status, err, jiffies); 
    818822 
    819823                if (descptr->status & 0x8000) 
     
    867871        status = ioread16(ioaddr + MISR); 
    868872 
    869         dbg(DBG_IRQ, "status x%x\n", status); 
     873        dbg(DBG_IRQ, "status x%x jiffies %lu\n", status, jiffies); 
    870874 
    871875        if (status == 0x0000 || status == 0xffff) 
     
    886890 
    887891        /* rx FIFO full */ 
    888         if (status & (1<<2)) { 
     892        if (status & RX_FIFO_FULL) { 
    889893                dev->stats.rx_fifo_errors++; 
    890894        } 
     
    907911 
    908912/* Init RDC MAC */ 
    909 void r6040_up(struct net_device *dev) 
     913int r6040_up(struct net_device *dev) 
    910914{ 
    911915        struct r6040_private *lp = netdev_priv(dev); 
    912916        void __iomem *ioaddr = lp->base; 
     917        int rc; 
    913918 
    914919        dbg(DBG_INIT, "ENTER\n"); 
    915920 
    916921        /* Initialise and alloc RX/TX buffers */ 
    917         r6040_alloc_txbufs(dev); 
    918         r6040_alloc_rxbufs(dev); 
     922        r6040_init_txbufs(dev); 
     923        if ((rc=r6040_alloc_rxbufs(dev))) 
     924                return rc; 
    919925 
    920926        /* Read the PHY ID */ 
     
    946952        /* Reset MAC and init all registers */ 
    947953        r6040_init_mac_regs(lp); 
     954 
     955        return 0; 
    948956} 
    949957 
     
    10081016        dbg(DBG_OPEN, "allocated tx ring\n"); 
    10091017 
    1010         r6040_up(dev); 
    1011  
     1018        if ((ret=r6040_up(dev))) { 
     1019                pci_free_consistent(lp->pdev, TX_DESC_SIZE, lp->tx_ring, 
     1020                                    lp->tx_ring_dma); 
     1021                pci_free_consistent(lp->pdev, RX_DESC_SIZE, lp->rx_ring, 
     1022                                     lp->rx_ring_dma); 
     1023                return ret; 
     1024        } 
     1025                 
    10121026        napi_enable(&lp->napi); 
    10131027        netif_start_queue(dev); 
     
    10551069                skb->data, skb->len, PCI_DMA_TODEVICE)); 
    10561070 
    1057         dbg(DBG_TX_DESCR, "desc @ %p: len x%x buf %08x skb->data %p skb->len x%x\n", 
    1058             descptr, descptr->len, descptr->buf, skb->data, skb->len); 
     1071        dbg(DBG_TX_DESCR, "desc @ %p: len x%x buf %08x skb->data %p skb->len x%x jiffies %lu\n", 
     1072            descptr, descptr->len, descptr->buf, skb->data, skb->len, jiffies); 
    10591073 
    10601074        { 
     
    12561270        SET_NETDEV_DEV(dev, &pdev->dev); 
    12571271        lp = netdev_priv(dev); 
    1258         lp->pdev = pdev; 
    1259         lp->dev = dev; 
    12601272 
    12611273        if (pci_request_regions(pdev, DRV_NAME)) { 
     
    12831295        /* Link new device into r6040_root_dev */ 
    12841296        lp->pdev = pdev; 
     1297 
     1298        lp->dev = dev; 
    12851299 
    12861300        /* Init RDC private data */ 
Note: See TracChangeset for help on using the changeset viewer.