rndis_wlan: cleanup: rename and remove local pointers
[linux-2.6.git] / drivers / net / tlan.c
index 106dc1e..85246ed 100644 (file)
@@ -13,8 +13,6 @@
  *  This software may be used and distributed according to the terms
  *  of the GNU General Public License, incorporated herein by reference.
  *
- ** This file is best viewed/edited with columns>=132.
- *
  ** Useful (if not required) reading:
  *
  *             Texas Instruments, ThunderLAN Programmer's Guide,
@@ -218,9 +216,7 @@ static      int             bbuf;
 module_param(bbuf, int, 0);
 MODULE_PARM_DESC(bbuf, "ThunderLAN use big buffer (0-1)");
 
-static u8              *TLanPadBuffer;
-static  dma_addr_t     TLanPadBufferDMA;
-static char            TLanSignature[] = "TLAN";
+static const char TLanSignature[] = "TLAN";
 static  const char tlan_banner[] = "ThunderLAN driver v1.15\n";
 static  int tlan_have_pci;
 static  int tlan_have_eisa;
@@ -238,9 +234,11 @@ static struct board {
        { "Compaq Netelligent 10 T PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
        { "Compaq Netelligent 10/100 TX PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
        { "Compaq Integrated NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
-       { "Compaq NetFlex-3/P", TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
+       { "Compaq NetFlex-3/P",
+         TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
        { "Compaq NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
-       { "Compaq Netelligent Integrated 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
+       { "Compaq Netelligent Integrated 10/100 TX UTP",
+         TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
        { "Compaq Netelligent Dual 10/100 TX PCI UTP", TLAN_ADAPTER_NONE, 0x83 },
        { "Compaq Netelligent 10/100 TX Embedded UTP", TLAN_ADAPTER_NONE, 0x83 },
        { "Olicom OC-2183/2185", TLAN_ADAPTER_USE_INTERN_10, 0x83 },
@@ -248,8 +246,9 @@ static struct board {
        { "Olicom OC-2326", TLAN_ADAPTER_USE_INTERN_10, 0xF8 },
        { "Compaq Netelligent 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
        { "Compaq Netelligent 10 T/2 PCI UTP/Coax", TLAN_ADAPTER_NONE, 0x83 },
-       { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED |     /* EISA card */
-                               TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
+       { "Compaq NetFlex-3/E",
+         TLAN_ADAPTER_ACTIVITY_LED |   /* EISA card */
+         TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
        { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, /* EISA card */
 };
 
@@ -294,12 +293,12 @@ static int        TLan_Close( struct net_device *);
 static struct  net_device_stats *TLan_GetStats( struct net_device *);
 static void    TLan_SetMulticastList( struct net_device *);
 static int     TLan_ioctl( struct net_device *dev, struct ifreq *rq, int cmd);
-static int      TLan_probe1( struct pci_dev *pdev, long ioaddr, int irq, int rev, const struct pci_device_id *ent);
+static int      TLan_probe1( struct pci_dev *pdev, long ioaddr,
+                            int irq, int rev, const struct pci_device_id *ent);
 static void    TLan_tx_timeout( struct net_device *dev);
 static void    TLan_tx_timeout_work(struct work_struct *work);
 static int     tlan_init_one( struct pci_dev *pdev, const struct pci_device_id *ent);
 
-static u32     TLan_HandleInvalid( struct net_device *, u16 );
 static u32     TLan_HandleTxEOF( struct net_device *, u16 );
 static u32     TLan_HandleStatOverflow( struct net_device *, u16 );
 static u32     TLan_HandleRxEOF( struct net_device *, u16 );
@@ -348,29 +347,27 @@ static void       TLan_EeReceiveByte( u16, u8 *, int );
 static int     TLan_EeReadByte( struct net_device *, u8, u8 * );
 
 
-static void
+static inline void
 TLan_StoreSKB( struct tlan_list_tag *tag, struct sk_buff *skb)
 {
        unsigned long addr = (unsigned long)skb;
-       tag->buffer[9].address = (u32)addr;
-       addr >>= 31;    /* >>= 32 is undefined for 32bit arch, stupid C */
-       addr >>= 1;
-       tag->buffer[8].address = (u32)addr;
+       tag->buffer[9].address = addr;
+       tag->buffer[8].address = upper_32_bits(addr);
 }
 
-static struct sk_buff *
-TLan_GetSKB( struct tlan_list_tag *tag)
+static inline struct sk_buff *
+TLan_GetSKB( const struct tlan_list_tag *tag)
 {
-       unsigned long addr = tag->buffer[8].address;
-       addr <<= 31;
-       addr <<= 1;
-       addr |= tag->buffer[9].address;
+       unsigned long addr;
+
+       addr = tag->buffer[8].address;
+       addr |= (tag->buffer[9].address << 16) << 16;
        return (struct sk_buff *) addr;
 }
 
 
 static TLanIntVectorFunc *TLanIntVector[TLAN_INT_NUMBER_OF_INTS] = {
-       TLan_HandleInvalid,
+       NULL,
        TLan_HandleTxEOF,
        TLan_HandleStatOverflow,
        TLan_HandleRxEOF,
@@ -444,7 +441,9 @@ static void __devexit tlan_remove_one( struct pci_dev *pdev)
        unregister_netdev( dev );
 
        if ( priv->dmaStorage ) {
-               pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, priv->dmaStorageDMA );
+               pci_free_consistent(priv->pciDev,
+                                   priv->dmaSize, priv->dmaStorage,
+                                   priv->dmaStorageDMA );
        }
 
 #ifdef CONFIG_PCI
@@ -465,25 +464,20 @@ static struct pci_driver tlan_driver = {
 
 static int __init tlan_probe(void)
 {
-       static int      pad_allocated;
+       int rc = -ENODEV;
 
        printk(KERN_INFO "%s", tlan_banner);
 
-       TLanPadBuffer = (u8 *) pci_alloc_consistent(NULL, TLAN_MIN_FRAME_SIZE, &TLanPadBufferDMA);
-
-       if (TLanPadBuffer == NULL) {
-               printk(KERN_ERR "TLAN: Could not allocate memory for pad buffer.\n");
-               return -ENOMEM;
-       }
-
-       memset(TLanPadBuffer, 0, TLAN_MIN_FRAME_SIZE);
-       pad_allocated = 1;
-
        TLAN_DBG(TLAN_DEBUG_PROBE, "Starting PCI Probe....\n");
 
        /* Use new style PCI probing. Now the kernel will
           do most of this for us */
-       pci_register_driver(&tlan_driver);
+       rc = pci_register_driver(&tlan_driver);
+
+       if (rc != 0) {
+               printk(KERN_ERR "TLAN: Could not register pci driver.\n");
+               goto err_out_pci_free;
+       }
 
        TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....\n");
        TLan_EisaProbe();
@@ -493,11 +487,15 @@ static int __init tlan_probe(void)
                 tlan_have_pci, tlan_have_eisa);
 
        if (TLanDevicesInstalled == 0) {
-               pci_unregister_driver(&tlan_driver);
-               pci_free_consistent(NULL, TLAN_MIN_FRAME_SIZE, TLanPadBuffer, TLanPadBufferDMA);
-               return -ENODEV;
+               rc = -ENODEV;
+               goto  err_out_pci_unreg;
        }
        return 0;
+
+err_out_pci_unreg:
+       pci_unregister_driver(&tlan_driver);
+err_out_pci_free:
+       return rc;
 }
 
 
@@ -528,12 +526,12 @@ static int __devinit tlan_init_one( struct pci_dev *pdev,
         **************************************************************/
 
 static int __devinit TLan_probe1(struct pci_dev *pdev,
-                               long ioaddr, int irq, int rev, const struct pci_device_id *ent )
+                                long ioaddr, int irq, int rev,
+                                const struct pci_device_id *ent )
 {
 
        struct net_device  *dev;
        TLanPrivateInfo    *priv;
-       u8                 pci_rev;
        u16                device_id;
        int                reg, rc = -ENODEV;
 
@@ -557,7 +555,6 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
                rc = -ENOMEM;
                goto err_out_regions;
        }
-       SET_MODULE_OWNER(dev);
        SET_NETDEV_DEV(dev, &pdev->dev);
 
        priv = netdev_priv(dev);
@@ -577,8 +574,6 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
                        goto err_out_free_dev;
                }
 
-               pci_read_config_byte ( pdev, PCI_REVISION_ID, &pci_rev);
-
                for ( reg= 0; reg <= 5; reg ++ ) {
                        if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {
                                pci_io_base = pci_resource_start(pdev, reg);
@@ -595,7 +590,7 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
 
                dev->base_addr = pci_io_base;
                dev->irq = pdev->irq;
-               priv->adapterRev = pci_rev;
+               priv->adapterRev = pdev->revision;
                pci_set_master(pdev);
                pci_set_drvdata(pdev, dev);
 
@@ -618,8 +613,10 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
        /* Kernel parameters */
        if (dev->mem_start) {
                priv->aui    = dev->mem_start & 0x01;
-               priv->duplex = ((dev->mem_start & 0x06) == 0x06) ? 0 : (dev->mem_start & 0x06) >> 1;
-               priv->speed  = ((dev->mem_start & 0x18) == 0x18) ? 0 : (dev->mem_start & 0x18) >> 3;
+               priv->duplex = ((dev->mem_start & 0x06) == 0x06) ? 0
+                       : (dev->mem_start & 0x06) >> 1;
+               priv->speed  = ((dev->mem_start & 0x18) == 0x18) ? 0
+                       : (dev->mem_start & 0x18) >> 3;
 
                if (priv->speed == 0x1) {
                        priv->speed = TLAN_SPEED_10;
@@ -699,7 +696,8 @@ static void TLan_Eisa_Cleanup(void)
                dev = TLan_Eisa_Devices;
                priv = netdev_priv(dev);
                if (priv->dmaStorage) {
-                       pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, priv->dmaStorageDMA );
+                       pci_free_consistent(priv->pciDev, priv->dmaSize,
+                                           priv->dmaStorage, priv->dmaStorageDMA );
                }
                release_region( dev->base_addr, 0x10);
                unregister_netdev( dev );
@@ -717,8 +715,6 @@ static void __exit tlan_exit(void)
        if (tlan_have_eisa)
                TLan_Eisa_Cleanup();
 
-       pci_free_consistent(NULL, TLAN_MIN_FRAME_SIZE, TLanPadBuffer, TLanPadBufferDMA);
-
 }
 
 
@@ -756,8 +752,10 @@ static void  __init TLan_EisaProbe (void)
        /* Loop through all slots of the EISA bus */
        for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
 
-       TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", (int) ioaddr + 0xC80, inw(ioaddr + EISA_ID));
-       TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", (int) ioaddr + 0xC82, inw(ioaddr + EISA_ID2));
+       TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n",
+                (int) ioaddr + 0xC80, inw(ioaddr + EISA_ID));
+       TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n",
+                (int) ioaddr + 0xC82, inw(ioaddr + EISA_ID2));
 
 
                TLAN_DBG(TLAN_DEBUG_PROBE, "Probing for EISA adapter at IO: 0x%4x : ",
@@ -867,7 +865,8 @@ static int TLan_Init( struct net_device *dev )
                dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
                   * ( sizeof(TLanList) );
        }
-       priv->dmaStorage = pci_alloc_consistent(priv->pciDev, dma_size, &priv->dmaStorageDMA);
+       priv->dmaStorage = pci_alloc_consistent(priv->pciDev,
+                                               dma_size, &priv->dmaStorageDMA);
        priv->dmaSize = dma_size;
 
        if ( priv->dmaStorage == NULL ) {
@@ -876,16 +875,19 @@ static int TLan_Init( struct net_device *dev )
                return -ENOMEM;
        }
        memset( priv->dmaStorage, 0, dma_size );
-       priv->rxList = (TLanList *)
-                      ( ( ( (u32) priv->dmaStorage ) + 7 ) & 0xFFFFFFF8 );
-       priv->rxListDMA = ( ( ( (u32) priv->dmaStorageDMA ) + 7 ) & 0xFFFFFFF8 );
+       priv->rxList = (TLanList *) ALIGN((unsigned long)priv->dmaStorage, 8);
+       priv->rxListDMA = ALIGN(priv->dmaStorageDMA, 8);
        priv->txList = priv->rxList + TLAN_NUM_RX_LISTS;
        priv->txListDMA = priv->rxListDMA + sizeof(TLanList) * TLAN_NUM_RX_LISTS;
+
        if ( bbuf ) {
                priv->rxBuffer = (u8 *) ( priv->txList + TLAN_NUM_TX_LISTS );
-               priv->rxBufferDMA =priv->txListDMA + sizeof(TLanList) * TLAN_NUM_TX_LISTS;
-               priv->txBuffer = priv->rxBuffer + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
-               priv->txBufferDMA = priv->rxBufferDMA + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
+               priv->rxBufferDMA =priv->txListDMA
+                       + sizeof(TLanList) * TLAN_NUM_TX_LISTS;
+               priv->txBuffer = priv->rxBuffer
+                       + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
+               priv->txBufferDMA = priv->rxBufferDMA
+                       + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
        }
 
        err = 0;
@@ -945,10 +947,12 @@ static int TLan_Open( struct net_device *dev )
        int             err;
 
        priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION );
-       err = request_irq( dev->irq, TLan_HandleInterrupt, IRQF_SHARED, TLanSignature, dev );
+       err = request_irq( dev->irq, TLan_HandleInterrupt, IRQF_SHARED,
+                          dev->name, dev );
 
        if ( err ) {
-               printk(KERN_ERR "TLAN:  Cannot open %s because IRQ %d is already in use.\n", dev->name, dev->irq );
+               pr_err("TLAN:  Cannot open %s because IRQ %d is already in use.\n",
+                      dev->name, dev->irq );
                return err;
        }
 
@@ -962,7 +966,8 @@ static int TLan_Open( struct net_device *dev )
        TLan_ReadAndClearStats( dev, TLAN_IGNORE );
        TLan_ResetAdapter( dev );
 
-       TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Opened.  TLAN Chip Rev: %x\n", dev->name, priv->tlanRev );
+       TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Opened.  TLAN Chip Rev: %x\n",
+                 dev->name, priv->tlanRev );
 
        return 0;
 
@@ -1000,14 +1005,16 @@ static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 
 
        case SIOCGMIIREG:               /* Read MII PHY register. */
-                       TLan_MiiReadReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, &data->val_out);
+                       TLan_MiiReadReg(dev, data->phy_id & 0x1f,
+                                       data->reg_num & 0x1f, &data->val_out);
                        return 0;
 
 
        case SIOCSMIIREG:               /* Write MII PHY register. */
                        if (!capable(CAP_NET_ADMIN))
                                return -EPERM;
-                       TLan_MiiWriteReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
+                       TLan_MiiWriteReg(dev, data->phy_id & 0x1f,
+                                        data->reg_num & 0x1f, data->val_in);
                        return 0;
                default:
                        return -EOPNOTSUPP;
@@ -1089,20 +1096,25 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
        TLanList        *tail_list;
        dma_addr_t      tail_list_phys;
        u8              *tail_buffer;
-       int             pad;
        unsigned long   flags;
 
        if ( ! priv->phyOnline ) {
-               TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s PHY is not ready\n", dev->name );
+               TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s PHY is not ready\n",
+                         dev->name );
                dev_kfree_skb_any(skb);
                return 0;
        }
 
+       if (skb_padto(skb, TLAN_MIN_FRAME_SIZE))
+               return 0;
+
        tail_list = priv->txList + priv->txTail;
        tail_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txTail;
 
        if ( tail_list->cStat != TLAN_CSTAT_UNUSED ) {
-               TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s is busy (Head=%d Tail=%d)\n", dev->name, priv->txHead, priv->txTail );
+               TLAN_DBG( TLAN_DEBUG_TX,
+                         "TRANSMIT:  %s is busy (Head=%d Tail=%d)\n",
+                         dev->name, priv->txHead, priv->txTail );
                netif_stop_queue(dev);
                priv->txBusyCount++;
                return 1;
@@ -1114,37 +1126,34 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
                tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE );
                skb_copy_from_linear_data(skb, tail_buffer, skb->len);
        } else {
-               tail_list->buffer[0].address = pci_map_single(priv->pciDev, skb->data, skb->len, PCI_DMA_TODEVICE);
+               tail_list->buffer[0].address = pci_map_single(priv->pciDev,
+                                                             skb->data, skb->len,
+                                                             PCI_DMA_TODEVICE);
                TLan_StoreSKB(tail_list, skb);
        }
 
-       pad = TLAN_MIN_FRAME_SIZE - skb->len;
-
-       if ( pad > 0 ) {
-               tail_list->frameSize = (u16) skb->len + pad;
-               tail_list->buffer[0].count = (u32) skb->len;
-               tail_list->buffer[1].count = TLAN_LAST_BUFFER | (u32) pad;
-               tail_list->buffer[1].address = TLanPadBufferDMA;
-       } else {
-               tail_list->frameSize = (u16) skb->len;
-               tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) skb->len;
-               tail_list->buffer[1].count = 0;
-               tail_list->buffer[1].address = 0;
-       }
+       tail_list->frameSize = (u16) skb->len;
+       tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) skb->len;
+       tail_list->buffer[1].count = 0;
+       tail_list->buffer[1].address = 0;
 
        spin_lock_irqsave(&priv->lock, flags);
        tail_list->cStat = TLAN_CSTAT_READY;
        if ( ! priv->txInProgress ) {
                priv->txInProgress = 1;
-               TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Starting TX on buffer %d\n", priv->txTail );
+               TLAN_DBG( TLAN_DEBUG_TX,
+                         "TRANSMIT:  Starting TX on buffer %d\n", priv->txTail );
                outl( tail_list_phys, dev->base_addr + TLAN_CH_PARM );
                outl( TLAN_HC_GO, dev->base_addr + TLAN_HOST_CMD );
        } else {
-               TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Adding buffer %d to TX channel\n", priv->txTail );
+               TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Adding buffer %d to TX channel\n",
+                         priv->txTail );
                if ( priv->txTail == 0 ) {
-                       ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward = tail_list_phys;
+                       ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward
+                               = tail_list_phys;
                } else {
-                       ( priv->txList + ( priv->txTail - 1 ) )->forward = tail_list_phys;
+                       ( priv->txList + ( priv->txTail - 1 ) )->forward
+                               = tail_list_phys;
                }
        }
        spin_unlock_irqrestore(&priv->lock, flags);
@@ -1184,33 +1193,31 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
 
 static irqreturn_t TLan_HandleInterrupt(int irq, void *dev_id)
 {
-       u32             ack;
-       struct net_device       *dev;
-       u32             host_cmd;
+       struct net_device       *dev = dev_id;
+       TLanPrivateInfo *priv = netdev_priv(dev);
        u16             host_int;
-       int             type;
-       TLanPrivateInfo *priv;
-
-       dev = dev_id;
-       priv = netdev_priv(dev);
+       u16             type;
 
        spin_lock(&priv->lock);
 
        host_int = inw( dev->base_addr + TLAN_HOST_INT );
-       outw( host_int, dev->base_addr + TLAN_HOST_INT );
-
        type = ( host_int & TLAN_HI_IT_MASK ) >> 2;
+       if ( type ) {
+               u32     ack;
+               u32     host_cmd;
 
-       ack = TLanIntVector[type]( dev, host_int );
+               outw( host_int, dev->base_addr + TLAN_HOST_INT );
+               ack = TLanIntVector[type]( dev, host_int );
 
-       if ( ack ) {
-               host_cmd = TLAN_HC_ACK | ack | ( type << 18 );
-               outl( host_cmd, dev->base_addr + TLAN_HOST_CMD );
+               if ( ack ) {
+                       host_cmd = TLAN_HC_ACK | ack | ( type << 18 );
+                       outl( host_cmd, dev->base_addr + TLAN_HOST_CMD );
+               }
        }
 
        spin_unlock(&priv->lock);
 
-       return IRQ_HANDLED;
+       return IRQ_RETVAL(type);
 } /* TLan_HandleInterrupts */
 
 
@@ -1279,8 +1286,10 @@ static struct net_device_stats *TLan_GetStats( struct net_device *dev )
        /* Should only read stats if open ? */
        TLan_ReadAndClearStats( dev, TLAN_RECORD );
 
-       TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  %s EOC count = %d\n", dev->name, priv->rxEocCount );
-       TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s Busy count = %d\n", dev->name, priv->txBusyCount );
+       TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  %s EOC count = %d\n", dev->name,
+                 priv->rxEocCount );
+       TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s Busy count = %d\n", dev->name,
+                 priv->txBusyCount );
        if ( debug & TLAN_DEBUG_GNRL ) {
                TLan_PrintDio( dev->base_addr );
                TLan_PhyPrint( dev );
@@ -1292,7 +1301,7 @@ static struct net_device_stats *TLan_GetStats( struct net_device *dev )
                        TLan_PrintList( priv->txList + i, "TX", i );
        }
 
-       return ( &( (TLanPrivateInfo *) netdev_priv(dev) )->stats );
+       return &dev->stats;
 
 } /* TLan_GetStats */
 
@@ -1330,10 +1339,12 @@ static void TLan_SetMulticastList( struct net_device *dev )
 
        if ( dev->flags & IFF_PROMISC ) {
                tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
-               TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF );
+               TLan_DioWrite8( dev->base_addr,
+                               TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF );
        } else {
                tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
-               TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF );
+               TLan_DioWrite8( dev->base_addr,
+                               TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF );
                if ( dev->flags & IFF_ALLMULTI ) {
                        for ( i = 0; i < 3; i++ )
                                TLan_SetMac( dev, i + 1, NULL );
@@ -1342,7 +1353,8 @@ static void TLan_SetMulticastList( struct net_device *dev )
                } else {
                        for ( i = 0; i < dev->mc_count; i++ ) {
                                if ( i < 3 ) {
-                                       TLan_SetMac( dev, i + 1, (char *) &dmi->dmi_addr );
+                                       TLan_SetMac( dev, i + 1,
+                                                    (char *) &dmi->dmi_addr );
                                } else {
                                        offset = TLan_HashFunc( (u8 *) &dmi->dmi_addr );
                                        if ( offset < 32 )
@@ -1376,31 +1388,6 @@ static void TLan_SetMulticastList( struct net_device *dev )
 *****************************************************************************/
 
 
-       /***************************************************************
-        *      TLan_HandleInvalid
-        *
-        *      Returns:
-        *              0
-        *      Parms:
-        *              dev             Device assigned the IRQ that was
-        *                              raised.
-        *              host_int        The contents of the HOST_INT
-        *                              port.
-        *
-        *      This function handles invalid interrupts.  This should
-        *      never happen unless some other adapter is trying to use
-        *      the IRQ line assigned to the device.
-        *
-        **************************************************************/
-
-u32 TLan_HandleInvalid( struct net_device *dev, u16 host_int )
-{
-       /* printk( "TLAN:  Invalid interrupt on %s.\n", dev->name ); */
-       return 0;
-
-} /* TLan_HandleInvalid */
-
-
 
 
        /***************************************************************
@@ -1425,7 +1412,7 @@ u32 TLan_HandleInvalid( struct net_device *dev, u16 host_int )
         *
         **************************************************************/
 
-u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
+static u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        int             eoc = 0;
@@ -1434,14 +1421,16 @@ u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
        u32             ack = 0;
        u16             tmpCStat;
 
-       TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOF (Head=%d Tail=%d)\n", priv->txHead, priv->txTail );
+       TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOF (Head=%d Tail=%d)\n",
+                 priv->txHead, priv->txTail );
        head_list = priv->txList + priv->txHead;
 
        while (((tmpCStat = head_list->cStat ) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
                ack++;
                if ( ! bbuf ) {
                        struct sk_buff *skb = TLan_GetSKB(head_list);
-                       pci_unmap_single(priv->pciDev, head_list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
+                       pci_unmap_single(priv->pciDev, head_list->buffer[0].address,
+                                        skb->len, PCI_DMA_TODEVICE);
                        dev_kfree_skb_any(skb);
                        head_list->buffer[8].address = 0;
                        head_list->buffer[9].address = 0;
@@ -1450,7 +1439,7 @@ u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
                if ( tmpCStat & TLAN_CSTAT_EOC )
                        eoc = 1;
 
-               priv->stats.tx_bytes += head_list->frameSize;
+               dev->stats.tx_bytes += head_list->frameSize;
 
                head_list->cStat = TLAN_CSTAT_UNUSED;
                netif_start_queue(dev);
@@ -1462,7 +1451,9 @@ u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
                printk(KERN_INFO "TLAN: Received interrupt for uncompleted TX frame.\n");
 
        if ( eoc ) {
-               TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d)\n", priv->txHead, priv->txTail );
+               TLAN_DBG( TLAN_DEBUG_TX,
+                         "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d)\n",
+                         priv->txHead, priv->txTail );
                head_list = priv->txList + priv->txHead;
                head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
                if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
@@ -1474,7 +1465,8 @@ u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
        }
 
        if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
-               TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
+               TLan_DioWrite8( dev->base_addr,
+                               TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
                if ( priv->timer.function == NULL ) {
                         priv->timer.function = &TLan_Timer;
                         priv->timer.data = (unsigned long) dev;
@@ -1511,7 +1503,7 @@ u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
         *
         **************************************************************/
 
-u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int )
+static u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int )
 {
        TLan_ReadAndClearStats( dev, TLAN_RECORD );
 
@@ -1547,7 +1539,7 @@ u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int )
         *
         **************************************************************/
 
-u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
+static u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u32             ack = 0;
@@ -1556,66 +1548,65 @@ u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
        TLanList        *head_list;
        struct sk_buff  *skb;
        TLanList        *tail_list;
-       void            *t;
-       u32             frameSize;
        u16             tmpCStat;
        dma_addr_t      head_list_phys;
 
-       TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOF (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
+       TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOF (Head=%d Tail=%d)\n",
+                 priv->rxHead, priv->rxTail );
        head_list = priv->rxList + priv->rxHead;
        head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
 
        while (((tmpCStat = head_list->cStat) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
-               frameSize = head_list->frameSize;
+               dma_addr_t frameDma = head_list->buffer[0].address;
+               u32 frameSize = head_list->frameSize;
                ack++;
                if (tmpCStat & TLAN_CSTAT_EOC)
                        eoc = 1;
 
                if (bbuf) {
-                       skb = dev_alloc_skb(frameSize + 7);
-                       if (skb == NULL)
-                               printk(KERN_INFO "TLAN: Couldn't allocate memory for received data.\n");
-                       else {
-                               head_buffer = priv->rxBuffer + (priv->rxHead * TLAN_MAX_FRAME_SIZE);
-                               skb_reserve(skb, 2);
-                               t = (void *) skb_put(skb, frameSize);
-
-                               priv->stats.rx_bytes += head_list->frameSize;
-
-                               memcpy( t, head_buffer, frameSize );
-                               skb->protocol = eth_type_trans( skb, dev );
-                               netif_rx( skb );
-                       }
+                       skb = netdev_alloc_skb(dev, frameSize + 7);
+                       if ( !skb )
+                               goto drop_and_reuse;
+
+                       head_buffer = priv->rxBuffer
+                               + (priv->rxHead * TLAN_MAX_FRAME_SIZE);
+                       skb_reserve(skb, 2);
+                       pci_dma_sync_single_for_cpu(priv->pciDev,
+                                                   frameDma, frameSize,
+                                                   PCI_DMA_FROMDEVICE);
+                       skb_copy_from_linear_data(skb, head_buffer, frameSize);
+                       skb_put(skb, frameSize);
+                       dev->stats.rx_bytes += frameSize;
+
+                       skb->protocol = eth_type_trans( skb, dev );
+                       netif_rx( skb );
                } else {
                        struct sk_buff *new_skb;
 
-                       /*
-                        *      I changed the algorithm here. What we now do
-                        *      is allocate the new frame. If this fails we
-                        *      simply recycle the frame.
-                        */
+                       new_skb = netdev_alloc_skb(dev, TLAN_MAX_FRAME_SIZE + 7 );
+                       if ( !new_skb )
+                               goto drop_and_reuse;
 
-                       new_skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
+                       skb = TLan_GetSKB(head_list);
+                       pci_unmap_single(priv->pciDev, frameDma,
+                                        TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
+                       skb_put( skb, frameSize );
 
-                       if ( new_skb != NULL ) {
-                               skb = TLan_GetSKB(head_list);
-                               pci_unmap_single(priv->pciDev, head_list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
-                               skb_trim( skb, frameSize );
+                       dev->stats.rx_bytes += frameSize;
 
-                               priv->stats.rx_bytes += frameSize;
+                       skb->protocol = eth_type_trans( skb, dev );
+                       netif_rx( skb );
 
-                               skb->protocol = eth_type_trans( skb, dev );
-                               netif_rx( skb );
+                       skb_reserve( new_skb, NET_IP_ALIGN );
+                       head_list->buffer[0].address = pci_map_single(priv->pciDev,
+                                                                     new_skb->data,
+                                                                     TLAN_MAX_FRAME_SIZE,
+                                                                     PCI_DMA_FROMDEVICE);
 
-                               skb_reserve( new_skb, 2 );
-                               t = (void *) skb_put( new_skb, TLAN_MAX_FRAME_SIZE );
-                               head_list->buffer[0].address = pci_map_single(priv->pciDev, new_skb->data, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
-                               head_list->buffer[8].address = (u32) t;
-                               TLan_StoreSKB(head_list, new_skb);
-                       } else
-                               printk(KERN_WARNING "TLAN:  Couldn't allocate memory for received data.\n" );
-               }
+                       TLan_StoreSKB(head_list, new_skb);
 
+               }
+drop_and_reuse:
                head_list->forward = 0;
                head_list->cStat = 0;
                tail_list = priv->rxList + priv->rxTail;
@@ -1631,10 +1622,10 @@ u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
                printk(KERN_INFO "TLAN: Received interrupt for uncompleted RX frame.\n");
 
 
-
-
        if ( eoc ) {
-               TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d)\n", priv->rxHead, priv->rxTail );
+               TLAN_DBG( TLAN_DEBUG_RX,
+                         "RECEIVE:  Handling RX EOC (Head=%d Tail=%d)\n",
+                         priv->rxHead, priv->rxTail );
                head_list = priv->rxList + priv->rxHead;
                head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
                outl(head_list_phys, dev->base_addr + TLAN_CH_PARM );
@@ -1643,7 +1634,8 @@ u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
        }
 
        if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
-               TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
+               TLan_DioWrite8( dev->base_addr,
+                               TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
                if ( priv->timer.function == NULL )  {
                        priv->timer.function = &TLan_Timer;
                        priv->timer.data = (unsigned long) dev;
@@ -1682,7 +1674,7 @@ u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
         *
         **************************************************************/
 
-u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
+static u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
 {
        printk( "TLAN:  Test interrupt on %s.\n", dev->name );
        return 1;
@@ -1712,7 +1704,7 @@ u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
         *
         **************************************************************/
 
-u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
+static u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        TLanList                *head_list;
@@ -1721,7 +1713,9 @@ u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
 
        host_int = 0;
        if ( priv->tlanRev < 0x30 ) {
-               TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d) -- IRQ\n", priv->txHead, priv->txTail );
+               TLAN_DBG( TLAN_DEBUG_TX,
+                         "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d) -- IRQ\n",
+                         priv->txHead, priv->txTail );
                head_list = priv->txList + priv->txHead;
                head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead;
                if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
@@ -1760,7 +1754,7 @@ u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
         *
         **************************************************************/
 
-u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
+static u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u32             ack;
@@ -1789,15 +1783,18 @@ u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
                net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS );
                if ( net_sts ) {
                        TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts );
-                       TLAN_DBG( TLAN_DEBUG_GNRL, "%s:    Net_Sts = %x\n", dev->name, (unsigned) net_sts );
+                       TLAN_DBG( TLAN_DEBUG_GNRL, "%s:    Net_Sts = %x\n",
+                                 dev->name, (unsigned) net_sts );
                }
                if ( ( net_sts & TLAN_NET_STS_MIRQ ) &&  ( priv->phyNum == 0 ) ) {
                        TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts );
                        TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
-                       if ( ! ( tlphy_sts & TLAN_TS_POLOK ) && ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
+                       if ( ! ( tlphy_sts & TLAN_TS_POLOK ) &&
+                            ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
                                tlphy_ctl |= TLAN_TC_SWAPOL;
                                TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
-                       } else if ( ( tlphy_sts & TLAN_TS_POLOK ) && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
+                       } else if ( ( tlphy_sts & TLAN_TS_POLOK )
+                                   && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
                                tlphy_ctl &= ~TLAN_TC_SWAPOL;
                                TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
                        }
@@ -1835,14 +1832,16 @@ u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
         *
         **************************************************************/
 
-u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
+static u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        dma_addr_t      head_list_phys;
        u32             ack = 1;
 
        if (  priv->tlanRev < 0x30 ) {
-               TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d) -- IRQ\n", priv->rxHead, priv->rxTail );
+               TLAN_DBG( TLAN_DEBUG_RX,
+                         "RECEIVE:  Handling RX EOC (Head=%d Tail=%d) -- IRQ\n",
+                         priv->rxHead, priv->rxTail );
                head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead;
                outl( head_list_phys, dev->base_addr + TLAN_CH_PARM );
                ack |= TLAN_HC_GO | TLAN_HC_RT;
@@ -1895,7 +1894,7 @@ u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
         *
         **************************************************************/
 
-void TLan_Timer( unsigned long data )
+static void TLan_Timer( unsigned long data )
 {
        struct net_device       *dev = (struct net_device *) data;
        TLanPrivateInfo *priv = netdev_priv(dev);
@@ -1933,10 +1932,12 @@ void TLan_Timer( unsigned long data )
                        if ( priv->timer.function == NULL ) {
                                elapsed = jiffies - priv->timerSetAt;
                                if ( elapsed >= TLAN_TIMER_ACT_DELAY ) {
-                                       TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
+                                       TLan_DioWrite8( dev->base_addr,
+                                                       TLAN_LED_REG, TLAN_LED_LINK );
                                } else  {
                                        priv->timer.function = &TLan_Timer;
-                                       priv->timer.expires = priv->timerSetAt + TLAN_TIMER_ACT_DELAY;
+                                       priv->timer.expires = priv->timerSetAt
+                                               + TLAN_TIMER_ACT_DELAY;
                                        spin_unlock_irqrestore(&priv->lock, flags);
                                        add_timer( &priv->timer );
                                        break;
@@ -1976,7 +1977,7 @@ void TLan_Timer( unsigned long data )
         *
         **************************************************************/
 
-void TLan_ResetLists( struct net_device *dev )
+static void TLan_ResetLists( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        int             i;
@@ -1991,7 +1992,8 @@ void TLan_ResetLists( struct net_device *dev )
                list = priv->txList + i;
                list->cStat = TLAN_CSTAT_UNUSED;
                if ( bbuf ) {
-                       list->buffer[0].address = priv->txBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
+                       list->buffer[0].address = priv->txBufferDMA
+                               + ( i * TLAN_MAX_FRAME_SIZE );
                } else {
                        list->buffer[0].address = 0;
                }
@@ -2010,33 +2012,37 @@ void TLan_ResetLists( struct net_device *dev )
                list->frameSize = TLAN_MAX_FRAME_SIZE;
                list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
                if ( bbuf ) {
-                       list->buffer[0].address = priv->rxBufferDMA + ( i * TLAN_MAX_FRAME_SIZE );
+                       list->buffer[0].address = priv->rxBufferDMA
+                               + ( i * TLAN_MAX_FRAME_SIZE );
                } else {
-                       skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
-                       if ( skb == NULL ) {
-                               printk( "TLAN:  Couldn't allocate memory for received data.\n" );
-                               /* If this ever happened it would be a problem */
-                       } else {
-                               skb->dev = dev;
-                               skb_reserve( skb, 2 );
-                               t = (void *) skb_put( skb, TLAN_MAX_FRAME_SIZE );
+                       skb = netdev_alloc_skb(dev, TLAN_MAX_FRAME_SIZE + 7 );
+                       if ( !skb ) {
+                               pr_err("TLAN: out of memory for received data.\n" );
+                               break;
                        }
-                       list->buffer[0].address = pci_map_single(priv->pciDev, t, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
-                       list->buffer[8].address = (u32) t;
+
+                       skb_reserve( skb, NET_IP_ALIGN );
+                       list->buffer[0].address = pci_map_single(priv->pciDev, t,
+                                                                TLAN_MAX_FRAME_SIZE,
+                                                                PCI_DMA_FROMDEVICE);
                        TLan_StoreSKB(list, skb);
                }
                list->buffer[1].count = 0;
                list->buffer[1].address = 0;
-               if ( i < TLAN_NUM_RX_LISTS - 1 )
-                       list->forward = list_phys + sizeof(TLanList);
-               else
-                       list->forward = 0;
+               list->forward = list_phys + sizeof(TLanList);
+       }
+
+       /* in case ran out of memory early, clear bits */
+       while (i < TLAN_NUM_RX_LISTS) {
+               TLan_StoreSKB(priv->rxList + i, NULL);
+               ++i;
        }
+       list->forward = 0;
 
 } /* TLan_ResetLists */
 
 
-void TLan_FreeLists( struct net_device *dev )
+static void TLan_FreeLists( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        int             i;
@@ -2048,7 +2054,9 @@ void TLan_FreeLists( struct net_device *dev )
                        list = priv->txList + i;
                        skb = TLan_GetSKB(list);
                        if ( skb ) {
-                               pci_unmap_single(priv->pciDev, list->buffer[0].address, skb->len, PCI_DMA_TODEVICE);
+                               pci_unmap_single(priv->pciDev,
+                                                list->buffer[0].address, skb->len,
+                                                PCI_DMA_TODEVICE);
                                dev_kfree_skb_any( skb );
                                list->buffer[8].address = 0;
                                list->buffer[9].address = 0;
@@ -2059,7 +2067,10 @@ void TLan_FreeLists( struct net_device *dev )
                        list = priv->rxList + i;
                        skb = TLan_GetSKB(list);
                        if ( skb ) {
-                               pci_unmap_single(priv->pciDev, list->buffer[0].address, TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
+                               pci_unmap_single(priv->pciDev,
+                                                list->buffer[0].address,
+                                                TLAN_MAX_FRAME_SIZE,
+                                                PCI_DMA_FROMDEVICE);
                                dev_kfree_skb_any( skb );
                                list->buffer[8].address = 0;
                                list->buffer[9].address = 0;
@@ -2085,12 +2096,13 @@ void TLan_FreeLists( struct net_device *dev )
         *
         **************************************************************/
 
-void TLan_PrintDio( u16 io_base )
+static void TLan_PrintDio( u16 io_base )
 {
        u32 data0, data1;
        int     i;
 
-       printk( "TLAN:   Contents of internal registers for io base 0x%04hx.\n", io_base );
+       printk( "TLAN:   Contents of internal registers for io base 0x%04hx.\n",
+               io_base );
        printk( "TLAN:      Off.  +0         +4\n" );
        for ( i = 0; i < 0x4C; i+= 8 ) {
                data0 = TLan_DioRead32( io_base, i );
@@ -2120,17 +2132,18 @@ void TLan_PrintDio( u16 io_base )
         *
         **************************************************************/
 
-void TLan_PrintList( TLanList *list, char *type, int num)
+static void TLan_PrintList( TLanList *list, char *type, int num)
 {
        int i;
 
-       printk( "TLAN:   %s List %d at 0x%08x\n", type, num, (u32) list );
+       printk( "TLAN:   %s List %d at %p\n", type, num, list );
        printk( "TLAN:      Forward    = 0x%08x\n",  list->forward );
        printk( "TLAN:      CSTAT      = 0x%04hx\n", list->cStat );
        printk( "TLAN:      Frame Size = 0x%04hx\n", list->frameSize );
        /* for ( i = 0; i < 10; i++ ) { */
        for ( i = 0; i < 2; i++ ) {
-               printk( "TLAN:      Buffer[%d].count, addr = 0x%08x, 0x%08x\n", i, list->buffer[i].count, list->buffer[i].address );
+               printk( "TLAN:      Buffer[%d].count, addr = 0x%08x, 0x%08x\n",
+                       i, list->buffer[i].count, list->buffer[i].address );
        }
 
 } /* TLan_PrintList */
@@ -2156,9 +2169,8 @@ void TLan_PrintList( TLanList *list, char *type, int num)
         *
         **************************************************************/
 
-void TLan_ReadAndClearStats( struct net_device *dev, int record )
+static void TLan_ReadAndClearStats( struct net_device *dev, int record )
 {
-       TLanPrivateInfo *priv = netdev_priv(dev);
        u32             tx_good, tx_under;
        u32             rx_good, rx_over;
        u32             def_tx, crc, code;
@@ -2195,18 +2207,18 @@ void TLan_ReadAndClearStats( struct net_device *dev, int record )
        loss       = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
 
        if ( record ) {
-               priv->stats.rx_packets += rx_good;
-               priv->stats.rx_errors  += rx_over + crc + code;
-               priv->stats.tx_packets += tx_good;
-               priv->stats.tx_errors  += tx_under + loss;
-               priv->stats.collisions += multi_col + single_col + excess_col + late_col;
+               dev->stats.rx_packets += rx_good;
+               dev->stats.rx_errors  += rx_over + crc + code;
+               dev->stats.tx_packets += tx_good;
+               dev->stats.tx_errors  += tx_under + loss;
+               dev->stats.collisions += multi_col + single_col + excess_col + late_col;
 
-               priv->stats.rx_over_errors    += rx_over;
-               priv->stats.rx_crc_errors     += crc;
-               priv->stats.rx_frame_errors   += code;
+               dev->stats.rx_over_errors    += rx_over;
+               dev->stats.rx_crc_errors     += crc;
+               dev->stats.rx_frame_errors   += code;
 
-               priv->stats.tx_aborted_errors += tx_under;
-               priv->stats.tx_carrier_errors += loss;
+               dev->stats.tx_aborted_errors += tx_under;
+               dev->stats.tx_carrier_errors += loss;
        }
 
 } /* TLan_ReadAndClearStats */
@@ -2231,7 +2243,7 @@ void TLan_ReadAndClearStats( struct net_device *dev, int record )
         *
         **************************************************************/
 
-void
+static void
 TLan_ResetAdapter( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
@@ -2317,7 +2329,7 @@ TLan_ResetAdapter( struct net_device *dev )
 
 
 
-void
+static void
 TLan_FinishReset( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
@@ -2347,14 +2359,16 @@ TLan_FinishReset( struct net_device *dev )
        TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 );
        TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
 
-       if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || ( priv->aui ) ) {
+       if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) ||
+            ( priv->aui ) ) {
                status = MII_GS_LINK;
                printk( "TLAN:  %s: Link forced.\n", dev->name );
        } else {
                TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
                udelay( 1000 );
                TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
-               if ( (status & MII_GS_LINK) &&   /* We only support link info on Nat.Sem. PHY's */
+               if ( (status & MII_GS_LINK) &&
+                    /* We only support link info on Nat.Sem. PHY's */
                        (tlphy_id1 == NAT_SEM_ID1) &&
                        (tlphy_id2 == NAT_SEM_ID2) ) {
                        TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner );
@@ -2363,12 +2377,12 @@ TLan_FinishReset( struct net_device *dev )
                        printk( "TLAN: %s: Link active with ", dev->name );
                        if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
                                 printk( "forced 10%sMbps %s-Duplex\n",
-                                               tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
-                                               tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
+                                        tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
+                                        tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
                        } else {
                                printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplex\n",
-                                               tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
-                                               tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
+                                       tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
+                                       tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
                                printk("TLAN: Partner capability: ");
                                        for (i = 5; i <= 10; i++)
                                                if (partner & (1<<i))
@@ -2409,7 +2423,8 @@ TLan_FinishReset( struct net_device *dev )
                outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD );
                netif_carrier_on(dev);
        } else {
-               printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n", dev->name );
+               printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n",
+                       dev->name );
                TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
                return;
        }
@@ -2441,7 +2456,7 @@ TLan_FinishReset( struct net_device *dev )
         *
         **************************************************************/
 
-void TLan_SetMac( struct net_device *dev, int areg, char *mac )
+static void TLan_SetMac( struct net_device *dev, int areg, char *mac )
 {
        int i;
 
@@ -2449,10 +2464,12 @@ void TLan_SetMac( struct net_device *dev, int areg, char *mac )
 
        if ( mac != NULL ) {
                for ( i = 0; i < 6; i++ )
-                       TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, mac[i] );
+                       TLan_DioWrite8( dev->base_addr,
+                                       TLAN_AREG_0 + areg + i, mac[i] );
        } else {
                for ( i = 0; i < 6; i++ )
-                       TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, 0 );
+                       TLan_DioWrite8( dev->base_addr,
+                                       TLAN_AREG_0 + areg + i, 0 );
        }
 
 } /* TLan_SetMac */
@@ -2483,7 +2500,7 @@ void TLan_SetMac( struct net_device *dev, int areg, char *mac )
         *
         ********************************************************************/
 
-void TLan_PhyPrint( struct net_device *dev )
+static void TLan_PhyPrint( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u16 i, data0, data1, data2, data3, phy;
@@ -2532,7 +2549,7 @@ void TLan_PhyPrint( struct net_device *dev )
         *
         ********************************************************************/
 
-void TLan_PhyDetect( struct net_device *dev )
+static void TLan_PhyDetect( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u16             control;
@@ -2558,9 +2575,13 @@ void TLan_PhyDetect( struct net_device *dev )
                TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control );
                TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi );
                TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo );
-               if ( ( control != 0xFFFF ) || ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
-                       TLAN_DBG( TLAN_DEBUG_GNRL, "PHY found at %02x %04x %04x %04x\n", phy, control, hi, lo );
-                       if ( ( priv->phy[1] == TLAN_PHY_NONE ) && ( phy != TLAN_PHY_MAX_ADDR ) ) {
+               if ( ( control != 0xFFFF ) ||
+                    ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
+                       TLAN_DBG( TLAN_DEBUG_GNRL,
+                                 "PHY found at %02x %04x %04x %04x\n",
+                                 phy, control, hi, lo );
+                       if ( ( priv->phy[1] == TLAN_PHY_NONE ) &&
+                            ( phy != TLAN_PHY_MAX_ADDR ) ) {
                                priv->phy[1] = phy;
                        }
                }
@@ -2579,7 +2600,7 @@ void TLan_PhyDetect( struct net_device *dev )
 
 
 
-void TLan_PhyPowerDown( struct net_device *dev )
+static void TLan_PhyPowerDown( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u16             value;
@@ -2588,7 +2609,9 @@ void TLan_PhyPowerDown( struct net_device *dev )
        value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
        TLan_MiiSync( dev->base_addr );
        TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
-       if ( ( priv->phyNum == 0 ) && ( priv->phy[1] != TLAN_PHY_NONE ) && ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
+       if ( ( priv->phyNum == 0 ) &&
+            ( priv->phy[1] != TLAN_PHY_NONE ) &&
+            ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
                TLan_MiiSync( dev->base_addr );
                TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value );
        }
@@ -2604,7 +2627,7 @@ void TLan_PhyPowerDown( struct net_device *dev )
 
 
 
-void TLan_PhyPowerUp( struct net_device *dev )
+static void TLan_PhyPowerUp( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u16             value;
@@ -2625,7 +2648,7 @@ void TLan_PhyPowerUp( struct net_device *dev )
 
 
 
-void TLan_PhyReset( struct net_device *dev )
+static void TLan_PhyReset( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u16             phy;
@@ -2653,7 +2676,7 @@ void TLan_PhyReset( struct net_device *dev )
 
 
 
-void TLan_PhyStartLink( struct net_device *dev )
+static void TLan_PhyStartLink( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u16             ability;
@@ -2740,7 +2763,7 @@ void TLan_PhyStartLink( struct net_device *dev )
 
 
 
-void TLan_PhyFinishAutoNeg( struct net_device *dev )
+static void TLan_PhyFinishAutoNeg( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        u16             an_adv;
@@ -2761,10 +2784,10 @@ void TLan_PhyFinishAutoNeg( struct net_device *dev )
                 * more time.  Perhaps we should fail after a while.
                 */
                 if (!priv->neg_be_verbose++) {
-                        printk(KERN_INFO "TLAN:  Giving autonegotiation more time.\n");
-                        printk(KERN_INFO "TLAN:  Please check that your adapter has\n");
-                        printk(KERN_INFO "TLAN:  been properly connected to a HUB or Switch.\n");
-                        printk(KERN_INFO "TLAN:  Trying to establish link in the background...\n");
+                        pr_info("TLAN:  Giving autonegotiation more time.\n");
+                        pr_info("TLAN:  Please check that your adapter has\n");
+                        pr_info("TLAN:  been properly connected to a HUB or Switch.\n");
+                        pr_info("TLAN:  Trying to establish link in the background...\n");
                 }
                TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN );
                return;
@@ -2780,7 +2803,9 @@ void TLan_PhyFinishAutoNeg( struct net_device *dev )
                priv->tlanFullDuplex = TRUE;
        }
 
-       if ( ( ! ( mode & 0x0180 ) ) && ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && ( priv->phyNum != 0 ) ) {
+       if ( ( ! ( mode & 0x0180 ) ) &&
+            ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) &&
+            ( priv->phyNum != 0 ) ) {
                priv->phyNum = 0;
                data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
                TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
@@ -2789,12 +2814,14 @@ void TLan_PhyFinishAutoNeg( struct net_device *dev )
        }
 
        if ( priv->phyNum == 0 ) {
-               if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || ( an_adv & an_lpa & 0x0040 ) ) {
-                       TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB | MII_GC_DUPLEX );
-                       printk( "TLAN:  Starting internal PHY with FULL-DUPLEX\n" );
+               if ( ( priv->duplex == TLAN_DUPLEX_FULL ) ||
+                    ( an_adv & an_lpa & 0x0040 ) ) {
+                       TLan_MiiWriteReg( dev, phy, MII_GEN_CTL,
+                                         MII_GC_AUTOENB | MII_GC_DUPLEX );
+                       pr_info("TLAN:  Starting internal PHY with FULL-DUPLEX\n" );
                } else {
                        TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB );
-                       printk( "TLAN:  Starting internal PHY with HALF-DUPLEX\n" );
+                       pr_info( "TLAN:  Starting internal PHY with HALF-DUPLEX\n" );
                }
        }
 
@@ -2896,7 +2923,7 @@ void TLan_PhyMonitor( struct net_device *dev )
         *
         **************************************************************/
 
-int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
+static int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
 {
        u8      nack;
        u16     sio, tmp;
@@ -2986,7 +3013,7 @@ int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
         *
         **************************************************************/
 
-void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
+static void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
 {
        u16 sio;
        u32 i;
@@ -3028,7 +3055,7 @@ void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
         *
         **************************************************************/
 
-void TLan_MiiSync( u16 base_port )
+static void TLan_MiiSync( u16 base_port )
 {
        int i;
        u16 sio;
@@ -3067,7 +3094,7 @@ void TLan_MiiSync( u16 base_port )
         *
         **************************************************************/
 
-void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
+static void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
 {
        u16     sio;
        int     minten;
@@ -3137,7 +3164,7 @@ void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
         *
         **************************************************************/
 
-void TLan_EeSendStart( u16 io_base )
+static void TLan_EeSendStart( u16 io_base )
 {
        u16     sio;
 
@@ -3177,7 +3204,7 @@ void TLan_EeSendStart( u16 io_base )
         *
         **************************************************************/
 
-int TLan_EeSendByte( u16 io_base, u8 data, int stop )
+static int TLan_EeSendByte( u16 io_base, u8 data, int stop )
 {
        int     err;
        u8      place;
@@ -3202,7 +3229,8 @@ int TLan_EeSendByte( u16 io_base, u8 data, int stop )
        TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
 
        if ( ( ! err ) && stop ) {
-               TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
+               /* STOP, raise data while clock is high */
+               TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
                TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
                TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
        }
@@ -3238,7 +3266,7 @@ int TLan_EeSendByte( u16 io_base, u8 data, int stop )
         *
         **************************************************************/
 
-void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
+static void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
 {
        u8  place;
        u16 sio;
@@ -3265,7 +3293,8 @@ void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
                TLan_SetBit( TLAN_NET_SIO_EDATA, sio );         /* No ack = 1 (?) */
                TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
                TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
-               TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );       /* STOP, raise data while clock is high */
+               /* STOP, raise data while clock is high */
+               TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
                TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
                TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
        }
@@ -3296,7 +3325,7 @@ void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
         *
         **************************************************************/
 
-int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
+static int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
 {
        int err;
        TLanPrivateInfo *priv = netdev_priv(dev);