Changeset 16021


Ignore:
Timestamp:
2009-05-24T11:16:41+02:00 (9 years ago)
Author:
florian
Message:

backport r6040 mainline fixes to 8.09

File:
1 edited

Legend:

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

    r13243 r16021  
    2525#include <linux/kernel.h> 
    2626#include <linux/module.h> 
    27 #include <linux/version.h> 
    2827#include <linux/moduleparam.h> 
    2928#include <linux/string.h> 
     
    5150 
    5251#define DRV_NAME        "r6040" 
    53 #define DRV_VERSION     "0.19" 
    54 #define DRV_RELDATE     "16Jun2008" 
    55  
    56 /* define bits of a debug mask */ 
    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. */ 
    75  
    76 static int debug = 0; 
    77 module_param(debug, int, 0); 
    78 MODULE_PARM_DESC(debug, "debug mask (-1 for all)"); 
    79  
    80 /* define which debugs are left in the code during compilation */ 
    81 #define DEBUG (-1) /* all debugs */ 
    82  
    83 #define dbg(l, f, ...)                          \ 
    84   do { \ 
    85     if ((DEBUG & l) && (debug & l)) { \ 
    86       printk(KERN_INFO DRV_NAME " %s: " f, __FUNCTION__, ## __VA_ARGS__); \ 
    87     } \ 
    88   } while (0) 
    89  
    90 #define err(f, ...) printk(KERN_WARNING DRV_NAME " %s: " f, __FUNCTION__, ## __VA_ARGS__) 
     52#define DRV_VERSION     "0.22" 
     53#define DRV_RELDATE     "25Mar2009" 
    9154 
    9255/* PHY CHIP Address */ 
    9356#define PHY1_ADDR       1       /* For MAC1 */ 
    94 #define PHY2_ADDR       2       /* For MAC2 */ 
     57#define PHY2_ADDR       3       /* For MAC2 */ 
    9558#define PHY_MODE        0x3100  /* PHY CHIP Register 0 */ 
    9659#define PHY_CAP         0x01E1  /* PHY CHIP Register 4 */ 
     
    12891#define MIER            0x40    /* INT enable register */ 
    12992#define  MSK_INT        0x0000  /* Mask off interrupts */ 
    130 #define  RX_FINISH      0x0001  /* rx finished irq */ 
    131 #define  RX_NO_DESC     0x0002  /* rx no descr. avail. irq */ 
    132 #define  RX_FIFO_FULL   0x0004  /* rx fifo full irq */ 
    133 #define  RX_EARLY       0x0008  /* rx early irq */ 
    134 #define  TX_FINISH      0x0010  /* tx finished irq */ 
    135 #define  TX_EARLY       0x0080  /* tx early irq */ 
    136 #define  EVENT_OVRFL    0x0100  /* event counter overflow irq */ 
    137 #define  LINK_CHANGED   0x0200  /* PHY link changed irq */ 
    138  
     93#define  RX_FINISH      0x0001  /* RX finished */ 
     94#define  RX_NO_DESC     0x0002  /* No RX descriptor available */ 
     95#define  RX_FIFO_FULL   0x0004  /* RX FIFO full */ 
     96#define  RX_EARLY       0x0008  /* RX early */ 
     97#define  TX_FINISH      0x0010  /* TX finished */ 
     98#define  TX_EARLY       0x0080  /* TX early */ 
     99#define  EVENT_OVRFL    0x0100  /* Event counter overflow */ 
     100#define  LINK_CHANGED   0x0200  /* PHY link changed */ 
    139101#define ME_CISR         0x44    /* Event counter INT status */ 
    140102#define ME_CIER         0x48    /* Event counter INT enable  */ 
     
    173135#define RX_DESC_SIZE    (RX_DCNT * sizeof(struct r6040_descriptor)) 
    174136#define TX_DESC_SIZE    (TX_DCNT * sizeof(struct r6040_descriptor)) 
    175 #define MBCR_DEFAULT    0x012A  /* MAC Bus Control Register:  
    176                                    - wait 1 host clock until SDRAM bus request 
    177                                      becomes high priority 
    178                                    - RX FIFO: 32 byte 
    179                                    - TX FIFO: 64 byte 
    180                                    - FIFO transfer length: 16 byte */ 
     137#define MBCR_DEFAULT    0x012A  /* MAC Bus Control Register */ 
    181138#define MCAST_MAX       4       /* Max number multicast addresses to filter */ 
     139 
     140/* Descriptor status */ 
     141#define DSC_OWNER_MAC   0x8000  /* MAC is the owner of this descriptor */ 
     142#define DSC_RX_OK       0x4000  /* RX was successful */ 
     143#define DSC_RX_ERR      0x0800  /* RX PHY error */ 
     144#define DSC_RX_ERR_DRI  0x0400  /* RX dribble packet */ 
     145#define DSC_RX_ERR_BUF  0x0200  /* RX length exceeds buffer size */ 
     146#define DSC_RX_ERR_LONG 0x0100  /* RX length > maximum packet length */ 
     147#define DSC_RX_ERR_RUNT 0x0080  /* RX packet length < 64 byte */ 
     148#define DSC_RX_ERR_CRC  0x0040  /* RX CRC error */ 
     149#define DSC_RX_BCAST    0x0020  /* RX broadcast (no error) */ 
     150#define DSC_RX_MCAST    0x0010  /* RX multicast (no error) */ 
     151#define DSC_RX_MCH_HIT  0x0008  /* RX multicast hit in hash table (no error) */ 
     152#define DSC_RX_MIDH_HIT 0x0004  /* RX MID table hit (no error) */ 
     153#define DSC_RX_IDX_MID_MASK 3   /* RX mask for the index of matched MIDx */ 
    182154 
    183155/* PHY settings */ 
     
    189161MODULE_LICENSE("GPL"); 
    190162MODULE_DESCRIPTION("RDC R6040 NAPI PCI FastEthernet driver"); 
    191  
    192 /*! which rx interrupts do we allow */ 
    193 #define RX_INTS                        (RX_FIFO_FULL|RX_NO_DESC|RX_FINISH) 
    194 /*! which tx interrupts do we allow */ 
    195 #define TX_INTS                        (TX_FINISH) 
    196 #define INT_MASK                 (RX_INTS | TX_INTS) 
     163MODULE_VERSION(DRV_VERSION " " DRV_RELDATE); 
     164 
     165/* RX and TX interrupts that we handle */ 
     166#define RX_INTS                 (RX_FIFO_FULL | RX_NO_DESC | RX_FINISH) 
     167#define TX_INTS                 (TX_FINISH) 
     168#define INT_MASK                (RX_INTS | TX_INTS) 
    197169 
    198170struct r6040_descriptor { 
     
    206178        u32     rev2;                   /* 1C-1F */ 
    207179} __attribute__((aligned(32))); 
    208  
    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 */ 
    223180 
    224181struct r6040_private { 
     
    243200}; 
    244201 
    245 struct net_device *parent_dev; 
    246 static char *parent = "wlan0"; 
    247 module_param(parent, charp, 0444); 
    248 MODULE_PARM_DESC(parent, "Parent network device name to get the MAC address from"); 
    249  
    250202static char version[] __devinitdata = KERN_INFO DRV_NAME 
    251203        ": RDC R6040 NAPI net driver," 
    252         "version "DRV_VERSION " (" DRV_RELDATE ")\n"; 
     204        "version "DRV_VERSION " (" DRV_RELDATE ")"; 
    253205 
    254206static int phy_table[] = { PHY1_ADDR, PHY2_ADDR }; 
    255207 
    256 /* forward declarations */ 
    257 void r6040_multicast_list(struct net_device *dev); 
    258  
    259 /* jal2: comment out to get more symbols for debugging */ 
    260 //#define STATIC static 
    261 #define STATIC 
    262  
    263 #if DEBUG 
    264 /*! hexdump an memory area into a string. delim is taken as the delimiter between two bytes. 
    265     It is omitted if delim == '\0' */ 
    266 STATIC char *hex2str(void *addr, char *buf, int nr_bytes, int delim) 
    267 { 
    268         unsigned char *src = addr; 
    269         char *outb = buf; 
    270  
    271 #define BIN2HEXDIGIT(x) ((x) < 10 ? '0'+(x) : 'A'-10+(x)) 
    272  
    273         while (nr_bytes > 0) { 
    274                 *outb++ = BIN2HEXDIGIT(*src>>4); 
    275                 *outb++ = BIN2HEXDIGIT(*src&0xf); 
    276                 if (delim) 
    277                         *outb++ = delim; 
    278                 nr_bytes--; 
    279                 src++; 
    280         } 
    281  
    282         if (delim) 
    283                 outb--; 
    284         *outb = '\0'; 
    285         return buf; 
    286 } 
    287  
    288 #endif /* #if DEBUG */ 
    289  
    290208/* Read a word data from PHY Chip */ 
    291 STATIC int phy_read(void __iomem *ioaddr, int phy_addr, int reg) 
     209static int r6040_phy_read(void __iomem *ioaddr, int phy_addr, int reg) 
    292210{ 
    293211        int limit = 2048; 
    294212        u16 cmd; 
    295         int rc; 
    296213 
    297214        iowrite16(MDIO_READ + reg + (phy_addr << 8), ioaddr + MMDIO); 
     
    299216        while (limit--) { 
    300217                cmd = ioread16(ioaddr + MMDIO); 
    301                 if (cmd & MDIO_READ) 
     218                if (!(cmd & MDIO_READ)) 
    302219                        break; 
    303220        } 
    304221 
    305         if (limit <= 0) 
    306                 err("phy addr x%x reg x%x timed out\n", 
    307                     phy_addr, reg); 
    308  
    309         rc=ioread16(ioaddr + MMRD); 
    310  
    311         dbg(DBG_PHY, "phy addr x%x reg x%x val x%x\n", phy_addr, reg, rc); 
    312         return rc; 
     222        return ioread16(ioaddr + MMRD); 
    313223} 
    314224 
    315225/* Write a word data from PHY Chip */ 
    316 STATIC void phy_write(void __iomem *ioaddr, int phy_addr, int reg, u16 val) 
     226static void r6040_phy_write(void __iomem *ioaddr, int phy_addr, int reg, u16 val) 
    317227{ 
    318228        int limit = 2048; 
    319229        u16 cmd; 
    320  
    321         dbg(DBG_PHY, "phy addr x%x reg x%x val x%x\n", phy_addr, reg, val); 
    322230 
    323231        iowrite16(val, ioaddr + MMWD); 
     
    327235        while (limit--) { 
    328236                cmd = ioread16(ioaddr + MMDIO); 
    329                 if (cmd & MDIO_WRITE) 
     237                if (!(cmd & MDIO_WRITE)) 
    330238                        break; 
    331239        } 
    332         if (limit <= 0) 
    333                 err("phy addr x%x reg x%x val x%x timed out\n", 
    334                     phy_addr, reg, val); 
    335 } 
    336  
    337 STATIC int mdio_read(struct net_device *dev, int mii_id, int reg) 
     240} 
     241 
     242static int r6040_mdio_read(struct net_device *dev, int mii_id, int reg) 
    338243{ 
    339244        struct r6040_private *lp = netdev_priv(dev); 
    340245        void __iomem *ioaddr = lp->base; 
    341246 
    342         return (phy_read(ioaddr, lp->phy_addr, reg)); 
    343 } 
    344  
    345 STATIC void mdio_write(struct net_device *dev, int mii_id, int reg, int val) 
     247        return (r6040_phy_read(ioaddr, lp->phy_addr, reg)); 
     248} 
     249 
     250static void r6040_mdio_write(struct net_device *dev, int mii_id, int reg, int val) 
    346251{ 
    347252        struct r6040_private *lp = netdev_priv(dev); 
    348253        void __iomem *ioaddr = lp->base; 
    349254 
    350         phy_write(ioaddr, lp->phy_addr, reg, val); 
    351 } 
    352  
    353 void r6040_free_txbufs(struct net_device *dev) 
     255        r6040_phy_write(ioaddr, lp->phy_addr, reg, val); 
     256} 
     257 
     258static void r6040_free_txbufs(struct net_device *dev) 
    354259{ 
    355260        struct r6040_private *lp = netdev_priv(dev); 
    356261        int i; 
    357262 
    358         dbg(DBG_FREE_BUFS, "ENTER\n"); 
    359263        for (i = 0; i < TX_DCNT; i++) { 
    360264                if (lp->tx_insert_ptr->skb_ptr) { 
     
    367271                lp->tx_insert_ptr = lp->tx_insert_ptr->vndescp; 
    368272        } 
    369         dbg(DBG_FREE_BUFS, "EXIT\n"); 
    370 } 
    371  
    372 /*! unmap and free all rx skb */ 
    373 void r6040_free_rxbufs(struct net_device *dev) 
     273} 
     274 
     275static void r6040_free_rxbufs(struct net_device *dev) 
    374276{ 
    375277        struct r6040_private *lp = netdev_priv(dev); 
    376278        int i; 
    377279 
    378         dbg(DBG_FREE_BUFS, "ENTER\n"); 
    379280        for (i = 0; i < RX_DCNT; i++) { 
    380281                if (lp->rx_insert_ptr->skb_ptr) { 
     
    387288                lp->rx_insert_ptr = lp->rx_insert_ptr->vndescp; 
    388289        } 
    389         dbg(DBG_FREE_BUFS, "EXIT\n"); 
    390  
    391 } 
    392  
    393 void r6040_init_ring_desc(struct r6040_descriptor *desc_ring, 
     290} 
     291 
     292static void r6040_init_ring_desc(struct r6040_descriptor *desc_ring, 
    394293                                 dma_addr_t desc_dma, int size) 
    395294{ 
     
    397296        dma_addr_t mapping = desc_dma; 
    398297 
    399         dbg(DBG_RING, "desc_ring %p desc_dma %08x size x%x\n", 
    400             desc_ring, desc_dma, size); 
    401  
    402          
    403298        while (size-- > 0) { 
    404299                mapping += sizeof(*desc); 
    405                 memset(desc, 0, sizeof(*desc)); 
    406300                desc->ndesc = cpu_to_le32(mapping); 
    407301                desc->vndescp = desc + 1; 
    408302                desc++; 
    409303        } 
    410  
    411         /* last descriptor points to first one to close the descriptor ring */ 
    412304        desc--; 
    413305        desc->ndesc = cpu_to_le32(desc_dma); 
     
    415307} 
    416308 
    417 #if (DEBUG & DBG_TX_RING_DUMP) 
    418 /*! dump the tx ring to syslog */ 
    419 STATIC void 
    420 dump_tx_ring(struct r6040_private *lp) 
    421 { 
    422         int i; 
    423         struct r6040_descriptor *ptr; 
    424  
    425         printk(KERN_INFO "%s: nr_desc x%x tx_ring %p tx_ring_dma %08x " 
    426                "tx_insert %p tx_remove %p\n", 
    427                DRV_NAME, TX_DCNT, lp->tx_ring, lp->tx_ring_dma, 
    428                lp->tx_insert_ptr, lp->tx_remove_ptr); 
    429  
    430         if (lp->tx_ring) { 
    431                 for(i=0, ptr=lp->tx_ring; i < TX_DCNT; i++, ptr++) { 
    432                         printk(KERN_INFO "%s: %d. descr: status x%x len x%x " 
    433                                "ndesc %08x vbufp %p vndescp %p skb_ptr %p\n",  
    434                                DRV_NAME, i, ptr->status, ptr->len, 
    435                                ptr->ndesc, ptr->vbufp, ptr->vndescp, ptr->skb_ptr); 
    436                 } 
    437         } 
    438 } 
    439 #endif /* #if (DEBUG & DBG_TX_RING_DUMP) */ 
    440  
    441 void r6040_init_txbufs(struct net_device *dev) 
     309static void r6040_init_txbufs(struct net_device *dev) 
    442310{ 
    443311        struct r6040_private *lp = netdev_priv(dev); 
     
    447315        lp->tx_remove_ptr = lp->tx_insert_ptr = lp->tx_ring; 
    448316        r6040_init_ring_desc(lp->tx_ring, lp->tx_ring_dma, TX_DCNT); 
    449  
    450 #if (DEBUG & DBG_TX_RING_DUMP) 
    451         if (debug & DBG_TX_RING_DUMP) { 
    452                 dump_tx_ring(lp); 
    453         } 
    454 #endif 
    455 } 
    456  
    457 #if (DEBUG & DBG_RX_RING_DUMP) 
    458 /*! dump the rx ring to syslog */ 
    459 STATIC void 
    460 dump_rx_ring(struct r6040_private *lp) 
    461 { 
    462         int i; 
    463         struct r6040_descriptor *ptr; 
    464  
    465         printk(KERN_INFO "%s: nr_desc x%x rx_ring %p rx_ring_dma %08x " 
    466                "rx_insert %p rx_remove %p\n", 
    467                DRV_NAME, RX_DCNT, lp->rx_ring, lp->rx_ring_dma, 
    468                lp->rx_insert_ptr, lp->rx_remove_ptr); 
    469  
    470         if (lp->rx_ring) { 
    471                 for(i=0, ptr=lp->rx_ring; i < RX_DCNT; i++, ptr++) { 
    472                         printk(KERN_INFO "%s: %d. descr: status x%x len x%x " 
    473                                "ndesc %08x vbufp %p vndescp %p skb_ptr %p\n",  
    474                                DRV_NAME, i, ptr->status, ptr->len, 
    475                                ptr->ndesc, ptr->vbufp, ptr->vndescp, ptr->skb_ptr); 
    476                 } 
    477         } 
    478 } 
    479 #endif /* #if (DEBUG & DBG_TX_RING_DUMP) */ 
    480  
    481 int r6040_alloc_rxbufs(struct net_device *dev) 
     317} 
     318 
     319static int r6040_alloc_rxbufs(struct net_device *dev) 
    482320{ 
    483321        struct r6040_private *lp = netdev_priv(dev); 
     
    489327        r6040_init_ring_desc(lp->rx_ring, lp->rx_ring_dma, RX_DCNT); 
    490328 
    491         /* alloc skbs for the rx descriptors */ 
     329        /* Allocate skbs for the rx descriptors */ 
    492330        desc = lp->rx_ring; 
    493331        do { 
    494                 if (!(skb=netdev_alloc_skb(dev, MAX_BUF_SIZE))) { 
    495                         err("failed to alloc skb for rx\n"); 
     332                skb = netdev_alloc_skb(dev, MAX_BUF_SIZE); 
     333                if (!skb) { 
     334                        printk(KERN_ERR DRV_NAME "%s: failed to alloc skb for rx\n", dev->name); 
    496335                        rc = -ENOMEM; 
    497336                        goto err_exit; 
     
    499338                desc->skb_ptr = skb; 
    500339                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; 
     340                                                desc->skb_ptr->data, 
     341                                                MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
     342                desc->status = DSC_OWNER_MAC; 
    504343                desc = desc->vndescp; 
    505344        } while (desc != lp->rx_ring); 
    506345 
    507 #if (DEBUG & DBG_RX_RING_DUMP) 
    508         if (debug & DBG_RX_RING_DUMP) { 
    509                 dump_rx_ring(lp); 
    510         } 
    511 #endif 
    512  
    513346        return 0; 
    514347 
    515348err_exit: 
    516         /* dealloc all previously allocated skb */ 
     349        /* Deallocate all previously allocated skbs */ 
    517350        r6040_free_rxbufs(dev); 
    518351        return rc; 
    519352} 
    520353 
    521 /*! reset MAC and set all registers */ 
    522 void r6040_init_mac_regs(struct r6040_private *lp) 
    523 { 
     354static void r6040_init_mac_regs(struct net_device *dev) 
     355{ 
     356        struct r6040_private *lp = netdev_priv(dev); 
    524357        void __iomem *ioaddr = lp->base; 
    525         int limit; 
    526         char obuf[3*ETH_ALEN] __attribute__ ((unused)); 
     358        int limit = 2048; 
     359        u16 cmd; 
    527360 
    528361        /* Mask Off Interrupt */ 
    529362        iowrite16(MSK_INT, ioaddr + MIER); 
    530363 
    531         /* reset MAC */ 
     364        /* Reset RDC MAC */ 
    532365        iowrite16(MAC_RST, ioaddr + MCR1); 
    533         udelay(100); 
    534         limit=2048; 
    535         while ((ioread16(ioaddr + MCR1) & MAC_RST) && limit-- > 0); 
    536  
     366        while (limit--) { 
     367                cmd = ioread16(ioaddr + MCR1); 
     368                if (cmd & 0x1) 
     369                        break; 
     370        } 
    537371        /* Reset internal state machine */ 
    538372        iowrite16(2, ioaddr + MAC_SM); 
    539373        iowrite16(0, ioaddr + MAC_SM); 
    540         udelay(5000); 
    541  
    542         /* Restore MAC Addresses */ 
    543         r6040_multicast_list(lp->dev); 
    544  
    545         /* TODO: restore multcast and hash table */ 
     374        mdelay(5); 
    546375 
    547376        /* MAC Bus Control Register */ 
     
    551380        iowrite16(MAX_BUF_SIZE, ioaddr + MR_BSR); 
    552381 
    553         /* write tx ring start address */ 
     382        /* Write TX ring start address */ 
    554383        iowrite16(lp->tx_ring_dma, ioaddr + MTD_SA0); 
    555384        iowrite16(lp->tx_ring_dma >> 16, ioaddr + MTD_SA1); 
    556385 
    557         /* write rx ring start address */ 
     386        /* Write RX ring start address */ 
    558387        iowrite16(lp->rx_ring_dma, ioaddr + MRD_SA0); 
    559388        iowrite16(lp->rx_ring_dma >> 16, ioaddr + MRD_SA1); 
    560389 
    561         /* set interrupt waiting time and packet numbers */ 
     390        /* Set interrupt waiting time and packet numbers */ 
    562391        iowrite16(0, ioaddr + MT_ICR); 
    563392        iowrite16(0, ioaddr + MR_ICR); 
    564393 
    565         /* enable interrupts */ 
     394        /* Enable interrupts */ 
    566395        iowrite16(INT_MASK, ioaddr + MIER); 
    567396 
    568         /* enable tx and rx */ 
     397        /* Enable TX and RX */ 
    569398        iowrite16(lp->mcr0 | 0x0002, ioaddr); 
    570399 
    571         /* let TX poll the descriptors - we may got called by r6040_tx_timeout which has left 
    572            some unsent tx buffers */ 
     400        /* Let TX poll the descriptors 
     401         * we may got called by r6040_tx_timeout which has left 
     402         * some unsent tx buffers */ 
    573403        iowrite16(0x01, ioaddr + MTPR); 
    574404} 
    575405 
    576 void r6040_tx_timeout(struct net_device *dev) 
     406static void r6040_tx_timeout(struct net_device *dev) 
    577407{ 
    578408        struct r6040_private *priv = netdev_priv(dev); 
    579409        void __iomem *ioaddr = priv->base; 
    580410 
    581         /* we read MISR, which clears on read (i.e. we may loose an RX interupt, 
    582            but this is an error anyhow ... */ 
    583411        printk(KERN_WARNING "%s: transmit timed out, int enable %4.4x " 
    584                "status %4.4x, PHY status %4.4x\n", 
    585                dev->name, ioread16(ioaddr + MIER), 
    586                ioread16(ioaddr + MISR), 
    587                mdio_read(dev, priv->mii_if.phy_id, MII_BMSR)); 
     412                "status %4.4x, PHY status %4.4x\n", 
     413                dev->name, ioread16(ioaddr + MIER), 
     414                ioread16(ioaddr + MISR), 
     415                r6040_mdio_read(dev, priv->mii_if.phy_id, MII_BMSR)); 
    588416 
    589417        dev->stats.tx_errors++; 
    590418 
    591419        /* Reset MAC and re-init all registers */ 
    592         r6040_init_mac_regs(priv); 
    593 } 
    594  
    595 struct net_device_stats *r6040_get_stats(struct net_device *dev) 
     420        r6040_init_mac_regs(dev); 
     421} 
     422 
     423static struct net_device_stats *r6040_get_stats(struct net_device *dev) 
    596424{ 
    597425        struct r6040_private *priv = netdev_priv(dev); 
     
    608436 
    609437/* Stop RDC MAC and Free the allocated resource */ 
    610 void r6040_down(struct net_device *dev) 
     438static void r6040_down(struct net_device *dev) 
    611439{ 
    612440        struct r6040_private *lp = netdev_priv(dev); 
    613441        void __iomem *ioaddr = lp->base; 
    614         struct pci_dev *pdev = lp->pdev; 
    615442        int limit = 2048; 
    616  
    617         dbg(DBG_EXIT, "ENTER\n"); 
     443        u16 *adrp; 
     444        u16 cmd; 
    618445 
    619446        /* Stop MAC */ 
    620447        iowrite16(MSK_INT, ioaddr + MIER);      /* Mask Off Interrupt */ 
    621448        iowrite16(MAC_RST, ioaddr + MCR1);      /* Reset RDC MAC */ 
    622         udelay(100); 
    623         while ((ioread16(ioaddr+MCR1) & 1) && limit-- > 0); 
    624  
    625         if (limit <= 0) 
    626                 err("timeout while waiting for reset done.\n"); 
    627  
    628         free_irq(dev->irq, dev); 
    629  
    630         /* Free RX buffer */ 
    631         r6040_free_rxbufs(dev); 
    632  
    633         /* Free TX buffer */ 
    634         r6040_free_txbufs(dev); 
    635  
    636         /* Free Descriptor memory */ 
    637         pci_free_consistent(pdev, RX_DESC_SIZE, lp->rx_ring, lp->rx_ring_dma); 
    638         pci_free_consistent(pdev, TX_DESC_SIZE, lp->tx_ring, lp->tx_ring_dma); 
    639  
    640         dbg(DBG_EXIT, "EXIT\n"); 
    641 } 
    642  
    643 int r6040_close(struct net_device *dev) 
    644 { 
    645         struct r6040_private *lp = netdev_priv(dev); 
    646  
    647         dbg(DBG_EXIT, "ENTER\n"); 
     449        while (limit--) { 
     450                cmd = ioread16(ioaddr + MCR1); 
     451                if (cmd & 0x1) 
     452                        break; 
     453        } 
     454 
     455        /* Restore MAC Address to MIDx */ 
     456        adrp = (u16 *) dev->dev_addr; 
     457        iowrite16(adrp[0], ioaddr + MID_0L); 
     458        iowrite16(adrp[1], ioaddr + MID_0M); 
     459        iowrite16(adrp[2], ioaddr + MID_0H); 
     460} 
     461 
     462static int r6040_close(struct net_device *dev) 
     463{ 
     464        struct r6040_private *lp = netdev_priv(dev); 
     465        struct pci_dev *pdev = lp->pdev; 
    648466 
    649467        /* deleted timer */ 
    650468        del_timer_sync(&lp->timer); 
     469 
    651470        spin_lock_irq(&lp->lock); 
    652471        napi_disable(&lp->napi); 
    653472        netif_stop_queue(dev); 
    654473        r6040_down(dev); 
     474 
     475        free_irq(dev->irq, dev); 
     476 
     477        /* Free RX buffer */ 
     478        r6040_free_rxbufs(dev); 
     479 
     480        /* Free TX buffer */ 
     481        r6040_free_txbufs(dev); 
     482 
    655483        spin_unlock_irq(&lp->lock); 
    656484 
    657         dbg(DBG_EXIT, "EXIT\n"); 
     485        /* Free Descriptor memory */ 
     486        if (lp->rx_ring) { 
     487                pci_free_consistent(pdev, RX_DESC_SIZE, lp->rx_ring, lp->rx_ring_dma); 
     488                lp->rx_ring = NULL; 
     489        } 
     490 
     491        if (lp->tx_ring) { 
     492                pci_free_consistent(pdev, TX_DESC_SIZE, lp->tx_ring, lp->tx_ring_dma); 
     493                lp->tx_ring = NULL; 
     494        } 
     495 
    658496        return 0; 
    659497} 
    660498 
    661 /* Status of PHY CHIP. Returns 0x8000 for full duplex, 0 for half duplex */ 
    662 STATIC int phy_mode_chk(struct net_device *dev) 
     499/* Status of PHY CHIP */ 
     500static int r6040_phy_mode_chk(struct net_device *dev) 
    663501{ 
    664502        struct r6040_private *lp = netdev_priv(dev); 
     
    667505 
    668506        /* PHY Link Status Check */ 
    669         phy_dat = phy_read(ioaddr, lp->phy_addr, 1); 
     507        phy_dat = r6040_phy_read(ioaddr, lp->phy_addr, 1); 
    670508        if (!(phy_dat & 0x4)) 
    671509                phy_dat = 0x8000;       /* Link Failed, full duplex */ 
    672510 
    673511        /* PHY Chip Auto-Negotiation Status */ 
    674         phy_dat = phy_read(ioaddr, lp->phy_addr, 1); 
     512        phy_dat = r6040_phy_read(ioaddr, lp->phy_addr, 1); 
    675513        if (phy_dat & 0x0020) { 
    676514                /* Auto Negotiation Mode */ 
    677                 phy_dat = phy_read(ioaddr, lp->phy_addr, 5); 
    678                 phy_dat &= phy_read(ioaddr, lp->phy_addr, 4); 
     515                phy_dat = r6040_phy_read(ioaddr, lp->phy_addr, 5); 
     516                phy_dat &= r6040_phy_read(ioaddr, lp->phy_addr, 4); 
    679517                if (phy_dat & 0x140) 
    680518                        /* Force full duplex */ 
     
    684522        } else { 
    685523                /* Force Mode */ 
    686                 phy_dat = phy_read(ioaddr, lp->phy_addr, 0); 
     524                phy_dat = r6040_phy_read(ioaddr, lp->phy_addr, 0); 
    687525                if (phy_dat & 0x100) 
    688526                        phy_dat = 0x8000; 
     
    691529        } 
    692530 
    693         dbg(DBG_PHY, "RETURN x%x\n", phy_dat); 
     531        mii_check_media(&lp->mii_if, 1, 1); 
     532 
    694533        return phy_dat; 
    695534}; 
    696535 
    697 void r6040_set_carrier(struct mii_if_info *mii) 
    698 { 
    699         if (phy_mode_chk(mii->dev)) { 
     536static void r6040_set_carrier(struct mii_if_info *mii) 
     537{ 
     538        if (r6040_phy_mode_chk(mii->dev)) { 
    700539                /* autoneg is off: Link is always assumed to be up */ 
    701540                if (!netif_carrier_ok(mii->dev)) 
    702541                        netif_carrier_on(mii->dev); 
    703542        } else 
    704                 phy_mode_chk(mii->dev); 
    705 } 
    706  
    707 int r6040_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
     543                r6040_phy_mode_chk(mii->dev); 
     544} 
     545 
     546static int r6040_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
    708547{ 
    709548        struct r6040_private *lp = netdev_priv(dev); 
     
    720559} 
    721560 
    722 int r6040_rx(struct net_device *dev, int limit) 
     561static int r6040_rx(struct net_device *dev, int limit) 
    723562{ 
    724563        struct r6040_private *priv = netdev_priv(dev); 
    725         int count=0; 
    726564        struct r6040_descriptor *descptr = priv->rx_remove_ptr; 
    727565        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                  
    736                 /* Check for errors */ 
    737                 if (descptr->status & DESC_STATUS_RX_ERR) { 
    738                  
    739                         dev->stats.rx_errors++; 
    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*/ 
     566        int count = 0; 
     567        u16 err; 
     568 
     569        /* Limit not reached and the descriptor belongs to the CPU */ 
     570        while (count < limit && !(descptr->status & DSC_OWNER_MAC)) { 
     571                /* Read the descriptor status */ 
     572                err = descptr->status; 
     573                /* Global error status set */ 
     574                if (err & DSC_RX_ERR) { 
     575                        /* RX dribble */ 
     576                        if (err & DSC_RX_ERR_DRI) 
     577                                dev->stats.rx_frame_errors++; 
     578                        /* Buffer lenght exceeded */ 
     579                        if (err & DSC_RX_ERR_BUF) 
    746580                                dev->stats.rx_length_errors++; 
    747                         } 
    748  
    749                         if (descptr->status & DESC_STATUS_RX_ERR_CRC) { 
     581                        /* Packet too long */ 
     582                        if (err & DSC_RX_ERR_LONG) 
     583                                dev->stats.rx_length_errors++; 
     584                        /* Packet < 64 bytes */ 
     585                        if (err & DSC_RX_ERR_RUNT) 
     586                                dev->stats.rx_length_errors++; 
     587                        /* CRC error */ 
     588                        if (err & DSC_RX_ERR_CRC) { 
     589                                spin_lock(&priv->lock); 
    750590                                dev->stats.rx_crc_errors++; 
     591                                spin_unlock(&priv->lock); 
    751592                        } 
    752593                        goto next_descr; 
    753594                } 
    754595                 
    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.*/ 
     596                /* Packet successfully received */ 
    759597                new_skb = netdev_alloc_skb(dev, MAX_BUF_SIZE); 
    760598                if (!new_skb) { 
     
    764602                skb_ptr = descptr->skb_ptr; 
    765603                skb_ptr->dev = priv->dev; 
     604                 
    766605                /* Do not count the CRC */ 
    767606                skb_put(skb_ptr, descptr->len - 4); 
    768607                pci_unmap_single(priv->pdev, le32_to_cpu(descptr->buf), 
    769                                  MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
     608                                        MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    770609                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  
     610                 
    776611                /* Send to upper layer */ 
    777612                netif_receive_skb(skb_ptr); 
    778                 dev->last_rx = jiffies; 
    779613                dev->stats.rx_packets++; 
    780                 dev->stats.rx_bytes += (descptr->len-4); 
     614                dev->stats.rx_bytes += descptr->len - 4; 
    781615 
    782616                /* put new skb into descriptor */ 
    783617                descptr->skb_ptr = new_skb; 
    784618                descptr->buf = cpu_to_le32(pci_map_single(priv->pdev, 
    785                         descptr->skb_ptr->data, 
    786                         MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
    787  
    788 next_descr:              
     619                                                descptr->skb_ptr->data, 
     620                                        MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
     621 
     622next_descr: 
    789623                /* put the descriptor back to the MAC */ 
    790                 descptr->status = DESC_STATUS_OWNER_MAC; 
     624                descptr->status = DSC_OWNER_MAC; 
    791625                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 */ 
     626                count++; 
     627        } 
    796628        priv->rx_remove_ptr = descptr; 
    797629 
     
    799631} 
    800632 
    801 void r6040_tx(struct net_device *dev) 
     633static void r6040_tx(struct net_device *dev) 
    802634{ 
    803635        struct r6040_private *priv = netdev_priv(dev); 
     
    818650                        dev->stats.tx_carrier_errors++; 
    819651 
    820                 dbg(DBG_TX_DONE, "descptr %p status x%x err x%x jiffies %lu\n", 
    821                     descptr, descptr->status, err, jiffies); 
    822  
    823                 if (descptr->status & 0x8000) 
     652                if (descptr->status & DSC_OWNER_MAC) 
    824653                        break; /* Not complete */ 
    825654                skb_ptr = descptr->skb_ptr; 
     
    840669} 
    841670 
    842 int r6040_poll(struct napi_struct *napi, int budget) 
     671static int r6040_poll(struct napi_struct *napi, int budget) 
    843672{ 
    844673        struct r6040_private *priv = 
     
    850679        work_done = r6040_rx(dev, budget); 
    851680 
    852         dbg(DBG_POLL, "budget x%x done x%x\n", budget, work_done); 
    853  
    854681        if (work_done < budget) { 
    855                 netif_rx_complete(dev, napi); 
     682                napi_complete(napi); 
    856683                /* Enable RX interrupt */ 
    857684                iowrite16(ioread16(ioaddr + MIER) | RX_INTS, ioaddr + MIER); 
     
    861688 
    862689/* The RDC interrupt handler. */ 
    863 irqreturn_t r6040_interrupt(int irq, void *dev_id) 
     690static irqreturn_t r6040_interrupt(int irq, void *dev_id) 
    864691{ 
    865692        struct net_device *dev = dev_id; 
    866693        struct r6040_private *lp = netdev_priv(dev); 
    867694        void __iomem *ioaddr = lp->base; 
    868         u16 status; 
    869  
     695        u16 misr, status; 
     696 
     697        /* Save MIER */ 
     698        misr = ioread16(ioaddr + MIER); 
     699        /* Mask off RDC MAC interrupt */ 
     700        iowrite16(MSK_INT, ioaddr + MIER); 
    870701        /* Read MISR status and clear */ 
    871702        status = ioread16(ioaddr + MISR); 
    872703 
    873         dbg(DBG_IRQ, "status x%x jiffies %lu\n", status, jiffies); 
    874  
    875704        if (status == 0x0000 || status == 0xffff) 
    876705                return IRQ_NONE; 
    877706 
    878         /* rx early / rx finish interrupt 
    879            or rx descriptor unavail. */ 
     707        /* RX interrupt request */ 
    880708        if (status & RX_INTS) { 
    881709                if (status & RX_NO_DESC) { 
    882                         /* rx descriptor unavail. */ 
     710                        /* RX descriptor unavailable */ 
    883711                        dev->stats.rx_dropped++; 
    884712                        dev->stats.rx_missed_errors++; 
    885713                } 
    886                 /* Mask off RX interrupts */ 
    887                 iowrite16(ioread16(ioaddr + MIER) & ~RX_INTS, ioaddr + MIER); 
    888                 netif_rx_schedule(dev, &lp->napi); 
    889         } 
    890  
    891         /* rx FIFO full */ 
    892         if (status & RX_FIFO_FULL) { 
    893                 dev->stats.rx_fifo_errors++; 
    894         } 
    895          
     714                if (status & RX_FIFO_FULL) 
     715                        dev->stats.rx_fifo_errors++; 
     716 
     717                /* Mask off RX interrupt */ 
     718                misr &= ~RX_INTS; 
     719                napi_schedule(&lp->napi); 
     720        } 
     721 
    896722        /* TX interrupt request */ 
    897         if (status & 0x10) 
     723        if (status & TX_INTS) 
    898724                r6040_tx(dev); 
    899725 
     726        /* Restore RDC MAC interrupt */ 
     727        iowrite16(misr, ioaddr + MIER); 
     728 
    900729        return IRQ_HANDLED; 
    901730} 
    902731 
    903732#ifdef CONFIG_NET_POLL_CONTROLLER 
    904 void r6040_poll_controller(struct net_device *dev) 
     733static void r6040_poll_controller(struct net_device *dev) 
    905734{ 
    906735        disable_irq(dev->irq); 
     
    911740 
    912741/* Init RDC MAC */ 
    913 int r6040_up(struct net_device *dev) 
     742static int r6040_up(struct net_device *dev) 
    914743{ 
    915744        struct r6040_private *lp = netdev_priv(dev); 
    916745        void __iomem *ioaddr = lp->base; 
    917         int rc; 
    918  
    919         dbg(DBG_INIT, "ENTER\n"); 
     746        int ret; 
    920747 
    921748        /* Initialise and alloc RX/TX buffers */ 
    922749        r6040_init_txbufs(dev); 
    923         if ((rc=r6040_alloc_rxbufs(dev))) 
    924                 return rc; 
     750        ret = r6040_alloc_rxbufs(dev); 
     751        if (ret) 
     752                return ret; 
    925753 
    926754        /* Read the PHY ID */ 
    927         lp->switch_sig = phy_read(ioaddr, 0, 2); 
     755        lp->switch_sig = r6040_phy_read(ioaddr, 0, 2); 
    928756 
    929757        if (lp->switch_sig  == ICPLUS_PHY_ID) { 
    930                 phy_write(ioaddr, 29, 31, 0x175C); /* Enable registers */ 
     758                r6040_phy_write(ioaddr, 29, 31, 0x175C); /* Enable registers */ 
    931759                lp->phy_mode = 0x8000; 
    932760        } else { 
    933761                /* PHY Mode Check */ 
    934                 phy_write(ioaddr, lp->phy_addr, 4, PHY_CAP); 
    935                 phy_write(ioaddr, lp->phy_addr, 0, PHY_MODE); 
     762                r6040_phy_write(ioaddr, lp->phy_addr, 4, PHY_CAP); 
     763                r6040_phy_write(ioaddr, lp->phy_addr, 0, PHY_MODE); 
    936764 
    937765                if (PHY_MODE == 0x3100) 
    938                         lp->phy_mode = phy_mode_chk(dev); 
     766                        lp->phy_mode = r6040_phy_mode_chk(dev); 
    939767                else 
    940768                        lp->phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
    941769        } 
    942          
    943 /* configure duplex mode */ 
     770 
     771        /* Set duplex mode */ 
    944772        lp->mcr0 |= lp->phy_mode; 
    945773 
    946774        /* improve performance (by RDC guys) */ 
    947         phy_write(ioaddr, 30, 17, (phy_read(ioaddr, 30, 17) | 0x4000)); 
    948         phy_write(ioaddr, 30, 17, ~((~phy_read(ioaddr, 30, 17)) | 0x2000)); 
    949         phy_write(ioaddr, 0, 19, 0x0000); 
    950         phy_write(ioaddr, 0, 30, 0x01F0); 
    951  
    952         /* Reset MAC and init all registers */ 
    953         r6040_init_mac_regs(lp); 
     775        r6040_phy_write(ioaddr, 30, 17, (r6040_phy_read(ioaddr, 30, 17) | 0x4000)); 
     776        r6040_phy_write(ioaddr, 30, 17, ~((~r6040_phy_read(ioaddr, 30, 17)) | 0x2000)); 
     777        r6040_phy_write(ioaddr, 0, 19, 0x0000); 
     778        r6040_phy_write(ioaddr, 0, 30, 0x01F0); 
     779 
     780        /* Initialize all MAC registers */ 
     781        r6040_init_mac_regs(dev); 
    954782 
    955783        return 0; 
     
    960788        Polling PHY Chip Link Status 
    961789*/ 
    962 void r6040_timer(unsigned long data) 
     790static void r6040_timer(unsigned long data) 
    963791{ 
    964792        struct net_device *dev = (struct net_device *)data; 
     
    969797        /* Polling PHY Chip Status */ 
    970798        if (PHY_MODE == 0x3100) 
    971                 phy_mode = phy_mode_chk(dev); 
     799                phy_mode = r6040_phy_mode_chk(dev); 
    972800        else 
    973801                phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
     
    977805                lp->mcr0 = (lp->mcr0 & 0x7fff) | phy_mode; 
    978806                iowrite16(lp->mcr0, ioaddr); 
    979                 printk(KERN_INFO "Link Change x%x \n", ioread16(ioaddr)); 
     807                //printk(KERN_INFO "Link Change %x \n", ioread16(ioaddr)); 
    980808        } 
    981809 
    982810        /* Timer active again */ 
    983         mod_timer(&lp->timer, jiffies + round_jiffies(HZ)); 
    984 } 
    985  
    986 int r6040_open(struct net_device *dev) 
     811        mod_timer(&lp->timer, round_jiffies(jiffies + HZ)); 
     812} 
     813 
     814/* Read/set MAC address routines */ 
     815static void r6040_mac_address(struct net_device *dev) 
     816{ 
     817        struct r6040_private *lp = netdev_priv(dev); 
     818        void __iomem *ioaddr = lp->base; 
     819        u16 *adrp; 
     820 
     821        /* MAC operation register */ 
     822        iowrite16(0x01, ioaddr + MCR1); /* Reset MAC */ 
     823        iowrite16(2, ioaddr + MAC_SM); /* Reset internal state machine */ 
     824        iowrite16(0, ioaddr + MAC_SM); 
     825        mdelay(5); 
     826 
     827        /* Restore MAC Address */ 
     828        adrp = (u16 *) dev->dev_addr; 
     829        iowrite16(adrp[0], ioaddr + MID_0L); 
     830        iowrite16(adrp[1], ioaddr + MID_0M); 
     831        iowrite16(adrp[2], ioaddr + MID_0H); 
     832} 
     833 
     834static int r6040_open(struct net_device *dev) 
    987835{ 
    988836        struct r6040_private *lp = netdev_priv(dev); 
    989837        int ret; 
    990838 
    991         dbg(DBG_OPEN, "ENTER\n"); 
    992839        /* Request IRQ and Register interrupt handler */ 
    993840        ret = request_irq(dev->irq, &r6040_interrupt, 
     
    996843                return ret; 
    997844 
    998         dbg(DBG_OPEN, "got irq %d\n", dev->irq); 
     845        /* Set MAC address */ 
     846        r6040_mac_address(dev); 
    999847 
    1000848        /* Allocate Descriptor memory */ 
     
    1003851        if (!lp->rx_ring) 
    1004852                return -ENOMEM; 
    1005  
    1006         dbg(DBG_OPEN, "allocated rx ring\n"); 
    1007853 
    1008854        lp->tx_ring = 
     
    1014860        } 
    1015861 
    1016         dbg(DBG_OPEN, "allocated tx ring\n"); 
    1017  
    1018         if ((ret=r6040_up(dev))) { 
     862        ret = r6040_up(dev); 
     863        if (ret) { 
    1019864                pci_free_consistent(lp->pdev, TX_DESC_SIZE, lp->tx_ring, 
    1020                                     lp->tx_ring_dma); 
     865                                                        lp->tx_ring_dma); 
    1021866                pci_free_consistent(lp->pdev, RX_DESC_SIZE, lp->rx_ring, 
    1022                                      lp->rx_ring_dma); 
     867                                                        lp->rx_ring_dma); 
    1023868                return ret; 
    1024869        } 
    1025                  
     870 
    1026871        napi_enable(&lp->napi); 
    1027872        netif_start_queue(dev); 
     
    1034879} 
    1035880 
    1036 int r6040_start_xmit(struct sk_buff *skb, struct net_device *dev) 
     881static int r6040_start_xmit(struct sk_buff *skb, struct net_device *dev) 
    1037882{ 
    1038883        struct r6040_private *lp = netdev_priv(dev); 
     
    1068913        descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, 
    1069914                skb->data, skb->len, PCI_DMA_TODEVICE)); 
    1070  
    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); 
    1073  
    1074         { 
    1075                 char obuf[2*32+1]; 
    1076                 dbg(DBG_TX_DATA, "tx len x%x: %s\n", 
    1077                     descptr->len, hex2str(skb->data, obuf, sizeof(obuf)/2, '\0')); 
    1078         } 
    1079  
    1080         descptr->status = 0x8000; 
     915        descptr->status = DSC_OWNER_MAC; 
    1081916        /* Trigger the MAC to check the TX descriptor */ 
    1082917        iowrite16(0x01, ioaddr + MTPR); 
     
    1092927} 
    1093928 
    1094 /*! set MAC addresses and promiscous mode */ 
    1095 void r6040_multicast_list(struct net_device *dev) 
     929static void r6040_multicast_list(struct net_device *dev) 
    1096930{ 
    1097931        struct r6040_private *lp = netdev_priv(dev); 
     
    1102936        struct dev_mc_list *dmi = dev->mc_list; 
    1103937        int i; 
    1104         char obuf[3*ETH_ALEN] __attribute__ ((unused)); 
    1105938 
    1106939        /* MAC Address */ 
     
    1109942        iowrite16(adrp[1], ioaddr + MID_0M); 
    1110943        iowrite16(adrp[2], ioaddr + MID_0H); 
    1111  
    1112         dbg(DBG_MAC_ADDR, "%s: set MAC addr %s\n",  
    1113             dev->name, hex2str(dev->dev_addr, obuf, ETH_ALEN, ':')); 
    1114944 
    1115945        /* Promiscous Mode */ 
     
    11751005} 
    11761006 
    1177 STATIC void netdev_get_drvinfo(struct net_device *dev, 
     1007static void netdev_get_drvinfo(struct net_device *dev, 
    11781008                        struct ethtool_drvinfo *info) 
    11791009{ 
     
    11851015} 
    11861016 
    1187 STATIC int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
     1017static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
    11881018{ 
    11891019        struct r6040_private *rp = netdev_priv(dev); 
     
    11971027} 
    11981028 
    1199 STATIC int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
     1029static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
    12001030{ 
    12011031        struct r6040_private *rp = netdev_priv(dev); 
     
    12101040} 
    12111041 
    1212 STATIC u32 netdev_get_link(struct net_device *dev) 
     1042static u32 netdev_get_link(struct net_device *dev) 
    12131043{ 
    12141044        struct r6040_private *rp = netdev_priv(dev); 
     
    12241054}; 
    12251055 
    1226 int __devinit r6040_init_one(struct pci_dev *pdev, 
     1056static int __devinit r6040_init_one(struct pci_dev *pdev, 
    12271057                                         const struct pci_device_id *ent) 
    12281058{ 
     
    12341064        int bar = 0; 
    12351065        long pioaddr; 
     1066        u16 *adrp; 
    12361067 
    12371068        printk(KERN_INFO "%s\n", version); 
    1238         printk(KERN_INFO DRV_NAME ": debug %x\n", debug); 
    12391069 
    12401070        err = pci_enable_device(pdev); 
    12411071        if (err) 
    1242                 return err; 
     1072                goto err_out; 
    12431073 
    12441074        /* this should always be supported */ 
    1245         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) { 
    1246                 printk(KERN_ERR DRV_NAME "32-bit PCI DMA addresses" 
     1075        err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); 
     1076        if (err) { 
     1077                printk(KERN_ERR DRV_NAME ": 32-bit PCI DMA addresses" 
    12471078                                "not supported by the card\n"); 
    1248                 return -ENODEV; 
    1249         } 
    1250         if (pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) { 
    1251                 printk(KERN_ERR DRV_NAME "32-bit PCI DMA addresses" 
     1079                goto err_out; 
     1080        } 
     1081        err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK); 
     1082        if (err) { 
     1083                printk(KERN_ERR DRV_NAME ": 32-bit PCI DMA addresses" 
    12521084                                "not supported by the card\n"); 
    1253                 return -ENODEV; 
     1085                goto err_out; 
    12541086        } 
    12551087 
    12561088        /* IO Size check */ 
    12571089        if (pci_resource_len(pdev, 0) < io_size) { 
    1258                 printk(KERN_ERR "Insufficient PCI resources, aborting\n"); 
    1259                 return -EIO; 
     1090                printk(KERN_ERR DRV_NAME ": Insufficient PCI resources, aborting\n"); 
     1091                err = -EIO; 
     1092                goto err_out; 
    12601093        } 
    12611094 
     
    12651098        dev = alloc_etherdev(sizeof(struct r6040_private)); 
    12661099        if (!dev) { 
    1267                 printk(KERN_ERR "Failed to allocate etherdev\n"); 
    1268                 return -ENOMEM; 
     1100                printk(KERN_ERR DRV_NAME ": Failed to allocate etherdev\n"); 
     1101                err = -ENOMEM; 
     1102                goto err_out; 
    12691103        } 
    12701104        SET_NETDEV_DEV(dev, &pdev->dev); 
    12711105        lp = netdev_priv(dev); 
    12721106 
    1273         if (pci_request_regions(pdev, DRV_NAME)) { 
     1107        err = pci_request_regions(pdev, DRV_NAME); 
     1108 
     1109        if (err) { 
    12741110                printk(KERN_ERR DRV_NAME ": Failed to request PCI regions\n"); 
    1275                 err = -ENODEV; 
    1276                 goto err_out_disable; 
     1111                goto err_out_free_dev; 
    12771112        } 
    12781113 
    12791114        ioaddr = pci_iomap(pdev, bar, io_size); 
    12801115        if (!ioaddr) { 
    1281                 printk(KERN_ERR "ioremap failed for device %s\n", 
     1116                printk(KERN_ERR DRV_NAME ": ioremap failed for device %s\n", 
    12821117                        pci_name(pdev)); 
    1283                 return -EIO; 
    1284         } 
     1118                err = -EIO; 
     1119                goto err_out_free_res; 
     1120        } 
     1121        /* If PHY status change register is still set to zero it means the 
     1122         * bootloader didn't initialize it */ 
     1123        if (ioread16(ioaddr + PHY_CC) == 0) 
     1124                iowrite16(0x9f07, ioaddr + PHY_CC); 
    12851125 
    12861126        /* Init system & device */ 
     
    12911131        pci_set_drvdata(pdev, dev); 
    12921132 
     1133        /* Set MAC address */ 
    12931134        card_idx++; 
     1135 
     1136        adrp = (u16 *)dev->dev_addr; 
     1137        adrp[0] = ioread16(ioaddr + MID_0L); 
     1138        adrp[1] = ioread16(ioaddr + MID_0M); 
     1139        adrp[2] = ioread16(ioaddr + MID_0H); 
     1140 
     1141        /* Some bootloader/BIOSes do not initialize 
     1142         * MAC address, warn about that */ 
     1143        if (!(adrp[0] || adrp[1] || adrp[2])) { 
     1144                printk(KERN_WARNING DRV_NAME ": MAC address not initialized, generating random\n"); 
     1145                random_ether_addr(dev->dev_addr); 
     1146        } 
    12941147 
    12951148        /* Link new device into r6040_root_dev */ 
    12961149        lp->pdev = pdev; 
    1297  
    12981150        lp->dev = dev; 
    12991151 
     
    13131165        dev->tx_timeout = &r6040_tx_timeout; 
    13141166        dev->watchdog_timeo = TX_TIMEOUT; 
    1315  
    1316         { 
    1317         /* TODO: fix the setting of the MAC address. 
    1318            Right now you must either specify a netdevice with "parent=", whose 
    1319            address is copied or the (default) address of the Sitecom WL-153 
    1320            bootloader is used */ 
    1321                 static const u8 dflt_addr[ETH_ALEN] = {0,0x50,0xfc,2,3,4}; 
    1322                 if (parent_dev) { 
    1323                         memcpy(dev->dev_addr, parent_dev->dev_addr, ETH_ALEN); 
    1324                 } else { 
    1325                         printk(KERN_WARNING "%s: no parent - using default mac address\n", 
    1326                                dev->name); 
    1327                         memcpy(dev->dev_addr, dflt_addr, ETH_ALEN); 
    1328                 } 
    1329                 dev->dev_addr[ETH_ALEN-1] += card_idx ^ 1; /* + 0 or 1 */ 
    1330         } 
    1331  
    13321167#ifdef CONFIG_NET_POLL_CONTROLLER 
    13331168        dev->poll_controller = r6040_poll_controller; 
     
    13351170        netif_napi_add(dev, &lp->napi, r6040_poll, 64); 
    13361171        lp->mii_if.dev = dev; 
    1337         lp->mii_if.mdio_read = mdio_read; 
    1338         lp->mii_if.mdio_write = mdio_write; 
     1172        lp->mii_if.mdio_read = r6040_mdio_read; 
     1173        lp->mii_if.mdio_write = r6040_mdio_write; 
    13391174        lp->mii_if.phy_id = lp->phy_addr; 
    13401175        lp->mii_if.phy_id_mask = 0x1f; 
     
    13451180        if (err) { 
    13461181                printk(KERN_ERR DRV_NAME ": Failed to register net device\n"); 
    1347                 goto err_out_res; 
    1348         } 
    1349  
    1350         dbg(DBG_INIT, "%s successfully registered\n", dev->name); 
     1182                goto err_out_unmap; 
     1183        } 
    13511184        return 0; 
    13521185 
    1353 err_out_res: 
     1186err_out_unmap: 
     1187        pci_iounmap(pdev, ioaddr); 
     1188err_out_free_res: 
    13541189        pci_release_regions(pdev); 
    1355 err_out_disable: 
    1356         pci_disable_device(pdev); 
    1357         pci_set_drvdata(pdev, NULL); 
     1190err_out_free_dev: 
    13581191        free_netdev(dev); 
    1359  
     1192err_out: 
    13601193        return err; 
    13611194} 
    13621195 
    1363 void __devexit r6040_remove_one(struct pci_dev *pdev) 
     1196static void __devexit r6040_remove_one(struct pci_dev *pdev) 
    13641197{ 
    13651198        struct net_device *dev = pci_get_drvdata(pdev); 
     
    13891222static int __init r6040_init(void) 
    13901223{ 
    1391         if (parent) 
    1392                 parent_dev = dev_get_by_name(&init_net, parent); 
    1393          
    13941224        return pci_register_driver(&r6040_driver); 
    13951225} 
Note: See TracChangeset for help on using the changeset viewer.