The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/pci/if_fpa.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    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
   12  *
   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.
   23  *
   24  * $FreeBSD$
   25  *
   26  */
   27 
   28 /*
   29  * DEC PDQ FDDI Controller; code for BSD derived operating systems
   30  *
   31  *   This module supports the DEC DEFPA PCI FDDI Controller
   32  */
   33 
   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>
   39 #endif
   40 
   41 #include <net/if.h>
   42 
   43 #if defined(__FreeBSD__)
   44 #include "fpa.h"
   45 #include <net/ethernet.h>
   46 #include <net/if_arp.h>
   47 #include <pci/pcivar.h>
   48 #include <dev/pdq/pdqvar.h>
   49 #include <dev/pdq/pdqreg.h>
   50 #elif defined(__bsdi__)
   51 #include <i386/isa/isavar.h>
   52 #include <i386/isa/icu.h>
   53 #ifndef DRQNONE
   54 #define DRQNONE         0
   55 #endif
   56 #if _BSDI_VERSION < 199401
   57 #define IRQSHARE        0
   58 #endif
   59 #elif defined(__NetBSD__)
   60 #include <dev/pci/pcivar.h>
   61 #include <dev/ic/pdqvar.h>
   62 #include <dev/ic/pdqreg.h>
   63 #endif /* __NetBSD__ */
   64 
   65 
   66 #define DEC_VENDORID            0x1011
   67 #define DEFPA_CHIPID            0x000F
   68 #define PCI_VENDORID(x)         ((x) & 0xFFFF)
   69 #define PCI_CHIPID(x)           (((x) >> 16) & 0xFFFF)
   70 
   71 #define DEFPA_LATENCY   0x88
   72 
   73 #define PCI_CFLT        0x0C    /* Configuration Latency */
   74 #define PCI_CBMA        0x10    /* Configuration Base Memory Address */
   75 #define PCI_CBIO        0x14    /* Configuration Base I/O Address */
   76 
   77 #if defined(__FreeBSD__)
   78 #if NFPA < 4
   79 #undef NFPA
   80 #define NFPA    4
   81 #endif
   82 static pdq_softc_t *pdqs_pci[NFPA];
   83 #define PDQ_PCI_UNIT_TO_SOFTC(unit)     (pdqs_pci[unit])
   84 #if BSD >= 199506
   85 #define pdq_pci_ifwatchdog              NULL
   86 #endif
   87 
   88 #elif defined(__bsdi__)
   89 extern struct cfdriver fpacd;
   90 #define PDQ_PCI_UNIT_TO_SOFTC(unit)     ((pdq_softc_t *)fpacd.cd_devs[unit])
   91 
   92 #elif defined(__NetBSD__)
   93 extern struct cfattach fpa_ca;
   94 extern struct cfdriver fpa_cd;
   95 #define PDQ_PCI_UNIT_TO_SOFTC(unit)     ((pdq_softc_t *)fpa_cd.cd_devs[unit])
   96 #define pdq_pci_ifwatchdog              NULL
   97 #endif
   98 
   99 #ifndef pdq_pci_ifwatchdog
  100 static ifnet_ret_t
  101 pdq_pci_ifwatchdog(
  102     int unit)
  103 {
  104     pdq_ifwatchdog(&PDQ_PCI_UNIT_TO_SOFTC(unit)->sc_if);
  105 }
  106 #endif
  107 
  108 #if defined(__FreeBSD__) && BSD >= 199506
  109 static void
  110 pdq_pci_ifintr(
  111     void *arg)
  112 {
  113     (void) pdq_interrupt(((pdq_softc_t *) arg)->sc_pdq);
  114 }
  115 #else
  116 static int
  117 pdq_pci_ifintr(
  118     void *arg)
  119 {
  120     pdq_softc_t * const sc = (pdq_softc_t *) arg;
  121 #ifdef __FreeBSD__
  122     return pdq_interrupt(sc->sc_pdq);
  123 #elif defined(__bsdi__) || defined(__NetBSD__)
  124     (void) pdq_interrupt(sc->sc_pdq);
  125     return 1;
  126 #endif
  127 }
  128 #endif /* __FreeBSD && BSD */
  129 
  130 #if defined(__FreeBSD__)
  131 static void pdq_pci_shutdown(int, void *);
  132 
  133 /*
  134  * This is the PCI configuration support.  Since the PDQ is available
  135  * on both EISA and PCI boards, one must be careful in how defines the
  136  * PDQ in the config file.
  137  */
  138 static const char *
  139 pdq_pci_probe(
  140     pcici_t config_id,
  141     pcidi_t device_id)
  142 {
  143     if (PCI_VENDORID(device_id) == DEC_VENDORID &&
  144             PCI_CHIPID(device_id) == DEFPA_CHIPID)
  145         return "Digital DEFPA PCI FDDI Controller";
  146     return NULL;
  147 }
  148 
  149 static void
  150 pdq_pci_attach(
  151     pcici_t config_id,
  152     int unit)
  153 {
  154     pdq_softc_t *sc;
  155     vm_offset_t va_csrs, pa_csrs;
  156     pdq_uint32_t data;
  157 
  158     if (unit == NFPA) {
  159         printf("fpa%d: not configured; kernel is built for only %d device%s.\n",
  160                unit, NFPA, NFPA == 1 ? "" : "s");
  161         return;
  162     }
  163 
  164     data = pci_conf_read(config_id, PCI_CFLT);
  165     if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
  166         data &= ~0xFF00;
  167         data |= DEFPA_LATENCY << 8;
  168         pci_conf_write(config_id, PCI_CFLT, data);
  169     }
  170 
  171     sc = (pdq_softc_t *) malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT);
  172     if (sc == NULL)
  173         return;
  174 
  175     bzero(sc, sizeof(pdq_softc_t));     /* Zero out the softc*/
  176     if (!pci_map_mem(config_id, PCI_CBMA, &va_csrs, &pa_csrs)) {
  177         free((void *) sc, M_DEVBUF);
  178         return;
  179     }
  180 
  181     sc->sc_if.if_name = "fpa";
  182     sc->sc_if.if_unit = unit;
  183     sc->sc_membase = (pdq_bus_memaddr_t) va_csrs;
  184     sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
  185                                 sc->sc_if.if_name, sc->sc_if.if_unit,
  186                                 (void *) sc, PDQ_DEFPA);
  187     if (sc->sc_pdq == NULL) {
  188         free((void *) sc, M_DEVBUF);
  189         return;
  190     }
  191     bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
  192     pdqs_pci[unit] = sc;
  193     pdq_ifattach(sc, pdq_pci_ifwatchdog);
  194     pci_map_int(config_id, pdq_pci_ifintr, (void*) sc, &net_imask);
  195     at_shutdown(pdq_pci_shutdown, (void *) sc, SHUTDOWN_POST_SYNC);
  196 
  197 }
  198 
  199 static void
  200 pdq_pci_shutdown(
  201     int howto,
  202     void *sc)
  203 {
  204     pdq_hwreset(((pdq_softc_t *)sc)->sc_pdq);
  205 }
  206 
  207 static u_long pdq_pci_count;
  208 
  209 static struct pci_device fpadevice = {
  210     "fpa",
  211     pdq_pci_probe,
  212     pdq_pci_attach,
  213     &pdq_pci_count,
  214     NULL
  215 };
  216 
  217 #ifdef DATA_SET
  218 DATA_SET (pcidevice_set, fpadevice);
  219 #endif
  220 #elif defined(__bsdi__)
  221 
  222 static int
  223 pdq_pci_match(
  224     pci_devaddr_t *pa)
  225 {
  226     int irq;
  227     int id;
  228 
  229     id = pci_inl(pa, PCI_VENDOR_ID);
  230     if (PCI_VENDORID(id) != DEC_VENDORID || PCI_CHIPID(id) != DEFPA_CHIPID)
  231         return 0;
  232 
  233     irq = pci_inl(pa, PCI_I_LINE) & 0xFF;
  234     if (irq == 0 || irq >= 16)
  235         return 0;
  236 
  237     return 1;
  238 }
  239 
  240 int
  241 pdq_pci_probe(
  242     struct device *parent,
  243     struct cfdata *cf,
  244     void *aux)
  245 {
  246     struct isa_attach_args *ia = (struct isa_attach_args *) aux;
  247     pdq_uint32_t irq, data;
  248     pci_devaddr_t *pa;
  249 
  250     pa = pci_scan(pdq_pci_match);
  251     if (pa == NULL)
  252         return 0;
  253 
  254     irq = (1 << (pci_inl(pa, PCI_I_LINE) & 0xFF));
  255 
  256     if (ia->ia_irq != IRQUNK && irq != ia->ia_irq) {
  257         printf("fpa%d: error: desired IRQ of %d does not match device's actual IRQ of %d\n",
  258                cf->cf_unit,
  259                ffs(ia->ia_irq) - 1, ffs(irq) - 1);
  260         return 0;
  261     }
  262     if (ia->ia_irq == IRQUNK) {
  263         (void) isa_irqalloc(irq);
  264         ia->ia_irq = irq;
  265     }
  266 
  267     /* PCI bus masters don't use host DMA channels */
  268     ia->ia_drq = DRQNONE;
  269 
  270     /* Get the memory base address; assume the BIOS set it up correctly */
  271     ia->ia_maddr = (caddr_t) (pci_inl(pa, PCI_CBMA) & ~7);
  272     pci_outl(pa, PCI_CBMA, 0xFFFFFFFF);
  273     ia->ia_msize = ((~pci_inl(pa, PCI_CBMA)) | 7) + 1;
  274     pci_outl(pa, PCI_CBMA, (int) ia->ia_maddr);
  275 
  276     /* Disable I/O space access */
  277     pci_outl(pa, PCI_COMMAND, pci_inl(pa, PCI_COMMAND) & ~1);
  278     ia->ia_iobase = 0;
  279     ia->ia_iosize = 0;
  280 
  281     /* Make sure the latency timer is what the DEFPA likes */
  282     data = pci_inl(pa, PCI_CFLT);
  283     if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
  284         data &= ~0xFF00;
  285         data |= DEFPA_LATENCY << 8;
  286         pci_outl(pa, PCI_CFLT, data);
  287     }
  288     ia->ia_irq |= IRQSHARE;
  289 
  290     return 1;
  291 }
  292 
  293 void
  294 pdq_pci_attach(
  295     struct device *parent,
  296     struct device *self,
  297     void *aux)
  298 {
  299     pdq_softc_t *sc = (pdq_softc_t *) self;
  300     register struct isa_attach_args *ia = (struct isa_attach_args *) aux;
  301     register struct ifnet *ifp = &sc->sc_if;
  302     int i;
  303 
  304     sc->sc_if.if_unit = sc->sc_dev.dv_unit;
  305     sc->sc_if.if_name = "fpa";
  306     sc->sc_if.if_flags = 0;
  307     sc->sc_membase = (pdq_bus_memaddr_t) mapphys((vm_offset_t)ia->ia_maddr, ia->ia_msize);
  308 
  309     sc->sc_pdq = pdq_initialize(PDQ_BUS_PCI, sc->sc_membase,
  310                                 sc->sc_if.if_name, sc->sc_if.if_unit,
  311                                 (void *) sc, PDQ_DEFPA);
  312     if (sc->sc_pdq == NULL) {
  313         printf("fpa%d: initialization failed\n", sc->sc_if.if_unit);
  314         return;
  315     }
  316 
  317     bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
  318 
  319     pdq_ifattach(sc, pdq_pci_ifwatchdog);
  320 
  321     isa_establish(&sc->sc_id, &sc->sc_dev);
  322 
  323     sc->sc_ih.ih_fun = pdq_pci_ifintr;
  324     sc->sc_ih.ih_arg = (void *)sc;
  325     intr_establish(ia->ia_irq, &sc->sc_ih, DV_NET);
  326 
  327     sc->sc_ats.func = (void (*)(void *)) pdq_hwreset;
  328     sc->sc_ats.arg = (void *) sc->sc_pdq;
  329     atshutdown(&sc->sc_ats, ATSH_ADD);
  330 }
  331 
  332 struct cfdriver fpacd = {
  333     0, "fpa", pdq_pci_probe, pdq_pci_attach,
  334 #if _BSDI_VERSION >= 199401
  335     DV_IFNET,
  336 #endif
  337     sizeof(pdq_softc_t)
  338 };
  339 
  340 #elif defined(__NetBSD__)
  341 
  342 static int
  343 pdq_pci_match(
  344     struct device *parent,
  345     void *match,
  346     void *aux)
  347 {
  348     struct pci_attach_args *pa = (struct pci_attach_args *) aux;
  349 
  350     if (PCI_VENDORID(pa->pa_id) != DEC_VENDORID)
  351         return 0;
  352     if (PCI_CHIPID(pa->pa_id) == DEFPA_CHIPID)
  353         return 1;
  354 
  355     return 0;
  356 }
  357 
  358 static void
  359 pdq_pci_attach(
  360     struct device * const parent,
  361     struct device * const self,
  362     void * const aux)
  363 {
  364     pdq_softc_t * const sc = (pdq_softc_t *) self;
  365     struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
  366     pdq_uint32_t data;
  367     pci_intr_handle_t intrhandle;
  368     const char *intrstr;
  369 #ifdef PDQ_IOMAPPED
  370     bus_io_addr_t iobase;
  371     bus_io_size_t iosize;
  372 #else
  373     bus_mem_addr_t membase;
  374     bus_mem_size_t memsize;
  375 #endif
  376 
  377     data = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CFLT);
  378     if ((data & 0xFF00) < (DEFPA_LATENCY << 8)) {
  379         data &= ~0xFF00;
  380         data |= DEFPA_LATENCY << 8;
  381         pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_CFLT, data);
  382     }
  383 
  384     sc->sc_bc = pa->pa_bc;
  385     bcopy(sc->sc_dev.dv_xname, sc->sc_if.if_xname, IFNAMSIZ);
  386     sc->sc_if.if_flags = 0;
  387     sc->sc_if.if_softc = sc;
  388 
  389 #ifdef PDQ_IOMAPPED
  390     if (pci_io_find(pa->pa_pc, pa->pa_tag, PCI_CBIO, &iobase, &iosize)
  391             || bus_io_map(pa->pa_bc, iobase, iosize, &sc->sc_iobase))
  392         return;
  393 #else
  394     if (pci_mem_find(pa->pa_pc, pa->pa_tag, PCI_CBMA, &membase, &memsize, NULL)
  395             || bus_mem_map(pa->pa_bc, membase, memsize, 0, &sc->sc_membase))
  396         return;
  397 #endif
  398 
  399     sc->sc_pdq = pdq_initialize(sc->sc_bc, sc->sc_membase,
  400                                 sc->sc_if.if_xname, 0,
  401                                 (void *) sc, PDQ_DEFPA);
  402     if (sc->sc_pdq == NULL) {
  403         printf("%s: initialization failed\n", sc->sc_dev.dv_xname);
  404         return;
  405     }
  406 
  407     bcopy((caddr_t) sc->sc_pdq->pdq_hwaddr.lanaddr_bytes, sc->sc_ac.ac_enaddr, 6);
  408     pdq_ifattach(sc, pdq_pci_ifwatchdog);
  409 
  410     if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
  411                      pa->pa_intrline, &intrhandle)) {
  412         printf("%s: couldn't map interrupt\n", self->dv_xname);
  413         return;
  414     }
  415     intrstr = pci_intr_string(pa->pa_pc, intrhandle);
  416     sc->sc_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET, pdq_pci_ifintr, sc);
  417     if (sc->sc_ih == NULL) {
  418         printf("%s: couldn't establish interrupt", self->dv_xname);
  419         if (intrstr != NULL)
  420             printf(" at %s", intrstr);
  421         printf("\n");
  422         return;
  423     }
  424 
  425     sc->sc_ats = shutdownhook_establish((void (*)(void *)) pdq_hwreset, sc->sc_pdq);
  426     if (sc->sc_ats == NULL)
  427         printf("%s: warning: couldn't establish shutdown hook\n", self->dv_xname);
  428     if (intrstr != NULL)
  429         printf("%s: interrupting at %s\n", self->dv_xname, intrstr);
  430 }
  431 
  432 struct cfattach fpa_ca = {
  433     sizeof(pdq_softc_t), pdq_pci_match, pdq_pci_attach
  434 };
  435 
  436 struct cfdriver fpa_cd = {
  437     0, "fpa", DV_IFNET
  438 };
  439 
  440 #endif /* __NetBSD__ */

Cache object: 01d46e6baac87ef51c2ff1afd9c6e0c6


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.