/**************************************************************************
*    ns83820.c: Etherboot device driver for the National Semiconductor 83820
*    Written 2004 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:
*       ns83820.c by Benjamin LaHaise with contributions
*               for Linux kernel 2.4.x.
*       
*    Linux Driver Version 0.20, 20020610
* 
*    This development of this Etherboot driver was funded by:
*
*    NXTV: http://www.nxtv.com/
*       
*    REVISION HISTORY:
*    ================
*
*    v1.0       02-16-2004      timlegge        Initial port of Linux driver
*    v1.1       02-19-2004      timlegge        More rohbust transmit and poll
*    
*    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"

#if ARCH == ia64                /* Support 64-bit addressing */
#define USE_64BIT_ADDR
#endif

//#define DDEBUG
#ifdef DDEBUG
#define dprintf(x) printf x
#else
#define dprintf(x)
#endif

typedef unsigned char u8;
typedef signed char s8;
typedef unsigned short u16;
typedef signed short s16;
typedef unsigned int u32;
typedef signed int s32;

#define HZ 100

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

/* NIC specific static variables go here */

/* Global parameters.  See MODULE_PARM near the bottom. */
// static int ihr = 2;
static int reset_phy = 0;
static int lnksts = 0;          /* CFG_LNKSTS bit polarity */

#if defined(CONFIG_HIGHMEM64G) || defined(__ia64__)
#define USE_64BIT_ADDR  "+"
#endif

#if defined(USE_64BIT_ADDR)
#define TRY_DAC 1
#else
#define TRY_DAC 0
#endif

/* tunables */
#define RX_BUF_SIZE     1500    /* 8192 */

/* Must not exceed ~65000. */
#define NR_RX_DESC      64
#define NR_TX_DESC      1

                   /* not tunable *//* Extra 6 bytes for 64 bit alignment (divisable by 8) */
#define REAL_RX_BUF_SIZE (RX_BUF_SIZE + 14 + 6) /* rx/tx mac addr + type */

#define MIN_TX_DESC_FREE        8

/* register defines */
#define CFGCS           0x04

#define CR_TXE          0x00000001
#define CR_TXD          0x00000002
/* Ramit : Here's a tip, don't do a RXD immediately followed by an RXE
 * The Receive engine skips one descriptor and moves
 * onto the next one!! */
#define CR_RXE          0x00000004
#define CR_RXD          0x00000008
#define CR_TXR          0x00000010
#define CR_RXR          0x00000020
#define CR_SWI          0x00000080
#define CR_RST          0x00000100

#define PTSCR_EEBIST_FAIL       0x00000001
#define PTSCR_EEBIST_EN         0x00000002
#define PTSCR_EELOAD_EN         0x00000004
#define PTSCR_RBIST_FAIL        0x000001b8
#define PTSCR_RBIST_DONE        0x00000200
#define PTSCR_RBIST_EN          0x00000400
#define PTSCR_RBIST_RST         0x00002000

#define MEAR_EEDI               0x00000001
#define MEAR_EEDO               0x00000002
#define MEAR_EECLK              0x00000004
#define MEAR_EESEL              0x00000008
#define MEAR_MDIO               0x00000010
#define MEAR_MDDIR              0x00000020
#define MEAR_MDC                0x00000040

#define ISR_TXDESC3     0x40000000
#define ISR_TXDESC2     0x20000000
#define ISR_TXDESC1     0x10000000
#define ISR_TXDESC0     0x08000000
#define ISR_RXDESC3     0x04000000
#define ISR_RXDESC2     0x02000000
#define ISR_RXDESC1     0x01000000
#define ISR_RXDESC0     0x00800000
#define ISR_TXRCMP      0x00400000
#define ISR_RXRCMP      0x00200000
#define ISR_DPERR       0x00100000
#define ISR_SSERR       0x00080000
#define ISR_RMABT       0x00040000
#define ISR_RTABT       0x00020000
#define ISR_RXSOVR      0x00010000
#define ISR_HIBINT      0x00008000
#define ISR_PHY         0x00004000
#define ISR_PME         0x00002000
#define ISR_SWI         0x00001000
#define ISR_MIB         0x00000800
#define ISR_TXURN       0x00000400
#define ISR_TXIDLE      0x00000200
#define ISR_TXERR       0x00000100
#define ISR_TXDESC      0x00000080
#define ISR_TXOK        0x00000040
#define ISR_RXORN       0x00000020
#define ISR_RXIDLE      0x00000010
#define ISR_RXEARLY     0x00000008
#define ISR_RXERR       0x00000004
#define ISR_RXDESC      0x00000002
#define ISR_RXOK        0x00000001

#define TXCFG_CSI       0x80000000
#define TXCFG_HBI       0x40000000
#define TXCFG_MLB       0x20000000
#define TXCFG_ATP       0x10000000
#define TXCFG_ECRETRY   0x00800000
#define TXCFG_BRST_DIS  0x00080000
#define TXCFG_MXDMA1024 0x00000000
#define TXCFG_MXDMA512  0x00700000
#define TXCFG_MXDMA256  0x00600000
#define TXCFG_MXDMA128  0x00500000
#define TXCFG_MXDMA64   0x00400000
#define TXCFG_MXDMA32   0x00300000
#define TXCFG_MXDMA16   0x00200000
#define TXCFG_MXDMA8    0x00100000

#define CFG_LNKSTS      0x80000000
#define CFG_SPDSTS      0x60000000
#define CFG_SPDSTS1     0x40000000
#define CFG_SPDSTS0     0x20000000
#define CFG_DUPSTS      0x10000000
#define CFG_TBI_EN      0x01000000
#define CFG_MODE_1000   0x00400000
/* Ramit : Dont' ever use AUTO_1000, it never works and is buggy.
 * Read the Phy response and then configure the MAC accordingly */
#define CFG_AUTO_1000   0x00200000
#define CFG_PINT_CTL    0x001c0000
#define CFG_PINT_DUPSTS 0x00100000
#define CFG_PINT_LNKSTS 0x00080000
#define CFG_PINT_SPDSTS 0x00040000
#define CFG_TMRTEST     0x00020000
#define CFG_MRM_DIS     0x00010000
#define CFG_MWI_DIS     0x00008000
#define CFG_T64ADDR     0x00004000
#define CFG_PCI64_DET   0x00002000
#define CFG_DATA64_EN   0x00001000
#define CFG_M64ADDR     0x00000800
#define CFG_PHY_RST     0x00000400
#define CFG_PHY_DIS     0x00000200
#define CFG_EXTSTS_EN   0x00000100
#define CFG_REQALG      0x00000080
#define CFG_SB          0x00000040
#define CFG_POW         0x00000020
#define CFG_EXD         0x00000010
#define CFG_PESEL       0x00000008
#define CFG_BROM_DIS    0x00000004
#define CFG_EXT_125     0x00000002
#define CFG_BEM         0x00000001

#define EXTSTS_UDPPKT   0x00200000
#define EXTSTS_TCPPKT   0x00080000
#define EXTSTS_IPPKT    0x00020000

#define SPDSTS_POLARITY (CFG_SPDSTS1 | CFG_SPDSTS0 | CFG_DUPSTS | (lnksts ? CFG_LNKSTS : 0))

#define MIBC_MIBS       0x00000008
#define MIBC_ACLR       0x00000004
#define MIBC_FRZ        0x00000002
#define MIBC_WRN        0x00000001

#define PCR_PSEN        (1 << 31)
#define PCR_PS_MCAST    (1 << 30)
#define PCR_PS_DA       (1 << 29)
#define PCR_STHI_8      (3 << 23)
#define PCR_STLO_4      (1 << 23)
#define PCR_FFHI_8K     (3 << 21)
#define PCR_FFLO_4K     (1 << 21)
#define PCR_PAUSE_CNT   0xFFFE

#define RXCFG_AEP       0x80000000
#define RXCFG_ARP       0x40000000
#define RXCFG_STRIPCRC  0x20000000
#define RXCFG_RX_FD     0x10000000
#define RXCFG_ALP       0x08000000
#define RXCFG_AIRL      0x04000000
#define RXCFG_MXDMA512  0x00700000
#define RXCFG_DRTH      0x0000003e
#define RXCFG_DRTH0     0x00000002

#define RFCR_RFEN       0x80000000
#define RFCR_AAB        0x40000000
#define RFCR_AAM        0x20000000
#define RFCR_AAU        0x10000000
#define RFCR_APM        0x08000000
#define RFCR_APAT       0x07800000
#define RFCR_APAT3      0x04000000
#define RFCR_APAT2      0x02000000
#define RFCR_APAT1      0x01000000
#define RFCR_APAT0      0x00800000
#define RFCR_AARP       0x00400000
#define RFCR_MHEN       0x00200000
#define RFCR_UHEN       0x00100000
#define RFCR_ULM        0x00080000

#define VRCR_RUDPE      0x00000080
#define VRCR_RTCPE      0x00000040
#define VRCR_RIPE       0x00000020
#define VRCR_IPEN       0x00000010
#define VRCR_DUTF       0x00000008
#define VRCR_DVTF       0x00000004
#define VRCR_VTREN      0x00000002
#define VRCR_VTDEN      0x00000001

#define VTCR_PPCHK      0x00000008
#define VTCR_GCHK       0x00000004
#define VTCR_VPPTI      0x00000002
#define VTCR_VGTI       0x00000001

#define CR              0x00
#define CFG             0x04
#define MEAR            0x08
#define PTSCR           0x0c
#define ISR             0x10
#define IMR             0x14
#define IER             0x18
#define IHR             0x1c
#define TXDP            0x20
#define TXDP_HI         0x24
#define TXCFG           0x28
#define GPIOR           0x2c
#define RXDP            0x30
#define RXDP_HI         0x34
#define RXCFG           0x38
#define PQCR            0x3c
#define WCSR            0x40
#define PCR             0x44
#define RFCR            0x48
#define RFDR            0x4c

#define SRR             0x58

#define VRCR            0xbc
#define VTCR            0xc0
#define VDR             0xc4
#define CCSR            0xcc

#define TBICR           0xe0
#define TBISR           0xe4
#define TANAR           0xe8
#define TANLPAR         0xec
#define TANER           0xf0
#define TESR            0xf4

#define TBICR_MR_AN_ENABLE      0x00001000
#define TBICR_MR_RESTART_AN     0x00000200

#define TBISR_MR_LINK_STATUS    0x00000020
#define TBISR_MR_AN_COMPLETE    0x00000004

#define TANAR_PS2               0x00000100
#define TANAR_PS1               0x00000080
#define TANAR_HALF_DUP          0x00000040
#define TANAR_FULL_DUP          0x00000020

#define GPIOR_GP5_OE            0x00000200
#define GPIOR_GP4_OE            0x00000100
#define GPIOR_GP3_OE            0x00000080
#define GPIOR_GP2_OE            0x00000040
#define GPIOR_GP1_OE            0x00000020
#define GPIOR_GP3_OUT           0x00000004
#define GPIOR_GP1_OUT           0x00000001

#define LINK_AUTONEGOTIATE      0x01
#define LINK_DOWN               0x02
#define LINK_UP                 0x04


#define __kick_rx()     writel(CR_RXE, ns->base + CR)

#define kick_rx() do { \
        dprintf(("kick_rx: maybe kicking\n")); \
                writel(virt_to_le32desc(&rx_ring[ns->cur_rx]), ns->base + RXDP); \
                if (ns->next_rx == ns->next_empty) \
                        printf("uh-oh: next_rx == next_empty???\n"); \
                __kick_rx(); \
} while(0)


#ifdef USE_64BIT_ADDR
#define HW_ADDR_LEN     8
#else
#define HW_ADDR_LEN     4
#endif

#define CMDSTS_OWN      0x80000000
#define CMDSTS_MORE     0x40000000
#define CMDSTS_INTR     0x20000000
#define CMDSTS_ERR      0x10000000
#define CMDSTS_OK       0x08000000
#define CMDSTS_LEN_MASK 0x0000ffff

#define CMDSTS_DEST_MASK        0x01800000
#define CMDSTS_DEST_SELF        0x00800000
#define CMDSTS_DEST_MULTI       0x01000000

#define DESC_SIZE       8       /* Should be cache line sized */

#ifdef USE_64BIT_ADDR
struct ring_desc {
        uint64_t link;
        uint64_t bufptr;
        u32 cmdsts;
        u32 extsts;             /* Extended status field */
};
#else
struct ring_desc {
        u32 link;
        u32 bufptr;
        u32 cmdsts;
        u32 extsts;             /* Extended status field */
};
#endif

/* Define the TX Descriptor */
static struct ring_desc tx_ring[NR_TX_DESC]
    __attribute__ ((aligned(8)));

/* Create a static buffer of size REAL_RX_BUF_SIZE for each
TX Descriptor.  All descriptors point to a
part of this buffer */
static unsigned char txb[NR_TX_DESC * REAL_RX_BUF_SIZE];

/* Define the TX Descriptor */
static struct ring_desc rx_ring[NR_RX_DESC]
    __attribute__ ((aligned(8)));

/* Create a static buffer of size REAL_RX_BUF_SIZE for each
RX Descriptor   All descriptors point to a
part of this buffer */
static unsigned char rxb[NR_RX_DESC * REAL_RX_BUF_SIZE]
    __attribute__ ((aligned(8)));

/* Private Storage for the NIC */
struct ns83820_private {
        u8 *base;
        int up;
        long idle;
        u32 *next_rx_desc;
        u16 next_rx, next_empty;
        u32 cur_rx;
        u32 *descs;
        unsigned ihr;
        u32 CFG_cache;
        u32 MEAR_cache;
        u32 IMR_cache;
        int linkstate;
        u16 tx_done_idx;
        u16 tx_idx;
        u16 tx_intr_idx;
        u32 phy_descs;
        u32 *tx_descs;

} nsx;
static struct ns83820_private *ns;

static void phy_intr(struct nic *nic __unused)
{
        static char *speeds[] =
            { "10", "100", "1000", "1000(?)", "1000F" };
        u32 cfg, new_cfg;
        u32 tbisr, tanar, tanlpar;
        int speed, fullduplex, newlinkstate;

        cfg = readl(ns->base + CFG) ^ SPDSTS_POLARITY;
        if (ns->CFG_cache & CFG_TBI_EN) {
                /* we have an optical transceiver */
                tbisr = readl(ns->base + TBISR);
                tanar = readl(ns->base + TANAR);
                tanlpar = readl(ns->base + TANLPAR);
                dprintf(("phy_intr: tbisr=%hX, tanar=%hX, tanlpar=%hX\n",
                         tbisr, tanar, tanlpar));

                if ((fullduplex = (tanlpar & TANAR_FULL_DUP)
                     && (tanar & TANAR_FULL_DUP))) {

                        /* both of us are full duplex */
                        writel(readl(ns->base + TXCFG)
                               | TXCFG_CSI | TXCFG_HBI | TXCFG_ATP,
                               ns->base + TXCFG);
                        writel(readl(ns->base + RXCFG) | RXCFG_RX_FD,
                               ns->base + RXCFG);
                        /* Light up full duplex LED */
                        writel(readl(ns->base + GPIOR) | GPIOR_GP1_OUT,
                               ns->base + GPIOR);

                } else if (((tanlpar & TANAR_HALF_DUP)
                            && (tanar & TANAR_HALF_DUP))
                           || ((tanlpar & TANAR_FULL_DUP)
                               && (tanar & TANAR_HALF_DUP))
                           || ((tanlpar & TANAR_HALF_DUP)
                               && (tanar & TANAR_FULL_DUP))) {

                        /* one or both of us are half duplex */
                        writel((readl(ns->base + TXCFG)
                                & ~(TXCFG_CSI | TXCFG_HBI)) | TXCFG_ATP,
                               ns->base + TXCFG);
                        writel(readl(ns->base + RXCFG) & ~RXCFG_RX_FD,
                               ns->base + RXCFG);
                        /* Turn off full duplex LED */
                        writel(readl(ns->base + GPIOR) & ~GPIOR_GP1_OUT,
                               ns->base + GPIOR);
                }

                speed = 4;      /* 1000F */

        } else {
                /* we have a copper transceiver */
                new_cfg =
                    ns->CFG_cache & ~(CFG_SB | CFG_MODE_1000 | CFG_SPDSTS);

                if (cfg & CFG_SPDSTS1)
                        new_cfg |= CFG_MODE_1000;
                else
                        new_cfg &= ~CFG_MODE_1000;

                speed = ((cfg / CFG_SPDSTS0) & 3);
                fullduplex = (cfg & CFG_DUPSTS);

                if (fullduplex)
                        new_cfg |= CFG_SB;

                if ((cfg & CFG_LNKSTS) &&
                    ((new_cfg ^ ns->CFG_cache) & CFG_MODE_1000)) {
                        writel(new_cfg, ns->base + CFG);
                        ns->CFG_cache = new_cfg;
                }

                ns->CFG_cache &= ~CFG_SPDSTS;
                ns->CFG_cache |= cfg & CFG_SPDSTS;
        }

        newlinkstate = (cfg & CFG_LNKSTS) ? LINK_UP : LINK_DOWN;

        if (newlinkstate & LINK_UP && ns->linkstate != newlinkstate) {
                printf("link now %s mbps, %s duplex and up.\n",
                       speeds[speed], fullduplex ? "full" : "half");
        } else if (newlinkstate & LINK_DOWN
                   && ns->linkstate != newlinkstate) {
                printf("link now down.\n");
        }
        ns->linkstate = newlinkstate;
}
static void ns83820_set_multicast(struct nic *nic __unused);
static void ns83820_setup_rx(struct nic *nic)
{
        unsigned i;
        ns->idle = 1;
        ns->next_rx = 0;
        ns->next_rx_desc = ns->descs;
        ns->next_empty = 0;
        ns->cur_rx = 0;


        for (i = 0; i < NR_RX_DESC; i++) {
                rx_ring[i].link = virt_to_le32desc(&rx_ring[i + 1]);
                rx_ring[i].bufptr =
                    virt_to_le32desc(&rxb[i * REAL_RX_BUF_SIZE]);
                rx_ring[i].cmdsts = cpu_to_le32(REAL_RX_BUF_SIZE);
                rx_ring[i].extsts = cpu_to_le32(0);
        }
//      No need to wrap the ring 
//      rx_ring[i].link = virt_to_le32desc(&rx_ring[0]);
        writel(0, ns->base + RXDP_HI);
        writel(virt_to_le32desc(&rx_ring[0]), ns->base + RXDP);

        dprintf(("starting receiver\n"));

        writel(0x0001, ns->base + CCSR);
        writel(0, ns->base + RFCR);
        writel(0x7fc00000, ns->base + RFCR);
        writel(0xffc00000, ns->base + RFCR);

        ns->up = 1;

        phy_intr(nic);

        /* Okay, let it rip */
        ns->IMR_cache |= ISR_PHY;
        ns->IMR_cache |= ISR_RXRCMP;
        //dev->IMR_cache |= ISR_RXERR;
        //dev->IMR_cache |= ISR_RXOK;
        ns->IMR_cache |= ISR_RXORN;
        ns->IMR_cache |= ISR_RXSOVR;
        ns->IMR_cache |= ISR_RXDESC;
        ns->IMR_cache |= ISR_RXIDLE;
        ns->IMR_cache |= ISR_TXDESC;
        ns->IMR_cache |= ISR_TXIDLE;

        // No reason to enable interupts...
        // writel(ns->IMR_cache, ns->base + IMR);
        // writel(1, ns->base + IER);
        ns83820_set_multicast(nic);
        kick_rx();
}


static void ns83820_do_reset(struct nic *nic __unused, u32 which)
{
        dprintf(("resetting chip...\n"));
        writel(which, ns->base + CR);
        do {

        } while (readl(ns->base + CR) & which);
        dprintf(("okay!\n"));
}

static void ns83820_reset(struct nic *nic)
{
        unsigned i;
        dprintf(("ns83820_reset\n"));

        writel(0, ns->base + PQCR);

        ns83820_setup_rx(nic);

        for (i = 0; i < NR_TX_DESC; i++) {
                tx_ring[i].link = 0;
                tx_ring[i].bufptr = 0;
                tx_ring[i].cmdsts = cpu_to_le32(0);
                tx_ring[i].extsts = cpu_to_le32(0);
        }

        ns->tx_idx = 0;
        ns->tx_done_idx = 0;
        writel(0, ns->base + TXDP_HI);
        return;
}
static void ns83820_getmac(struct nic *nic __unused, u8 * mac)
{
        unsigned i;
        for (i = 0; i < 3; i++) {
                u32 data;
                /* Read from the perfect match memory: this is loaded by
                 * the chip from the EEPROM via the EELOAD self test.
                 */
                writel(i * 2, ns->base + RFCR);
                data = readl(ns->base + RFDR);
                *mac++ = data;
                *mac++ = data >> 8;
        }
}

static void ns83820_set_multicast(struct nic *nic __unused)
{
        u8 *rfcr = ns->base + RFCR;
        u32 and_mask = 0xffffffff;
        u32 or_mask = 0;
        u32 val;

        /* Support Multicast */
        and_mask &= ~(RFCR_AAU | RFCR_AAM);
        or_mask |= RFCR_AAM;
        val = (readl(rfcr) & and_mask) | or_mask;
        /* Ramit : RFCR Write Fix doc says RFEN must be 0 modify other bits */
        writel(val & ~RFCR_RFEN, rfcr);
        writel(val, rfcr);

}
static void ns83820_run_bist(struct nic *nic __unused, const char *name,
                             u32 enable, u32 done, u32 fail)
{
        int timed_out = 0;
        long start;
        u32 status;
        int loops = 0;

        dprintf(("start %s\n", name))

            start = currticks();

        writel(enable, ns->base + PTSCR);
        for (;;) {
                loops++;
                status = readl(ns->base + PTSCR);
                if (!(status & enable))
                        break;
                if (status & done)
                        break;
                if (status & fail)
                        break;
                if ((currticks() - start) >= HZ) {
                        timed_out = 1;
                        break;
                }
        }

        if (status & fail)
                printf("%s failed! (0x%hX & 0x%hX)\n", name, status, fail);
        else if (timed_out)
                printf("run_bist %s timed out! (%hX)\n", name, status);
        dprintf(("done %s in %d loops\n", name, loops));
}

/*************************************
Check Link
*************************************/
static void ns83820_check_intr(struct nic *nic) {
        int i;
        u32 isr = readl(ns->base + ISR);
        if(ISR_PHY & isr)
                phy_intr(nic);
        if(( ISR_RXIDLE | ISR_RXDESC | ISR_RXERR) & isr)
                kick_rx();
        for (i = 0; i < NR_RX_DESC; i++) {
                if (rx_ring[i].cmdsts == CMDSTS_OWN) {
//                      rx_ring[i].link = virt_to_le32desc(&rx_ring[i + 1]);
                        rx_ring[i].cmdsts = cpu_to_le32(REAL_RX_BUF_SIZE);
                }
        }
}
/**************************************************************************
POLL - Wait for a frame
***************************************************************************/
static int ns83820_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 cmdsts;
        int entry = ns->cur_rx;

        ns83820_check_intr(nic);

        cmdsts = le32_to_cpu(rx_ring[entry].cmdsts);

        if ( ! ( (CMDSTS_OWN & (cmdsts)) && (cmdsts != (CMDSTS_OWN)) ) )
          return 0;

        if ( ! retrieve ) return 1;

        if (! (CMDSTS_OK & cmdsts) )
          return 0;

        nic->packetlen = cmdsts & 0xffff;
        memcpy(nic->packet,
               rxb + (entry * REAL_RX_BUF_SIZE),
               nic->packetlen);
        //                      rx_ring[entry].link = 0;
        rx_ring[entry].cmdsts = cpu_to_le32(CMDSTS_OWN);

        ns->cur_rx = ++ns->cur_rx % NR_RX_DESC;

        if (ns->cur_rx == 0)    /* We have wrapped the ring */
          kick_rx();

        return 1;
}

static inline void kick_tx(struct nic *nic __unused)
{
        dprintf(("kick_tx\n"));
        writel(CR_TXE, ns->base + CR);
}

/**************************************************************************
TRANSMIT - Transmit a frame
***************************************************************************/
static void ns83820_transmit(struct nic *nic, const char *d,    /* Destination */
                             unsigned int t,    /* Type */
                             unsigned int s,    /* size */
                             const char *p)
{                               /* Packet */
        /* send the packet to destination */

        u16 nstype;
        u32 cmdsts, extsts;
        int cur_tx = 0;
        u32 isr = readl(ns->base + ISR);
        if (ISR_TXIDLE & isr)
                kick_tx(nic);
        /* point to the current txb incase multiple tx_rings are used */
        memcpy(txb, d, ETH_ALEN);
        memcpy(txb + ETH_ALEN, nic->node_addr, ETH_ALEN);
        nstype = htons((u16) t);
        memcpy(txb + 2 * ETH_ALEN, (u8 *) & nstype, 2);
        memcpy(txb + ETH_HLEN, p, s);
        s += ETH_HLEN;
        s &= 0x0FFF;
        while (s < ETH_ZLEN)
                txb[s++] = '\0';

        /* Setup the transmit descriptor */
        extsts = 0;
        extsts |= EXTSTS_UDPPKT;

        tx_ring[cur_tx].bufptr = virt_to_le32desc(&txb);
        tx_ring[cur_tx].extsts = cpu_to_le32(extsts);

        cmdsts = cpu_to_le32(0);
        cmdsts |= cpu_to_le32(CMDSTS_OWN | s);
        tx_ring[cur_tx].cmdsts = cpu_to_le32(cmdsts);

        writel(virt_to_le32desc(&tx_ring[0]), ns->base + TXDP);
        kick_tx(nic);
}

/**************************************************************************
DISABLE - Turn off ethernet interface
***************************************************************************/
static void ns83820_disable(struct dev *dev)
{
        /* 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.
         */
        /* disable interrupts */
        writel(0, ns->base + IMR);
        writel(0, ns->base + IER);
        readl(ns->base + IER);

        ns->up = 0;

        ns83820_do_reset((struct nic *) dev, CR_RST);

        ns->IMR_cache &=
            ~(ISR_RXOK | ISR_RXDESC | ISR_RXERR | ISR_RXEARLY |
              ISR_RXIDLE);
        writel(ns->IMR_cache, ns->base + IMR);

        /* touch the pci bus... */
        readl(ns->base + IMR);

        /* assumes the transmitter is already disabled and reset */
        writel(0, ns->base + RXDP_HI);
        writel(0, ns->base + RXDP);
}

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

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

#define board_found 1
#define valid_link 0
static int ns83820_probe(struct dev *dev, struct pci_device *pci)
{
        struct nic *nic = (struct nic *) dev;
        int sz;
        long addr;
        int using_dac = 0;

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

        printf("ns83820.c: Found %s, vendor=0x%hX, device=0x%hX\n",
               pci->name, pci->vendor, pci->dev_id);

        /* point to private storage */
        ns = &nsx;

        adjust_pci_device(pci);

        addr = pci_bar_start(pci, PCI_BASE_ADDRESS_1);
        sz = pci_bar_size(pci, PCI_BASE_ADDRESS_1);

        ns->base = ioremap(addr, (1UL << 12));
//      ns->base = ioremap(addr, sz);

        if (!ns->base)
                return 0;

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

        /* disable interrupts */
        writel(0, ns->base + IMR);
        writel(0, ns->base + IER);
        readl(ns->base + IER);

        ns->IMR_cache = 0;

        ns83820_do_reset(nic, CR_RST);

        /* Must reset the ram bist before running it */
        writel(PTSCR_RBIST_RST, ns->base + PTSCR);
        ns83820_run_bist(nic, "sram bist", PTSCR_RBIST_EN,
                         PTSCR_RBIST_DONE, PTSCR_RBIST_FAIL);
        ns83820_run_bist(nic, "eeprom bist", PTSCR_EEBIST_EN, 0,
                         PTSCR_EEBIST_FAIL);
        ns83820_run_bist(nic, "eeprom load", PTSCR_EELOAD_EN, 0, 0);

        /* I love config registers */
        ns->CFG_cache = readl(ns->base + CFG);

        if ((ns->CFG_cache & CFG_PCI64_DET)) {
                printf("%s: detected 64 bit PCI data bus.\n", pci->name);
                /*dev->CFG_cache |= CFG_DATA64_EN; */
                if (!(ns->CFG_cache & CFG_DATA64_EN))
                        printf
                            ("%s: EEPROM did not enable 64 bit bus.  Disabled.\n",
                             pci->name);
        } else
                ns->CFG_cache &= ~(CFG_DATA64_EN);

        ns->CFG_cache &= (CFG_TBI_EN | CFG_MRM_DIS | CFG_MWI_DIS |
                          CFG_T64ADDR | CFG_DATA64_EN | CFG_EXT_125 |
                          CFG_M64ADDR);
        ns->CFG_cache |=
            CFG_PINT_DUPSTS | CFG_PINT_LNKSTS | CFG_PINT_SPDSTS |
            CFG_EXTSTS_EN | CFG_EXD | CFG_PESEL;
        ns->CFG_cache |= CFG_REQALG;
        ns->CFG_cache |= CFG_POW;
        ns->CFG_cache |= CFG_TMRTEST;

        /* When compiled with 64 bit addressing, we must always enable
         * the 64 bit descriptor format.
         */
#ifdef USE_64BIT_ADDR
        ns->CFG_cache |= CFG_M64ADDR;
#endif

//FIXME: Enable section on dac or remove this
        if (using_dac)
                ns->CFG_cache |= CFG_T64ADDR;

        /* Big endian mode does not seem to do what the docs suggest */
        ns->CFG_cache &= ~CFG_BEM;

        /* setup optical transceiver if we have one */
        if (ns->CFG_cache & CFG_TBI_EN) {
                dprintf(("%s: enabling optical transceiver\n", pci->name));
                writel(readl(ns->base + GPIOR) | 0x3e8, ns->base + GPIOR);

                /* setup auto negotiation feature advertisement */
                writel(readl(ns->base + TANAR)
                       | TANAR_HALF_DUP | TANAR_FULL_DUP,
                       ns->base + TANAR);

                /* start auto negotiation */
                writel(TBICR_MR_AN_ENABLE | TBICR_MR_RESTART_AN,
                       ns->base + TBICR);
                writel(TBICR_MR_AN_ENABLE, ns->base + TBICR);
                ns->linkstate = LINK_AUTONEGOTIATE;

                ns->CFG_cache |= CFG_MODE_1000;
        }
        writel(ns->CFG_cache, ns->base + CFG);
        dprintf(("CFG: %hX\n", ns->CFG_cache));

        /* FIXME: reset_phy is defaulted to 0, should we reset anyway? */
        if (reset_phy) {
                dprintf(("%s: resetting phy\n", pci->name));
                writel(ns->CFG_cache | CFG_PHY_RST, ns->base + CFG);
                writel(ns->CFG_cache, ns->base + CFG);
        }
#if 0                           /* Huh?  This sets the PCI latency register.  Should be done via 
                                 * the PCI layer.  FIXME.
                                 */
        if (readl(dev->base + SRR))
                writel(readl(dev->base + 0x20c) | 0xfe00,
                       dev->base + 0x20c);
#endif

        /* Note!  The DMA burst size interacts with packet
         * transmission, such that the largest packet that
         * can be transmitted is 8192 - FLTH - burst size.
         * If only the transmit fifo was larger...
         */
        /* Ramit : 1024 DMA is not a good idea, it ends up banging 
         * some DELL and COMPAQ SMP systems */
        writel(TXCFG_CSI | TXCFG_HBI | TXCFG_ATP | TXCFG_MXDMA512
               | ((1600 / 32) * 0x100), ns->base + TXCFG);

        /* Set Rx to full duplex, don't accept runt, errored, long or length
         * range errored packets.  Use 512 byte DMA.
         */
        /* Ramit : 1024 DMA is not a good idea, it ends up banging 
         * some DELL and COMPAQ SMP systems 
         * Turn on ALP, only we are accpeting Jumbo Packets */
        writel(RXCFG_AEP | RXCFG_ARP | RXCFG_AIRL | RXCFG_RX_FD
               | RXCFG_STRIPCRC
               //| RXCFG_ALP
               | (RXCFG_MXDMA512) | 0, ns->base + RXCFG);

        /* Disable priority queueing */
        writel(0, ns->base + PQCR);

        /* Enable IP checksum validation and detetion of VLAN headers.
         * Note: do not set the reject options as at least the 0x102
         * revision of the chip does not properly accept IP fragments
         * at least for UDP.
         */
        /* Ramit : Be sure to turn on RXCFG_ARP if VLAN's are enabled, since
         * the MAC it calculates the packetsize AFTER stripping the VLAN
         * header, and if a VLAN Tagged packet of 64 bytes is received (like
         * a ping with a VLAN header) then the card, strips the 4 byte VLAN
         * tag and then checks the packet size, so if RXCFG_ARP is not enabled,
         * it discrards it!.  These guys......
         */
        writel(VRCR_IPEN | VRCR_VTDEN, ns->base + VRCR);

        /* Enable per-packet TCP/UDP/IP checksumming */
        writel(VTCR_PPCHK, ns->base + VTCR);

        /* Ramit : Enable async and sync pause frames */
//      writel(0, ns->base + PCR); 
        writel((PCR_PS_MCAST | PCR_PS_DA | PCR_PSEN | PCR_FFLO_4K |
                PCR_FFHI_8K | PCR_STLO_4 | PCR_STHI_8 | PCR_PAUSE_CNT),
               ns->base + PCR);

        /* Disable Wake On Lan */
        writel(0, ns->base + WCSR);

        ns83820_getmac(nic, nic->node_addr);
        printf("%! at ioaddr 0x%hX, ", nic->node_addr, ns->base);

        if (using_dac) {
                dprintf(("%s: using 64 bit addressing.\n", pci->name));
        }

        dprintf(("%s: DP83820 %d.%d: %! io=0x%hX\n",
                 pci->name,
                 (unsigned) readl(ns->base + SRR) >> 8,
                 (unsigned) readl(ns->base + SRR) & 0xff,
                 nic->node_addr, pci->ioaddr));

#ifdef PHY_CODE_IS_FINISHED
        ns83820_probe_phy(dev);
#endif

        ns83820_reset(nic);
        /* point to NIC specific routines */
        dev->disable  = ns83820_disable;
        nic->poll     = ns83820_poll;
        nic->transmit = ns83820_transmit;
        nic->irq      = ns83820_irq;
        return 1;
}

static struct pci_id ns83820_nics[] = {
        PCI_ROM(0x100b, 0x0022, "ns83820", "National Semiconductor 83820"),
};

struct pci_driver ns83820_driver = {
        .type = NIC_DRIVER,
        .name = "NS83820/PCI",
        .probe = ns83820_probe,
        .ids = ns83820_nics,
        .id_count = sizeof(ns83820_nics) / sizeof(ns83820_nics[0]),
        .class = 0,
};