root/dev/pci/puc.c

DEFINITIONS

1. puc_pci_match
2. puc_pci_intr_string
3. puc_pci_intr_establish
4. puc_pci_attach
5. puc_common_attach
6. puc_print
7. puc_submatch
8. puc_find_description
9. puc_port_type_name
10. puc_print_ports

    1 /*      $OpenBSD: puc.c,v 1.12 2007/04/26 01:31:05 gwk Exp $    */
    2 /*      $NetBSD: puc.c,v 1.3 1999/02/06 06:29:54 cgd Exp $      */
    4 /*
    5  * Copyright (c) 1996, 1998, 1999
    6  *      Christopher G. Demetriou.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. All advertising materials mentioning features or use of this software
   17  *    must display the following acknowledgement:
   18  *      This product includes software developed by Christopher G. Demetriou
   19  *      for the NetBSD Project.
   20  * 4. The name of the author may not be used to endorse or promote products
   21  *    derived from this software without specific prior written permission
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   33  */
   35 /*
   36  * PCI "universal" communication card device driver, glues com, lpt,
   37  * and similar ports to PCI via bridge chip often much larger than
   38  * the devices being glued.
   39  *
   40  * Author: Christopher G. Demetriou, May 14, 1998 (derived from NetBSD
   41  * sys/dev/pci/pciide.c, revision 1.6).
   42  *
   43  * These devices could be (and some times are) described as
   44  * communications/{serial,parallel}, etc. devices with known
   45  * programming interfaces, but those programming interfaces (in
   46  * particular the BAR assignments for devices, etc.) in fact are not
   47  * particularly well defined.
   48  *
   49  * After I/we have seen more of these devices, it may be possible
   50  * to generalize some of these bits.  In particular, devices which
   51  * describe themselves as communications/serial/16[45]50, and
   52  * communications/parallel/??? might be attached via direct
   53  * 'com' and 'lpt' attachments to pci.
   54  */
   56 #include <sys/param.h>
   57 #include <sys/systm.h>
   58 #include <sys/device.h>
   60 #include <dev/pci/pcireg.h>
   61 #include <dev/pci/pcivar.h>
   62 #include <dev/pci/pucvar.h>
   64 #include <dev/pci/pcidevs.h>
   66 struct puc_pci_softc {
   67         struct puc_softc        sc_psc;
pci_chipset_tag_t       pc;
pci_intr_handle_t       ih;
   71 };
   73 int     puc_pci_match(struct device *, void *, void *);
   74 void    puc_pci_attach(struct device *, struct device *, void *);
   75 const char *puc_pci_intr_string(struct puc_attach_args *);
   76 void    *puc_pci_intr_establish(struct puc_attach_args *, int,
   77     int (*)(void *), void *, char *);
   79 struct cfattach puc_pci_ca = {
   80         sizeof(struct puc_pci_softc), puc_pci_match, puc_pci_attach
   81 };
   83 struct cfdriver puc_cd = {
NULL, "puc", DV_DULL
   85 };
   87 const char *puc_port_type_name(int);
   89 int
puc_pci_match(struct device *parent, void *match, void *aux)
   91 {
   92         struct pci_attach_args *pa = aux;
   93         const struct puc_device_description *desc;
pcireg_t bhlc, subsys;
bhlc = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_BHLC_REG);
   97         if (PCI_HDRTYPE_TYPE(bhlc) != 0)
   98                 return (0);
subsys = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
desc = puc_find_description(PCI_VENDOR(pa->pa_id),
PCI_PRODUCT(pa->pa_id), PCI_VENDOR(subsys), PCI_PRODUCT(subsys));
  104         if (desc != NULL)
  105                 return (10);
  107         /*
  108          * Match class/subclass, so we can tell people to compile kernel
  109          * with options that cause this driver to spew.
  110          */
  111         if (PCI_CLASS(pa->pa_class) == PCI_CLASS_COMMUNICATIONS &&
PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_BRIDGE_PCI)
  113                 return (1);
  115         return (0);
  116 }
  118 const char *
puc_pci_intr_string(struct puc_attach_args *paa)
  120 {
  121         struct puc_pci_softc *sc = paa->puc;
  123         return (pci_intr_string(sc->pc, sc->ih));
  124 }
  126 void *
puc_pci_intr_establish(struct puc_attach_args *paa, int type,
  128     int (*func)(void *), void *arg, char *name)
  129 {
  130         struct puc_pci_softc *sc = paa->puc;
  132         return (pci_intr_establish(sc->pc, sc->ih, type, func, arg, name));
  133 }
  135 void
puc_pci_attach(struct device *parent, struct device *self, void *aux)
  137 {
  138         struct puc_pci_softc *psc = (struct puc_pci_softc *)self;
  139         struct puc_softc *sc = &psc->sc_psc;
  140         struct pci_attach_args *pa = aux;
  141         struct puc_attach_args paa;
pcireg_t subsys;
  143         int i;
subsys = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
sc->sc_desc = puc_find_description(PCI_VENDOR(pa->pa_id),
PCI_PRODUCT(pa->pa_id), PCI_VENDOR(subsys), PCI_PRODUCT(subsys));
  148         if (sc->sc_desc == NULL) {
  149                 /*
  150                  * This was a class/subclass match, so tell people to compile
  151                  * kernel with options that cause this driver to spew.
  152                  */
  153 #ifdef PUC_PRINT_REGS
printf(":\n");
pci_conf_print(pa->pa_pc, pa->pa_tag, NULL);
  156 #else
printf(": unknown PCI communications device\n");
printf("%s: compile kernel with PUC_PRINT_REGS and larger\n",
sc->sc_dev.dv_xname);
printf("%s: message buffer (via 'options MSGBUFSIZE=...'),\n",
sc->sc_dev.dv_xname);
printf("%s: and report the result with sendbug(1)\n",
sc->sc_dev.dv_xname);
  164 #endif
  165                 return;
  166         }
puc_print_ports(sc->sc_desc);
  170         /*
  171          * XXX This driver assumes that 'com' ports attached to it
  172          * XXX can not be console.  That isn't unreasonable, because PCI
  173          * XXX devices are supposed to be dynamically mapped, and com
  174          * XXX console ports want fixed addresses.  When/if baseboard
  175          * XXX 'com' ports are identified as PCI/communications/serial
  176          * XXX devices and are known to be mapped at the standard
  177          * XXX addresses, if they can be the system console then we have
  178          * XXX to cope with doing the mapping right.  Then this will get
  179          * XXX really ugly.  Of course, by then we might know the real
  180          * XXX definition of PCI/communications/serial, and attach 'com'
  181          * XXX directly on PCI.
  182          */
  183         for (i = 0; i < PUC_NBARS; i++) {
pcireg_t type;
  185                 int bar;
sc->sc_bar_mappings[i].mapped = 0;
bar = PCI_MAPREG_START + 4 * i;
  189                 if (!pci_mapreg_probe(pa->pa_pc, pa->pa_tag, bar, &type))
  190                         continue;
sc->sc_bar_mappings[i].mapped = (pci_mapreg_map(pa, bar, type,
  193                     0, &sc->sc_bar_mappings[i].t, &sc->sc_bar_mappings[i].h,
  194                     &sc->sc_bar_mappings[i].a, &sc->sc_bar_mappings[i].s, 0)
  195                       == 0);
sc->sc_bar_mappings[i].type = type;
  197                 if (sc->sc_bar_mappings[i].mapped)
  198                         continue;
printf("%s: couldn't map BAR at offset 0x%lx\n",
sc->sc_dev.dv_xname, (long)bar);
  202         }
  204         /* Map interrupt. */
psc->pc = pa->pa_pc;
  206         if (pci_intr_map(pa, &psc->ih)) {
printf("%s: couldn't map interrupt\n", sc->sc_dev.dv_xname);
  208                 return;
  209         }
paa.puc = sc;
paa.hwtype = 0; /* autodetect */
paa.intr_string = &puc_pci_intr_string;
paa.intr_establish = &puc_pci_intr_establish;
  216         /*
  217          * If this is a serial card with a known specific chip, provide
  218          * the UART type.
  219          */
  220         if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_PLX &&
PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_PLX_CRONYX_OMEGA)
paa.hwtype = 0x08;      /* XXX COM_UART_ST16C654 */
puc_common_attach(sc, &paa);
  225 }
  227 void
puc_common_attach(struct puc_softc *sc, struct puc_attach_args *paa)
  229 {
  230         int i, bar;
  232         /*
  233          * XXX the sub-devices establish the interrupts, for the
  234          * XXX following reasons:
  235          * XXX
  236          * XXX    * we can't really know what IPLs they'd want
  237          * XXX
  238          * XXX    * the MD dispatching code can ("should") dispatch
  239          * XXX      chained interrupts better than we can.
  240          * XXX
  241          * XXX It would be nice if we could indicate to the MD interrupt
  242          * XXX handling code that the interrupt line used by the device
  243          * XXX was a PCI (level triggered) interrupt.
  244          * XXX
  245          * XXX It's not pretty, but hey, what is?
  246          */
  248         /* Configure each port. */
  249         for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) {
  250                 /* Skip unknown ports */
  251                 if (sc->sc_desc->ports[i].type != PUC_PORT_TYPE_COM &&
sc->sc_desc->ports[i].type != PUC_PORT_TYPE_LPT)
  253                         continue;
  254                 /* make sure the base address register is mapped */
bar = PUC_PORT_BAR_INDEX(sc->sc_desc->ports[i].bar);
  256                 if (!sc->sc_bar_mappings[bar].mapped) {
printf("%s: %s port uses unmapped BAR (0x%x)\n",
sc->sc_dev.dv_xname,
puc_port_type_name(sc->sc_desc->ports[i].type),
sc->sc_desc->ports[i].bar);
  261                         continue;
  262                 }
  264                 /* set up to configure the child device */
paa->port = i;
paa->type = sc->sc_desc->ports[i].type;
paa->flags = sc->sc_desc->ports[i].flags;
paa->a = sc->sc_bar_mappings[bar].a;
paa->t = sc->sc_bar_mappings[bar].t;
  271                 if (bus_space_subregion(sc->sc_bar_mappings[bar].t,
sc->sc_bar_mappings[bar].h, sc->sc_desc->ports[i].offset,
sc->sc_bar_mappings[bar].s - sc->sc_desc->ports[i].offset,
  274                     &paa->h)) {
printf("%s: couldn't get subregion for port %d\n",
sc->sc_dev.dv_xname, i);
  277                         continue;
  278                 }
  280 #if 0
  281                 if (autoconf_verbose)
printf("%s: port %d: %s @ (index %d) 0x%x "
  283                             "(0x%lx, 0x%lx)\n", sc->sc_dev.dv_xname, paa->port,
puc_port_type_name(paa->type), bar, (int)paa->a,
  285                             (long)paa->t, (long)paa->h);
  286 #endif
  288                 /* and configure it */
sc->sc_ports[i].dev = config_found_sm(&sc->sc_dev, paa,
puc_print, puc_submatch);
  291         }
  292 }
  294 int
puc_print(void *aux, const char *pnp)
  296 {
  297         struct puc_attach_args *paa = aux;
  299         if (pnp)
printf("%s at %s", puc_port_type_name(paa->type), pnp);
printf(" port %d", paa->port);
  302         return (UNCONF);
  303 }
  305 int
puc_submatch(struct device *parent, void *vcf, void *aux)
  307 {
  308         struct cfdata *cf = (struct cfdata *)vcf;
  309         struct puc_attach_args *aa = aux;
  311         if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != aa->port)
  312                 return 0;
  313         return ((*cf->cf_attach->ca_match)(parent, cf, aux));
  314 }
  316 const struct puc_device_description *
puc_find_description(u_long vend, u_long prod, u_long svend, u_long sprod)
  318 {
  319         int i;
  321 #define checkreg(val, index) \
  322     (((val) & puc_devices[i].rmask[(index)]) == puc_devices[i].rval[(index)])
  323 #define pucdevdone(idx) \
  324     (puc_devices[idx].rval[0] == 0 && puc_devices[idx].rval[1] == 0 \
  325         && puc_devices[idx].rval[2] == 0 && puc_devices[idx].rval[3] == 0)
  327         for (i = 0; !pucdevdone(i); i++) {
  328                 if (checkreg(vend, PUC_REG_VEND) &&
checkreg(prod, PUC_REG_PROD) &&
checkreg(svend, PUC_REG_SVEND) &&
checkreg(sprod, PUC_REG_SPROD))
  332                         return (&puc_devices[i]);
  333         }
  335 #undef devdone
  336 #undef checkreg
  338         return (NULL);
  339 }
  341 const char *
puc_port_type_name(int type)
  343 {
  345         switch (type) {
  346         case PUC_PORT_TYPE_COM:
  347                 return "com";
  348         case PUC_PORT_TYPE_LPT:
  349                 return "lpt";
  350         default:
  351                 return "unknown";
  352         }
  353 }
  355 void
puc_print_ports(const struct puc_device_description *desc)
  357 {
  358         int i, ncom, nlpt;
printf(": ports: ");
  361         for (i = ncom = nlpt = 0; PUC_PORT_VALID(desc, i); i++) {
  362                 switch (desc->ports[i].type) {
  363                 case PUC_PORT_TYPE_COM:
ncom++;
  365                 break;
  366                 case PUC_PORT_TYPE_LPT:
nlpt++;
  368                 break;
  369                 default:
printf("port %d unknown type %d ", i,
desc->ports[i].type);
  372                 }
  373         }
  374         if (ncom)
printf("%d com", ncom);
  376         if (nlpt) {
  377                 if (ncom)
printf(", ");
printf("%d lpt", nlpt);
  380         }
printf("\n");
  382 }