root/dev/isa/isapnp.c

DEFINITIONS

1. isapnp_init
2. isapnp_shift_bit
3. isapnp_findcard
4. isapnp_free_region
5. isapnp_alloc_region
6. isapnp_alloc_irq
7. isapnp_alloc_drq
8. isapnp_testconfig
9. isapnp_config
10. isapnp_unconfig
11. isapnp_bestconfig
12. isapnp_id_to_vendor
13. isapnp_print_region
14. isapnp_print_pin
15. isapnp_print
16. isapnp_com_submatch
17. isapnp_submatch
18. isapnp_find
19. isapnp_configure
20. isapnp_isa_attach_hook
21. isapnp_match
22. isapnp_attach

    1 /*      $OpenBSD: isapnp.c,v 1.35 2003/04/27 11:22:53 ho Exp $  */
    2 /*      $NetBSD: isapnp.c,v 1.9.4.3 1997/10/29 00:40:43 thorpej Exp $   */
    4 /*
    5  * Copyright (c) 1996 Christos Zoulas.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Christos Zoulas.
   18  * 4. The name of the author may not be used to endorse or promote products
   19  *    derived from this software without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   31  */
   33 /*
   34  * ISA PnP bus autoconfiguration.
   35  */
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/device.h>
   40 #include <sys/malloc.h>
   42 #include <machine/bus.h>
   44 #include <dev/isa/isapnpreg.h>
   46 #include <dev/isa/isavar.h>
   47 #include <dev/isa/isadmavar.h>
   49 #include <dev/isa/pnpdevs.h>
   51 #include "isadma.h"
   53 void isapnp_init(struct isapnp_softc *);
   54 static __inline u_char isapnp_shift_bit(struct isapnp_softc *);
   55 int isapnp_findcard(struct isapnp_softc *);
   56 void isapnp_free_region(bus_space_tag_t, struct isapnp_region *);
   57 int isapnp_alloc_region(bus_space_tag_t, struct isapnp_region *);
   58 int isapnp_alloc_irq(isa_chipset_tag_t, struct isapnp_pin *);
   59 int isapnp_alloc_drq(struct device *, struct isapnp_pin *);
   60 int isapnp_testconfig(bus_space_tag_t, bus_space_tag_t,
   61     struct isa_attach_args *, int);
   62 struct isa_attach_args *isapnp_bestconfig(struct device *,
   63     struct isapnp_softc *, struct isa_attach_args **);
   64 void isapnp_print_region(const char *, struct isapnp_region *,
size_t);
   66 void isapnp_configure(struct isapnp_softc *,
   67     const struct isa_attach_args *);
   68 void isapnp_print_pin(const char *, struct isapnp_pin *, size_t);
   69 int isapnp_print(void *, const char *);
   70 int isapnp_submatch(struct device *, void *, void *);
   71 int isapnp_com_submatch(struct device *, void *, void *);
   72 int isapnp_find(struct isapnp_softc *, int);
   73 int isapnp_match(struct device *, void *, void *);
   74 void isapnp_attach(struct device *, struct device *, void *);
   76 #ifdef DEBUG_ISAPNP
   77 # define DPRINTF(a) printf a
   78 #else
   79 # define DPRINTF(a)
   80 #endif
   82 struct cfattach isapnp_ca = {
   83         sizeof(struct isapnp_softc), isapnp_match, isapnp_attach
   84 };
   86 struct cfdriver isapnp_cd = {
NULL, "isapnp", DV_DULL
   88 };
   91 /* isapnp_init():
   92  *      Write the PNP initiation key to wake up the cards...
   93  */
   94 void
isapnp_init(sc)
   96         struct isapnp_softc *sc;
   97 {
   98         int i;
u_char v = ISAPNP_LFSR_INIT;
  101         /* First write 0's twice to enter the Wait for Key state */
ISAPNP_WRITE_ADDR(sc, 0);
ISAPNP_WRITE_ADDR(sc, 0);
  105         /* Send the 32 byte sequence to awake the logic */
  106         for (i = 0; i < ISAPNP_LFSR_LENGTH; i++) {
ISAPNP_WRITE_ADDR(sc, v);
v = ISAPNP_LFSR_NEXT(v);
  109         }
  110 }
  113 /* isapnp_shift_bit():
  114  *      Read a bit at a time from the config card.
  115  */
  116 static __inline u_char
isapnp_shift_bit(sc)
  118         struct isapnp_softc *sc;
  119 {
u_char c1, c2;
DELAY(250);
c1 = ISAPNP_READ_DATA(sc);
DELAY(250);
c2 = ISAPNP_READ_DATA(sc);
  127         if (c1 == 0x55 && c2 == 0xAA)
  128                 return 0x80;
  129         else
  130                 return 0;
  131 }
  134 /* isapnp_findcard():
  135  *      Attempt to read the vendor/serial/checksum for a card
  136  *      If a card is found [the checksum matches], assign the
  137  *      next card number to it and return 1
  138  */
  139 int
isapnp_findcard(sc)
  141         struct isapnp_softc *sc;
  142 {
u_char v = ISAPNP_LFSR_INIT, csum, w;
  144         int i, b;
  146         if (sc->sc_ncards == ISAPNP_MAX_CARDS) {
printf("%s: Too many pnp cards\n", sc->sc_dev.dv_xname);
  148                 return 0;
  149         }
  151         /* Set the read port */
isapnp_write_reg(sc, ISAPNP_WAKE, 0);
isapnp_write_reg(sc, ISAPNP_SET_RD_PORT, sc->sc_read_port >> 2);
sc->sc_read_port |= 3;
DELAY(1000);
ISAPNP_WRITE_ADDR(sc, ISAPNP_SERIAL_ISOLATION);
DELAY(1000);
  160         /* Read the 8 bytes of the Vendor ID and Serial Number */
  161         for(i = 0; i < 8; i++) {
  162                 /* Read each bit separately */
  163                 for (w = 0, b = 0; b < 8; b++) {
u_char neg = isapnp_shift_bit(sc);
w >>= 1;
w |= neg;
v = ISAPNP_LFSR_NEXT(v) ^ neg;
  169                 }
sc->sc_id[sc->sc_ncards][i] = w;
  171         }
  173         /* Read the remaining checksum byte */
  174         for (csum = 0, b = 0; b < 8; b++) {
u_char neg = isapnp_shift_bit(sc);
csum >>= 1;
csum |= neg;
  179         }
sc->sc_id[sc->sc_ncards][8] = csum;
  182         if (csum == v) {
sc->sc_ncards++;
isapnp_write_reg(sc, ISAPNP_CARD_SELECT_NUM, sc->sc_ncards);
  185                 return 1;
  186         }
  187         return 0;
  188 }
  191 /* isapnp_free_region():
  192  *      Free a region
  193  */
  194 void
isapnp_free_region(t, r)
bus_space_tag_t t;
  197         struct isapnp_region *r;
  198 {
  199         if (r->length == 0)
  200                 return;
bus_space_unmap(t, r->h, r->length);
r->h = NULL;
  204 }
  207 /* isapnp_alloc_region():
  208  *      Allocate a single region if possible
  209  */
  210 int
isapnp_alloc_region(t, r)
bus_space_tag_t t;
  213         struct isapnp_region *r;
  214 {
  215         int error = 0;
  217         if (r->length == 0)
  218                 return 0;
r->h = NULL;
  221         for (r->base = r->minbase; r->base <= r->maxbase;
r->base += r->align) {
error = bus_space_map(t, r->base, r->length, 0, &r->h);
  224                 if (error == 0)
  225                         return 0;
  226         }
  227         return error;
  228 }
  231 /* isapnp_alloc_irq():
  232  *      Allocate an irq
  233  */
  234 int
isapnp_alloc_irq(ic, i)
isa_chipset_tag_t ic;
  237         struct isapnp_pin *i;
  238 {
  239         int irq;
  240 #define LEVEL_IRQ (ISAPNP_IRQTYPE_LEVEL_PLUS|ISAPNP_IRQTYPE_LEVEL_MINUS)
i->type = (i->flags & LEVEL_IRQ) ? IST_LEVEL : IST_EDGE;
  243         if (i->bits == 0) {
i->num = 0;
  245                 return 0;
  246         }
  248         if (isa_intr_alloc(ic, i->bits, i->type, &irq) == 0) {
i->num = irq;
  250                 return 0;
  251         }
  253         return EINVAL;
  254 }
  256 /* isapnp_alloc_drq():
  257  *      Allocate a drq
  258  */
  259 int
isapnp_alloc_drq(isa, i)
  261         struct device *isa;
  262         struct isapnp_pin *i;
  263 {
  264 #if NISADMA > 0
  265         int b;
  267         if (i->bits == 0) {
i->num = 0;
  269                 return 0;
  270         }
  272         for (b = 0; b < 16; b++)
  273                 if ((i->bits & (1 << b)) && isa_drq_isfree(isa, b)) {
i->num = b;
  275                         return 0;
  276                 }
  277 #endif
  279         return EINVAL;
  280 }
  282 /* isapnp_testconfig():
  283  *      Test/Allocate the regions used
  284  */
  285 int
isapnp_testconfig(iot, memt, ipa, alloc)
bus_space_tag_t iot, memt;
  288         struct isa_attach_args *ipa;
  289         int alloc;
  290 {
  291         int nio = 0, nmem = 0, nmem32 = 0, nirq = 0, ndrq = 0;
  292         int error = 0;
  294 #ifdef DEBUG_ISAPNP
isapnp_print_attach(ipa);
  296 #endif
  298         for (; nio < ipa->ipa_nio; nio++) {
error = isapnp_alloc_region(iot, &ipa->ipa_io[nio]);
  300                 if (error)
  301                         goto bad;
  302         }
  304         for (; nmem < ipa->ipa_nmem; nmem++) {
error = isapnp_alloc_region(memt, &ipa->ipa_mem[nmem]);
  306                 if (error)
  307                         goto bad;
  308         }
  310         for (; nmem32 < ipa->ipa_nmem32; nmem32++) {
error = isapnp_alloc_region(memt, &ipa->ipa_mem32[nmem32]);
  312                 if (error)
  313                         goto bad;
  314         }
  316         for (; nirq < ipa->ipa_nirq; nirq++) {
error = isapnp_alloc_irq(ipa->ia_ic, &ipa->ipa_irq[nirq]);
  318                 if (error)
  319                         goto bad;
  320         }
  322         for (; ndrq < ipa->ipa_ndrq; ndrq++) {
error = isapnp_alloc_drq(ipa->ia_isa, &ipa->ipa_drq[ndrq]);
  324                 if (error)
  325                         goto bad;
  326         }
  328         if (alloc)
  329                 return error;
bad:
  332 #ifdef notyet
  333         for (ndrq--; ndrq >= 0; ndrq--)
isapnp_free_pin(&ipa->ipa_drq[ndrq]);
  336         for (nirq--; nirq >= 0; nirq--)
isapnp_free_pin(&ipa->ipa_irq[nirq]);
  338 #endif
  340         for (nmem32--; nmem32 >= 0; nmem32--)
isapnp_free_region(memt, &ipa->ipa_mem32[nmem32]);
  343         for (nmem--; nmem >= 0; nmem--)
isapnp_free_region(memt, &ipa->ipa_mem[nmem]);
  346         for (nio--; nio >= 0; nio--)
isapnp_free_region(iot, &ipa->ipa_io[nio]);
  349         return error;
  350 }
  353 /* isapnp_config():
  354  *      Test/Allocate the regions used
  355  */
  356 int
isapnp_config(iot, memt, ipa)
bus_space_tag_t iot, memt;
  359         struct isa_attach_args *ipa;
  360 {
  361         return isapnp_testconfig(iot, memt, ipa, 1);
  362 }
  365 /* isapnp_unconfig():
  366  *      Free the regions used
  367  */
  368 void
isapnp_unconfig(iot, memt, ipa)
bus_space_tag_t iot, memt;
  371         struct isa_attach_args *ipa;
  372 {
  373         int i;
  375 #ifdef notyet
  376         for (i = 0; i < ipa->ipa_ndrq; i++)
isapnp_free_pin(&ipa->ipa_drq[i]);
  379         for (i = 0; i < ipa->ipa_nirq; i++)
isapnp_free_pin(&ipa->ipa_irq[i]);
  381 #endif
  383         for (i = 0; i < ipa->ipa_nmem32; i++)
isapnp_free_region(memt, &ipa->ipa_mem32[i]);
  386         for (i = 0; i < ipa->ipa_nmem; i++)
isapnp_free_region(memt, &ipa->ipa_mem[i]);
  389         for (i = 0; i < ipa->ipa_nio; i++)
isapnp_free_region(iot, &ipa->ipa_io[i]);
  391 }
  394 /* isapnp_bestconfig():
  395  *      Return the best configuration for each logical device, remove and
  396  *      free all other configurations.
  397  */
  398 struct isa_attach_args *
isapnp_bestconfig(isa, sc, ipa)
  400         struct device *isa;
  401         struct isapnp_softc *sc;
  402         struct isa_attach_args **ipa;
  403 {
  404         struct isa_attach_args *c, *best, *f = *ipa;
  405         int error;
  407         for (;;) {
  408                 if (f == NULL)
  409                         return NULL;
  411 #define SAMEDEV(a, b) (strcmp((a)->ipa_devlogic, (b)->ipa_devlogic) == 0)
  413                 /* Find the best config */
  414                 for (best = c = f; c != NULL; c = c->ipa_sibling) {
  415                         if (!SAMEDEV(c, f))
  416                                 continue;
  417                         if (c->ipa_pref < best->ipa_pref)
best = c;
  419                 }
best->ia_isa = isa;
  422                 /* Test the best config */
error = isapnp_testconfig(sc->sc_iot, sc->sc_memt, best, 0);
  425                 /* Remove this config from the list */
  426                 if (best == f)
f = f->ipa_sibling;
  428                 else {
  429                         for (c = f; c->ipa_sibling != best; c = c->ipa_sibling)
  430                                 continue;
c->ipa_sibling = best->ipa_sibling;
  432                 }
  434                 if (error) {
best->ipa_pref = ISAPNP_DEP_CONFLICTING;
  437                         for (c = f; c != NULL; c = c->ipa_sibling)
  438                                 if (c != best && SAMEDEV(c, best))
  439                                         break;
  440                         /* Last config for this logical device is conflicting */
  441                         if (c == NULL) {
  442                                 *ipa = f;
  443                                 return best;
  444                         }
ISAPNP_FREE(best);
  447                         continue;
  448                 }
  449                 else {
  450                         /* Remove all other configs for this device */
  451                         struct isa_attach_args *l = NULL, *n = NULL, *d;
  453                         for (c = f; c; ) {
  454                                 if (c == best)
  455                                         continue;
d = c->ipa_sibling;
  457                                 if (SAMEDEV(c, best))
ISAPNP_FREE(c);
  459                                 else {
  460                                         if (n)
n->ipa_sibling = c;
  463                                         else
l = c;
n = c;
c->ipa_sibling = NULL;
  467                                 }
c = d;
  469                         }
f = l;
  471                 }
  472                 *ipa = f;
  473                 return best;
  474         }
  475 }
  478 /* isapnp_id_to_vendor():
  479  *      Convert a pnp ``compressed ascii'' vendor id to a string
  480  */
  481 char *
isapnp_id_to_vendor(v, id)
  483         char   *v;
  484         const u_char *id;
  485 {
  486         static const char hex[] = "0123456789ABCDEF";
  487         char *p = v;
  489         *p++ = 'A' + (id[0] >> 2) - 1;
  490         *p++ = 'A' + ((id[0] & 3) << 3) + (id[1] >> 5) - 1;
  491         *p++ = 'A' + (id[1] & 0x1f) - 1;
  492         *p++ = hex[id[2] >> 4];
  493         *p++ = hex[id[2] & 0x0f];
  494         *p++ = hex[id[3] >> 4];
  495         *p++ = hex[id[3] & 0x0f];
  496         *p = '\0';
  498         return v;
  499 }
  502 /* isapnp_print_region():
  503  *      Print a region allocation
  504  */
  505 void
isapnp_print_region(str, r, n)
  507         const char *str;
  508         struct isapnp_region *r;
size_t n;
  510 {
size_t i;
  513         if (n == 0)
  514                 return;
printf(" %s ", str);
  517         for (i = 0; i < n; i++, r++) {
printf("0x%x", r->base);
  519                 if (r->length)
printf("/%d", r->length);
  521                 if (i != n - 1)
printf(",");
  523         }
  524 }
  527 /* isapnp_print_pin():
  528  *      Print an irq/drq assignment
  529  */
  530 void
isapnp_print_pin(str, p, n)
  532         const char *str;
  533         struct isapnp_pin *p;
size_t n;
  535 {
size_t i;
  538         if (n == 0)
  539                 return;
printf(" %s ", str);
  542         for (i = 0; i < n; i++, p++) {
printf("%d", p->num);
  544                 if (i != n - 1)
printf(",");
  546         }
  547 }
  549 /* isapnp_print():
  550  *      Print the configuration line for an ISA PnP card.
  551  */
  552 int
isapnp_print(aux, str)
  554         void *aux;
  555         const char *str;
  556 {
  557         struct isa_attach_args *ipa = aux;
  559         if (!str)
printf(" ");
printf("\"%s, %s, %s, %s\"", ipa->ipa_devident,
ipa->ipa_devlogic, ipa->ipa_devcompat, ipa->ipa_devclass);
  564         if (str)
printf(" at %s", str);
isapnp_print_region("port", ipa->ipa_io, ipa->ipa_nio);
isapnp_print_region("mem", ipa->ipa_mem, ipa->ipa_nmem);
isapnp_print_region("mem32", ipa->ipa_mem32, ipa->ipa_nmem32);
isapnp_print_pin("irq", ipa->ipa_irq, ipa->ipa_nirq);
isapnp_print_pin("drq", ipa->ipa_drq, ipa->ipa_ndrq);
  572         return UNCONF;
  573 }
  576 /* isapnp_submatch():
  577  * Special case.
  578  * A lot of com/pccom devices do not have the PNPxxx identifiers
  579  * they should have.  If it looks like a modem..... let's try it.
  580  */
  581 int
isapnp_com_submatch(parent, match, aux)
  583         struct device *parent;
  584         void *match, *aux;
  585 {
  586         struct cfdata *cf = match;
  587         struct isa_attach_args *ipa = aux;
  589         if ((strcmp("com", cf->cf_driver->cd_name) == 0 ||
strcmp("pccom", cf->cf_driver->cd_name) == 0) &&
ipa->ipa_nio == 1 && ipa->ipa_nirq == 1 &&
ipa->ipa_ndrq == 0 && ipa->ipa_nmem == 0 &&
ipa->ipa_io[0].length == 8) {
  594                 if (isapnp_config(ipa->ia_iot, ipa->ia_memt, ipa)) {
printf("%s: error in region allocation\n",
cf->cf_driver->cd_name);
  597                         return (0);
  598                 }
  599                 return ((*cf->cf_attach->ca_match)(parent, match, ipa));
  600         }
  601         return (0);
  602 }
  604 /* isapnp_submatch():
  605  *      Probe the logical device...
  606  */
  607 int
isapnp_submatch(parent, match, aux)
  609         struct device *parent;
  610         void *match, *aux;
  611 {
  612         struct cfdata *cf = match;
  613         struct isa_attach_args *ipa = aux;
  614         const char *dname;
  615         int i;
  617         for (i = 0; i < sizeof(isapnp_knowndevs)/sizeof(isapnp_knowndevs[0]); i++) {
dname = NULL;
  620                 if (strcmp(isapnp_knowndevs[i].pnpid, ipa->ipa_devlogic) == 0)
dname = isapnp_knowndevs[i].driver;
  622                 else if (strcmp(isapnp_knowndevs[i].pnpid, ipa->ipa_devcompat) == 0)
dname = isapnp_knowndevs[i].driver;
  625                 if (dname && strcmp(dname, cf->cf_driver->cd_name) == 0) {
  626                         /*
  627                          * We found a match.  Configure the card and call the
  628                          * ISA probe...
  629                          */
  630                         if (isapnp_config(ipa->ia_iot, ipa->ia_memt, ipa)) {
printf("%s: error in region allocation\n",
cf->cf_driver->cd_name);
  633                                 return (0);
  634                         }
  636                         return ((*cf->cf_attach->ca_match)(parent, match, ipa));
  637                 }
  638         }
  640         return (0);
  641 }
  643 /* isapnp_find():
  644  *      Probe and add cards
  645  */
  646 int
isapnp_find(sc, all)
  648         struct isapnp_softc *sc;
  649         int all;
  650 {
  651         int p;
isapnp_init(sc);
isapnp_write_reg(sc, ISAPNP_CONFIG_CONTROL, ISAPNP_CC_RESET_DRV);
DELAY(2000);
isapnp_init(sc);
DELAY(2000);
  661         for (p = ISAPNP_RDDATA_MIN; p <= ISAPNP_RDDATA_MAX; p += 4) {
sc->sc_read_port = p;
  663                 if (isapnp_map_readport(sc))
  664                         continue;
DPRINTF(("%s: Trying port %x\n", sc->sc_dev.dv_xname, p));
  666                 if (isapnp_findcard(sc))
  667                         break;
isapnp_unmap_readport(sc);
  669         }
  671         if (p > ISAPNP_RDDATA_MAX) {
sc->sc_read_port = 0;
  673                 return 0;
  674         }
  676         if (all)
  677                 while (isapnp_findcard(sc))
  678                         continue;
  680         return 1;
  681 }
  684 /* isapnp_configure():
  685  *      Configure a PnP card
  686  *      XXX: The memory configuration code is wrong. We need to check the
  687  *           range/length bit an do appropriate sets.
  688  */
  689 void
isapnp_configure(sc, ipa)
  691         struct isapnp_softc *sc;
  692         const struct isa_attach_args *ipa;
  693 {
  694         int i;
  695         static u_char isapnp_mem_range[] = ISAPNP_MEM_DESC;
  696         static u_char isapnp_io_range[] = ISAPNP_IO_DESC;
  697         static u_char isapnp_irq_range[] = ISAPNP_IRQ_DESC;
  698         static u_char isapnp_drq_range[] = ISAPNP_DRQ_DESC;
  699         static u_char isapnp_mem32_range[] = ISAPNP_MEM32_DESC;
  700         const struct isapnp_region *r;
  701         const struct isapnp_pin *p;
  702         struct isapnp_region rz;
  703         struct isapnp_pin pz;
bzero(&pz, sizeof(pz));
bzero(&rz, sizeof(rz));
  708 #define B0(a) ((a) & 0xff)
  709 #define B1(a) (((a) >> 8) & 0xff)
  710 #define B2(a) (((a) >> 16) & 0xff)
  711 #define B3(a) (((a) >> 24) & 0xff)
  713         for (i = 0; i < sizeof(isapnp_io_range); i++) {
  714                 if (i < ipa->ipa_nio)
r = &ipa->ipa_io[i];
  716                 else
r = &rz;
isapnp_write_reg(sc,
isapnp_io_range[i] + ISAPNP_IO_BASE_15_8, B1(r->base));
isapnp_write_reg(sc,
isapnp_io_range[i] + ISAPNP_IO_BASE_7_0, B0(r->base));
  723         }
  725         for (i = 0; i < sizeof(isapnp_mem_range); i++) {
  726                 if (i < ipa->ipa_nmem)
r = &ipa->ipa_mem[i];
  728                 else
r = &rz;
isapnp_write_reg(sc,
isapnp_mem_range[i] + ISAPNP_MEM_BASE_23_16, B2(r->base));
isapnp_write_reg(sc,
isapnp_mem_range[i] + ISAPNP_MEM_BASE_15_8, B1(r->base));
isapnp_write_reg(sc,
isapnp_mem_range[i] + ISAPNP_MEM_LRANGE_23_16,
B2(r->length));
isapnp_write_reg(sc,
isapnp_mem_range[i] + ISAPNP_MEM_LRANGE_15_8,
B1(r->length));
  742         }
  744         for (i = 0; i < sizeof(isapnp_irq_range); i++) {
u_char v;
  747                 if (i < ipa->ipa_nirq)
p = &ipa->ipa_irq[i];
  749                 else
p = &pz;
isapnp_write_reg(sc,
isapnp_irq_range[i] + ISAPNP_IRQ_NUMBER, p->num);
  755                 switch (p->flags) {
  756                 case ISAPNP_IRQTYPE_LEVEL_PLUS:
v = ISAPNP_IRQ_LEVEL|ISAPNP_IRQ_HIGH;
  758                         break;
  760                 case ISAPNP_IRQTYPE_EDGE_PLUS:
v = ISAPNP_IRQ_HIGH;
  762                         break;
  764                 case ISAPNP_IRQTYPE_LEVEL_MINUS:
v = ISAPNP_IRQ_LEVEL;
  766                         break;
  768                 default:
  769                 case ISAPNP_IRQTYPE_EDGE_MINUS:
v = 0;
  771                         break;
  772                 }
isapnp_write_reg(sc,
isapnp_irq_range[i] + ISAPNP_IRQ_CONTROL, v);
  775         }
  777         for (i = 0; i < sizeof(isapnp_drq_range); i++) {
u_char v;
  780                 if (i < ipa->ipa_ndrq)
v = ipa->ipa_drq[i].num;
  782                 else
v = 4;
isapnp_write_reg(sc, isapnp_drq_range[i], v);
  786         }
  788         for (i = 0; i < sizeof(isapnp_mem32_range); i++) {
  789                 if (i < ipa->ipa_nmem32)
r = &ipa->ipa_mem32[i];
  791                 else
r = &rz;
isapnp_write_reg(sc,
isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_31_24,
B3(r->base));
isapnp_write_reg(sc,
isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_23_16,
B2(r->base));
isapnp_write_reg(sc,
isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_15_8,
B1(r->base));
isapnp_write_reg(sc,
isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_7_0,
B0(r->base));
isapnp_write_reg(sc,
isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_31_24,
B3(r->length));
isapnp_write_reg(sc,
isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_23_16,
B2(r->length));
isapnp_write_reg(sc,
isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_15_8,
B1(r->length));
isapnp_write_reg(sc,
isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_7_0,
B0(r->length));
  819         }
  820 }
  823 /*
  824  * Some BIOSes take the liberty of configuring our ISA cards for us.
  825  * This code undoes the PNP card configuration.
  826  */
  828 void
isapnp_isa_attach_hook(isa_sc)
  830         struct isa_softc *isa_sc;
  832 {
  833         struct isapnp_softc sc;
bzero(&sc, sizeof sc);
sc.sc_iot = isa_sc->sc_iot;
sc.sc_ncards = 0;
  839         if (isapnp_map(&sc))
  840                 return;
isapnp_init(&sc);
isapnp_write_reg(&sc, ISAPNP_CONFIG_CONTROL, ISAPNP_CC_RESET_DRV);
DELAY(2000);
isapnp_unmap(&sc);
  848 }
  850 /* isapnp_match():
  851  *      Probe routine
  852  */
  853 int
isapnp_match(parent, match, aux)
  855         struct device *parent;
  856         void *match;
  857         void *aux;
  858 {
  859         int rv;
  860         struct isapnp_softc sc;
  861         struct isa_attach_args *ia = aux;
sc.sc_iot = ia->ia_iot;
sc.sc_ncards = 0;
  865         (void) strlcpy(sc.sc_dev.dv_xname, "(isapnp probe)",
  866              sizeof sc.sc_dev.dv_xname);
  868         if (isapnp_map(&sc))
  869                 return 0;
rv = isapnp_find(&sc, 0);
ia->ia_iobase = ISAPNP_ADDR;
ia->ia_iosize = 1;
isapnp_unmap(&sc);
  876         if (rv)
isapnp_unmap_readport(&sc);
  879         return (rv);
  880 }
  883 /* isapnp_attach
  884  *      Find and attach PnP cards.
  885  */
  886 void
isapnp_attach(parent, self, aux)
  888         struct device *parent, *self;
  889         void *aux;
  890 {
  891         struct isapnp_softc *sc = (struct isapnp_softc *) self;
  892         struct isa_attach_args *ia = aux;
  893         void *match;
  894         int c, d;
sc->sc_iot = ia->ia_iot;
sc->sc_memt = ia->ia_memt;
  898 #if NISADMA > 0
sc->sc_dmat = ia->ia_dmat;
  900 #endif
sc->sc_ncards = 0;
  903         if (isapnp_map(sc))
panic("%s: bus map failed", sc->sc_dev.dv_xname);
  906         if (!isapnp_find(sc, 1)) {
printf(": no cards found\n");
  908                 return;
  909         }
printf(": read port 0x%x\n", sc->sc_read_port);
  913         for (c = 0; c < sc->sc_ncards; c++) {
  914                 struct isa_attach_args *ipa, *lpa;
  916                 /* Good morning card c */
isapnp_write_reg(sc, ISAPNP_WAKE, c + 1);
  919                 if ((ipa = isapnp_get_resource(sc, c, ia)) == NULL)
  920                         continue;
DPRINTF(("Selecting attachments\n"));
  923                 for (d = 0;
  924                     (lpa = isapnp_bestconfig(parent, sc, &ipa)) != NULL; d++) {
isapnp_write_reg(sc, ISAPNP_LOGICAL_DEV_NUM, d);
isapnp_configure(sc, lpa);
  927 #ifdef DEBUG_ISAPNP
  928                         {
  929                                 struct isa_attach_args pa;
isapnp_get_config(sc, &pa);
isapnp_print_config(&pa);
  933                         }
  934 #endif
DPRINTF(("%s: configuring <%s, %s, %s, %s>\n",
sc->sc_dev.dv_xname,
lpa->ipa_devident, lpa->ipa_devlogic,
lpa->ipa_devcompat, lpa->ipa_devclass));
  940                         if (lpa->ipa_pref == ISAPNP_DEP_CONFLICTING) {
isapnp_print(lpa, self->dv_xname);
printf(" resource conflict\n");
ISAPNP_FREE(lpa);
  944                                 continue;
  945                         }
lpa->ia_ic = ia->ia_ic;
lpa->ia_iot = ia->ia_iot;
lpa->ia_memt = ia->ia_memt;
  950 #if NISADMA > 0
lpa->ia_dmat = ia->ia_dmat;
  952 #endif
lpa->ia_delaybah = ia->ia_delaybah;
isapnp_write_reg(sc, ISAPNP_ACTIVATE, 1);
  957                         if ((match = config_search(isapnp_submatch,
self, lpa)))
config_attach(self, match, lpa, isapnp_print);
  960                         else if ((match = config_search(isapnp_com_submatch,
self, lpa)))
config_attach(self, match, lpa, isapnp_print);
  963                         else {
isapnp_print(lpa, self->dv_xname);
printf(" not configured\n");
isapnp_write_reg(sc, ISAPNP_ACTIVATE, 0);
  967                         }
ISAPNP_FREE(lpa);
  969                 }
isapnp_write_reg(sc, ISAPNP_WAKE, 0);    /* Good night cards */
  971         }
  972 }