Finally import the 960801 of Matt Thomas' DEC FDDI driver. I'm

importing it onto a vendor branch first, in the hope that this will
make future maintenance easier.

The conflicts are (hopefully) unimportant.  More commits that actually
bring this into the source tree will follow.

Submitted by:	Matt Thomas (thomas@lkg.dec.com)

2 files changed, 1009 insertions, 0 deletions

diff --git a/sys/dev/pdq/if_fea.c b/sys/dev/pdq/if_fea.c
new file mode 100644
index 0000000..3c17bf6
--- /dev/null
+++ b/sys/dev/pdq/if_fea.c
@@ -0,0 +1,537 @@
+/*-
+ * Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
+ * 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. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
+ *
+ * $Id: if_fea.c,v 1.7 1996/07/31 21:38:44 thomas Exp $
+ */
+
+/*
+ * DEC PDQ FDDI Controller
+ *
+ *	This module support the DEFEA EISA FDDI Controller.
+ */
+
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/mbuf.h>
+#include <sys/protosw.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/errno.h>
+#include <sys/malloc.h>
+#if defined(__FreeBSD__)
+#include <sys/devconf.h>
+#elif defined(__bsdi__) || defined(__NetBSD__)
+#include <sys/device.h>
+#endif
+
+#include <net/if.h>
+#include <net/if_types.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+
+#include "bpfilter.h"
+#if NBPFILTER > 0
+#include <net/bpf.h>
+#include <net/bpfdesc.h>
+#endif
+
+#ifdef INET
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/in_var.h>
+#include <netinet/ip.h>
+#include <netinet/if_ether.h>
+#endif
+
+#if defined(__FreeBSD__)
+#include <netinet/if_fddi.h>
+#else
+#include <net/if_fddi.h>
+#endif
+
+#include <vm/vm.h>
+#include <vm/vm_kern.h>
+#include <vm/vm_param.h>
+
+#if defined(__FreeBSD__)
+#include <i386/eisa/eisaconf.h>
+#include <i386/isa/icu.h>
+#include <dev/pdq/pdqvar.h>
+#include <dev/pdq/pdqreg.h>
+#elif defined(__bsdi__)
+#include <i386/isa/isa.h>
+#include <i386/isa/icu.h>
+#include <i386/isa/dma.h>
+#include <i386/isa/isavar.h>
+#include <i386/eisa/eisa.h>
+#include <dev/pdq/pdqvar.h>
+#include <dev/pdq/pdqreg.h>
+#elif defined(__NetBSD__)
+#include <machine/cpu.h>
+#include <machine/bus.h>
+
+#include <dev/ic/pdqvar.h>
+#include <dev/ic/pdqreg.h>
+
+#include <dev/eisa/eisareg.h>
+#include <dev/eisa/eisavar.h>
+#include <dev/eisa/eisadevs.h>
+#endif
+
+/*
+ *
+ */
+
+#define	DEFEA_IRQS		0x0000FBA9U
+
+#if defined(__FreeBSD__)
+static pdq_softc_t *pdqs_eisa[16];
+#define	PDQ_EISA_UNIT_TO_SOFTC(unit)	(pdqs_eisa[unit])
+#define	DEFEA_INTRENABLE		0x8	/* level interrupt */
+#define	pdq_eisa_ifwatchdog		NULL
+#define	DEFEA_DECODE_IRQ(n)		((DEFEA_IRQS >> ((n) << 2)) & 0x0f)
+
+#elif defined(__bsdi__)
+extern struct cfdriver feacd;
+#define	PDQ_EISA_UNIT_TO_SOFTC(unit)	((pdq_softc_t *)feacd.cd_devs[unit])
+#define	DEFEA_INTRENABLE		0x28	/* edge interrupt */
+static const int pdq_eisa_irqs[4] = { IRQ9, IRQ10, IRQ11, IRQ15 };
+#define	DEFEA_DECODE_IRQ(n)		(pdq_eisa_irqs[(n)])
+
+#elif defined(__NetBSD__)
+#define	DEFEA_INTRENABLE		0x8	/* level interrupt */
+#define	pdq_eisa_ifwatchdog		NULL
+#define	DEFEA_DECODE_IRQ(n)		((DEFEA_IRQS >> ((n) << 2)) & 0x0f)
+
+#else
+#error unknown system
+#endif
+
+#ifndef pdq_eisa_ifwatchdog
+static ifnet_ret_t
+pdq_eisa_ifwatchdog(
+    int unit)
+{
+    pdq_ifwatchdog(&PDQ_EISA_UNIT_TO_SOFTC(unit)->sc_if);
+}
+#endif
+
+static void
+pdq_eisa_subprobe(
+    pdq_bus_t bc,
+    pdq_bus_ioport_t iobase,
+    pdq_uint32_t *maddr,
+    pdq_uint32_t *msize,
+    pdq_uint32_t *irq)
+{
+    if (irq != NULL)
+	*irq = DEFEA_DECODE_IRQ(PDQ_OS_IORD_8(bc, iobase, PDQ_EISA_IO_CONFIG_STAT_0) & 3);
+    *maddr = (PDQ_OS_IORD_8(bc, iobase, PDQ_EISA_MEM_ADD_CMP_0) << 8)
+	| (PDQ_OS_IORD_8(bc, iobase, PDQ_EISA_MEM_ADD_CMP_1) << 16);
+    *msize = (PDQ_OS_IORD_8(bc, iobase, PDQ_EISA_MEM_ADD_MASK_0) + 4) << 8;
+}
+
+static void
+pdq_eisa_devinit(
+    pdq_softc_t *sc)
+{
+    pdq_uint8_t data;
+
+    /*
+     * 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);
+#if defined(PDQ_IOMAPPED)
+    PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, PDQ_EISA_BURST_HOLDOFF, data & ~1);
+#else
+    PDQ_OS_IOWR_8(sc->sc_bc, sc->sc_iobase, 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);
+}
+
+#if defined(__FreeBSD__)
+static int pdq_eisa_shutdown(struct kern_devconf *kdc, int force);
+static int pdq_eisa_probe(void);
+static int pdq_eisa_attach(struct eisa_device *ed);
+
+static unsigned long pdq_eisa_unit;
+
+static struct eisa_driver pdq_eisa_driver = {
+    "fea", pdq_eisa_probe, pdq_eisa_attach, NULL, &pdq_eisa_unit
+};
+
+DATA_SET(eisadriver_set, pdq_eisa_driver);
+
+static struct kern_devconf kdc_pdq_eisa = {
+    0, 0, 0,			/* filled in by dev_attach */
+    "fea", 0, { MDDT_EISA, 0, "net" },
+    eisa_generic_externalize, 0, pdq_eisa_shutdown, EISA_EXTERNALLEN,
+    &kdc_eisa0,			/* parent */
+    0,				/* parentdata */
+    DC_BUSY,			/* host adapters are always ``in use'' */
+    "DEC DEFEA EISA FDDI Controller",
+    DC_CLS_NETIF
+};
+
+static const char *
+pdq_eisa_match(
+    eisa_id_t type)
+{
+    if ((type >> 8) == 0x10a330)
+	return kdc_pdq_eisa.kdc_description;
+    return NULL;
+}
+
+static int
+pdq_eisa_probe(
+    void)
+{
+    struct eisa_device *ed = NULL;
+    int count;
+
+    for (count = 0; (ed = eisa_match_dev(ed, pdq_eisa_match)) != NULL; count++) {
+	pdq_bus_ioport_t iobase = ed->ioconf.slot * EISA_SLOT_SIZE;
+	pdq_uint32_t irq, maddr, msize;
+
+	eisa_add_iospace(ed, iobase, 0x200, RESVADDR_NONE);
+	pdq_eisa_subprobe(PDQ_BUS_EISA, iobase, &maddr, &msize, &irq);
+	eisa_add_mspace(ed, maddr, msize, RESVADDR_NONE);
+	eisa_add_intr(ed, irq);
+	eisa_registerdev(ed, &pdq_eisa_driver, &kdc_pdq_eisa);
+    }
+    return count;
+}
+
+static void
+pdq_eisa_interrupt(
+    void *arg)
+{
+    pdq_softc_t * const sc = (pdq_softc_t *) arg;
+    (void) pdq_interrupt(sc->sc_pdq);
+}
+
+static int
+pdq_eisa_attach(
+    struct eisa_device *ed)
+{
+    pdq_softc_t *sc;
+    resvaddr_t *iospace;
+    resvaddr_t *mspace;
+    int irq = ffs(ed->ioconf.irq) - 1;
+
+    sc = (pdq_softc_t *) malloc(sizeof(*sc), M_DEVBUF, M_WAITOK);
+    if (sc == NULL) {
+	printf("fea%d: malloc failed!\n", sc->sc_if.if_unit);
+	return -1;
+    }
+    pdqs_eisa[ed->unit] = sc;
+
+    bzero(sc, sizeof(pdq_softc_t));	/* Zero out the softc*/
+    sc->sc_if.if_name = "fea";
+    sc->sc_if.if_unit = ed->unit;
+
+    if ((iospace = ed->ioconf.ioaddrs.lh_first) == NULL) {
+	printf("fea%d: no iospace??\n", sc->sc_if.if_unit);
+	return -1;
+    }
+    if ((mspace = ed->ioconf.maddrs.lh_first) == NULL) {
+	printf("fea%d: no memory space??\n", sc->sc_if.if_unit);
+	return -1;
+    }
+
+    sc->sc_iobase = (pdq_bus_ioport_t) iospace->addr;
+    sc->sc_membase = (pdq_bus_memaddr_t) pmap_mapdev(mspace->addr, mspace->size);
+    if (sc->sc_membase == NULL) {
+	printf("fea%d: failed to map memory 0x%x-0x%x!\n",
+	       sc->sc_if.if_unit, mspace->addr, mspace->addr + mspace->size - 1);
+	return -1;
+    }
+
+    eisa_reg_start(ed);
+    if (eisa_reg_iospace(ed, iospace)) {
+	printf("fea%d: failed to register iospace 0x%x-0x%x!\n",
+	       sc->sc_if.if_unit, iospace->addr, iospace->addr + iospace->size - 1);
+	return -1;
+    }
+    if (eisa_reg_mspace(ed, mspace)) {
+	printf("fea%d: failed to register memory 0x%x-0x%x!\n",
+	       sc->sc_if.if_unit, mspace->addr, mspace->addr + mspace->size - 1);
+	return -1;
+    }
+
+    if (eisa_reg_intr(ed, irq, pdq_eisa_interrupt, sc, &net_imask, 1)) {
+	printf("fea%d: interrupt registration failed\n", sc->sc_if.if_unit);
+	return -1;
+    }
+
+    eisa_reg_end(ed);
+
+    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);
+    if (sc->sc_pdq == NULL) {
+	printf("fea%d: initialization failed\n", sc->sc_if.if_unit);
+	return -1;
+    }
+
+    if (eisa_enable_intr(ed, irq)) {
+	printf("fea%d: failed to enable interrupt\n", sc->sc_if.if_unit);
+	return -1;
+    }
+
+    bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
+    pdq_ifattach(sc, pdq_eisa_ifwatchdog);
+
+    ed->kdc->kdc_state = DC_BUSY;	 /* host adapters always busy */
+
+    return 0;
+}
+
+static int
+pdq_eisa_shutdown(
+    struct kern_devconf *kdc,
+    int force)
+{
+    pdq_hwreset(PDQ_EISA_UNIT_TO_SOFTC(kdc->kdc_unit)->sc_pdq);
+    (void) dev_detach(kdc);
+    return 0;
+}
+#endif /* __FreeBSD__ */
+
+#if defined(__bsdi__)
+static int
+pdq_eisa_probe(
+    struct device *parent,
+    struct cfdata *cf,
+    void *aux)
+{
+    struct isa_attach_args *ia = (struct isa_attach_args *) aux;
+    int slot;
+    pdq_uint32_t irq, maddr, msize;
+
+    if (isa_bustype != BUS_EISA)
+	return 0;
+
+    if ((slot = eisa_match(cf, ia)) == 0)
+	return 0;
+    ia->ia_iobase = slot << 12;
+    ia->ia_iosize = EISA_NPORT;
+    eisa_slotalloc(slot);
+
+    pdq_eisa_subprobe(PDQ_BUS_EISA, ia->ia_iobase, &maddr, &msize, &irq);
+    if (ia->ia_irq != IRQUNK && irq != ia->ia_irq) {
+	printf("fea%d: error: desired IRQ of %d does not match device's actual IRQ (%d),\n",
+	       cf->cf_unit,
+	       ffs(ia->ia_irq) - 1, ffs(irq) - 1);
+	return 0;
+    }
+    if (ia->ia_irq == IRQUNK) {
+	if ((ia->ia_irq = isa_irqalloc(irq)) == 0) {
+	    if ((ia->ia_irq = isa_irqalloc(IRQ9|IRQ10|IRQ11|IRQ15)) == 0) {
+		printf("fea%d: error: IRQ %d is already in use\n", cf->cf_unit,
+		       ffs(irq) - 1);
+		return 0;
+	    }
+	    irq = PDQ_OS_IORD_8(PDQ_BUS_EISA, ia->ia_iobase, PDQ_EISA_IO_CONFIG_STAT_0) & ~3;
+	    switch (ia->ia_irq) {
+		case IRQ9:  irq |= 0;
+		case IRQ10: irq |= 1;
+		case IRQ11: irq |= 2;
+		case IRQ15: irq |= 3;
+	    }
+	    PDQ_OS_IOWR_8(PDQ_BUS_EISA, ia->ia_iobase, PDQ_EISA_IO_CONFIG_STAT_0, irq);
+	}
+    }
+    if (maddr == 0) {
+	printf("fea%d: error: memory not enabled! ECU reconfiguration required\n",
+	       cf->cf_unit);
+	return 0;
+    }
+
+    /* EISA bus masters don't use host DMA channels */
+    ia->ia_drq = DRQNONE;
+
+    ia->ia_maddr = (caddr_t) maddr;
+    ia->ia_msize = msize;
+    return 1;
+}
+
+static void
+pdq_eisa_attach(
+    struct device *parent,
+    struct device *self,
+    void *aux)
+{
+    pdq_softc_t *sc = (pdq_softc_t *) self;
+    register struct isa_attach_args *ia = (struct isa_attach_args *) aux;
+    register struct ifnet *ifp = &sc->sc_if;
+
+    sc->sc_if.if_unit = sc->sc_dev.dv_unit;
+    sc->sc_if.if_name = "fea";
+    sc->sc_if.if_flags = 0;
+
+    sc->sc_iobase = ia->ia_iobase;
+
+    pdq_eisa_devinit(sc);
+    sc->sc_pdq = pdq_initialize(PDQ_BUS_EISA,
+				(pdq_bus_memaddr_t) ISA_HOLE_VADDR(ia->ia_maddr),
+				sc->sc_if.if_name, sc->sc_if.if_unit,
+				(void *) sc, PDQ_DEFEA);
+    if (sc->sc_pdq == NULL) {
+	printf("fea%d: initialization failed\n", sc->sc_if.if_unit);
+	return;
+    }
+
+    bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
+
+    pdq_ifattach(sc, pdq_eisa_ifwatchdog);
+
+    isa_establish(&sc->sc_id, &sc->sc_dev);
+
+    sc->sc_ih.ih_fun = pdq_interrupt;
+    sc->sc_ih.ih_arg = (void *) sc->sc_pdq;
+    intr_establish(ia->ia_irq, &sc->sc_ih, DV_NET);
+
+    sc->sc_ats.func = (void (*)(void *)) pdq_hwreset;
+    sc->sc_ats.arg = (void *) sc->sc_pdq;
+    atshutdown(&sc->sc_ats, ATSH_ADD);
+}
+
+static char *pdq_eisa_ids[] = {
+    "DEC3001",	/* 0x0130A310 */
+    "DEC3002",	/* 0x0230A310 */
+    "DEC3003",	/* 0x0330A310 */
+    "DEC3004",	/* 0x0430A310 */
+};
+
+struct cfdriver feacd = {
+    0, "fea", pdq_eisa_probe, pdq_eisa_attach, DV_IFNET, sizeof(pdq_softc_t),
+    pdq_eisa_ids
+};
+#endif /* __bsdi__ */
+
+#if defined(__NetBSD__)
+static int
+pdq_eisa_match(
+    struct device *parent,
+    void *match,
+    void *aux)
+{
+    const struct eisa_attach_args * const ea = (struct eisa_attach_args *) aux;
+
+    if (strncmp(ea->ea_idstring, "DEC300", 6) == 0)
+	return 1;
+
+    return 0;
+}
+
+static void
+pdq_eisa_attach(
+    struct device *parent,
+    struct device *self,
+    void *aux)
+{
+    pdq_softc_t * const sc = (pdq_softc_t *) self;
+    struct eisa_attach_args * const ea = (struct eisa_attach_args *) aux;
+    pdq_uint32_t irq, maddr, msize;
+    eisa_intr_handle_t ih;
+    const char *intrstr;
+
+    sc->sc_bc = ea->ea_bc;
+    bcopy(sc->sc_dev.dv_xname, sc->sc_if.if_xname, IFNAMSIZ);
+    sc->sc_if.if_flags = 0;
+    sc->sc_if.if_softc = sc;
+
+    if (bus_io_map(sc->sc_bc, EISA_SLOT_ADDR(ea->ea_slot), EISA_SLOT_SIZE, &sc->sc_iobase)) {
+	printf("\n%s: failed to map I/O!\n", sc->sc_dev.dv_xname);
+	return;
+    }
+
+    pdq_eisa_subprobe(sc->sc_bc, sc->sc_iobase, &maddr, &msize, &irq);
+
+#if !defined(PDQ_IOMAPPED)
+    if (maddr == 0 || msize == 0) {
+	printf("\n%s: error: memory not enabled! ECU reconfiguration required\n",
+	       sc->sc_dev.dv_xname);
+	return;
+    }
+
+    if (bus_mem_map(sc->sc_bc, maddr, msize, 0, &sc->sc_membase)) {
+	bus_io_unmap(sc->sc_bc, sc->sc_iobase, EISA_SLOT_SIZE);
+	printf("\n%s: failed to map memory (0x%x-0x%x)!\n",
+	       sc->sc_dev.dv_xname, maddr, maddr + msize - 1);
+	return;
+    }
+#endif
+    pdq_eisa_devinit(sc);
+    sc->sc_pdq = pdq_initialize(sc->sc_bc, sc->sc_membase,
+				sc->sc_if.if_xname, 0,
+				(void *) sc, PDQ_DEFEA);
+    if (sc->sc_pdq == NULL) {
+	printf("%s: initialization failed\n", sc->sc_dev.dv_xname);
+	return;
+    }
+
+    bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
+
+    pdq_ifattach(sc, pdq_eisa_ifwatchdog);
+
+    if (eisa_intr_map(ea->ea_ec, irq, &ih)) {
+	printf("%s: couldn't map interrupt (%d)\n", sc->sc_dev.dv_xname, irq);
+	return;
+    }
+    intrstr = eisa_intr_string(ea->ea_ec, ih);
+    sc->sc_ih = eisa_intr_establish(ea->ea_ec, ih, IST_LEVEL, IPL_NET,
+				    (int (*)(void *)) pdq_interrupt, sc->sc_pdq);
+    if (sc->sc_ih == NULL) {
+	printf("%s: couldn't establish interrupt", sc->sc_dev.dv_xname);
+	if (intrstr != NULL)
+	    printf(" at %s", intrstr);
+	printf("\n");
+	return;
+    }
+    sc->sc_ats = shutdownhook_establish((void (*)(void *)) pdq_hwreset, sc->sc_pdq);
+    if (sc->sc_ats == NULL)
+	printf("%s: warning: couldn't establish shutdown hook\n", self->dv_xname);
+#if !defined(PDQ_IOMAPPED)
+    printf("%s: using iomem 0x%x-0x%x\n", sc->sc_dev.dv_xname, maddr, maddr + msize - 1);
+#endif
+    if (intrstr != NULL)
+	printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname, intrstr);
+}
+
+struct cfattach fea_ca = {
+    sizeof(pdq_softc_t), pdq_eisa_match, pdq_eisa_attach
+};
+
+struct cfdriver fea_cd = {
+    0, "fea", DV_IFNET
+};
+#endif
diff --git a/sys/dev/pdq/if_fpa.c b/sys/dev/pdq/if_fpa.c
new file mode 100644
index 0000000..40757ba
--- /dev/null
+++ b/sys/dev/pdq/if_fpa.c
@@ -0,0 +1,472 @@
+/*-
+ * Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
+ * 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. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
+ *
+ * $Id: if_fpa.c,v 1.9 1996/07/31 21:38:44 thomas Exp $
+ *
+ */
+
+/*
+ * DEC PDQ FDDI Controller; code for BSD derived operating systems
+ *
+ *   This module supports the DEC DEFPA PCI FDDI Controller
+ */
+
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/mbuf.h>
+#include <sys/protosw.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/errno.h>
+#include <sys/malloc.h>
+#if defined(__FreeBSD__)
+#include <sys/devconf.h>
+#elif defined(__bsdi__) || defined(__NetBSD__)
+#include <sys/device.h>
+#endif
+
+#include <net/if.h>
+#include <net/if_types.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+
+#include "bpfilter.h"
+#if NBPFILTER > 0
+#include <net/bpf.h>
+#include <net/bpfdesc.h>
+#endif
+
+#ifdef INET
+#include <netinet/in.h>
+#include <netinet/if_ether.h>
+#endif
+#if defined(__FreeBSD__)
+#include <netinet/if_fddi.h>
+#else
+#include <net/if_fddi.h>
+#endif
+
+#include <vm/vm.h>
+#include <vm/vm_kern.h>
+#include <vm/vm_param.h>
+
+#if defined(__FreeBSD__)
+#include "fpa.h"
+#include <pci/pcivar.h>
+#include <i386/isa/icu.h>
+#include <dev/pdq/pdqvar.h>
+#include <dev/pdq/pdqreg.h>
+#elif defined(__bsdi__)
+#include <i386/isa/isavar.h>
+#include <i386/isa/icu.h>
+#ifndef DRQNONE
+#define	DRQNONE		0
+#endif
+#if _BSDI_VERSION < 199401
+#define IRQSHARE	0
+#endif
+#include <i386/pci/pci.h>
+#include <dev/pdq/pdqvar.h>
+#include <dev/pdq/pdqreg.h>
+#elif defined(__NetBSD__)
+#include <dev/pci/pcivar.h>
+#include <dev/ic/pdqvar.h>
+#include <dev/ic/pdqreg.h>
+#endif /* __NetBSD__ */
+
+
+#define	DEC_VENDORID		0x1011
+#define	DEFPA_CHIPID		0x000F
+#define	PCI_VENDORID(x)		((x) & 0xFFFF)
+#define	PCI_CHIPID(x)		(((x) >> 16) & 0xFFFF)
+
+#define	DEFPA_LATENCY	0x88
+
+#define	PCI_CFLT	0x0C	/* Configuration Latency */
+#define	PCI_CBMA	0x10	/* Configuration Base Memory Address */
+#define	PCI_CBIO	0x14	/* Configuration Base I/O Address */
+
+#if defined(__FreeBSD__)
+#if NFPA < 4
+#undef NFPA
+#define NFPA	4
+#endif
+static pdq_softc_t *pdqs_pci[NFPA];
+#define	PDQ_PCI_UNIT_TO_SOFTC(unit)	(pdqs_pci[unit])
+#if BSD >= 199506
+#define	pdq_pci_ifwatchdog		NULL
+#endif
+
+#elif defined(__bsdi__)
+extern struct cfdriver fpacd;
+#define	PDQ_PCI_UNIT_TO_SOFTC(unit)	((pdq_softc_t *)fpacd.cd_devs[unit])
+
+#elif defined(__NetBSD__)
+extern struct cfattach fpa_ca;
+extern struct cfdriver fpa_cd;
+#define	PDQ_PCI_UNIT_TO_SOFTC(unit)	((pdq_softc_t *)fpa_cd.cd_devs[unit])
+#define	pdq_pci_ifwatchdog		NULL
+#endif
+
+#ifndef pdq_pci_ifwatchdog
+static ifnet_ret_t
+pdq_pci_ifwatchdog(
+    int unit)
+{
+    pdq_ifwatchdog(&PDQ_PCI_UNIT_TO_SOFTC(unit)->sc_if);
+}
+#endif
+
+#if defined(__FreeBSD__) && BSD >= 199506
+static void
+pdq_pci_ifintr(
+    void *arg)
+{
+    (void) pdq_interrupt(((pdq_softc_t *) arg)->sc_pdq);
+}
+#else
+static int
+pdq_pci_ifintr(
+    void *arg)
+{
+    pdq_softc_t * const sc = (pdq_softc_t *) arg;
+#ifdef __FreeBSD__
+    return pdq_interrupt(sc->sc_pdq);
+#elif defined(__bsdi__) || defined(__NetBSD__)
+    (void) pdq_interrupt(sc->sc_pdq);
+    return 1;
+#endif
+}
+#endif /* __FreeBSD && BSD */
+
+#if defined(__FreeBSD__)
+/*
+ * This is the PCI configuration support.  Since the PDQ is available
+ * on both EISA and PCI boards, one must be careful in how defines the
+ * PDQ in the config file.
+ */
+static char *
+pdq_pci_probe(
+    pcici_t config_id,
+    pcidi_t device_id)
+{
+    if (PCI_VENDORID(device_id) == DEC_VENDORID &&
+	    PCI_CHIPID(device_id) == DEFPA_CHIPID)
+	return "Digital DEFPA PCI FDDI Controller";
+    return NULL;
+}
+
+static void
+pdq_pci_attach(
+    pcici_t config_id,
+    int unit)
+{
+    pdq_softc_t *sc;
+    vm_offset_t va_csrs, pa_csrs;
+    pdq_uint32_t data;
+
+    if (unit == NFPA) {
+	printf("fpa%d: not configured; kernel is built for only %d device%s.\n",
+	       unit, NFPA, NFPA == 1 ? "" : "s");
+	return;
+    }
+
+    data = pci_conf_read(config_id, PCI_CFLT);
+    if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
+	data &= ~0xFF00;
+	data |= DEFPA_LATENCY << 8;
+	pci_conf_write(config_id, PCI_CFLT, data);
+    }
+
+    sc = (pdq_softc_t *) malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
+    if (sc == NULL)
+	return;
+
+    bzero(sc, sizeof(pdq_softc_t));	/* Zero out the softc*/
+    if (!pci_map_mem(config_id, PCI_CBMA, &va_csrs, &pa_csrs)) {
+	free((void *) sc, M_DEVBUF);
+	return;
+    }
+
+    sc->sc_if.if_name = "fpa";
+    sc->sc_if.if_unit = unit;
+    sc->sc_membase = (pdq_bus_memaddr_t) va_csrs;
+    sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
+				sc->sc_if.if_name, sc->sc_if.if_unit,
+				(void *) sc, PDQ_DEFPA);
+    if (sc->sc_pdq == NULL) {
+	free((void *) sc, M_DEVBUF);
+	return;
+    }
+    bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
+    pdqs_pci[unit] = sc;
+    pdq_ifattach(sc, pdq_pci_ifwatchdog);
+    pci_map_int(config_id, pdq_pci_ifintr, (void*) sc, &net_imask);
+}
+
+static int
+pdq_pci_shutdown(
+    struct kern_devconf *kdc,
+    int force)
+{
+    if (kdc->kdc_unit < NFPA)
+	pdq_hwreset(PDQ_PCI_UNIT_TO_SOFTC(kdc->kdc_unit)->sc_pdq);
+    (void) dev_detach(kdc);
+    return 0;
+}
+
+static u_long pdq_pci_count;
+
+struct pci_device fpadevice = {
+    "fpa",
+    pdq_pci_probe,
+    pdq_pci_attach,
+    &pdq_pci_count,
+    pdq_pci_shutdown,
+};
+
+#ifdef DATA_SET
+DATA_SET (pcidevice_set, fpadevice);
+#endif
+#elif defined(__bsdi__)
+
+static int
+pdq_pci_match(
+    pci_devaddr_t *pa)
+{
+    int irq;
+    int id;
+
+    id = pci_inl(pa, PCI_VENDOR_ID);
+    if (PCI_VENDORID(id) != DEC_VENDORID || PCI_CHIPID(id) != DEFPA_CHIPID)
+	return 0;
+
+    irq = pci_inl(pa, PCI_I_LINE) & 0xFF;
+    if (irq == 0 || irq >= 16)
+	return 0;
+
+    return 1;
+}
+
+int
+pdq_pci_probe(
+    struct device *parent,
+    struct cfdata *cf,
+    void *aux)
+{
+    struct isa_attach_args *ia = (struct isa_attach_args *) aux;
+    pdq_uint32_t irq, data;
+    pci_devaddr_t *pa;
+
+    pa = pci_scan(pdq_pci_match);
+    if (pa == NULL)
+	return 0;
+
+    irq = (1 << (pci_inl(pa, PCI_I_LINE) & 0xFF));
+
+    if (ia->ia_irq != IRQUNK && irq != ia->ia_irq) {
+	printf("fpa%d: error: desired IRQ of %d does not match device's actual IRQ of %d\n",
+	       cf->cf_unit,
+	       ffs(ia->ia_irq) - 1, ffs(irq) - 1);
+	return 0;
+    }
+    if (ia->ia_irq == IRQUNK) {
+	(void) isa_irqalloc(irq);
+	ia->ia_irq = irq;
+    }
+
+    /* PCI bus masters don't use host DMA channels */
+    ia->ia_drq = DRQNONE;
+
+    /* Get the memory base address; assume the BIOS set it up correctly */
+    ia->ia_maddr = (caddr_t) (pci_inl(pa, PCI_CBMA) & ~7);
+    pci_outl(pa, PCI_CBMA, 0xFFFFFFFF);
+    ia->ia_msize = ((~pci_inl(pa, PCI_CBMA)) | 7) + 1;
+    pci_outl(pa, PCI_CBMA, (int) ia->ia_maddr);
+
+    /* Disable I/O space access */
+    pci_outl(pa, PCI_COMMAND, pci_inl(pa, PCI_COMMAND) & ~1);
+    ia->ia_iobase = 0;
+    ia->ia_iosize = 0;
+
+    /* Make sure the latency timer is what the DEFPA likes */
+    data = pci_inl(pa, PCI_CFLT);
+    if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
+	data &= ~0xFF00;
+	data |= DEFPA_LATENCY << 8;
+	pci_outl(pa, PCI_CFLT, data);
+    }
+    ia->ia_irq |= IRQSHARE;
+
+    return 1;
+}
+
+void
+pdq_pci_attach(
+    struct device *parent,
+    struct device *self,
+    void *aux)
+{
+    pdq_softc_t *sc = (pdq_softc_t *) self;
+    register struct isa_attach_args *ia = (struct isa_attach_args *) aux;
+    register struct ifnet *ifp = &sc->sc_if;
+    int i;
+
+    sc->sc_if.if_unit = sc->sc_dev.dv_unit;
+    sc->sc_if.if_name = "fpa";
+    sc->sc_if.if_flags = 0;
+    sc->sc_membase = (pdq_bus_memaddr_t) mapphys((vm_offset_t)ia->ia_maddr, ia->ia_msize);
+
+    sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
+				sc->sc_if.if_name, sc->sc_if.if_unit,
+				(void *) sc, PDQ_DEFPA);
+    if (sc->sc_pdq == NULL) {
+	printf("fpa%d: initialization failed\n", sc->sc_if.if_unit);
+	return;
+    }
+
+    bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
+
+    pdq_ifattach(sc, pdq_pci_ifwatchdog);
+
+    isa_establish(&sc->sc_id, &sc->sc_dev);
+
+    sc->sc_ih.ih_fun = pdq_pci_ifintr;
+    sc->sc_ih.ih_arg = (void *)sc;
+    intr_establish(ia->ia_irq, &sc->sc_ih, DV_NET);
+
+    sc->sc_ats.func = (void (*)(void *)) pdq_hwreset;
+    sc->sc_ats.arg = (void *) sc->sc_pdq;
+    atshutdown(&sc->sc_ats, ATSH_ADD);
+}
+
+struct cfdriver fpacd = {
+    0, "fpa", pdq_pci_probe, pdq_pci_attach,
+#if _BSDI_VERSION >= 199401
+    DV_IFNET,
+#endif
+    sizeof(pdq_softc_t)
+};
+
+#elif defined(__NetBSD__)
+
+static int
+pdq_pci_match(
+    struct device *parent,
+    void *match,
+    void *aux)
+{
+    struct pci_attach_args *pa = (struct pci_attach_args *) aux;
+
+    if (PCI_VENDORID(pa->pa_id) != DEC_VENDORID)
+	return 0;
+    if (PCI_CHIPID(pa->pa_id) == DEFPA_CHIPID)
+	return 1;
+
+    return 0;
+}
+
+static void
+pdq_pci_attach(
+    struct device * const parent,
+    struct device * const self,
+    void * const aux)
+{
+    pdq_softc_t * const sc = (pdq_softc_t *) self;
+    struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
+    pdq_uint32_t data;
+    pci_intr_handle_t intrhandle;
+    const char *intrstr;
+#ifdef PDQ_IOMAPPED
+    bus_io_addr_t iobase;
+    bus_io_size_t iosize;
+#else
+    bus_mem_addr_t membase;
+    bus_mem_size_t memsize;
+#endif
+
+    data = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFLT);
+    if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
+	data &= ~0xFF00;
+	data |= DEFPA_LATENCY << 8;
+	pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_CFLT, data);
+    }
+
+    sc->sc_bc = pa->pa_bc;
+    bcopy(sc->sc_dev.dv_xname, sc->sc_if.if_xname, IFNAMSIZ);
+    sc->sc_if.if_flags = 0;
+    sc->sc_if.if_softc = sc;
+
+#ifdef PDQ_IOMAPPED
+    if (pci_io_find(pa->pa_pc, pa->pa_tag, PCI_CBIO, &iobase, &iosize)
+	    || bus_io_map(pa->pa_bc, iobase, iosize, &sc->sc_iobase))
+	return;
+#else
+    if (pci_mem_find(pa->pa_pc, pa->pa_tag, PCI_CBMA, &membase, &memsize, NULL)
+	    || bus_mem_map(pa->pa_bc, membase, memsize, 0, &sc->sc_membase))
+	return;
+#endif
+
+    sc->sc_pdq = pdq_initialize(sc->sc_bc, sc->sc_membase,
+				sc->sc_if.if_xname, 0,
+				(void *) sc, PDQ_DEFPA);
+    if (sc->sc_pdq == NULL) {
+	printf("%s: initialization failed\n", sc->sc_dev.dv_xname);
+	return;
+    }
+
+    bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
+    pdq_ifattach(sc, pdq_pci_ifwatchdog);
+
+    if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
+		     pa->pa_intrline, &intrhandle)) {
+	printf("%s: couldn't map interrupt\n", self->dv_xname);
+	return;
+    }
+    intrstr = pci_intr_string(pa->pa_pc, intrhandle);
+    sc->sc_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET, pdq_pci_ifintr, sc);
+    if (sc->sc_ih == NULL) {
+	printf("%s: couldn't establish interrupt", self->dv_xname);
+	if (intrstr != NULL)
+	    printf(" at %s", intrstr);
+	printf("\n");
+	return;
+    }
+
+    sc->sc_ats = shutdownhook_establish((void (*)(void *)) pdq_hwreset, sc->sc_pdq);
+    if (sc->sc_ats == NULL)
+	printf("%s: warning: couldn't establish shutdown hook\n", self->dv_xname);
+    if (intrstr != NULL)
+	printf("%s: interrupting at %s\n", self->dv_xname, intrstr);
+}
+
+struct cfattach fpa_ca = {
+    sizeof(pdq_softc_t), pdq_pci_match, pdq_pci_attach
+};
+
+struct cfdriver fpa_cd = {
+    0, "fpa", DV_IFNET
+};
+
+#endif /* __NetBSD__ */