Changeset 10754


Ignore:
Timestamp:
2008-04-07T09:50:45+02:00 (10 years ago)
Author:
florian
Message:

Use an update r6040 driver

File:
1 edited

Legend:

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

    r10453 r10754  
    6262/* Time in jiffies before concluding the transmitter is hung. */ 
    6363#define TX_TIMEOUT      (6000 * HZ / 1000) 
    64 #define TIMER_WUT       (jiffies + HZ * 1)/* timer wakeup time : 1 second */ 
    6564 
    6665/* RDC MAC I/O Size */ 
     
    175174        struct mii_if_info mii_if; 
    176175        struct napi_struct napi; 
    177         struct net_device_stats stats; 
    178         u16     napi_rx_running; 
    179176        void __iomem *base; 
    180177}; 
     
    236233} 
    237234 
    238 static void r6040_tx_timeout(struct net_device *dev) 
    239 { 
    240         struct r6040_private *priv = netdev_priv(dev); 
    241  
    242         disable_irq(dev->irq); 
    243         napi_disable(&priv->napi); 
    244         spin_lock(&priv->lock); 
    245         dev->stats.tx_errors++; 
    246         spin_unlock(&priv->lock); 
    247  
    248         netif_stop_queue(dev); 
     235static void r6040_free_txbufs(struct net_device *dev) 
     236{ 
     237        struct r6040_private *lp = netdev_priv(dev); 
     238        int i; 
     239 
     240        for (i = 0; i < TX_DCNT; i++) { 
     241                if (lp->tx_insert_ptr->skb_ptr) { 
     242                        pci_unmap_single(lp->pdev, 
     243                                le32_to_cpu(lp->tx_insert_ptr->buf), 
     244                                MAX_BUF_SIZE, PCI_DMA_TODEVICE); 
     245                        dev_kfree_skb(lp->tx_insert_ptr->skb_ptr); 
     246                        lp->rx_insert_ptr->skb_ptr = NULL; 
     247                } 
     248                lp->tx_insert_ptr = lp->tx_insert_ptr->vndescp; 
     249        } 
     250} 
     251 
     252static void r6040_free_rxbufs(struct net_device *dev) 
     253{ 
     254        struct r6040_private *lp = netdev_priv(dev); 
     255        int i; 
     256 
     257        for (i = 0; i < RX_DCNT; i++) { 
     258                if (lp->rx_insert_ptr->skb_ptr) { 
     259                        pci_unmap_single(lp->pdev, 
     260                                le32_to_cpu(lp->rx_insert_ptr->buf), 
     261                                MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
     262                        dev_kfree_skb(lp->rx_insert_ptr->skb_ptr); 
     263                        lp->rx_insert_ptr->skb_ptr = NULL; 
     264                } 
     265                lp->rx_insert_ptr = lp->rx_insert_ptr->vndescp; 
     266        } 
     267} 
     268 
     269static void r6040_init_ring_desc(struct r6040_descriptor *desc_ring, 
     270                                 dma_addr_t desc_dma, int size) 
     271{ 
     272        struct r6040_descriptor *desc = desc_ring; 
     273        dma_addr_t mapping = desc_dma; 
     274 
     275        while (size-- > 0) { 
     276                mapping += sizeof(sizeof(*desc)); 
     277                desc->ndesc = cpu_to_le32(mapping); 
     278                desc->vndescp = desc + 1; 
     279                desc++; 
     280        } 
     281        desc--; 
     282        desc->ndesc = cpu_to_le32(desc_dma); 
     283        desc->vndescp = desc_ring; 
    249284} 
    250285 
     
    257292        descptr = lp->rx_insert_ptr; 
    258293        while (lp->rx_free_desc < RX_DCNT) { 
    259                 descptr->skb_ptr = dev_alloc_skb(MAX_BUF_SIZE); 
     294                descptr->skb_ptr = netdev_alloc_skb(dev, MAX_BUF_SIZE); 
    260295 
    261296                if (!descptr->skb_ptr) 
     
    273308} 
    274309 
     310static void r6040_alloc_txbufs(struct net_device *dev) 
     311{ 
     312        struct r6040_private *lp = netdev_priv(dev); 
     313        void __iomem *ioaddr = lp->base; 
     314 
     315        lp->tx_free_desc = TX_DCNT; 
     316 
     317        lp->tx_remove_ptr = lp->tx_insert_ptr = lp->tx_ring; 
     318        r6040_init_ring_desc(lp->tx_ring, lp->tx_ring_dma, TX_DCNT); 
     319 
     320        iowrite16(lp->tx_ring_dma, ioaddr + MTD_SA0); 
     321        iowrite16(lp->tx_ring_dma >> 16, ioaddr + MTD_SA1); 
     322} 
     323 
     324static void r6040_alloc_rxbufs(struct net_device *dev) 
     325{ 
     326        struct r6040_private *lp = netdev_priv(dev); 
     327        void __iomem *ioaddr = lp->base; 
     328 
     329        lp->rx_free_desc = 0; 
     330 
     331        lp->rx_remove_ptr = lp->rx_insert_ptr = lp->rx_ring; 
     332        r6040_init_ring_desc(lp->rx_ring, lp->rx_ring_dma, RX_DCNT); 
     333 
     334        rx_buf_alloc(lp, dev); 
     335 
     336        iowrite16(lp->rx_ring_dma, ioaddr + MRD_SA0); 
     337        iowrite16(lp->rx_ring_dma >> 16, ioaddr + MRD_SA1); 
     338} 
     339 
     340static void r6040_tx_timeout(struct net_device *dev) 
     341{ 
     342        struct r6040_private *priv = netdev_priv(dev); 
     343        void __iomem *ioaddr = priv->base; 
     344 
     345        printk(KERN_WARNING "%s: transmit timed out, status %4.4x, PHY status " 
     346                "%4.4x\n", 
     347                dev->name, ioread16(ioaddr + MIER), 
     348                mdio_read(dev, priv->mii_if.phy_id, MII_BMSR)); 
     349 
     350        disable_irq(dev->irq); 
     351        napi_disable(&priv->napi); 
     352        spin_lock(&priv->lock); 
     353        /* Clear all descriptors */ 
     354        r6040_free_txbufs(dev); 
     355        r6040_free_rxbufs(dev); 
     356        r6040_alloc_txbufs(dev); 
     357        r6040_alloc_rxbufs(dev); 
     358 
     359        /* Reset MAC */ 
     360        iowrite16(MAC_RST, ioaddr + MCR1); 
     361        spin_unlock(&priv->lock); 
     362        enable_irq(dev->irq); 
     363 
     364        dev->stats.tx_errors++; 
     365        netif_wake_queue(dev); 
     366} 
    275367 
    276368static struct net_device_stats *r6040_get_stats(struct net_device *dev) 
     
    281373 
    282374        spin_lock_irqsave(&priv->lock, flags); 
    283         priv->stats.rx_crc_errors += ioread8(ioaddr + ME_CNT1); 
    284         priv->stats.multicast += ioread8(ioaddr + ME_CNT0); 
     375        dev->stats.rx_crc_errors += ioread8(ioaddr + ME_CNT1); 
     376        dev->stats.multicast += ioread8(ioaddr + ME_CNT0); 
    285377        spin_unlock_irqrestore(&priv->lock, flags); 
    286378 
    287         return &priv->stats; 
     379        return &dev->stats; 
    288380} 
    289381 
     
    294386        void __iomem *ioaddr = lp->base; 
    295387        struct pci_dev *pdev = lp->pdev; 
    296         int i; 
    297388        int limit = 2048; 
    298389        u16 *adrp; 
     
    314405        iowrite16(adrp[2], ioaddr + MID_0H); 
    315406        free_irq(dev->irq, dev); 
     407 
    316408        /* Free RX buffer */ 
    317         for (i = 0; i < RX_DCNT; i++) { 
    318                 if (lp->rx_insert_ptr->skb_ptr) { 
    319                         pci_unmap_single(lp->pdev, lp->rx_insert_ptr->buf, 
    320                                 MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    321                         dev_kfree_skb(lp->rx_insert_ptr->skb_ptr); 
    322                         lp->rx_insert_ptr->skb_ptr = NULL; 
    323                 } 
    324                 lp->rx_insert_ptr = lp->rx_insert_ptr->vndescp; 
    325         } 
     409        r6040_free_rxbufs(dev); 
    326410 
    327411        /* Free TX buffer */ 
    328         for (i = 0; i < TX_DCNT; i++) { 
    329                 if (lp->tx_insert_ptr->skb_ptr) { 
    330                         pci_unmap_single(lp->pdev, lp->tx_insert_ptr->buf, 
    331                                 MAX_BUF_SIZE, PCI_DMA_TODEVICE); 
    332                         dev_kfree_skb(lp->tx_insert_ptr->skb_ptr); 
    333                         lp->rx_insert_ptr->skb_ptr = NULL; 
    334                 } 
    335                 lp->tx_insert_ptr = lp->tx_insert_ptr->vndescp; 
    336         } 
     412        r6040_free_txbufs(dev); 
    337413 
    338414        /* Free Descriptor memory */ 
     
    433509                /* Check for errors */ 
    434510                err = ioread16(ioaddr + MLSR); 
    435                 if (err & 0x0400) priv->stats.rx_errors++; 
     511                if (err & 0x0400) 
     512                        dev->stats.rx_errors++; 
    436513                /* RX FIFO over-run */ 
    437                 if (err & 0x8000) priv->stats.rx_fifo_errors++; 
     514                if (err & 0x8000) 
     515                        dev->stats.rx_fifo_errors++; 
    438516                /* RX descriptor unavailable */ 
    439                 if (err & 0x0080) priv->stats.rx_frame_errors++; 
     517                if (err & 0x0080) 
     518                        dev->stats.rx_frame_errors++; 
    440519                /* Received packet with length over buffer lenght */ 
    441                 if (err & 0x0020) priv->stats.rx_over_errors++; 
     520                if (err & 0x0020) 
     521                        dev->stats.rx_over_errors++; 
    442522                /* Received packet with too long or short */ 
    443                 if (err & (0x0010|0x0008)) priv->stats.rx_length_errors++; 
     523                if (err & (0x0010 | 0x0008)) 
     524                        dev->stats.rx_length_errors++; 
    444525                /* Received packet with CRC errors */ 
    445526                if (err & 0x0004) { 
    446527                        spin_lock(&priv->lock); 
    447                         priv->stats.rx_crc_errors++; 
     528                        dev->stats.rx_crc_errors++; 
    448529                        spin_unlock(&priv->lock); 
    449530                } 
     
    464545                        /* Do not count the CRC */ 
    465546                        skb_put(skb_ptr, descptr->len - 4); 
    466                         pci_unmap_single(priv->pdev, descptr->buf, 
     547                        pci_unmap_single(priv->pdev, le32_to_cpu(descptr->buf), 
    467548                                MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    468549                        skb_ptr->protocol = eth_type_trans(skb_ptr, priv->dev); 
     
    470551                        netif_receive_skb(skb_ptr); 
    471552                        dev->last_rx = jiffies; 
    472                         priv->dev->stats.rx_packets++; 
    473                         priv->dev->stats.rx_bytes += descptr->len; 
     553                        dev->stats.rx_packets++; 
     554                        dev->stats.rx_bytes += descptr->len; 
    474555                        /* To next descriptor */ 
    475556                        descptr = descptr->vndescp; 
     
    499580                err = ioread16(ioaddr + MLSR); 
    500581 
    501                 if (err & 0x0200) priv->stats.rx_fifo_errors++; 
    502                 if (err & (0x2000 | 0x4000)) priv->stats.tx_carrier_errors++; 
     582                if (err & 0x0200) 
     583                        dev->stats.rx_fifo_errors++; 
     584                if (err & (0x2000 | 0x4000)) 
     585                        dev->stats.tx_carrier_errors++; 
    503586 
    504587                if (descptr->status & 0x8000) 
    505                         break; /* Not complte */ 
     588                        break; /* Not complete */ 
    506589                skb_ptr = descptr->skb_ptr; 
    507                 pci_unmap_single(priv->pdev, descptr->buf, 
     590                pci_unmap_single(priv->pdev, le32_to_cpu(descptr->buf), 
    508591                        skb_ptr->len, PCI_DMA_TODEVICE); 
    509592                /* Free buffer */ 
     
    546629        void __iomem *ioaddr = lp->base; 
    547630        u16 status; 
    548         int handled = 1; 
    549631 
    550632        /* Mask off RDC MAC interrupt */ 
     
    566648                r6040_tx(dev); 
    567649 
    568         return IRQ_RETVAL(handled); 
     650        return IRQ_HANDLED; 
    569651} 
    570652 
     
    578660#endif 
    579661 
    580 static void r6040_init_ring_desc(struct r6040_descriptor *desc_ring, 
    581                                  dma_addr_t desc_dma, int size) 
    582 { 
    583         struct r6040_descriptor *desc = desc_ring; 
    584         dma_addr_t mapping = desc_dma; 
    585  
    586         while (size-- > 0) { 
    587                 mapping += sizeof(sizeof(*desc)); 
    588                 desc->ndesc = cpu_to_le32(mapping); 
    589                 desc->vndescp = desc + 1; 
    590                 desc++; 
    591         } 
    592         desc--; 
    593         desc->ndesc = cpu_to_le32(desc_dma); 
    594         desc->vndescp = desc_ring; 
    595 } 
    596  
    597662/* Init RDC MAC */ 
    598663static void r6040_up(struct net_device *dev) 
     
    601666        void __iomem *ioaddr = lp->base; 
    602667 
    603         /* Initialize */ 
    604         lp->tx_free_desc = TX_DCNT; 
    605         lp->rx_free_desc = 0; 
    606         /* Init descriptor */ 
    607         lp->tx_remove_ptr = lp->tx_insert_ptr = lp->tx_ring; 
    608         lp->rx_remove_ptr = lp->rx_insert_ptr = lp->rx_ring; 
    609         /* Init TX descriptor */ 
    610         r6040_init_ring_desc(lp->tx_ring, lp->tx_ring_dma, TX_DCNT); 
    611  
    612         /* Init RX descriptor */ 
    613         r6040_init_ring_desc(lp->rx_ring, lp->rx_ring_dma, RX_DCNT); 
    614  
    615         /* Allocate buffer for RX descriptor */ 
    616         rx_buf_alloc(lp, dev); 
    617  
    618         /* 
    619          * TX and RX descriptor start registers. 
    620          * Lower 16-bits to MxD_SA0. Higher 16-bits to MxD_SA1. 
    621          */ 
    622         iowrite16(lp->tx_ring_dma, ioaddr + MTD_SA0); 
    623         iowrite16(lp->tx_ring_dma >> 16, ioaddr + MTD_SA1); 
    624  
    625         iowrite16(lp->rx_ring_dma, ioaddr + MRD_SA0); 
    626         iowrite16(lp->rx_ring_dma >> 16, ioaddr + MRD_SA1); 
     668        /* Initialise and alloc RX/TX buffers */ 
     669        r6040_alloc_txbufs(dev); 
     670        r6040_alloc_rxbufs(dev); 
    627671 
    628672        /* Buffer Size Register */ 
     
    690734 
    691735        /* Timer active again */ 
    692         lp->timer.expires = TIMER_WUT; 
    693         add_timer(&lp->timer); 
     736        mod_timer(&lp->timer, jiffies + round_jiffies(HZ)); 
    694737} 
    695738 
     
    747790        netif_start_queue(dev); 
    748791 
    749         if (lp->switch_sig != ICPLUS_PHY_ID) { 
    750                 /* set and active a timer process */ 
    751                 init_timer(&lp->timer); 
    752                 lp->timer.expires = TIMER_WUT; 
    753                 lp->timer.data = (unsigned long)dev; 
    754                 lp->timer.function = &r6040_timer; 
    755                 add_timer(&lp->timer); 
    756         } 
     792        /* set and active a timer process */ 
     793        setup_timer(&lp->timer, r6040_timer, (unsigned long) dev); 
     794        if (lp->switch_sig != ICPLUS_PHY_ID) 
     795                mod_timer(&lp->timer, jiffies + HZ); 
    757796        return 0; 
    758797} 
Note: See TracChangeset for help on using the changeset viewer.