text: /*-
   * Copyright (c) 2003 Matthew N. Dodd
   * All rights reserved.
   *
   * 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 AUTHOR 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 AUTHOR 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.
   *
   * Portions: 
   * Copyright (c) 1992, 1993, University of Vermont and State
   *  Agricultural College.
   * Copyright (c) 1992, 1993, Garrett A. Wollman.
   * Copyright (c) 1990, 1991, William F. Jolitz
   * Copyright (c) 1990, The Regents of the University of California
   * Copyright (c) 1993, 1994, Charles M. Hannum
   * Copyright (c) 1993, 1994, 1995, Rodney W. Grimes
   * Copyright (c) 1997, Aaron C. Smith
   *
   * See if_ie.c for applicable license.
   */
  
  #include <sys/cdefs.h>
  __FBSDID("$FreeBSD: src/sys/dev/ie/if_ie_isa.c,v 1.5 2005/12/05 11:58:33 ru Exp $");
  
  #include <sys/param.h>
  #include <sys/systm.h>
  #include <sys/kernel.h>
  #include <sys/socket.h>
  
  #include <sys/module.h>
  #include <sys/bus.h>
  
  #include <machine/bus.h>
  #include <machine/resource.h>
  #include <sys/rman.h>
  
  #include <machine/clock.h>
  #include <machine/md_var.h>
  
  #include <net/if.h>
  #include <net/if_arp.h>
  #include <net/if_media.h>
  
  #include <isa/isavar.h>
  #include <isa/pnpvar.h>
  
  #include <i386/isa/elink.h>
  
  #include <dev/ic/i82586.h>
  #include <dev/ie/if_ie507.h>
  #include <dev/ie/if_iee16.h>
  #include <dev/ie/if_iereg.h>
  #include <dev/ie/if_ievar.h>
  
  static int		ie_modevent		(module_t, int, void *);
  
  static void		ie_isa_3C507_identify	(driver_t *, device_t);
  static int		ie_isa_3C507_probe	(device_t);
  static int		ie_isa_3C507_attach	(device_t);
  static int		ie_3C507_port_check	(u_int32_t);
  
  static void		ie_isa_ee16_identify	(driver_t *, device_t);
  static int		ie_isa_ee16_probe	(device_t);
  static int		ie_isa_ee16_attach	(device_t);
  static int		ie_ee16_port_check	(u_int32_t port);
  static u_int16_t	ie_ee16_hw_read_eeprom	(u_int32_t port, int loc);
  
  static int		ie_isa_sl_probe		(device_t);
  static int		ie_isa_sl_attach	(device_t);
  static enum ie_hardware	ie_isa_sl_get_hard_type	(u_int32_t);
  
  /*
   * 3Com 3C507 Etherlink 16
   */
  #define IE_3C507_IOBASE_LOW	0x200
  #define IE_3C507_IOBASE_HIGH	0x3e0
  #define IE_3C507_IOSIZE		16
  
  #define IE_3C507_IRQ_MASK	0x0f
  
  #define IE_3C507_MADDR_HIGH	0x20
  #define IE_3C507_MADDR_MASK	0x1c
  #define IE_3C507_MADDR_BASE	0xc0000
  #define IE_3C507_MADDR_SHIFT	12
  
  #define IE_3C507_MSIZE_MASK	3
  #define IE_3C507_MSIZE_SHIFT	14
  
  static void
  ie_isa_3C507_identify (driver_t *driver, device_t parent)
  {
  	char *		desc = "3Com 3C507 Etherlink 16";
  	device_t	child;
  	u_int32_t	port, maddr, msize;
  	u_int8_t	irq, data;
  	int		error;
  
  	/* Reset and put card in CONFIG state without changing address. */
  	elink_reset();
  	elink_idseq(ELINK_507_POLY);
  	elink_idseq(ELINK_507_POLY);
  	outb(ELINK_ID_PORT, 0xff);
  
  	for (port = IE_3C507_IOBASE_LOW;
  	     port <= IE_3C507_IOBASE_HIGH;
  	     port += IE_3C507_IOSIZE) {
  
  		if (ie_3C507_port_check(port)) {
  #ifdef DEBUG 
  			if (bootverbose) {
  				device_printf(parent,
  					"(if_ie) (3C507) not found at port %#x\n",
  					port);
  			}
  #endif
  			continue;
  		}
  
  		outb(port + IE507_CTRL, EL_CTRL_NRST);
  
  		data = inb(port + IE507_IRQ);
  		irq = data & IE_3C507_IRQ_MASK;
  
  		data = inb(port + IE507_MADDR);
  
  		if (data & IE_3C507_MADDR_HIGH) {
  			if (bootverbose) {
  				device_printf(parent,
  					"(if_ie) can't map 3C507 RAM in high memory\n");
  			}
  			continue;
  		}
  
  		maddr = IE_3C507_MADDR_BASE +
  			((data & IE_3C507_MADDR_MASK)
  			<< IE_3C507_MADDR_SHIFT);
  		msize = ((data & IE_3C507_MSIZE_MASK) + 1)
  			<< IE_3C507_MSIZE_SHIFT;
  
  		child = BUS_ADD_CHILD(parent, ISA_ORDER_SPECULATIVE, "ie", -1);
  		device_set_desc_copy(child, desc);
  		device_set_driver(child, driver);
  
  		error = bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1);
  		if (error) {
  			device_printf(parent, "(if_ie) Unable to set IRQ resource %d.\n",
  					irq);
  			error = device_delete_child(parent, child);
  			continue;
  		}
  
  		error = bus_set_resource(child, SYS_RES_IOPORT, 0, port, IE_3C507_IOSIZE);
  		if (error) {
  			device_printf(parent, "(if_ie) Unable to set IOPORT resource %#x-%#x.\n",
  					port, port+IE_3C507_IOSIZE);
  			error = device_delete_child(parent, child);
  			continue;
  		}
  
  		error = bus_set_resource(child, SYS_RES_MEMORY, 0, maddr, msize);
  		if (error) {
  			device_printf(parent, "(if_ie) Unable to set MEMORY resource %#x-%#x.\n",
  					maddr, maddr+msize);
  			error = device_delete_child(parent, child);
  			continue;
  		}
  
  		if (bootverbose) {
  			device_printf(parent,
  				"(if_ie) <%s> at port %#x-%#x irq %d iomem %#lx-%#lx (%dKB)\n",
  				desc,
  				port, (port + IE_3C507_IOSIZE) - 1,
  				irq,
  				(u_long)maddr, (u_long)(maddr + msize) - 1,
  				(msize / 1024));
  		}
  	}
  
  	/* go to RUN state */
  	outb(ELINK_ID_PORT, 0x00);
  	elink_idseq(ELINK_507_POLY);
  	outb(ELINK_ID_PORT, 0x00);
  
  	return;
  }
  
  static int
  ie_isa_3C507_probe (device_t dev)
  {
  	u_int32_t	iobase;
  
  	/* No ISA-PnP support */
  	if (isa_get_vendorid(dev)) {
  		return (ENXIO);
  	}
  
  	/* No ISA-HINT support */
  	if (!device_get_desc(dev)) {
  		return (EBUSY);
  	}
  
  	/* Have we at least an ioport? */
  	if ((iobase = bus_get_resource_start(dev, SYS_RES_IOPORT, 0)) == 0) {
  		return (ENXIO);
  	}
  
  	/* Is this thing really a 3c507? */
  	if (ie_3C507_port_check(iobase)) {
  		return (ENXIO);
  	}
  
  	return (0);
  }
  
  static int
  ie_isa_3C507_attach (device_t dev)
  {
  	struct ie_softc *	sc;
  	int			error;
  
  	sc = device_get_softc(dev);
  
  	sc->io_rid = 0;
  	sc->irq_rid = 0;
  	sc->mem_rid = 0;
  
  	error = ie_alloc_resources(dev);
  	if (error) {
  		goto bad;
  	}
  
  	sc->bus_use = 0;
  	sc->ie_reset_586 = el_reset_586;
  	sc->ie_chan_attn = el_chan_attn;
  	sc->hard_type = IE_3C507;
  	sc->hard_vers = 0;
  
  	outb(PORT(sc) + IE507_CTRL, EL_CTRL_NORMAL);
  
  	if (!check_ie_present(sc)) {
  		error = ENXIO;
  		goto bad;
  	}
  
  	sl_read_ether(sc, sc->enaddr);
  
  	/* Clear the interrupt latch just in case. */
  	outb(PORT(sc) + IE507_ICTRL, 1);
  
  	error = ie_attach(dev);
  	if (error) {
  		device_printf(dev, "ie_attach() failed.\n");
  		goto bad;
  	}
  
  	error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_NET,
  				ie_intr, sc, &sc->irq_ih);
  	if (error) {
  		device_printf(dev, "Unable to register interrupt handler\n"); 
  		goto bad;
  	}
  
  	return (0);
  bad:
  	ie_release_resources(dev);
  
  	return (error);
  }
  
  /*
   * If a 3c507 is present, return 0
   * else, return 1.
   */
  static int
  ie_3C507_port_check (u_int32_t port)
  {
  	u_char *	signature = "*3COM*";
  	int		i;
  
  	for (i = 0; i < 6; i++)
  		if (inb(port + i) != signature[i])
  			return (ENXIO);
  
  	return (0);
  }
  
  /*
   * Intel EtherExpress 16
   */
  #define IE_EE16_ID_PORT			0x0f
  #define IE_EE16_ID			0xbaba
  #define IE_EE16_EEPROM_CONFIG1		0x00
  #define IE_EE16_EEPROM_IRQ_MASK		0xe000
  #define IE_EE16_EEPROM_IRQ_SHIFT	13
  #define IE_EE16_EEPROM_MEMCFG		0x06
  #define IE_EE16_IOSIZE			16
  
  /*
   * TODO:
   *		Test for 8/16 bit mode.
   *		Test for invalid mem sizes.
   */
  static void
  ie_isa_ee16_identify (driver_t *driver, device_t parent)
  {
  	char *		desc = "Intel EtherExpress 16";
  	device_t	child;
  	u_int16_t	ports[] = {
  				0x300, 0x310, 0x320, 0x330,
  				0x340, 0x350, 0x360, 0x370,
  				0x200, 0x210, 0x220, 0x230,
  				0x240, 0x250, 0x260, 0x270,
  				0
  			};
  	u_int16_t	irqs[] = { 0, 0x09, 0x03, 0x04, 0x05, 0x0a, 0x0b, 0 };
  	u_int32_t	port, maddr, msize;
  	u_int8_t	irq;
  	u_int16_t	data;
  	int		i, error;
  
  	for (i = 0; ports[i]; i++) {
  		port = ports[i];
  
  		if (ie_ee16_port_check(port)) {
  #ifdef DEBUG
  			if (bootverbose) {
  				device_printf(parent,
  					"if_ie: (EE16) not found at port %#x\n",
  					port);
  			}
  #endif
  			continue;
  		}
  
  		/* reset any ee16 at the current iobase */
  		outb(port + IEE16_ECTRL, IEE16_RESET_ASIC);
  		outb(port + IEE16_ECTRL, 0);
  		DELAY(240);
  
  		data = ie_ee16_hw_read_eeprom(port, IE_EE16_EEPROM_CONFIG1);
  		irq = irqs[((data & IE_EE16_EEPROM_IRQ_MASK)
  			   >> IE_EE16_EEPROM_IRQ_SHIFT)];
  
  		data = ie_ee16_hw_read_eeprom(port, IE_EE16_EEPROM_MEMCFG);
  		maddr = 0xc0000 + ((ffs(data & 0x00ff) - 1) * 0x4000);
  		msize = (fls((data & 0x00ff) >> (ffs(data & 0x00ff) - 1)))
  			* 0x4000;
  
  		child = BUS_ADD_CHILD(parent, ISA_ORDER_SPECULATIVE, "ie", -1);
  		device_set_desc_copy(child, desc);
  		device_set_driver(child, driver);
  
  		error = bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1);
  		if (error) {
  			device_printf(parent, "(if_ie) Unable to set IRQ resource %d.\n",
  					irq);
  			error = device_delete_child(parent, child);
  			continue;
  		}
  
  		error = bus_set_resource(child, SYS_RES_IOPORT, 0, port, IE_EE16_IOSIZE);
  		if (error) {
  			device_printf(parent, "(if_ie) Unable to set IOPORT resource %#x-%#x.\n",
  					port, port+IE_EE16_IOSIZE);
  			error = device_delete_child(parent, child);
  			continue;
  		}
  
  		error = bus_set_resource(child, SYS_RES_MEMORY, 0, maddr, msize);
  		if (error) {
  			device_printf(parent, "(if_ie) Unable to set MEMORY resource %#x-%#x.\n",
  					maddr, maddr+msize);
  			error = device_delete_child(parent, child);
  			continue;
  		}
  
  		if (bootverbose) {
  			device_printf(parent,
  				"if_ie: <%s> at port %#x-%#x irq %d iomem %#lx-%#lx (%dKB)\n",
  				desc,
  				port, (port + IE_EE16_IOSIZE) - 1,
  				irq,
  				(u_long)maddr, (u_long)(maddr + msize) - 1,
  				(msize / 1024));
  		}
  	}
  
  	return;
  }
  
  static int
  ie_isa_ee16_probe (device_t dev)
  {
  	u_int32_t	iobase;
  
  	/* No ISA-PnP support */
  	if (isa_get_vendorid(dev))
  		return (ENXIO);
  
  	/* No ISA-HINT support */
  	if (!device_get_desc(dev))
  		return (EBUSY);
  
  	/* Have we at least an ioport? */
  	if ((iobase = bus_get_resource_start(dev, SYS_RES_IOPORT, 0)) == 0)
  		return (ENXIO);
  
  	/* Is this really an EE16? */
  	if (ie_ee16_port_check(iobase))
  		return (ENXIO);
  
  	return (0);
  }
  
  static int
  ie_isa_ee16_attach (device_t dev)
  {
  	struct ie_softc *	sc;
  	int			i, error;
  	u_int16_t		checksum;
  	u_short			eaddrtemp, pg, adjust, decode, edecode;
  	u_char			bart_config;
          
  	sc = device_get_softc(dev);
  
  	sc->io_rid = 0;
  	sc->irq_rid = 0;
  	sc->mem_rid = 0;
  
  	error = ie_alloc_resources(dev);
  	if (error) {
  		goto bad;
  	}
  
  	sc->bus_use = 0;
  	sc->ie_reset_586 = ee16_reset_586;
  	sc->ie_chan_attn = ee16_chan_attn;
  	sc->hard_type = IE_EE16;
  	sc->hard_vers = 0;
  	sc->iomem = 0;
  
  	/* reset any ee16 at the current iobase */
  	outb(PORT(sc) + IEE16_ECTRL, IEE16_RESET_ASIC);
  	outb(PORT(sc) + IEE16_ECTRL, 0);
  	DELAY(240);
  
  	/* Is this really an EE16? */
  	if (ie_ee16_port_check(PORT(sc))) {
  		device_printf(dev, "ie_ee16_port_check() failed\n");
  		error = ENXIO;
  		goto bad;
  	}
  
  	/* need to put the 586 in RESET while we access the eeprom. */
  	outb(PORT(sc) + IEE16_ECTRL, IEE16_RESET_586);
  
  	/* read the eeprom and checksum it, should == IE_E16_ID */
  	checksum = 0;
  	for (i = 0; i < 0x40; i++)
  		checksum += ie_ee16_hw_read_eeprom(PORT(sc), i);
  
  	if (checksum != IE_EE16_ID) {
  		device_printf(dev, "invalid eeprom checksum: %x\n", checksum);
  		error = ENXIO;
  		goto bad;
  	}
  
  	if ((kvtop(sc->iomembot) < 0xC0000) ||
  	     (kvtop(sc->iomembot) + sc->iosize > 0xF0000)) {
  		device_printf(sc->dev, "mapped memory location %p out of range\n",
  			(void *)sc->iomembot);
  		error = ENXIO;
  		goto bad;
  	}
  
  	pg = ((kvtop(sc->iomembot)) & 0x3C000) >> 14;
  	adjust = IEE16_MCTRL_FMCS16 | (pg & 0x3) << 2;
  	decode = ((1 << (sc->iosize / 16384)) - 1) << pg;
  	edecode = ((~decode >> 4) & 0xF0) | (decode >> 8);
  
  	/* ZZZ This should be checked against eeprom location 6, low byte */
  	outb(PORT(sc) + IEE16_MEMDEC, decode & 0xFF);
  	/* ZZZ This should be checked against eeprom location 1, low byte */
  	outb(PORT(sc) + IEE16_MCTRL, adjust);
  	/* ZZZ Now if I could find this one I would have it made */
  	outb(PORT(sc) + IEE16_MPCTRL, (~decode & 0xFF));
  	/* ZZZ I think this is location 6, high byte */
  	outb(PORT(sc) + IEE16_MECTRL, edecode); /* XXX disable Exxx */
  
  #if 0
  	(void) kvtop(sc->iomembot);
  #endif
  
  	/*
  	 * first prime the stupid bart DRAM controller so that it works,
  	 * then zero out all of memory.
  	 */
  	bzero(sc->iomembot, 32);
  	bzero(sc->iomembot, sc->iosize);
  
  	/* Get the encoded interrupt number from the EEPROM */
  	sc->irq_encoded = ie_ee16_hw_read_eeprom(PORT(sc),
  						 IE_EE16_EEPROM_CONFIG1);
  	sc->irq_encoded = (sc->irq_encoded & IE_EE16_EEPROM_IRQ_MASK) >>
  			   IE_EE16_EEPROM_IRQ_SHIFT;
  
  	/*
  	 * Get the hardware ethernet address from the EEPROM and save it in
  	 * the softc for use by the 586 setup code.
  	 */
  	eaddrtemp = ie_ee16_hw_read_eeprom(PORT(sc), IEE16_EEPROM_ENET_HIGH);
  	sc->enaddr[1] = eaddrtemp & 0xFF;
  	sc->enaddr[0] = eaddrtemp >> 8;
  	eaddrtemp = ie_ee16_hw_read_eeprom(PORT(sc), IEE16_EEPROM_ENET_MID);
  	sc->enaddr[3] = eaddrtemp & 0xFF;
  	sc->enaddr[2] = eaddrtemp >> 8;
  	eaddrtemp = ie_ee16_hw_read_eeprom(PORT(sc), IEE16_EEPROM_ENET_LOW);
  	sc->enaddr[5] = eaddrtemp & 0xFF;
  	sc->enaddr[4] = eaddrtemp >> 8;
  
  	/* disable the board interrupts */
  	outb(PORT(sc) + IEE16_IRQ, sc->irq_encoded);
  
  	/* enable loopback to keep bad packets off the wire */
  	bart_config = inb(PORT(sc) + IEE16_CONFIG);
  	bart_config |= IEE16_BART_LOOPBACK;
  	bart_config |= IEE16_BART_MCS16_TEST;/* inb doesn't get bit! */
  	outb(PORT(sc) + IEE16_CONFIG, bart_config);
  	bart_config = inb(PORT(sc) + IEE16_CONFIG);
  
  	/* take the board out of reset state */
  	outb(PORT(sc) + IEE16_ECTRL, 0);
  	DELAY(100);
  
  	if (!check_ie_present(sc)) {
  		device_printf(dev, "check_ie_present() returned false.\n");
  		error = ENXIO;
  		goto bad;
  	}
  
  	error = ie_attach(dev);
  	if (error) {
  		device_printf(dev, "ie_attach() failed.\n");
  		goto bad;
  	}
  
  	error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_NET,
  				ie_intr, sc, &sc->irq_ih);
  	if (error) {
  		device_printf(dev, "Unable to register interrupt handler\n"); 
  		goto bad;
  	}
  
  	return (0);
  bad:
  	ie_release_resources(dev);
  
  	return (error);
  }
  
  /*
   * If an EE16 is present, return 0
   * else, return 1.
   */
  static int
  ie_ee16_port_check (u_int32_t port)
  {
  	int		i;
  	u_int16_t	board_id;
  	u_int8_t	data;
  
  	board_id = 0;
  	for (i = 0; i < 4; i++) {
  		data = inb(port + IE_EE16_ID_PORT);
  		board_id |= ((data >> 4) << ((data & 0x03) << 2));
  	}
  
  	if (board_id != IE_EE16_ID)
  		return (1);
  
  	return (0);
  }
  
  static void
  ie_ee16_hw_eeprom_clock (u_int32_t port, int state)
  {
  	u_int8_t	ectrl;
  
  	ectrl = inb(port + IEE16_ECTRL);
  	ectrl &= ~(IEE16_RESET_ASIC | IEE16_ECTRL_EESK);
  
  	if (state) {
  		ectrl |= IEE16_ECTRL_EESK;
  	}
  	outb(port + IEE16_ECTRL, ectrl);
  	DELAY(9);		/* EESK must be stable for 8.38 uSec */
  }
  
  static void
  ie_ee16_hw_eeprom_out (u_int32_t port, u_int16_t edata, int count)
  {
  	u_int8_t	ectrl;
  	int		i;
  
  	ectrl = inb(port + IEE16_ECTRL);
  	ectrl &= ~IEE16_RESET_ASIC;
  
  	for (i = count - 1; i >= 0; i--) {
  		ectrl &= ~IEE16_ECTRL_EEDI;
  		if (edata & (1 << i)) {
  			ectrl |= IEE16_ECTRL_EEDI;
  		}
  		outb(port + IEE16_ECTRL, ectrl);
  		DELAY(1);       /* eeprom data must be setup for 0.4 uSec */
  		ie_ee16_hw_eeprom_clock(port, 1);
  		ie_ee16_hw_eeprom_clock(port, 0);
  	}
  	ectrl &= ~IEE16_ECTRL_EEDI;
  	outb(port + IEE16_ECTRL, ectrl);
  	DELAY(1);               /* eeprom data must be held for 0.4 uSec */
  
  	return;
  }
  
  static u_int16_t
  ie_ee16_hw_eeprom_in (u_int32_t port)
  {
  	u_int8_t	ectrl;
  	u_int16_t	edata;
  	int		i;
  
  	ectrl = inb(port + IEE16_ECTRL);
  	ectrl &= ~IEE16_RESET_ASIC;
  
  	for (edata = 0, i = 0; i < 16; i++) {
  		edata = edata << 1;
  		ie_ee16_hw_eeprom_clock(port, 1);
  		ectrl = inb(port + IEE16_ECTRL);
  		if (ectrl & IEE16_ECTRL_EEDO) {
  			edata |= 1;
  		}
  		ie_ee16_hw_eeprom_clock(port, 0);
  	}
  	return (edata);
  }
  
  static u_int16_t
  ie_ee16_hw_read_eeprom (u_int32_t port, int loc)
  {
  	u_int8_t	ectrl;
  	u_int16_t	edata;
  
  	ectrl = inb(port + IEE16_ECTRL);
  	ectrl &= IEE16_ECTRL_MASK;
  	ectrl |= IEE16_ECTRL_EECS;
  	outb(port + IEE16_ECTRL, ectrl);
  
  	ie_ee16_hw_eeprom_out(port, IEE16_EEPROM_READ, IEE16_EEPROM_OPSIZE1);
  	ie_ee16_hw_eeprom_out(port, loc, IEE16_EEPROM_ADDR_SIZE);
  	edata = ie_ee16_hw_eeprom_in(port);
  
  	ectrl = inb(port + IEE16_ECTRL);
  	ectrl &= ~(IEE16_RESET_ASIC | IEE16_ECTRL_EEDI | IEE16_ECTRL_EECS);
  	outb(port + IEE16_ECTRL, ectrl);
  
  	ie_ee16_hw_eeprom_clock(port, 1);
  	ie_ee16_hw_eeprom_clock(port, 0);
  
  	return (edata);
  }
  
  /*
   * AT&T StarLan/
   */
  
  static int
  ie_isa_sl_probe (device_t dev)
  {
  	u_int32_t	iobase;
  
  	/* No ISA-PnP support */
  	if (isa_get_vendorid(dev))
  		return (ENXIO);
  
  	/* ISA-HINT support only! */
  	if (device_get_desc(dev))
  		return (EBUSY);
  
  	/* Have we at least an ioport? */
  	if ((iobase = bus_get_resource_start(dev, SYS_RES_IOPORT, 0)) == 0)
  		return (ENXIO);
  
  	/* Is this really an SL board? */
  	if (ie_isa_sl_get_hard_type(iobase) == IE_NONE)
  		return (ENXIO);
  
  	return (ENXIO);
  }
  
  static int
  ie_isa_sl_attach (device_t dev)
  {
  	struct ie_softc *	sc;
  	int			error;
  
  	sc = device_get_softc(dev);
  
  	sc->io_rid = 0;
  	sc->irq_rid = 0;
  	sc->mem_rid = 0;
  
  	error = ie_alloc_resources(dev);
  	if (error) {
  		goto bad;
  	}
  
  	/* Is this really an SL board? */
  	if ((sc->hard_type = ie_isa_sl_get_hard_type(PORT(sc))) == IE_NONE) {
  		error = ENXIO;
  		goto bad;
  	}
  
  	sc->hard_vers = SL_REV(inb(PORT(sc) + IEATT_REVISION));
  	if (sc->hard_type == IE_NI5210) {
  		sc->bus_use = 1;
  	} else {
  		sc->bus_use = 0;
  	}
  
  	sc->ie_reset_586 = sl_reset_586;
  	sc->ie_chan_attn = sl_chan_attn;
  
  	if (!check_ie_present(sc)) {
  		error = ENXIO;
  		goto bad;
  	}
  
  	switch (sc->hard_type) {
  		case IE_EN100:
  		case IE_STARLAN10:
  		case IE_SLFIBER:
  		case IE_NI5210:
  			sl_read_ether(sc, sc->enaddr);
  			break;
  		default:
  			if (bootverbose)
  				device_printf(sc->dev, "unknown AT&T board type code %d\n", sc->hard_type);
  			error = ENXIO;
  			goto bad;
  			break;
  	}
  
  	error = ie_attach(dev);
  	if (error) {
  		device_printf(dev, "ie_attach() failed.\n");
  		goto bad;
  	}
  
  	error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_NET,
  				ie_intr, sc, &sc->irq_ih);
  	if (error) {
  		device_printf(dev, "Unable to register interrupt handler\n"); 
  		goto bad;
  	}
  
  	return (0);
  bad:
  	ie_release_resources(dev);
  
  	return (error);
  }
  
  static enum ie_hardware
  ie_isa_sl_get_hard_type (u_int32_t port)
  {
  	u_char			c;
  	enum ie_hardware	retval;
  
  	c = inb(port + IEATT_REVISION);
  	switch (SL_BOARD(c)) {
  		case SL1_BOARD:
  			if (inb(port + IEATT_ATTRIB) != NI5210_BOARD)
  				retval = IE_NONE;
  			retval = IE_NI5210;
  			break;
  		case SL10_BOARD:
  			retval = IE_STARLAN10;
  			break;
  		case EN100_BOARD:
  			retval = IE_EN100;
  			break;
  		case SLFIBER_BOARD:
  			retval = IE_SLFIBER;
  			break;
  		default:
  			retval = IE_NONE;
  	}
  	return (retval);
  }
  
  static devclass_t ie_devclass;
  
  static device_method_t ie_isa_3C507_methods[] = {
  	DEVMETHOD(device_identify,	ie_isa_3C507_identify),
  	DEVMETHOD(device_probe,		ie_isa_3C507_probe),
  	DEVMETHOD(device_attach,	ie_isa_3C507_attach),
  	DEVMETHOD(device_detach,	ie_detach),
  	{ 0, 0 }
  };
  static driver_t ie_isa_3C507_driver = {
  	"ie",
  	ie_isa_3C507_methods,
  	sizeof(struct ie_softc), 
  };
  DRIVER_MODULE(ie_3C507, isa, ie_isa_3C507_driver, ie_devclass, ie_modevent, 0);
  MODULE_DEPEND(ie_3C507, elink, 1, 1, 1);
  
  static device_method_t ie_isa_ee16_methods[] = {
  	DEVMETHOD(device_identify,	ie_isa_ee16_identify),
  	DEVMETHOD(device_probe,		ie_isa_ee16_probe),
  	DEVMETHOD(device_attach,	ie_isa_ee16_attach),
  	DEVMETHOD(device_detach,	ie_detach),
  	{ 0, 0 }
  };
  static driver_t ie_isa_ee16_driver = {
  	"ie",
  	ie_isa_ee16_methods,
  	sizeof(struct ie_softc), 
  };
  DRIVER_MODULE(ie_EE16, isa, ie_isa_ee16_driver, ie_devclass, ie_modevent, 0);
  
  static device_method_t ie_isa_sl_methods[] = {
  	DEVMETHOD(device_probe,		ie_isa_sl_probe),
  	DEVMETHOD(device_attach,	ie_isa_sl_attach),
  	DEVMETHOD(device_detach,	ie_detach),
  	{ 0, 0 }
  };
  static driver_t ie_isa_sl_driver = {
  	"ie",
  	ie_isa_sl_methods,
  	sizeof(struct ie_softc), 
  };
  DRIVER_MODULE(ie_SL, isa, ie_isa_sl_driver, ie_devclass, ie_modevent, 0);
  
  static int
  ie_modevent (mod, what, arg)
  	module_t	mod;
  	int		what;
  	void *		arg;
  {
  	device_t *	devs;
  	int		count;
  	int		i;
  
  	switch (what) {
  	case MOD_LOAD:
  		break;
  	case MOD_UNLOAD:
  		devclass_get_devices(ie_devclass, &devs, &count);
  		for (i = 0; i < count; i++)
  			device_delete_child(device_get_parent(devs[i]), devs[i]);
  		break;
  	default:
  		break;
  	};
  
  	return (0);
  }
  