Changeset 11506


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

Hi,

this is the first of three patches to fix the ethernet driver of RDC R32xx applied to svn r10754.

It adds debugs and make some procedures (r6040_*) global symbols in order to help with debugging kernel oops. Version is increased from 0.16 to 0.18 to avoid conflicts with the driver variant metioned in the X-WRT forum (call 0.17.3) Tested on a Sitecom WL-153.

Signed-Off-By: Joerg Albert <jal2@…>

File:
1 edited

Legend:

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

    r10754 r11506  
    5151 
    5252#define DRV_NAME        "r6040" 
    53 #define DRV_VERSION     "0.16" 
    54 #define DRV_RELDATE     "10Nov2007" 
     53#define DRV_VERSION     "0.18" 
     54#define DRV_RELDATE     "13Jun2008" 
     55 
     56/* 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. */ 
     76 
     77static int debug = 0; 
     78module_param(debug, int, 0); 
     79MODULE_PARM_DESC(debug, "debug mask (-1 for all)"); 
     80 
     81/* define wcd hich debugs are left in the code during compilation */ 
     82#define DEBUG (-1) /* all debugs */ 
     83 
     84#define dbg(l, f, ...)                          \ 
     85  do { \ 
     86    if ((DEBUG & l) && (debug & l)) { \ 
     87      printk(KERN_INFO DRV_NAME " %s: " f, __FUNCTION__, ## __VA_ARGS__); \ 
     88    } \ 
     89  } while (0) 
     90 
     91#define err(f, ...) printk(KERN_WARNING DRV_NAME " %s: " f, __FUNCTION__, ## __VA_ARGS__) 
    5592 
    5693/* PHY CHIP Address */ 
     
    183220static int phy_table[] = { PHY1_ADDR, PHY2_ADDR }; 
    184221 
     222/* jal2: comment out to get more symbols for debugging */ 
     223//#define STATIC static 
     224#define STATIC 
     225 
     226#if DEBUG 
     227/*! hexdump an memory area into a string. delim is taken as the delimiter between two bytes. 
     228    It is omitted if delim == '\0' */ 
     229STATIC char *hex2str(void *addr, char *buf, int nr_bytes, int delim) 
     230{ 
     231        unsigned char *dst = addr; 
     232        char *outb = buf; 
     233 
     234#define BIN2HEXDIGIT(x) ((x) < 10 ? '0'+(x) : 'A'-10+(x)) 
     235 
     236        while (nr_bytes > 0) { 
     237                *outb++ = BIN2HEXDIGIT(*dst>>4); 
     238                *outb++ = BIN2HEXDIGIT(*dst&0xf); 
     239                if (delim) 
     240                        *outb++ = delim; 
     241                nr_bytes--; 
     242                dst++; 
     243        } 
     244 
     245        if (delim) 
     246                dst--; 
     247        *dst = '\0'; 
     248        return buf; 
     249} 
     250 
     251#endif /* #if DEBUG */ 
     252 
    185253/* Read a word data from PHY Chip */ 
    186 static int phy_read(void __iomem *ioaddr, int phy_addr, int reg) 
     254STATIC int phy_read(void __iomem *ioaddr, int phy_addr, int reg) 
    187255{ 
    188256        int limit = 2048; 
    189257        u16 cmd; 
     258        int rc; 
    190259 
    191260        iowrite16(MDIO_READ + reg + (phy_addr << 8), ioaddr + MMDIO); 
     
    197266        } 
    198267 
    199         return ioread16(ioaddr + MMRD); 
     268        if (limit <= 0) 
     269                err("phy addr x%x reg x%x timed out\n", 
     270                    phy_addr, reg); 
     271 
     272        rc=ioread16(ioaddr + MMRD); 
     273 
     274        dbg(DBG_PHY, "phy addr x%x reg x%x val x%x\n", phy_addr, reg, rc); 
     275        return rc; 
    200276} 
    201277 
    202278/* Write a word data from PHY Chip */ 
    203 static void phy_write(void __iomem *ioaddr, int phy_addr, int reg, u16 val) 
     279STATIC void phy_write(void __iomem *ioaddr, int phy_addr, int reg, u16 val) 
    204280{ 
    205281        int limit = 2048; 
    206282        u16 cmd; 
     283 
     284        dbg(DBG_PHY, "phy addr x%x reg x%x val x%x\n", phy_addr, reg, val); 
    207285 
    208286        iowrite16(val, ioaddr + MMWD); 
     
    215293                        break; 
    216294        } 
    217 } 
    218  
    219 static int mdio_read(struct net_device *dev, int mii_id, int reg) 
     295        if (limit <= 0) 
     296                err("phy addr x%x reg x%x val x%x timed out\n", 
     297                    phy_addr, reg, val); 
     298} 
     299 
     300STATIC int mdio_read(struct net_device *dev, int mii_id, int reg) 
    220301{ 
    221302        struct r6040_private *lp = netdev_priv(dev); 
     
    225306} 
    226307 
    227 static void mdio_write(struct net_device *dev, int mii_id, int reg, int val) 
     308STATIC void mdio_write(struct net_device *dev, int mii_id, int reg, int val) 
    228309{ 
    229310        struct r6040_private *lp = netdev_priv(dev); 
     
    233314} 
    234315 
    235 static void r6040_free_txbufs(struct net_device *dev) 
     316void r6040_free_txbufs(struct net_device *dev) 
    236317{ 
    237318        struct r6040_private *lp = netdev_priv(dev); 
    238319        int i; 
    239320 
     321        dbg(DBG_FREE_BUFS, "ENTER\n"); 
    240322        for (i = 0; i < TX_DCNT; i++) { 
    241323                if (lp->tx_insert_ptr->skb_ptr) { 
     
    248330                lp->tx_insert_ptr = lp->tx_insert_ptr->vndescp; 
    249331        } 
    250 } 
    251  
    252 static void r6040_free_rxbufs(struct net_device *dev) 
     332        dbg(DBG_FREE_BUFS, "EXIT\n"); 
     333} 
     334 
     335void r6040_free_rxbufs(struct net_device *dev) 
    253336{ 
    254337        struct r6040_private *lp = netdev_priv(dev); 
    255338        int i; 
    256339 
     340        dbg(DBG_FREE_BUFS, "ENTER\n"); 
    257341        for (i = 0; i < RX_DCNT; i++) { 
    258342                if (lp->rx_insert_ptr->skb_ptr) { 
     
    265349                lp->rx_insert_ptr = lp->rx_insert_ptr->vndescp; 
    266350        } 
    267 } 
    268  
    269 static void r6040_init_ring_desc(struct r6040_descriptor *desc_ring, 
     351        dbg(DBG_FREE_BUFS, "EXIT\n"); 
     352 
     353} 
     354 
     355void r6040_init_ring_desc(struct r6040_descriptor *desc_ring, 
    270356                                 dma_addr_t desc_dma, int size) 
    271357{ 
    272358        struct r6040_descriptor *desc = desc_ring; 
    273359        dma_addr_t mapping = desc_dma; 
     360 
     361        dbg(DBG_RING, "desc_ring %p desc_dma %08x size x%x\n", 
     362            desc_ring, desc_dma, size); 
    274363 
    275364        while (size-- > 0) { 
     
    285374 
    286375/* Allocate skb buffer for rx descriptor */ 
    287 static void rx_buf_alloc(struct r6040_private *lp, struct net_device *dev) 
     376STATIC void rx_buf_alloc(struct r6040_private *lp, struct net_device *dev) 
    288377{ 
    289378        struct r6040_descriptor *descptr; 
    290379        void __iomem *ioaddr = lp->base; 
     380 
     381        dbg(DBG_RX_BUF, "rx_insert %p rx_free_desc x%x dev %p\n", 
     382            lp->rx_insert_ptr, lp->rx_free_desc, dev); 
    291383 
    292384        descptr = lp->rx_insert_ptr; 
    293385        while (lp->rx_free_desc < RX_DCNT) { 
    294386                descptr->skb_ptr = netdev_alloc_skb(dev, MAX_BUF_SIZE); 
     387 
     388                dbg(DBG_RX_BUF, "alloc'ed skb %p for rx descptr %p\n", 
     389                    descptr->skb_ptr, descptr); 
    295390 
    296391                if (!descptr->skb_ptr) 
     
    300395                        MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
    301396                descptr->status = 0x8000; 
     397                /* debug before descptr goes to next ! */ 
     398                dbg(DBG_RX_BUF, "descptr %p skb->data %p buf %08x rx_free_desc x%x\n", 
     399                    descptr, descptr->skb_ptr->data, descptr->buf, lp->rx_free_desc); 
    302400                descptr = descptr->vndescp; 
    303401                lp->rx_free_desc++; 
     
    308406} 
    309407 
    310 static void r6040_alloc_txbufs(struct net_device *dev) 
     408#if (DEBUG & DBG_TX_RING_DUMP) 
     409/*! dump the tx ring to syslog */ 
     410STATIC void 
     411dump_tx_ring(struct r6040_private *lp) 
     412{ 
     413        int i; 
     414        struct r6040_descriptor *ptr; 
     415 
     416        printk(KERN_INFO "%s: nr_desc x%x tx_ring %p tx_ring_dma %08x " 
     417               "tx_insert %p tx_remove %p\n", 
     418               DRV_NAME, TX_DCNT, lp->tx_ring, lp->tx_ring_dma, 
     419               lp->tx_insert_ptr, lp->tx_remove_ptr); 
     420 
     421        if (lp->tx_ring) { 
     422                for(i=0, ptr=lp->tx_ring; i < TX_DCNT; i++, ptr++) { 
     423                        printk(KERN_INFO "%s: %d. descr: status x%x len x%x " 
     424                               "ndesc %08x vbufp %p vndescp %p skb_ptr %p\n",  
     425                               DRV_NAME, i, ptr->status, ptr->len, 
     426                               ptr->ndesc, ptr->vbufp, ptr->vndescp, ptr->skb_ptr); 
     427                } 
     428        } 
     429} 
     430#endif /* #if (DEBUG & DBG_TX_RING_DUMP) */ 
     431 
     432void r6040_alloc_txbufs(struct net_device *dev) 
    311433{ 
    312434        struct r6040_private *lp = netdev_priv(dev); 
     
    318440        r6040_init_ring_desc(lp->tx_ring, lp->tx_ring_dma, TX_DCNT); 
    319441 
     442#if (DEBUG & DBG_TX_RING_DUMP) 
     443        if (debug & DBG_TX_RING_DUMP) { 
     444                dump_tx_ring(lp); 
     445        } 
     446#endif 
    320447        iowrite16(lp->tx_ring_dma, ioaddr + MTD_SA0); 
    321448        iowrite16(lp->tx_ring_dma >> 16, ioaddr + MTD_SA1); 
    322449} 
    323450 
    324 static void r6040_alloc_rxbufs(struct net_device *dev) 
     451#if (DEBUG & DBG_RX_RING_DUMP) 
     452/*! dump the rx ring to syslog */ 
     453STATIC void 
     454dump_rx_ring(struct r6040_private *lp) 
     455{ 
     456        int i; 
     457        struct r6040_descriptor *ptr; 
     458 
     459        printk(KERN_INFO "%s: nr_desc x%x rx_ring %p rx_ring_dma %08x " 
     460               "rx_insert %p rx_remove %p\n", 
     461               DRV_NAME, RX_DCNT, lp->rx_ring, lp->rx_ring_dma, 
     462               lp->rx_insert_ptr, lp->rx_remove_ptr); 
     463 
     464        if (lp->rx_ring) { 
     465                for(i=0, ptr=lp->rx_ring; i < RX_DCNT; i++, ptr++) { 
     466                        printk(KERN_INFO "%s: %d. descr: status x%x len x%x " 
     467                               "ndesc %08x vbufp %p vndescp %p skb_ptr %p\n",  
     468                               DRV_NAME, i, ptr->status, ptr->len, 
     469                               ptr->ndesc, ptr->vbufp, ptr->vndescp, ptr->skb_ptr); 
     470                } 
     471        } 
     472} 
     473#endif /* #if (DEBUG & DBG_TX_RING_DUMP) */ 
     474 
     475void r6040_alloc_rxbufs(struct net_device *dev) 
    325476{ 
    326477        struct r6040_private *lp = netdev_priv(dev); 
     
    334485        rx_buf_alloc(lp, dev); 
    335486 
     487#if (DEBUG & DBG_RX_RING_DUMP) 
     488        if (debug & DBG_RX_RING_DUMP) { 
     489                dump_rx_ring(lp); 
     490        } 
     491#endif 
     492 
    336493        iowrite16(lp->rx_ring_dma, ioaddr + MRD_SA0); 
    337494        iowrite16(lp->rx_ring_dma >> 16, ioaddr + MRD_SA1); 
    338495} 
    339496 
    340 static void r6040_tx_timeout(struct net_device *dev) 
     497void r6040_tx_timeout(struct net_device *dev) 
    341498{ 
    342499        struct r6040_private *priv = netdev_priv(dev); 
     
    366523} 
    367524 
    368 static struct net_device_stats *r6040_get_stats(struct net_device *dev) 
     525struct net_device_stats *r6040_get_stats(struct net_device *dev) 
    369526{ 
    370527        struct r6040_private *priv = netdev_priv(dev); 
     
    381538 
    382539/* Stop RDC MAC and Free the allocated resource */ 
    383 static void r6040_down(struct net_device *dev) 
     540void r6040_down(struct net_device *dev) 
    384541{ 
    385542        struct r6040_private *lp = netdev_priv(dev); 
     
    389546        u16 *adrp; 
    390547        u16 cmd; 
     548 
     549        dbg(DBG_EXIT, "ENTER\n"); 
    391550 
    392551        /* Stop MAC */ 
     
    399558        } 
    400559 
     560        if (limit <= 0) 
     561                err("timeout while waiting for reset\n"); 
     562 
    401563        /* Restore MAC Address to MIDx */ 
    402564        adrp = (u16 *) dev->dev_addr; 
     
    415577        pci_free_consistent(pdev, RX_DESC_SIZE, lp->rx_ring, lp->rx_ring_dma); 
    416578        pci_free_consistent(pdev, TX_DESC_SIZE, lp->tx_ring, lp->tx_ring_dma); 
    417 } 
    418  
    419 static int r6040_close(struct net_device *dev) 
    420 { 
    421         struct r6040_private *lp = netdev_priv(dev); 
     579 
     580        dbg(DBG_EXIT, "EXIT\n"); 
     581} 
     582 
     583int r6040_close(struct net_device *dev) 
     584{ 
     585        struct r6040_private *lp = netdev_priv(dev); 
     586 
     587        dbg(DBG_EXIT, "ENTER\n"); 
    422588 
    423589        /* deleted timer */ 
     
    429595        spin_unlock_irq(&lp->lock); 
    430596 
     597        dbg(DBG_EXIT, "EXIT\n"); 
    431598        return 0; 
    432599} 
    433600 
    434 /* Status of PHY CHIP */ 
    435 static int phy_mode_chk(struct net_device *dev) 
     601/* Status of PHY CHIP. Returns 0x8000 for full duplex, 0 for half duplex */ 
     602STATIC int phy_mode_chk(struct net_device *dev) 
    436603{ 
    437604        struct r6040_private *lp = netdev_priv(dev); 
     
    464631        } 
    465632 
     633        dbg(DBG_PHY, "RETURN x%x\n", phy_dat); 
    466634        return phy_dat; 
    467635}; 
    468636 
    469 static void r6040_set_carrier(struct mii_if_info *mii) 
     637void r6040_set_carrier(struct mii_if_info *mii) 
    470638{ 
    471639        if (phy_mode_chk(mii->dev)) { 
     
    477645} 
    478646 
    479 static int r6040_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
     647int r6040_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
    480648{ 
    481649        struct r6040_private *lp = netdev_priv(dev); 
     
    492660} 
    493661 
    494 static int r6040_rx(struct net_device *dev, int limit) 
     662int r6040_rx(struct net_device *dev, int limit) 
    495663{ 
    496664        struct r6040_private *priv = netdev_priv(dev); 
     
    530698                } 
    531699 
     700                dbg(DBG_RX_IRQ, "descptr %p status x%x err x%x\n",  
     701                    descptr, descptr->status, err); 
     702 
    532703                while (priv->rx_free_desc) { 
    533704                        /* No RX packet */ 
     
    548719                                MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    549720                        skb_ptr->protocol = eth_type_trans(skb_ptr, priv->dev); 
     721 
     722                        dbg(DBG_RX_DESCR, "descptr %p status x%x err x%x data len x%x\n", 
     723                            descptr, descptr->status, err, descptr->len); 
     724 
     725                        { 
     726                                char obuf[2*32+1] __attribute__ ((unused)); 
     727                                dbg(DBG_RX_DATA, "rx len x%x: %s...\n", 
     728                                    descptr->len,  
     729                                    hex2str(skb_ptr->data, obuf, sizeof(obuf)/2, '\0')); 
     730                        } 
     731 
    550732                        /* Send to upper layer */ 
    551733                        netif_receive_skb(skb_ptr); 
     
    566748} 
    567749 
    568 static void r6040_tx(struct net_device *dev) 
     750void r6040_tx(struct net_device *dev) 
    569751{ 
    570752        struct r6040_private *priv = netdev_priv(dev); 
     
    584766                if (err & (0x2000 | 0x4000)) 
    585767                        dev->stats.tx_carrier_errors++; 
     768 
     769                dbg(DBG_TX_IRQ, "descptr %p status x%x err x%x\n", 
     770                    descptr, descptr->status, err); 
    586771 
    587772                if (descptr->status & 0x8000) 
     
    604789} 
    605790 
    606 static int r6040_poll(struct napi_struct *napi, int budget) 
     791int r6040_poll(struct napi_struct *napi, int budget) 
    607792{ 
    608793        struct r6040_private *priv = 
     
    614799        work_done = r6040_rx(dev, budget); 
    615800 
     801        dbg(DBG_POLL, "budget x%x done x%x\n", budget, work_done); 
     802 
    616803        if (work_done < budget) { 
    617804                netif_rx_complete(dev, napi); 
     
    623810 
    624811/* The RDC interrupt handler. */ 
    625 static irqreturn_t r6040_interrupt(int irq, void *dev_id) 
     812irqreturn_t r6040_interrupt(int irq, void *dev_id) 
    626813{ 
    627814        struct net_device *dev = dev_id; 
     
    635822        status = ioread16(ioaddr + MISR); 
    636823 
     824        dbg(DBG_IRQ, "status x%x\n", status); 
     825 
    637826        if (status == 0x0000 || status == 0xffff) 
    638827                return IRQ_NONE; 
     
    652841 
    653842#ifdef CONFIG_NET_POLL_CONTROLLER 
    654 static void r6040_poll_controller(struct net_device *dev) 
     843void r6040_poll_controller(struct net_device *dev) 
    655844{ 
    656845        disable_irq(dev->irq); 
     
    661850 
    662851/* Init RDC MAC */ 
    663 static void r6040_up(struct net_device *dev) 
     852void r6040_up(struct net_device *dev) 
    664853{ 
    665854        struct r6040_private *lp = netdev_priv(dev); 
    666855        void __iomem *ioaddr = lp->base; 
     856 
     857        dbg(DBG_INIT, "ENTER\n"); 
    667858 
    668859        /* Initialise and alloc RX/TX buffers */ 
     
    713904        Polling PHY Chip Link Status 
    714905*/ 
    715 static void r6040_timer(unsigned long data) 
     906void r6040_timer(unsigned long data) 
    716907{ 
    717908        struct net_device *dev = (struct net_device *)data; 
     
    730921                lp->mcr0 = (lp->mcr0 & 0x7fff) | phy_mode; 
    731922                iowrite16(lp->mcr0, ioaddr); 
    732                 printk(KERN_INFO "Link Change %x \n", ioread16(ioaddr)); 
     923                printk(KERN_INFO "Link Change x%x \n", ioread16(ioaddr)); 
    733924        } 
    734925 
     
    738929 
    739930/* Read/set MAC address routines */ 
    740 static void r6040_mac_address(struct net_device *dev) 
     931void r6040_mac_address(struct net_device *dev) 
    741932{ 
    742933        struct r6040_private *lp = netdev_priv(dev); 
     
    755946        iowrite16(adrp[1], ioaddr + MID_0M); 
    756947        iowrite16(adrp[2], ioaddr + MID_0H); 
    757 } 
    758  
    759 static int r6040_open(struct net_device *dev) 
     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        } 
     954} 
     955 
     956int r6040_open(struct net_device *dev) 
    760957{ 
    761958        struct r6040_private *lp = netdev_priv(dev); 
    762959        int ret; 
    763960 
     961        dbg(DBG_OPEN, "ENTER\n"); 
    764962        /* Request IRQ and Register interrupt handler */ 
    765963        ret = request_irq(dev->irq, &r6040_interrupt, 
     
    768966                return ret; 
    769967 
     968        dbg(DBG_OPEN, "got irq %d\n", dev->irq); 
     969 
    770970        /* Set MAC address */ 
    771971        r6040_mac_address(dev); 
     
    776976        if (!lp->rx_ring) 
    777977                return -ENOMEM; 
     978 
     979        dbg(DBG_OPEN, "allocated rx ring\n"); 
    778980 
    779981        lp->tx_ring = 
     
    785987        } 
    786988 
     989        dbg(DBG_OPEN, "allocated tx ring\n"); 
     990 
    787991        r6040_up(dev); 
    788992 
     
    7971001} 
    7981002 
    799 static int r6040_start_xmit(struct sk_buff *skb, struct net_device *dev) 
     1003int r6040_start_xmit(struct sk_buff *skb, struct net_device *dev) 
    8001004{ 
    8011005        struct r6040_private *lp = netdev_priv(dev); 
     
    8311035        descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, 
    8321036                skb->data, skb->len, PCI_DMA_TODEVICE)); 
     1037 
     1038        dbg(DBG_TX_DESCR, "desc @ %p: len x%x buf %08x skb->data %p skb->len x%x\n", 
     1039            descptr, descptr->len, descptr->buf, skb->data, skb->len); 
     1040 
     1041        { 
     1042                char obuf[2*32+1]; 
     1043                dbg(DBG_TX_DATA, "tx len x%x: %s\n", 
     1044                    descptr->len, hex2str(skb->data, obuf, sizeof(obuf)/2, '\0')); 
     1045        } 
     1046 
    8331047        descptr->status = 0x8000; 
    8341048        /* Trigger the MAC to check the TX descriptor */ 
     
    8451059} 
    8461060 
    847 static void r6040_multicast_list(struct net_device *dev) 
     1061void r6040_multicast_list(struct net_device *dev) 
    8481062{ 
    8491063        struct r6040_private *lp = netdev_priv(dev); 
     
    9231137} 
    9241138 
    925 static void netdev_get_drvinfo(struct net_device *dev, 
     1139STATIC void netdev_get_drvinfo(struct net_device *dev, 
    9261140                        struct ethtool_drvinfo *info) 
    9271141{ 
     
    9331147} 
    9341148 
    935 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
     1149STATIC int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
    9361150{ 
    9371151        struct r6040_private *rp = netdev_priv(dev); 
     
    9451159} 
    9461160 
    947 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
     1161STATIC int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
    9481162{ 
    9491163        struct r6040_private *rp = netdev_priv(dev); 
     
    9581172} 
    9591173 
    960 static u32 netdev_get_link(struct net_device *dev) 
     1174STATIC u32 netdev_get_link(struct net_device *dev) 
    9611175{ 
    9621176        struct r6040_private *rp = netdev_priv(dev); 
     
    9721186}; 
    9731187 
    974 static int __devinit r6040_init_one(struct pci_dev *pdev, 
     1188int __devinit r6040_init_one(struct pci_dev *pdev, 
    9751189                                         const struct pci_device_id *ent) 
    9761190{ 
     
    9851199 
    9861200        printk(KERN_INFO "%s\n", version); 
     1201        printk(KERN_INFO DRV_NAME ": debug %x\n", debug); 
    9871202 
    9881203        err = pci_enable_device(pdev); 
     
    10661281        dev->tx_timeout = &r6040_tx_timeout; 
    10671282        dev->watchdog_timeo = TX_TIMEOUT; 
     1283 
     1284        { 
     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" */ 
     1288                static const u8 dflt_addr[ETH_ALEN] = {0,0x50,0xfc,2,3,4}; 
     1289                memcpy(dev->dev_addr, dflt_addr, ETH_ALEN); 
     1290        } 
     1291 
    10681292#ifdef CONFIG_NET_POLL_CONTROLLER 
    10691293        dev->poll_controller = r6040_poll_controller; 
     
    10831307                goto err_out_res; 
    10841308        } 
     1309 
     1310        dbg(DBG_INIT, "%s successfully registered\n", dev->name); 
    10851311        return 0; 
    10861312 
     
    10951321} 
    10961322 
    1097 static void __devexit r6040_remove_one(struct pci_dev *pdev) 
     1323void __devexit r6040_remove_one(struct pci_dev *pdev) 
    10981324{ 
    10991325        struct net_device *dev = pci_get_drvdata(pdev); 
Note: See TracChangeset for help on using the changeset viewer.