Changeset 11507


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

This patch applies to the RDC 32xx ethernet driver (svn r10754, first patch applied) and fixes the following issues:

  • re-added the parent parameter to specify a netdevice to steal the MAC address from (optional).
  • fixed null pointer access in r6040_rx() (lp->dev init. was missing)
  • fixed "scheduling while atomic" endless loop if tx_timeout() was called (caused by the re-allocs of the buffers)
  • fixed tx timeouts (tx irq weren't re-enabled on rx irq)

It adds some defines and cleans the code a bit (IMHO).

Signed-Off by Joerg Albert <jal2@…>

File:
1 edited

Legend:

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

    r11506 r11507  
    129129#define MIER            0x40    /* INT enable register */ 
    130130#define  MSK_INT        0x0000  /* Mask off interrupts */ 
     131#define  RX_FINISH      0x0001  /* rx finished irq */ 
     132#define  RX_NO_DESC     0x0002  /* rx no descr. avail. irq */ 
     133#define  RX_FIFO_FULL   0x0004  /* rx fifo full irq */ 
     134#define  RX_EARLY       0x0008  /* rx early irq */ 
     135#define  TX_FINISH      0x0010  /* tx finished irq */ 
     136#define  TX_EARLY       0x0080  /* tx early irq */ 
     137#define  EVENT_OVRFL    0x0100  /* event counter overflow irq */ 
     138#define  LINK_CHANGED   0x0200  /* PHY link changed irq */ 
     139 
    131140#define ME_CISR         0x44    /* Event counter INT status */ 
    132141#define ME_CIER         0x48    /* Event counter INT enable  */ 
     
    165174#define RX_DESC_SIZE    (RX_DCNT * sizeof(struct r6040_descriptor)) 
    166175#define TX_DESC_SIZE    (TX_DCNT * sizeof(struct r6040_descriptor)) 
    167 #define MBCR_DEFAULT    0x012A  /* MAC Bus Control Register */ 
     176#define MBCR_DEFAULT    0x012A  /* MAC Bus Control Register:  
     177                                   - wait 1 host clock until SDRAM bus request 
     178                                     becomes high priority 
     179                                   - RX FIFO: 32 byte 
     180                                   - TX FIFO: 64 byte 
     181                                   - FIFO transfer length: 16 byte */ 
    168182#define MCAST_MAX       4       /* Max number multicast addresses to filter */ 
    169183 
     
    177191MODULE_DESCRIPTION("RDC R6040 NAPI PCI FastEthernet driver"); 
    178192 
    179 #define RX_INT                         0x0001 
    180 #define TX_INT                         0x0010 
    181 #define RX_NO_DESC_INT                 0x0002 
    182 #define INT_MASK                 (RX_INT | TX_INT) 
     193/*! which rx interrupts do we allow */ 
     194#define RX_INTS                        (RX_FIFO_FULL|RX_NO_DESC|RX_FINISH) 
     195/*! which tx interrupts do we allow */ 
     196#define TX_INTS                        (TX_FINISH) 
     197#define INT_MASK                 (RX_INTS | TX_INTS) 
    183198 
    184199struct r6040_descriptor { 
     
    214229}; 
    215230 
     231struct net_device *parent_dev; 
     232static char *parent; 
     233module_param(parent, charp, 0444); 
     234MODULE_PARM_DESC(parent, "Parent network device name to get the MAC address from"); 
     235 
    216236static char version[] __devinitdata = KERN_INFO DRV_NAME 
    217237        ": RDC R6040 NAPI net driver," 
     
    219239 
    220240static int phy_table[] = { PHY1_ADDR, PHY2_ADDR }; 
     241 
     242/* forward declarations */ 
     243void r6040_multicast_list(struct net_device *dev); 
    221244 
    222245/* jal2: comment out to get more symbols for debugging */ 
     
    363386 
    364387        while (size-- > 0) { 
    365                 mapping += sizeof(sizeof(*desc)); 
     388                mapping += sizeof(*desc); 
    366389                desc->ndesc = cpu_to_le32(mapping); 
    367390                desc->vndescp = desc + 1; 
     
    377400{ 
    378401        struct r6040_descriptor *descptr; 
    379         void __iomem *ioaddr = lp->base; 
    380402 
    381403        dbg(DBG_RX_BUF, "rx_insert %p rx_free_desc x%x dev %p\n", 
     
    400422                descptr = descptr->vndescp; 
    401423                lp->rx_free_desc++; 
    402                 /* Trigger RX DMA */ 
    403                 iowrite16(lp->mcr0 | 0x0002, ioaddr); 
    404424        } 
    405425        lp->rx_insert_ptr = descptr; 
     
    433453{ 
    434454        struct r6040_private *lp = netdev_priv(dev); 
    435         void __iomem *ioaddr = lp->base; 
    436455 
    437456        lp->tx_free_desc = TX_DCNT; 
     
    445464        } 
    446465#endif 
    447         iowrite16(lp->tx_ring_dma, ioaddr + MTD_SA0); 
    448         iowrite16(lp->tx_ring_dma >> 16, ioaddr + MTD_SA1); 
    449466} 
    450467 
     
    476493{ 
    477494        struct r6040_private *lp = netdev_priv(dev); 
    478         void __iomem *ioaddr = lp->base; 
    479495 
    480496        lp->rx_free_desc = 0; 
     
    490506        } 
    491507#endif 
    492  
     508} 
     509 
     510/*! reset MAC and set all registers */ 
     511void r6040_init_mac_regs(struct r6040_private *lp) 
     512{ 
     513        void __iomem *ioaddr = lp->base; 
     514        int limit; 
     515        char obuf[3*ETH_ALEN] __attribute__ ((unused)); 
     516 
     517        /* Mask Off Interrupt */ 
     518        iowrite16(MSK_INT, ioaddr + MIER); 
     519 
     520        /* reset MAC */ 
     521        iowrite16(MAC_RST, ioaddr + MCR1); 
     522        udelay(100); 
     523        limit=2048; 
     524        while ((ioread16(ioaddr + MCR1) & MAC_RST) && limit-- > 0); 
     525 
     526        /* Reset internal state machine */ 
     527        iowrite16(2, ioaddr + MAC_SM); 
     528        iowrite16(0, ioaddr + MAC_SM); 
     529        udelay(5000); 
     530 
     531        /* Restore MAC Addresses */ 
     532        r6040_multicast_list(lp->dev); 
     533 
     534        /* TODO: restore multcast and hash table */ 
     535 
     536        /* MAC Bus Control Register */ 
     537        iowrite16(MBCR_DEFAULT, ioaddr + MBCR); 
     538 
     539        /* Buffer Size Register */ 
     540        iowrite16(MAX_BUF_SIZE, ioaddr + MR_BSR); 
     541 
     542        /* write tx ring start address */ 
     543        iowrite16(lp->tx_ring_dma, ioaddr + MTD_SA0); 
     544        iowrite16(lp->tx_ring_dma >> 16, ioaddr + MTD_SA1); 
     545 
     546        /* write rx ring start address */ 
    493547        iowrite16(lp->rx_ring_dma, ioaddr + MRD_SA0); 
    494548        iowrite16(lp->rx_ring_dma >> 16, ioaddr + MRD_SA1); 
     549 
     550        /* set interrupt waiting time and packet numbers */ 
     551        iowrite16(0x0F06, ioaddr + MT_ICR); 
     552        iowrite16(0x0F06, ioaddr + MR_ICR); 
     553 
     554        /* enable interrupts */ 
     555        iowrite16(INT_MASK, ioaddr + MIER); 
     556 
     557        /* enable tx and rx */ 
     558        iowrite16(lp->mcr0 | 0x0002, ioaddr); 
     559 
     560        /* let TX poll the descriptors - we may got called by r6040_tx_timeout which has left 
     561           some unsent tx buffers */ 
     562        iowrite16(0x01, ioaddr + MTPR); 
    495563} 
    496564 
     
    500568        void __iomem *ioaddr = priv->base; 
    501569 
    502         printk(KERN_WARNING "%s: transmit timed out, status %4.4x, PHY status " 
    503                 "%4.4x\n", 
    504                 dev->name, ioread16(ioaddr + MIER), 
    505                 mdio_read(dev, priv->mii_if.phy_id, MII_BMSR)); 
    506  
    507         disable_irq(dev->irq); 
    508         napi_disable(&priv->napi); 
    509         spin_lock(&priv->lock); 
    510         /* Clear all descriptors */ 
    511         r6040_free_txbufs(dev); 
    512         r6040_free_rxbufs(dev); 
    513         r6040_alloc_txbufs(dev); 
    514         r6040_alloc_rxbufs(dev); 
    515  
    516         /* Reset MAC */ 
    517         iowrite16(MAC_RST, ioaddr + MCR1); 
    518         spin_unlock(&priv->lock); 
    519         enable_irq(dev->irq); 
     570        /* we read MISR, which clears on read (i.e. we may loose an RX interupt, 
     571           but this is an error anyhow ... */ 
     572        printk(KERN_WARNING "%s: transmit timed out, int enable %4.4x " 
     573               "status %4.4x, PHY status %4.4x\n", 
     574               dev->name, ioread16(ioaddr + MIER), 
     575               ioread16(ioaddr + MISR), 
     576               mdio_read(dev, priv->mii_if.phy_id, MII_BMSR)); 
    520577 
    521578        dev->stats.tx_errors++; 
    522         netif_wake_queue(dev); 
     579 
     580        /* Reset MAC and re-init all registers */ 
     581        r6040_init_mac_regs(priv); 
    523582} 
    524583 
     
    544603        struct pci_dev *pdev = lp->pdev; 
    545604        int limit = 2048; 
    546         u16 *adrp; 
    547         u16 cmd; 
    548605 
    549606        dbg(DBG_EXIT, "ENTER\n"); 
     
    552609        iowrite16(MSK_INT, ioaddr + MIER);      /* Mask Off Interrupt */ 
    553610        iowrite16(MAC_RST, ioaddr + MCR1);      /* Reset RDC MAC */ 
    554         while (limit--) { 
    555                 cmd = ioread16(ioaddr + MCR1); 
    556                 if (cmd & 0x1) 
    557                         break; 
    558         } 
     611        udelay(100); 
     612        while ((ioread16(ioaddr+MCR1) & 1) && limit-- > 0); 
    559613 
    560614        if (limit <= 0) 
    561                 err("timeout while waiting for reset\n"); 
    562  
    563         /* Restore MAC Address to MIDx */ 
    564         adrp = (u16 *) dev->dev_addr; 
    565         iowrite16(adrp[0], ioaddr + MID_0L); 
    566         iowrite16(adrp[1], ioaddr + MID_0M); 
    567         iowrite16(adrp[2], ioaddr + MID_0H); 
     615                err("timeout while waiting for reset done.\n"); 
     616 
    568617        free_irq(dev->irq, dev); 
    569618 
     
    671720                struct sk_buff *skb_ptr; 
    672721 
    673                 /* Disable RX interrupt */ 
    674                 iowrite16(ioread16(ioaddr + MIER) & (~RX_INT), ioaddr + MIER); 
    675722                descptr = priv->rx_remove_ptr; 
    676723 
     
    804851                netif_rx_complete(dev, napi); 
    805852                /* Enable RX interrupt */ 
    806                 iowrite16(ioread16(ioaddr + MIER) | RX_INT, ioaddr + MIER); 
     853                iowrite16(ioread16(ioaddr + MIER) | RX_INTS, ioaddr + MIER); 
    807854        } 
    808855        return work_done; 
     
    817864        u16 status; 
    818865 
    819         /* Mask off RDC MAC interrupt */ 
    820         iowrite16(MSK_INT, ioaddr + MIER); 
    821866        /* Read MISR status and clear */ 
    822867        status = ioread16(ioaddr + MISR); 
     
    827872                return IRQ_NONE; 
    828873 
    829         /* RX interrupt request */ 
    830         if (status & 0x01) { 
     874        /* rx early / rx finish interrupt 
     875           or rx descriptor unavail. */ 
     876        if (status & RX_INTS) { 
     877                if (status & RX_NO_DESC) { 
     878                        /* rx descriptor unavail. */ 
     879                        dev->stats.rx_dropped++; 
     880                        dev->stats.rx_missed_errors++; 
     881                } 
     882                /* Mask off RX interrupts */ 
     883                iowrite16(ioread16(ioaddr + MIER) & ~RX_INTS, ioaddr + MIER); 
    831884                netif_rx_schedule(dev, &lp->napi); 
    832                 iowrite16(TX_INT, ioaddr + MIER); 
    833         } 
    834  
     885        } 
     886 
     887        /* rx FIFO full */ 
     888        if (status & (1<<2)) { 
     889                dev->stats.rx_fifo_errors++; 
     890        } 
     891         
    835892        /* TX interrupt request */ 
    836893        if (status & 0x10) 
     
    861918        r6040_alloc_rxbufs(dev); 
    862919 
    863         /* Buffer Size Register */ 
    864         iowrite16(MAX_BUF_SIZE, ioaddr + MR_BSR); 
    865920        /* Read the PHY ID */ 
    866921        lp->switch_sig = phy_read(ioaddr, 0, 2); 
     
    879934                        lp->phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
    880935        } 
    881         /* MAC Bus Control Register */ 
    882         iowrite16(MBCR_DEFAULT, ioaddr + MBCR); 
    883  
    884         /* MAC TX/RX Enable */ 
     936         
     937/* configure duplex mode */ 
    885938        lp->mcr0 |= lp->phy_mode; 
    886         iowrite16(lp->mcr0, ioaddr); 
    887  
    888         /* set interrupt waiting time and packet numbers */ 
    889         iowrite16(0x0F06, ioaddr + MT_ICR); 
    890         iowrite16(0x0F06, ioaddr + MR_ICR); 
    891939 
    892940        /* improve performance (by RDC guys) */ 
     
    896944        phy_write(ioaddr, 0, 30, 0x01F0); 
    897945 
    898         /* Interrupt Mask Register */ 
    899         iowrite16(INT_MASK, ioaddr + MIER); 
     946        /* Reset MAC and init all registers */ 
     947        r6040_init_mac_regs(lp); 
    900948} 
    901949 
     
    926974        /* Timer active again */ 
    927975        mod_timer(&lp->timer, jiffies + round_jiffies(HZ)); 
    928 } 
    929  
    930 /* Read/set MAC address routines */ 
    931 void r6040_mac_address(struct net_device *dev) 
    932 { 
    933         struct r6040_private *lp = netdev_priv(dev); 
    934         void __iomem *ioaddr = lp->base; 
    935         u16 *adrp; 
    936  
    937         /* MAC operation register */ 
    938         iowrite16(0x01, ioaddr + MCR1); /* Reset MAC */ 
    939         iowrite16(2, ioaddr + MAC_SM); /* Reset internal state machine */ 
    940         iowrite16(0, ioaddr + MAC_SM); 
    941         udelay(5000); 
    942  
    943         /* Restore MAC Address */ 
    944         adrp = (u16 *) dev->dev_addr; 
    945         iowrite16(adrp[0], ioaddr + MID_0L); 
    946         iowrite16(adrp[1], ioaddr + MID_0M); 
    947         iowrite16(adrp[2], ioaddr + MID_0H); 
    948  
    949         { 
    950                 char obuf[3*ETH_ALEN] __attribute__ ((unused)); 
    951                 dbg(DBG_MAC_ADDR, "set MAC addr %s\n",  
    952                     hex2str(dev->dev_addr, obuf, ETH_ALEN, ':')); 
    953         } 
    954976} 
    955977 
     
    967989 
    968990        dbg(DBG_OPEN, "got irq %d\n", dev->irq); 
    969  
    970         /* Set MAC address */ 
    971         r6040_mac_address(dev); 
    972991 
    973992        /* Allocate Descriptor memory */ 
     
    10591078} 
    10601079 
     1080/*! set MAC addresses and promiscous mode */ 
    10611081void r6040_multicast_list(struct net_device *dev) 
    10621082{ 
     
    10681088        struct dev_mc_list *dmi = dev->mc_list; 
    10691089        int i; 
     1090        char obuf[3*ETH_ALEN] __attribute__ ((unused)); 
    10701091 
    10711092        /* MAC Address */ 
     
    10741095        iowrite16(adrp[1], ioaddr + MID_0M); 
    10751096        iowrite16(adrp[2], ioaddr + MID_0H); 
     1097 
     1098        dbg(DBG_MAC_ADDR, "%s: set MAC addr %s\n",  
     1099            dev->name, hex2str(dev->dev_addr, obuf, ETH_ALEN, ':')); 
    10761100 
    10771101        /* Promiscous Mode */ 
     
    11961220        int bar = 0; 
    11971221        long pioaddr; 
    1198         u16 *adrp; 
    11991222 
    12001223        printk(KERN_INFO "%s\n", version); 
     
    12341257        lp = netdev_priv(dev); 
    12351258        lp->pdev = pdev; 
     1259        lp->dev = dev; 
    12361260 
    12371261        if (pci_request_regions(pdev, DRV_NAME)) { 
     
    12551279        pci_set_drvdata(pdev, dev); 
    12561280 
    1257         /* Set MAC address */ 
    12581281        card_idx++; 
    1259  
    1260         adrp = (u16 *)dev->dev_addr; 
    1261         adrp[0] = ioread16(ioaddr + MID_0L); 
    1262         adrp[1] = ioread16(ioaddr + MID_0M); 
    1263         adrp[2] = ioread16(ioaddr + MID_0H); 
    12641282 
    12651283        /* Link new device into r6040_root_dev */ 
     
    12831301 
    12841302        { 
    1285         /* jal2: added for debugging only: set fixed mac address. 
    1286            Otherwise we need to call "ifconfig ethX hw ether XX:XX:..." 
    1287            before we can invoke "ifconfig ethX up" */ 
     1303        /* TODO: fix the setting of the MAC address. 
     1304           Right now you must either specify a netdevice with "parent=", whose 
     1305           address is copied or the (default) address of the Sitecom WL-153 
     1306           bootloader is used */ 
    12881307                static const u8 dflt_addr[ETH_ALEN] = {0,0x50,0xfc,2,3,4}; 
    1289                 memcpy(dev->dev_addr, dflt_addr, ETH_ALEN); 
     1308                if (parent_dev) { 
     1309                        memcpy(dev->dev_addr, parent_dev->dev_addr, ETH_ALEN); 
     1310                } else { 
     1311                        printk(KERN_WARNING "%s: no parent - using default mac address\n", 
     1312                               dev->name); 
     1313                        memcpy(dev->dev_addr, dflt_addr, ETH_ALEN); 
     1314                } 
     1315                dev->dev_addr[ETH_ALEN-1] += card_idx; /* + 0 or 1 */ 
    12901316        } 
    12911317 
     
    13491375static int __init r6040_init(void) 
    13501376{ 
     1377        if (parent) 
     1378                parent_dev = dev_get_by_name(&init_net, parent); 
     1379         
    13511380        return pci_register_driver(&r6040_driver); 
    13521381} 
Note: See TracChangeset for help on using the changeset viewer.