Changeset 9184


Ignore:
Timestamp:
2007-10-08T10:01:30+02:00 (9 years ago)
Author:
florian
Message:

Clean up the r6040 driver using checkpatch

File:
1 edited

Legend:

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

    r8360 r9184  
    1414        Modification List 
    1515        ----------      ------------------------------------------------ 
     16        10-07-2007      Clean up the driver using checkpatch 
    1617        08-24-2006      Support at linux 2.6.10 above 
    1718        03-24-2006      Support NAPI 
    18         03-21-2006      By Charies,change spin_lock_irqsave(lp->lock, flags) to 
    19                         spin_lock_irqsave(&lp->lock, flags) in set_multicast_list 
     19        03-21-2006      By Charies,change spin_lock_irqsave(lp->lock, flags)  
     20                        to spin_lock_irqsave(&lp->lock, flags) 
     21                        in set_multicast_list 
    2022        03-15-2006      Modify the set_multicast_list ,due to when re-plug the ethernet, 
    2123                        it will forget the previous setting 
    22         07-12-2005      Tim, modify the set_multicast_list 
    23         03-28-2005      Tim, modify some error mac register offset in  
    24                         function set_multicast_list 
     24        07-12-2005      Tim, modify the set_multicast_list 
     25        03-28-2005      Tim, modify some error mac register offset in  
     26                        function set_multicast_list 
    2527        03-27-2005      Tim, Add the internal state machine reset 
    2628                        Sten, If multicast address more than 4, enter PROM mode 
     
    6668#define MBCR_DEFAULT    0x012A  /* MAC Bus Control Register */ 
    6769 
     70/* PHY settings */ 
     71#define ICPLUS_PHY_ID   0x0243 
     72 
    6873/* Debug enable or not */ 
    6974#define RDC_DEBUG       0 
    7075 
    7176#if RDC_DEBUG > 1 
    72 #define RDC_DBUG(msg, value) printk("%s %x\n", msg, value); 
     77#define RDC_DBUG(msg, value) printk(KERN_ERR "%s %x\n", msg, value); 
    7378#else 
    7479#define RDC_DBUG(msg, value) 
     
    9398#include <linux/skbuff.h> 
    9499#include <linux/init.h> 
    95 #include <linux/delay.h>        /* for udelay() */ 
     100#include <linux/delay.h> 
    96101#include <linux/mii.h> 
    97102#include <linux/ethtool.h> 
     
    105110#include <asm/uaccess.h> 
    106111 
    107 MODULE_AUTHOR("Sten Wang <sten.wang@rdc.com.tw>"); 
     112MODULE_AUTHOR("Sten Wang <sten.wang@rdc.com.tw>, Daniel Gimpelevich <daniel@gimpelevich.san-francisco.ca.us>, Florian Fainelli <florian@openwrt.org>"); 
    108113MODULE_LICENSE("GPL"); 
    109114#ifdef CONFIG_R6040_NAPI 
     
    124129        struct sk_buff *skb_ptr;        /* 18-1B */ 
    125130        u32     rev2;                   /* 1C-1F */ 
    126 } __attribute__(( aligned(32) )); 
     131} __attribute__((aligned(32))); 
    127132 
    128133struct r6040_private { 
    129134        struct net_device_stats stats; 
    130         spinlock_t lock; 
    131         struct timer_list timer; 
     135        spinlock_t lock;                /* driver lock */ 
     136        struct timer_list timer; 
    132137        struct pci_dev *pdev; 
    133138 
     
    157162#ifdef CONFIG_R6040_NAPI 
    158163static char version[] __devinitdata = 
    159         KERN_INFO DRV_NAME ": RDC R6040 NAPI net driver, version "DRV_VERSION " (" DRV_RELDATE ")\n";    
     164        KERN_INFO DRV_NAME ": RDC R6040 NAPI net driver, version "DRV_VERSION " (" DRV_RELDATE ")\n"; 
    160165#else 
    161166static char version[] __devinitdata = 
    162         KERN_INFO DRV_NAME ": RDC R6040 net driver, version "DRV_VERSION " (" DRV_RELDATE ")\n";         
     167        KERN_INFO DRV_NAME ": RDC R6040 net driver, version "DRV_VERSION " (" DRV_RELDATE ")\n"; 
    163168#endif 
    164169static struct r6040_chip_info r6040_chip_info[] __devinitdata = 
     
    166171        { "RDC R6040 Knight", R6040_PCI_CMD, R6040_IO_SIZE, 0} 
    167172}; 
    168 static char *parent = NULL; 
     173static char *parent; 
    169174 
    170175#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 
     
    177182 
    178183static int phy_table[] = { 0x1, 0x2}; 
    179 static u8 adr_table[2][8] = {{0x00, 0x00, 0x60, 0x00, 0x00, 0x01}, {0x00, 0x00, 0x60, 0x00, 0x00, 0x02}}; 
     184static u8 adr_table[2][8] = { 
     185        {0x00, 0x00, 0x60, 0x00, 0x00, 0x01}, 
     186        {0x00, 0x00, 0x60, 0x00, 0x00, 0x02} 
     187}; 
    180188 
    181189#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 10) 
    182190        module_param_array(adr_table, int, &NUM_MAC_TABLE, 0644); 
    183 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)  
     191#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 
    184192        module_param_array(adr_table, int, NUM_MAC_TABLE, 0644); 
    185193#else 
    186194        MODULE_PARM(adr_table, "2-4i"); 
    187 #endif  
     195#endif 
    188196MODULE_PARM_DESC(adr_table, "MAC Address (assigned)"); 
    189197 
     
    204212static int phy_read(int ioaddr, int phy_adr, int reg_idx); 
    205213static void phy_write(int ioaddr, int phy_adr, int reg_idx, int dat); 
    206 static void rx_buf_alloc(struct r6040_private *lp,struct net_device *dev); 
     214static void rx_buf_alloc(struct r6040_private *lp, struct net_device *dev); 
    207215#ifdef CONFIG_R6040_NAPI 
    208216static int r6040_poll(struct net_device *netdev, int *budget); 
     
    216224        struct r6040_private *lp; 
    217225        int ioaddr, io_size, err; 
    218         static int card_idx = -1;  
     226        static int card_idx = -1; 
    219227        int chip_id = (int)ent->driver_data; 
    220228 
     
    222230 
    223231        if (printed_version++) 
    224                 printk(version); 
    225  
    226         if ((err = pci_enable_device (pdev))) 
     232                printk(KERN_INFO version); 
     233 
     234        err = pci_enable_device(pdev); 
     235        if (err) 
    227236                return err; 
    228237 
     
    289298 
    290299        /* Register net device. After this dev->name assign */ 
    291         if ((err = register_netdev(dev))) { 
     300        err = register_netdev(dev); 
     301        if (err) { 
    292302                printk(KERN_ERR DRV_NAME ": Failed to register net device\n"); 
    293303                goto err_out_res; 
     
    331341 
    332342        /* Allocate Descriptor memory */ 
    333         lp->desc_pool = pci_alloc_consistent(lp->pdev, ALLOC_DESC_SIZE, &lp->desc_dma);  
    334         if (!lp->desc_pool) return -ENOMEM;  
     343        lp->desc_pool = pci_alloc_consistent(lp->pdev, ALLOC_DESC_SIZE, &lp->desc_dma); 
     344        if (!lp->desc_pool) 
     345                return -ENOMEM; 
    335346 
    336347        r6040_up(dev); 
     
    338349        netif_start_queue(dev); 
    339350 
    340         if (lp->switch_sig != 0x0243) 
    341         { 
    342         /* set and active a timer process */ 
    343         init_timer(&lp->timer); 
    344         lp->timer.expires = TIMER_WUT; 
    345         lp->timer.data = (unsigned long)dev; 
    346         lp->timer.function = &r6040_timer; 
    347         add_timer(&lp->timer); 
     351        if (lp->switch_sig != ICPLUS_PHY_ID) { 
     352                /* set and active a timer process */ 
     353                init_timer(&lp->timer); 
     354                lp->timer.expires = TIMER_WUT; 
     355                lp->timer.data = (unsigned long)dev; 
     356                lp->timer.function = &r6040_timer; 
     357                add_timer(&lp->timer); 
    348358        } 
    349359        return 0; 
     
    354364{ 
    355365        struct r6040_private *lp = dev->priv; 
    356         //int ioaddr = dev->base_addr; 
    357         //struct r6040_descriptor *descptr = lp->tx_remove_ptr; 
     366        /* int ioaddr = dev->base_addr; 
     367        struct r6040_descriptor *descptr = lp->tx_remove_ptr; */ 
    358368 
    359369        RDC_DBUG("r6040_tx_timeout()", 0); 
     
    361371        /* Transmitter timeout, serious problems. */ 
    362372        /* Sten: Nothing need to do so far. */ 
    363         printk(KERN_ERR DRV_NAME ": Big Trobule, transmit timeout/n");  
     373        printk(KERN_ERR DRV_NAME ": Big Trobule, transmit timeout/n"); 
    364374        lp->stats.tx_errors++; 
    365375        netif_stop_queue(dev); 
     
    381391        RDC_DBUG("r6040_start_xmit()", 0); 
    382392 
    383         if (skb == NULL)        /* NULL skb directly return */  
     393        if (skb == NULL)        /* NULL skb directly return */ 
    384394                return 0; 
    385395        if (skb->len >= MAX_BUF_SIZE) { /* Packet too long, drop it */ 
     
    394404        if (!lp->tx_free_desc) {  
    395405                spin_unlock_irqrestore(&lp->lock, flags); 
    396                 printk(KERN_ERR DRV_NAME ": NO TX DESC ");  
     406                printk(KERN_ERR DRV_NAME ": NO TX DESC "); 
    397407                return 1; 
    398408        } 
     
    405415        lp->tx_free_desc--; 
    406416        descptr = lp->tx_insert_ptr; 
    407         if (skb->len < 0x3c) descptr->len = 0x3c; 
    408         else descptr->len = skb->len; 
     417        if (skb->len < 0x3c) 
     418                descptr->len = 0x3c; 
     419        else 
     420                descptr->len = skb->len; 
     421 
    409422        descptr->skb_ptr = skb; 
    410423        descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, skb->data, skb->len, PCI_DMA_TODEVICE)); 
     
    415428#if RDC_DEBUG 
    416429 printk("Xmit(): %08lx:%04x %04x %08lx %08lx %08lx %08lx\n", descptr, descptr->status, descptr->len, descptr->buf, descptr->skb_ptr, descptr->ndesc, descptr->vndescp); 
    417 #endif  
     430#endif 
    418431 
    419432        /* If no tx resource, stop */ 
     
    436449        int ioaddr, status; 
    437450        unsigned long flags; 
    438 #ifdef CONFIG_R6040_NAPI         
     451#ifdef CONFIG_R6040_NAPI 
    439452        int handled = 1; 
    440453#else 
    441454        int handled = 0; 
    442 #endif   
     455#endif 
    443456 
    444457        RDC_DBUG("r6040_interrupt()", 0); 
     
    457470         
    458471 
    459 #ifdef CONFIG_R6040_NAPI                 
    460  
    461             if(netif_rx_schedule_prep(dev))      
    462                 { 
    463                 NAPI_status = status ;      
     472#ifdef CONFIG_R6040_NAPI 
     473        if (netif_rx_schedule_prep(dev)) { 
     474                NAPI_status = status; 
    464475                __netif_rx_schedule(dev); 
    465                 } 
    466          
     476        } 
     477 
    467478        spin_unlock_irqrestore(&lp->lock, flags); 
    468         return IRQ_RETVAL(handled);      
     479        return IRQ_RETVAL(handled); 
    469480#else            
    470481        /* TX interrupt request */ 
     
    472483                handled = 1; 
    473484                descptr = lp->tx_remove_ptr; 
    474                 while(lp->tx_free_desc < TX_DCNT) { 
    475                         if (descptr->status & 0x8000) break; /* Not complte */ 
     485                while (lp->tx_free_desc < TX_DCNT) { 
     486                        if (descptr->status & 0x8000) 
     487                                break; /* Not complte */ 
    476488                        skb_ptr = descptr->skb_ptr; 
    477489                        pci_unmap_single(lp->pdev, descptr->buf, skb_ptr->len, PCI_DMA_TODEVICE); 
     
    482494                } 
    483495                lp->tx_remove_ptr = descptr; 
    484                 if (lp->tx_free_desc) netif_wake_queue(dev); 
     496                if (lp->tx_free_desc) 
     497                        netif_wake_queue(dev); 
    485498        }  
    486499 
     
    539552        RDC_DBUG("set_multicast_list()", 0); 
    540553 
    541         /* MAC Address */        
     554        /* MAC Address */ 
    542555        adrp = (u16 *) dev->dev_addr; 
    543         outw(adrp[0], ioaddr + 0x68);  
    544         outw(adrp[1], ioaddr + 0x6A);  
    545         outw(adrp[2], ioaddr + 0x6C);  
    546  
    547  
    548 #if RDC_DEBUG  
     556        outw(adrp[0], ioaddr + 0x68); 
     557        outw(adrp[1], ioaddr + 0x6A); 
     558        outw(adrp[2], ioaddr + 0x6C); 
     559 
     560 
     561#if RDC_DEBUG 
    549562        printk("MAC ADDR: %04x %04x %04x\n", adrp[0], adrp[1], adrp[2]); 
    550563#endif 
     
    553566        spin_lock_irqsave(&lp->lock, flags); 
    554567        i = inw(ioaddr) & ~0x0120;              /* Clear AMCP & PROM */ 
    555         if (dev->flags & IFF_PROMISC) 
    556             {    
    557                 i |= 0x0020; 
    558                 lp->mcr0 |= 0x0020 ; 
    559             } 
    560         if (dev->mc_count > 4) i |= 0x0020;     /* Too many multicast address */ 
     568        if (dev->flags & IFF_PROMISC) { 
     569                i |= 0x0020; 
     570                lp->mcr0 |= 0x0020; 
     571        } 
     572        if (dev->mc_count > 4) 
     573                i |= 0x0020;    /* Too many multicast address */ 
     574 
    561575        outw(i, ioaddr); 
    562576        spin_unlock_irqrestore(&lp->lock, flags); 
     
    567581 
    568582        /* Multicast Address 1~4 case */ 
    569         for (i = 0, mcptr = dev->mc_list; (i<dev->mc_count) && (i<4); i++) { 
     583        for (i = 0, mcptr = dev->mc_list; (i < dev->mc_count) && (i < 4); i++) { 
    570584                adrp = (u16 *)mcptr->dmi_addr; 
    571                 outw(adrp[0], ioaddr + 0x70 + 8*i);  
    572                 outw(adrp[1], ioaddr + 0x72 + 8*i);  
    573                 outw(adrp[2], ioaddr + 0x74 + 8*i);  
     585                outw(adrp[0], ioaddr + 0x70 + 8*i); 
     586                outw(adrp[1], ioaddr + 0x72 + 8*i); 
     587                outw(adrp[2], ioaddr + 0x74 + 8*i); 
    574588                mcptr = mcptr->next; 
    575 #if RDC_DEBUG  
     589#if RDC_DEBUG 
    576590        printk("M_ADDR: %04x %04x %04x\n", adrp[0], adrp[1], adrp[2]); 
    577591#endif 
    578592        } 
    579593        for (i = dev->mc_count; i < 4; i++) { 
    580                 outw(0xffff, ioaddr + 0x68 + 8*i);  
    581                 outw(0xffff, ioaddr + 0x6A + 8*i);  
    582                 outw(0xffff, ioaddr + 0x6C + 8*i);  
     594                outw(0xffff, ioaddr + 0x68 + 8*i); 
     595                outw(0xffff, ioaddr + 0x6A + 8*i); 
     596                outw(0xffff, ioaddr + 0x6C + 8*i); 
    583597        } 
    584598} 
     
    605619 
    606620        /* deleted timer */ 
    607         del_timer_sync(&lp->timer); 
     621        del_timer_sync(&lp->timer); 
    608622 
    609623        spin_lock_irq(&lp->lock); 
     
    623637 
    624638        RDC_DBUG("netdev_ioctl()", 0); 
    625         if (lp->switch_sig == 0x0243 && cmd == SIOCDEVPRIVATE) 
    626         { 
     639 
     640        if (lp->switch_sig == ICPLUS_PHY_ID && cmd == SIOCDEVPRIVATE) { 
    627641                unsigned long *data = (unsigned long *)rq->ifr_data, args[4]; 
    628642                int ioaddr = dev->base_addr; 
     
    634648 
    635649                /* port priority */ 
    636                 if(args[0]&(1<<31))phy_write(ioaddr,29,19,(phy_read(ioaddr,29,19)|0x2000));     /* port 0 */ 
    637                 if(args[0]&(1<<29))phy_write(ioaddr,29,19,(phy_read(ioaddr,29,19)|0x0020));     /* port 1 */ 
    638                 if(args[0]&(1<<27))phy_write(ioaddr,29,20,(phy_read(ioaddr,29,20)|0x2000));     /* port 2 */ 
    639                 if(args[0]&(1<<25))phy_write(ioaddr,29,20,(phy_read(ioaddr,29,20)|0x0020));     /* port 3 */ 
    640  
    641         }  
     650                if(args[0]&(1<<31))phy_write(ioaddr, 29, 19, (phy_read(ioaddr, 29, 19) | 0x2000));      /* port 0 */ 
     651                if(args[0]&(1<<29))phy_write(ioaddr, 29, 19, (phy_read(ioaddr, 29, 19) | 0x0020));      /* port 1 */ 
     652                if(args[0]&(1<<27))phy_write(ioaddr, 29, 20, (phy_read(ioaddr, 29, 20) | 0x2000));      /* port 2 */ 
     653                if(args[0]&(1<<25))phy_write(ioaddr, 29, 20, (phy_read(ioaddr, 29, 20) | 0x0020));      /* port 3 */ 
     654 
     655        } 
    642656        return -EOPNOTSUPP; 
    643657} 
     
    698712         
    699713         
    700         ioaddr = dev->base_addr;         
     714        ioaddr = dev->base_addr; 
    701715        lp = (struct r6040_private *)dev->priv; 
    702         unsigned long rx_work = dev->quota ; 
    703         unsigned long rx ; 
    704          
    705          
     716        unsigned long rx_work = dev->quota; 
     717        unsigned long rx;        
    706718#if 1 
    707719        /* TX interrupt request */ 
    708720        if (NAPI_status & 0x10) { 
    709                  
    710721                descptr = lp->tx_remove_ptr; 
    711                 while(lp->tx_free_desc < TX_DCNT) { 
    712                         if (descptr->status & 0x8000) break; /* Not complte */ 
     722                while (lp->tx_free_desc < TX_DCNT) { 
     723                        if (descptr->status & 0x8000) 
     724                                break; /* Not complte */ 
     725                         
    713726                        skb_ptr = descptr->skb_ptr; 
    714727                        pci_unmap_single(lp->pdev, descptr->buf, skb_ptr->len, PCI_DMA_TODEVICE); 
     
    720733                lp->tx_remove_ptr = descptr; 
    721734                if (lp->tx_free_desc) netif_wake_queue(dev); 
    722         }  
     735        } 
    723736#endif   
    724737#if 1 
    725738        /* RX interrupt request */ 
    726         if (NAPI_status & 0x01) {                
    727                  
     739        if (NAPI_status & 0x01) { 
    728740                descptr = lp->rx_remove_ptr; 
    729                 while(lp->rx_free_desc) { 
    730                         if (descptr->status & 0x8000) break; /* No Rx packet */ 
     741                while (lp->rx_free_desc) { 
     742                        if (descptr->status & 0x8000) 
     743                                break; /* No Rx packet */ 
    731744                        skb_ptr = descptr->skb_ptr; 
    732745                        descptr->skb_ptr = 0; 
     
    734747                        skb_put(skb_ptr, descptr->len - 4); 
    735748                        pci_unmap_single(lp->pdev, descptr->buf, MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    736                         skb_ptr->protocol = eth_type_trans(skb_ptr, dev);                          
    737                         netif_receive_skb(skb_ptr); /* Send to upper layer */ 
     749                        skb_ptr->protocol = eth_type_trans(skb_ptr, dev); 
     750                        netif_receive_skb(skb_ptr); /* Send to upper layer */ 
    738751                        lp->stats.rx_packets++; 
    739752                        lp->stats.rx_bytes += descptr->len; 
     
    742755                } 
    743756                lp->rx_remove_ptr = descptr; 
    744                  
    745757        } 
    746758        /* Allocate new RX buffer */ 
    747         if (lp->rx_free_desc < RX_DCNT) rx_buf_alloc(lp,dev); 
     759        if (lp->rx_free_desc < RX_DCNT) 
     760                rx_buf_alloc(lp, dev); 
    748761         
    749762        local_irq_disable(); 
    750763        netif_rx_complete(dev); 
    751         outw(R6040_INT_MASK,ioaddr + 0x40);      
     764        outw(R6040_INT_MASK, ioaddr + 0x40); 
    752765        local_irq_enable(); 
    753766        return 0; 
     
    778791        lp->rx_insert_ptr = (struct r6040_descriptor *)lp->tx_insert_ptr+TX_DCNT; 
    779792        lp->rx_remove_ptr = lp->rx_insert_ptr; 
    780          
     793 
    781794        /* Init TX descriptor */ 
    782795        descptr = lp->tx_insert_ptr; 
     
    805818 
    806819        /* Allocate buffer for RX descriptor */ 
    807         rx_buf_alloc(lp,dev); 
    808  
    809 #if RDC_DEBUG  
     820        rx_buf_alloc(lp, dev); 
     821 
     822#if RDC_DEBUG 
    810823descptr = lp->tx_insert_ptr; 
    811824for (i = 0; i < TX_DCNT; i++) { 
     
    822835        /* MAC operation register */ 
    823836        outw(0x01, ioaddr+0x04);        /* Reset MAC */ 
    824         outw(2   , ioaddr+0xAC);        /* Reset internal state machine */ 
    825         outw(0   , ioaddr+0xAC); 
     837        outw(2, ioaddr+0xAC);           /* Reset internal state machine */ 
     838        outw(0, ioaddr+0xAC); 
    826839        udelay(5000); 
    827840 
     
    839852        outw(MAX_BUF_SIZE, ioaddr+0x18); 
    840853 
    841         if ((lp->switch_sig = phy_read(ioaddr, 0, 2)) == 0x0243)        // ICPlus IP175C Signature 
    842         { 
    843                 phy_write(ioaddr, 29,31, 0x175C);       //Enable registers 
     854        if ((lp->switch_sig = phy_read(ioaddr, 0, 2)) == ICPLUS_PHY_ID) { 
     855                phy_write(ioaddr, 29,31, 0x175C); /* Enable registers */ 
    844856                lp->phy_mode = 0x8000; 
    845857        } else { 
     
    865877 
    866878        /* upgrade performance (by RDC guys) */ 
    867         phy_write(ioaddr,30,17,(phy_read(ioaddr,30,17)|0x4000));        //bit 14=1 
    868         phy_write(ioaddr,30,17,~((~phy_read(ioaddr,30,17))|0x2000));    //bit 13=0 
    869         phy_write(ioaddr,0,19,0x0000); 
    870         phy_write(ioaddr,0,30,0x01F0); 
     879        phy_write(ioaddr, 30, 17, (phy_read(ioaddr, 30, 17) | 0x4000));        //bit 14=1 
     880        phy_write(ioaddr, 30, 17, ~((~phy_read(ioaddr, 30, 17)) | 0x2000));    //bit 13=0 
     881        phy_write(ioaddr, 0, 19, 0x0000); 
     882        phy_write(ioaddr, 0, 30, 0x01F0); 
    871883 
    872884        /* Interrupt Mask Register */ 
     
    880892static void r6040_timer(unsigned long data) 
    881893{ 
    882         struct net_device *dev=(struct net_device *)data; 
     894        struct net_device *dev = (struct net_device *)data; 
    883895        struct r6040_private *lp = dev->priv; 
    884896        u16 ioaddr = dev->base_addr, phy_mode; 
    885   
     897 
    886898        RDC_DBUG("r6040_timer()", 0); 
    887899 
     
    889901        if (PHY_MODE == 0x3100)  
    890902                phy_mode = phy_mode_chk(dev); 
    891         else phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
     903        else 
     904                phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
    892905 
    893906        if (phy_mode != lp->phy_mode) { 
     
    895908                lp->mcr0 = (lp->mcr0 & 0x7fff) | phy_mode; 
    896909                outw(lp->mcr0, ioaddr); 
    897                 printk("<RDC> Link Change %x \n", inw(ioaddr)); 
     910                printk(KERN_INFO "Link Change %x \n", inw(ioaddr)); 
    898911        } 
    899912 
     
    901914//      printk("<RDC> Timer: CR0 %x CR40 %x CR3C %x\n", inw(ioaddr), inw(ioaddr+0x40), inw(ioaddr+0x3c)); 
    902915 
    903         /* Timer active again */ 
    904         lp->timer.expires = TIMER_WUT; 
    905         add_timer(&lp->timer); 
     916        /* Timer active again */ 
     917        lp->timer.expires = TIMER_WUT; 
     918        add_timer(&lp->timer); 
    906919} 
    907920 
    908921/* Allocate skb buffer for rx descriptor */ 
    909 static void rx_buf_alloc(struct r6040_private *lp,struct net_device *dev) 
     922static void rx_buf_alloc(struct r6040_private *lp, struct net_device *dev) 
    910923{ 
    911924        struct r6040_descriptor *descptr; 
     
    913926 
    914927        RDC_DBUG("rx_buf_alloc()", 0); 
     928 
    915929        descptr = lp->rx_insert_ptr; 
    916         while(lp->rx_free_desc < RX_DCNT){ 
     930        while (lp->rx_free_desc < RX_DCNT) { 
    917931                descptr->skb_ptr = dev_alloc_skb(MAX_BUF_SIZE); 
    918                 if (!descptr->skb_ptr) break; 
     932 
     933                if (!descptr->skb_ptr) 
     934                        break; 
    919935                descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, descptr->skb_ptr->tail, MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
    920936                descptr->status = 0x8000; 
    921937                descptr = descptr->vndescp; 
    922938                lp->rx_free_desc++; 
    923                 outw(lp->mcr0 | 0x0002, ioaddr);        //Trigger Rx DMA 
     939                outw(lp->mcr0 | 0x0002, ioaddr); /* Trigger Rx DMA */ 
    924940        } 
    925941        lp->rx_insert_ptr = descptr; 
     
    936952        /* PHY Link Status Check */ 
    937953        phy_dat = phy_read(ioaddr, lp->phy_addr, 1); 
    938         if (!(phy_dat & 0x4)) return 0x8000;    /* Link Failed, full duplex */ 
     954        if (!(phy_dat & 0x4)) 
     955                return 0x8000;  /* Link Failed, full duplex */ 
    939956 
    940957        /* PHY Chip Auto-Negotiation Status */ 
     
    944961                phy_dat = phy_read(ioaddr, lp->phy_addr, 5); 
    945962                phy_dat &= phy_read(ioaddr, lp->phy_addr, 4); 
    946                 if (phy_dat & 0x140) phy_dat = 0x8000; 
    947                 else phy_dat = 0; 
     963                if (phy_dat & 0x140) 
     964                        phy_dat = 0x8000; 
     965                else 
     966                        phy_dat = 0; 
    948967        } else { 
    949968                /* Force Mode */ 
     
    963982        RDC_DBUG("phy_read()", 0); 
    964983        outw(0x2000 + reg_idx + (phy_addr << 8), ioaddr + 0x20); 
    965         do{}while( (i++ < 2048) && (inw(ioaddr + 0x20) & 0x2000) ); 
     984        do {} while ((i++ < 2048) && (inw(ioaddr + 0x20) & 0x2000)); 
    966985 
    967986        return inw(ioaddr + 0x24); 
     
    9851004static struct pci_device_id r6040_pci_tbl[] = { 
    9861005        {0x17F3, 0x6040, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RDC_6040}, 
    987         //{0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RDC_6040}, 
    988         {0,}                    /* terminate list */ 
     1006        /* {PCI_VENDOR_ID_RDC, PCI_DEVICE_ID_R6040, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RDC_6040},*/ 
     1007        /*{0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RDC_6040},*/ 
     1008        {0,} 
    9891009}; 
    9901010MODULE_DEVICE_TABLE(pci, r6040_pci_tbl); 
     
    10021022        RDC_DBUG("r6040_init()", 0); 
    10031023 
    1004         printk(version); 
     1024        printk(KERN_INFO version); 
    10051025        printed_version = 1; 
    10061026 
    1007         if (parent != NULL) 
    1008         { 
     1027        if (parent != NULL) { 
    10091028                struct net_device *the_parent = dev_get_by_name(parent); 
    10101029 
    1011                 if (the_parent == NULL) 
    1012                 { 
     1030                if (the_parent == NULL) { 
    10131031                        printk (KERN_ERR DRV_NAME ": Unknown device \"%s\" specified.\n", parent); 
    10141032                        return -EINVAL; 
     
    10301048module_init(r6040_init); 
    10311049module_exit(r6040_cleanup); 
    1032  
    1033  
    1034 /* 
    1035  * Local variables: 
    1036  *  compile-command: "gcc -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -c r6040.c `[ -f /usr/include/linux/modversions.h ] && echo -DMODVERSIONS`" 
    1037  *  c-indent-level: 4 
    1038  *  c-basic-offset: 4 
    1039  *  tab-width: 4 
    1040  * End: 
    1041  */ 
Note: See TracChangeset for help on using the changeset viewer.