/*******************************************************************************
 *
 *  Linux ThunderLAN Driver
 *
 *  tlan.c
 *  by James Banks
 *
 *  (C) 1997-1998 Caldera, Inc.
 *  (C) 1998 James Banks
 *  (C) 1999-2001 Torben Mathiasen
 *  (C) 2002 Samuel Chessman
 *
 *  This software may be used and distributed according to the terms
 *  of the GNU General Public License, incorporated herein by reference.
 *
 ** Useful (if not required) reading:
 *
 *              Texas Instruments, ThunderLAN Programmer's Guide,
 *                      TI Literature Number SPWU013A
 *                      available in PDF format from www.ti.com
 *              Level One, LXT901 and LXT970 Data Sheets
 *                      available in PDF format from www.level1.com
 *              National Semiconductor, DP83840A Data Sheet
 *                      available in PDF format from www.national.com
 *              Microchip Technology, 24C01A/02A/04A Data Sheet
 *                      available in PDF format from www.microchip.com
 *
 ******************************************************************************/

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/hardirq.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#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>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/mii.h>

#include "tlan.h"


/* For removing EISA devices */
static  struct net_device       *tlan_eisa_devices;

static  int             tlan_devices_installed;

/* Set speed, duplex and aui settings */
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 speed setting(s) (0,10,100)");

MODULE_AUTHOR("Maintainer: Samuel Chessman <chessman@tux.org>");
MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters");
MODULE_LICENSE("GPL");

/* Turn on debugging.
 * See Documentation/networking/device_drivers/ethernet/ti/tlan.rst for details
 */
static  int             debug;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "ThunderLAN debug mask");

static  const char tlan_signature[] = "TLAN";
static  const char tlan_banner[] = "ThunderLAN driver v1.17\n";
static  int tlan_have_pci;
static  int tlan_have_eisa;

static const char * const media[] = {
        "10BaseT-HD", "10BaseT-FD", "100baseTx-HD",
        "100BaseTx-FD", "100BaseT4", NULL
};

static struct board {
        const char      *device_label;
        u32             flags;
        u16             addr_ofs;
} board_info[] = {
        { "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_NONE, 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 },
        { "Olicom OC-2325", TLAN_ADAPTER_ACTIVITY_LED |
          TLAN_ADAPTER_UNMANAGED_PHY, 0xf8 },
        { "Olicom OC-2326", TLAN_ADAPTER_ACTIVITY_LED |
          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, 0x83 }, /* EISA card */
};

static const struct pci_device_id tlan_pci_tbl[] = {
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
        { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2183,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
        { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2325,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
        { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2326,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
        { 0,}
};
MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);

static void     tlan_eisa_probe(void);
static void     tlan_eisa_cleanup(void);
static int      tlan_init(struct net_device *);
static int      tlan_open(struct net_device *dev);
static netdev_tx_t tlan_start_tx(struct sk_buff *, struct net_device *);
static irqreturn_t tlan_handle_interrupt(int, void *);
static int      tlan_close(struct net_device *);
static struct   net_device_stats *tlan_get_stats(struct net_device *);
static void     tlan_set_multicast_list(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 void     tlan_tx_timeout(struct net_device *dev, unsigned int txqueue);
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_handle_tx_eof(struct net_device *, u16);
static u32      tlan_handle_stat_overflow(struct net_device *, u16);
static u32      tlan_handle_rx_eof(struct net_device *, u16);
static u32      tlan_handle_dummy(struct net_device *, u16);
static u32      tlan_handle_tx_eoc(struct net_device *, u16);
static u32      tlan_handle_status_check(struct net_device *, u16);
static u32      tlan_handle_rx_eoc(struct net_device *, u16);

static void     tlan_timer(struct timer_list *t);
static void     tlan_phy_monitor(struct timer_list *t);

static void     tlan_reset_lists(struct net_device *);
static void     tlan_free_lists(struct net_device *);
static void     tlan_print_dio(u16);
static void     tlan_print_list(struct tlan_list *, char *, int);
static void     tlan_read_and_clear_stats(struct net_device *, int);
static void     tlan_reset_adapter(struct net_device *);
static void     tlan_finish_reset(struct net_device *);
static void     tlan_set_mac(struct net_device *, int areg, const char *mac);

static void     __tlan_phy_print(struct net_device *);
static void     tlan_phy_print(struct net_device *);
static void     tlan_phy_detect(struct net_device *);
static void     tlan_phy_power_down(struct net_device *);
static void     tlan_phy_power_up(struct net_device *);
static void     tlan_phy_reset(struct net_device *);
static void     tlan_phy_start_link(struct net_device *);
static void     tlan_phy_finish_auto_neg(struct net_device *);

/*
  static int    tlan_phy_nop(struct net_device *);
  static int    tlan_phy_internal_check(struct net_device *);
  static int    tlan_phy_internal_service(struct net_device *);
  static int    tlan_phy_dp83840a_check(struct net_device *);
*/

static bool     __tlan_mii_read_reg(struct net_device *, u16, u16, u16 *);
static void     tlan_mii_read_reg(struct net_device *, u16, u16, u16 *);
static void     tlan_mii_send_data(u16, u32, unsigned);
static void     tlan_mii_sync(u16);
static void     __tlan_mii_write_reg(struct net_device *, u16, u16, u16);
static void     tlan_mii_write_reg(struct net_device *, u16, u16, u16);

static void     tlan_ee_send_start(u16);
static int      tlan_ee_send_byte(u16, u8, int);
static void     tlan_ee_receive_byte(u16, u8 *, int);
static int      tlan_ee_read_byte(struct net_device *, u8, u8 *);


static inline void
tlan_store_skb(struct tlan_list *tag, struct sk_buff *skb)
{
        unsigned long addr = (unsigned long)skb;
        tag->buffer[9].address = addr;
        tag->buffer[8].address = upper_32_bits(addr);
}

static inline struct sk_buff *
tlan_get_skb(const struct tlan_list *tag)
{
        unsigned long addr;

        addr = tag->buffer[9].address;
        addr |= ((unsigned long) tag->buffer[8].address << 16) << 16;
        return (struct sk_buff *) addr;
}

static u32
(*tlan_int_vector[TLAN_INT_NUMBER_OF_INTS])(struct net_device *, u16) = {
        NULL,
        tlan_handle_tx_eof,
        tlan_handle_stat_overflow,
        tlan_handle_rx_eof,
        tlan_handle_dummy,
        tlan_handle_tx_eoc,
        tlan_handle_status_check,
        tlan_handle_rx_eoc
};

static void
tlan_set_timer(struct net_device *dev, u32 ticks, u32 type)
{
        struct tlan_priv *priv = netdev_priv(dev);
        unsigned long flags = 0;

        spin_lock_irqsave(&priv->lock, flags);
        if (priv->timer.function != NULL &&
            priv->timer_type != TLAN_TIMER_ACTIVITY) {
                spin_unlock_irqrestore(&priv->lock, flags);
                return;
        }
        priv->timer.function = tlan_timer;
        spin_unlock_irqrestore(&priv->lock, flags);

        priv->timer_set_at = jiffies;
        priv->timer_type = type;
        mod_timer(&priv->timer, jiffies + ticks);

}


/*****************************************************************************
******************************************************************************

ThunderLAN driver primary functions

these functions are more or less common to all linux network drivers.

******************************************************************************
*****************************************************************************/





/***************************************************************
 *      tlan_remove_one
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              None
 *
 *      Goes through the TLanDevices list and frees the device
 *      structs and memory associated with each device (lists
 *      and buffers).  It also ureserves the IO port regions
 *      associated with this device.
 *
 **************************************************************/


static void tlan_remove_one(struct pci_dev *pdev)
{
        struct net_device *dev = pci_get_drvdata(pdev);
        struct tlan_priv        *priv = netdev_priv(dev);

        unregister_netdev(dev);

        if (priv->dma_storage) {
                dma_free_coherent(&priv->pci_dev->dev, priv->dma_size,
                                  priv->dma_storage, priv->dma_storage_dma);
        }

#ifdef CONFIG_PCI
        pci_release_regions(pdev);
#endif

        cancel_work_sync(&priv->tlan_tqueue);
        free_netdev(dev);
}

static void tlan_start(struct net_device *dev)
{
        tlan_reset_lists(dev);
        /* NOTE: It might not be necessary to read the stats before a
           reset if you don't care what the values are.
        */
        tlan_read_and_clear_stats(dev, TLAN_IGNORE);
        tlan_reset_adapter(dev);
        netif_wake_queue(dev);
}

static void tlan_stop(struct net_device *dev)
{
        struct tlan_priv *priv = netdev_priv(dev);

        timer_delete_sync(&priv->media_timer);
        tlan_read_and_clear_stats(dev, TLAN_RECORD);
        outl(TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD);
        /* Reset and power down phy */
        tlan_reset_adapter(dev);
        if (priv->timer.function != NULL) {
                timer_delete_sync(&priv->timer);
                priv->timer.function = NULL;
        }
}

static int __maybe_unused tlan_suspend(struct device *dev_d)
{
        struct net_device *dev = dev_get_drvdata(dev_d);

        if (netif_running(dev))
                tlan_stop(dev);

        netif_device_detach(dev);

        return 0;
}

static int __maybe_unused tlan_resume(struct device *dev_d)
{
        struct net_device *dev = dev_get_drvdata(dev_d);
        netif_device_attach(dev);

        if (netif_running(dev))
                tlan_start(dev);

        return 0;
}

static SIMPLE_DEV_PM_OPS(tlan_pm_ops, tlan_suspend, tlan_resume);

static struct pci_driver tlan_driver = {
        .name           = "tlan",
        .id_table       = tlan_pci_tbl,
        .probe          = tlan_init_one,
        .remove         = tlan_remove_one,
        .driver.pm      = &tlan_pm_ops,
};

static int __init tlan_probe(void)
{
        int rc = -ENODEV;

        pr_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 */
        rc = pci_register_driver(&tlan_driver);

        if (rc != 0) {
                pr_err("Could not register pci driver\n");
                goto err_out_pci_free;
        }

        TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....\n");
        tlan_eisa_probe();

        pr_info("%d device%s installed, PCI: %d  EISA: %d\n",
                tlan_devices_installed, tlan_devices_installed == 1 ? "" : "s",
                tlan_have_pci, tlan_have_eisa);

        if (tlan_devices_installed == 0) {
                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 tlan_init_one(struct pci_dev *pdev,
                                   const struct pci_device_id *ent)
{
        return tlan_probe1(pdev, -1, -1, 0, ent);
}


/*
***************************************************************
*       tlan_probe1
*
*       Returns:
*               0 on success, error code on error
*       Parms:
*               none
*
*       The name is lower case to fit in with all the rest of
*       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
*       now allocates its own device structure. This function
*       is also used by modules.
*
**************************************************************/

static int tlan_probe1(struct pci_dev *pdev, long ioaddr, int irq, int rev,
                       const struct pci_device_id *ent)
{

        struct net_device  *dev;
        struct tlan_priv  *priv;
        u16                device_id;
        int                reg, rc = -ENODEV;

#ifdef CONFIG_PCI
        if (pdev) {
                rc = pci_enable_device(pdev);
                if (rc)
                        return rc;

                rc = pci_request_regions(pdev, tlan_signature);
                if (rc) {
                        pr_err("Could not reserve IO regions\n");
                        goto err_out;
                }
        }
#endif  /*  CONFIG_PCI  */

        dev = alloc_etherdev(sizeof(struct tlan_priv));
        if (dev == NULL) {
                rc = -ENOMEM;
                goto err_out_regions;
        }
        SET_NETDEV_DEV(dev, &pdev->dev);

        priv = netdev_priv(dev);

        priv->pci_dev = pdev;
        priv->dev = dev;

        /* Is this a PCI device? */
        if (pdev) {
                u32                pci_io_base = 0;

                priv->adapter = &board_info[ent->driver_data];

                rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (rc) {
                        pr_err("No suitable PCI mapping available\n");
                        goto err_out_free_dev;
                }

                for (reg = 0; reg <= 5; reg++) {
                        if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {
                                pci_io_base = pci_resource_start(pdev, reg);
                                TLAN_DBG(TLAN_DEBUG_GNRL,
                                         "IO mapping is available at %x.\n",
                                         pci_io_base);
                                break;
                        }
                }
                if (!pci_io_base) {
                        pr_err("No IO mappings available\n");
                        rc = -EIO;
                        goto err_out_free_dev;
                }

                dev->base_addr = pci_io_base;
                dev->irq = pdev->irq;
                priv->adapter_rev = pdev->revision;
                pci_set_master(pdev);
                pci_set_drvdata(pdev, dev);

        } else  {     /* EISA card */
                /* This is a hack. We need to know which board structure
                 * is suited for this adapter */
                device_id = inw(ioaddr + EISA_ID2);
                if (device_id == 0x20F1) {
                        priv->adapter = &board_info[13]; /* NetFlex-3/E */
                        priv->adapter_rev = 23;         /* TLAN 2.3 */
                } else {
                        priv->adapter = &board_info[14];
                        priv->adapter_rev = 10;         /* TLAN 1.0 */
                }
                dev->base_addr = ioaddr;
                dev->irq = irq;
        }

        /* 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;

                if (priv->speed == 0x1)
                        priv->speed = TLAN_SPEED_10;
                else if (priv->speed == 0x2)
                        priv->speed = TLAN_SPEED_100;

                debug = priv->debug = dev->mem_end;
        } else {
                priv->aui    = aui[boards_found];
                priv->speed  = speed[boards_found];
                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, tlan_tx_timeout_work);

        spin_lock_init(&priv->lock);

        rc = tlan_init(dev);
        if (rc) {
                pr_err("Could not set up device\n");
                goto err_out_free_dev;
        }

        rc = register_netdev(dev);
        if (rc) {
                pr_err("Could not register device\n");
                goto err_out_uninit;
        }


        tlan_devices_installed++;
        boards_found++;

        /* pdev is NULL if this is an EISA device */
        if (pdev)
                tlan_have_pci++;
        else {
                priv->next_device = tlan_eisa_devices;
                tlan_eisa_devices = dev;
                tlan_have_eisa++;
        }

        netdev_info(dev, "irq=%2d, io=%04x, %s, Rev. %d\n",
                    (int)dev->irq,
                    (int)dev->base_addr,
                    priv->adapter->device_label,
                    priv->adapter_rev);
        return 0;

err_out_uninit:
        dma_free_coherent(&priv->pci_dev->dev, priv->dma_size,
                          priv->dma_storage, priv->dma_storage_dma);
err_out_free_dev:
        free_netdev(dev);
err_out_regions:
#ifdef CONFIG_PCI
        if (pdev)
                pci_release_regions(pdev);
err_out:
#endif
        if (pdev)
                pci_disable_device(pdev);
        return rc;
}


static void tlan_eisa_cleanup(void)
{
        struct net_device *dev;
        struct tlan_priv *priv;

        while (tlan_have_eisa) {
                dev = tlan_eisa_devices;
                priv = netdev_priv(dev);
                if (priv->dma_storage) {
                        dma_free_coherent(&priv->pci_dev->dev, priv->dma_size,
                                          priv->dma_storage,
                                          priv->dma_storage_dma);
                }
                release_region(dev->base_addr, 0x10);
                unregister_netdev(dev);
                tlan_eisa_devices = priv->next_device;
                free_netdev(dev);
                tlan_have_eisa--;
        }
}


static void __exit tlan_exit(void)
{
        pci_unregister_driver(&tlan_driver);

        if (tlan_have_eisa)
                tlan_eisa_cleanup();

}


/* Module loading/unloading */
module_init(tlan_probe);
module_exit(tlan_exit);



/**************************************************************
 *      tlan_eisa_probe
 *
 *      Returns: 0 on success, 1 otherwise
 *
 *      Parms:   None
 *
 *
 *      This functions probes for EISA devices and calls
 *      TLan_probe1 when one is found.
 *
 *************************************************************/

static void  __init tlan_eisa_probe(void)
{
        long    ioaddr;
        int     irq;
        u16     device_id;

        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,
                         "Probing for EISA adapter at IO: 0x%4x : ",
                         (int) ioaddr);
                if (request_region(ioaddr, 0x10, tlan_signature) == NULL)
                        goto out;

                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) {
                        release_region(ioaddr, 0x10);
                        goto out;
                }

                /* check if adapter is enabled */
                if (inb(ioaddr + EISA_CR) != 0x1) {
                        release_region(ioaddr, 0x10);
                        goto out2;
                }

                if (debug == 0x10)
                        pr_info("Found one\n");


                /* Get irq from board */
                switch (inb(ioaddr + 0xcc0)) {
                case(0x10):
                        irq = 5;
                        break;
                case(0x20):
                        irq = 9;
                        break;
                case(0x40):
                        irq = 10;
                        break;
                case(0x80):
                        irq = 11;
                        break;
                default:
                        goto out;
                }


                /* Setup the newly found eisa adapter */
                tlan_probe1(NULL, ioaddr, irq, 12, NULL);
                continue;

out:
                if (debug == 0x10)
                        pr_info("None found\n");
                continue;

out2:
                if (debug == 0x10)
                        pr_info("Card found but it is not enabled, skipping\n");
                continue;

        }

}

#ifdef CONFIG_NET_POLL_CONTROLLER
static void tlan_poll(struct net_device *dev)
{
        disable_irq(dev->irq);
        tlan_handle_interrupt(dev->irq, dev);
        enable_irq(dev->irq);
}
#endif

static const struct net_device_ops tlan_netdev_ops = {
        .ndo_open               = tlan_open,
        .ndo_stop               = tlan_close,
        .ndo_start_xmit         = tlan_start_tx,
        .ndo_tx_timeout         = tlan_tx_timeout,
        .ndo_get_stats          = tlan_get_stats,
        .ndo_set_rx_mode        = tlan_set_multicast_list,
        .ndo_eth_ioctl          = tlan_ioctl,
        .ndo_set_mac_address    = eth_mac_addr,
        .ndo_validate_addr      = eth_validate_addr,
#ifdef CONFIG_NET_POLL_CONTROLLER
        .ndo_poll_controller     = tlan_poll,
#endif
};

static void tlan_get_drvinfo(struct net_device *dev,
                             struct ethtool_drvinfo *info)
{
        struct tlan_priv *priv = netdev_priv(dev);

        strscpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
        if (priv->pci_dev)
                strscpy(info->bus_info, pci_name(priv->pci_dev),
                        sizeof(info->bus_info));
        else
                strscpy(info->bus_info, "EISA", sizeof(info->bus_info));
}

static int tlan_get_eeprom_len(struct net_device *dev)
{
        return TLAN_EEPROM_SIZE;
}

static int tlan_get_eeprom(struct net_device *dev,
                           struct ethtool_eeprom *eeprom, u8 *data)
{
        int i;

        for (i = 0; i < TLAN_EEPROM_SIZE; i++)
                if (tlan_ee_read_byte(dev, i, &data[i]))
                        return -EIO;

        return 0;
}

static const struct ethtool_ops tlan_ethtool_ops = {
        .get_drvinfo    = tlan_get_drvinfo,
        .get_link       = ethtool_op_get_link,
        .get_eeprom_len = tlan_get_eeprom_len,
        .get_eeprom     = tlan_get_eeprom,
};

/***************************************************************
 *      tlan_init
 *
 *      Returns:
 *              0 on success, error code otherwise.
 *      Parms:
 *              dev     The structure of the device to be
 *                      init'ed.
 *
 *      This function completes the initialization of the
 *      device structure and driver.  It reserves the IO
 *      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)
{
        int             dma_size;
        int             err;
        int             i;
        struct tlan_priv        *priv;
        u8 addr[ETH_ALEN];

        priv = netdev_priv(dev);

        dma_size = (TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS)
                * (sizeof(struct tlan_list));
        priv->dma_storage = dma_alloc_coherent(&priv->pci_dev->dev, dma_size,
                                               &priv->dma_storage_dma, GFP_KERNEL);
        priv->dma_size = dma_size;

        if (priv->dma_storage == NULL) {
                pr_err("Could not allocate lists and buffers for %s\n",
                       dev->name);
                return -ENOMEM;
        }
        priv->rx_list = (struct tlan_list *)
                ALIGN((unsigned long)priv->dma_storage, 8);
        priv->rx_list_dma = ALIGN(priv->dma_storage_dma, 8);
        priv->tx_list = priv->rx_list + TLAN_NUM_RX_LISTS;
        priv->tx_list_dma =
                priv->rx_list_dma + sizeof(struct tlan_list)*TLAN_NUM_RX_LISTS;

        err = 0;
        for (i = 0; i < ETH_ALEN; i++)
                err |= tlan_ee_read_byte(dev,
                                         (u8) priv->adapter->addr_ofs + i,
                                         addr + i);
        if (err) {
                pr_err("%s: Error reading MAC from eeprom: %d\n",
                       dev->name, err);
        }
        /* Olicom OC-2325/OC-2326 have the address byte-swapped */
        if (priv->adapter->addr_ofs == 0xf8) {
                for (i = 0; i < ETH_ALEN; i += 2) {
                        char tmp = addr[i];
                        addr[i] = addr[i + 1];
                        addr[i + 1] = tmp;
                }
        }
        eth_hw_addr_set(dev, addr);

        netif_carrier_off(dev);

        /* Device methods */
        dev->netdev_ops = &tlan_netdev_ops;
        dev->ethtool_ops = &tlan_ethtool_ops;
        dev->watchdog_timeo = TX_TIMEOUT;

        return 0;

}




/***************************************************************
 *      tlan_open
 *
 *      Returns:
 *              0 on success, error code otherwise.
 *      Parms:
 *              dev     Structure of device to be opened.
 *
 *      This routine puts the driver and TLAN adapter in a
 *      state where it is ready to send and receive packets.
 *      It allocates the IRQ, resets and brings the adapter
 *      out of reset, and allows interrupts.  It also delays
 *      the startup for autonegotiation or sends a Rx GO
 *      command to the adapter, as appropriate.
 *
 **************************************************************/

static int tlan_open(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        int             err;

        priv->tlan_rev = tlan_dio_read8(dev->base_addr, TLAN_DEF_REVISION);
        err = request_irq(dev->irq, tlan_handle_interrupt, IRQF_SHARED,
                          dev->name, dev);

        if (err) {
                netdev_err(dev, "Cannot open because IRQ %d is already in use\n",
                           dev->irq);
                return err;
        }

        timer_setup(&priv->timer, NULL, 0);
        timer_setup(&priv->media_timer, tlan_phy_monitor, 0);

        tlan_start(dev);

        TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Opened.  TLAN Chip Rev: %x\n",
                 dev->name, priv->tlan_rev);

        return 0;

}



/**************************************************************
 *      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.
 *
 *
 *************************************************************/

static int tlan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
        struct tlan_priv *priv = netdev_priv(dev);
        struct mii_ioctl_data *data = if_mii(rq);
        u32 phy   = priv->phy[priv->phy_num];

        if (!priv->phy_online)
                return -EAGAIN;

        switch (cmd) {
        case SIOCGMIIPHY:               /* get address of MII PHY in use. */
                data->phy_id = phy;
                fallthrough;


        case SIOCGMIIREG:               /* read MII PHY register. */
                tlan_mii_read_reg(dev, data->phy_id & 0x1f,
                                  data->reg_num & 0x1f, &data->val_out);
                return 0;


        case SIOCSMIIREG:               /* write MII PHY register. */
                tlan_mii_write_reg(dev, data->phy_id & 0x1f,
                                   data->reg_num & 0x1f, data->val_in);
                return 0;
        default:
                return -EOPNOTSUPP;
        }
}


/***************************************************************
 *      tlan_tx_timeout
 *
 *      Returns: nothing
 *
 *      Params:
 *              dev     structure of device which timed out
 *                      during transmit.
 *
 **************************************************************/

static void tlan_tx_timeout(struct net_device *dev, unsigned int txqueue)
{

        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_free_lists(dev);
        tlan_reset_lists(dev);
        tlan_read_and_clear_stats(dev, TLAN_IGNORE);
        tlan_reset_adapter(dev);
        netif_trans_update(dev); /* prevent tx timeout */
        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)
{
        struct tlan_priv        *priv =
                container_of(work, struct tlan_priv, tlan_tqueue);

        tlan_tx_timeout(priv->dev, UINT_MAX);
}



/***************************************************************
 *      tlan_start_tx
 *
 *      Returns:
 *              0 on success, non-zero on failure.
 *      Parms:
 *              skb     A pointer to the sk_buff containing the
 *                      frame to be sent.
 *              dev     The device to send the data on.
 *
 *      This function adds a frame to the Tx list to be sent
 *      ASAP.  First it verifies that the adapter is ready and
 *      there is room in the queue.  Then it sets up the next
 *      available list, copies the frame to the corresponding
 *      buffer.  If the adapter Tx channel is idle, it gives
 *      the adapter a Tx Go command on the list, otherwise it
 *      sets the forward address of the previous list to point
 *      to this one.  Then it frees the sk_buff.
 *
 **************************************************************/

static netdev_tx_t tlan_start_tx(struct sk_buff *skb, struct net_device *dev)
{
        struct tlan_priv *priv = netdev_priv(dev);
        dma_addr_t      tail_list_phys;
        struct tlan_list        *tail_list;
        unsigned long   flags;
        unsigned int    txlen;

        if (!priv->phy_online) {
                TLAN_DBG(TLAN_DEBUG_TX, "TRANSMIT:  %s PHY is not ready\n",
                         dev->name);
                dev_kfree_skb_any(skb);
                return NETDEV_TX_OK;
        }

        if (skb_padto(skb, TLAN_MIN_FRAME_SIZE))
                return NETDEV_TX_OK;
        txlen = max(skb->len, (unsigned int)TLAN_MIN_FRAME_SIZE);

        tail_list = priv->tx_list + priv->tx_tail;
        tail_list_phys =
                priv->tx_list_dma + sizeof(struct tlan_list)*priv->tx_tail;

        if (tail_list->c_stat != TLAN_CSTAT_UNUSED) {
                TLAN_DBG(TLAN_DEBUG_TX,
                         "TRANSMIT:  %s is busy (Head=%d Tail=%d)\n",
                         dev->name, priv->tx_head, priv->tx_tail);
                netif_stop_queue(dev);
                priv->tx_busy_count++;
                return NETDEV_TX_BUSY;
        }

        tail_list->forward = 0;

        tail_list->buffer[0].address = dma_map_single(&priv->pci_dev->dev,
                                                      skb->data, txlen,
                                                      DMA_TO_DEVICE);
        tlan_store_skb(tail_list, skb);

        tail_list->frame_size = (u16) txlen;
        tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) txlen;
        tail_list->buffer[1].count = 0;
        tail_list->buffer[1].address = 0;

        spin_lock_irqsave(&priv->lock, flags);
        tail_list->c_stat = TLAN_CSTAT_READY;
        if (!priv->tx_in_progress) {
                priv->tx_in_progress = 1;
                TLAN_DBG(TLAN_DEBUG_TX,
                         "TRANSMIT:  Starting TX on buffer %d\n",
                         priv->tx_tail);
                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->tx_tail);
                if (priv->tx_tail == 0) {
                        (priv->tx_list + (TLAN_NUM_TX_LISTS - 1))->forward
                                = tail_list_phys;
                } else {
                        (priv->tx_list + (priv->tx_tail - 1))->forward
                                = tail_list_phys;
                }
        }
        spin_unlock_irqrestore(&priv->lock, flags);

        CIRC_INC(priv->tx_tail, TLAN_NUM_TX_LISTS);

        return NETDEV_TX_OK;

}




/***************************************************************
 *      tlan_handle_interrupt
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              irq     The line on which the interrupt
 *                      occurred.
 *              dev_id  A pointer to the device assigned to
 *                      this irq line.
 *
 *      This function handles an interrupt generated by its
 *      assigned TLAN adapter.  The function deactivates
 *      interrupts on its adapter, records the type of
 *      interrupt, executes the appropriate subhandler, and
 *      acknowdges the interrupt to the adapter (thus
 *      re-enabling adapter interrupts.
 *
 **************************************************************/

static irqreturn_t tlan_handle_interrupt(int irq, void *dev_id)
{
        struct net_device       *dev = dev_id;
        struct tlan_priv *priv = netdev_priv(dev);
        u16             host_int;
        u16             type;

        spin_lock(&priv->lock);

        host_int = inw(dev->base_addr + TLAN_HOST_INT);
        type = (host_int & TLAN_HI_IT_MASK) >> 2;
        if (type) {
                u32     ack;
                u32     host_cmd;

                outw(host_int, dev->base_addr + TLAN_HOST_INT);
                ack = tlan_int_vector[type](dev, host_int);

                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_RETVAL(type);
}




/***************************************************************
 *      tlan_close
 *
 *      Returns:
 *              An error code.
 *      Parms:
 *              dev     The device structure of the device to
 *                      close.
 *
 *      This function shuts down the adapter.  It records any
 *      stats, puts the adapter into reset state, deactivates
 *      its time as needed, and frees the irq it is using.
 *
 **************************************************************/

static int tlan_close(struct net_device *dev)
{
        tlan_stop(dev);

        free_irq(dev->irq, dev);
        tlan_free_lists(dev);
        TLAN_DBG(TLAN_DEBUG_GNRL, "Device %s closed.\n", dev->name);

        return 0;

}




/***************************************************************
 *      tlan_get_stats
 *
 *      Returns:
 *              A pointer to the device's statistics structure.
 *      Parms:
 *              dev     The device structure to return the
 *                      stats for.
 *
 *      This function updates the devices statistics by reading
 *      the TLAN chip's onboard registers.  Then it returns the
 *      address of the statistics structure.
 *
 **************************************************************/

static struct net_device_stats *tlan_get_stats(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        int i;

        /* Should only read stats if open ? */
        tlan_read_and_clear_stats(dev, TLAN_RECORD);

        TLAN_DBG(TLAN_DEBUG_RX, "RECEIVE:  %s EOC count = %d\n", dev->name,
                 priv->rx_eoc_count);
        TLAN_DBG(TLAN_DEBUG_TX, "TRANSMIT:  %s Busy count = %d\n", dev->name,
                 priv->tx_busy_count);
        if (debug & TLAN_DEBUG_GNRL) {
                tlan_print_dio(dev->base_addr);
                tlan_phy_print(dev);
        }
        if (debug & TLAN_DEBUG_LIST) {
                for (i = 0; i < TLAN_NUM_RX_LISTS; i++)
                        tlan_print_list(priv->rx_list + i, "RX", i);
                for (i = 0; i < TLAN_NUM_TX_LISTS; i++)
                        tlan_print_list(priv->tx_list + i, "TX", i);
        }

        return &dev->stats;

}




/***************************************************************
 *      tlan_set_multicast_list
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              dev     The device structure to set the
 *                      multicast list for.
 *
 *      This function sets the TLAN adaptor to various receive
 *      modes.  If the IFF_PROMISC flag is set, promiscuous
 *      mode is acitviated.  Otherwise, promiscuous mode is
 *      turned off.  If the IFF_ALLMULTI flag is set, then
 *      the hash table is set to receive all group addresses.
 *      Otherwise, the first three multicast addresses are
 *      stored in AREG_1-3, and the rest are selected via the
 *      hash table, as necessary.
 *
 **************************************************************/

static void tlan_set_multicast_list(struct net_device *dev)
{
        struct netdev_hw_addr *ha;
        u32                     hash1 = 0;
        u32                     hash2 = 0;
        int                     i;
        u32                     offset;
        u8                      tmp;

        if (dev->flags & IFF_PROMISC) {
                tmp = tlan_dio_read8(dev->base_addr, TLAN_NET_CMD);
                tlan_dio_write8(dev->base_addr,
                                TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF);
        } else {
                tmp = tlan_dio_read8(dev->base_addr, TLAN_NET_CMD);
                tlan_dio_write8(dev->base_addr,
                                TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF);
                if (dev->flags & IFF_ALLMULTI) {
                        for (i = 0; i < 3; i++)
                                tlan_set_mac(dev, i + 1, NULL);
                        tlan_dio_write32(dev->base_addr, TLAN_HASH_1,
                                         0xffffffff);
                        tlan_dio_write32(dev->base_addr, TLAN_HASH_2,
                                         0xffffffff);
                } else {
                        i = 0;
                        netdev_for_each_mc_addr(ha, dev) {
                                if (i < 3) {
                                        tlan_set_mac(dev, i + 1,
                                                     (char *) &ha->addr);
                                } else {
                                        offset =
                                                tlan_hash_func((u8 *)&ha->addr);
                                        if (offset < 32)
                                                hash1 |= (1 << offset);
                                        else
                                                hash2 |= (1 << (offset - 32));
                                }
                                i++;
                        }
                        for ( ; i < 3; i++)
                                tlan_set_mac(dev, i + 1, NULL);
                        tlan_dio_write32(dev->base_addr, TLAN_HASH_1, hash1);
                        tlan_dio_write32(dev->base_addr, TLAN_HASH_2, hash2);
                }
        }

}



/*****************************************************************************
******************************************************************************

ThunderLAN driver interrupt vectors and table

please see chap. 4, "Interrupt Handling" of the "ThunderLAN
Programmer's Guide" for more informations on handling interrupts
generated by TLAN based adapters.

******************************************************************************
*****************************************************************************/




/***************************************************************
 *      tlan_handle_tx_eof
 *
 *      Returns:
 *              1
 *      Parms:
 *              dev             Device assigned the IRQ that was
 *                              raised.
 *              host_int        The contents of the HOST_INT
 *                              port.
 *
 *      This function handles Tx EOF interrupts which are raised
 *      by the adapter when it has completed sending the
 *      contents of a buffer.  If detemines which list/buffer
 *      was completed and resets it.  If the buffer was the last
 *      in the channel (EOC), then the function checks to see if
 *      another buffer is ready to send, and if so, sends a Tx
 *      Go command.  Finally, the driver activates/continues the
 *      activity LED.
 *
 **************************************************************/

static u32 tlan_handle_tx_eof(struct net_device *dev, u16 host_int)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        int             eoc = 0;
        struct tlan_list        *head_list;
        dma_addr_t      head_list_phys;
        u32             ack = 0;
        u16             tmp_c_stat;

        TLAN_DBG(TLAN_DEBUG_TX,
                 "TRANSMIT:  Handling TX EOF (Head=%d Tail=%d)\n",
                 priv->tx_head, priv->tx_tail);
        head_list = priv->tx_list + priv->tx_head;

        while (((tmp_c_stat = head_list->c_stat) & TLAN_CSTAT_FRM_CMP)
               && (ack < 255)) {
                struct sk_buff *skb = tlan_get_skb(head_list);

                ack++;
                dma_unmap_single(&priv->pci_dev->dev,
                                 head_list->buffer[0].address,
                                 max(skb->len, (unsigned int)TLAN_MIN_FRAME_SIZE),
                                 DMA_TO_DEVICE);
                dev_kfree_skb_any(skb);
                head_list->buffer[8].address = 0;
                head_list->buffer[9].address = 0;

                if (tmp_c_stat & TLAN_CSTAT_EOC)
                        eoc = 1;

                dev->stats.tx_bytes += head_list->frame_size;

                head_list->c_stat = TLAN_CSTAT_UNUSED;
                netif_start_queue(dev);
                CIRC_INC(priv->tx_head, TLAN_NUM_TX_LISTS);
                head_list = priv->tx_list + priv->tx_head;
        }

        if (!ack)
                netdev_info(dev,
                            "Received interrupt for uncompleted TX frame\n");

        if (eoc) {
                TLAN_DBG(TLAN_DEBUG_TX,
                         "TRANSMIT:  handling TX EOC (Head=%d Tail=%d)\n",
                         priv->tx_head, priv->tx_tail);
                head_list = priv->tx_list + priv->tx_head;
                head_list_phys = priv->tx_list_dma
                        + sizeof(struct tlan_list)*priv->tx_head;
                if ((head_list->c_stat & TLAN_CSTAT_READY)
                    == TLAN_CSTAT_READY) {
                        outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
                        ack |= TLAN_HC_GO;
                } else {
                        priv->tx_in_progress = 0;
                }
        }

        if (priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED) {
                tlan_dio_write8(dev->base_addr,
                                TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT);
                if (priv->timer.function == NULL) {
                        priv->timer.function = tlan_timer;
                        priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
                        priv->timer_set_at = jiffies;
                        priv->timer_type = TLAN_TIMER_ACTIVITY;
                        add_timer(&priv->timer);
                } else if (priv->timer_type == TLAN_TIMER_ACTIVITY) {
                        priv->timer_set_at = jiffies;
                }
        }

        return ack;

}




/***************************************************************
 *      TLan_HandleStatOverflow
 *
 *      Returns:
 *              1
 *      Parms:
 *              dev             Device assigned the IRQ that was
 *                              raised.
 *              host_int        The contents of the HOST_INT
 *                              port.
 *
 *      This function handles the Statistics Overflow interrupt
 *      which means that one or more of the TLAN statistics
 *      registers has reached 1/2 capacity and needs to be read.
 *
 **************************************************************/

static u32 tlan_handle_stat_overflow(struct net_device *dev, u16 host_int)
{
        tlan_read_and_clear_stats(dev, TLAN_RECORD);

        return 1;

}




/***************************************************************
 *      TLan_HandleRxEOF
 *
 *      Returns:
 *              1
 *      Parms:
 *              dev             Device assigned the IRQ that was
 *                              raised.
 *              host_int        The contents of the HOST_INT
 *                              port.
 *
 *      This function handles the Rx EOF interrupt which
 *      indicates a frame has been received by the adapter from
 *      the net and the frame has been transferred to memory.
 *      The function determines the bounce buffer the frame has
 *      been loaded into, creates a new sk_buff big enough to
 *      hold the frame, and sends it to protocol stack.  It
 *      then resets the used buffer and appends it to the end
 *      of the list.  If the frame was the last in the Rx
 *      channel (EOC), the function restarts the receive channel
 *      by sending an Rx Go command to the adapter.  Then it
 *      activates/continues the activity LED.
 *
 **************************************************************/

static u32 tlan_handle_rx_eof(struct net_device *dev, u16 host_int)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        u32             ack = 0;
        int             eoc = 0;
        struct tlan_list        *head_list;
        struct sk_buff  *skb;
        struct tlan_list        *tail_list;
        u16             tmp_c_stat;
        dma_addr_t      head_list_phys;

        TLAN_DBG(TLAN_DEBUG_RX, "RECEIVE:  handling RX EOF (Head=%d Tail=%d)\n",
                 priv->rx_head, priv->rx_tail);
        head_list = priv->rx_list + priv->rx_head;
        head_list_phys =
                priv->rx_list_dma + sizeof(struct tlan_list)*priv->rx_head;

        while (((tmp_c_stat = head_list->c_stat) & TLAN_CSTAT_FRM_CMP)
               && (ack < 255)) {
                dma_addr_t frame_dma = head_list->buffer[0].address;
                u32 frame_size = head_list->frame_size;
                struct sk_buff *new_skb;

                ack++;
                if (tmp_c_stat & TLAN_CSTAT_EOC)
                        eoc = 1;

                new_skb = netdev_alloc_skb_ip_align(dev,
                                                    TLAN_MAX_FRAME_SIZE + 5);
                if (!new_skb)
                        goto drop_and_reuse;

                skb = tlan_get_skb(head_list);
                dma_unmap_single(&priv->pci_dev->dev, frame_dma,
                                 TLAN_MAX_FRAME_SIZE, DMA_FROM_DEVICE);
                skb_put(skb, frame_size);

                dev->stats.rx_bytes += frame_size;

                skb->protocol = eth_type_trans(skb, dev);
                netif_rx(skb);

                head_list->buffer[0].address =
                        dma_map_single(&priv->pci_dev->dev, new_skb->data,
                                       TLAN_MAX_FRAME_SIZE, DMA_FROM_DEVICE);

                tlan_store_skb(head_list, new_skb);
drop_and_reuse:
                head_list->forward = 0;
                head_list->c_stat = 0;
                tail_list = priv->rx_list + priv->rx_tail;
                tail_list->forward = head_list_phys;

                CIRC_INC(priv->rx_head, TLAN_NUM_RX_LISTS);
                CIRC_INC(priv->rx_tail, TLAN_NUM_RX_LISTS);
                head_list = priv->rx_list + priv->rx_head;
                head_list_phys = priv->rx_list_dma
                        + sizeof(struct tlan_list)*priv->rx_head;
        }

        if (!ack)
                netdev_info(dev,
                            "Received interrupt for uncompleted RX frame\n");


        if (eoc) {
                TLAN_DBG(TLAN_DEBUG_RX,
                         "RECEIVE:  handling RX EOC (Head=%d Tail=%d)\n",
                         priv->rx_head, priv->rx_tail);
                head_list = priv->rx_list + priv->rx_head;
                head_list_phys = priv->rx_list_dma
                        + sizeof(struct tlan_list)*priv->rx_head;
                outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
                ack |= TLAN_HC_GO | TLAN_HC_RT;
                priv->rx_eoc_count++;
        }

        if (priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED) {
                tlan_dio_write8(dev->base_addr,
                                TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT);
                if (priv->timer.function == NULL)  {
                        priv->timer.function = tlan_timer;
                        priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
                        priv->timer_set_at = jiffies;
                        priv->timer_type = TLAN_TIMER_ACTIVITY;
                        add_timer(&priv->timer);
                } else if (priv->timer_type == TLAN_TIMER_ACTIVITY) {
                        priv->timer_set_at = jiffies;
                }
        }

        return ack;

}




/***************************************************************
 *      tlan_handle_dummy
 *
 *      Returns:
 *              1
 *      Parms:
 *              dev             Device assigned the IRQ that was
 *                              raised.
 *              host_int        The contents of the HOST_INT
 *                              port.
 *
 *      This function handles the Dummy interrupt, which is
 *      raised whenever a test interrupt is generated by setting
 *      the Req_Int bit of HOST_CMD to 1.
 *
 **************************************************************/

static u32 tlan_handle_dummy(struct net_device *dev, u16 host_int)
{
        netdev_info(dev, "Test interrupt\n");
        return 1;

}




/***************************************************************
 *      tlan_handle_tx_eoc
 *
 *      Returns:
 *              1
 *      Parms:
 *              dev             Device assigned the IRQ that was
 *                              raised.
 *              host_int        The contents of the HOST_INT
 *                              port.
 *
 *      This driver is structured to determine EOC occurrences by
 *      reading the CSTAT member of the list structure.  Tx EOC
 *      interrupts are disabled via the DIO INTDIS register.
 *      However, TLAN chips before revision 3.0 didn't have this
 *      functionality, so process EOC events if this is the
 *      case.
 *
 **************************************************************/

static u32 tlan_handle_tx_eoc(struct net_device *dev, u16 host_int)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        struct tlan_list                *head_list;
        dma_addr_t              head_list_phys;
        u32                     ack = 1;

        if (priv->tlan_rev < 0x30) {
                TLAN_DBG(TLAN_DEBUG_TX,
                         "TRANSMIT:  handling TX EOC (Head=%d Tail=%d) -- IRQ\n",
                         priv->tx_head, priv->tx_tail);
                head_list = priv->tx_list + priv->tx_head;
                head_list_phys = priv->tx_list_dma
                        + sizeof(struct tlan_list)*priv->tx_head;
                if ((head_list->c_stat & TLAN_CSTAT_READY)
                    == TLAN_CSTAT_READY) {
                        netif_stop_queue(dev);
                        outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
                        ack |= TLAN_HC_GO;
                } else {
                        priv->tx_in_progress = 0;
                }
        }

        return ack;

}




/***************************************************************
 *      tlan_handle_status_check
 *
 *      Returns:
 *              0 if Adapter check, 1 if Network Status check.
 *      Parms:
 *              dev             Device assigned the IRQ that was
 *                              raised.
 *              host_int        The contents of the HOST_INT
 *                              port.
 *
 *      This function handles Adapter Check/Network Status
 *      interrupts generated by the adapter.  It checks the
 *      vector in the HOST_INT register to determine if it is
 *      an Adapter Check interrupt.  If so, it resets the
 *      adapter.  Otherwise it clears the status registers
 *      and services the PHY.
 *
 **************************************************************/

static u32 tlan_handle_status_check(struct net_device *dev, u16 host_int)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        u32             ack;
        u32             error;
        u8              net_sts;
        u32             phy;
        u16             tlphy_ctl;
        u16             tlphy_sts;

        ack = 1;
        if (host_int & TLAN_HI_IV_MASK) {
                netif_stop_queue(dev);
                error = inl(dev->base_addr + TLAN_CH_PARM);
                netdev_info(dev, "Adaptor Error = 0x%x\n", error);
                tlan_read_and_clear_stats(dev, TLAN_RECORD);
                outl(TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD);

                schedule_work(&priv->tlan_tqueue);

                netif_wake_queue(dev);
                ack = 0;
        } else {
                TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name);
                phy = priv->phy[priv->phy_num];

                net_sts = tlan_dio_read8(dev->base_addr, TLAN_NET_STS);
                if (net_sts) {
                        tlan_dio_write8(dev->base_addr, TLAN_NET_STS, 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->phy_num == 0)) {
                        __tlan_mii_read_reg(dev, phy, TLAN_TLPHY_STS, &tlphy_sts);
                        __tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl);
                        if (!(tlphy_sts & TLAN_TS_POLOK) &&
                            !(tlphy_ctl & TLAN_TC_SWAPOL)) {
                                tlphy_ctl |= TLAN_TC_SWAPOL;
                                __tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL,
                                                     tlphy_ctl);
                        } else if ((tlphy_sts & TLAN_TS_POLOK) &&
                                   (tlphy_ctl & TLAN_TC_SWAPOL)) {
                                tlphy_ctl &= ~TLAN_TC_SWAPOL;
                                __tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL,
                                                     tlphy_ctl);
                        }

                        if (debug)
                                __tlan_phy_print(dev);
                }
        }

        return ack;

}




/***************************************************************
 *      tlan_handle_rx_eoc
 *
 *      Returns:
 *              1
 *      Parms:
 *              dev             Device assigned the IRQ that was
 *                              raised.
 *              host_int        The contents of the HOST_INT
 *                              port.
 *
 *      This driver is structured to determine EOC occurrences by
 *      reading the CSTAT member of the list structure.  Rx EOC
 *      interrupts are disabled via the DIO INTDIS register.
 *      However, TLAN chips before revision 3.0 didn't have this
 *      CSTAT member or a INTDIS register, so if this chip is
 *      pre-3.0, process EOC interrupts normally.
 *
 **************************************************************/

static u32 tlan_handle_rx_eoc(struct net_device *dev, u16 host_int)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        dma_addr_t      head_list_phys;
        u32             ack = 1;

        if (priv->tlan_rev < 0x30) {
                TLAN_DBG(TLAN_DEBUG_RX,
                         "RECEIVE:  Handling RX EOC (head=%d tail=%d) -- IRQ\n",
                         priv->rx_head, priv->rx_tail);
                head_list_phys = priv->rx_list_dma
                        + sizeof(struct tlan_list)*priv->rx_head;
                outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
                ack |= TLAN_HC_GO | TLAN_HC_RT;
                priv->rx_eoc_count++;
        }

        return ack;

}




/*****************************************************************************
******************************************************************************

ThunderLAN driver timer function

******************************************************************************
*****************************************************************************/


/***************************************************************
 *      tlan_timer
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              data    A value given to add timer when
 *                      add_timer was called.
 *
 *      This function handles timed functionality for the
 *      TLAN driver.  The two current timer uses are for
 *      delaying for autonegotionation and driving the ACT LED.
 *      -       Autonegotiation requires being allowed about
 *              2 1/2 seconds before attempting to transmit a
 *              packet.  It would be a very bad thing to hang
 *              the kernel this long, so the driver doesn't
 *              allow transmission 'til after this time, for
 *              certain PHYs.  It would be much nicer if all
 *              PHYs were interrupt-capable like the internal
 *              PHY.
 *      -       The ACT LED, which shows adapter activity, is
 *              driven by the driver, and so must be left on
 *              for a short period to power up the LED so it
 *              can be seen.  This delay can be changed by
 *              changing the TLAN_TIMER_ACT_DELAY in tlan.h,
 *              if desired.  100 ms  produces a slightly
 *              sluggish response.
 *
 **************************************************************/

static void tlan_timer(struct timer_list *t)
{
        struct tlan_priv        *priv = timer_container_of(priv, t, timer);
        struct net_device       *dev = priv->dev;
        u32             elapsed;
        unsigned long   flags = 0;

        priv->timer.function = NULL;

        switch (priv->timer_type) {
        case TLAN_TIMER_PHY_PDOWN:
                tlan_phy_power_down(dev);
                break;
        case TLAN_TIMER_PHY_PUP:
                tlan_phy_power_up(dev);
                break;
        case TLAN_TIMER_PHY_RESET:
                tlan_phy_reset(dev);
                break;
        case TLAN_TIMER_PHY_START_LINK:
                tlan_phy_start_link(dev);
                break;
        case TLAN_TIMER_PHY_FINISH_AN:
                tlan_phy_finish_auto_neg(dev);
                break;
        case TLAN_TIMER_FINISH_RESET:
                tlan_finish_reset(dev);
                break;
        case TLAN_TIMER_ACTIVITY:
                spin_lock_irqsave(&priv->lock, flags);
                if (priv->timer.function == NULL) {
                        elapsed = jiffies - priv->timer_set_at;
                        if (elapsed >= TLAN_TIMER_ACT_DELAY) {
                                tlan_dio_write8(dev->base_addr,
                                                TLAN_LED_REG, TLAN_LED_LINK);
                        } else  {
                                priv->timer.expires = priv->timer_set_at
                                        + TLAN_TIMER_ACT_DELAY;
                                spin_unlock_irqrestore(&priv->lock, flags);
                                add_timer(&priv->timer);
                                break;
                        }
                }
                spin_unlock_irqrestore(&priv->lock, flags);
                break;
        default:
                break;
        }

}


/*****************************************************************************
******************************************************************************

ThunderLAN driver adapter related routines

******************************************************************************
*****************************************************************************/


/***************************************************************
 *      tlan_reset_lists
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              dev     The device structure with the list
 *                      structures to be reset.
 *
 *      This routine sets the variables associated with managing
 *      the TLAN lists to their initial values.
 *
 **************************************************************/

static void tlan_reset_lists(struct net_device *dev)
{
        struct tlan_priv *priv = netdev_priv(dev);
        int             i;
        struct tlan_list        *list;
        dma_addr_t      list_phys;
        struct sk_buff  *skb;

        priv->tx_head = 0;
        priv->tx_tail = 0;
        for (i = 0; i < TLAN_NUM_TX_LISTS; i++) {
                list = priv->tx_list + i;
                list->c_stat = TLAN_CSTAT_UNUSED;
                list->buffer[0].address = 0;
                list->buffer[2].count = 0;
                list->buffer[2].address = 0;
                list->buffer[8].address = 0;
                list->buffer[9].address = 0;
        }

        priv->rx_head = 0;
        priv->rx_tail = TLAN_NUM_RX_LISTS - 1;
        for (i = 0; i < TLAN_NUM_RX_LISTS; i++) {
                list = priv->rx_list + i;
                list_phys = priv->rx_list_dma + sizeof(struct tlan_list)*i;
                list->c_stat = TLAN_CSTAT_READY;
                list->frame_size = TLAN_MAX_FRAME_SIZE;
                list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
                skb = netdev_alloc_skb_ip_align(dev, TLAN_MAX_FRAME_SIZE + 5);
                if (!skb)
                        break;

                list->buffer[0].address = dma_map_single(&priv->pci_dev->dev,
                                                         skb->data,
                                                         TLAN_MAX_FRAME_SIZE,
                                                         DMA_FROM_DEVICE);
                tlan_store_skb(list, skb);
                list->buffer[1].count = 0;
                list->buffer[1].address = 0;
                list->forward = list_phys + sizeof(struct tlan_list);
        }

        /* in case ran out of memory early, clear bits */
        while (i < TLAN_NUM_RX_LISTS) {
                tlan_store_skb(priv->rx_list + i, NULL);
                ++i;
        }
        list->forward = 0;

}


static void tlan_free_lists(struct net_device *dev)
{
        struct tlan_priv *priv = netdev_priv(dev);
        int             i;
        struct tlan_list        *list;
        struct sk_buff  *skb;

        for (i = 0; i < TLAN_NUM_TX_LISTS; i++) {
                list = priv->tx_list + i;
                skb = tlan_get_skb(list);
                if (skb) {
                        dma_unmap_single(&priv->pci_dev->dev,
                                         list->buffer[0].address,
                                         max(skb->len, (unsigned int)TLAN_MIN_FRAME_SIZE),
                                         DMA_TO_DEVICE);
                        dev_kfree_skb_any(skb);
                        list->buffer[8].address = 0;
                        list->buffer[9].address = 0;
                }
        }

        for (i = 0; i < TLAN_NUM_RX_LISTS; i++) {
                list = priv->rx_list + i;
                skb = tlan_get_skb(list);
                if (skb) {
                        dma_unmap_single(&priv->pci_dev->dev,
                                         list->buffer[0].address,
                                         TLAN_MAX_FRAME_SIZE, DMA_FROM_DEVICE);
                        dev_kfree_skb_any(skb);
                        list->buffer[8].address = 0;
                        list->buffer[9].address = 0;
                }
        }
}




/***************************************************************
 *      tlan_print_dio
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              io_base         Base IO port of the device of
 *                              which to print DIO registers.
 *
 *      This function prints out all the internal (DIO)
 *      registers of a TLAN chip.
 *
 **************************************************************/

static void tlan_print_dio(u16 io_base)
{
        u32 data0, data1;
        int     i;

        pr_info("Contents of internal registers for io base 0x%04hx\n",
                io_base);
        pr_info("Off.  +0        +4\n");
        for (i = 0; i < 0x4C; i += 8) {
                data0 = tlan_dio_read32(io_base, i);
                data1 = tlan_dio_read32(io_base, i + 0x4);
                pr_info("0x%02x  0x%08x 0x%08x\n", i, data0, data1);
        }

}




/***************************************************************
 *      TLan_PrintList
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              list    A pointer to the struct tlan_list structure to
 *                      be printed.
 *              type    A string to designate type of list,
 *                      "Rx" or "Tx".
 *              num     The index of the list.
 *
 *      This function prints out the contents of the list
 *      pointed to by the list parameter.
 *
 **************************************************************/

static void tlan_print_list(struct tlan_list *list, char *type, int num)
{
        int i;

        pr_info("%s List %d at %p\n", type, num, list);
        pr_info("   Forward    = 0x%08x\n",  list->forward);
        pr_info("   CSTAT      = 0x%04hx\n", list->c_stat);
        pr_info("   Frame Size = 0x%04hx\n", list->frame_size);
        /* for (i = 0; i < 10; i++) { */
        for (i = 0; i < 2; i++) {
                pr_info("   Buffer[%d].count, addr = 0x%08x, 0x%08x\n",
                        i, list->buffer[i].count, list->buffer[i].address);
        }

}




/***************************************************************
 *      tlan_read_and_clear_stats
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              dev     Pointer to device structure of adapter
 *                      to which to read stats.
 *              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.
 *      It then either adds the values to the device's status
 *      struct, or discards them, depending on whether record
 *      is TLAN_RECORD (!=0)  or TLAN_IGNORE (==0).
 *
 **************************************************************/

static void tlan_read_and_clear_stats(struct net_device *dev, int record)
{
        u32             tx_good, tx_under;
        u32             rx_good, rx_over;
        u32             def_tx, crc, code;
        u32             multi_col, single_col;
        u32             excess_col, late_col, loss;

        outw(TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR);
        tx_good  = inb(dev->base_addr + TLAN_DIO_DATA);
        tx_good += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
        tx_good += inb(dev->base_addr + TLAN_DIO_DATA + 2) << 16;
        tx_under = inb(dev->base_addr + TLAN_DIO_DATA + 3);

        outw(TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR);
        rx_good  = inb(dev->base_addr + TLAN_DIO_DATA);
        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;
        single_col  = inb(dev->base_addr + TLAN_DIO_DATA + 2);
        single_col += inb(dev->base_addr + TLAN_DIO_DATA + 3) << 8;

        outw(TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR);
        excess_col = inb(dev->base_addr + TLAN_DIO_DATA);
        late_col   = inb(dev->base_addr + TLAN_DIO_DATA + 1);
        loss       = inb(dev->base_addr + TLAN_DIO_DATA + 2);

        if (record) {
                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;

                dev->stats.rx_over_errors    += rx_over;
                dev->stats.rx_crc_errors     += crc;
                dev->stats.rx_frame_errors   += code;

                dev->stats.tx_aborted_errors += tx_under;
                dev->stats.tx_carrier_errors += loss;
        }

}




/***************************************************************
 *      TLan_Reset
 *
 *      Returns:
 *              0
 *      Parms:
 *              dev     Pointer to device structure of adapter
 *                      to be reset.
 *
 *      This function resets the adapter and it's physical
 *      device.  See Chap. 3, pp. 9-10 of the "ThunderLAN
 *      Programmer's Guide" for details.  The routine tries to
 *      implement what is detailed there, though adjustments
 *      have been made.
 *
 **************************************************************/

static void
tlan_reset_adapter(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        int             i;
        u32             addr;
        u32             data;
        u8              data8;

        priv->tlan_full_duplex = false;
        priv->phy_online = 0;
        netif_carrier_off(dev);

/*  1.  Assert reset bit. */

        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) */

        data = inl(dev->base_addr + TLAN_HOST_CMD);
        data |= TLAN_HC_INT_OFF;
        outl(data, dev->base_addr + TLAN_HOST_CMD);

/*  3.  Clear AREGs and HASHs. */

        for (i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4)
                tlan_dio_write32(dev->base_addr, (u16) i, 0);

/*  4.  Setup NetConfig register. */

        data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
        tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, (u16) data);

/*  5.  Load Ld_Tmr and Ld_Thr in HOST_CMD. */

        outl(TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD);
        outl(TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD);

/*  6.  Unreset the MII by setting NMRST (in NetSio) to 1. */

        outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
        addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
        tlan_set_bit(TLAN_NET_SIO_NMRST, addr);

/*  7.  Setup the remaining registers. */

        if (priv->tlan_rev >= 0x30) {
                data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
                tlan_dio_write8(dev->base_addr, TLAN_INT_DIS, data8);
        }
        tlan_phy_detect(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) {
                        tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x0a);
                } else if (priv->duplex == TLAN_DUPLEX_FULL) {
                        tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x00);
                        priv->tlan_full_duplex = true;
                } else {
                        tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x08);
                }
        }

        /* don't power down internal PHY if we're going to use it */
        if (priv->phy_num == 0 ||
           (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10))
                data |= TLAN_NET_CFG_PHY_EN;
        tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, (u16) data);

        if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY)
                tlan_finish_reset(dev);
        else
                tlan_phy_power_down(dev);

}




static void
tlan_finish_reset(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        u8              data;
        u32             phy;
        u8              sio;
        u16             status;
        u16             partner;
        u16             tlphy_ctl;
        u16             tlphy_par;
        u16             tlphy_id1, tlphy_id2;
        int             i;

        phy = priv->phy[priv->phy_num];

        data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
        if (priv->tlan_full_duplex)
                data |= TLAN_NET_CMD_DUPLEX;
        tlan_dio_write8(dev->base_addr, TLAN_NET_CMD, data);
        data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
        if (priv->phy_num == 0)
                data |= TLAN_NET_MASK_MASK7;
        tlan_dio_write8(dev->base_addr, TLAN_NET_MASK, data);
        tlan_dio_write16(dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7);
        tlan_mii_read_reg(dev, phy, MII_GEN_ID_HI, &tlphy_id1);
        tlan_mii_read_reg(dev, phy, MII_GEN_ID_LO, &tlphy_id2);

        if ((priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) ||
            (priv->aui)) {
                status = MII_GS_LINK;
                netdev_info(dev, "Link forced\n");
        } else {
                tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
                udelay(1000);
                tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
                if (status & MII_GS_LINK) {
                        /* We only support link info on Nat.Sem. PHY's */
                        if ((tlphy_id1 == NAT_SEM_ID1) &&
                            (tlphy_id2 == NAT_SEM_ID2)) {
                                tlan_mii_read_reg(dev, phy, MII_AN_LPA,
                                        &partner);
                                tlan_mii_read_reg(dev, phy, TLAN_TLPHY_PAR,
                                        &tlphy_par);

                                netdev_info(dev,
                                        "Link active, %s %uMbps %s-Duplex\n",
                                        !(tlphy_par & TLAN_PHY_AN_EN_STAT)
                                        ? "forced" : "Autonegotiation enabled,",
                                        tlphy_par & TLAN_PHY_SPEED_100
                                        ? 100 : 10,
                                        tlphy_par & TLAN_PHY_DUPLEX_FULL
                                        ? "Full" : "Half");

                                if (tlphy_par & TLAN_PHY_AN_EN_STAT) {
                                        netdev_info(dev, "Partner capability:");
                                        for (i = 5; i < 10; i++)
                                                if (partner & (1 << i))
                                                        pr_cont(" %s",
                                                                media[i-5]);
                                        pr_cont("\n");
                                }
                        } else
                                netdev_info(dev, "Link active\n");
                        /* Enabling link beat monitoring */
                        priv->media_timer.expires = jiffies + HZ;
                        add_timer(&priv->media_timer);
                }
        }

        if (priv->phy_num == 0) {
                tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl);
                tlphy_ctl |= TLAN_TC_INTEN;
                tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
                sio = tlan_dio_read8(dev->base_addr, TLAN_NET_SIO);
                sio |= TLAN_NET_SIO_MINTEN;
                tlan_dio_write8(dev->base_addr, TLAN_NET_SIO, sio);
        }

        if (status & MII_GS_LINK) {
                tlan_set_mac(dev, 0, dev->dev_addr);
                priv->phy_online = 1;
                outb((TLAN_HC_INT_ON >> 8), dev->base_addr + TLAN_HOST_CMD + 1);
                if (debug >= 1 && debug != TLAN_DEBUG_PROBE)
                        outb((TLAN_HC_REQ_INT >> 8),
                             dev->base_addr + TLAN_HOST_CMD + 1);
                outl(priv->rx_list_dma, dev->base_addr + TLAN_CH_PARM);
                outl(TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD);
                tlan_dio_write8(dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK);
                netif_carrier_on(dev);
        } else {
                netdev_info(dev, "Link inactive, will retry in 10 secs...\n");
                tlan_set_timer(dev, (10*HZ), TLAN_TIMER_FINISH_RESET);
                return;
        }
        tlan_set_multicast_list(dev);

}




/***************************************************************
 *      tlan_set_mac
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              dev     Pointer to device structure of adapter
 *                      on which to change the AREG.
 *              areg    The AREG to set the address in (0 - 3).
 *              mac     A pointer to an array of chars.  Each
 *                      element stores one byte of the address.
 *                      IE, it isn't in ascii.
 *
 *      This function transfers a MAC address to one of the
 *      TLAN AREGs (address registers).  The TLAN chip locks
 *      the register on writing to offset 0 and unlocks the
 *      register after writing to offset 5.  If NULL is passed
 *      in mac, then the AREG is filled with 0's.
 *
 **************************************************************/

static void tlan_set_mac(struct net_device *dev, int areg, const char *mac)
{
        int i;

        areg *= 6;

        if (mac != NULL) {
                for (i = 0; i < 6; i++)
                        tlan_dio_write8(dev->base_addr,
                                        TLAN_AREG_0 + areg + i, mac[i]);
        } else {
                for (i = 0; i < 6; i++)
                        tlan_dio_write8(dev->base_addr,
                                        TLAN_AREG_0 + areg + i, 0);
        }

}




/*****************************************************************************
******************************************************************************

ThunderLAN driver PHY layer routines

******************************************************************************
*****************************************************************************/



/*********************************************************************
 *      __tlan_phy_print
 *
 *      Returns:
 *              Nothing
 *      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).
 *
 ********************************************************************/

static void __tlan_phy_print(struct net_device *dev)
{
        struct tlan_priv *priv = netdev_priv(dev);
        u16 i, data0, data1, data2, data3, phy;

        lockdep_assert_held(&priv->lock);

        phy = priv->phy[priv->phy_num];

        if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) {
                netdev_info(dev, "Unmanaged PHY\n");
        } else if (phy <= TLAN_PHY_MAX_ADDR) {
                netdev_info(dev, "PHY 0x%02x\n", phy);
                pr_info("   Off.  +0     +1     +2     +3\n");
                for (i = 0; i < 0x20; i += 4) {
                        __tlan_mii_read_reg(dev, phy, i, &data0);
                        __tlan_mii_read_reg(dev, phy, i + 1, &data1);
                        __tlan_mii_read_reg(dev, phy, i + 2, &data2);
                        __tlan_mii_read_reg(dev, phy, i + 3, &data3);
                        pr_info("   0x%02x 0x%04hx 0x%04hx 0x%04hx 0x%04hx\n",
                                i, data0, data1, data2, data3);
                }
        } else {
                netdev_info(dev, "Invalid PHY\n");
        }

}

static void tlan_phy_print(struct net_device *dev)
{
        struct tlan_priv *priv = netdev_priv(dev);
        unsigned long flags;

        spin_lock_irqsave(&priv->lock, flags);
        __tlan_phy_print(dev);
        spin_unlock_irqrestore(&priv->lock, flags);
}


/*********************************************************************
 *      tlan_phy_detect
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              dev     A pointer to the device structure of the adapter
 *                      for which the PHY needs determined.
 *
 *      So far I've found that adapters which have external PHYs
 *      may also use the internal PHY for part of the functionality.
 *      (eg, AUI/Thinnet).  This function finds out if this TLAN
 *      chip has an internal PHY, and then finds the first external
 *      PHY (starting from address 0) if it exists).
 *
 ********************************************************************/

static void tlan_phy_detect(struct net_device *dev)
{
        struct tlan_priv *priv = netdev_priv(dev);
        u16             control;
        u16             hi;
        u16             lo;
        u32             phy;

        if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) {
                priv->phy_num = 0xffff;
                return;
        }

        tlan_mii_read_reg(dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi);

        if (hi != 0xffff)
                priv->phy[0] = TLAN_PHY_MAX_ADDR;
        else
                priv->phy[0] = TLAN_PHY_NONE;

        priv->phy[1] = TLAN_PHY_NONE;
        for (phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++) {
                tlan_mii_read_reg(dev, phy, MII_GEN_CTL, &control);
                tlan_mii_read_reg(dev, phy, MII_GEN_ID_HI, &hi);
                tlan_mii_read_reg(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)) {
                                priv->phy[1] = phy;
                        }
                }
        }

        if (priv->phy[1] != TLAN_PHY_NONE)
                priv->phy_num = 1;
        else if (priv->phy[0] != TLAN_PHY_NONE)
                priv->phy_num = 0;
        else
                netdev_info(dev, "Cannot initialize device, no PHY was found!\n");

}




static void tlan_phy_power_down(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        u16             value;

        TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name);
        value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
        tlan_mii_sync(dev->base_addr);
        tlan_mii_write_reg(dev, priv->phy[priv->phy_num], MII_GEN_CTL, value);
        if ((priv->phy_num == 0) && (priv->phy[1] != TLAN_PHY_NONE)) {
                /* if using internal PHY, the external PHY must be powered on */
                if (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10)
                        value = MII_GC_ISOLATE; /* just isolate it from MII */
                tlan_mii_sync(dev->base_addr);
                tlan_mii_write_reg(dev, priv->phy[1], MII_GEN_CTL, value);
        }

        /* Wait for 50 ms and powerup
         * This is arbitrary.  It is intended to make sure the
         * transceiver settles.
         */
        tlan_set_timer(dev, msecs_to_jiffies(50), TLAN_TIMER_PHY_PUP);

}




static void tlan_phy_power_up(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        u16             value;

        TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name);
        tlan_mii_sync(dev->base_addr);
        value = MII_GC_LOOPBK;
        tlan_mii_write_reg(dev, priv->phy[priv->phy_num], MII_GEN_CTL, value);
        tlan_mii_sync(dev->base_addr);
        /* Wait for 500 ms and reset the
         * transceiver.  The TLAN docs say both 50 ms and
         * 500 ms, so do the longer, just in case.
         */
        tlan_set_timer(dev, msecs_to_jiffies(500), TLAN_TIMER_PHY_RESET);

}




static void tlan_phy_reset(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        u16             phy;
        u16             value;
        unsigned long timeout = jiffies + HZ;

        phy = priv->phy[priv->phy_num];

        TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Resetting PHY.\n", dev->name);
        tlan_mii_sync(dev->base_addr);
        value = MII_GC_LOOPBK | MII_GC_RESET;
        tlan_mii_write_reg(dev, phy, MII_GEN_CTL, value);
        do {
                tlan_mii_read_reg(dev, phy, MII_GEN_CTL, &value);
                if (time_after(jiffies, timeout)) {
                        netdev_err(dev, "PHY reset timeout\n");
                        return;
                }
        } while (value & MII_GC_RESET);

        /* Wait for 500 ms and initialize.
         * I don't remember why I wait this long.
         * I've changed this to 50ms, as it seems long enough.
         */
        tlan_set_timer(dev, msecs_to_jiffies(50), TLAN_TIMER_PHY_START_LINK);

}




static void tlan_phy_start_link(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        u16             ability;
        u16             control;
        u16             data;
        u16             phy;
        u16             status;
        u16             tctl;

        phy = priv->phy[priv->phy_num];
        TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name);
        tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
        tlan_mii_read_reg(dev, phy, MII_GEN_STS, &ability);

        if ((status & MII_GS_AUTONEG) &&
            (!priv->aui)) {
                ability = status >> 11;
                if (priv->speed  == TLAN_SPEED_10 &&
                    priv->duplex == TLAN_DUPLEX_HALF) {
                        tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x0000);
                } else if (priv->speed == TLAN_SPEED_10 &&
                           priv->duplex == TLAN_DUPLEX_FULL) {
                        priv->tlan_full_duplex = true;
                        tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x0100);
                } else if (priv->speed == TLAN_SPEED_100 &&
                           priv->duplex == TLAN_DUPLEX_HALF) {
                        tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x2000);
                } else if (priv->speed == TLAN_SPEED_100 &&
                           priv->duplex == TLAN_DUPLEX_FULL) {
                        priv->tlan_full_duplex = true;
                        tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x2100);
                } else {

                        /* Set Auto-Neg advertisement */
                        tlan_mii_write_reg(dev, phy, MII_AN_ADV,
                                           (ability << 5) | 1);
                        /* Enablee Auto-Neg */
                        tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x1000);
                        /* Restart Auto-Neg */
                        tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x1200);
                        /* Wait for 4 sec for autonegotiation
                         * to complete.  The max spec time is less than this
                         * but the card need additional time to start AN.
                         * .5 sec should be plenty extra.
                         */
                        netdev_info(dev, "Starting autonegotiation\n");
                        tlan_set_timer(dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN);
                        return;
                }

        }

        if ((priv->aui) && (priv->phy_num != 0)) {
                priv->phy_num = 0;
                data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN
                        | TLAN_NET_CFG_PHY_EN;
                tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, data);
                tlan_set_timer(dev, msecs_to_jiffies(40), TLAN_TIMER_PHY_PDOWN);
                return;
        } else if (priv->phy_num == 0) {
                control = 0;
                tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tctl);
                if (priv->aui) {
                        tctl |= TLAN_TC_AUISEL;
                } else {
                        tctl &= ~TLAN_TC_AUISEL;
                        if (priv->duplex == TLAN_DUPLEX_FULL) {
                                control |= MII_GC_DUPLEX;
                                priv->tlan_full_duplex = true;
                        }
                        if (priv->speed == TLAN_SPEED_100)
                                control |= MII_GC_SPEEDSEL;
                }
                tlan_mii_write_reg(dev, phy, MII_GEN_CTL, control);
                tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL, tctl);
        }

        /* Wait for 2 sec to give the transceiver time
         * to establish link.
         */
        tlan_set_timer(dev, (4*HZ), TLAN_TIMER_FINISH_RESET);

}




static void tlan_phy_finish_auto_neg(struct net_device *dev)
{
        struct tlan_priv        *priv = netdev_priv(dev);
        u16             an_adv;
        u16             an_lpa;
        u16             mode;
        u16             phy;
        u16             status;

        phy = priv->phy[priv->phy_num];

        tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
        udelay(1000);
        tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);

        if (!(status & MII_GS_AUTOCMPLT)) {
                /* Wait for 8 sec to give the process
                 * more time.  Perhaps we should fail after a while.
                 */
                tlan_set_timer(dev, 2 * HZ, TLAN_TIMER_PHY_FINISH_AN);
                return;
        }

        netdev_info(dev, "Autonegotiation complete\n");
        tlan_mii_read_reg(dev, phy, MII_AN_ADV, &an_adv);
        tlan_mii_read_reg(dev, phy, MII_AN_LPA, &an_lpa);
        mode = an_adv & an_lpa & 0x03E0;
        if (mode & 0x0100)
                priv->tlan_full_duplex = true;
        else if (!(mode & 0x0080) && (mode & 0x0040))
                priv->tlan_full_duplex = true;

        /* switch to internal PHY for 10 Mbps */
        if ((!(mode & 0x0180)) &&
            (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10) &&
            (priv->phy_num != 0)) {
                priv->phy_num = 0;
                tlan_set_timer(dev, msecs_to_jiffies(400), TLAN_TIMER_PHY_PDOWN);
                return;
        }

        if (priv->phy_num == 0) {
                if ((priv->duplex == TLAN_DUPLEX_FULL) ||
                    (an_adv & an_lpa & 0x0040)) {
                        tlan_mii_write_reg(dev, phy, MII_GEN_CTL,
                                           MII_GC_AUTOENB | MII_GC_DUPLEX);
                        netdev_info(dev, "Starting internal PHY with FULL-DUPLEX\n");
                } else {
                        tlan_mii_write_reg(dev, phy, MII_GEN_CTL,
                                           MII_GC_AUTOENB);
                        netdev_info(dev, "Starting internal PHY with HALF-DUPLEX\n");
                }
        }

        /* Wait for 100 ms.  No reason in partiticular.
         */
        tlan_set_timer(dev, msecs_to_jiffies(100), TLAN_TIMER_FINISH_RESET);

}


/*********************************************************************
 *
 *     tlan_phy_monitor
 *
 *     Returns:
 *            None
 *
 *     Params:
 *            data           The device structure of this device.
 *
 *
 *     This function monitors PHY condition by reading the status
 *     register via the MII bus, controls LINK LED and notifies the
 *     kernel about link state.
 *
 *******************************************************************/

static void tlan_phy_monitor(struct timer_list *t)
{
        struct tlan_priv *priv = timer_container_of(priv, t, media_timer);
        struct net_device *dev = priv->dev;
        u16     phy;
        u16     phy_status;

        phy = priv->phy[priv->phy_num];

        /* Get PHY status register */
        tlan_mii_read_reg(dev, phy, MII_GEN_STS, &phy_status);

        /* Check if link has been lost */
        if (!(phy_status & MII_GS_LINK)) {
                if (netif_carrier_ok(dev)) {
                        printk(KERN_DEBUG "TLAN: %s has lost link\n",
                               dev->name);
                        tlan_dio_write8(dev->base_addr, TLAN_LED_REG, 0);
                        netif_carrier_off(dev);
                        if (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10) {
                                /* power down internal PHY */
                                u16 data = MII_GC_PDOWN | MII_GC_LOOPBK |
                                           MII_GC_ISOLATE;

                                tlan_mii_sync(dev->base_addr);
                                tlan_mii_write_reg(dev, priv->phy[0],
                                                   MII_GEN_CTL, data);
                                /* set to external PHY */
                                priv->phy_num = 1;
                                /* restart autonegotiation */
                                tlan_set_timer(dev, msecs_to_jiffies(400),
                                               TLAN_TIMER_PHY_PDOWN);
                                return;
                        }
                }
        }

        /* Link restablished? */
        if ((phy_status & MII_GS_LINK) && !netif_carrier_ok(dev)) {
                tlan_dio_write8(dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK);
                printk(KERN_DEBUG "TLAN: %s has reestablished link\n",
                       dev->name);
                netif_carrier_on(dev);
        }
        priv->media_timer.expires = jiffies + HZ;
        add_timer(&priv->media_timer);
}


/*****************************************************************************
******************************************************************************

ThunderLAN driver MII routines

these routines are based on the information in chap. 2 of the
"ThunderLAN Programmer's Guide", pp. 15-24.

******************************************************************************
*****************************************************************************/


/***************************************************************
 *      __tlan_mii_read_reg
 *
 *      Returns:
 *              false   if ack received ok
 *              true    if no ack received or other error
 *
 *      Parms:
 *              dev             The device structure containing
 *                              The io address and interrupt count
 *                              for this device.
 *              phy             The address of the PHY to be queried.
 *              reg             The register whose contents are to be
 *                              retrieved.
 *              val             A pointer to a variable to store the
 *                              retrieved value.
 *
 *      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.
 *
 **************************************************************/

static bool
__tlan_mii_read_reg(struct net_device *dev, u16 phy, u16 reg, u16 *val)
{
        u8      nack;
        u16     sio, tmp;
        u32     i;
        bool    err;
        int     minten;
        struct tlan_priv *priv = netdev_priv(dev);

        lockdep_assert_held(&priv->lock);

        err = false;
        outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
        sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;

        tlan_mii_sync(dev->base_addr);

        minten = tlan_get_bit(TLAN_NET_SIO_MINTEN, sio);
        if (minten)
                tlan_clear_bit(TLAN_NET_SIO_MINTEN, sio);

        tlan_mii_send_data(dev->base_addr, 0x1, 2);     /* start (01b) */
        tlan_mii_send_data(dev->base_addr, 0x2, 2);     /* read  (10b) */
        tlan_mii_send_data(dev->base_addr, phy, 5);     /* device #      */
        tlan_mii_send_data(dev->base_addr, reg, 5);     /* register #    */


        tlan_clear_bit(TLAN_NET_SIO_MTXEN, sio);        /* change direction */

        tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);         /* clock idle bit */
        tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
        tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);         /* wait 300ns */

        nack = tlan_get_bit(TLAN_NET_SIO_MDATA, sio);   /* check for ACK */
        tlan_set_bit(TLAN_NET_SIO_MCLK, sio);           /* finish ACK */
        if (nack) {                                     /* no ACK, so fake it */
                for (i = 0; i < 16; i++) {
                        tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
                        tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
                }
                tmp = 0xffff;
                err = true;
        } else {                                        /* ACK, so read data */
                for (tmp = 0, i = 0x8000; i; i >>= 1) {
                        tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
                        if (tlan_get_bit(TLAN_NET_SIO_MDATA, sio))
                                tmp |= i;
                        tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
                }
        }


        tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);         /* idle cycle */
        tlan_set_bit(TLAN_NET_SIO_MCLK, sio);

        if (minten)
                tlan_set_bit(TLAN_NET_SIO_MINTEN, sio);

        *val = tmp;

        return err;
}

static void tlan_mii_read_reg(struct net_device *dev, u16 phy, u16 reg,
                              u16 *val)
{
        struct tlan_priv *priv = netdev_priv(dev);
        unsigned long flags;

        spin_lock_irqsave(&priv->lock, flags);
        __tlan_mii_read_reg(dev, phy, reg, val);
        spin_unlock_irqrestore(&priv->lock, flags);
}

/***************************************************************
 *      tlan_mii_send_data
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              base_port       The base IO port of the adapter in
 *                              question.
 *              dev             The address of the PHY to be queried.
 *              data            The value to be placed on the MII bus.
 *              num_bits        The number of bits in data that are to
 *                              be placed on the MII bus.
 *
 *      This function sends on sequence of bits on the MII
 *      configuration bus.
 *
 **************************************************************/

static void tlan_mii_send_data(u16 base_port, u32 data, unsigned num_bits)
{
        u16 sio;
        u32 i;

        if (num_bits == 0)
                return;

        outw(TLAN_NET_SIO, base_port + TLAN_DIO_ADR);
        sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
        tlan_set_bit(TLAN_NET_SIO_MTXEN, sio);

        for (i = (0x1 << (num_bits - 1)); i; i >>= 1) {
                tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
                (void) tlan_get_bit(TLAN_NET_SIO_MCLK, sio);
                if (data & i)
                        tlan_set_bit(TLAN_NET_SIO_MDATA, sio);
                else
                        tlan_clear_bit(TLAN_NET_SIO_MDATA, sio);
                tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
                (void) tlan_get_bit(TLAN_NET_SIO_MCLK, sio);
        }

}




/***************************************************************
 *      TLan_MiiSync
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              base_port       The base IO port of the adapter in
 *                              question.
 *
 *      This functions syncs all PHYs in terms of the MII configuration
 *      bus.
 *
 **************************************************************/

static void tlan_mii_sync(u16 base_port)
{
        int i;
        u16 sio;

        outw(TLAN_NET_SIO, base_port + TLAN_DIO_ADR);
        sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;

        tlan_clear_bit(TLAN_NET_SIO_MTXEN, sio);
        for (i = 0; i < 32; i++) {
                tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
                tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
        }

}




/***************************************************************
 *      __tlan_mii_write_reg
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              dev             The device structure for the device
 *                              to write to.
 *              phy             The address of the PHY to be written to.
 *              reg             The register whose contents are to be
 *                              written.
 *              val             The value to be written to the register.
 *
 *      This function uses the TLAN's MII bus to write the contents of a
 *      given register on a PHY.  It sends the appropriate info and then
 *      writes the 16-bit register value from the MII configuration bus
 *      via the TLAN SIO register.
 *
 **************************************************************/

static void
__tlan_mii_write_reg(struct net_device *dev, u16 phy, u16 reg, u16 val)
{
        u16     sio;
        int     minten;
        struct tlan_priv *priv = netdev_priv(dev);

        lockdep_assert_held(&priv->lock);

        outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
        sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;

        tlan_mii_sync(dev->base_addr);

        minten = tlan_get_bit(TLAN_NET_SIO_MINTEN, sio);
        if (minten)
                tlan_clear_bit(TLAN_NET_SIO_MINTEN, sio);

        tlan_mii_send_data(dev->base_addr, 0x1, 2);     /* start (01b) */
        tlan_mii_send_data(dev->base_addr, 0x1, 2);     /* write (01b) */
        tlan_mii_send_data(dev->base_addr, phy, 5);     /* device #      */
        tlan_mii_send_data(dev->base_addr, reg, 5);     /* register #    */

        tlan_mii_send_data(dev->base_addr, 0x2, 2);     /* send ACK */
        tlan_mii_send_data(dev->base_addr, val, 16);    /* send data */

        tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* idle cycle */
        tlan_set_bit(TLAN_NET_SIO_MCLK, sio);

        if (minten)
                tlan_set_bit(TLAN_NET_SIO_MINTEN, sio);

}

static void
tlan_mii_write_reg(struct net_device *dev, u16 phy, u16 reg, u16 val)
{
        struct tlan_priv *priv = netdev_priv(dev);
        unsigned long flags;

        spin_lock_irqsave(&priv->lock, flags);
        __tlan_mii_write_reg(dev, phy, reg, val);
        spin_unlock_irqrestore(&priv->lock, flags);
}


/*****************************************************************************
******************************************************************************

ThunderLAN driver eeprom routines

the Compaq netelligent 10 and 10/100 cards use a microchip 24C02A
EEPROM.  these functions are based on information in microchip's
data sheet.  I don't know how well this functions will work with
other Eeproms.

******************************************************************************
*****************************************************************************/


/***************************************************************
 *      tlan_ee_send_start
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              io_base         The IO port base address for the
 *                              TLAN device with the EEPROM to
 *                              use.
 *
 *      This function sends a start cycle to an EEPROM attached
 *      to a TLAN chip.
 *
 **************************************************************/

static void tlan_ee_send_start(u16 io_base)
{
        u16     sio;

        outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
        sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;

        tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
        tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
        tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);
        tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
        tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);

}




/***************************************************************
 *      tlan_ee_send_byte
 *
 *      Returns:
 *              If the correct ack was received, 0, otherwise 1
 *      Parms:  io_base         The IO port base address for the
 *                              TLAN device with the EEPROM to
 *                              use.
 *              data            The 8 bits of information to
 *                              send to the EEPROM.
 *              stop            If TLAN_EEPROM_STOP is passed, a
 *                              stop cycle is sent after the
 *                              byte is sent after the ack is
 *                              read.
 *
 *      This function sends a byte on the serial EEPROM line,
 *      driving the clock to send each bit. The function then
 *      reverses transmission direction and reads an acknowledge
 *      bit.
 *
 **************************************************************/

static int tlan_ee_send_byte(u16 io_base, u8 data, int stop)
{
        int     err;
        u8      place;
        u16     sio;

        outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
        sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;

        /* Assume clock is low, tx is enabled; */
        for (place = 0x80; place != 0; place >>= 1) {
                if (place & data)
                        tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
                else
                        tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
                tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
                tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
        }
        tlan_clear_bit(TLAN_NET_SIO_ETXEN, sio);
        tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
        err = tlan_get_bit(TLAN_NET_SIO_EDATA, sio);
        tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
        tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);

        if ((!err) && stop) {
                /* STOP, raise data while clock is high */
                tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
                tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
                tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
        }

        return err;

}




/***************************************************************
 *      tlan_ee_receive_byte
 *
 *      Returns:
 *              Nothing
 *      Parms:
 *              io_base         The IO port base address for the
 *                              TLAN device with the EEPROM to
 *                              use.
 *              data            An address to a char to hold the
 *                              data sent from the EEPROM.
 *              stop            If TLAN_EEPROM_STOP is passed, a
 *                              stop cycle is sent after the
 *                              byte is received, and no ack is
 *                              sent.
 *
 *      This function receives 8 bits of data from the EEPROM
 *      over the serial link.  It then sends and ack bit, or no
 *      ack and a stop bit.  This function is used to retrieve
 *      data after the address of a byte in the EEPROM has been
 *      sent.
 *
 **************************************************************/

static void tlan_ee_receive_byte(u16 io_base, u8 *data, int stop)
{
        u8  place;
        u16 sio;

        outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
        sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
        *data = 0;

        /* Assume clock is low, tx is enabled; */
        tlan_clear_bit(TLAN_NET_SIO_ETXEN, sio);
        for (place = 0x80; place; place >>= 1) {
                tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
                if (tlan_get_bit(TLAN_NET_SIO_EDATA, sio))
                        *data |= place;
                tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
        }

        tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);
        if (!stop) {
                tlan_clear_bit(TLAN_NET_SIO_EDATA, sio); /* ack = 0 */
                tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
                tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
        } else {
                tlan_set_bit(TLAN_NET_SIO_EDATA, sio);  /* no ack = 1 (?) */
                tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
                tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
                /* STOP, raise data while clock is high */
                tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
                tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
                tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
        }

}




/***************************************************************
 *      tlan_ee_read_byte
 *
 *      Returns:
 *              No error = 0, else, the stage at which the error
 *              occurred.
 *      Parms:
 *              io_base         The IO port base address for the
 *                              TLAN device with the EEPROM to
 *                              use.
 *              ee_addr         The address of the byte in the
 *                              EEPROM whose contents are to be
 *                              retrieved.
 *              data            An address to a char to hold the
 *                              data obtained from the EEPROM.
 *
 *      This function reads a byte of information from an byte
 *      cell in the EEPROM.
 *
 **************************************************************/

static int tlan_ee_read_byte(struct net_device *dev, u8 ee_addr, u8 *data)
{
        int err;
        struct tlan_priv *priv = netdev_priv(dev);
        unsigned long flags = 0;
        int ret = 0;

        spin_lock_irqsave(&priv->lock, flags);

        tlan_ee_send_start(dev->base_addr);
        err = tlan_ee_send_byte(dev->base_addr, 0xa0, TLAN_EEPROM_ACK);
        if (err) {
                ret = 1;
                goto fail;
        }
        err = tlan_ee_send_byte(dev->base_addr, ee_addr, TLAN_EEPROM_ACK);
        if (err) {
                ret = 2;
                goto fail;
        }
        tlan_ee_send_start(dev->base_addr);
        err = tlan_ee_send_byte(dev->base_addr, 0xa1, TLAN_EEPROM_ACK);
        if (err) {
                ret = 3;
                goto fail;
        }
        tlan_ee_receive_byte(dev->base_addr, data, TLAN_EEPROM_STOP);
fail:
        spin_unlock_irqrestore(&priv->lock, flags);

        return ret;

}