2 * Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. The name of the author may not be used to endorse or promote products
11 * derived from this software withough specific prior written permission
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 * $FreeBSD: src/sys/dev/pdq/if_fpa.c,v 1.13 1999/08/28 00:50:50 peter Exp $
25 * $DragonFly: src/sys/dev/netif/fpa/Attic/if_fpa.c,v 1.12 2005/11/28 17:13:42 dillon Exp $
29 * DEC PDQ FDDI Controller; code for BSD derived operating systems
31 * This module supports the DEC DEFPA PCI FDDI Controller
34 #include <sys/param.h>
35 #include <sys/kernel.h>
36 #include <sys/socket.h>
37 #if defined(__bsdi__) || defined(__NetBSD__)
38 #include <sys/device.h>
40 #include <sys/serialize.h>
44 #if defined(__DragonFly__) || defined(__FreeBSD__)
46 #include <sys/eventhandler.h>
47 #include <net/ethernet.h>
48 #include <net/if_arp.h>
49 #include <bus/pci/pcivar.h>
50 #include <dev/netif/pdq_layer/pdqvar.h>
51 #include <dev/netif/pdq_layer/pdqreg.h>
52 #elif defined(__bsdi__)
53 #include <i386/isa/isavar.h>
54 #include <i386/icu/icu.h>
58 #if _BSDI_VERSION < 199401
61 #elif defined(__NetBSD__)
62 #include <dev/pci/pcivar.h>
63 #include <dev/ic/pdqvar.h>
64 #include <dev/ic/pdqreg.h>
65 #endif /* __NetBSD__ */
68 #define DEC_VENDORID 0x1011
69 #define DEFPA_CHIPID 0x000F
70 #define PCI_VENDORID(x) ((x) & 0xFFFF)
71 #define PCI_CHIPID(x) (((x) >> 16) & 0xFFFF)
73 #define DEFPA_LATENCY 0x88
75 #define PCI_CFLT 0x0C /* Configuration Latency */
76 #define PCI_CBMA 0x10 /* Configuration Base Memory Address */
77 #define PCI_CBIO 0x14 /* Configuration Base I/O Address */
79 #if defined(__DragonFly__) || defined(__FreeBSD__)
84 static pdq_softc_t *pdqs_pci[NFPA];
85 #define PDQ_PCI_UNIT_TO_SOFTC(unit) (pdqs_pci[unit])
87 #define pdq_pci_ifwatchdog NULL
90 #elif defined(__bsdi__)
91 extern struct cfdriver fpacd;
92 #define PDQ_PCI_UNIT_TO_SOFTC(unit) ((pdq_softc_t *)fpacd.cd_devs[unit])
94 #elif defined(__NetBSD__)
95 extern struct cfattach fpa_ca;
96 extern struct cfdriver fpa_cd;
97 #define PDQ_PCI_UNIT_TO_SOFTC(unit) ((pdq_softc_t *)fpa_cd.cd_devs[unit])
98 #define pdq_pci_ifwatchdog NULL
101 #ifndef pdq_pci_ifwatchdog
106 pdq_ifwatchdog(&PDQ_PCI_UNIT_TO_SOFTC(unit)->sc_if);
110 #if defined(__DragonFly__) || (defined(__FreeBSD__) && BSD >= 199506)
115 pdq_softc_t *sc = arg;
117 lwkt_serialize_enter(sc->sc_if.if_serializer);
118 pdq_interrupt(sc->sc_pdq);
119 lwkt_serialize_exit(sc->sc_if.if_serializer);
126 pdq_softc_t * const sc = (pdq_softc_t *) arg;
127 #if defined(__DragonFly__) || defined(__FreeBSD__)
128 return pdq_interrupt(sc->sc_pdq);
129 #elif defined(__bsdi__) || defined(__NetBSD__)
130 (void) pdq_interrupt(sc->sc_pdq);
134 #endif /* __FreeBSD && BSD */
136 #if defined(__DragonFly__) || defined(__FreeBSD__)
137 static void pdq_pci_shutdown(void *, int);
140 * This is the PCI configuration support. Since the PDQ is available
141 * on both EISA and PCI boards, one must be careful in how defines the
142 * PDQ in the config file.
149 if (PCI_VENDORID(device_id) == DEC_VENDORID &&
150 PCI_CHIPID(device_id) == DEFPA_CHIPID)
151 return "Digital DEFPA PCI FDDI Controller";
161 vm_offset_t va_csrs, pa_csrs;
165 printf("fpa%d: not configured; kernel is built for only %d device%s.\n",
166 unit, NFPA, NFPA == 1 ? "" : "s");
170 data = pci_conf_read(config_id, PCI_CFLT);
171 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
173 data |= DEFPA_LATENCY << 8;
174 pci_conf_write(config_id, PCI_CFLT, data);
177 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
178 if (!pci_map_mem(config_id, PCI_CBMA, &va_csrs, &pa_csrs)) {
179 free((void *) sc, M_DEVBUF);
183 if_initname(&(sc->sc_if), "fpa", unit);
184 sc->sc_membase = (pdq_bus_memaddr_t) va_csrs;
185 sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
186 sc->sc_if.if_dname, sc->sc_if.if_dunit,
187 (void *) sc, PDQ_DEFPA);
188 if (sc->sc_pdq == NULL) {
189 free((void *) sc, M_DEVBUF);
192 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
194 pdq_ifattach(sc, pdq_pci_ifwatchdog);
195 pci_map_int(config_id, pdq_pci_ifintr, (void*) sc);
196 EVENTHANDLER_REGISTER(shutdown_post_sync, pdq_pci_shutdown, sc,
197 SHUTDOWN_PRI_DEFAULT);
206 lwkt_serialize_enter(sc->sc_if.if_serializer);
207 pdq_hwreset(((pdq_softc_t *)sc)->sc_pdq);
208 lwkt_serialize_exit(sc->sc_if.if_serializer);
211 static u_long pdq_pci_count;
213 static struct pci_device fpadevice = {
221 COMPAT_PCI_DRIVER (if_fpa, fpadevice);
223 #elif defined(__bsdi__)
232 id = pci_inl(pa, PCI_VENDOR_ID);
233 if (PCI_VENDORID(id) != DEC_VENDORID || PCI_CHIPID(id) != DEFPA_CHIPID)
236 irq = pci_inl(pa, PCI_I_LINE) & 0xFF;
237 if (irq == 0 || irq >= 16)
245 struct device *parent,
249 struct isa_attach_args *ia = (struct isa_attach_args *) aux;
250 pdq_uint32_t irq, data;
253 pa = pci_scan(pdq_pci_match);
257 irq = (1 << (pci_inl(pa, PCI_I_LINE) & 0xFF));
259 if (ia->ia_irq != IRQUNK && irq != ia->ia_irq) {
260 printf("fpa%d: error: desired IRQ of %d does not match device's actual IRQ of %d\n",
262 ffs(ia->ia_irq) - 1, ffs(irq) - 1);
265 if (ia->ia_irq == IRQUNK) {
266 (void) isa_irqalloc(irq);
270 /* PCI bus masters don't use host DMA channels */
271 ia->ia_drq = DRQNONE;
273 /* Get the memory base address; assume the BIOS set it up correctly */
274 ia->ia_maddr = (caddr_t) (pci_inl(pa, PCI_CBMA) & ~7);
275 pci_outl(pa, PCI_CBMA, 0xFFFFFFFF);
276 ia->ia_msize = ((~pci_inl(pa, PCI_CBMA)) | 7) + 1;
277 pci_outl(pa, PCI_CBMA, (int) ia->ia_maddr);
279 /* Disable I/O space access */
280 pci_outl(pa, PCI_COMMAND, pci_inl(pa, PCI_COMMAND) & ~1);
284 /* Make sure the latency timer is what the DEFPA likes */
285 data = pci_inl(pa, PCI_CFLT);
286 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
288 data |= DEFPA_LATENCY << 8;
289 pci_outl(pa, PCI_CFLT, data);
291 ia->ia_irq |= IRQSHARE;
298 struct device *parent,
302 pdq_softc_t *sc = (pdq_softc_t *) self;
303 struct isa_attach_args *ia = (struct isa_attach_args *) aux;
304 struct ifnet *ifp = &sc->sc_if;
307 if_initname(&(sc->sc_if), "fpa", sc->sc_dev.dv_unit);
308 sc->sc_if.if_flags = 0;
309 sc->sc_membase = (pdq_bus_memaddr_t) mapphys((vm_offset_t)ia->ia_maddr, ia->ia_msize);
311 sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
312 sc->sc_if.if_dname, sc->sc_if.if_dunit,
313 (void *) sc, PDQ_DEFPA);
314 if (sc->sc_pdq == NULL) {
315 printf("%s: initialization failed\n", sc->sc_if.if_xname);
319 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
321 pdq_ifattach(sc, pdq_pci_ifwatchdog);
323 isa_establish(&sc->sc_id, &sc->sc_dev);
325 sc->sc_ih.ih_fun = pdq_pci_ifintr;
326 sc->sc_ih.ih_arg = (void *)sc;
327 intr_establish(ia->ia_irq, &sc->sc_ih, DV_NET);
329 sc->sc_ats.func = (void (*)(void *)) pdq_hwreset;
330 sc->sc_ats.arg = (void *) sc->sc_pdq;
331 atshutdown(&sc->sc_ats, ATSH_ADD);
334 struct cfdriver fpacd = {
335 0, "fpa", pdq_pci_probe, pdq_pci_attach,
336 #if _BSDI_VERSION >= 199401
342 #elif defined(__NetBSD__)
346 struct device *parent,
350 struct pci_attach_args *pa = (struct pci_attach_args *) aux;
352 if (PCI_VENDORID(pa->pa_id) != DEC_VENDORID)
354 if (PCI_CHIPID(pa->pa_id) == DEFPA_CHIPID)
362 struct device * const parent,
363 struct device * const self,
366 pdq_softc_t * const sc = (pdq_softc_t *) self;
367 struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
369 pci_intr_handle_t intrhandle;
372 bus_io_addr_t iobase;
373 bus_io_size_t iosize;
375 bus_mem_addr_t membase;
376 bus_mem_size_t memsize;
379 data = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFLT);
380 if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
382 data |= DEFPA_LATENCY << 8;
383 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_CFLT, data);
386 sc->sc_bc = pa->pa_bc;
387 bcopy(sc->sc_dev.dv_xname, sc->sc_if.if_xname, IFNAMSIZ);
388 sc->sc_if.if_flags = 0;
389 sc->sc_if.if_softc = sc;
392 if (pci_io_find(pa->pa_pc, pa->pa_tag, PCI_CBIO, &iobase, &iosize)
393 || bus_io_map(pa->pa_bc, iobase, iosize, &sc->sc_iobase))
396 if (pci_mem_find(pa->pa_pc, pa->pa_tag, PCI_CBMA, &membase, &memsize, NULL)
397 || bus_mem_map(pa->pa_bc, membase, memsize, 0, &sc->sc_membase))
401 sc->sc_pdq = pdq_initialize(sc->sc_bc, sc->sc_membase,
402 sc->sc_if.if_xname, 0,
403 (void *) sc, PDQ_DEFPA);
404 if (sc->sc_pdq == NULL) {
405 printf("%s: initialization failed\n", sc->sc_dev.dv_xname);
409 bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
410 pdq_ifattach(sc, pdq_pci_ifwatchdog);
412 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
413 pa->pa_intrline, &intrhandle)) {
414 printf("%s: couldn't map interrupt\n", self->dv_xname);
417 intrstr = pci_intr_string(pa->pa_pc, intrhandle);
418 sc->sc_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET, pdq_pci_ifintr, sc);
419 if (sc->sc_ih == NULL) {
420 printf("%s: couldn't establish interrupt", self->dv_xname);
422 printf(" at %s", intrstr);
427 sc->sc_ats = shutdownhook_establish((void (*)(void *)) pdq_hwreset, sc->sc_pdq);
428 if (sc->sc_ats == NULL)
429 printf("%s: warning: couldn't establish shutdown hook\n", self->dv_xname);
431 printf("%s: interrupting at %s\n", self->dv_xname, intrstr);
434 struct cfattach fpa_ca = {
435 sizeof(pdq_softc_t), pdq_pci_match, pdq_pci_attach
438 struct cfdriver fpa_cd = {
442 #endif /* __NetBSD__ */