/*      $NetBSD: if_ne_pbus.c,v 1.20 2019/05/29 06:21:56 msaitoh Exp $  */

/*
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Mark Brinicombe of Causality Limited.
 *
 * EtherH code Copyright (c) 1998 Mike Pumford
 * EtherN/EtherI code Copyright (c) 1999 Mike Pumford
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This driver uses the generic ne2000 & dp8390 IC drivers
 *
 * Currently supports:
 *      ANT EtherM network slot cards
 *      ICubed Etherlan 600 (EtherH) network slot cards
 *      Irlam EtherN podules
 *      Acorn EtherI podules (identical hardware to EtherN)
 *
 * Thanks go to Stephen Borrill for providing the EtherN card
 * and information to program it.
 *
 * TO DO List for this Driver.
 *
 * EtherM - Needs proper media support.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_ne_pbus.c,v 1.20 2019/05/29 06:21:56 msaitoh Exp $");

#include <sys/param.h>
#include <sys/device.h>
#include <sys/socket.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/bus.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_ether.h>
#include <net/if_media.h>

#include <machine/intr.h>
#include <machine/io.h>
#include <dev/ic/dp8390reg.h>
#include <dev/ic/dp8390var.h>
#include <dev/ic/ne2000reg.h>
#include <dev/ic/ne2000var.h>
#include <dev/ic/dp83905reg.h>
#include <dev/ic/dp83905var.h>
#include <dev/ic/mx98905var.h>

#include <arch/acorn32/podulebus/podulebus.h>
#include <arch/acorn32/podulebus/if_ne_pbusreg.h>

#include <dev/podulebus/podules.h>

/*
 * ne_pbus_softc: ne2000_softc plus podule, interrupt and bs tag info
 */
struct ne_pbus_softc {
        struct  ne2000_softc    sc_ne2000;              /* ne2000 softc */
        int                     sc_podule_number;
        podule_t                *sc_podule;
        struct bus_space        sc_tag;                 /* Patched tag */
        irqhandler_t            *sc_ih;                 /* Interrupt handler */
        struct evcnt            sc_intrcnt;             /* Interrupt count */
        bus_space_handle_t      sc_extrah;              /* Bus handle for any
                                                           extra registers */
};

/*
 * Attach data and prototypes for driver
 */
static int  ne_pbus_probe       (device_t, cfdata_t , void *);
static void ne_pbus_attach      (device_t, device_t, void *);

CFATTACH_DECL_NEW(ne_pbus, sizeof(struct ne_pbus_softc),
    ne_pbus_probe, ne_pbus_attach, NULL, NULL);

/*
 * Prototypes for interface specific routines
 */
static uint8_t *em_ea           (struct ne_pbus_softc *sc, uint8_t *buffer);
static void em_postattach       (struct ne_pbus_softc *sc);
static void eh600_postattach    (struct ne_pbus_softc *sc);
static void eh600_preattach     (struct ne_pbus_softc *sc);
static uint8_t *eh600_ea        (struct ne_pbus_softc *sc, uint8_t *buffer);

void    eh600_init_media        (struct dp8390_softc *);

void    en_postattach           (struct ne_pbus_softc *);
void    en_init_media           (struct dp8390_softc *);

/*
 * Define a structure to hold all the information required on an NE2000
 * clone interface.
 * We create an array of these structures to describe all the interfaces
 * that we can handle via the MI NE2000 driver.
 */
struct ne_clone {
        int             product;        /* podule product id */
        unsigned int    cookie;         /* podulebus space cookie */
        unsigned int    nicbase;        /* byte offset of NIC */
        unsigned int    nicsize;        /* size of NIC (regs) */
        unsigned int    asicbase;       /* byte offset of ASIC */
        unsigned int    asicsize;       /* size of ASIC (regs) */
        unsigned int    extrabase;      /* extra registers byte offset */
        unsigned int    extrasize;      /* size of extra registers(regs) */
        unsigned char   nicspace;       /* easi,fast or mod space ? */
        unsigned char   asicspace;      /* easi,fast or mod space ? */
        unsigned char   extraspace;     /* easi,fast or mod space ? */
#define NE_SPACE_FAST           0
#define NE_SPACE_MOD            1
#define NE_SPACE_EASI           2
        unsigned char   reserved0;      /* not used (padding) */
        const char      *name;          /* name */
        uint8_t *       (*getea)        /* do this to get the MAC */
                            (struct ne_pbus_softc *sc, uint8_t *buffer);
        void            (*preattach)    /* do this before attach */
                            (struct ne_pbus_softc *sc);
        void            (*postattach)   /* do this after attach */
                            (struct ne_pbus_softc *sc);
        int             (*mediachange)  /* media change */
                            (struct dp8390_softc *);
        void            (*mediastatus)  /* media status */
                            (struct dp8390_softc *, struct ifmediareq *);
        void            (*init_card)    /* media init card */
                            (struct dp8390_softc *);
        void            (*init_media)   /* media init */
                            (struct dp8390_softc *);
} ne_clones[] = {
        /* ANT EtherM netslot interface */
        {
          PODULE_ETHERM, EM_REGSHIFT,
          EM_NIC_OFFSET, EM_NIC_SIZE, EM_ASIC_OFFSET, EM_ASIC_SIZE,
          0,0, NE_SPACE_FAST,
          NE_SPACE_FAST, NE_SPACE_FAST, 0,
          "EtherM", em_ea, NULL, em_postattach,
          NULL,NULL,NULL,NULL
        },
        /* ICubed EtherLan EtherH netslot interface */
        {
          PODULE_ETHERLAN600, EH600_REGSHIFT,
          EH600_NIC_OFFSET, EH600_NIC_SIZE, EH600_ASIC_OFFSET, EH600_ASIC_SIZE,
          EH600_CONTROL_OFFSET, EH600_CONTROL_SIZE, NE_SPACE_FAST,
          NE_SPACE_FAST, NE_SPACE_FAST, 0,
          "EtherLan 600", eh600_ea, eh600_preattach, eh600_postattach,
          dp83905_mediachange, dp83905_mediastatus, dp83905_init_card,
          eh600_init_media
        },
        /* Acorn EtherLan EtherH netslot interface */
        {
          PODULE_ETHERLAN600AEH, EH600_REGSHIFT,
          EH600_NIC_OFFSET, EH600_NIC_SIZE, EH600_ASIC_OFFSET, EH600_ASIC_SIZE,
          EH600_CONTROL_OFFSET, EH600_CONTROL_SIZE, NE_SPACE_FAST,
          NE_SPACE_FAST, NE_SPACE_FAST, 0,
          "EtherLan 600A", eh600_ea , eh600_preattach, eh600_postattach,
          dp83905_mediachange, dp83905_mediastatus, dp83905_init_card,
          eh600_init_media
        },
        /* Irlam EtherN podule. (supplied with NC) */
        {
          PODULE_ETHERN, EN_REGSHIFT,
          EN_NIC_OFFSET, EN_NIC_SIZE, EN_ASIC_OFFSET, EN_ASIC_SIZE,
          0,0, NE_SPACE_EASI,
          NE_SPACE_EASI, NE_SPACE_EASI, 0,
          "EtherN", em_ea, NULL, en_postattach,
          dp83905_mediachange, dp83905_mediastatus, dp83905_init_card,
          en_init_media
        },
        /* Acorn EtherI podule. (supplied with NC) */
        {
          PODULE_ETHERI, EN_REGSHIFT,
          EN_NIC_OFFSET, EN_NIC_SIZE, EN_ASIC_OFFSET, EN_ASIC_SIZE,
          0,0, NE_SPACE_EASI,
          NE_SPACE_EASI, NE_SPACE_EASI, 0,
          "EtherI", em_ea, NULL, en_postattach,
          dp83905_mediachange, dp83905_mediastatus, dp83905_init_card,
          en_init_media
        },
};

/*
 * Determine if the device is present.
 */
static int
ne_pbus_probe(device_t parent, cfdata_t cf, void *aux)
{
        struct podule_attach_args *pa = (void *)aux;
        int loop;

        /* Scan the list of known interfaces looking for a match */
        for (loop = 0; loop < sizeof(ne_clones) / sizeof(struct ne_clone);
            ++loop) {
                if (pa->pa_product == ne_clones[loop].product)
                        return 1;
        }
        return 0;
}

/*
 * Install interface into kernel networking data structures.
 */
static void
ne_pbus_attach(device_t parent, device_t self, void *aux)
{
        struct podule_attach_args *pa = (void *)aux;
        struct ne_pbus_softc *npsc = device_private(self);
        struct ne2000_softc *nsc = &npsc->sc_ne2000;
        struct dp8390_softc *dsc = &nsc->sc_dp8390;
        struct ne_clone *ne = NULL;
        uint8_t buffer[6];
        uint8_t *myea;
        int loop;

        dsc->sc_dev = self;
        /* Check a few things about the attach args */

        if (pa->pa_podule_number == -1)
                panic("Podule has disappeared !");

        npsc->sc_podule_number = pa->pa_podule_number;
        npsc->sc_podule = pa->pa_podule;
        podules[npsc->sc_podule_number].attached = 1;           /* XXX */

        /* Scan the list of known interfaces for a match */
        for (loop = 0; loop < sizeof(ne_clones) / sizeof(struct ne_clone);
            ++loop) {
                if (pa->pa_product == ne_clones[loop].product) {
                        ne = &ne_clones[loop];
                        break;
                }
        }

#ifdef  DIAGNOSTIC
        /* This should never fail as we must have matched at probe time */
        if (ne == NULL)
                panic("Podule has vanished");
#endif

        /* Update the nic and asic base addresses appropriately */
        switch (ne->nicspace) {
        case NE_SPACE_EASI:
                ne->nicbase += npsc->sc_podule->easi_base;
                break;
        case NE_SPACE_MOD:
                ne->nicbase += npsc->sc_podule->mod_base;
                break;
        case NE_SPACE_FAST:
        default:
                ne->nicbase += npsc->sc_podule->fast_base;
                break;
        }
        switch (ne->asicspace) {
        case NE_SPACE_EASI:
                ne->asicbase += npsc->sc_podule->easi_base;
                break;
        case NE_SPACE_MOD:
                ne->asicbase += npsc->sc_podule->mod_base;
                break;
        case NE_SPACE_FAST:
        default:
                ne->asicbase += npsc->sc_podule->fast_base;
                break;
        }

        switch (ne->extraspace) {
        case NE_SPACE_EASI:
                ne->extrabase += npsc->sc_podule->easi_base;
                break;
        case NE_SPACE_MOD:
                ne->extrabase += npsc->sc_podule->mod_base;
                break;
        case NE_SPACE_FAST:
        default:
                ne->extrabase += npsc->sc_podule->fast_base;
                break;
        }

        /* Report the interface name */
        aprint_normal(": %s ethernet\n", ne->name);

        /*
         * Ok we need our own bus tag as the register spacing
         * may not the default.
         *
         * For the podulebus, the bus tag cookie is the shift
         * to apply to registers
         * So duplicate the bus space tag and change the
         * cookie.
         */

        npsc->sc_tag = *pa->pa_iot;
        npsc->sc_tag.bs_cookie = (void *) ne->cookie;

        dsc->sc_regt = &npsc->sc_tag;
        nsc->sc_asict = dsc->sc_regt;

        /* Map all the I/O space for the NIC */
        if (bus_space_map(dsc->sc_regt, ne->nicbase, ne->nicsize,
            0, &dsc->sc_regh)) {
                aprint_error_dev(self, "cannot map i/o space\n");
                return;
        }
        /* Map the I/O space for the ASIC */
        if (bus_space_map(nsc->sc_asict, ne->asicbase, ne->asicsize,
            0, &nsc->sc_asich)) {
                aprint_error_dev(self, "cannot map i/o space\n");
                return;
        }
        /* Map any extra register space required by the card */
        if (ne->extrasize > 0) {
                if (bus_space_map(&npsc->sc_tag, ne->extrabase, ne->extrasize,
                                  0, &npsc->sc_extrah)) {
                        aprint_error_dev(self, "cannot map extra space\n");
                        return;
                }
        }

        /* This interface is always enabled. */
        dsc->sc_enabled = 1;

        /*
         * Now get the ethernet address in an interface specific manner if
         * specified
         */
        if (ne->getea)
                myea = ne->getea(npsc, buffer);
        else
                myea = NULL;

        /* Does the interface need a preattach call ? */
        if (ne->preattach)
                ne->preattach(npsc);

        /* If the interface has media support initialise it */
        if (ne->init_media) {
                dsc->sc_mediachange = ne->mediachange;
                dsc->sc_mediastatus = ne->mediastatus;
                dsc->init_card = ne->init_card;
                dsc->sc_media_init = ne->init_media;
#if 0
                int *media = NULL, nmedia = 0, defmedia = 0;
                ne->init_media(dsc, &media, &nmedia, &defmedia);
#endif
        }

        /*
         * Do generic NE2000 attach.  This will read the station address
         * from the EEPROM.
         */
        ne2000_attach(nsc, myea);
        aprint_normal_dev(self, "");
        switch (nsc->sc_type) {
        case NE2000_TYPE_NE1000:
                aprint_normal("NE1000");
                break;
        case NE2000_TYPE_NE2000:
                aprint_normal("NE2000");
                break;
        case NE2000_TYPE_AX88190:
                aprint_normal("AX88190");
                break;
        case NE2000_TYPE_DL10019:
                aprint_normal("DL10019");
                break;
        case NE2000_TYPE_DL10022:
                aprint_normal("DL10022");
                break;
        default:
                printf("??");
        };
        aprint_normal(" chipset, %d Kb memory\n", dsc->mem_start/1024);

        /* Does the interface need a postattach call ? */
        if (ne->postattach)
                ne->postattach(npsc);

        /* Install an interrupt handler */
        evcnt_attach_dynamic(&npsc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
            device_xname(self), "intr");
        npsc->sc_ih = podulebus_irq_establish(pa->pa_ih, IPL_NET, dp8390_intr,
            dsc, &npsc->sc_intrcnt);
        if (npsc->sc_ih == NULL)
                panic("%s: Cannot install interrupt handler",
                   device_xname(self));
        /* This feels wrong to do this here */
        npsc->sc_ih->ih_maskaddr = npsc->sc_podule->irq_addr;
        npsc->sc_ih->ih_maskbits = npsc->sc_podule->irq_mask;
}

/*
 * em_ea()
 *
 * return the ethernet address for an EtherM netslot interface.
 * The EtherM interface uses the machines ethernet address so just
 * fill it out
 */
static uint8_t *
em_ea(struct ne_pbus_softc *sc, uint8_t *buffer)
{
        /*
         * Use the podulebus netslot_ea() function to get the netslot
         * ethernet address. This is generated from the machine ID.
         */

        netslot_ea(buffer);
        return buffer;
}

/*
 * em_postattach()
 *
 * The EtherM interface has a Diagnostic Status register. After attaching
 * the driver, print out some more information using this register.
 */
static void
em_postattach(struct ne_pbus_softc *sc)
{
        int dsr;

        /*
         * Report information from the Diagnostic Status Register for
         * the EtherM card
         */
        aprint_normal_dev(sc->sc_ne2000.sc_dp8390.sc_dev,
            "16KB buffer memory");

        /* Get the Diagnostic Status Register */
        dsr = bus_space_read_1(sc->sc_ne2000.sc_asict,
            sc->sc_ne2000.sc_asich, EM_DSR_REG);

        /* Check for bits that indicate a fault */
        if (!(dsr & EM_DSR_20M))
                aprint_normal(", VCO faulty");
        if (!(dsr & EM_DSR_TCOK))
                aprint_normal(", TxClk faulty");

        /* Report status of card */
        if (dsr & EM_DSR_POL)
                aprint_normal(", UTP reverse polarity");
        if (dsr & EM_DSR_JAB)
                aprint_normal(", jabber");
        if (dsr & EM_DSR_LNK)
                aprint_normal(", link OK");
        if (dsr & EM_DSR_LBK)
                aprint_normal(", loopback");
        if (dsr & EM_DSR_UTP)
                aprint_normal(", UTP");
        aprint_normal("\n");
}


/*
 * eh600_preattach()
 *
 * pre-initialise the AT/Lantic chipset so that the card probes and
 * detects properly.
 */
static void
eh600_preattach(struct ne_pbus_softc *sc)
{
        u_char tmp;
        struct ne2000_softc *nsc = &sc->sc_ne2000;
        struct dp8390_softc *dsc = &nsc->sc_dp8390;
        bus_space_tag_t nict = dsc->sc_regt;
        bus_space_handle_t nich = dsc->sc_regh;

        /* Initialise EH600 config register */
        bus_space_read_1(nict, nich, DP83905_MCRA);
        bus_space_write_1(nict, nich, DP83905_MCRA, DP83905_MCRA_INT3);

        /* Enable interrupts for the card */
        tmp = bus_space_read_1(&sc->sc_tag, sc->sc_extrah, 0);
        tmp |= EH_INTR_MASK;
        bus_space_write_1(&sc->sc_tag, sc->sc_extrah, 0, tmp);
}

/*
 * eh600_postattach()
 *
 * Etherlan 600 has 32k of buffer memory as it runs the AT/Lantic
 * DP8390 clone in IO non-compatible mode. We need to adjust the memory
 * description set up by dp8390.c and ne2000.c to reflect this.
 */
static void
eh600_postattach(struct ne_pbus_softc *sc)
{
        struct ne2000_softc *nsc = &sc->sc_ne2000;
        struct dp8390_softc *dsc = &nsc->sc_dp8390;

        /* First page is mapped to the PROM. so start at 2nd page */
        dsc->mem_start = EH600_MEM_START;
        dsc->mem_size = EH600_MEM_END - EH600_MEM_START;
        dsc->mem_end = EH600_MEM_END;
        dsc->txb_cnt = 3; /* >16k of ram setup 3 tx buffers */
        /* Recompute the mem ring (taken straight from the ne2000 init code) */
        dsc->mem_ring =
                dsc->mem_start +
                (((dsc->txb_cnt + 1) * ED_TXBUF_SIZE ) <<
                 ED_PAGE_SHIFT);

        /* Recompute the dp8390 register values. (from dp8390 init code) */
        dsc->tx_page_start = dsc->mem_start >> ED_PAGE_SHIFT;

        dsc->rec_page_start = dsc->tx_page_start +
                (dsc->txb_cnt + 1) * ED_TXBUF_SIZE;

        dsc->rec_page_stop = dsc->tx_page_start +
                (dsc->mem_size >> ED_PAGE_SHIFT);
        aprint_normal_dev(dsc->sc_dev, "32KB buffer memory\n");
}
/*
 * EtherLan 600 media.
 */
void eh600_init_media(struct dp8390_softc *sc)
{
        static int eh600_media[] = {
                IFM_ETHER | IFM_AUTO,
                IFM_ETHER | IFM_10_T,
                IFM_ETHER | IFM_10_2,
        };
        int i, defmedia = IFM_ETHER | IFM_AUTO;
        static const int eh600_nmedia = __arraycount(eh600_media);

        aprint_normal_dev(sc->sc_dev,
            "10base2, 10baseT, auto, default auto\n");

        ifmedia_init(&sc->sc_media, 0, dp8390_mediachange, dp8390_mediastatus);
        for (i = 0; i < eh600_nmedia; i++)
                ifmedia_add(&sc->sc_media, eh600_media[i], 0, NULL);
        ifmedia_set(&sc->sc_media, defmedia);
}


void
en_postattach(struct ne_pbus_softc *sc)
{

        mx98905_attach(&sc->sc_ne2000.sc_dp8390);
}

/*
 * EtherN media.
 */
void
en_init_media(struct dp8390_softc *sc)
{
        static int en_media[] = {
                IFM_ETHER | IFM_10_T
        };

        aprint_normal_dev(sc->sc_dev, "10baseT, default 10baseT\n");

        ifmedia_init(&sc->sc_media, 0, dp8390_mediachange, dp8390_mediastatus);
        ifmedia_add(&sc->sc_media, en_media[0], 0, NULL);
        ifmedia_set(&sc->sc_media, en_media[0]);
}


/*
 * extracts the station address from the Podule description string.
 * The description has to be re-read here since the podule description
 * string is not always long enough to contain the full address.
 *
 * If for any reason we cannot extract the address this routine will
 * use netslot_ea() to return the generic address for the network slot.
 */

#define POD_READ(addr) \
        podule->read_rom(podule->sync_base, addr)

static uint8_t *
eh600_ea(struct ne_pbus_softc *sc, uint8_t *buffer)
{
        podule_t *podule = sc->sc_podule;
        u_int address;
        u_int id;

        address = 0x40;
        memset(buffer, 0, 6);

        /* Read chunks from the podule  */
        do {
                id = POD_READ(address);
                /* Check for description chunk. */
                if (id == 0xf5) {
                        u_int size;
                        u_int pod_addr;
                        int loop;

                        /* Read the size */
                        size = POD_READ(address + 4);
                        size |= (POD_READ(address + 8) << 8);
                        size |= (POD_READ(address + 12) << 16);

                        /* Read address of description */
                        pod_addr = POD_READ(address + 16);
                        pod_addr |= (POD_READ(address + 20) << 8);
                        pod_addr |= (POD_READ(address + 24) << 16);
                        pod_addr |= (POD_READ(address + 28) << 24);

                        if (pod_addr < 0x800) {
                                uint8_t tmp;
                                int addr_index = 0;
                                int found_ether = 0;

                                /*
                                 * Start scanning for ethernet address
                                 * which starts with a '('
                                 */
                                for (loop = 0; loop < size; ++loop) {
                                        if (found_ether) {
                                                /* We have found a '(' so start decoding the address */
                                                tmp = POD_READ((pod_addr + loop) * 4);
                                                if (tmp >= '0' &&  tmp <= '9') {
                                                        buffer[addr_index >> 1] |= (tmp - '0') << ((addr_index & 1) ? 0 : 4);
                                                        ++addr_index;
                                                }
                                                else if (tmp >= 'a' &&  tmp <= 'f'){
                                                        buffer[addr_index >> 1] |= (10 + (tmp - 'a')) << ((addr_index & 1) ? 0 : 4);
                                                        ++addr_index;
                                                }
                                                else if (tmp >= 'A' &&  tmp <= 'F'){
                                                        buffer[addr_index >> 1] |= (10 + (tmp - 'A')) << ((addr_index & 1) ? 0 : 4);
                                                        ++addr_index;
                                                }
                                                else if (tmp == ')') {
                                                        /* We have read the whole address so we can stop scanning
                                                         * the podule description */
                                                        break;
                                                }
                                        }
                                        /*
                                         * We have found the start of the ethernet address (decode begins
                                         * on the next run round the loop. */
                                        if (POD_READ((pod_addr + loop) * 4) == '(') {
                                                found_ether = 1;
                                        }
                                }
                                /*
                                 * Failed to find the address so fall back
                                 * on the netslot address
                                 */
                                if (!found_ether)
                                        netslot_ea(buffer);
                                return buffer;
                        }
                }
                address += 32;
        } while (id != 0 && address < 0x8000);

        /*
         * If we get here we failed to find the address
         * In this case the best solution is to go with the netslot addrness
         */
        netslot_ea(buffer);
        return buffer;
}