mtd80x.c

Go to the documentation of this file.

/**************************************************************************
*
*    mtd80x.c: Etherboot device driver for the mtd80x Ethernet chip.
*    Written 2004-2004 by Erdem Güven <zuencap@yahoo.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:
*               fealnx.c: A Linux device driver for the mtd80x Ethernet chip
*               Written 1998-2000 by Donald Becker
*
***************************************************************************/

FILE_LICENCE ( GPL2_OR_LATER );

/* 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 <gpxe/pci.h>
#include <gpxe/ethernet.h>
#include <mii.h>

/* 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))
#define get_unaligned(ptr) (*(ptr))


/* Operational parameters that are set at compile time. */

/* Keep the ring sizes a power of two for compile efficiency.           */
/* The compiler will convert <unsigned>'%'<2^N> into a bit mask.        */
/* Making the Tx ring too large decreases the effectiveness of channel  */
/* bonding and packet priority.                                         */
/* There are no ill effects from too-large receive rings.               */
#define TX_RING_SIZE 2
#define TX_QUEUE_LEN 10 /* Limit ring entries actually used.  */
#define RX_RING_SIZE 4

/* Operational parameters that usually are not changed. */
/* Time in jiffies before concluding the transmitter is hung. */
#define HZ 100
#define TX_TIME_OUT   (6*HZ)

/* Allocation size of Rx buffers with normal sized Ethernet frames.
   Do not change this value without good reason.  This is not a limit,
   but a way to keep a consistent allocation size among drivers.
 */
#define PKT_BUF_SZ 1536

/* for different PHY */
enum phy_type_flags {
    MysonPHY = 1,
    AhdocPHY = 2,
    SeeqPHY = 3,
    MarvellPHY = 4,
    Myson981 = 5,
    LevelOnePHY = 6,
    OtherPHY = 10,
};

/* A chip capabilities table*/
enum chip_capability_flags {
    HAS_MII_XCVR,
    HAS_CHIP_XCVR,
};

#if 0 /* not used */
static
struct chip_info
{
    u16 dev_id;
    int flag;
}
mtd80x_chips[] = {
                     {0x0800, HAS_MII_XCVR},
                     {0x0803, HAS_CHIP_XCVR},
                     {0x0891, HAS_MII_XCVR}
                 };
static int chip_cnt = sizeof( mtd80x_chips ) / sizeof( struct chip_info );
#endif

/* Offsets to the Command and Status Registers. */
enum mtd_offsets {
    PAR0 = 0x0,        /* physical address 0-3 */
    PAR1 = 0x04,        /* physical address 4-5 */
    MAR0 = 0x08,        /* multicast address 0-3 */
    MAR1 = 0x0C,        /* multicast address 4-7 */
    FAR0 = 0x10,        /* flow-control address 0-3 */
    FAR1 = 0x14,        /* flow-control address 4-5 */
    TCRRCR = 0x18,        /* receive & transmit configuration */
    BCR = 0x1C,        /* bus command */
    TXPDR = 0x20,        /* transmit polling demand */
    RXPDR = 0x24,        /* receive polling demand */
    RXCWP = 0x28,        /* receive current word pointer */
    TXLBA = 0x2C,        /* transmit list base address */
    RXLBA = 0x30,        /* receive list base address */
    ISR = 0x34,        /* interrupt status */
    IMR = 0x38,        /* interrupt mask */
    FTH = 0x3C,        /* flow control high/low threshold */
    MANAGEMENT = 0x40,    /* bootrom/eeprom and mii management */
    TALLY = 0x44,        /* tally counters for crc and mpa */
    TSR = 0x48,        /* tally counter for transmit status */
    BMCRSR = 0x4c,        /* basic mode control and status */
    PHYIDENTIFIER = 0x50,    /* phy identifier */
    ANARANLPAR = 0x54,    /* auto-negotiation advertisement and link
                                                       partner ability */
    ANEROCR = 0x58,        /* auto-negotiation expansion and pci conf. */
    BPREMRPSR = 0x5c,    /* bypass & receive error mask and phy status */
};

/* Bits in the interrupt status/enable registers. */
/* The bits in the Intr Status/Enable registers, mostly interrupt sources. */
enum intr_status_bits {
    RFCON = 0x00020000, /* receive flow control xon packet */
    RFCOFF = 0x00010000, /* receive flow control xoff packet */
    LSCStatus = 0x00008000, /* link status change */
    ANCStatus = 0x00004000, /* autonegotiation completed */
    FBE = 0x00002000, /* fatal bus error */
    FBEMask = 0x00001800, /* mask bit12-11 */
    ParityErr = 0x00000000, /* parity error */
    TargetErr = 0x00001000, /* target abort */
    MasterErr = 0x00000800, /* master error */
    TUNF = 0x00000400, /* transmit underflow */
    ROVF = 0x00000200, /* receive overflow */
    ETI = 0x00000100, /* transmit early int */
    ERI = 0x00000080, /* receive early int */
    CNTOVF = 0x00000040, /* counter overflow */
    RBU = 0x00000020, /* receive buffer unavailable */
    TBU = 0x00000010, /* transmit buffer unavilable */
    TI = 0x00000008, /* transmit interrupt */
    RI = 0x00000004, /* receive interrupt */
    RxErr = 0x00000002, /* receive error */
};

/* Bits in the NetworkConfig register. */
enum rx_mode_bits {
    RxModeMask   = 0xe0,
    AcceptAllPhys = 0x80,        /* promiscuous mode */
    AcceptBroadcast = 0x40,        /* accept broadcast */
    AcceptMulticast = 0x20,        /* accept mutlicast */
    AcceptRunt   = 0x08,        /* receive runt pkt */
    ALP          = 0x04,        /* receive long pkt */
    AcceptErr    = 0x02,        /* receive error pkt */

    AcceptMyPhys = 0x00000000,
    RxEnable     = 0x00000001,
    RxFlowCtrl   = 0x00002000,
    TxEnable     = 0x00040000,
    TxModeFDX    = 0x00100000,
    TxThreshold  = 0x00e00000,

    PS1000       = 0x00010000,
    PS10         = 0x00080000,
    FD           = 0x00100000,
};

/* Bits in network_desc.status */
enum rx_desc_status_bits {
    RXOWN = 0x80000000, /* own bit */
    FLNGMASK = 0x0fff0000, /* frame length */
    FLNGShift = 16,
    MARSTATUS = 0x00004000, /* multicast address received */
    BARSTATUS = 0x00002000, /* broadcast address received */
    PHYSTATUS = 0x00001000, /* physical address received */
    RXFSD = 0x00000800, /* first descriptor */
    RXLSD = 0x00000400, /* last descriptor */
    ErrorSummary = 0x80, /* error summary */
    RUNT = 0x40,  /* runt packet received */
    LONG = 0x20,  /* long packet received */
    FAE = 0x10,  /* frame align error */
    CRC = 0x08,  /* crc error */
    RXER = 0x04,  /* receive error */
};

enum rx_desc_control_bits {
    RXIC = 0x00800000, /* interrupt control */
    RBSShift = 0,
};

enum tx_desc_status_bits {
    TXOWN = 0x80000000, /* own bit */
    JABTO = 0x00004000, /* jabber timeout */
    CSL = 0x00002000, /* carrier sense lost */
    LC = 0x00001000, /* late collision */
    EC = 0x00000800, /* excessive collision */
    UDF = 0x00000400, /* fifo underflow */
    DFR = 0x00000200, /* deferred */
    HF = 0x00000100, /* heartbeat fail */
    NCRMask = 0x000000ff, /* collision retry count */
    NCRShift = 0,
};

enum tx_desc_control_bits {
    TXIC = 0x80000000, /* interrupt control */
    ETIControl = 0x40000000, /* early transmit interrupt */
    TXLD = 0x20000000, /* last descriptor */
    TXFD = 0x10000000, /* first descriptor */
    CRCEnable = 0x08000000, /* crc control */
    PADEnable = 0x04000000, /* padding control */
    RetryTxLC = 0x02000000, /* retry late collision */
    PKTSMask = 0x3ff800, /* packet size bit21-11 */
    PKTSShift = 11,
    TBSMask = 0x000007ff, /* transmit buffer bit 10-0 */
    TBSShift = 0,
};

/* BootROM/EEPROM/MII Management Register */
#define MASK_MIIR_MII_READ       0x00000000
#define MASK_MIIR_MII_WRITE      0x00000008
#define MASK_MIIR_MII_MDO        0x00000004
#define MASK_MIIR_MII_MDI        0x00000002
#define MASK_MIIR_MII_MDC        0x00000001

/* ST+OP+PHYAD+REGAD+TA */
#define OP_READ             0x6000 /* ST:01+OP:10+PHYAD+REGAD+TA:Z0 */
#define OP_WRITE            0x5002 /* ST:01+OP:01+PHYAD+REGAD+TA:10 */

/* ------------------------------------------------------------------------- */
/*      Constants for Myson PHY                                              */
/* ------------------------------------------------------------------------- */
#define MysonPHYID      0xd0000302
/* 89-7-27 add, (begin) */
#define MysonPHYID0     0x0302
#define StatusRegister  18
#define SPEED100        0x0400 // bit10
#define FULLMODE        0x0800 // bit11
/* 89-7-27 add, (end) */

/* ------------------------------------------------------------------------- */
/*      Constants for Seeq 80225 PHY                                         */
/* ------------------------------------------------------------------------- */
#define SeeqPHYID0      0x0016

#define MIIRegister18   18
#define SPD_DET_100     0x80
#define DPLX_DET_FULL   0x40

/* ------------------------------------------------------------------------- */
/*      Constants for Ahdoc 101 PHY                                          */
/* ------------------------------------------------------------------------- */
#define AhdocPHYID0     0x0022

#define DiagnosticReg   18
#define DPLX_FULL       0x0800
#define Speed_100       0x0400

/* 89/6/13 add, */
/* -------------------------------------------------------------------------- */
/*      Constants                                                             */
/* -------------------------------------------------------------------------- */
#define MarvellPHYID0           0x0141
#define LevelOnePHYID0  0x0013

#define MII1000BaseTControlReg  9
#define MII1000BaseTStatusReg   10
#define SpecificReg  17

/* for 1000BaseT Control Register */
#define PHYAbletoPerform1000FullDuplex  0x0200
#define PHYAbletoPerform1000HalfDuplex  0x0100
#define PHY1000AbilityMask              0x300

// for phy specific status register, marvell phy.
#define SpeedMask       0x0c000
#define Speed_1000M     0x08000
#define Speed_100M      0x4000
#define Speed_10M       0
#define Full_Duplex     0x2000

// 89/12/29 add, for phy specific status register, levelone phy, (begin)
#define LXT1000_100M    0x08000
#define LXT1000_1000M   0x0c000
#define LXT1000_Full    0x200
// 89/12/29 add, for phy specific status register, levelone phy, (end)

#if 0
/* for 3-in-1 case */
#define PS10            0x00080000
#define FD              0x00100000
#define PS1000          0x00010000
#endif

/* for PHY */
#define LinkIsUp        0x0004
#define LinkIsUp2 0x00040000

/* Create a static buffer of size PKT_BUF_SZ for each
RX and TX Descriptor.  All descriptors point to a
part of this buffer */
struct {
        u8 txb[PKT_BUF_SZ * TX_RING_SIZE] __attribute__ ((aligned(8)));
        u8 rxb[PKT_BUF_SZ * RX_RING_SIZE] __attribute__ ((aligned(8)));
} mtd80x_bufs __shared;
#define txb mtd80x_bufs.txb
#define rxb mtd80x_bufs.rxb

/* The Tulip Rx and Tx buffer descriptors. */
struct mtd_desc
{
    s32 status;
    s32 control;
    u32 buffer;
    u32 next_desc;
    struct mtd_desc *next_desc_logical;
    u8* skbuff;
    u32 reserved1;
    u32 reserved2;
};

struct mtd_private
{
    struct mtd_desc rx_ring[RX_RING_SIZE];
    struct mtd_desc tx_ring[TX_RING_SIZE];

    /* Frequently used values: keep some adjacent for cache effect. */
    int flags;
    struct pci_dev *pci_dev;
    unsigned long crvalue;
    unsigned long bcrvalue;
    /*unsigned long imrvalue;*/
    struct mtd_desc *cur_rx;
    struct mtd_desc *lack_rxbuf;
    int really_rx_count;
    struct mtd_desc *cur_tx;
    struct mtd_desc *cur_tx_copy;
    int really_tx_count;
    int free_tx_count;
    unsigned int rx_buf_sz; /* Based on MTU+slack. */

    /* These values are keep track of the transceiver/media in use. */
    unsigned int linkok;
    unsigned int line_speed;
    unsigned int duplexmode;
    unsigned int default_port:
    4; /* Last dev->if_port value. */
    unsigned int PHYType;

    /* MII transceiver section. */
    int mii_cnt;  /* MII device addresses. */
    unsigned char phys[1]; /* MII device addresses. */

    /*other*/
    const char *nic_name;
    int ioaddr;
    u16 dev_id;
};

static struct mtd_private mtdx;

static int mdio_read(struct nic * , int phy_id, int location);
static void getlinktype(struct nic * );
static void getlinkstatus(struct nic * );
static void set_rx_mode(struct nic *);

/**************************************************************************
 *  init_ring - setup the tx and rx descriptors
 *************************************************************************/
static void init_ring(struct nic *nic __unused)
{
    int i;

    mtdx.cur_rx = &mtdx.rx_ring[0];

    mtdx.rx_buf_sz = PKT_BUF_SZ;
    /*mtdx.rx_head_desc = &mtdx.rx_ring[0];*/

    /* Initialize all Rx descriptors. */
    /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
    for (i = 0; i < RX_RING_SIZE; i++)
    {
        mtdx.rx_ring[i].status = RXOWN;
        mtdx.rx_ring[i].control = mtdx.rx_buf_sz << RBSShift;
        mtdx.rx_ring[i].next_desc = virt_to_le32desc(&mtdx.rx_ring[i+1]);
        mtdx.rx_ring[i].next_desc_logical = &mtdx.rx_ring[i+1];
        mtdx.rx_ring[i].buffer = virt_to_le32desc(&rxb[i * PKT_BUF_SZ]);
        mtdx.rx_ring[i].skbuff = &rxb[i * PKT_BUF_SZ];
    }
    /* Mark the last entry as wrapping the ring. */
    mtdx.rx_ring[i-1].next_desc = virt_to_le32desc(&mtdx.rx_ring[0]);
    mtdx.rx_ring[i-1].next_desc_logical = &mtdx.rx_ring[0];

    /* We only use one transmit buffer, but two
     * descriptors so transmit engines have somewhere
     * to point should they feel the need */
    mtdx.tx_ring[0].status = 0x00000000;
    mtdx.tx_ring[0].buffer = virt_to_bus(&txb[0]);
    mtdx.tx_ring[0].next_desc = virt_to_le32desc(&mtdx.tx_ring[1]);

    /* This descriptor is never used */
    mtdx.tx_ring[1].status = 0x00000000;
    mtdx.tx_ring[1].buffer = 0; /*virt_to_bus(&txb[1]); */
    mtdx.tx_ring[1].next_desc = virt_to_le32desc(&mtdx.tx_ring[0]);

    return;
}

/**************************************************************************
RESET - Reset Adapter
***************************************************************************/
static void mtd_reset( struct nic *nic )
{
    /* Reset the chip to erase previous misconfiguration. */
    outl(0x00000001, mtdx.ioaddr + BCR);

    init_ring(nic);

    outl(virt_to_bus(mtdx.rx_ring), mtdx.ioaddr + RXLBA);
    outl(virt_to_bus(mtdx.tx_ring), mtdx.ioaddr + TXLBA);

    /* Initialize other registers. */
    /* Configure the PCI bus bursts and FIFO thresholds. */
    mtdx.bcrvalue = 0x10; /* little-endian, 8 burst length */
    mtdx.crvalue = 0xa00; /* rx 128 burst length */

        if ( mtdx.dev_id == 0x891 ) {
                mtdx.bcrvalue |= 0x200; /* set PROG bit */
                mtdx.crvalue |= 0x02000000;     /* set enhanced bit */
        }

    outl( mtdx.bcrvalue, mtdx.ioaddr + BCR);

    /* Restart Rx engine if stopped. */
    outl(0, mtdx.ioaddr + RXPDR);

    getlinkstatus(nic);
    if (mtdx.linkok)
    {
        static const char* texts[]={"half","full","10","100","1000"};
        getlinktype(nic);
        DBG ( "Link is OK : %s %s\n", texts[mtdx.duplexmode-1], texts[mtdx.line_speed+1] );
    } else
    {
        DBG ( "No link!!!\n" );
    }

    mtdx.crvalue |= /*TxEnable |*/ RxEnable | TxThreshold;
    set_rx_mode(nic);

    /* Clear interrupts by setting the interrupt mask. */
    outl(FBE | TUNF | CNTOVF | RBU | TI | RI, mtdx.ioaddr + ISR);
    outl( 0, mtdx.ioaddr + IMR);
}

/**************************************************************************
POLL - Wait for a frame
***************************************************************************/
static int mtd_poll(struct nic *nic, __unused int retrieve)
{
    s32 rx_status = mtdx.cur_rx->status;
    int retval = 0;

    if( ( rx_status & RXOWN ) != 0 )
    {
        return 0;
    }

    if (rx_status & ErrorSummary)
    { /* there was a fatal error */
        printf( "%s: Receive error, Rx status %8.8x, Error(s) %s%s%s\n",
                mtdx.nic_name, (unsigned int) rx_status,
                (rx_status & (LONG | RUNT)) ? "length_error ":"",
                (rx_status & RXER) ? "frame_error ":"",
                (rx_status & CRC) ? "crc_error ":"" );
        retval = 0;
    } else if( !((rx_status & RXFSD) && (rx_status & RXLSD)) )
    {
        /* this pkt is too long, over one rx buffer */
        printf("Pkt is too long, over one rx buffer.\n");
        retval = 0;
    } else
    { /* this received pkt is ok */
        /* Omit the four octet CRC from the length. */
        short pkt_len = ((rx_status & FLNGMASK) >> FLNGShift) - 4;

        DBG ( " netdev_rx() normal Rx pkt length %d"
              " status %x.\n", pkt_len, (unsigned int) rx_status );

        nic->packetlen = pkt_len;
        memcpy(nic->packet, mtdx.cur_rx->skbuff, pkt_len);

        retval = 1;
    }

    while( ( mtdx.cur_rx->status & RXOWN ) == 0 )
    {
        mtdx.cur_rx->status = RXOWN;
        mtdx.cur_rx = mtdx.cur_rx->next_desc_logical;
    }

    /* Restart Rx engine if stopped. */
    outl(0, mtdx.ioaddr + RXPDR);

    return retval;
}

/**************************************************************************
TRANSMIT - Transmit a frame
***************************************************************************/
static void mtd_transmit(
    struct nic *nic,
    const char *dest,            /* Destination */
    unsigned int type,            /* Type */
    unsigned int size,            /* size */
    const char *data)            /* Packet */
{
    u32 to;
    u32 tx_status;
    unsigned int nstype = htons ( type );

    memcpy( txb, dest, ETH_ALEN );
    memcpy( txb + ETH_ALEN, nic->node_addr, ETH_ALEN );
    memcpy( txb + 2 * ETH_ALEN, &nstype, 2 );
    memcpy( txb + ETH_HLEN, data, size );

    size += ETH_HLEN;
    size &= 0x0FFF;
    while( size < ETH_ZLEN )
    {
        txb[size++] = '\0';
    }

    mtdx.tx_ring[0].control = TXLD | TXFD | CRCEnable | PADEnable;
    mtdx.tx_ring[0].control |= (size << PKTSShift); /* pkt size */
    mtdx.tx_ring[0].control |= (size << TBSShift); /* buffer size */
    mtdx.tx_ring[0].status = TXOWN;

    /* Point to transmit descriptor */
    outl(virt_to_bus(mtdx.tx_ring), mtdx.ioaddr + TXLBA);
    /* Enable Tx */
    outl( mtdx.crvalue | TxEnable, mtdx.ioaddr + TCRRCR);
    /* Wake the potentially-idle transmit channel. */
    outl(0, mtdx.ioaddr + TXPDR);

    to = currticks() + TX_TIME_OUT;
    while(( mtdx.tx_ring[0].status & TXOWN) && (currticks() < to));

    /* Disable Tx */
    outl( mtdx.crvalue & (~TxEnable), mtdx.ioaddr + TCRRCR);

    tx_status = mtdx.tx_ring[0].status;
    if (currticks() >= to){
        DBG ( "TX Time Out" );
    } else if( tx_status & (CSL | LC | EC | UDF | HF)){
        printf( "Transmit error: %8.8x %s %s %s %s %s\n",
                (unsigned int) tx_status,
                tx_status & EC ? "abort" : "",
                tx_status & CSL ? "carrier" : "",
                tx_status & LC ? "late" : "",
                tx_status & UDF ? "fifo" : "",
                tx_status & HF ? "heartbeat" : "" );
    }

    /*hex_dump( txb, size );*/
    /*pause();*/

    DBG ( "TRANSMIT\n" );
}

/**************************************************************************
DISABLE - Turn off ethernet interface
***************************************************************************/
static void mtd_disable ( struct nic *nic ) {

    /* Disable Tx Rx*/
    outl( mtdx.crvalue & (~TxEnable) & (~RxEnable), mtdx.ioaddr + TCRRCR );

    /* Reset the chip to erase previous misconfiguration. */
    mtd_reset(nic);

    DBG ( "DISABLE\n" );
}

static struct nic_operations mtd_operations = {
        .connect        = dummy_connect,
        .poll           = mtd_poll,
        .transmit       = mtd_transmit,
        .irq            = dummy_irq,

};

static struct pci_device_id mtd80x_nics[] = {
        PCI_ROM(0x1516, 0x0800, "MTD800", "Myson MTD800", 0),
        PCI_ROM(0x1516, 0x0803, "MTD803", "Surecom EP-320X", 0),
        PCI_ROM(0x1516, 0x0891, "MTD891", "Myson MTD891", 0),
};

PCI_DRIVER ( mtd80x_driver, mtd80x_nics, PCI_NO_CLASS );

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

static int mtd_probe ( struct nic *nic, struct pci_device *pci ) {

    int i;

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

    adjust_pci_device(pci);

    nic->ioaddr = pci->ioaddr;
    nic->irqno = 0;

    mtdx.nic_name = pci->driver_name;
    mtdx.dev_id = pci->device;
    mtdx.ioaddr = nic->ioaddr;

    /* read ethernet id */
    for (i = 0; i < 6; ++i)
    {
        nic->node_addr[i] = inb(mtdx.ioaddr + PAR0 + i);
    }

    if (memcmp(nic->node_addr, "\0\0\0\0\0\0", 6) == 0)
    {
        return 0;
    }

    DBG ( "%s: ioaddr %4.4x MAC %s\n", mtdx.nic_name, mtdx.ioaddr, eth_ntoa ( nic->node_addr ) );

    /* Reset the chip to erase previous misconfiguration. */
    outl(0x00000001, mtdx.ioaddr + BCR);

    /* find the connected MII xcvrs */

    if( mtdx.dev_id != 0x803 )
    {
        int phy, phy_idx = 0;

        for (phy = 1; phy < 32 && phy_idx < 1; phy++) {
            int mii_status = mdio_read(nic, phy, 1);

            if (mii_status != 0xffff && mii_status != 0x0000) {
                mtdx.phys[phy_idx] = phy;

                DBG ( "%s: MII PHY found at address %d, status "
                      "0x%4.4x.\n", mtdx.nic_name, phy, mii_status );
                /* get phy type */
                {
                    unsigned int data;

                    data = mdio_read(nic, mtdx.phys[phy_idx], 2);
                    if (data == SeeqPHYID0)
                        mtdx.PHYType = SeeqPHY;
                    else if (data == AhdocPHYID0)
                        mtdx.PHYType = AhdocPHY;
                    else if (data == MarvellPHYID0)
                        mtdx.PHYType = MarvellPHY;
                    else if (data == MysonPHYID0)
                        mtdx.PHYType = Myson981;
                    else if (data == LevelOnePHYID0)
                        mtdx.PHYType = LevelOnePHY;
                    else
                        mtdx.PHYType = OtherPHY;
                }
                phy_idx++;
            }
        }

        mtdx.mii_cnt = phy_idx;
        if (phy_idx == 0) {
            printf("%s: MII PHY not found -- this device may "
                   "not operate correctly.\n", mtdx.nic_name);
        }
    } else {
        mtdx.phys[0] = 32;
        /* get phy type */
        if (inl(mtdx.ioaddr + PHYIDENTIFIER) == MysonPHYID ) {
            mtdx.PHYType = MysonPHY;
            DBG ( "MysonPHY\n" );
        } else {
            mtdx.PHYType = OtherPHY;
            DBG ( "OtherPHY\n" );
        }
    }

    getlinkstatus(nic);
    if( !mtdx.linkok )
    {
        printf("No link!!!\n");
        return 0;
    }

    mtd_reset( nic );

    /* point to NIC specific routines */
    nic->nic_op = &mtd_operations;
    return 1;
}


/**************************************************************************/
static void set_rx_mode(struct nic *nic __unused)
{
    u32 mc_filter[2];                       /* Multicast hash filter */
    u32 rx_mode;

    /* Too many to match, or accept all multicasts. */
    mc_filter[1] = mc_filter[0] = ~0;
    rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;

    outl(mc_filter[0], mtdx.ioaddr + MAR0);
    outl(mc_filter[1], mtdx.ioaddr + MAR1);

    mtdx.crvalue = ( mtdx.crvalue & ~RxModeMask ) | rx_mode;
    outb( mtdx.crvalue, mtdx.ioaddr + TCRRCR);
}
/**************************************************************************/
static unsigned int m80x_read_tick(void)
/* function: Reads the Timer tick count register which decrements by 2 from  */
/*           65536 to 0 every 1/36.414 of a second. Each 2 decrements of the */
/*           count represents 838 nsec's.                                    */
/* input   : none.                                                           */
/* output  : none.                                                           */
{
    unsigned char tmp;
    int value;

    outb((char) 0x06, 0x43); // Command 8254 to latch T0's count

    // now read the count.
    tmp = (unsigned char) inb(0x40);
    value = ((int) tmp) << 8;
    tmp = (unsigned char) inb(0x40);
    value |= (((int) tmp) & 0xff);
    return (value);
}

static void m80x_delay(unsigned int interval)
/* function: to wait for a specified time.                                   */
/* input   : interval ... the specified time.                                */
/* output  : none.                                                           */
{
    unsigned int interval1, interval2, i = 0;

    interval1 = m80x_read_tick(); // get initial value
    do
    {
        interval2 = m80x_read_tick();
        if (interval1 < interval2)
            interval1 += 65536;
        ++i;
    } while (((interval1 - interval2) < (u16) interval) && (i < 65535));
}


static u32 m80x_send_cmd_to_phy(long miiport, int opcode, int phyad, int regad)
{
    u32 miir;
    int i;
    unsigned int mask, data;

    /* enable MII output */
    miir = (u32) inl(miiport);
    miir &= 0xfffffff0;

    miir |= MASK_MIIR_MII_WRITE + MASK_MIIR_MII_MDO;

    /* send 32 1's preamble */
    for (i = 0; i < 32; i++) {
        /* low MDC; MDO is already high (miir) */
        miir &= ~MASK_MIIR_MII_MDC;
        outl(miir, miiport);

        /* high MDC */
        miir |= MASK_MIIR_MII_MDC;
        outl(miir, miiport);
    }

    /* calculate ST+OP+PHYAD+REGAD+TA */
    data = opcode | (phyad << 7) | (regad << 2);

    /* sent out */
    mask = 0x8000;
    while (mask) {
        /* low MDC, prepare MDO */
        miir &= ~(MASK_MIIR_MII_MDC + MASK_MIIR_MII_MDO);
        if (mask & data)
            miir |= MASK_MIIR_MII_MDO;

        outl(miir, miiport);
        /* high MDC */
        miir |= MASK_MIIR_MII_MDC;
        outl(miir, miiport);
        m80x_delay(30);

        /* next */
        mask >>= 1;
        if (mask == 0x2 && opcode == OP_READ)
            miir &= ~MASK_MIIR_MII_WRITE;
    }
    return miir;
}

static int mdio_read(struct nic *nic __unused, int phyad, int regad)
{
    long miiport = mtdx.ioaddr + MANAGEMENT;
    u32 miir;
    unsigned int mask, data;

    miir = m80x_send_cmd_to_phy(miiport, OP_READ, phyad, regad);

    /* read data */
    mask = 0x8000;
    data = 0;
    while (mask)
    {
        /* low MDC */
        miir &= ~MASK_MIIR_MII_MDC;
        outl(miir, miiport);

        /* read MDI */
        miir = inl(miiport);
        if (miir & MASK_MIIR_MII_MDI)
            data |= mask;

        /* high MDC, and wait */
        miir |= MASK_MIIR_MII_MDC;
        outl(miir, miiport);
        m80x_delay((int) 30);

        /* next */
        mask >>= 1;
    }

    /* low MDC */
    miir &= ~MASK_MIIR_MII_MDC;
    outl(miir, miiport);

    return data & 0xffff;
}

#if 0 /* not used */
static void mdio_write(struct nic *nic __unused, int phyad, int regad,
                       int data)
{
    long miiport = mtdx.ioaddr + MANAGEMENT;
    u32 miir;
    unsigned int mask;

    miir = m80x_send_cmd_to_phy(miiport, OP_WRITE, phyad, regad);

    /* write data */
    mask = 0x8000;
    while (mask)
    {
        /* low MDC, prepare MDO */
        miir &= ~(MASK_MIIR_MII_MDC + MASK_MIIR_MII_MDO);
        if (mask & data)
            miir |= MASK_MIIR_MII_MDO;
        outl(miir, miiport);

        /* high MDC */
        miir |= MASK_MIIR_MII_MDC;
        outl(miir, miiport);

        /* next */
        mask >>= 1;
    }

    /* low MDC */
    miir &= ~MASK_MIIR_MII_MDC;
    outl(miir, miiport);

    return;
}
#endif

static void getlinkstatus(struct nic *nic)
/* function: Routine will read MII Status Register to get link status.       */
/* input   : dev... pointer to the adapter block.                            */
/* output  : none.                                                           */
{
    unsigned int i, DelayTime = 0x1000;

    mtdx.linkok = 0;

    if (mtdx.PHYType == MysonPHY)
    {
        for (i = 0; i < DelayTime; ++i) {
            if (inl(mtdx.ioaddr + BMCRSR) & LinkIsUp2) {
                mtdx.linkok = 1;
                return;
            }
            // delay
            m80x_delay(100);
        }
    } else
    {
        for (i = 0; i < DelayTime; ++i) {
            if (mdio_read(nic, mtdx.phys[0], MII_BMSR) & BMSR_LSTATUS) {
                mtdx.linkok = 1;
                return;
            }
            // delay
            m80x_delay(100);
        }
    }
}


static void getlinktype(struct nic *dev)
{
    if (mtdx.PHYType == MysonPHY)
    { /* 3-in-1 case */
        if (inl(mtdx.ioaddr + TCRRCR) & FD)
            mtdx.duplexmode = 2; /* full duplex */
        else
            mtdx.duplexmode = 1; /* half duplex */
        if (inl(mtdx.ioaddr + TCRRCR) & PS10)
            mtdx.line_speed = 1; /* 10M */
        else
            mtdx.line_speed = 2; /* 100M */
    } else
    {
        if (mtdx.PHYType == SeeqPHY) { /* this PHY is SEEQ 80225 */
            unsigned int data;

            data = mdio_read(dev, mtdx.phys[0], MIIRegister18);
            if (data & SPD_DET_100)
                mtdx.line_speed = 2; /* 100M */
            else
                mtdx.line_speed = 1; /* 10M */
            if (data & DPLX_DET_FULL)
                mtdx.duplexmode = 2; /* full duplex mode */
            else
                mtdx.duplexmode = 1; /* half duplex mode */
        } else if (mtdx.PHYType == AhdocPHY) {
            unsigned int data;

            data = mdio_read(dev, mtdx.phys[0], DiagnosticReg);
            if (data & Speed_100)
                mtdx.line_speed = 2; /* 100M */
            else
                mtdx.line_speed = 1; /* 10M */
            if (data & DPLX_FULL)
                mtdx.duplexmode = 2; /* full duplex mode */
            else
                mtdx.duplexmode = 1; /* half duplex mode */
        }
        /* 89/6/13 add, (begin) */
        else if (mtdx.PHYType == MarvellPHY) {
            unsigned int data;

            data = mdio_read(dev, mtdx.phys[0], SpecificReg);
            if (data & Full_Duplex)
                mtdx.duplexmode = 2; /* full duplex mode */
            else
                mtdx.duplexmode = 1; /* half duplex mode */
            data &= SpeedMask;
            if (data == Speed_1000M)
                mtdx.line_speed = 3; /* 1000M */
            else if (data == Speed_100M)
                mtdx.line_speed = 2; /* 100M */
            else
                mtdx.line_speed = 1; /* 10M */
        }
        /* 89/6/13 add, (end) */
        /* 89/7/27 add, (begin) */
        else if (mtdx.PHYType == Myson981) {
            unsigned int data;

            data = mdio_read(dev, mtdx.phys[0], StatusRegister);

            if (data & SPEED100)
                mtdx.line_speed = 2;
            else
                mtdx.line_speed = 1;

            if (data & FULLMODE)
                mtdx.duplexmode = 2;
            else
                mtdx.duplexmode = 1;
        }
        /* 89/7/27 add, (end) */
        /* 89/12/29 add */
        else if (mtdx.PHYType == LevelOnePHY) {
            unsigned int data;

            data = mdio_read(dev, mtdx.phys[0], SpecificReg);
            if (data & LXT1000_Full)
                mtdx.duplexmode = 2; /* full duplex mode */
            else
                mtdx.duplexmode = 1; /* half duplex mode */
            data &= SpeedMask;
            if (data == LXT1000_1000M)
                mtdx.line_speed = 3; /* 1000M */
            else if (data == LXT1000_100M)
                mtdx.line_speed = 2; /* 100M */
            else
                mtdx.line_speed = 1; /* 10M */
        }
        // chage crvalue
        // mtdx.crvalue&=(~PS10)&(~FD);
        mtdx.crvalue &= (~PS10) & (~FD) & (~PS1000);
        if (mtdx.line_speed == 1)
            mtdx.crvalue |= PS10;
        else if (mtdx.line_speed == 3)
            mtdx.crvalue |= PS1000;
        if (mtdx.duplexmode == 2)
            mtdx.crvalue |= FD;
    }
}

DRIVER ( "MTD80X", nic_driver, pci_driver, mtd80x_driver,
         mtd_probe, mtd_disable );