rndis_wlan: cleanup: rename and remove local pointers
[linux-2.6.git] / drivers / net / tlan.c
index ce11662..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,
  *                                             new PCI BIOS interface.
  *     Alan Cox        <alan@redhat.com>:      Fixed the out of memory
  *                                             handling.
- *      
+ *
  *     Torben Mathiasen <torben.mathiasen@compaq.com> New Maintainer!
  *
  *     v1.1 Dec 20, 1999    - Removed linux version checking
- *                            Patch from Tigran Aivazian. 
+ *                            Patch from Tigran Aivazian.
  *                          - v1.1 includes Alan's SMP updates.
  *                          - We still have problems on SMP though,
- *                            but I'm looking into that. 
- *                     
+ *                            but I'm looking into that.
+ *
  *     v1.2 Jan 02, 2000    - Hopefully fixed the SMP deadlock.
  *                          - Removed dependency of HZ being 100.
- *                          - We now allow higher priority timers to 
+ *                          - We now allow higher priority timers to
  *                            overwrite timers like TLAN_TIMER_ACTIVITY
  *                            Patch from John Cagle <john.cagle@compaq.com>.
  *                          - Fixed a few compiler warnings.
  *
  *     v1.3 Feb 04, 2000    - Fixed the remaining HZ issues.
- *                          - Removed call to pci_present(). 
+ *                          - Removed call to pci_present().
  *                          - Removed SA_INTERRUPT flag from irq handler.
- *                          - Added __init and __initdata to reduce resisdent 
+ *                          - Added __init and __initdata to reduce resisdent
  *                            code size.
  *                          - Driver now uses module_init/module_exit.
  *                          - Rewrote init_module and tlan_probe to
  *                            share a lot more code. We now use tlan_probe
  *                            with builtin and module driver.
- *                          - Driver ported to new net API. 
- *                          - tlan.txt has been reworked to reflect current 
+ *                          - Driver ported to new net API.
+ *                          - tlan.txt has been reworked to reflect current
  *                            driver (almost)
  *                          - Other minor stuff
  *
  *                                  Auto-Neg fallback.
  *
  *     v1.6 April 04, 2000  - Fixed driver support for kernel-parameters. Haven't
- *                            tested it though, as the kernel support is currently 
+ *                            tested it though, as the kernel support is currently
  *                            broken (2.3.99p4p3).
  *                          - Updated tlan.txt accordingly.
  *                          - Adjusted minimum/maximum frame length.
- *                          - There is now a TLAN website up at 
+ *                          - There is now a TLAN website up at
  *                            http://tlan.kernel.dk
  *
  *     v1.7 April 07, 2000  - Started to implement custom ioctls. Driver now
  *                            link partner abilities. When forced link is used,
  *                            the driver will report status of the established
  *                            link.
- *                            Please read tlan.txt for additional information. 
- *                          - Removed call to check_region(), and used 
+ *                            Please read tlan.txt for additional information.
+ *                          - Removed call to check_region(), and used
  *                            return value of request_region() instead.
- *     
+ *
  *     v1.8a May 28, 2000   - Minor updates.
  *
  *     v1.9 July 25, 2000   - Fixed a few remaining Full-Duplex issues.
  *                          - Added routine to monitor PHY status.
  *                          - Added activity led support for Proliant devices.
  *
- *     v1.10 Aug 30, 2000   - Added support for EISA based tlan controllers 
- *                            like the Compaq NetFlex3/E. 
+ *     v1.10 Aug 30, 2000   - Added support for EISA based tlan controllers
+ *                            like the Compaq NetFlex3/E.
  *                          - Rewrote tlan_probe to better handle multiple
  *                            bus probes. Probing and device setup is now
  *                            done through TLan_Probe and TLan_init_one. Actual
- *                            hardware probe is done with kernel API and 
+ *                            hardware probe is done with kernel API and
  *                            TLan_EisaProbe.
  *                          - Adjusted debug information for probing.
- *                          - Fixed bug that would cause general debug information 
- *                            to be printed after driver removal. 
+ *                          - Fixed bug that would cause general debug information
+ *                            to be printed after driver removal.
  *                          - Added transmit timeout handling.
- *                          - Fixed OOM return values in tlan_probe. 
- *                          - Fixed possible mem leak in tlan_exit 
+ *                          - Fixed OOM return values in tlan_probe.
+ *                          - Fixed possible mem leak in tlan_exit
  *                            (now tlan_remove_one).
  *                          - Fixed timer bug in TLan_phyMonitor.
  *                          - This driver version is alpha quality, please
  *                            send me any bug issues you may encounter.
  *
- *     v1.11 Aug 31, 2000   - Do not try to register irq 0 if no irq line was 
+ *     v1.11 Aug 31, 2000   - Do not try to register irq 0 if no irq line was
  *                            set for EISA cards.
  *                          - Added support for NetFlex3/E with nibble-rate
  *                            10Base-T PHY. This is untestet as I haven't got
  *                          - Added the bbuf option as a kernel parameter.
  *                          - Fixed ioaddr probe bug.
  *                          - Fixed stupid deadlock with MII interrupts.
- *                          - Added support for speed/duplex selection with 
+ *                          - Added support for speed/duplex selection with
  *                            multiple nics.
  *                          - Added partly fix for TX Channel lockup with
  *                            TLAN v1.0 silicon. This needs to be investigated
 #include <linux/ioport.h>
 #include <linux/eisa.h>
 #include <linux/pci.h>
+#include <linux/dma-mapping.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/delay.h>
@@ -193,6 +192,12 @@ static  int aui[MAX_TLAN_BOARDS];
 static  int duplex[MAX_TLAN_BOARDS];
 static  int speed[MAX_TLAN_BOARDS];
 static  int boards_found;
+module_param_array(aui, int, NULL, 0);
+module_param_array(duplex, int, NULL, 0);
+module_param_array(speed, int, NULL, 0);
+MODULE_PARM_DESC(aui, "ThunderLAN use AUI port(s) (0-1)");
+MODULE_PARM_DESC(duplex, "ThunderLAN duplex setting(s) (0-default, 1-half, 2-full)");
+MODULE_PARM_DESC(speed, "ThunderLAN port speen setting(s) (0,10,100)");
 
 MODULE_AUTHOR("Maintainer: Samuel Chessman <chessman@tux.org>");
 MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters");
@@ -204,17 +209,20 @@ MODULE_LICENSE("GPL");
 
 /* Turn on debugging. See Documentation/networking/tlan.txt for details */
 static  int            debug;
+module_param(debug, int, 0);
+MODULE_PARM_DESC(debug, "ThunderLAN debug mask");
 
 static int             bbuf;
-static u8              *TLanPadBuffer;
-static  dma_addr_t     TLanPadBufferDMA;
-static char            TLanSignature[] = "TLAN";
+module_param(bbuf, int, 0);
+MODULE_PARM_DESC(bbuf, "ThunderLAN use big buffer (0-1)");
+
+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;
 
 static const char *media[] = {
-       "10BaseT-HD ", "10BaseT-FD ","100baseTx-HD ", 
+       "10BaseT-HD ", "10BaseT-FD ","100baseTx-HD ",
        "100baseTx-FD", "100baseT4", NULL
 };
 
@@ -226,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 },
@@ -236,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 */
 };
 
@@ -270,23 +281,24 @@ static struct pci_device_id tlan_pci_tbl[] = {
                PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
        { 0,}
 };
-MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);                
+MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);
 
 static void    TLan_EisaProbe( void );
 static void    TLan_Eisa_Cleanup( void );
 static int      TLan_Init( struct net_device * );
 static int     TLan_Open( struct net_device *dev );
 static int     TLan_StartTx( struct sk_buff *, struct net_device *);
-static irqreturn_t TLan_HandleInterrupt( int, void *, struct pt_regs *);
+static irqreturn_t TLan_HandleInterrupt( int, void *);
 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 );
@@ -335,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,
@@ -372,11 +382,11 @@ TLan_SetTimer( struct net_device *dev, u32 ticks, u32 type )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        unsigned long flags = 0;
-       
+
        if (!in_irq())
                spin_lock_irqsave(&priv->lock, flags);
        if ( priv->timer.function != NULL &&
-               priv->timerType != TLAN_TIMER_ACTIVITY ) { 
+               priv->timerType != TLAN_TIMER_ACTIVITY ) {
                if (!in_irq())
                        spin_unlock_irqrestore(&priv->lock, flags);
                return;
@@ -389,7 +399,7 @@ TLan_SetTimer( struct net_device *dev, u32 ticks, u32 type )
        priv->timerSetAt = jiffies;
        priv->timerType = type;
        mod_timer(&priv->timer, jiffies + ticks);
-       
+
 } /* TLan_SetTimer */
 
 
@@ -427,66 +437,67 @@ static void __devexit tlan_remove_one( struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata( pdev );
        TLanPrivateInfo *priv = netdev_priv(dev);
-       
+
        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
        pci_release_regions(pdev);
 #endif
-       
+
        free_netdev( dev );
-               
+
        pci_set_drvdata( pdev, NULL );
-} 
+}
 
 static struct pci_driver tlan_driver = {
        .name           = "tlan",
        .id_table       = tlan_pci_tbl,
        .probe          = tlan_init_one,
-       .remove         = __devexit_p(tlan_remove_one), 
+       .remove         = __devexit_p(tlan_remove_one),
 };
 
 static int __init tlan_probe(void)
 {
-       static int      pad_allocated;
-       
-       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;
-       }
+       int rc = -ENODEV;
 
-       memset(TLanPadBuffer, 0, TLAN_MIN_FRAME_SIZE);
-       pad_allocated = 1;
+       printk(KERN_INFO "%s", tlan_banner);
 
        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();
-               
-       printk(KERN_INFO "TLAN: %d device%s installed, PCI: %d  EISA: %d\n", 
+
+       printk(KERN_INFO "TLAN: %d device%s installed, PCI: %d  EISA: %d\n",
                 TLanDevicesInstalled, TLanDevicesInstalled == 1 ? "" : "s",
                 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;
 }
-       
+
 
 static int __devinit tlan_init_one( struct pci_dev *pdev,
                                    const struct pci_device_id *ent)
@@ -501,11 +512,11 @@ static int __devinit tlan_init_one( struct pci_dev *pdev,
         *
         *      Returns:
         *              0 on success, error code on error
-        *      Parms: 
+        *      Parms:
         *              none
         *
         *      The name is lower case to fit in with all the rest of
-        *      the netcard_probe names.  This function looks for 
+        *      the netcard_probe names.  This function looks for
         *      another TLan based adapter, setting it up with the
         *      allocated device struct if one is found.
         *      tlan_probe has been ported to the new net API and
@@ -514,16 +525,17 @@ 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 )
+static int __devinit TLan_probe1(struct pci_dev *pdev,
+                                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;
 
+#ifdef CONFIG_PCI
        if (pdev) {
                rc = pci_enable_device(pdev);
                if (rc)
@@ -535,6 +547,7 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
                        goto err_out;
                }
        }
+#endif  /*  CONFIG_PCI  */
 
        dev = alloc_etherdev(sizeof(TLanPrivateInfo));
        if (dev == NULL) {
@@ -542,27 +555,25 @@ 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);
 
        priv->pciDev = pdev;
-       
+       priv->dev = dev;
+
        /* Is this a PCI device? */
        if (pdev) {
                u32                pci_io_base = 0;
 
                priv->adapter = &board_info[ent->driver_data];
 
-               rc = pci_set_dma_mask(pdev, 0xFFFFFFFF);
+               rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                if (rc) {
                        printk(KERN_ERR "TLAN: No suitable PCI mapping available.\n");
                        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);
@@ -576,10 +587,10 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
                        rc = -EIO;
                        goto err_out_free_dev;
                }
-               
+
                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);
 
@@ -602,9 +613,11 @@ 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;
                } else if (priv->speed == 0x2) {
@@ -617,13 +630,13 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
                priv->duplex = duplex[boards_found];
                priv->debug = debug;
        }
-       
+
        /* This will be used when we get an adapter error from
         * within our irq handler */
-       INIT_WORK(&priv->tlan_tqueue, (void *)(void*)TLan_tx_timeout, dev);
+       INIT_WORK(&priv->tlan_tqueue, TLan_tx_timeout_work);
 
        spin_lock_init(&priv->lock);
-       
+
        rc = TLan_Init(dev);
        if (rc) {
                printk(KERN_ERR "TLAN: Could not set up device.\n");
@@ -636,10 +649,10 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
                goto err_out_uninit;
        }
 
-       
+
        TLanDevicesInstalled++;
        boards_found++;
-       
+
        /* pdev is NULL if this is an EISA device */
        if (pdev)
                tlan_have_pci++;
@@ -648,7 +661,7 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
                TLan_Eisa_Devices = dev;
                tlan_have_eisa++;
        }
-       
+
        printk(KERN_INFO "TLAN: %s irq=%2d, io=%04x, %s, Rev. %d\n",
                        dev->name,
                        (int) dev->irq,
@@ -678,12 +691,13 @@ static void TLan_Eisa_Cleanup(void)
 {
        struct net_device *dev;
        TLanPrivateInfo *priv;
-       
+
        while( tlan_have_eisa ) {
                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 );
@@ -692,8 +706,8 @@ static void TLan_Eisa_Cleanup(void)
                tlan_have_eisa--;
        }
 }
-       
-               
+
+
 static void __exit tlan_exit(void)
 {
        pci_unregister_driver(&tlan_driver);
@@ -701,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);
-
 }
 
 
@@ -720,52 +732,54 @@ module_exit(tlan_exit);
         *      Parms:   None
         *
         *
-        *      This functions probes for EISA devices and calls 
-        *      TLan_probe1 when one is found. 
+        *      This functions probes for EISA devices and calls
+        *      TLan_probe1 when one is found.
         *
         *************************************************************/
 
-static void  __init TLan_EisaProbe (void) 
+static void  __init TLan_EisaProbe (void)
 {
        long    ioaddr;
        int     rc = -ENODEV;
        int     irq;
        u16     device_id;
 
-       if (!EISA_bus) {        
+       if (!EISA_bus) {
                TLAN_DBG(TLAN_DEBUG_PROBE, "No EISA bus present\n");
                return;
        }
-       
+
        /* 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 : ",
                                        (int) ioaddr);
-               if (request_region(ioaddr, 0x10, TLanSignature) == NULL) 
+               if (request_region(ioaddr, 0x10, TLanSignature) == NULL)
                        goto out;
 
-               if (inw(ioaddr + EISA_ID) != 0x110E) {          
+               if (inw(ioaddr + EISA_ID) != 0x110E) {
                        release_region(ioaddr, 0x10);
                        goto out;
                }
-               
+
                device_id = inw(ioaddr + EISA_ID2);
-               if (device_id !=  0x20F1 && device_id != 0x40F1) {              
+               if (device_id !=  0x20F1 && device_id != 0x40F1) {
                        release_region (ioaddr, 0x10);
                        goto out;
                }
-               
+
                if (inb(ioaddr + EISA_CR) != 0x1) {     /* Check if adapter is enabled */
                        release_region (ioaddr, 0x10);
                        goto out2;
                }
-               
-               if (debug == 0x10)              
+
+               if (debug == 0x10)
                        printk("Found one\n");
 
 
@@ -785,14 +799,14 @@ static void  __init TLan_EisaProbe (void)
                                break;
                        default:
                                goto out;
-               }               
-               
-               
+               }
+
+
                /* Setup the newly found eisa adapter */
                rc = TLan_probe1( NULL, ioaddr, irq,
                                        12, NULL);
                continue;
-               
+
                out:
                        if (debug == 0x10)
                                printk("None found\n");
@@ -801,7 +815,7 @@ static void  __init TLan_EisaProbe (void)
                out2:   if (debug == 0x10)
                                printk("Card found but it is not enabled, skipping\n");
                        continue;
-               
+
        }
 
 } /* TLan_EisaProbe */
@@ -810,12 +824,12 @@ static void  __init TLan_EisaProbe (void)
 static void TLan_Poll(struct net_device *dev)
 {
        disable_irq(dev->irq);
-       TLan_HandleInterrupt(dev->irq, dev, NULL);
+       TLan_HandleInterrupt(dev->irq, dev);
        enable_irq(dev->irq);
 }
 #endif
 
-       
+
 
 
        /***************************************************************
@@ -832,7 +846,7 @@ static void TLan_Poll(struct net_device *dev)
         *      addresses, allocates memory for the lists and bounce
         *      buffers, retrieves the MAC address from the eeprom
         *      and assignes the device's methods.
-        *      
+        *
         **************************************************************/
 
 static int TLan_Init( struct net_device *dev )
@@ -843,7 +857,7 @@ static int TLan_Init( struct net_device *dev )
        TLanPrivateInfo *priv;
 
        priv = netdev_priv(dev);
-       
+
        if ( bbuf ) {
                dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
                   * ( sizeof(TLanList) + TLAN_MAX_FRAME_SIZE );
@@ -851,25 +865,29 @@ 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 ) {
                printk(KERN_ERR "TLAN:  Could not allocate lists and buffers for %s.\n",
                        dev->name );
                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;
@@ -927,18 +945,20 @@ static int TLan_Open( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
        int             err;
-       
+
        priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION );
-       err = request_irq( dev->irq, TLan_HandleInterrupt, SA_SHIRQ, 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;
        }
-       
+
        init_timer(&priv->timer);
        netif_start_queue(dev);
-       
+
        /* NOTE: It might not be necessary to read the stats before a
                         reset if you don't care what the values are.
        */
@@ -946,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;
 
@@ -956,12 +977,12 @@ static int TLan_Open( struct net_device *dev )
 
        /**************************************************************
         *      TLan_ioctl
-        *      
+        *
         *      Returns:
         *              0 on success, error code otherwise
         *      Params:
         *              dev     structure of device to receive ioctl.
-        *              
+        *
         *              rq      ifreq structure to hold userspace data.
         *
         *              cmd     ioctl command.
@@ -974,7 +995,7 @@ static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
        TLanPrivateInfo *priv = netdev_priv(dev);
        struct mii_ioctl_data *data = if_mii(rq);
        u32 phy   = priv->phy[priv->phyNum];
-       
+
        if (!priv->phyOnline)
                return -EAGAIN;
 
@@ -984,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;
@@ -1005,31 +1028,50 @@ static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         *      Returns: nothing
         *
         *      Params:
-        *              dev     structure of device which timed out 
+        *              dev     structure of device which timed out
         *                      during transmit.
         *
         **************************************************************/
 
 static void TLan_tx_timeout(struct net_device *dev)
 {
-       
+
        TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Transmit timed out.\n", dev->name);
-       
+
        /* Ok so we timed out, lets see what we can do about it...*/
        TLan_FreeLists( dev );
-       TLan_ResetLists( dev );         
+       TLan_ResetLists( dev );
        TLan_ReadAndClearStats( dev, TLAN_IGNORE );
        TLan_ResetAdapter( dev );
        dev->trans_start = jiffies;
-       netif_wake_queue( dev );        
+       netif_wake_queue( dev );
+
+}
+
+
+       /***************************************************************
+        *      TLan_tx_timeout_work
+        *
+        *      Returns: nothing
+        *
+        *      Params:
+        *              work    work item of device which timed out
+        *
+        **************************************************************/
+
+static void TLan_tx_timeout_work(struct work_struct *work)
+{
+       TLanPrivateInfo *priv =
+               container_of(work, TLanPrivateInfo, tlan_tqueue);
 
+       TLan_tx_timeout(priv->dev);
 }
-       
+
 
 
        /***************************************************************
         *      TLan_StartTx
-        *  
+        *
         *      Returns:
         *              0 on success, non-zero on failure.
         *      Parms:
@@ -1054,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;
@@ -1077,39 +1124,36 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
 
        if ( bbuf ) {
                tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE );
-               memcpy( tail_buffer, skb->data, skb->len );
+               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);
@@ -1118,7 +1162,7 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
 
        if ( bbuf )
                dev_kfree_skb_any(skb);
-               
+
        dev->trans_start = jiffies;
        return 0;
 
@@ -1129,15 +1173,14 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
 
        /***************************************************************
         *      TLan_HandleInterrupt
-        *  
-        *      Returns:        
+        *
+        *      Returns:
         *              Nothing
         *      Parms:
         *              irq     The line on which the interrupt
         *                      occurred.
         *              dev_id  A pointer to the device assigned to
         *                      this irq line.
-        *              regs    ???
         *
         *      This function handles an interrupt generated by its
         *      assigned TLAN adapter.  The function deactivates
@@ -1148,35 +1191,33 @@ static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
         *
         **************************************************************/
 
-static irqreturn_t TLan_HandleInterrupt(int irq, void *dev_id, struct pt_regs *regs)
+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 */
 
 
@@ -1184,7 +1225,7 @@ static irqreturn_t TLan_HandleInterrupt(int irq, void *dev_id, struct pt_regs *r
 
        /***************************************************************
         *      TLan_Close
-        *  
+        *
         *      Returns:
         *              An error code.
         *      Parms:
@@ -1210,7 +1251,7 @@ static int TLan_Close(struct net_device *dev)
                del_timer_sync( &priv->timer );
                priv->timer.function = NULL;
        }
-       
+
        free_irq( dev->irq, dev );
        TLan_FreeLists( dev );
        TLAN_DBG( TLAN_DEBUG_GNRL, "Device %s closed.\n", dev->name );
@@ -1224,7 +1265,7 @@ static int TLan_Close(struct net_device *dev)
 
        /***************************************************************
         *      TLan_GetStats
-        *  
+        *
         *      Returns:
         *              A pointer to the device's statistics structure.
         *      Parms:
@@ -1245,11 +1286,13 @@ 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 );           
+               TLan_PhyPrint( dev );
        }
        if ( debug & TLAN_DEBUG_LIST ) {
                for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ )
@@ -1257,8 +1300,8 @@ static struct net_device_stats *TLan_GetStats( struct net_device *dev )
                for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ )
                        TLan_PrintList( priv->txList + i, "TX", i );
        }
-       
-       return ( &( (TLanPrivateInfo *) netdev_priv(dev) )->stats );
+
+       return &dev->stats;
 
 } /* TLan_GetStats */
 
@@ -1267,7 +1310,7 @@ static struct net_device_stats *TLan_GetStats( struct net_device *dev )
 
        /***************************************************************
         *      TLan_SetMulticastList
-        *  
+        *
         *      Returns:
         *              Nothing
         *      Parms:
@@ -1286,7 +1329,7 @@ static struct net_device_stats *TLan_GetStats( struct net_device *dev )
         **************************************************************/
 
 static void TLan_SetMulticastList( struct net_device *dev )
-{      
+{
        struct dev_mc_list      *dmi = dev->mc_list;
        u32                     hash1 = 0;
        u32                     hash2 = 0;
@@ -1296,29 +1339,32 @@ 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++ ) 
+                       for ( i = 0; i < 3; i++ )
                                TLan_SetMac( dev, i + 1, NULL );
                        TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, 0xFFFFFFFF );
                        TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, 0xFFFFFFFF );
                } 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 ) 
+                                       if ( offset < 32 )
                                                hash1 |= ( 1 << offset );
                                        else
                                                hash2 |= ( 1 << ( offset - 32 ) );
                                }
                                dmi = dmi->next;
                        }
-                       for ( ; i < 3; i++ ) 
+                       for ( ; i < 3; i++ )
                                TLan_SetMac( dev, i + 1, NULL );
                        TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, hash1 );
                        TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, hash2 );
@@ -1336,37 +1382,12 @@ static void TLan_SetMulticastList( struct net_device *dev )
 
        Please see Chap. 4, "Interrupt Handling" of the "ThunderLAN
        Programmer's Guide" for more informations on handling interrupts
-       generated by TLAN based adapters.  
+       generated by TLAN based adapters.
 
 ******************************************************************************
 *****************************************************************************/
 
 
-       /***************************************************************
-        *      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 */
-
-
 
 
        /***************************************************************
@@ -1391,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;
@@ -1399,36 +1420,40 @@ u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
        dma_addr_t      head_list_phys;
        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;
                }
-       
+
                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);         
-               CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS ); 
+               netif_start_queue(dev);
+               CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS );
                head_list = priv->txList + priv->txHead;
        }
 
        if (!ack)
                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 ) {
@@ -1438,9 +1463,10 @@ u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
                        priv->txInProgress = 0;
                }
        }
-       
+
        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;
@@ -1477,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 );
 
@@ -1513,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;
@@ -1522,68 +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->dev = dev;
-                               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 = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
-                       
-                       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 );
-
-                               priv->stats.rx_bytes += frameSize;
-
-                               skb->protocol = eth_type_trans( skb, dev );
-                               netif_rx( skb );
-       
-                               new_skb->dev = dev;
-                               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" );
-               }
 
+                       new_skb = netdev_alloc_skb(dev, TLAN_MAX_FRAME_SIZE + 7 );
+                       if ( !new_skb )
+                               goto drop_and_reuse;
+
+                       skb = TLan_GetSKB(head_list);
+                       pci_unmap_single(priv->pciDev, frameDma,
+                                        TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
+                       skb_put( skb, frameSize );
+
+                       dev->stats.rx_bytes += frameSize;
+
+                       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);
+
+                       TLan_StoreSKB(head_list, new_skb);
+
+               }
+drop_and_reuse:
                head_list->forward = 0;
                head_list->cStat = 0;
                tail_list = priv->rxList + priv->rxTail;
@@ -1597,12 +1620,12 @@ u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
 
        if (!ack)
                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 );
+       if ( eoc ) {
+               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 );
@@ -1611,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;
@@ -1625,7 +1649,7 @@ u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
        }
 
        dev->last_rx = jiffies;
-       
+
        return ack;
 
 } /* TLan_HandleRxEOF */
@@ -1650,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;
@@ -1680,16 +1704,18 @@ 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;
        dma_addr_t              head_list_phys;
        u32                     ack = 1;
-       
+
        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 ) {
@@ -1728,8 +1754,8 @@ 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;
        u32             error;
@@ -1737,7 +1763,7 @@ u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
        u32             phy;
        u16             tlphy_ctl;
        u16             tlphy_sts;
-       
+
        ack = 1;
        if ( host_int & TLAN_HI_IV_MASK ) {
                netif_stop_queue( dev );
@@ -1757,21 +1783,24 @@ 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);
                        }
 
                        if (debug) {
-                               TLan_PhyPrint( dev );           
+                               TLan_PhyPrint( dev );
                        }
                }
        }
@@ -1803,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;
@@ -1863,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);
@@ -1873,7 +1904,7 @@ void TLan_Timer( unsigned long data )
        priv->timer.function = NULL;
 
        switch ( priv->timerType ) {
-#ifdef MONITOR         
+#ifdef MONITOR
                case TLAN_TIMER_LINK_BEAT:
                        TLan_PhyMonitor( dev );
                        break;
@@ -1901,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;
@@ -1932,7 +1965,7 @@ void TLan_Timer( unsigned long data )
 
        /***************************************************************
         *      TLan_ResetLists
-        *  
+        *
         *      Returns:
         *              Nothing
         *      Parms:
@@ -1944,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;
@@ -1959,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;
                }
@@ -1978,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;
@@ -2016,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;
@@ -2027,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;
@@ -2041,7 +2084,7 @@ void TLan_FreeLists( struct net_device *dev )
 
        /***************************************************************
         *      TLan_PrintDio
-        *  
+        *
         *      Returns:
         *              Nothing
         *      Parms:
@@ -2053,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 );
@@ -2073,7 +2117,7 @@ void TLan_PrintDio( u16 io_base )
 
        /***************************************************************
         *      TLan_PrintList
-        *  
+        *
         *      Returns:
         *              Nothing
         *      Parms:
@@ -2088,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 */
@@ -2114,7 +2159,7 @@ void TLan_PrintList( TLanList *list, char *type, int num)
         *      Parms:
         *              dev     Pointer to device structure of adapter
         *                      to which to read stats.
-        *              record  Flag indicating whether to add 
+        *              record  Flag indicating whether to add
         *
         *      This functions reads all the internal status registers
         *      of the TLAN chip, which clears them as a side effect.
@@ -2124,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;
@@ -2144,13 +2188,13 @@ void TLan_ReadAndClearStats( struct net_device *dev, int record )
        rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
        rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
        rx_over  = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
-               
+
        outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR );
        def_tx  = inb( dev->base_addr + TLAN_DIO_DATA );
        def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
        crc     = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
        code    = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
-       
+
        outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
        multi_col   = inb( dev->base_addr + TLAN_DIO_DATA );
        multi_col  += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
@@ -2163,20 +2207,20 @@ 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 */
 
 
@@ -2199,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);
@@ -2217,7 +2261,7 @@ TLan_ResetAdapter( struct net_device *dev )
        data = inl(dev->base_addr + TLAN_HOST_CMD);
        data |= TLAN_HC_AD_RST;
        outl(data, dev->base_addr + TLAN_HOST_CMD);
-       
+
        udelay(1000);
 
 /*  2. Turn off interrupts. ( Probably isn't necessary ) */
@@ -2256,7 +2300,7 @@ TLan_ResetAdapter( struct net_device *dev )
        }
        TLan_PhyDetect( dev );
        data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
-       
+
        if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) {
                data |= TLAN_NET_CFG_BIT;
                if ( priv->aui == 1 ) {
@@ -2285,7 +2329,7 @@ TLan_ResetAdapter( struct net_device *dev )
 
 
 
-void
+static void
 TLan_FinishReset( struct net_device *dev )
 {
        TLanPrivateInfo *priv = netdev_priv(dev);
@@ -2306,37 +2350,39 @@ TLan_FinishReset( struct net_device *dev )
                data |= TLAN_NET_CMD_DUPLEX;
        }
        TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
-       data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5; 
+       data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
        if ( priv->phyNum == 0 ) {
-               data |= TLAN_NET_MASK_MASK7; 
+               data |= TLAN_NET_MASK_MASK7;
        }
        TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data );
        TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 );
        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 );
                        TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par );
-                       
+
                        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");
+                                printk( "forced 10%sMbps %s-Duplex\n",
+                                        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))
@@ -2345,12 +2391,12 @@ TLan_FinishReset( struct net_device *dev )
                        }
 
                        TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
-#ifdef MONITOR                 
+#ifdef MONITOR
                        /* We have link beat..for now anyway */
                        priv->link = 1;
                        /*Enabling link beat monitoring */
                        TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT );
-#endif 
+#endif
                } else if (status & MII_GS_LINK)  {
                        printk( "TLAN: %s: Link active\n", dev->name );
                        TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
@@ -2377,10 +2423,12 @@ 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;
        }
+       TLan_SetMulticastList(dev);
 
 } /* TLan_FinishReset */
 
@@ -2408,18 +2456,20 @@ 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;
-                       
+
        areg *= 6;
 
        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 */
@@ -2445,12 +2495,12 @@ void TLan_SetMac( struct net_device *dev, int areg, char *mac )
         *      Parms:
         *              dev     A pointer to the device structure of the
         *                      TLAN device having the PHYs to be detailed.
-        *                              
+        *
         *      This function prints the registers a PHY (aka transceiver).
         *
         ********************************************************************/
 
-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;
@@ -2499,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;
@@ -2513,7 +2563,7 @@ void TLan_PhyDetect( struct net_device *dev )
        }
 
        TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi );
-       
+
        if ( hi != 0xFFFF ) {
                priv->phy[0] = TLAN_PHY_MAX_ADDR;
        } else {
@@ -2525,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;
                        }
                }
@@ -2546,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;
@@ -2555,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 );
        }
@@ -2571,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;
@@ -2592,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;
@@ -2620,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;
@@ -2635,10 +2691,10 @@ void TLan_PhyStartLink( struct net_device *dev )
        TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
        TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability );
 
-       if ( ( status & MII_GS_AUTONEG ) && 
+       if ( ( status & MII_GS_AUTONEG ) &&
             ( ! priv->aui ) ) {
                ability = status >> 11;
-               if ( priv->speed  == TLAN_SPEED_10 && 
+               if ( priv->speed  == TLAN_SPEED_10 &&
                     priv->duplex == TLAN_DUPLEX_HALF) {
                        TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000);
                } else if ( priv->speed == TLAN_SPEED_10 &&
@@ -2653,7 +2709,7 @@ void TLan_PhyStartLink( struct net_device *dev )
                        priv->tlanFullDuplex = TRUE;
                        TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100);
                } else {
-       
+
                        /* Set Auto-Neg advertisement */
                        TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1);
                        /* Enablee Auto-Neg */
@@ -2669,9 +2725,9 @@ void TLan_PhyStartLink( struct net_device *dev )
                        TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN );
                        return;
                }
-               
-       }       
-       
+
+       }
+
        if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) {
                priv->phyNum = 0;
                data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
@@ -2683,7 +2739,7 @@ void TLan_PhyStartLink( struct net_device *dev )
                TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl );
                if ( priv->aui ) {
                        tctl |= TLAN_TC_AUISEL;
-               } else { 
+               } else {
                        tctl &= ~TLAN_TC_AUISEL;
                        if ( priv->duplex == TLAN_DUPLEX_FULL ) {
                                control |= MII_GC_DUPLEX;
@@ -2707,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;
@@ -2716,7 +2772,7 @@ void TLan_PhyFinishAutoNeg( struct net_device *dev )
        u16             mode;
        u16             phy;
        u16             status;
-       
+
        phy = priv->phy[priv->phyNum];
 
        TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
@@ -2728,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;
@@ -2747,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 );
@@ -2756,19 +2814,21 @@ 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" );
                }
        }
 
        /* Wait for 100 ms.  No reason in partiticular.
         */
        TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET );
-               
+
 } /* TLan_PhyFinishAutoNeg */
 
 #ifdef MONITOR
@@ -2777,13 +2837,13 @@ void TLan_PhyFinishAutoNeg( struct net_device *dev )
         *
         *      TLan_phyMonitor
         *
-        *      Returns: 
+        *      Returns:
         *              None
         *
         *      Params:
         *              dev             The device structure of this device.
         *
-        *      
+        *
         *      This function monitors PHY condition by reading the status
         *      register via the MII bus. This can be used to give info
         *      about link changes (up/down), and possible switch to alternate
@@ -2803,7 +2863,7 @@ void TLan_PhyMonitor( struct net_device *dev )
         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status );
 
         /* Check if link has been lost */
-        if (!(phy_status & MII_GS_LINK)) { 
+        if (!(phy_status & MII_GS_LINK)) {
               if (priv->link) {
                      priv->link = 0;
                      printk(KERN_DEBUG "TLAN: %s has lost link\n", dev->name);
@@ -2822,7 +2882,7 @@ void TLan_PhyMonitor( struct net_device *dev )
 
        /* Setup a new monitor */
        TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
-}      
+}
 
 #endif /* MONITOR */
 
@@ -2852,18 +2912,18 @@ void TLan_PhyMonitor( struct net_device *dev )
         *                              for this device.
         *              phy             The address of the PHY to be queried.
         *              reg             The register whose contents are to be
-        *                              retreived.
+        *                              retrieved.
         *              val             A pointer to a variable to store the
         *                              retrieved value.
         *
-        *      This function uses the TLAN's MII bus to retreive the contents
+        *      This function uses the TLAN's MII bus to retrieve the contents
         *      of a given register on a PHY.  It sends the appropriate info
         *      and then reads the 16-bit register value from the MII bus via
         *      the TLAN SIO register.
         *
         **************************************************************/
 
-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;
@@ -2876,7 +2936,7 @@ int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
        err = FALSE;
        outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
        sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
-       
+
        if (!in_irq())
                spin_lock_irqsave(&priv->lock, flags);
 
@@ -2924,7 +2984,7 @@ int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
                TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);
 
        *val = tmp;
-       
+
        if (!in_irq())
                spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -2953,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;
@@ -2995,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;
@@ -3034,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;
@@ -3043,7 +3103,7 @@ void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
 
        outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
        sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
-       
+
        if (!in_irq())
                spin_lock_irqsave(&priv->lock, flags);
 
@@ -3066,7 +3126,7 @@ void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
 
        if ( minten )
                TLan_SetBit( TLAN_NET_SIO_MINTEN, sio );
-       
+
        if (!in_irq())
                spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -3094,7 +3154,7 @@ void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
         *
         *      Returns:
         *              Nothing
-        *      Parms:  
+        *      Parms:
         *              io_base         The IO port base address for the
         *                              TLAN device with the EEPROM to
         *                              use.
@@ -3104,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;
 
@@ -3144,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;
@@ -3169,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 );
        }
@@ -3205,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;
@@ -3232,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 );
        }
@@ -3263,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);