#define EB51

#ifdef EB50
#define __unused __attribute__((unused))
#endif

/**************************************************************************
*
*    tlan.c -- Etherboot device driver for the Texas Instruments ThunderLAN
*    Written 2003-2003 by Timothy Legge <tlegge@rogers.com>
*
*    This program is free software; you can redistribute it and/or modify
*    it under the terms of the GNU General Public License as published by
*    the Free Software Foundation; either version 2 of the License, or
*    (at your option) any later version.
*
*    This program is distributed in the hope that it will be useful,
*    but WITHOUT ANY WARRANTY; without even the implied warranty of
*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*    GNU General Public License for more details.
*
*    You should have received a copy of the GNU General Public License
*    along with this program; if not, write to the Free Software
*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*    Portions of this code based on:
*       lan.c: Linux ThunderLan Driver:
*
*       by James Banks
*
*       (C) 1997-1998 Caldera, Inc.
*       (C) 1998 James Banks
*       (C) 1999-2001 Torben Mathiasen
*       (C) 2002 Samuel Chessman
*
*    REVISION HISTORY:
*    ================
*    v1.0       07-08-2003      timlegge        Initial not quite working version
*    v1.1       07-27-2003      timlegge        Sync 5.0 and 5.1 versions
*    v1.2       08-19-2003      timlegge        Implement Multicast Support
*    v1.3       08-23-2003      timlegge        Fix the transmit Function
*    v1.4       01-17-2004      timlegge        Initial driver output cleanup    
*    
*    Indent Options: indent -kr -i8
***************************************************************************/

/* to get some global routines like printf */
#include "etherboot.h"
/* to get the interface to the body of the program */
#include "nic.h"
/* to get the PCI support functions, if this is a PCI NIC */
#include "pci.h"
#include "timer.h"
#include "tlan.h"

#define drv_version "v1.4"
#define drv_date "01-17-2004"

/* NIC specific static variables go here */
#define HZ 100
#define TX_TIME_OUT       (6*HZ)

#ifdef EB50
#define cpu_to_le32(val) (val)
#define le32_to_cpu(val) (val)
#define virt_to_bus(x) ((unsigned long) x)
#define bus_to_virt(x) ((unsigned long) x)
#endif

/* Condensed operations for readability. */
#define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
#define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))


static void TLan_ResetLists(struct nic *nic __unused);
static void TLan_ResetAdapter(struct nic *nic __unused);
static void TLan_FinishReset(struct nic *nic __unused);

static void TLan_EeSendStart(u16);
static int TLan_EeSendByte(u16, u8, int);
static void TLan_EeReceiveByte(u16, u8 *, int);
static int TLan_EeReadByte(u16 io_base, u8, u8 *);

static void TLan_PhyDetect(struct nic *nic);
static void TLan_PhyPowerDown(struct nic *nic);
static void TLan_PhyPowerUp(struct nic *nic);


static void TLan_SetMac(struct nic *nic __unused, int areg, char *mac);

static void TLan_PhyReset(struct nic *nic);
static void TLan_PhyStartLink(struct nic *nic);
static void TLan_PhyFinishAutoNeg(struct nic *nic);

#ifdef MONITOR
static void TLan_PhyMonitor(struct nic *nic);
#endif


static void refill_rx(struct nic *nic __unused);

static int TLan_MiiReadReg(struct nic *nic __unused, u16, u16, u16 *);
static void TLan_MiiSendData(u16, u32, unsigned);
static void TLan_MiiSync(u16);
static void TLan_MiiWriteReg(struct nic *nic __unused, u16, u16, u16);


const char *media[] = {
        "10BaseT-HD ", "10BaseT-FD ", "100baseTx-HD ",
        "100baseTx-FD", "100baseT4", 0
};

/* This much match tlan_pci_tbl[]!  */
enum tlan_nics {
        NETEL10 = 0, NETEL100 = 1, NETFLEX3I = 2, THUNDER = 3, NETFLEX3B =
            4, NETEL100PI = 5,
        NETEL100D = 6, NETEL100I = 7, OC2183 = 8, OC2325 = 9, OC2326 =
            10, NETELLIGENT_10_100_WS_5100 = 11,
        NETELLIGENT_10_T2 = 12
};

struct pci_id_info {
        const char *name;
        int nic_id;
        struct match_info {
                u32 pci, pci_mask, subsystem, subsystem_mask;
                u32 revision, revision_mask;    /* Only 8 bits. */
        } id;
        u32 flags;
        u16 addrOfs;            /* Address Offset */
};

static struct pci_id_info tlan_pci_tbl[] = {
        {"Compaq Netelligent 10 T PCI UTP", NETEL10,
         {0xae340e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_ACTIVITY_LED, 0x83},
        {"Compaq Netelligent 10/100 TX PCI UTP", NETEL100,
         {0xae320e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_ACTIVITY_LED, 0x83},
        {"Compaq Integrated NetFlex-3/P", NETFLEX3I,
         {0xae350e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_NONE, 0x83},
        {"Compaq NetFlex-3/P", THUNDER,
         {0xf1300e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83},
        {"Compaq NetFlex-3/P", NETFLEX3B,
         {0xf1500e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_NONE, 0x83},
        {"Compaq Netelligent Integrated 10/100 TX UTP", NETEL100PI,
         {0xae430e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_ACTIVITY_LED, 0x83},
        {"Compaq Netelligent Dual 10/100 TX PCI UTP", NETEL100D,
         {0xae400e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_NONE, 0x83},
        {"Compaq Netelligent 10/100 TX Embedded UTP", NETEL100I,
         {0xb0110e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_NONE, 0x83},
        {"Olicom OC-2183/2185", OC2183,
         {0x0013108d, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_USE_INTERN_10, 0x83},
        {"Olicom OC-2325", OC2325,
         {0x0012108d, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_UNMANAGED_PHY, 0xF8},
        {"Olicom OC-2326", OC2326,
         {0x0014108d, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_USE_INTERN_10, 0xF8},
        {"Compaq Netelligent 10/100 TX UTP", NETELLIGENT_10_100_WS_5100,
         {0xb0300e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_ACTIVITY_LED, 0x83},
        {"Compaq Netelligent 10 T/2 PCI UTP/Coax", NETELLIGENT_10_T2,
         {0xb0120e11, 0xffffffff, 0, 0, 0, 0},
         TLAN_ADAPTER_NONE, 0x83},
        {"Compaq NetFlex-3/E", 0,       /* EISA card */
         {0, 0, 0, 0, 0, 0},
         TLAN_ADAPTER_ACTIVITY_LED | TLAN_ADAPTER_UNMANAGED_PHY |
         TLAN_ADAPTER_BIT_RATE_PHY, 0x83},
        {"Compaq NetFlex-3/E", 0,       /* EISA card */
         {0, 0, 0, 0, 0, 0},
         TLAN_ADAPTER_ACTIVITY_LED, 0x83},
        {0, 0,
         {0, 0, 0, 0, 0, 0},
         0, 0},
};


struct TLanList {
        u32 forward;
        u16 cStat;
        u16 frameSize;
        struct {
                u32 count;
                u32 address;
        } buffer[TLAN_BUFFERS_PER_LIST];
};



struct TLanList tx_ring[TLAN_NUM_TX_LISTS];
static unsigned char txb[TLAN_MAX_FRAME_SIZE * TLAN_NUM_TX_LISTS];

struct TLanList rx_ring[TLAN_NUM_RX_LISTS];
static unsigned char rxb[TLAN_MAX_FRAME_SIZE * TLAN_NUM_RX_LISTS];

typedef u8 TLanBuffer[TLAN_MAX_FRAME_SIZE];


int chip_idx;


/*****************************************************************
* TLAN Private Information Structure
*
****************************************************************/
struct tlan_private {
        unsigned short vendor_id;       /* PCI Vendor code */
        unsigned short dev_id;  /* PCI Device code */
        const char *nic_name;
        u8 *padBuffer;
        u8 *rxBuffer;
        struct TLanList *rx_head_desc;
        u32 rxHead;
        u32 rxTail;
        u32 rxEocCount;
        unsigned int cur_rx, dirty_rx;  /* Producer/consumer ring indicies */
        unsigned int cur_tx, dirty_tx;
        unsigned rx_buf_sz;     /* Based on mtu + Slack */
        struct TLanList *txList;
        struct TLanList *rxList;
        u8 *txBuffer;
        u32 txHead;
        u32 txInProgress;
        u32 txTail;
        int eoc;
        u32 txBusyCount;
        u32 phyOnline;
        u32 timerSetAt;
        u32 timerType;
        u32 adapterRev;
        u32 aui;
        u32 debug;
        u32 duplex;
        u32 phy[2];
        u32 phyNum;
        u32 speed;
        u8 tlanRev;
        u8 tlanFullDuplex;
        char devName[8];
        u8 link;
        u8 is_eisa;
        u8 neg_be_verbose;
} TLanPrivateInfo;

static struct tlan_private *priv;

u32 BASE;



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

void TLan_ResetLists(struct nic *nic __unused)
{

        int i;
        struct TLanList *list;
        priv->txHead = 0;
        priv->txTail = 0;

        for (i = 0; i < TLAN_NUM_TX_LISTS; i++) {
                list = &tx_ring[i];
                list->cStat = TLAN_CSTAT_UNUSED;
/*              list->buffer[0].address = 0; */
                list->buffer[0].address = virt_to_bus(txb + 
                                (i * TLAN_MAX_FRAME_SIZE)); 
                list->buffer[2].count = 0;
                list->buffer[2].address = 0;
                list->buffer[9].address = 0;
/*              list->forward = 0; */
        }

        priv->cur_rx = 0;
        priv->rx_buf_sz = (TLAN_MAX_FRAME_SIZE);
        priv->rx_head_desc = &rx_ring[0];

        /* Initialize all the Rx descriptors */
        for (i = 0; i < TLAN_NUM_RX_LISTS; i++) {
                rx_ring[i].forward = virt_to_le32desc(&rx_ring[i + 1]);
                rx_ring[i].cStat = TLAN_CSTAT_READY;
                rx_ring[i].frameSize = TLAN_MAX_FRAME_SIZE;
                rx_ring[i].buffer[0].count =
                    TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
                rx_ring[i].buffer[0].address =
                    virt_to_le32desc(&rxb[i * TLAN_MAX_FRAME_SIZE]);
                rx_ring[i].buffer[1].count = 0;
                rx_ring[i].buffer[1].address = 0;
        }

        /* Mark the last entry as wrapping the ring */
        rx_ring[i - 1].forward = virt_to_le32desc(&rx_ring[0]);
        priv->dirty_rx = (unsigned int) (i - TLAN_NUM_RX_LISTS);

} /* TLan_ResetLists */

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

void TLan_ResetAdapter(struct nic *nic __unused)
{
        int i;
        u32 addr;
        u32 data;
        u8 data8;

        priv->tlanFullDuplex = FALSE;
        priv->phyOnline = 0;
/*  1.  Assert reset bit. */

        data = inl(BASE + TLAN_HOST_CMD);
        data |= TLAN_HC_AD_RST;
        outl(data, BASE + TLAN_HOST_CMD);

        udelay(1000);

/*  2.  Turn off interrupts. ( Probably isn't necessary ) */

        data = inl(BASE + TLAN_HOST_CMD);
        data |= TLAN_HC_INT_OFF;
        outl(data, BASE + TLAN_HOST_CMD);
/*  3.  Clear AREGs and HASHs. */

        for (i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4) {
                TLan_DioWrite32(BASE, (u16) i, 0);
        }

/*  4.  Setup NetConfig register. */

        data =
            TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
        TLan_DioWrite16(BASE, TLAN_NET_CONFIG, (u16) data);

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

        outl(TLAN_HC_LD_TMR | 0x3f, BASE + TLAN_HOST_CMD);
        outl(TLAN_HC_LD_THR | 0x0, BASE + TLAN_HOST_CMD);

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

        outw(TLAN_NET_SIO, BASE + TLAN_DIO_ADR);
        addr = BASE + TLAN_DIO_DATA + TLAN_NET_SIO;
        TLan_SetBit(TLAN_NET_SIO_NMRST, addr);

/*  7.  Setup the remaining registers. */

        if (priv->tlanRev >= 0x30) {
                data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
                TLan_DioWrite8(BASE, TLAN_INT_DIS, data8);
        }
        TLan_PhyDetect(nic);
        data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;

        if (tlan_pci_tbl[chip_idx].flags & TLAN_ADAPTER_BIT_RATE_PHY) {
                data |= TLAN_NET_CFG_BIT;
                if (priv->aui == 1) {
                        TLan_DioWrite8(BASE, TLAN_ACOMMIT, 0x0a);
                } else if (priv->duplex == TLAN_DUPLEX_FULL) {
                        TLan_DioWrite8(BASE, TLAN_ACOMMIT, 0x00);
                        priv->tlanFullDuplex = TRUE;
                } else {
                        TLan_DioWrite8(BASE, TLAN_ACOMMIT, 0x08);
                }
        }

        if (priv->phyNum == 0) {
                data |= TLAN_NET_CFG_PHY_EN;
        }
        TLan_DioWrite16(BASE, TLAN_NET_CONFIG, (u16) data);

        if (tlan_pci_tbl[chip_idx].flags & TLAN_ADAPTER_UNMANAGED_PHY) {
                TLan_FinishReset(nic);
        } else {
                TLan_PhyPowerDown(nic);
        }

}       /* TLan_ResetAdapter */

void TLan_FinishReset(struct nic *nic)
{

        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->phyNum];

        data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
        if (priv->tlanFullDuplex) {
                data |= TLAN_NET_CMD_DUPLEX;
        }
        TLan_DioWrite8(BASE, TLAN_NET_CMD, data);
        data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
        if (priv->phyNum == 0) {
                data |= TLAN_NET_MASK_MASK7;
        }
        TLan_DioWrite8(BASE, TLAN_NET_MASK, data);
        TLan_DioWrite16(BASE, TLAN_MAX_RX, ((1536) + 7) & ~7);
        TLan_MiiReadReg(nic, phy, MII_GEN_ID_HI, &tlphy_id1);
        TLan_MiiReadReg(nic, phy, MII_GEN_ID_LO, &tlphy_id2);

        if ((tlan_pci_tbl[chip_idx].flags & TLAN_ADAPTER_UNMANAGED_PHY)
            || (priv->aui)) {
                status = MII_GS_LINK;
                printf("TLAN:  %s: Link forced.\n", priv->nic_name);
        } else {
                TLan_MiiReadReg(nic, phy, MII_GEN_STS, &status);
                udelay(1000);
                TLan_MiiReadReg(nic, phy, MII_GEN_STS, &status);
                if ((status & MII_GS_LINK) &&   /* We only support link info on Nat.Sem. PHY's */
                    (tlphy_id1 == NAT_SEM_ID1)
                    && (tlphy_id2 == NAT_SEM_ID2)) {
                        TLan_MiiReadReg(nic, phy, MII_AN_LPA, &partner);
                        TLan_MiiReadReg(nic, phy, TLAN_TLPHY_PAR,
                                        &tlphy_par);

                        printf("TLAN: %s: Link active with ",
                               priv->nic_name);
                        if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
                                printf("forced 10%sMbps %s-Duplex\n",
                                       tlphy_par & TLAN_PHY_SPEED_100 ? ""
                                       : "0",
                                       tlphy_par & TLAN_PHY_DUPLEX_FULL ?
                                       "Full" : "Half");
                        } else {
                                printf
                                    ("AutoNegotiation enabled, at 10%sMbps %s-Duplex\n",
                                     tlphy_par & TLAN_PHY_SPEED_100 ? "" :
                                     "0",
                                     tlphy_par & TLAN_PHY_DUPLEX_FULL ?
                                     "Full" : "Half");
                                printf("TLAN: Partner capability: ");
                                for (i = 5; i <= 10; i++)
                                        if (partner & (1 << i))
                                                printf("%s", media[i - 5]);
                                printf("\n");
                        }

                        TLan_DioWrite8(BASE, TLAN_LED_REG, TLAN_LED_LINK);
#ifdef MONITOR
                        /* We have link beat..for now anyway */
                        priv->link = 1;
                        /*Enabling link beat monitoring */
                        /* TLan_SetTimer( nic, (10*HZ), TLAN_TIMER_LINK_BEAT ); */
                        mdelay(10000);
                        TLan_PhyMonitor(nic);
#endif
                } else if (status & MII_GS_LINK) {
                        printf("TLAN: %s: Link active\n", priv->nic_name);
                        TLan_DioWrite8(BASE, TLAN_LED_REG, TLAN_LED_LINK);
                }
        }

        if (priv->phyNum == 0) {
                TLan_MiiReadReg(nic, phy, TLAN_TLPHY_CTL, &tlphy_ctl);
                tlphy_ctl |= TLAN_TC_INTEN;
                TLan_MiiWriteReg(nic, phy, TLAN_TLPHY_CTL, tlphy_ctl);
                sio = TLan_DioRead8(BASE, TLAN_NET_SIO);
                sio |= TLAN_NET_SIO_MINTEN;
                TLan_DioWrite8(BASE, TLAN_NET_SIO, sio);
        }

        if (status & MII_GS_LINK) {
                TLan_SetMac(nic, 0, nic->node_addr);
                priv->phyOnline = 1;
                outb((TLAN_HC_INT_ON >> 8), BASE + TLAN_HOST_CMD + 1);
/*              if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) {
                        outb( ( TLAN_HC_REQ_INT >> 8 ), BASE + TLAN_HOST_CMD + 1 );
                }

                */
                outl(virt_to_bus(&rx_ring), BASE + TLAN_CH_PARM);
                outl(TLAN_HC_GO | TLAN_HC_RT, BASE + TLAN_HOST_CMD);
        } else {
                printf
                    ("TLAN: %s: Link inactive, will retry in 10 secs...\n",
                     priv->nic_name);
                /* TLan_SetTimer( nic, (10*HZ), TLAN_TIMER_FINISH_RESET ); */
                mdelay(10000);
                TLan_FinishReset(nic);
                return;

        }

}       /* TLan_FinishReset */

/**************************************************************************
POLL - Wait for a frame
***************************************************************************/
static int tlan_poll(struct nic *nic, int retrieve)
{
        /* return true if there's an ethernet packet ready to read */
        /* nic->packet should contain data on return */
        /* nic->packetlen should contain length of data */
        u32 framesize;
        u32 host_cmd = 0;
        u32 ack = 1;
        int eoc = 0;
        int entry = priv->cur_rx % TLAN_NUM_RX_LISTS;
        u16 tmpCStat = le32_to_cpu(rx_ring[entry].cStat);
        u16 host_int = inw(BASE + TLAN_HOST_INT);

        if ((tmpCStat & TLAN_CSTAT_FRM_CMP) && !retrieve)
          return 1;

        outw(host_int, BASE + TLAN_HOST_INT);

        if (!(tmpCStat & TLAN_CSTAT_FRM_CMP))
                return 0;

        /* printf("PI-1: 0x%hX\n", host_int); */
        if (tmpCStat & TLAN_CSTAT_EOC)
                eoc = 1;

        framesize = rx_ring[entry].frameSize;

        nic->packetlen = framesize;

#ifdef EBDEBUG
     printf(".%d.", framesize); 
#endif
     
        memcpy(nic->packet, rxb +
               (priv->cur_rx * TLAN_MAX_FRAME_SIZE), nic->packetlen);

        rx_ring[entry].cStat = 0;
#ifdef EBDEBUG
        hex_dump(nic->packet, nic->packetlen);
        printf("%d", entry);  
#endif
        entry = (entry + 1) % TLAN_NUM_RX_LISTS;
        priv->cur_rx = entry;
        if (eoc) {
                if ((rx_ring[entry].cStat & TLAN_CSTAT_READY) ==
                    TLAN_CSTAT_READY) {
                        ack |= TLAN_HC_GO | TLAN_HC_RT;
                        host_cmd = TLAN_HC_ACK | ack | 0x001C0000;
                        outl(host_cmd, BASE + TLAN_HOST_CMD);
                }
        } else {
                host_cmd = TLAN_HC_ACK | ack | (0x000C0000);
                outl(host_cmd, BASE + TLAN_HOST_CMD);
#ifdef EBDEBUG
                printf("AC: 0x%hX\n", inw(BASE + TLAN_CH_PARM)); 
                host_int = inw(BASE + TLAN_HOST_INT);
                printf("PI-2: 0x%hX\n", host_int); 
#endif
        }
        refill_rx(nic);
        return (1);             /* initially as this is called to flush the input */
}

static void refill_rx(struct nic *nic __unused)
{
        int entry = 0;

        for (;
             (priv->cur_rx - priv->dirty_rx +
              TLAN_NUM_RX_LISTS) % TLAN_NUM_RX_LISTS > 0;
             priv->dirty_rx = (priv->dirty_rx + 1) % TLAN_NUM_RX_LISTS) {
                entry = priv->dirty_rx % TLAN_NUM_TX_LISTS;
                rx_ring[entry].frameSize = TLAN_MAX_FRAME_SIZE;
                rx_ring[entry].cStat = TLAN_CSTAT_READY;
        }

}

/* #define EBDEBUG */
/**************************************************************************
TRANSMIT - Transmit a frame
***************************************************************************/
static void tlan_transmit(struct nic *nic, const char *d,       /* Destination */
                          unsigned int t,       /* Type */
                          unsigned int s,       /* size */
                          const char *p)
{                               /* Packet */
        u16 nstype;
        u32 to;
        struct TLanList *tail_list;
        struct TLanList *head_list;
        u8 *tail_buffer;
        u32 ack = 0;
        u32 host_cmd;
        int eoc = 0;
        u16 tmpCStat;
#ifdef EBDEBUG
        u16 host_int = inw(BASE + TLAN_HOST_INT);
#endif
        int entry = 0;

#ifdef EBDEBUG
        printf("INT0-0x%hX\n", host_int);
#endif

        if (!priv->phyOnline) {
                printf("TRANSMIT:  %s PHY is not ready\n", priv->nic_name);
                return;
        }

        tail_list = priv->txList + priv->txTail;

        if (tail_list->cStat != TLAN_CSTAT_UNUSED) {
                printf("TRANSMIT: %s is busy (Head=%d Tail=%d)\n",
                       priv->nic_name, priv->txList, priv->txTail);
                tx_ring[entry].cStat = TLAN_CSTAT_UNUSED;
                priv->txBusyCount++;
                return;
        }

        tail_list->forward = 0;

        tail_buffer = txb + (priv->txTail * TLAN_MAX_FRAME_SIZE);

        /* send the packet to destination */
        memcpy(tail_buffer, d, ETH_ALEN);
        memcpy(tail_buffer + ETH_ALEN, nic->node_addr, ETH_ALEN);
        nstype = htons((u16) t);
        memcpy(tail_buffer + 2 * ETH_ALEN, (u8 *) & nstype, 2);
        memcpy(tail_buffer + ETH_HLEN, p, s);

        s += ETH_HLEN;
        s &= 0x0FFF;
        while (s < ETH_ZLEN)
                tail_buffer[s++] = '\0';

        /*=====================================================*/
        /* Receive
         * 0000 0000 0001 1100
         * 0000 0000 0000 1100
         * 0000 0000 0000 0011 = 0x0003
         *
         * 0000 0000 0000 0000 0000 0000 0000 0011
         * 0000 0000 0000 1100 0000 0000 0000 0000 = 0x000C0000
         *
         * Transmit
         * 0000 0000 0001 1100
         * 0000 0000 0000 0100
         * 0000 0000 0000 0001 = 0x0001
         *
         * 0000 0000 0000 0000 0000 0000 0000 0001
         * 0000 0000 0000 0100 0000 0000 0000 0000 = 0x00040000
         * */

        /* Setup the transmit descriptor */
        tail_list->frameSize = (u16) s;
        tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) s;
        tail_list->buffer[1].count = 0;
        tail_list->buffer[1].address = 0;

        tail_list->cStat = TLAN_CSTAT_READY;

#ifdef EBDEBUG
        host_int = inw(BASE + TLAN_HOST_INT);
        printf("INT1-0x%hX\n", host_int);
#endif

        if (!priv->txInProgress) {
                priv->txInProgress = 1;
                outl(virt_to_le32desc(tail_list), BASE + TLAN_CH_PARM);
                outl(TLAN_HC_GO, BASE + TLAN_HOST_CMD);
        } else {
                if (priv->txTail == 0) {
#ifdef EBDEBUG
                        printf("Out buffer\n");
#endif
                        (priv->txList + (TLAN_NUM_TX_LISTS - 1))->forward =
                            virt_to_le32desc(tail_list);
                } else {
#ifdef EBDEBUG
                        printf("Fix this \n");
#endif
                        (priv->txList + (priv->txTail - 1))->forward =
                            virt_to_le32desc(tail_list);
                }
        }
        
        CIRC_INC(priv->txTail, TLAN_NUM_TX_LISTS);

#ifdef EBDEBUG
        host_int = inw(BASE + TLAN_HOST_INT);
        printf("INT2-0x%hX\n", host_int);
#endif

        to = currticks() + TX_TIME_OUT;
        while ((tail_list->cStat == TLAN_CSTAT_READY) && currticks() < to);

        head_list = priv->txList + priv->txHead;
        while (((tmpCStat = head_list->cStat) & TLAN_CSTAT_FRM_CMP) 
                        && (ack < 255)) {
                ack++;
                if(tmpCStat & TLAN_CSTAT_EOC)
                        eoc =1;
                head_list->cStat = TLAN_CSTAT_UNUSED;
                CIRC_INC(priv->txHead, TLAN_NUM_TX_LISTS);
                head_list = priv->txList + priv->txHead;
                
        }
        if(!ack)
                printf("Incomplete TX Frame\n");

        if(eoc) {
                head_list = priv->txList + priv->txHead;
                if ((head_list->cStat & TLAN_CSTAT_READY) == TLAN_CSTAT_READY) {
                        outl(virt_to_le32desc(head_list), BASE + TLAN_CH_PARM);
                        ack |= TLAN_HC_GO;
                } else {
                        priv->txInProgress = 0;
                }
        }
        if(ack) {
                host_cmd = TLAN_HC_ACK | ack;
                outl(host_cmd, BASE + TLAN_HOST_CMD);
        }
        
        if(priv->tlanRev < 0x30 ) {
                ack = 1;
                head_list = priv->txList + priv->txHead;
                if ((head_list->cStat & TLAN_CSTAT_READY) == TLAN_CSTAT_READY) {
                        outl(virt_to_le32desc(head_list), BASE + TLAN_CH_PARM);
                        ack |= TLAN_HC_GO;
                } else {
                        priv->txInProgress = 0;
                }
                host_cmd = TLAN_HC_ACK | ack | 0x00140000;
                outl(host_cmd, BASE + TLAN_HOST_CMD);
                
        }
                        
        if (currticks() >= to) {
                printf("TX Time Out");
        }
}

/**************************************************************************
DISABLE - Turn off ethernet interface
***************************************************************************/
#ifdef EB51
static void tlan_disable(struct dev *dev __unused)
#else
static void tlan_disable(struct nic *nic __unused)
#endif
{
        /* put the card in its initial state */
        /* This function serves 3 purposes.
         * This disables DMA and interrupts so we don't receive
         *  unexpected packets or interrupts from the card after
         *  etherboot has finished.
         * This frees resources so etherboot may use
         *  this driver on another interface
         * This allows etherboot to reinitialize the interface
         *  if something is something goes wrong.
         *
         */
        outl(TLAN_HC_AD_RST, BASE + TLAN_HOST_CMD);
}

/**************************************************************************
IRQ - Enable, Disable, or Force interrupts
***************************************************************************/
static void tlan_irq(struct nic *nic __unused, irq_action_t action __unused)
{
  switch ( action ) {
  case DISABLE :
    break;
  case ENABLE :
    break;
  case FORCE :
    break;
  }
}

static void TLan_SetMulticastList(struct nic *nic) {
        int i;
        u8 tmp;

        /* !IFF_PROMISC */
        tmp = TLan_DioRead8(BASE, TLAN_NET_CMD);
        TLan_DioWrite8(BASE, TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF);

        /* IFF_ALLMULTI */
        for(i = 0; i< 3; i++)
                TLan_SetMac(nic, i + 1, NULL);
        TLan_DioWrite32(BASE, TLAN_HASH_1, 0xFFFFFFFF);
        TLan_DioWrite32(BASE, TLAN_HASH_2, 0xFFFFFFFF);

        
}
/**************************************************************************
PROBE - Look for an adapter, this routine's visible to the outside
***************************************************************************/

#define board_found 1
#define valid_link 0
#ifdef EB51
static int tlan_probe(struct dev *dev, struct pci_device *pci)
{
        struct nic *nic = (struct nic *) dev;
#else
struct nic *tlan_probe(struct nic *nic, unsigned short *io_addrs, struct pci_device *pci)
{
#endif
                u16 data = 0;
        int err;
        int i;

        if (pci->ioaddr == 0)
                return 0;

        nic->irqno  = 0;
        nic->ioaddr = pci->ioaddr & ~3;

        BASE = pci->ioaddr;
        printf("\n");
        printf("tlan.c: %s, %s\n", drv_version, drv_date);
        printf("%s: Probing for Vendor 0x%hX, Device 0x%hX",
               pci->name, pci->vendor, pci->dev_id);


        /* I really must find out what this does */
        adjust_pci_device(pci);

        /* Point to private storage */
        priv = &TLanPrivateInfo;
        /* Figure out which chip we're dealing with */
        i = 0;
        chip_idx = -1;

        while (tlan_pci_tbl[i].name) {
                if ((((u32) pci->dev_id << 16) | pci->vendor) ==
                    (tlan_pci_tbl[i].id.pci & 0xffffffff)) {
                        chip_idx = i;
                        break;
                }
                i++;
        }

        priv->vendor_id = pci->vendor;
        priv->dev_id = pci->dev_id;
        priv->nic_name = pci->name;
        priv->eoc = 0;

        err = 0;
        for (i = 0; i < 6; i++)
                err |= TLan_EeReadByte(BASE,
                                       (u8) tlan_pci_tbl[chip_idx].
                                       addrOfs + i,
                                       (u8 *) & nic->node_addr[i]);
        if (err) {
                printf("TLAN: %s: Error reading MAC from eeprom: %d\n",
                       pci->name, err);
        } else
                printf("\nAddress: %!\n", nic->node_addr);

        priv->tlanRev = TLan_DioRead8(BASE, TLAN_DEF_REVISION);
        printf("\nRevision = 0x%hX\n", priv->tlanRev);

        TLan_ResetLists(nic);
        TLan_ResetAdapter(nic);
/*
        data = inl(BASE + TLAN_HOST_CMD);
        data |= TLAN_HC_EOC;
        outw(data, BASE + TLAN_HOST_CMD);
*/

        data = inl(BASE + TLAN_HOST_CMD);
        data |= TLAN_HC_INT_OFF;
        outw(data, BASE + TLAN_HOST_CMD);

        TLan_SetMulticastList(nic);
        udelay(100); 
        priv->txList = tx_ring;
        priv->rxList = rx_ring;
/*      if (board_found && valid_link)
        {*/
        /* point to NIC specific routines */
#ifdef EB51
        dev->disable = tlan_disable;
        nic->poll = tlan_poll;
        nic->transmit = tlan_transmit;
        nic->irq    = tlan_irq;
        return 1;
#else
        nic->disable = tlan_disable;
        nic->poll = tlan_poll;
        nic->transmit = tlan_transmit;
        nic->irq    = tlan_irq;
        return nic;
#endif
}


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

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

void TLan_EeSendStart(u16 io_base)
{
        u16 sio;

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

        TLan_SetBit(TLAN_NET_SIO_ECLOK, sio);
        TLan_SetBit(TLAN_NET_SIO_EDATA, sio);
        TLan_SetBit(TLAN_NET_SIO_ETXEN, sio);
        TLan_ClearBit(TLAN_NET_SIO_EDATA, sio);
        TLan_ClearBit(TLAN_NET_SIO_ECLOK, sio);

}                               /* TLan_EeSendStart */




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

int TLan_EeSendByte(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_SetBit(TLAN_NET_SIO_EDATA, sio);
                else
                        TLan_ClearBit(TLAN_NET_SIO_EDATA, sio);
                TLan_SetBit(TLAN_NET_SIO_ECLOK, sio);
                TLan_ClearBit(TLAN_NET_SIO_ECLOK, sio);
        }
        TLan_ClearBit(TLAN_NET_SIO_ETXEN, sio);
        TLan_SetBit(TLAN_NET_SIO_ECLOK, sio);
        err = TLan_GetBit(TLAN_NET_SIO_EDATA, sio);
        TLan_ClearBit(TLAN_NET_SIO_ECLOK, sio);
        TLan_SetBit(TLAN_NET_SIO_ETXEN, sio);

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

        return (err);

}                               /* TLan_EeSendByte */




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

void TLan_EeReceiveByte(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_ClearBit(TLAN_NET_SIO_ETXEN, sio);
        for (place = 0x80; place; place >>= 1) {
                TLan_SetBit(TLAN_NET_SIO_ECLOK, sio);
                if (TLan_GetBit(TLAN_NET_SIO_EDATA, sio))
                        *data |= place;
                TLan_ClearBit(TLAN_NET_SIO_ECLOK, sio);
        }

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

}                               /* TLan_EeReceiveByte */



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

int TLan_EeReadByte(u16 io_base, u8 ee_addr, u8 * data)
{
        int err;
        int ret = 0;


        TLan_EeSendStart(io_base);
        err = TLan_EeSendByte(io_base, 0xA0, TLAN_EEPROM_ACK);
        if (err) {
                ret = 1;
                goto fail;
        }
        err = TLan_EeSendByte(io_base, ee_addr, TLAN_EEPROM_ACK);
        if (err) {
                ret = 2;
                goto fail;
        }
        TLan_EeSendStart(io_base);
        err = TLan_EeSendByte(io_base, 0xA1, TLAN_EEPROM_ACK);
        if (err) {
                ret = 3;
                goto fail;
        }
        TLan_EeReceiveByte(io_base, data, TLAN_EEPROM_STOP);
      fail:

        return ret;

}                               /* TLan_EeReadByte */


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

        ThunderLAN Driver MII Routines

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

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


        /***************************************************************
         *      TLan_MiiReadReg
         *
         *      Returns:
         *              0       if ack received ok
         *              1       otherwise.
         *
         *      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
         *                              retreived.
         *              val             A pointer to a variable to store the
         *                              retrieved value.
         *
         *      This function uses the TLAN's MII bus to retreive the contents
         *      of a given register on a PHY.  It sends the appropriate info
         *      and then reads the 16-bit register value from the MII bus via
         *      the TLAN SIO register.
         *
         **************************************************************/

int TLan_MiiReadReg(struct nic *nic __unused, u16 phy, u16 reg, u16 * val)
{
        u8 nack;
        u16 sio, tmp;
        u32 i;
        int err;
        int minten;

        err = FALSE;
        outw(TLAN_NET_SIO, BASE + TLAN_DIO_ADR);
        sio = BASE + TLAN_DIO_DATA + TLAN_NET_SIO;

        TLan_MiiSync(BASE);

        minten = TLan_GetBit(TLAN_NET_SIO_MINTEN, sio);
        if (minten)
                TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);

        TLan_MiiSendData(BASE, 0x1, 2); /* Start ( 01b ) */
        TLan_MiiSendData(BASE, 0x2, 2); /* Read  ( 10b ) */
        TLan_MiiSendData(BASE, phy, 5); /* Device #      */
        TLan_MiiSendData(BASE, reg, 5); /* Register #    */


        TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio); /* Change direction */

        TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);  /* Clock Idle bit */
        TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
        TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);  /* Wait 300ns */

        nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio);    /* Check for ACK */
        TLan_SetBit(TLAN_NET_SIO_MCLK, sio);    /* Finish ACK */
        if (nack) {             /* No ACK, so fake it */
                for (i = 0; i < 16; i++) {
                        TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
                        TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
                }
                tmp = 0xffff;
                err = TRUE;
        } else {                /* ACK, so read data */
                for (tmp = 0, i = 0x8000; i; i >>= 1) {
                        TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
                        if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio))
                                tmp |= i;
                        TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
                }
        }


        TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);  /* Idle cycle */
        TLan_SetBit(TLAN_NET_SIO_MCLK, sio);

        if (minten)
                TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);

        *val = tmp;

        return err;

}                               /* TLan_MiiReadReg */

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

void TLan_MiiSendData(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_SetBit(TLAN_NET_SIO_MTXEN, sio);

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

}                               /* TLan_MiiSendData */




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

void TLan_MiiSync(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_ClearBit(TLAN_NET_SIO_MTXEN, sio);
        for (i = 0; i < 32; i++) {
                TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
                TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
        }

}                               /* TLan_MiiSync */




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

void TLan_MiiWriteReg(struct nic *nic __unused, u16 phy, u16 reg, u16 val)
{
        u16 sio;
        int minten;

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

        TLan_MiiSync(BASE);

        minten = TLan_GetBit(TLAN_NET_SIO_MINTEN, sio);
        if (minten)
                TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);

        TLan_MiiSendData(BASE, 0x1, 2); /* Start ( 01b ) */
        TLan_MiiSendData(BASE, 0x1, 2); /* Write ( 01b ) */
        TLan_MiiSendData(BASE, phy, 5); /* Device #      */
        TLan_MiiSendData(BASE, reg, 5); /* Register #    */

        TLan_MiiSendData(BASE, 0x2, 2); /* Send ACK */
        TLan_MiiSendData(BASE, val, 16);        /* Send Data */

        TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);  /* Idle cycle */
        TLan_SetBit(TLAN_NET_SIO_MCLK, sio);

        if (minten)
                TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);


}                               /* TLan_MiiWriteReg */

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

void TLan_SetMac(struct nic *nic __unused, int areg, char *mac)
{
        int i;

        areg *= 6;

        if (mac != NULL) {
                for (i = 0; i < 6; i++)
                        TLan_DioWrite8(BASE, TLAN_AREG_0 + areg + i,
                                       mac[i]);
        } else {
                for (i = 0; i < 6; i++)
                        TLan_DioWrite8(BASE, TLAN_AREG_0 + areg + i, 0);
        }

}                               /* TLan_SetMac */

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

void TLan_PhyDetect(struct nic *nic)
{
        u16 control;
        u16 hi;
        u16 lo;
        u32 phy;

        if (tlan_pci_tbl[chip_idx].flags & TLAN_ADAPTER_UNMANAGED_PHY) {
                priv->phyNum = 0xFFFF;
                return;
        }

        TLan_MiiReadReg(nic, 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_MiiReadReg(nic, phy, MII_GEN_CTL, &control);
                TLan_MiiReadReg(nic, phy, MII_GEN_ID_HI, &hi);
                TLan_MiiReadReg(nic, phy, MII_GEN_ID_LO, &lo);
                if ((control != 0xFFFF) || (hi != 0xFFFF)
                    || (lo != 0xFFFF)) {
                        printf("PHY found at %hX %hX %hX %hX\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->phyNum = 1;
        } else if (priv->phy[0] != TLAN_PHY_NONE) {
                priv->phyNum = 0;
        } else {
                printf
                    ("TLAN:  Cannot initialize device, no PHY was found!\n");
        }

}                               /* TLan_PhyDetect */

void TLan_PhyPowerDown(struct nic *nic)
{

        u16 value;
        printf("%s: Powering down PHY(s).\n", priv->nic_name);
        value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
        TLan_MiiSync(BASE);
        TLan_MiiWriteReg(nic, priv->phy[priv->phyNum], MII_GEN_CTL, value);
        if ((priv->phyNum == 0) && (priv->phy[1] != TLAN_PHY_NONE)
            &&
            (!(tlan_pci_tbl[chip_idx].
               flags & TLAN_ADAPTER_USE_INTERN_10))) {
                TLan_MiiSync(BASE);
                TLan_MiiWriteReg(nic, priv->phy[1], MII_GEN_CTL, value);
        }

        /* Wait for 50 ms and powerup
         * This is abitrary.  It is intended to make sure the
         * tranceiver settles.
         */
        /* TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP ); */
        mdelay(50);
        TLan_PhyPowerUp(nic);

}                               /* TLan_PhyPowerDown */


void TLan_PhyPowerUp(struct nic *nic)
{
        u16 value;

        printf("%s: Powering up PHY.\n", priv->nic_name);
        TLan_MiiSync(BASE);
        value = MII_GC_LOOPBK;
        TLan_MiiWriteReg(nic, priv->phy[priv->phyNum], MII_GEN_CTL, value);
        TLan_MiiSync(BASE);
        /* Wait for 500 ms and reset the
         * tranceiver.  The TLAN docs say both 50 ms and
         * 500 ms, so do the longer, just in case.
         */
        mdelay(500);
        TLan_PhyReset(nic);
        /* TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET ); */

}                               /* TLan_PhyPowerUp */

void TLan_PhyReset(struct nic *nic)
{
        u16 phy;
        u16 value;

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

        printf("%s: Reseting PHY.\n", priv->nic_name);
        TLan_MiiSync(BASE);
        value = MII_GC_LOOPBK | MII_GC_RESET;
        TLan_MiiWriteReg(nic, phy, MII_GEN_CTL, value);
        TLan_MiiReadReg(nic, phy, MII_GEN_CTL, &value);
        while (value & MII_GC_RESET) {
                TLan_MiiReadReg(nic, phy, MII_GEN_CTL, &value);
        }

        /* 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_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK ); */
        mdelay(50);
        TLan_PhyStartLink(nic);

}                               /* TLan_PhyReset */


void TLan_PhyStartLink(struct nic *nic)
{

        u16 ability;
        u16 control;
        u16 data;
        u16 phy;
        u16 status;
        u16 tctl;

        phy = priv->phy[priv->phyNum];
        printf("%s: Trying to activate link.\n", priv->nic_name);
        TLan_MiiReadReg(nic, phy, MII_GEN_STS, &status);
        TLan_MiiReadReg(nic, 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_MiiWriteReg(nic, phy, MII_GEN_CTL, 0x0000);
                } else if (priv->speed == TLAN_SPEED_10 &&
                           priv->duplex == TLAN_DUPLEX_FULL) {
                        priv->tlanFullDuplex = TRUE;
                        TLan_MiiWriteReg(nic, phy, MII_GEN_CTL, 0x0100);
                } else if (priv->speed == TLAN_SPEED_100 &&
                           priv->duplex == TLAN_DUPLEX_HALF) {
                        TLan_MiiWriteReg(nic, phy, MII_GEN_CTL, 0x2000);
                } else if (priv->speed == TLAN_SPEED_100 &&
                           priv->duplex == TLAN_DUPLEX_FULL) {
                        priv->tlanFullDuplex = TRUE;
                        TLan_MiiWriteReg(nic, phy, MII_GEN_CTL, 0x2100);
                } else {

                        /* Set Auto-Neg advertisement */
                        TLan_MiiWriteReg(nic, phy, MII_AN_ADV,
                                         (ability << 5) | 1);
                        /* Enablee Auto-Neg */
                        TLan_MiiWriteReg(nic, phy, MII_GEN_CTL, 0x1000);
                        /* Restart Auto-Neg */
                        TLan_MiiWriteReg(nic, 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.
                         */
                        printf("TLAN: %s: Starting autonegotiation.\n",
                               priv->nic_name);
                        mdelay(4000);
                        TLan_PhyFinishAutoNeg(nic);
                        /* TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN ); */
                        return;
                }

        }

        if ((priv->aui) && (priv->phyNum != 0)) {
                priv->phyNum = 0;
                data =
                    TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN |
                    TLAN_NET_CFG_PHY_EN;
                TLan_DioWrite16(BASE, TLAN_NET_CONFIG, data);
                mdelay(50);
                /* TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN ); */
                TLan_PhyPowerDown(nic);
                return;
        } else if (priv->phyNum == 0) {
                control = 0;
                TLan_MiiReadReg(nic, 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->tlanFullDuplex = TRUE;
                        }
                        if (priv->speed == TLAN_SPEED_100) {
                                control |= MII_GC_SPEEDSEL;
                        }
                }
                TLan_MiiWriteReg(nic, phy, MII_GEN_CTL, control);
                TLan_MiiWriteReg(nic, phy, TLAN_TLPHY_CTL, tctl);
        }

        /* Wait for 2 sec to give the tranceiver time
         * to establish link.
         */
        /* TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET ); */
        mdelay(2000);
        TLan_FinishReset(nic);

}                               /* TLan_PhyStartLink */

void TLan_PhyFinishAutoNeg(struct nic *nic)
{

        u16 an_adv;
        u16 an_lpa;
        u16 data;
        u16 mode;
        u16 phy;
        u16 status;

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

        TLan_MiiReadReg(nic, phy, MII_GEN_STS, &status);
        udelay(1000);
        TLan_MiiReadReg(nic, 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.
                 */
                if (!priv->neg_be_verbose++) {
                        printf
                            ("TLAN:  Giving autonegotiation more time.\n");
                        printf
                            ("TLAN:  Please check that your adapter has\n");
                        printf
                            ("TLAN:  been properly connected to a HUB or Switch.\n");
                        printf
                            ("TLAN:  Trying to establish link in the background...\n");
                }
                mdelay(8000);
                TLan_PhyFinishAutoNeg(nic);
                /* TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN ); */
                return;
        }

        printf("TLAN: %s: Autonegotiation complete.\n", priv->nic_name);
        TLan_MiiReadReg(nic, phy, MII_AN_ADV, &an_adv);
        TLan_MiiReadReg(nic, phy, MII_AN_LPA, &an_lpa);
        mode = an_adv & an_lpa & 0x03E0;
        if (mode & 0x0100) {
                printf("Full Duplex\n");
                priv->tlanFullDuplex = TRUE;
        } else if (!(mode & 0x0080) && (mode & 0x0040)) {
                priv->tlanFullDuplex = TRUE;
                printf("Full Duplex\n");
        }

        if ((!(mode & 0x0180))
            && (tlan_pci_tbl[chip_idx].flags & TLAN_ADAPTER_USE_INTERN_10)
            && (priv->phyNum != 0)) {
                priv->phyNum = 0;
                data =
                    TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN |
                    TLAN_NET_CFG_PHY_EN;
                TLan_DioWrite16(BASE, TLAN_NET_CONFIG, data);
                /* TLan_SetTimer( nic, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN ); */
                mdelay(400);
                TLan_PhyPowerDown(nic);
                return;
        }

        if (priv->phyNum == 0) {
                if ((priv->duplex == TLAN_DUPLEX_FULL)
                    || (an_adv & an_lpa & 0x0040)) {
                        TLan_MiiWriteReg(nic, phy, MII_GEN_CTL,
                                         MII_GC_AUTOENB | MII_GC_DUPLEX);
                        printf
                            ("TLAN:  Starting internal PHY with FULL-DUPLEX\n");
                } else {
                        TLan_MiiWriteReg(nic, phy, MII_GEN_CTL,
                                         MII_GC_AUTOENB);
                        printf
                            ("TLAN:  Starting internal PHY with HALF-DUPLEX\n");
                }
        }

        /* Wait for 100 ms.  No reason in partiticular.
         */
        /* TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET ); */
        mdelay(100);
        TLan_FinishReset(nic);

}                               /* TLan_PhyFinishAutoNeg */

#ifdef MONITOR

        /*********************************************************************
        *
        *      TLan_phyMonitor
        *
        *      Returns:
        *              None
        *
        *      Params:
        *              dev             The device structure of this device.
        *
        *
        *      This function monitors PHY condition by reading the status
        *      register via the MII bus. This can be used to give info
        *      about link changes (up/down), and possible switch to alternate
        *      media.
        *
        * ******************************************************************/

void TLan_PhyMonitor(struct net_device *dev)
{
        TLanPrivateInfo *priv = dev->priv;
        u16 phy;
        u16 phy_status;

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

        /* Get PHY status register */
        TLan_MiiReadReg(nic, phy, MII_GEN_STS, &phy_status);

        /* Check if link has been lost */
        if (!(phy_status & MII_GS_LINK)) {
                if (priv->link) {
                        priv->link = 0;
                        printf("TLAN: %s has lost link\n", priv->nic_name);
                        priv->flags &= ~IFF_RUNNING;
                        mdelay(2000);
                        TLan_PhyMonitor(nic);
                        /* TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT ); */
                        return;
                }
        }

        /* Link restablished? */
        if ((phy_status & MII_GS_LINK) && !priv->link) {
                priv->link = 1;
                printf("TLAN: %s has reestablished link\n",
                       priv->nic_name);
                priv->flags |= IFF_RUNNING;
        }

        /* Setup a new monitor */
        /* TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT ); */
        mdelay(2000);
        TLan_PhyMonitor(nic);
}

#endif                          /* MONITOR */

#ifdef EB51
static struct pci_id tlan_nics[] = {
        PCI_ROM(0x0e11, 0xae34, "netel10", "Compaq Netelligent 10 T PCI UTP"),
        PCI_ROM(0x0e11, 0xae32, "netel100","Compaq Netelligent 10/100 TX PCI UTP"),
        PCI_ROM(0x0e11, 0xae35, "netflex3i", "Compaq Integrated NetFlex-3/P"),
        PCI_ROM(0x0e11, 0xf130, "thunder", "Compaq NetFlex-3/P"),
        PCI_ROM(0x0e11, 0xf150, "netflex3b", "Compaq NetFlex-3/P"),
        PCI_ROM(0x0e11, 0xae43, "netel100pi", "Compaq Netelligent Integrated 10/100 TX UTP"),
        PCI_ROM(0x0e11, 0xae40, "netel100d", "Compaq Netelligent Dual 10/100 TX PCI UTP"),
        PCI_ROM(0x0e11, 0xb011, "netel100i", "Compaq Netelligent 10/100 TX Embedded UTP"),
        PCI_ROM(0x108d, 0x0013, "oc2183", "Olicom OC-2183/2185"),
        PCI_ROM(0x108d, 0x0012, "oc2325", "Olicom OC-2325"),
        PCI_ROM(0x108d, 0x0014, "oc2326", "Olicom OC-2326"),
        PCI_ROM(0x0e11, 0xb030, "netelligent_10_100_ws_5100", "Compaq Netelligent 10/100 TX UTP"),
        PCI_ROM(0x0e11, 0xb012, "netelligent_10_t2", "Compaq Netelligent 10 T/2 PCI UTP/Coax"),
};

struct pci_driver tlan_driver = {
        .type = NIC_DRIVER,
        .name = "TLAN/PCI",
        .probe = tlan_probe,
        .ids = tlan_nics,
        .id_count = sizeof(tlan_nics) / sizeof(tlan_nics[0]),
        .class = 0,
};
#endif