sunhme.c

Go to the documentation of this file.

/* sunhme.c: Sparc HME/BigMac 10/100baseT half/full duplex auto switching,
 *           auto carrier detecting ethernet driver.  Also known as the
 *           "Happy Meal Ethernet" found on SunSwift SBUS cards.
 *
 * Copyright (C) 1996, 1998 David S. Miller (davem@caipfs.rutgers.edu)
 */

static char *version =
        "sunhme.c:v1.10 27/Jan/99 David S. Miller (davem@caipfs.rutgers.edu)\n";

#include <linux/module.h>

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/in.h>
#include <linux/malloc.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <asm/system.h>
#include <asm/bitops.h>
#include <asm/io.h>
#include <asm/dma.h>
#include <linux/errno.h>
#include <asm/byteorder.h>

#include <asm/idprom.h>
#include <asm/sbus.h>
#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/auxio.h>
#include <asm/pgtable.h>
#include <asm/irq.h>
#ifndef __sparc_v9__
#include <asm/io-unit.h>
#endif
#include <asm/ethtool.h>
#include <asm/uaccess.h>

#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>

#ifdef CONFIG_PCI
#include <linux/pci.h>
#include <asm/pbm.h>
#endif

#include "sunhme.h"

#ifdef MODULE
static struct happy_meal *root_happy_dev = NULL;
#endif

static struct quattro *qfe_sbus_list = NULL;
#ifdef CONFIG_PCI
static struct quattro *qfe_pci_list = NULL;
#endif

#undef HMEDEBUG
#undef SXDEBUG
#undef RXDEBUG
#undef TXDEBUG
#undef TXLOGGING

#ifdef TXLOGGING
struct hme_tx_logent {
        unsigned int tstamp;
        int tx_new, tx_old;
        unsigned int action;
#define TXLOG_ACTION_IRQ        0x01
#define TXLOG_ACTION_TXMIT      0x02
#define TXLOG_ACTION_TBUSY      0x04
#define TXLOG_ACTION_NBUFS      0x08
        unsigned int status;
};
#define TX_LOG_LEN      128
static struct hme_tx_logent tx_log[TX_LOG_LEN];
static int txlog_cur_entry = 0;
static __inline__ void tx_add_log(struct happy_meal *hp, unsigned int a, unsigned int s)
{
        struct hme_tx_logent *tlp;
        unsigned long flags;

        save_and_cli(flags);
        tlp = &tx_log[txlog_cur_entry];
        tlp->tstamp = (unsigned int)jiffies;
        tlp->tx_new = hp->tx_new;
        tlp->tx_old = hp->tx_old;
        tlp->action = a;
        tlp->status = s;
        txlog_cur_entry = (txlog_cur_entry + 1) & (TX_LOG_LEN - 1);
        restore_flags(flags);
}
static __inline__ void tx_dump_log(void)
{
        int i, this;

        this = txlog_cur_entry;
        for(i = 0; i < TX_LOG_LEN; i++) {
                printk("TXLOG[%d]: j[%08x] tx[N(%d)O(%d)] action[%08x] stat[%08x]\n", i,
                       tx_log[this].tstamp,
                       tx_log[this].tx_new, tx_log[this].tx_old,
                       tx_log[this].action, tx_log[this].status);
                this = (this + 1) & (TX_LOG_LEN - 1);
        }
}
static __inline__ void tx_dump_ring(struct happy_meal *hp)
{
        struct hmeal_init_block *hb = hp->happy_block;
        struct happy_meal_txd *tp = &hb->happy_meal_txd[0];
        int i;

        for(i = 0; i < TX_RING_SIZE; i+=4) {
                printk("TXD[%d..%d]: [%08x:%08x] [%08x:%08x] [%08x:%08x] [%08x:%08x]\n",
                       i, i + 4,
                       le32_to_cpu(tp[i].tx_flags), le32_to_cpu(tp[i].tx_addr),
                       le32_to_cpu(tp[i + 1].tx_flags), le32_to_cpu(tp[i + 1].tx_addr),
                       le32_to_cpu(tp[i + 2].tx_flags), le32_to_cpu(tp[i + 2].tx_addr),
                       le32_to_cpu(tp[i + 3].tx_flags), le32_to_cpu(tp[i + 3].tx_addr));
        }
}
#else
#define tx_add_log(hp, a, s)            do { } while(0)
#define tx_dump_log()                   do { } while(0)
#define tx_dump_ring(hp)                do { } while(0)
#endif

#ifdef HMEDEBUG
#define HMD(x)  printk x
#else
#define HMD(x)
#endif

/* #define AUTO_SWITCH_DEBUG */

#ifdef AUTO_SWITCH_DEBUG
#define ASD(x)  printk x
#else
#define ASD(x)
#endif

#define DEFAULT_IPG0      16 /* For lance-mode only */
#define DEFAULT_IPG1       8 /* For all modes */
#define DEFAULT_IPG2       4 /* For all modes */
#define DEFAULT_JAMSIZE    4 /* Toe jam */

/* Oh yes, the MIF BitBang is mighty fun to program.  BitBucket is more like it. */
#define BB_PUT_BIT(hp, tregs, bit)                                              \
do {    hme_write32(hp, &(tregs)->bb_data, (bit));                              \
        hme_write32(hp, &(tregs)->bb_clock, 0);                                 \
        hme_write32(hp, &(tregs)->bb_clock, 1);                                 \
} while(0)

#define BB_GET_BIT(hp, tregs, internal)                                         \
({                                                                              \
        hme_write32(hp, &(tregs)->bb_clock, 0);                                 \
        hme_write32(hp, &(tregs)->bb_clock, 1);                                 \
        if(internal)                                                            \
                hme_read32(hp, &(tregs)->cfg) & TCV_CFG_MDIO0;                  \
        else                                                                    \
                hme_read32(hp, &(tregs)->cfg) & TCV_CFG_MDIO1;                  \
})

#define BB_GET_BIT2(hp, tregs, internal)                                        \
({                                                                              \
        int retval;                                                             \
        hme_write32(hp, &(tregs)->bb_clock, 0);                                 \
        udelay(1);                                                              \
        if(internal)                                                            \
                retval = hme_read32(hp, &(tregs)->cfg) & TCV_CFG_MDIO0;         \
        else                                                                    \
                retval = hme_read32(hp, &(tregs)->cfg) & TCV_CFG_MDIO1;         \
        hme_write32(hp, &(tregs)->bb_clock, 1);                                 \
        retval;                                                                 \
})

#define TCVR_FAILURE      0x80000000     /* Impossible MIF read value */

static inline int happy_meal_bb_read(struct happy_meal *hp,
                                     struct hmeal_tcvregs *tregs, int reg)
{
        volatile int unused;
        unsigned long tmp;
        int retval = 0;
        int i;

        ASD(("happy_meal_bb_read: reg=%d ", reg));

        /* Enable the MIF BitBang outputs. */
        hme_write32(hp, &tregs->bb_oenab, 1);

        /* Force BitBang into the idle state. */
        for(i = 0; i < 32; i++)
                BB_PUT_BIT(hp, tregs, 1);

        /* Give it the read sequence. */
        BB_PUT_BIT(hp, tregs, 0);
        BB_PUT_BIT(hp, tregs, 1);
        BB_PUT_BIT(hp, tregs, 1);
        BB_PUT_BIT(hp, tregs, 0);

        /* Give it the PHY address. */
        tmp = hp->paddr & 0xff;
        for(i = 4; i >= 0; i--)
                BB_PUT_BIT(hp, tregs, ((tmp >> i) & 1));

        /* Tell it what register we want to read. */
        tmp = (reg & 0xff);
        for(i = 4; i >= 0; i--)
                BB_PUT_BIT(hp, tregs, ((tmp >> i) & 1));

        /* Close down the MIF BitBang outputs. */
        hme_write32(hp, &tregs->bb_oenab, 0);

        /* Now read in the value. */
        unused = BB_GET_BIT2(hp, tregs, (hp->tcvr_type == internal));
        for(i = 15; i >= 0; i--)
                retval |= BB_GET_BIT2(hp, tregs, (hp->tcvr_type == internal));
        unused = BB_GET_BIT2(hp, tregs, (hp->tcvr_type == internal));
        unused = BB_GET_BIT2(hp, tregs, (hp->tcvr_type == internal));
        unused = BB_GET_BIT2(hp, tregs, (hp->tcvr_type == internal));
        ASD(("value=%x\n", retval));
        return retval;
}

static inline void happy_meal_bb_write(struct happy_meal *hp,
                                       struct hmeal_tcvregs *tregs, int reg,
                                       unsigned short value)
{
        unsigned long tmp;
        int i;

        ASD(("happy_meal_bb_write: reg=%d value=%x\n", reg, value));

        /* Enable the MIF BitBang outputs. */
        hme_write32(hp, &tregs->bb_oenab, 1);

        /* Force BitBang into the idle state. */
        for(i = 0; i < 32; i++)
                BB_PUT_BIT(hp, tregs, 1);

        /* Give it write sequence. */
        BB_PUT_BIT(hp, tregs, 0);
        BB_PUT_BIT(hp, tregs, 1);
        BB_PUT_BIT(hp, tregs, 0);
        BB_PUT_BIT(hp, tregs, 1);

        /* Give it the PHY address. */
        tmp = (hp->paddr & 0xff);
        for(i = 4; i >= 0; i--)
                BB_PUT_BIT(hp, tregs, ((tmp >> i) & 1));

        /* Tell it what register we will be writing. */
        tmp = (reg & 0xff);
        for(i = 4; i >= 0; i--)
                BB_PUT_BIT(hp, tregs, ((tmp >> i) & 1));

        /* Tell it to become ready for the bits. */
        BB_PUT_BIT(hp, tregs, 1);
        BB_PUT_BIT(hp, tregs, 0);

        for(i = 15; i >= 0; i--)
                BB_PUT_BIT(hp, tregs, ((value >> i) & 1));

        /* Close down the MIF BitBang outputs. */
        hme_write32(hp, &tregs->bb_oenab, 0);
}

#define TCVR_READ_TRIES   16

static inline int happy_meal_tcvr_read(struct happy_meal *hp,
                                       struct hmeal_tcvregs *tregs, int reg)
{
        int tries = TCVR_READ_TRIES;
        int retval;

        ASD(("happy_meal_tcvr_read: reg=0x%02x ", reg));
        if(hp->tcvr_type == none) {
                ASD(("no transceiver, value=TCVR_FAILURE\n"));
                return TCVR_FAILURE;
        }

        if(!(hp->happy_flags & HFLAG_FENABLE)) {
                ASD(("doing bit bang\n"));
                return happy_meal_bb_read(hp, tregs, reg);
        }

        hme_write32(hp, &tregs->frame,
                    (FRAME_READ | (hp->paddr << 23) | ((reg & 0xff) << 18)));
        while(!(hme_read32(hp, &tregs->frame) & 0x10000) && --tries)
                udelay(20);
        if(!tries) {
                printk(KERN_ERR "happy meal: Aieee, transceiver MIF read bolixed\n");
                return TCVR_FAILURE;
        }
        retval = hme_read32(hp, &tregs->frame) & 0xffff;
        ASD(("value=%04x\n", retval));
        return retval;
}

#define TCVR_WRITE_TRIES  16

static inline void happy_meal_tcvr_write(struct happy_meal *hp,
                                         struct hmeal_tcvregs *tregs, int reg,
                                         unsigned short value)
{
        int tries = TCVR_WRITE_TRIES;
        
        ASD(("happy_meal_tcvr_write: reg=0x%02x value=%04x\n", reg, value));

        /* Welcome to Sun Microsystems, can I take your order please? */
        if(!hp->happy_flags & HFLAG_FENABLE)
                return happy_meal_bb_write(hp, tregs, reg, value);

        /* Would you like fries with that? */
        hme_write32(hp, &tregs->frame,
                    (FRAME_WRITE | (hp->paddr << 23) |
                     ((reg & 0xff) << 18) | (value & 0xffff)));
        while(!(hme_read32(hp, &tregs->frame) & 0x10000) && --tries)
                udelay(20);

        /* Anything else? */
        if(!tries)
                printk(KERN_ERR "happy meal: Aieee, transceiver MIF write bolixed\n");

        /* Fifty-two cents is your change, have a nice day. */
}

/* Auto negotiation.  The scheme is very simple.  We have a timer routine
 * that keeps watching the auto negotiation process as it progresses.
 * The DP83840 is first told to start doing it's thing, we set up the time
 * and place the timer state machine in it's initial state.
 *
 * Here the timer peeks at the DP83840 status registers at each click to see
 * if the auto negotiation has completed, we assume here that the DP83840 PHY
 * will time out at some point and just tell us what (didn't) happen.  For
 * complete coverage we only allow so many of the ticks at this level to run,
 * when this has expired we print a warning message and try another strategy.
 * This "other" strategy is to force the interface into various speed/duplex
 * configurations and we stop when we see a link-up condition before the
 * maximum number of "peek" ticks have occurred.
 *
 * Once a valid link status has been detected we configure the BigMAC and
 * the rest of the Happy Meal to speak the most efficient protocol we could
 * get a clean link for.  The priority for link configurations, highest first
 * is:
 *                 100 Base-T Full Duplex
 *                 100 Base-T Half Duplex
 *                 10 Base-T Full Duplex
 *                 10 Base-T Half Duplex
 *
 * We start a new timer now, after a successful auto negotiation status has
 * been detected.  This timer just waits for the link-up bit to get set in
 * the BMCR of the DP83840.  When this occurs we print a kernel log message
 * describing the link type in use and the fact that it is up.
 *
 * If a fatal error of some sort is signalled and detected in the interrupt
 * service routine, and the chip is reset, or the link is ifconfig'd down
 * and then back up, this entire process repeats itself all over again.
 */
static int try_next_permutation(struct happy_meal *hp, struct hmeal_tcvregs *tregs)
{
        hp->sw_bmcr = happy_meal_tcvr_read(hp, tregs, DP83840_BMCR);

        /* Downgrade from full to half duplex.  Only possible
         * via ethtool.
         */
        if(hp->sw_bmcr & BMCR_FULLDPLX) {
                hp->sw_bmcr &= ~(BMCR_FULLDPLX);
                happy_meal_tcvr_write(hp, tregs, DP83840_BMCR, hp->sw_bmcr);
                return 0;
        }

        /* Downgrade from 100 to 10. */
        if(hp->sw_bmcr & BMCR_SPEED100) {
                hp->sw_bmcr &= ~(BMCR_SPEED100);
                happy_meal_tcvr_write(hp, tregs, DP83840_BMCR, hp->sw_bmcr);
                return 0;
        }

        /* We've tried everything. */
        return -1;
}

static void display_link_mode(struct happy_meal *hp, struct hmeal_tcvregs *tregs)
{
        printk(KERN_INFO "%s: Link is up using ", hp->dev->name);
        if(hp->tcvr_type == external)
                printk("external ");
        else
                printk("internal ");
        printk("transceiver at ");
        hp->sw_lpa = happy_meal_tcvr_read(hp, tregs, DP83840_LPA);
        if(hp->sw_lpa & (LPA_100HALF | LPA_100FULL)) {
                if(hp->sw_lpa & LPA_100FULL)
                        printk("100Mb/s, Full Duplex.\n");
                else
                        printk("100Mb/s, Half Duplex.\n");
        } else {
                if(hp->sw_lpa & LPA_10FULL)
                        printk("10Mb/s, Full Duplex.\n");
                else
                        printk("10Mb/s, Half Duplex.\n");
        }
}

static void display_forced_link_mode(struct happy_meal *hp, struct hmeal_tcvregs *tregs)
{
        printk(KERN_INFO "%s: Link has been forced up using ", hp->dev->name);
        if(hp->tcvr_type == external)
                printk("external ");
        else
                printk("internal ");
        printk("transceiver at ");
        hp->sw_bmcr = happy_meal_tcvr_read(hp, tregs, DP83840_BMCR);
        if(hp->sw_bmcr & BMCR_SPEED100)
                printk("100Mb/s, ");
        else
                printk("10Mb/s, ");
        if(hp->sw_bmcr & BMCR_FULLDPLX)
                printk("Full Duplex.\n");
        else
                printk("Half Duplex.\n");
}

static int set_happy_link_modes(struct happy_meal *hp, struct hmeal_tcvregs *tregs)
{
        int full;

        /* All we care about is making sure the bigmac tx_cfg has a
         * proper duplex setting.
         */
        if(hp->timer_state == arbwait) {
                hp->sw_lpa = happy_meal_tcvr_read(hp, tregs, DP83840_LPA);
                if(!(hp->sw_lpa & (LPA_10HALF | LPA_10FULL | LPA_100HALF | LPA_100FULL)))
                        goto no_response;
                if(hp->sw_lpa & LPA_100FULL)
                        full = 1;
                else if(hp->sw_lpa & LPA_100HALF)
                        full = 0;
                else if(hp->sw_lpa & LPA_10FULL)
                        full = 1;
                else
                        full = 0;
        } else {
                /* Forcing a link mode. */
                hp->sw_bmcr = happy_meal_tcvr_read(hp, tregs, DP83840_BMCR);
                if(hp->sw_bmcr & BMCR_FULLDPLX)
                        full = 1;
                else
                        full = 0;
        }

        /* Before changing other bits in the tx_cfg register, and in
         * general any of other the TX config registers too, you
         * must:
         * 1) Clear Enable
         * 2) Poll with reads until that bit reads back as zero
         * 3) Make TX configuration changes
         * 4) Set Enable once more
         */
        hme_write32(hp, &hp->bigmacregs->tx_cfg,
                    hme_read32(hp, &hp->bigmacregs->tx_cfg) &
                    ~(BIGMAC_TXCFG_ENABLE));
        while(hme_read32(hp, &hp->bigmacregs->tx_cfg) & BIGMAC_TXCFG_ENABLE)
                barrier();
        if(full) {
                hp->happy_flags |= HFLAG_FULL;
                hme_write32(hp, &hp->bigmacregs->tx_cfg,
                            hme_read32(hp, &hp->bigmacregs->tx_cfg) |
                            BIGMAC_TXCFG_FULLDPLX);
        } else {
                hp->happy_flags &= ~(HFLAG_FULL);
                hme_write32(hp, &hp->bigmacregs->tx_cfg,
                            hme_read32(hp, &hp->bigmacregs->tx_cfg) &
                            ~(BIGMAC_TXCFG_FULLDPLX));
        }
        hme_write32(hp, &hp->bigmacregs->tx_cfg,
                    hme_read32(hp, &hp->bigmacregs->tx_cfg) |
                    BIGMAC_TXCFG_ENABLE);
        return 0;
no_response:
        return 1;
}

static int happy_meal_init(struct happy_meal *hp, int from_irq);

static int is_lucent_phy(struct happy_meal *hp)
{
        struct hmeal_tcvregs *tregs = hp->tcvregs;
        unsigned short mr2, mr3;
        int ret = 0;

        mr2 = happy_meal_tcvr_read(hp, tregs, 2);
        mr3 = happy_meal_tcvr_read(hp, tregs, 3);
        if ((mr2 & 0xffff) == 0x0180 &&
            ((mr3 & 0xffff) >> 10) == 0x1d) {
#if 0
                printk("HMEDEBUG: Lucent PHY detected.\n");
#endif
                ret = 1;
        }

        return ret;
}

static void happy_meal_timer(unsigned long data)
{
        struct happy_meal *hp = (struct happy_meal *) data;
        struct hmeal_tcvregs *tregs = hp->tcvregs;
        int restart_timer = 0;

        hp->timer_ticks++;
        switch(hp->timer_state) {
        case arbwait:
                /* Only allow for 5 ticks, thats 10 seconds and much too
                 * long to wait for arbitration to complete.
                 */
                if(hp->timer_ticks >= 10) {
                        /* Enter force mode. */
        do_force_mode:
                        hp->sw_bmcr = happy_meal_tcvr_read(hp, tregs, DP83840_BMCR);
                        printk(KERN_NOTICE "%s: Auto-Negotiation unsuccessful, trying force link mode\n",
                               hp->dev->name);
                        hp->sw_bmcr = BMCR_SPEED100;
                        happy_meal_tcvr_write(hp, tregs, DP83840_BMCR, hp->sw_bmcr);

                        if (!is_lucent_phy(hp)) {
                                /* OK, seems we need do disable the transceiver for
                                 * the first tick to make sure we get an accurate
                                 * link state at the second tick.
                                 */
                                hp->sw_csconfig = happy_meal_tcvr_read(hp, tregs,
                                                                       DP83840_CSCONFIG);
                                hp->sw_csconfig &= ~(CSCONFIG_TCVDISAB);
                                happy_meal_tcvr_write(hp, tregs, DP83840_CSCONFIG,
                                                      hp->sw_csconfig);
                        }
                        hp->timer_state = ltrywait;
                        hp->timer_ticks = 0;
                        restart_timer = 1;
                } else {
                        /* Anything interesting happen? */
                        hp->sw_bmsr = happy_meal_tcvr_read(hp, tregs, DP83840_BMSR);
                        if(hp->sw_bmsr & BMSR_ANEGCOMPLETE) {
                                int ret;

                                /* Just what we've been waiting for... */
                                ret = set_happy_link_modes(hp, tregs);
                                if(ret) {
                                        /* Ooops, something bad happened, go to force
                                         * mode.
                                         *
                                         * XXX Broken hubs which don't support 802.3u
                                         * XXX auto-negotiation make this happen as well.
                                         */
                                        goto do_force_mode;
                                }

                                /* Success, at least so far, advance our state engine. */
                                hp->timer_state = lupwait;
                                restart_timer = 1;
                        } else {
                                restart_timer = 1;
                        }
                }
                break;

        case lupwait:
                /* Auto negotiation was successful and we are awaiting a
                 * link up status.  I have decided to let this timer run
                 * forever until some sort of error is signalled, reporting
                 * a message to the user at 10 second intervals.
                 */
                hp->sw_bmsr = happy_meal_tcvr_read(hp, tregs, DP83840_BMSR);
                if(hp->sw_bmsr & BMSR_LSTATUS) {
                        /* Wheee, it's up, display the link mode in use and put
                         * the timer to sleep.
                         */
                        display_link_mode(hp, tregs);
                        hp->timer_state = asleep;
                        restart_timer = 0;
                } else {
                        if(hp->timer_ticks >= 10) {
                                printk(KERN_NOTICE "%s: Auto negotiation successful, link still "
                                       "not completely up.\n", hp->dev->name);
                                hp->timer_ticks = 0;
                                restart_timer = 1;
                        } else {
                                restart_timer = 1;
                        }
                }
                break;

        case ltrywait:
                /* Making the timeout here too long can make it take
                 * annoyingly long to attempt all of the link mode
                 * permutations, but then again this is essentially
                 * error recovery code for the most part.
                 */
                hp->sw_bmsr = happy_meal_tcvr_read(hp, tregs, DP83840_BMSR);
                hp->sw_csconfig = happy_meal_tcvr_read(hp, tregs, DP83840_CSCONFIG);
                if(hp->timer_ticks == 1) {
                        /* Re-enable transceiver, we'll re-enable the transceiver next
                         * tick, then check link state on the following tick.
                         * XXX But dont do this on Lucent PHY -DaveM
                         */
                        if (!is_lucent_phy(hp)) {
                                hp->sw_csconfig |= CSCONFIG_TCVDISAB;
                                happy_meal_tcvr_write(hp, tregs,
                                                      DP83840_CSCONFIG, hp->sw_csconfig);
                        }
                        restart_timer = 1;
                        break;
                }
                if(hp->timer_ticks == 2) {
                        /* XXX See above about Lucent PHY -DaveM */
                        if (!is_lucent_phy(hp)) {
                                hp->sw_csconfig &= ~(CSCONFIG_TCVDISAB);
                                happy_meal_tcvr_write(hp, tregs,
                                                      DP83840_CSCONFIG, hp->sw_csconfig);
                        }
                        restart_timer = 1;
                        break;
                }
                if(hp->sw_bmsr & BMSR_LSTATUS) {
                        /* Force mode selection success. */
                        display_forced_link_mode(hp, tregs);
                        set_happy_link_modes(hp, tregs); /* XXX error? then what? */
                        hp->timer_state = asleep;
                        restart_timer = 0;
                } else {
                        if(hp->timer_ticks >= 4) { /* 6 seconds or so... */
                                int ret;

                                ret = try_next_permutation(hp, tregs);
                                if(ret == -1) {
                                        /* Aieee, tried them all, reset the
                                         * chip and try all over again.
                                         */

                                        /* Let the user know... */
                                        printk(KERN_NOTICE "%s: Link down, cable problem?\n",
                                               hp->dev->name);

                                        ret = happy_meal_init(hp, 0);
                                        if(ret) {
                                                /* ho hum... */
                                                printk(KERN_ERR "%s: Error, cannot re-init the "
                                                       "Happy Meal.\n", hp->dev->name);
                                        }
                                        return;
                                }
                                hp->sw_csconfig = happy_meal_tcvr_read(hp, tregs,
                                                                       DP83840_CSCONFIG);
                                if (!is_lucent_phy(hp)) {
                                        hp->sw_csconfig |= CSCONFIG_TCVDISAB;
                                        happy_meal_tcvr_write(hp, tregs,
                                                              DP83840_CSCONFIG,
                                                              hp->sw_csconfig);
                                }
                                hp->timer_ticks = 0;
                                restart_timer = 1;
                        } else {
                                restart_timer = 1;
                        }
                }
                break;

        case asleep:
        default:
                /* Can't happens.... */
                printk(KERN_ERR "%s: Aieee, link timer is asleep but we got one anyways!\n",
                       hp->dev->name);
                restart_timer = 0;
                hp->timer_ticks = 0;
                hp->timer_state = asleep; /* foo on you */
                break;
        };

        if(restart_timer) {
                hp->happy_timer.expires = jiffies + ((12 * HZ)/10); /* 1.2 sec. */
                add_timer(&hp->happy_timer);
        }
}

#define TX_RESET_TRIES     32
#define RX_RESET_TRIES     32

static inline void happy_meal_tx_reset(struct happy_meal *hp,
                                       struct hmeal_bigmacregs *bregs)
{
        int tries = TX_RESET_TRIES;

        HMD(("happy_meal_tx_reset: reset, "));

        /* Would you like to try our SMCC Delux? */
        hme_write32(hp, &bregs->tx_swreset, 0);
        while((hme_read32(hp, &bregs->tx_swreset) & 1) && --tries)
                udelay(20);

        /* Lettuce, tomato, buggy hardware (no extra charge)? */
        if(!tries)
                printk(KERN_ERR "happy meal: Transceiver BigMac ATTACK!");

        /* Take care. */
        HMD(("done\n"));
}

static inline void happy_meal_rx_reset(struct happy_meal *hp,
                                       struct hmeal_bigmacregs *bregs)
{
        int tries = RX_RESET_TRIES;

        HMD(("happy_meal_rx_reset: reset, "));

        /* We have a special on GNU/Viking hardware bugs today. */
        hme_write32(hp, &bregs->rx_swreset, 0);
        while((hme_read32(hp, &bregs->rx_swreset) & 1) && --tries)
                udelay(20);

        /* Will that be all? */
        if(!tries)
                printk(KERN_ERR "happy meal: Receiver BigMac ATTACK!");

        /* Don't forget your vik_1137125_wa.  Have a nice day. */
        HMD(("done\n"));
}

#define STOP_TRIES         16

static inline void happy_meal_stop(struct happy_meal *hp,
                                   struct hmeal_gregs *gregs)
{
        int tries = STOP_TRIES;

        HMD(("happy_meal_stop: reset, "));

        /* We're consolidating our STB products, it's your lucky day. */
        hme_write32(hp, &gregs->sw_reset, GREG_RESET_ALL);
        while(hme_read32(hp, &gregs->sw_reset) && --tries)
                udelay(20);

        /* Come back next week when we are "Sun Microelectronics". */
        if(!tries)
                printk(KERN_ERR "happy meal: Fry guys.");

        /* Remember: "Different name, same old buggy as shit hardware." */
        HMD(("done\n"));
}

static void happy_meal_get_counters(struct happy_meal *hp,
                                    struct hmeal_bigmacregs *bregs)
{
        struct net_device_stats *stats = &hp->net_stats;

        stats->rx_crc_errors += hme_read32(hp, &bregs->rcrce_ctr);
        hme_write32(hp, &bregs->rcrce_ctr, 0);

        stats->rx_frame_errors += hme_read32(hp, &bregs->unale_ctr);
        hme_write32(hp, &bregs->unale_ctr, 0);

        stats->rx_length_errors += hme_read32(hp, &bregs->gle_ctr);
        hme_write32(hp, &bregs->gle_ctr, 0);

        stats->tx_aborted_errors += hme_read32(hp, &bregs->ex_ctr);

        stats->collisions +=
                (hme_read32(hp, &bregs->ex_ctr) +
                 hme_read32(hp, &bregs->lt_ctr));
        hme_write32(hp, &bregs->ex_ctr, 0);
        hme_write32(hp, &bregs->lt_ctr, 0);
}

static inline void happy_meal_poll_start(struct happy_meal *hp,
                                         struct hmeal_tcvregs *tregs)
{
        unsigned long tmp;
        int speed;

        ASD(("happy_meal_poll_start: "));
        if(!(hp->happy_flags & HFLAG_POLLENABLE)) {
                HMD(("polling disabled, return\n"));
                return;
        }

        /* Start the MIF polling on the external transceiver. */
        ASD(("polling on, "));
        tmp = hme_read32(hp, &tregs->cfg);
        tmp &= ~(TCV_CFG_PDADDR | TCV_CFG_PREGADDR);
        tmp |= ((hp->paddr & 0x1f) << 10);
        tmp |= (TCV_PADDR_ETX << 3);
        tmp |= TCV_CFG_PENABLE;
        hme_write32(hp, &tregs->cfg, tmp);

        /* Let the bits set. */
        udelay(200);

        /* We are polling now. */
        ASD(("now polling, "));
        hp->happy_flags |= HFLAG_POLL;

        /* Clear the poll flags, get the basic status as of now. */
        hp->poll_flag = 0;
        hp->poll_data = tregs->status >> 16;

        if(hp->happy_flags & HFLAG_AUTO)
                speed = hp->auto_speed;
        else
                speed = hp->forced_speed;

        /* Listen only for the MIF interrupts we want to hear. */
        ASD(("mif ints on, "));
        if(speed == 100)
                hme_write32(hp, &tregs->int_mask, 0xfffb);
        else
                hme_write32(hp, &tregs->int_mask, 0xfff9);
        ASD(("done\n"));
}

static inline void happy_meal_poll_stop(struct happy_meal *hp,
                                        struct hmeal_tcvregs *tregs)
{
        ASD(("happy_meal_poll_stop: "));

        /* If polling disabled or not polling already, nothing to do. */
        if((hp->happy_flags & (HFLAG_POLLENABLE | HFLAG_POLL)) !=
           (HFLAG_POLLENABLE | HFLAG_POLL)) {
                HMD(("not polling, return\n"));
                return;
        }

        /* Shut up the MIF. */
        ASD(("were polling, mif ints off, "));
        hme_write32(hp, &tregs->int_mask, 0xffff);

        /* Turn off polling. */
        ASD(("polling off, "));
        hme_write32(hp, &tregs->cfg,
                    hme_read32(hp, &tregs->cfg) & ~(TCV_CFG_PENABLE));

        /* We are no longer polling. */
        hp->happy_flags &= ~(HFLAG_POLL);

        /* Let the bits set. */
        udelay(200);
        ASD(("done\n"));
}

/* Only Sun can take such nice parts and fuck up the programming interface
 * like this.  Good job guys...
 */
#define TCVR_RESET_TRIES       16 /* It should reset quickly        */
#define TCVR_UNISOLATE_TRIES   32 /* Dis-isolation can take longer. */

static int happy_meal_tcvr_reset(struct happy_meal *hp,
                                 struct hmeal_tcvregs *tregs)
{
        unsigned long tconfig;
        int result, tries = TCVR_RESET_TRIES;

        tconfig = hme_read32(hp, &tregs->cfg);
        ASD(("happy_meal_tcvr_reset: tcfg<%08lx> ", tconfig));
        if(hp->tcvr_type == external) {
                ASD(("external<"));
                hme_write32(hp, &tregs->cfg, tconfig & ~(TCV_CFG_PSELECT));
                hp->tcvr_type = internal;
                hp->paddr = TCV_PADDR_ITX;
                ASD(("ISOLATE,"));
                happy_meal_tcvr_write(hp, tregs, DP83840_BMCR,
                                      (BMCR_LOOPBACK|BMCR_PDOWN|BMCR_ISOLATE));
                result = happy_meal_tcvr_read(hp, tregs, DP83840_BMCR);
                if(result == TCVR_FAILURE) {
                        ASD(("phyread_fail>\n"));
                        return -1;
                }
                ASD(("phyread_ok,PSELECT>"));
                hme_write32(hp, &tregs->cfg, tconfig | TCV_CFG_PSELECT);
                hp->tcvr_type = external;
                hp->paddr = TCV_PADDR_ETX;
        } else {
                if(tconfig & TCV_CFG_MDIO1) {
                        ASD(("internal<PSELECT,"));
                        hme_write32(hp, &tregs->cfg, (tconfig | TCV_CFG_PSELECT));
                        ASD(("ISOLATE,"));
                        happy_meal_tcvr_write(hp, tregs, DP83840_BMCR,
                                              (BMCR_LOOPBACK|BMCR_PDOWN|BMCR_ISOLATE));
                        result = happy_meal_tcvr_read(hp, tregs, DP83840_BMCR);
                        if(result == TCVR_FAILURE) {
                                ASD(("phyread_fail>\n"));
                                return -1;
                        }
                        ASD(("phyread_ok,~PSELECT>"));
                        hme_write32(hp, &tregs->cfg, (tconfig & ~(TCV_CFG_PSELECT)));
                        hp->tcvr_type = internal;
                        hp->paddr = TCV_PADDR_ITX;
                }
        }

        ASD(("BMCR_RESET "));
        happy_meal_tcvr_write(hp, tregs, DP83840_BMCR, BMCR_RESET);

        while(--tries) {
                result = happy_meal_tcvr_read(hp, tregs, DP83840_BMCR);
                if(result == TCVR_FAILURE)
                        return -1;
                hp->sw_bmcr = result;
                if(!(result & BMCR_RESET))
                        break;
                udelay(20);
        }
        if(!tries) {
                ASD(("BMCR RESET FAILED!\n"));
                return -1;
        }
        ASD(("RESET_OK\n"));

        /* Get fresh copies of the PHY registers. */
        hp->sw_bmsr      = happy_meal_tcvr_read(hp, tregs, DP83840_BMSR);
        hp->sw_physid1   = happy_meal_tcvr_read(hp, tregs, DP83840_PHYSID1);
        hp->sw_physid2   = happy_meal_tcvr_read(hp, tregs, DP83840_PHYSID2);
        hp->sw_advertise = happy_meal_tcvr_read(hp, tregs, DP83840_ADVERTISE);

        ASD(("UNISOLATE"));
        hp->sw_bmcr &= ~(BMCR_ISOLATE);
        happy_meal_tcvr_write(hp, tregs, DP83840_BMCR, hp->sw_bmcr);

        tries = TCVR_UNISOLATE_TRIES;
        while(--tries) {
                result = happy_meal_tcvr_read(hp, tregs, DP83840_BMCR);
                if(result == TCVR_FAILURE)
                        return -1;
                if(!(result & BMCR_ISOLATE))
                        break;
                udelay(20);
        }
        if(!tries) {
                ASD((" FAILED!\n"));
                return -1;
        }
        ASD((" SUCCESS and CSCONFIG_DFBYPASS\n"));
        if (!is_lucent_phy(hp)) {
                result = happy_meal_tcvr_read(hp, tregs, DP83840_CSCONFIG);
                happy_meal_tcvr_write(hp, tregs, DP83840_CSCONFIG,
                                      (result | CSCONFIG_DFBYPASS));
        }
        return 0;
}

/* Figure out whether we have an internal or external transceiver. */
static void happy_meal_transceiver_check(struct happy_meal *hp,
                                         struct hmeal_tcvregs *tregs)
{
        unsigned long tconfig = hme_read32(hp, &tregs->cfg);

        ASD(("happy_meal_transceiver_check: tcfg=%08lx ", tconfig));
        if(hp->happy_flags & HFLAG_POLL) {
                /* If we are polling, we must stop to get the transceiver type. */
                ASD(("<polling> "));
                if(hp->tcvr_type == internal) {
                        if(tconfig & TCV_CFG_MDIO1) {
                                ASD(("<internal> <poll stop> "));
                                happy_meal_poll_stop(hp, tregs);
                                hp->paddr = TCV_PADDR_ETX;
                                hp->tcvr_type = external;
                                ASD(("<external>\n"));
                                tconfig &= ~(TCV_CFG_PENABLE);
                                tconfig |= TCV_CFG_PSELECT;
                                hme_write32(hp, &tregs->cfg, tconfig);
                        }
                } else {
                        if(hp->tcvr_type == external) {
                                ASD(("<external> "));
                                if(!(hme_read32(hp, &tregs->status) >> 16)) {
                                        ASD(("<poll stop> "));
                                        happy_meal_poll_stop(hp, tregs);
                                        hp->paddr = TCV_PADDR_ITX;
                                        hp->tcvr_type = internal;
                                        ASD(("<internal>\n"));
                                        hme_write32(hp, &tregs->cfg,
                                                    hme_read32(hp, &tregs->cfg) &
                                                    ~(TCV_CFG_PSELECT));
                                }
                                ASD(("\n"));
                        } else {
                                ASD(("<none>\n"));
                        }
                }
        } else {
                unsigned long reread = hme_read32(hp, &tregs->cfg);

                /* Else we can just work off of the MDIO bits. */
                ASD(("<not polling> "));
                if(reread & TCV_CFG_MDIO1) {
                        hme_write32(hp, &tregs->cfg, tconfig | TCV_CFG_PSELECT);
                        hp->paddr = TCV_PADDR_ETX;
                        hp->tcvr_type = external;
                        ASD(("<external>\n"));
                } else {
                        if(reread & TCV_CFG_MDIO0) {
                                hme_write32(hp, &tregs->cfg,
                                            tconfig & ~(TCV_CFG_PSELECT));
                                hp->paddr = TCV_PADDR_ITX;
                                hp->tcvr_type = internal;
                                ASD(("<internal>\n"));
                        } else {
                                printk(KERN_ERR "happy meal: Transceiver and a coke please.");
                                hp->tcvr_type = none; /* Grrr... */
                                ASD(("<none>\n"));
                        }
                }
        }
}

/* The receive ring buffers are a bit tricky to get right.  Here goes...
 *
 * The buffers we dma into must be 64 byte aligned.  So we use a special
 * alloc_skb() routine for the happy meal to allocate 64 bytes more than
 * we really need.
 *
 * We use skb_reserve() to align the data block we get in the skb.  We
 * also program the etxregs->cfg register to use an offset of 2.  This
 * imperical constant plus the ethernet header size will always leave
 * us with a nicely aligned ip header once we pass things up to the
 * protocol layers.
 *
 * The numbers work out to:
 *
 *         Max ethernet frame size         1518
 *         Ethernet header size              14
 *         Happy Meal base offset             2
 *
 * Say a skb data area is at 0xf001b010, and its size alloced is
 * (ETH_FRAME_LEN + 64 + 2) = (1514 + 64 + 2) = 1580 bytes.
 *
 * First our alloc_skb() routine aligns the data base to a 64 byte
 * boundry.  We now have 0xf001b040 as our skb data address.  We
 * plug this into the receive descriptor address.
 *
 * Next, we skb_reserve() 2 bytes to account for the Happy Meal offset.
 * So now the data we will end up looking at starts at 0xf001b042.  When
 * the packet arrives, we will check out the size received and subtract
 * this from the skb->length.  Then we just pass the packet up to the
 * protocols as is, and allocate a new skb to replace this slot we have
 * just received from.
 *
 * The ethernet layer will strip the ether header from the front of the
 * skb we just sent to it, this leaves us with the ip header sitting
 * nicely aligned at 0xf001b050.  Also, for tcp and udp packets the
 * Happy Meal has even checksummed the tcp/udp data for us.  The 16
 * bit checksum is obtained from the low bits of the receive descriptor
 * flags, thus:
 *
 *      skb->csum = rxd->rx_flags & 0xffff;
 *      skb->ip_summed = CHECKSUM_HW;
 *
 * before sending off the skb to the protocols, and we are good as gold.
 */
static inline void happy_meal_clean_rings(struct happy_meal *hp)
{
        int i;

        for(i = 0; i < RX_RING_SIZE; i++) {
                if(hp->rx_skbs[i] != NULL) {
                        dev_kfree_skb(hp->rx_skbs[i]);
                        hp->rx_skbs[i] = NULL;
                }
        }

        for(i = 0; i < TX_RING_SIZE; i++) {
                if(hp->tx_skbs[i] != NULL) {
                        dev_kfree_skb(hp->tx_skbs[i]);
                        hp->tx_skbs[i] = NULL;
                }
        }
}

static void happy_meal_init_rings(struct happy_meal *hp, int from_irq)
{
        struct hmeal_init_block *hb = hp->happy_block;
        struct device *dev = hp->dev;
        int i, gfp_flags = GFP_KERNEL;

        if(from_irq || in_interrupt())
                gfp_flags = GFP_ATOMIC;

        HMD(("happy_meal_init_rings: counters to zero, "));
        hp->rx_new = hp->rx_old = hp->tx_new = hp->tx_old = 0;

        /* Free any skippy bufs left around in the rings. */
        HMD(("clean, "));
        happy_meal_clean_rings(hp);

        /* Now get new skippy bufs for the receive ring. */
        HMD(("init rxring, "));
        for(i = 0; i < RX_RING_SIZE; i++) {
                struct sk_buff *skb;

                skb = happy_meal_alloc_skb(RX_BUF_ALLOC_SIZE, gfp_flags | GFP_DMA);
                if(!skb)
                        continue;
                hp->rx_skbs[i] = skb;
                skb->dev = dev;

                /* Because we reserve afterwards. */
                skb_put(skb, (ETH_FRAME_LEN + RX_OFFSET));

#ifdef CONFIG_PCI
                if(hp->happy_flags & HFLAG_PCI) {
                        pcihme_write_rxd(&hb->happy_meal_rxd[i],
                                         (RXFLAG_OWN |
                                          ((RX_BUF_ALLOC_SIZE-RX_OFFSET)<<16)),
                                         (u32)virt_to_bus((volatile void *)skb->data));
                } else
#endif
#ifndef __sparc_v9__
                if (sparc_cpu_model == sun4d) {
                        __u32 va = (__u32)hp->sun4d_buffers + i * PAGE_SIZE;

                        hb->happy_meal_rxd[i].rx_addr =
                                iounit_map_dma_page(va, skb->data, hp->happy_sbus_dev->my_bus);
                        hb->happy_meal_rxd[i].rx_flags =
                                (RXFLAG_OWN | ((RX_BUF_ALLOC_SIZE - RX_OFFSET) << 16));
                } else
#endif
                {
                        hb->happy_meal_rxd[i].rx_addr = sbus_dvma_addr(skb->data);
                        hb->happy_meal_rxd[i].rx_flags =
                                (RXFLAG_OWN | ((RX_BUF_ALLOC_SIZE - RX_OFFSET) << 16));
                }
                skb_reserve(skb, RX_OFFSET);
        }

        HMD(("init txring, "));
        for(i = 0; i < TX_RING_SIZE; i++)
                hb->happy_meal_txd[i].tx_flags = 0;
        HMD(("done\n"));
}

#ifndef __sparc_v9__
static void sun4c_happy_meal_init_rings(struct happy_meal *hp)
{
        struct hmeal_init_block *hb = hp->happy_block;
        __u32 hbufs = hp->s4c_buf_dvma;
        int i;

        HMD(("happy_meal_init_rings: counters to zero, "));
        hp->rx_new = hp->rx_old = hp->tx_new = hp->tx_old = 0;

        HMD(("init rxring, "));
        for(i = 0; i < RX_RING_SIZE; i++) {
                hb->happy_meal_rxd[i].rx_addr = hbufs + hbuf_offset(rx_buf, i);
                hb->happy_meal_rxd[i].rx_flags =
                        (RXFLAG_OWN | ((SUN4C_RX_BUFF_SIZE - RX_OFFSET) << 16));
        }

        HMD(("init txring, "));
        for(i = 0; i < TX_RING_SIZE; i++)
                hb->happy_meal_txd[i].tx_flags = 0;
        HMD(("done\n"));
}
#endif

static void happy_meal_begin_auto_negotiation(struct happy_meal *hp,
                                              struct hmeal_tcvregs *tregs,
                                              struct ethtool_cmd *ep)
{
        int timeout;

        /* Read all of the registers we are interested in now. */
        hp->