- Merge the pdq driver (if_fpa and if_fea) from NetBSD.

  Among other things this gets us ifmedia support.
- Update fddi_ifattach() to take an additional argument.

1 files changed, 104 insertions, 76 deletions

diff --git a/sys/dev/pdq/if_fea.c b/sys/dev/pdq/if_fea.c
index ee4fba3ed4c8..334855092eea 100644
--- a/sys/dev/pdq/if_fea.c
+++ b/sys/dev/pdq/if_fea.c
@@ -35,25 +35,32 @@
 #include <sys/kernel.h>
 #include <sys/socket.h>
 
-#include <net/if.h>
-#include <net/if_arp.h>
-
 #include <sys/module.h>
 #include <sys/bus.h>
+
 #include <machine/bus.h>
 #include <machine/resource.h>
 #include <sys/rman.h> 
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/if_media.h>
+#include <net/fddi.h>
+
 #include <dev/eisa/eisaconf.h>
-#include <dev/pdq/pdqvar.h>
+
+#include <dev/pdq/pdq_freebsd.h>
 #include <dev/pdq/pdqreg.h>
 
 static void		pdq_eisa_subprobe	(pdq_bus_t, u_int32_t, u_int32_t *, u_int32_t *, u_int32_t *);
 static void		pdq_eisa_devinit	(pdq_softc_t *);
 static const char *	pdq_eisa_match		(eisa_id_t);
+
 static int 		pdq_eisa_probe		(device_t);
 static int		pdq_eisa_attach		(device_t);
-void			pdq_eisa_intr		(void *);
+static int		pdq_eisa_detach		(device_t);
 static int		pdq_eisa_shutdown	(device_t);
+static void		pdq_eisa_ifintr		(void *);
 
 #define	DEFEA_IRQS			0x0000FBA9U
 
@@ -91,18 +98,18 @@ pdq_eisa_devinit (sc)
 	/*
 	 * Do the standard initialization for the DEFEA registers.
 	 */
-	PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_FUNCTION_CTRL, 0x23);
-	PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_IO_CMP_1_1, (sc->sc_iobase >> 8) & 0xF0);
-	PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_IO_CMP_0_1, (sc->sc_iobase >> 8) & 0xF0);
-	PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_SLOT_CTRL, 0x01);
-	data = PDQ_OS_IORD_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_BURST_HOLDOFF);
+	PDQ_OS_IOWR_8(sc->io_bst, sc->io_bsh, PDQ_EISA_FUNCTION_CTRL, 0x23);
+	PDQ_OS_IOWR_8(sc->io_bst, sc->io_bsh, PDQ_EISA_IO_CMP_1_1, (sc->io_bsh >> 8) & 0xF0);
+	PDQ_OS_IOWR_8(sc->io_bst, sc->io_bsh, PDQ_EISA_IO_CMP_0_1, (sc->io_bsh >> 8) & 0xF0);
+	PDQ_OS_IOWR_8(sc->io_bst, sc->io_bsh, PDQ_EISA_SLOT_CTRL, 0x01);
+	data = PDQ_OS_IORD_8(sc->io_bst, sc->io_bsh, PDQ_EISA_BURST_HOLDOFF);
 #if defined(PDQ_IOMAPPED)
-	PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_BURST_HOLDOFF, data & ~1);
+	PDQ_OS_IOWR_8(sc->io_bst, sc->io_bsh, PDQ_EISA_BURST_HOLDOFF, data & ~1);
 #else
-	PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_BURST_HOLDOFF, data | 1);
+	PDQ_OS_IOWR_8(sc->io_bst, sc->io_bsh, PDQ_EISA_BURST_HOLDOFF, data | 1);
 #endif
-	data = PDQ_OS_IORD_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_IO_CONFIG_STAT_0);
-	PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_IO_CONFIG_STAT_0, data | DEFEA_INTRENABLE);
+	data = PDQ_OS_IORD_8(sc->io_bst, sc->io_bsh, PDQ_EISA_IO_CONFIG_STAT_0);
+	PDQ_OS_IOWR_8(sc->io_bst, sc->io_bsh, PDQ_EISA_IO_CONFIG_STAT_0, data | DEFEA_INTRENABLE);
 
 	return;
 }
@@ -144,7 +151,7 @@ pdq_eisa_probe (dev)
 	device_set_desc(dev, desc);
 
 	iobase = eisa_get_slot(dev) * EISA_SLOT_SIZE;
-	pdq_eisa_subprobe(PDQ_BUS_EISA, iobase, &maddr, &msize, &irq);
+	pdq_eisa_subprobe(SYS_RES_IOPORT, iobase, &maddr, &msize, &irq);
 
 	eisa_add_iospace(dev, iobase, 0x200, RESVADDR_NONE);
 	eisa_add_mspace(dev, maddr, msize, RESVADDR_NONE);
@@ -153,99 +160,119 @@ pdq_eisa_probe (dev)
 	return (0);
 }
 
-void
-pdq_eisa_intr(xdev)
-	void		*xdev;
+static void
+pdq_eisa_ifintr(arg)
+	void *		arg;
 {
-	device_t	dev = (device_t) xdev;
-	pdq_softc_t	*sc = device_get_softc(dev);
+	device_t	dev;
+	pdq_softc_t *	sc;
+
+	dev = (device_t)arg;
+	sc = device_get_softc(dev);
+
+	PDQ_LOCK(sc);
 	(void) pdq_interrupt(sc->sc_pdq);
+	PDQ_LOCK(sc);
 
 	return;
 }
 
 static int
 pdq_eisa_attach (dev)
-	device_t		dev;
+	device_t	dev;
 {
-	pdq_softc_t		*sc = device_get_softc(dev);
-	struct resource		*io = 0;
-	struct resource		*irq = 0;
-	struct resource		*mspace = 0;
-	int			rid;
-	void			*ih;
-	u_int32_t		m_addr, m_size;
-
-	rid = 0;
-	io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
-				0, ~0, 1, RF_ACTIVE);
-
-	if (!io) {
-		device_printf(dev, "No I/O space?!\n");
-		goto bad;
-	}
+	pdq_softc_t *	sc;
+	struct ifnet *	ifp;
+	int		error;
 
-	rid = 0;
-	mspace = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid,
-				    0, ~0, 1, RF_ACTIVE);
+	sc = device_get_softc(dev);
+	ifp = &sc->arpcom.ac_if;
 
-	if (!mspace) {
-		device_printf(dev, "No memory space?!\n");
+	sc->dev = dev;
+
+	sc->io_rid = 0;
+	sc->io_type = SYS_RES_IOPORT;
+	sc->io = bus_alloc_resource(dev, sc->io_type, &sc->io_rid,
+				    0, ~0, 1, RF_ACTIVE);
+	if (!sc->io) {
+		device_printf(dev, "Unable to allocate I/O space resource.\n");
+		error = ENXIO;
 		goto bad;
 	}
-
-	rid = 0;
-	irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid,
-				 0, ~0, 1, RF_ACTIVE);
-
-	if (!irq) {
-		device_printf(dev, "No, irq?!\n");
+	sc->io_bsh = rman_get_bushandle(sc->io);
+	sc->io_bst = rman_get_bustag(sc->io);
+
+	sc->mem_rid = 0;
+	sc->mem_type = SYS_RES_MEMORY;
+	sc->mem = bus_alloc_resource(dev, sc->mem_type, &sc->mem_rid,
+				     0, ~0, 1, RF_ACTIVE);
+	if (!sc->mem) {
+		device_printf(dev, "Unable to allocate memory resource.\n");
+		error = ENXIO;
+		goto bad;
+	}
+	sc->mem_bsh = rman_get_bushandle(sc->mem);
+	sc->mem_bst = rman_get_bustag(sc->mem);
+
+	sc->irq_rid = 0;
+	sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irq_rid,
+				     0, ~0, 1, RF_SHAREABLE | RF_ACTIVE);
+	if (!sc->irq) {
+		device_printf(dev, "Unable to allocate interrupt resource.\n");
+		error = ENXIO;
 		goto bad;
 	}
 
-	m_addr = rman_get_start(mspace);
- 	m_size = rman_get_size(mspace);
-
-	sc->sc_iobase = (pdq_bus_ioport_t) rman_get_start(io);
-	sc->sc_membase = (pdq_bus_memaddr_t) pmap_mapdev(m_addr, m_size);
-	sc->sc_if.if_name = "fea";
-	sc->sc_if.if_unit = device_get_unit(dev);
+	ifp->if_name = "fea";
+	ifp->if_unit = device_get_unit(dev);
 
 	pdq_eisa_devinit(sc);
-	sc->sc_pdq = pdq_initialize(PDQ_BUS_EISA, sc->sc_membase,
-				    sc->sc_if.if_name, sc->sc_if.if_unit,
-				    (void *) sc, PDQ_DEFEA);
+	sc->sc_pdq = pdq_initialize(sc->mem_bst, sc->mem_bsh,
+				    ifp->if_name, ifp->if_unit,
+				    (void *)sc, PDQ_DEFEA);
 	if (sc->sc_pdq == NULL) {
-		device_printf(dev, "initialization failed\n");
+		device_printf(dev, "Initialization failed.\n");
+		error = ENXIO;
 		goto bad;
 	}
 
-	if (bus_setup_intr(dev, irq, INTR_TYPE_NET, pdq_eisa_intr, dev, &ih)) {
+	error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET,
+		               pdq_eisa_ifintr, dev, &sc->irq_ih);
+	if (error) {
+		device_printf(dev, "Failed to setup interrupt handler.\n");
+		error = ENXIO;
 		goto bad;
 	}
 
-	bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
-	pdq_ifattach(sc, NULL);
+	bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes,
+	      (caddr_t) sc->arpcom.ac_enaddr, FDDI_ADDR_LEN);
+	pdq_ifattach(sc);
 
 	return (0);
-
 bad:
-	if (io)
-		bus_release_resource(dev, SYS_RES_IOPORT, 0, io);
-	if (irq)
-		bus_release_resource(dev, SYS_RES_IRQ, 0, irq);
-	if (mspace)
-		bus_release_resource(dev, SYS_RES_MEMORY, 0, mspace);
-
-	return (-1);
+	pdq_free(dev);
+	return (error);
+}
+
+static int
+pdq_eisa_detach (dev)
+	device_t	dev;
+{
+	pdq_softc_t *	sc;
+
+	sc = device_get_softc(dev);
+	pdq_ifdetach(sc);
+
+	return (0);
 }
 
 static int
 pdq_eisa_shutdown(dev)
 	device_t	dev;
 {
-	pdq_softc_t	*sc = device_get_softc(dev);
+	pdq_softc_t *	sc;
 
+	sc = device_get_softc(dev);
 	pdq_hwreset(sc->sc_pdq);
 
 	return (0);
@@ -254,6 +281,7 @@ pdq_eisa_shutdown(dev)
 static device_method_t pdq_eisa_methods[] = {
 	DEVMETHOD(device_probe,		pdq_eisa_probe),
 	DEVMETHOD(device_attach,	pdq_eisa_attach),
+	DEVMETHOD(device_attach,	pdq_eisa_detach),
 	DEVMETHOD(device_shutdown,      pdq_eisa_shutdown),
 
 	{ 0, 0 }
@@ -265,6 +293,6 @@ static driver_t pdq_eisa_driver = {
 	sizeof(pdq_softc_t),
 };
 
-static devclass_t pdq_devclass;
-
-DRIVER_MODULE(pdq, eisa, pdq_eisa_driver, pdq_devclass, 0, 0);
+DRIVER_MODULE(if_fea, eisa, pdq_eisa_driver, pdq_devclass, 0, 0);
+/* MODULE_DEPEND(if_fea, eisa, 1, 1, 1); */
+MODULE_DEPEND(if_fea, fddi, 1, 1, 1);