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/dev/isapnp/isapnp.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 /*      $NetBSD: isapnp.c,v 1.42 2003/12/04 13:57:30 keihan Exp $       */
    2 
    3 /*-
    4  * Copyright (c) 1996 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Christos Zoulas.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 3. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *        This product includes software developed by the NetBSD
   21  *        Foundation, Inc. and its contributors.
   22  * 4. Neither the name of The NetBSD Foundation nor the names of its
   23  *    contributors may be used to endorse or promote products derived
   24  *    from this software without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   36  * POSSIBILITY OF SUCH DAMAGE.
   37  */
   38 
   39 /*
   40  * ISA PnP bus autoconfiguration.
   41  */
   42 
   43 #include <sys/cdefs.h>
   44 __KERNEL_RCSID(0, "$NetBSD: isapnp.c,v 1.42 2003/12/04 13:57:30 keihan Exp $");
   45 
   46 #include "isadma.h"
   47 
   48 #include <sys/param.h>
   49 #include <sys/systm.h>
   50 #include <sys/device.h>
   51 #include <sys/malloc.h>
   52 
   53 #include <machine/bus.h>
   54 
   55 #include <dev/isa/isavar.h>
   56 
   57 #include <dev/isapnp/isapnpreg.h>
   58 #include <dev/isapnp/isapnpvar.h>
   59 #include <dev/isapnp/isapnpdevs.h>
   60 
   61 #include "wss_isapnp.h"         /* XXX part of disgusting CS chip hack */
   62 
   63 #ifndef ISAPNP_ALLOC_INTR_MASK
   64 #define ISAPNP_ALLOC_INTR_MASK (~0)
   65 #endif
   66 
   67 static void isapnp_init __P((struct isapnp_softc *));
   68 static __inline u_char isapnp_shift_bit __P((struct isapnp_softc *));
   69 static int isapnp_findcard __P((struct isapnp_softc *));
   70 static void isapnp_free_region __P((bus_space_tag_t, struct isapnp_region *));
   71 static int isapnp_alloc_region __P((bus_space_tag_t, struct isapnp_region *));
   72 static int isapnp_alloc_irq __P((isa_chipset_tag_t, struct isapnp_pin *));
   73 static int isapnp_alloc_drq __P((isa_chipset_tag_t, struct isapnp_pin *));
   74 static int isapnp_testconfig __P((bus_space_tag_t, bus_space_tag_t,
   75     struct isapnp_attach_args *, int));
   76 static struct isapnp_attach_args *isapnp_bestconfig __P((struct isapnp_softc *,
   77     struct isapnp_attach_args **));
   78 static void isapnp_print_region __P((const char *, struct isapnp_region *,
   79     size_t));
   80 static void isapnp_configure __P((struct isapnp_softc *,
   81     const struct isapnp_attach_args *));
   82 static void isapnp_print_pin __P((const char *, struct isapnp_pin *, size_t));
   83 static int isapnp_print __P((void *, const char *));
   84 #ifdef _KERNEL
   85 static int isapnp_submatch __P((struct device *, struct cfdata *, void *));
   86 #endif
   87 static int isapnp_find __P((struct isapnp_softc *, int));
   88 static int isapnp_match __P((struct device *, struct cfdata *, void *));
   89 static void isapnp_attach __P((struct device *, struct device *, void *));
   90 static void isapnp_callback __P((struct device *));
   91 
   92 CFATTACH_DECL(isapnp, sizeof(struct isapnp_softc),
   93     isapnp_match, isapnp_attach, NULL, NULL);
   94 
   95 /*
   96  * This keeps track if which ISA's we have been probed on.
   97  */
   98 struct isapnp_probe_cookie {
   99         LIST_ENTRY(isapnp_probe_cookie) ipc_link;
  100         struct device *ipc_parent;
  101 };
  102 LIST_HEAD(, isapnp_probe_cookie) isapnp_probes =
  103     LIST_HEAD_INITIALIZER(isapnp_probes);
  104 
  105 /* isapnp_init():
  106  *      Write the PNP initiation key to wake up the cards...
  107  */
  108 static void
  109 isapnp_init(sc)
  110         struct isapnp_softc *sc;
  111 {
  112         int i;
  113         u_char v = ISAPNP_LFSR_INIT;
  114 
  115         /* First write 0's twice to enter the Wait for Key state */
  116         ISAPNP_WRITE_ADDR(sc, 0);
  117         ISAPNP_WRITE_ADDR(sc, 0);
  118 
  119         /* Send the 32 byte sequence to awake the logic */
  120         for (i = 0; i < ISAPNP_LFSR_LENGTH; i++) {
  121                 ISAPNP_WRITE_ADDR(sc, v);
  122                 v = ISAPNP_LFSR_NEXT(v);
  123         }
  124 }
  125 
  126 
  127 /* isapnp_shift_bit():
  128  *      Read a bit at a time from the config card.
  129  */
  130 static __inline u_char
  131 isapnp_shift_bit(sc)
  132         struct isapnp_softc *sc;
  133 {
  134         u_char c1, c2;
  135 
  136         DELAY(250);
  137         c1 = ISAPNP_READ_DATA(sc);
  138         DELAY(250);
  139         c2 = ISAPNP_READ_DATA(sc);
  140 
  141         if (c1 == 0x55 && c2 == 0xAA)
  142                 return 0x80;
  143         else
  144                 return 0;
  145 }
  146 
  147 
  148 /* isapnp_findcard():
  149  *      Attempt to read the vendor/serial/checksum for a card
  150  *      If a card is found [the checksum matches], assign the
  151  *      next card number to it and return 1
  152  */
  153 static int
  154 isapnp_findcard(sc)
  155         struct isapnp_softc *sc;
  156 {
  157         u_char v = ISAPNP_LFSR_INIT, csum, w;
  158         int i, b;
  159 
  160         if (sc->sc_ncards == ISAPNP_MAX_CARDS) {
  161                 printf("%s: Too many pnp cards\n", sc->sc_dev.dv_xname);
  162                 return 0;
  163         }
  164 
  165         /* Set the read port */
  166         isapnp_write_reg(sc, ISAPNP_WAKE, 0);
  167         isapnp_write_reg(sc, ISAPNP_SET_RD_PORT, sc->sc_read_port >> 2);
  168         sc->sc_read_port |= 3;
  169         DELAY(1000);
  170 
  171         ISAPNP_WRITE_ADDR(sc, ISAPNP_SERIAL_ISOLATION);
  172         DELAY(1000);
  173 
  174         /* Read the 8 bytes of the Vendor ID and Serial Number */
  175         for(i = 0; i < 8; i++) {
  176                 /* Read each bit separately */
  177                 for (w = 0, b = 0; b < 8; b++) {
  178                         u_char neg = isapnp_shift_bit(sc);
  179 
  180                         w >>= 1;
  181                         w |= neg;
  182                         v = ISAPNP_LFSR_NEXT(v) ^ neg;
  183                 }
  184                 sc->sc_id[sc->sc_ncards][i] = w;
  185         }
  186 
  187         /* Read the remaining checksum byte */
  188         for (csum = 0, b = 0; b < 8; b++) {
  189                 u_char neg = isapnp_shift_bit(sc);
  190 
  191                 csum >>= 1;
  192                 csum |= neg;
  193         }
  194         sc->sc_id[sc->sc_ncards][8] = csum;
  195 
  196         if (csum == v) {
  197                 sc->sc_ncards++;
  198                 isapnp_write_reg(sc, ISAPNP_CARD_SELECT_NUM, sc->sc_ncards);
  199                 return 1;
  200         }
  201         return 0;
  202 }
  203 
  204 
  205 /* isapnp_free_region():
  206  *      Free a region
  207  */
  208 static void
  209 isapnp_free_region(t, r)
  210         bus_space_tag_t t;
  211         struct isapnp_region *r;
  212 {
  213         if (r->length == 0)
  214                 return;
  215 
  216 #ifdef _KERNEL
  217         bus_space_unmap(t, r->h, r->length);
  218 #endif
  219 }
  220 
  221 
  222 /* isapnp_alloc_region():
  223  *      Allocate a single region if possible
  224  */
  225 static int
  226 isapnp_alloc_region(t, r)
  227         bus_space_tag_t t;
  228         struct isapnp_region *r;
  229 {
  230         int error = 0;
  231 
  232         if (r->length == 0) {
  233                 r->base = 0;
  234                 return 0;
  235         }
  236 
  237         for (r->base = r->minbase; r->base <= r->maxbase;
  238              r->base += r->align) {
  239 #ifdef _KERNEL
  240                 error = bus_space_map(t, r->base, r->length, 0, &r->h);
  241 #endif
  242                 if (error == 0)
  243                         return 0;
  244                 if (r->align == 0)
  245                         break;
  246         }
  247         return error;
  248 }
  249 
  250 
  251 /* isapnp_alloc_irq():
  252  *      Allocate an irq
  253  */
  254 static int
  255 isapnp_alloc_irq(ic, i)
  256         isa_chipset_tag_t ic;
  257         struct isapnp_pin *i;
  258 {
  259         int irq;
  260 #define LEVEL_IRQ (ISAPNP_IRQTYPE_LEVEL_PLUS|ISAPNP_IRQTYPE_LEVEL_MINUS)
  261         i->type = (i->flags & LEVEL_IRQ) ? IST_LEVEL : IST_EDGE;
  262 
  263         if (i->bits == 0) {
  264                 i->num = 0;
  265                 return 0;
  266         }
  267 
  268         if (isa_intr_alloc(ic, ISAPNP_ALLOC_INTR_MASK & i->bits,
  269                            i->type, &irq) == 0) {
  270                 i->num = irq;
  271                 return 0;
  272         }
  273 
  274         return EINVAL;
  275 }
  276 
  277 /* isapnp_alloc_drq():
  278  *      Allocate a drq
  279  */
  280 static int
  281 isapnp_alloc_drq(ic, i)
  282         isa_chipset_tag_t ic;
  283         struct isapnp_pin *i;
  284 {
  285 #if NISADMA > 0
  286         int b;
  287 
  288         if (i->bits == 0) {
  289                 i->num = 0;
  290                 return 0;
  291         }
  292 
  293         for (b = 0; b < 8; b++)
  294                 if ((i->bits & (1 << b)) && isa_drq_isfree(ic, b)) {
  295                         i->num = b;
  296                         return 0;
  297                 }
  298 #endif /* NISADMA > 0 */
  299 
  300         return EINVAL;
  301 }
  302 
  303 /* isapnp_testconfig():
  304  *      Test/Allocate the regions used
  305  */
  306 static int
  307 isapnp_testconfig(iot, memt, ipa, alloc)
  308         bus_space_tag_t iot, memt;
  309         struct isapnp_attach_args *ipa;
  310         int alloc;
  311 {
  312         int nio = 0, nmem = 0, nmem32 = 0, nirq = 0, ndrq = 0;
  313         int error = 0;
  314 
  315 #ifdef DEBUG_ISAPNP
  316         isapnp_print_attach(ipa);
  317 #endif
  318 
  319         for (; nio < ipa->ipa_nio; nio++) {
  320                 error = isapnp_alloc_region(iot, &ipa->ipa_io[nio]);
  321                 if (error)
  322                         goto bad;
  323         }
  324 
  325         for (; nmem < ipa->ipa_nmem; nmem++) {
  326                 error = isapnp_alloc_region(memt, &ipa->ipa_mem[nmem]);
  327                 if (error)
  328                         goto bad;
  329         }
  330 
  331         for (; nmem32 < ipa->ipa_nmem32; nmem32++) {
  332                 error = isapnp_alloc_region(memt, &ipa->ipa_mem32[nmem32]);
  333                 if (error)
  334                         goto bad;
  335         }
  336 
  337         for (; nirq < ipa->ipa_nirq; nirq++) {
  338                 error = isapnp_alloc_irq(ipa->ipa_ic, &ipa->ipa_irq[nirq]);
  339                 if (error)
  340                         goto bad;
  341         }
  342 
  343         for (; ndrq < ipa->ipa_ndrq; ndrq++) {
  344                 error = isapnp_alloc_drq(ipa->ipa_ic, &ipa->ipa_drq[ndrq]);
  345                 if (error)
  346                         goto bad;
  347         }
  348 
  349         if (alloc)
  350                 return error;
  351 
  352 bad:
  353 #ifdef notyet
  354         for (ndrq--; ndrq >= 0; ndrq--)
  355                 isapnp_free_pin(&ipa->ipa_drq[ndrq]);
  356 
  357         for (nirq--; nirq >= 0; nirq--)
  358                 isapnp_free_pin(&ipa->ipa_irq[nirq]);
  359 #endif
  360 
  361         for (nmem32--; nmem32 >= 0; nmem32--)
  362                 isapnp_free_region(memt, &ipa->ipa_mem32[nmem32]);
  363 
  364         for (nmem--; nmem >= 0; nmem--)
  365                 isapnp_free_region(memt, &ipa->ipa_mem[nmem]);
  366 
  367         for (nio--; nio >= 0; nio--)
  368                 isapnp_free_region(iot, &ipa->ipa_io[nio]);
  369 
  370         return error;
  371 }
  372 
  373 
  374 /* isapnp_config():
  375  *      Test/Allocate the regions used
  376  */
  377 int
  378 isapnp_config(iot, memt, ipa)
  379         bus_space_tag_t iot, memt;
  380         struct isapnp_attach_args *ipa;
  381 {
  382         return isapnp_testconfig(iot, memt, ipa, 1);
  383 }
  384 
  385 
  386 /* isapnp_unconfig():
  387  *      Free the regions used
  388  */
  389 void
  390 isapnp_unconfig(iot, memt, ipa)
  391         bus_space_tag_t iot, memt;
  392         struct isapnp_attach_args *ipa;
  393 {
  394         int i;
  395 
  396 #ifdef notyet
  397         for (i = 0; i < ipa->ipa_ndrq; i++)
  398                 isapnp_free_pin(&ipa->ipa_drq[i]);
  399 
  400         for (i = 0; i < ipa->ipa_nirq; i++)
  401                 isapnp_free_pin(&ipa->ipa_irq[i]);
  402 #endif
  403 
  404         for (i = 0; i < ipa->ipa_nmem32; i++)
  405                 isapnp_free_region(memt, &ipa->ipa_mem32[i]);
  406 
  407         for (i = 0; i < ipa->ipa_nmem; i++)
  408                 isapnp_free_region(memt, &ipa->ipa_mem[i]);
  409 
  410         for (i = 0; i < ipa->ipa_nio; i++)
  411                 isapnp_free_region(iot, &ipa->ipa_io[i]);
  412 }
  413 
  414 
  415 /* isapnp_bestconfig():
  416  *      Return the best configuration for each logical device, remove and
  417  *      free all other configurations.
  418  */
  419 static struct isapnp_attach_args *
  420 isapnp_bestconfig(sc, ipa)
  421         struct isapnp_softc *sc;
  422         struct isapnp_attach_args **ipa;
  423 {
  424         struct isapnp_attach_args *c, *best, *f = *ipa;
  425         int error;
  426 
  427         for (;;) {
  428                 if (f == NULL)
  429                         return NULL;
  430 
  431 #define SAMEDEV(a, b) (strcmp((a)->ipa_devlogic, (b)->ipa_devlogic) == 0)
  432 
  433                 /* Find the best config */
  434                 for (best = c = f; c != NULL; c = c->ipa_sibling) {
  435                         if (!SAMEDEV(c, f))
  436                                 continue;
  437                         if (c->ipa_pref < best->ipa_pref)
  438                                 best = c;
  439                 }
  440 
  441                 /*
  442                  * Make sure the ISA chipset is initialized!  We need
  443                  * it to test the best config!
  444                  */
  445                 best->ipa_ic = sc->sc_ic;
  446 
  447                 /* Test the best config */
  448                 error = isapnp_testconfig(sc->sc_iot, sc->sc_memt, best, 0);
  449 
  450                 /* Remove this config from the list */
  451                 if (best == f)
  452                         f = f->ipa_sibling;
  453                 else {
  454                         for (c = f; c->ipa_sibling != best; c = c->ipa_sibling)
  455                                 continue;
  456                         c->ipa_sibling = best->ipa_sibling;
  457                 }
  458 
  459                 if (error) {
  460                         best->ipa_pref = ISAPNP_DEP_CONFLICTING;
  461 
  462                         for (c = f; c != NULL; c = c->ipa_sibling)
  463                                 if (c != best && SAMEDEV(c, best))
  464                                         break;
  465                         /* Last config for this logical device is conflicting */
  466                         if (c == NULL) {
  467                                 *ipa = f;
  468                                 return best;
  469                         }
  470 
  471                         ISAPNP_FREE(best);
  472                         continue;
  473                 }
  474                 else {
  475                         /* Remove all other configs for this device */
  476                         struct isapnp_attach_args *l = NULL, *n = NULL, *d;
  477 
  478                         for (c = f; c; ) {
  479                                 if (c == best)
  480                                         continue;
  481                                 d = c->ipa_sibling;
  482                                 if (SAMEDEV(c, best))
  483                                         ISAPNP_FREE(c);
  484                                 else {
  485                                         if (n)
  486                                                 n->ipa_sibling = c;
  487                                 
  488                                         else
  489                                                 l = c;
  490                                         n = c;
  491                                         c->ipa_sibling = NULL;
  492                                 }
  493                                 c = d;
  494                         }
  495                         f = l;
  496                 }
  497                 *ipa = f;
  498                 return best;
  499         }
  500 }
  501 
  502 
  503 /* isapnp_id_to_vendor():
  504  *      Convert a pnp ``compressed ascii'' vendor id to a string
  505  */
  506 char *
  507 isapnp_id_to_vendor(v, id)
  508         char   *v;
  509         const u_char *id;
  510 {
  511         static const char hex[] = "0123456789ABCDEF";
  512         char *p = v;
  513         
  514         *p++ = 'A' + (id[0] >> 2) - 1;
  515         *p++ = 'A' + ((id[0] & 3) << 3) + (id[1] >> 5) - 1;
  516         *p++ = 'A' + (id[1] & 0x1f) - 1;
  517         *p++ = hex[id[2] >> 4];
  518         *p++ = hex[id[2] & 0x0f];
  519         *p++ = hex[id[3] >> 4];
  520         *p++ = hex[id[3] & 0x0f];
  521         *p = '\0';
  522 
  523         return v;
  524 }
  525 
  526 
  527 /* isapnp_print_region():
  528  *      Print a region allocation
  529  */
  530 static void
  531 isapnp_print_region(str, r, n)
  532         const char *str;
  533         struct isapnp_region *r;
  534         size_t n;
  535 {
  536         size_t i;
  537 
  538         if (n == 0)
  539                 return;
  540 
  541         aprint_normal(" %s ", str);
  542         for (i = 0; i < n; i++, r++) {
  543                 aprint_normal("0x%x", r->base);
  544                 if (r->length)
  545                         aprint_normal("/%d", r->length);
  546                 if (i != n - 1)
  547                         aprint_normal(",");
  548         }
  549 }
  550 
  551 
  552 /* isapnp_print_pin():
  553  *      Print an irq/drq assignment
  554  */
  555 static void
  556 isapnp_print_pin(str, p, n)
  557         const char *str;
  558         struct isapnp_pin *p;
  559         size_t n;
  560 {
  561         size_t i;
  562 
  563         if (n == 0)
  564                 return;
  565 
  566         printf(" %s ", str);
  567         for (i = 0; i < n; i++, p++) {
  568                 printf("%d", p->num);
  569                 if (i != n - 1)
  570                         printf(",");
  571         }
  572 }
  573 
  574 
  575 /* isapnp_print():
  576  *      Print the configuration line for an ISA PnP card.
  577  */
  578 static int
  579 isapnp_print(aux, str)
  580         void *aux;
  581         const char *str;
  582 {
  583         struct isapnp_attach_args *ipa = aux;
  584 
  585         if (str != NULL)
  586                 aprint_normal("%s: <%s, %s, %s, %s>",
  587                     str, ipa->ipa_devident, ipa->ipa_devlogic,
  588                     ipa->ipa_devcompat, ipa->ipa_devclass);
  589 
  590         isapnp_print_region("port", ipa->ipa_io, ipa->ipa_nio);
  591         isapnp_print_region("mem", ipa->ipa_mem, ipa->ipa_nmem);
  592         isapnp_print_region("mem32", ipa->ipa_mem32, ipa->ipa_nmem32);
  593         isapnp_print_pin("irq", ipa->ipa_irq, ipa->ipa_nirq);
  594         isapnp_print_pin("drq", ipa->ipa_drq, ipa->ipa_ndrq);
  595 
  596         return UNCONF;
  597 }
  598 
  599 
  600 #ifdef _KERNEL
  601 /* isapnp_submatch():
  602  *      Probe the logical device...
  603  */
  604 static int
  605 isapnp_submatch(parent, match, aux)
  606         struct device *parent;
  607         struct cfdata *match;
  608         void *aux;
  609 {
  610         return (config_match(parent, match, aux));
  611 }
  612 
  613 
  614 /* isapnp_devmatch():
  615  *      Match a probed device with the information from the driver
  616  */
  617 int
  618 isapnp_devmatch(ipa, dinfo, variant)
  619         const struct isapnp_attach_args *ipa;
  620         const struct isapnp_devinfo *dinfo;
  621         int *variant;
  622 {
  623         const struct isapnp_matchinfo *match;
  624         int n;
  625 
  626         for (match = dinfo->devlogic, n = dinfo->nlogic; n--; match++)
  627                 if (strcmp(match->name, ipa->ipa_devlogic) == 0) {
  628                         *variant = match->variant;
  629                         return (1);
  630                 }
  631 
  632         for (match = dinfo->devcompat, n = dinfo->ncompat; n--; match++)
  633                 if (strcmp(match->name, ipa->ipa_devcompat) == 0) {
  634                         *variant = match->variant;
  635                         return (1);
  636                 }
  637 
  638         return (0);
  639 }
  640 
  641 
  642 /* isapnp_isa_attach_hook():
  643  *      This routine is called from the isa attach code and
  644  *      is a kludge; we are resetting all the cards here in order
  645  *      to undo any card configuration that the bios did for us, in order
  646  *      to avoid having the PnP devices match an isa probe. The correct
  647  *      way of doing this is to read the PnP BIOS and find the card settings
  648  *      from there. Unfortunately it is not as easy as it sounds.
  649  */
  650 void
  651 isapnp_isa_attach_hook(isa_sc)
  652         struct isa_softc *isa_sc;
  653 {
  654         struct isapnp_softc sc;
  655         
  656         sc.sc_iot = isa_sc->sc_iot;
  657         sc.sc_ncards = 0;
  658 
  659         if (isapnp_map(&sc))
  660                 return;
  661 
  662 #if NWSS_ISAPNP > 0
  663         /*
  664          * XXX XXX
  665          * This a totally disgusting hack, but I can't figure out another way.
  666          * It seems that many CS audio chips have a bug (as far as I can
  667          * understand).  The reset below does not really reset the chip, it
  668          * remains in a catatonic state and will not respond when probed.
  669          * The chip can be used both as a WSS and as a SB device, and a
  670          * single read at the WSS address (0x534) takes it out of this
  671          * non-responsive state.
  672          * The read has to happen at this point in time (or earlier) so
  673          * it cannot be moved to the wss_isapnp.c driver.
  674          * (BTW, We're not alone in having problems with these chips: 
  675          * Windoze 98 couldn't detect the sound chip on a Dell when I tried.)
  676          *
  677          *     Lennart Augustsson <augustss@NetBSD.org>
  678          *
  679          * (Implementation from John Kohl <jtk@kolvir.arlington.ma.us>)
  680          */
  681         {
  682                 bus_space_handle_t ioh;
  683                 int rv;
  684                 if ((rv = bus_space_map(sc.sc_iot, 0x534, 1, 0, &ioh)) == 0) {
  685                         DPRINTF(("wss probe kludge\n"));
  686                         (void)bus_space_read_1(sc.sc_iot, ioh, 0);
  687                         bus_space_unmap(sc.sc_iot, ioh, 1);
  688                 } else {
  689                         DPRINTF(("wss probe kludge failed to map: %d\n", rv));
  690                 }
  691         }
  692 #endif
  693 
  694         isapnp_init(&sc);
  695 
  696         isapnp_write_reg(&sc, ISAPNP_CONFIG_CONTROL, ISAPNP_CC_RESET_DRV);
  697         DELAY(2000);
  698 
  699         isapnp_unmap(&sc);
  700 }
  701 #endif
  702 
  703 
  704 /* isapnp_find():
  705  *      Probe and add cards
  706  */
  707 static int
  708 isapnp_find(sc, all)
  709         struct isapnp_softc *sc;
  710         int all;
  711 {
  712         int p;
  713 
  714         isapnp_init(sc);
  715 
  716         isapnp_write_reg(sc, ISAPNP_CONFIG_CONTROL, ISAPNP_CC_RESET_DRV);
  717         DELAY(2000);
  718 
  719         isapnp_init(sc);
  720         DELAY(2000);
  721 
  722         for (p = ISAPNP_RDDATA_MIN; p <= ISAPNP_RDDATA_MAX; p += 4) {
  723                 sc->sc_read_port = p;
  724                 if (isapnp_map_readport(sc))
  725                         continue;
  726                 DPRINTF(("%s: Trying port %x\r", sc->sc_dev.dv_xname, p));
  727                 if (isapnp_findcard(sc))
  728                         break;
  729                 isapnp_unmap_readport(sc);
  730         }
  731 
  732         if (p > ISAPNP_RDDATA_MAX) {
  733                 sc->sc_read_port = 0;
  734                 return 0;
  735         }
  736 
  737         if (all)
  738                 while (isapnp_findcard(sc))
  739                         continue;
  740 
  741         return 1;
  742 }
  743 
  744 
  745 /* isapnp_configure():
  746  *      Configure a PnP card
  747  *      XXX: The memory configuration code is wrong. We need to check the
  748  *           range/length bit an do appropriate sets.
  749  */
  750 static void
  751 isapnp_configure(sc, ipa)
  752         struct isapnp_softc *sc;
  753         const struct isapnp_attach_args *ipa;
  754 {
  755         int i;
  756         static u_char isapnp_mem_range[] = ISAPNP_MEM_DESC;
  757         static u_char isapnp_io_range[] = ISAPNP_IO_DESC;
  758         static u_char isapnp_irq_range[] = ISAPNP_IRQ_DESC;
  759         static u_char isapnp_drq_range[] = ISAPNP_DRQ_DESC;
  760         static u_char isapnp_mem32_range[] = ISAPNP_MEM32_DESC;
  761         const struct isapnp_region *r;
  762         const struct isapnp_pin *p;
  763         struct isapnp_region rz;
  764         struct isapnp_pin pz;
  765 
  766         memset(&pz, 0, sizeof(pz));
  767         memset(&rz, 0, sizeof(rz));
  768 
  769 #define B0(a) ((a) & 0xff)
  770 #define B1(a) (((a) >> 8) & 0xff)
  771 #define B2(a) (((a) >> 16) & 0xff)
  772 #define B3(a) (((a) >> 24) & 0xff)
  773 
  774         for (i = 0; i < sizeof(isapnp_io_range); i++) {
  775                 if (i < ipa->ipa_nio)
  776                         r = &ipa->ipa_io[i];
  777                 else
  778                         r = &rz;
  779 
  780                 isapnp_write_reg(sc,
  781                     isapnp_io_range[i] + ISAPNP_IO_BASE_15_8, B1(r->base));
  782                 isapnp_write_reg(sc,
  783                     isapnp_io_range[i] + ISAPNP_IO_BASE_7_0, B0(r->base));
  784         }
  785 
  786         for (i = 0; i < sizeof(isapnp_mem_range); i++) {
  787                 if (i < ipa->ipa_nmem)
  788                         r = &ipa->ipa_mem[i];
  789                 else 
  790                         r = &rz;
  791 
  792                 isapnp_write_reg(sc,
  793                     isapnp_mem_range[i] + ISAPNP_MEM_BASE_23_16, B2(r->base));
  794                 isapnp_write_reg(sc,
  795                     isapnp_mem_range[i] + ISAPNP_MEM_BASE_15_8, B1(r->base));
  796 
  797                 isapnp_write_reg(sc,
  798                     isapnp_mem_range[i] + ISAPNP_MEM_LRANGE_23_16,
  799                     B2(r->length));
  800                 isapnp_write_reg(sc,
  801                     isapnp_mem_range[i] + ISAPNP_MEM_LRANGE_15_8,
  802                     B1(r->length));
  803         }
  804 
  805         for (i = 0; i < sizeof(isapnp_irq_range); i++) {
  806                 u_char v;
  807 
  808                 if (i < ipa->ipa_nirq)
  809                         p = &ipa->ipa_irq[i];
  810                 else
  811                         p = &pz;
  812 
  813                 isapnp_write_reg(sc,
  814                     isapnp_irq_range[i] + ISAPNP_IRQ_NUMBER, p->num);
  815 
  816                 switch (p->flags) {
  817                 case ISAPNP_IRQTYPE_LEVEL_PLUS:
  818                         v = ISAPNP_IRQ_LEVEL|ISAPNP_IRQ_HIGH;
  819                         break;
  820 
  821                 case ISAPNP_IRQTYPE_EDGE_PLUS:
  822                         v = ISAPNP_IRQ_HIGH;
  823                         break;
  824 
  825                 case ISAPNP_IRQTYPE_LEVEL_MINUS:
  826                         v = ISAPNP_IRQ_LEVEL;
  827                         break;
  828 
  829                 default:
  830                 case ISAPNP_IRQTYPE_EDGE_MINUS:
  831                         v = 0;
  832                         break;
  833                 }
  834                 isapnp_write_reg(sc,
  835                     isapnp_irq_range[i] + ISAPNP_IRQ_CONTROL, v);
  836         }
  837 
  838         for (i = 0; i < sizeof(isapnp_drq_range); i++) {
  839                 u_char v;
  840 
  841                 if (i < ipa->ipa_ndrq)
  842                         v = ipa->ipa_drq[i].num;
  843                 else
  844                         v = 4;
  845 
  846                 isapnp_write_reg(sc, isapnp_drq_range[i], v);
  847         }
  848 
  849         for (i = 0; i < sizeof(isapnp_mem32_range); i++) {
  850                 if (i < ipa->ipa_nmem32)
  851                         r = &ipa->ipa_mem32[i];
  852                 else 
  853                         r = &rz;
  854 
  855                 isapnp_write_reg(sc,
  856                     isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_31_24,
  857                     B3(r->base));
  858                 isapnp_write_reg(sc,
  859                     isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_23_16,
  860                     B2(r->base));
  861                 isapnp_write_reg(sc,
  862                     isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_15_8,
  863                     B1(r->base));
  864                 isapnp_write_reg(sc,
  865                     isapnp_mem32_range[i] + ISAPNP_MEM32_BASE_7_0,
  866                     B0(r->base));
  867 
  868                 isapnp_write_reg(sc,
  869                     isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_31_24,
  870                     B3(r->length));
  871                 isapnp_write_reg(sc,
  872                     isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_23_16,
  873                     B2(r->length));
  874                 isapnp_write_reg(sc,
  875                     isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_15_8,
  876                     B1(r->length));
  877                 isapnp_write_reg(sc,
  878                     isapnp_mem32_range[i] + ISAPNP_MEM32_LRANGE_7_0,
  879                     B0(r->length));
  880         }
  881 }
  882 
  883 
  884 /* isapnp_match():
  885  *      Probe routine
  886  */
  887 static int
  888 isapnp_match(parent, match, aux)
  889         struct device *parent;
  890         struct cfdata *match;
  891         void *aux;
  892 {
  893         struct isapnp_softc sc;
  894         struct isa_attach_args *ia = aux;
  895         struct isapnp_probe_cookie *ipc;
  896 
  897         /*
  898          * Ensure we only probe ISA PnP once; we don't actually consume
  899          * bus resources, so we have to prevent being cloned forever.
  900          */
  901         for (ipc = LIST_FIRST(&isapnp_probes); ipc != NULL;
  902              ipc = LIST_NEXT(ipc, ipc_link))
  903                 if (ipc->ipc_parent == parent)
  904                         return (0);
  905 
  906         ipc = malloc(sizeof(*ipc), M_DEVBUF, M_NOWAIT);
  907         if (ipc == NULL)
  908                 panic("isapnp_match: can't allocate probe cookie");
  909 
  910         ipc->ipc_parent = parent;
  911         LIST_INSERT_HEAD(&isapnp_probes, ipc, ipc_link);
  912 
  913         sc.sc_iot = ia->ia_iot;
  914         (void) strcpy(sc.sc_dev.dv_xname, "(isapnp probe)");
  915 
  916         if (isapnp_map(&sc))
  917                 return 0;
  918 
  919         isapnp_unmap(&sc);
  920 
  921         /*
  922          * We always match.  We must let all legacy ISA devices map
  923          * their address spaces before we look for a read port.
  924          */
  925         ia->ia_io[0].ir_addr = ISAPNP_ADDR;
  926         ia->ia_io[0].ir_size = 1;
  927 
  928         ia->ia_niomem = 0;
  929         ia->ia_nirq = 0;
  930         ia->ia_ndrq = 0;
  931 
  932         return (1);
  933 }
  934 
  935 
  936 /* isapnp_attach
  937  *      Attach the PnP `bus'.
  938  */
  939 static void
  940 isapnp_attach(parent, self, aux)
  941         struct device *parent, *self;
  942         void *aux;
  943 {
  944         struct isapnp_softc *sc = (struct isapnp_softc *) self;
  945         struct isa_attach_args *ia = aux;
  946 
  947         sc->sc_iot = ia->ia_iot;
  948         sc->sc_memt = ia->ia_memt;
  949         sc->sc_ic = ia->ia_ic;
  950         sc->sc_dmat = ia->ia_dmat;
  951         sc->sc_ncards = 0;
  952 
  953         printf(": ISA Plug 'n Play device support\n");
  954 
  955         if (isapnp_map(sc)) {
  956                 printf("%s: unable to map PnP register\n",
  957                     sc->sc_dev.dv_xname);
  958                 return;
  959         }
  960 
  961 #ifdef _KERNEL
  962         /*
  963          * Defer configuration until the rest of the ISA devices have
  964          * attached themselves.
  965          */
  966         config_defer(self, isapnp_callback);
  967 #else
  968         isapnp_callback(self);
  969 #endif
  970 }
  971 
  972 /* isapnp_callback
  973  *      Find and attach PnP cards.
  974  */
  975 void
  976 isapnp_callback(self)
  977         struct device *self;
  978 {
  979         struct isapnp_softc *sc = (struct isapnp_softc *)self;
  980         struct isapnp_attach_args *ipa, *lpa;
  981         int c, d;
  982 
  983         /*
  984          * Look for cards.  If none are found, we say so and just return.
  985          */
  986         if (isapnp_find(sc, 1) == 0) {
  987                 printf("%s: no ISA Plug 'n Play devices found\n",
  988                     sc->sc_dev.dv_xname);
  989                 return;
  990         }
  991 
  992         printf("%s: read port 0x%x\n", sc->sc_dev.dv_xname, sc->sc_read_port);
  993 
  994         /*
  995          * Now configure all of the cards.
  996          */
  997         for (c = 0; c < sc->sc_ncards; c++) {
  998                 /* Good morning card c */
  999                 isapnp_write_reg(sc, ISAPNP_WAKE, c + 1);
 1000 
 1001                 if ((ipa = isapnp_get_resource(sc, c)) == NULL)
 1002                         continue;
 1003 
 1004                 DPRINTF(("Selecting attachments\n"));
 1005                 for (d = 0;
 1006                     (lpa = isapnp_bestconfig(sc, &ipa)) != NULL; d++) {
 1007                         isapnp_write_reg(sc, ISAPNP_LOGICAL_DEV_NUM, d);
 1008                         isapnp_configure(sc, lpa);
 1009 #ifdef DEBUG_ISAPNP
 1010                         {
 1011                                 struct isapnp_attach_args pa;
 1012 
 1013                                 isapnp_get_config(sc, &pa);
 1014                                 isapnp_print_config(&pa);
 1015                         }
 1016 #endif
 1017 
 1018                         DPRINTF(("%s: configuring <%s, %s, %s, %s>\n",
 1019                             sc->sc_dev.dv_xname,
 1020                             lpa->ipa_devident, lpa->ipa_devlogic,
 1021                             lpa->ipa_devcompat, lpa->ipa_devclass));
 1022                         if (lpa->ipa_pref == ISAPNP_DEP_CONFLICTING) {
 1023                                 printf("%s: <%s, %s, %s, %s> ignored; %s\n",
 1024                                     sc->sc_dev.dv_xname,
 1025                                     lpa->ipa_devident, lpa->ipa_devlogic,
 1026                                     lpa->ipa_devcompat, lpa->ipa_devclass,
 1027                                     "resource conflict");
 1028                                 ISAPNP_FREE(lpa);
 1029                                 continue;
 1030                         }
 1031 
 1032                         lpa->ipa_ic = sc->sc_ic;
 1033                         lpa->ipa_iot = sc->sc_iot;
 1034                         lpa->ipa_memt = sc->sc_memt;
 1035                         lpa->ipa_dmat = sc->sc_dmat;
 1036 
 1037                         isapnp_write_reg(sc, ISAPNP_ACTIVATE, 1);
 1038 #ifdef _KERNEL
 1039                         if (config_found_sm(self, lpa, isapnp_print,
 1040                             isapnp_submatch) == NULL)
 1041                                 isapnp_write_reg(sc, ISAPNP_ACTIVATE, 0);
 1042 #else
 1043                         isapnp_print(lpa, NULL);
 1044                         printf("\n");
 1045 #endif
 1046                         ISAPNP_FREE(lpa);
 1047                 }
 1048                 isapnp_write_reg(sc, ISAPNP_WAKE, 0);    /* Good night cards */
 1049         }
 1050 }

Cache object: 75836fc32ec223aae80f5e1337d1f1c5


[ 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.