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/i386/i386/bios.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) 1997 Michael Smith
    3  * Copyright (c) 1998 Jonathan Lemon
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  *
   27  * $FreeBSD$
   28  */
   29 
   30 /*
   31  * Code for dealing with the BIOS in x86 PC systems.
   32  */
   33 
   34 #include "opt_pnp.h"
   35 
   36 #include "isa.h"
   37 
   38 #include <sys/param.h>
   39 #include <sys/systm.h>
   40 #include <sys/kernel.h>
   41 #include <sys/malloc.h>
   42 #include <sys/bus.h>
   43 #include <vm/vm.h>
   44 #include <vm/pmap.h>
   45 #include <machine/md_var.h>
   46 #include <machine/segments.h>
   47 #include <machine/stdarg.h>
   48 #include <machine/vmparam.h>
   49 #include <machine/pc/bios.h>
   50 #include <isa/pnpreg.h>
   51 #include <isa/pnpvar.h>
   52 #if NISA > 0
   53 #include <isa/isavar.h>
   54 #endif
   55 
   56 #define BIOS_START      0xe0000
   57 #define BIOS_SIZE       0x20000
   58 
   59 /* exported lookup results */
   60 struct bios32_SDentry           PCIbios = {entry : 0};
   61 struct PnPBIOS_table            *PnPBIOStable = 0;
   62 
   63 static u_int                    bios32_SDCI = 0;
   64 
   65 /* start fairly early */
   66 static void                     bios32_init(void *junk);
   67 SYSINIT(bios32, SI_SUB_CPU, SI_ORDER_ANY, bios32_init, NULL);
   68 
   69 /*
   70  * bios32_init
   71  *
   72  * Locate various bios32 entities.
   73  */
   74 static void
   75 bios32_init(void *junk)
   76 {
   77     u_long                      sigaddr;
   78     struct bios32_SDheader      *sdh;
   79     struct PnPBIOS_table        *pt;
   80     u_int8_t                    ck, *cv;
   81     int                         i;
   82     
   83     /*
   84      * BIOS32 Service Directory
   85      */
   86     
   87     /* look for the signature */
   88     if ((sigaddr = bios_sigsearch(0, "_32_", 4, 16, 0)) != 0) {
   89 
   90         /* get a virtual pointer to the structure */
   91         sdh = (struct bios32_SDheader *)(uintptr_t)BIOS_PADDRTOVADDR(sigaddr);
   92         for (cv = (u_int8_t *)sdh, ck = 0, i = 0; i < (sdh->len * 16); i++) {
   93             ck += cv[i];
   94         }
   95         /* If checksum is OK, enable use of the entrypoint */
   96         if ((ck == 0) && (sdh->entry < (BIOS_START + BIOS_SIZE))) {
   97             bios32_SDCI = BIOS_PADDRTOVADDR(sdh->entry);
   98             if (bootverbose) {
   99                 printf("bios32: Found BIOS32 Service Directory header at %p\n", sdh);
  100                 printf("bios32: Entry = 0x%x (%x)  Rev = %d  Len = %d\n", 
  101                        sdh->entry, bios32_SDCI, sdh->revision, sdh->len);
  102             }
  103             /* See if there's a PCI BIOS entrypoint here */
  104             PCIbios.ident.id = 0x49435024;      /* PCI systems should have this */
  105             if (!bios32_SDlookup(&PCIbios) && bootverbose)
  106                 printf("pcibios: PCI BIOS entry at 0x%x\n", PCIbios.entry);
  107         } else {
  108             printf("bios32: Bad BIOS32 Service Directory\n");
  109         }
  110     }
  111 
  112     /*
  113      * PnP BIOS
  114      */
  115     if ((sigaddr = bios_sigsearch(0, "$PnP", 4, 16, 0)) != 0) {
  116 
  117         /* get a virtual pointer to the structure */
  118         pt = (struct PnPBIOS_table *)(uintptr_t)BIOS_PADDRTOVADDR(sigaddr);
  119         for (cv = (u_int8_t *)pt, ck = 0, i = 0; i < pt->len; i++) {
  120             ck += cv[i];
  121         }
  122         /* If checksum is OK, enable use of the entrypoint */
  123         if (ck == 0) {
  124             PnPBIOStable = pt;
  125             if (bootverbose) {
  126                 printf("pnpbios: Found PnP BIOS data at %p\n", pt);
  127                 printf("pnpbios: Entry = %x:%x  Rev = %d.%d\n", 
  128                        pt->pmentrybase, pt->pmentryoffset, pt->version >> 4, pt->version & 0xf);
  129                 if ((pt->control & 0x3) == 0x01)
  130                     printf("pnpbios: Event flag at %x\n", pt->evflagaddr);
  131                 if (pt->oemdevid != 0)
  132                     printf("pnpbios: OEM ID %x\n", pt->oemdevid);
  133                 
  134             }
  135         } else {
  136             printf("pnpbios: Bad PnP BIOS data checksum\n");
  137         }
  138     }
  139 
  140     if (bootverbose) {
  141             /* look for other know signatures */
  142             printf("Other BIOS signatures found:\n");
  143             printf("ACPI: %08x\n", bios_sigsearch(0, "RSD PTR ", 8, 16, 0));
  144     }
  145 }
  146 
  147 /*
  148  * bios32_SDlookup
  149  *
  150  * Query the BIOS32 Service Directory for the service named in (ent),
  151  * returns nonzero if the lookup fails.  The caller must fill in
  152  * (ent->ident), the remainder are populated on a successful lookup.
  153  */
  154 int
  155 bios32_SDlookup(struct bios32_SDentry *ent)
  156 {
  157     struct bios_regs args;
  158 
  159     if (bios32_SDCI == 0)
  160         return (1);
  161 
  162     args.eax = ent->ident.id;           /* set up arguments */
  163     args.ebx = args.ecx = args.edx = 0;
  164     bios32(&args, bios32_SDCI, GSEL(GCODE_SEL, SEL_KPL));
  165     if ((args.eax & 0xff) == 0) {       /* success? */
  166         ent->base = args.ebx;
  167         ent->len = args.ecx;
  168         ent->entry = args.edx;
  169         ent->ventry = BIOS_PADDRTOVADDR(ent->base + ent->entry);
  170         return (0);                     /* all OK */
  171     }
  172     return (1);                         /* failed */
  173 }
  174 
  175 
  176 /*
  177  * bios_sigsearch
  178  *
  179  * Search some or all of the BIOS region for a signature string.
  180  *
  181  * (start)      Optional offset returned from this function 
  182  *              (for searching for multiple matches), or NULL
  183  *              to start the search from the base of the BIOS.
  184  *              Note that this will be a _physical_ address in
  185  *              the range 0xe0000 - 0xfffff.
  186  * (sig)        is a pointer to the byte(s) of the signature.
  187  * (siglen)     number of bytes in the signature.
  188  * (paralen)    signature paragraph (alignment) size.
  189  * (sigofs)     offset of the signature within the paragraph.
  190  *
  191  * Returns the _physical_ address of the found signature, 0 if the
  192  * signature was not found.
  193  */
  194 
  195 u_int32_t
  196 bios_sigsearch(u_int32_t start, u_char *sig, int siglen, int paralen, int sigofs)
  197 {
  198     u_char      *sp, *end;
  199     
  200     /* compute the starting address */
  201     if ((start >= BIOS_START) && (start <= (BIOS_START + BIOS_SIZE))) {
  202         sp = (char *)BIOS_PADDRTOVADDR(start);
  203     } else if (start == 0) {
  204         sp = (char *)BIOS_PADDRTOVADDR(BIOS_START);
  205     } else {
  206         return 0;                               /* bogus start address */
  207     }
  208 
  209     /* compute the end address */
  210     end = (u_char *)BIOS_PADDRTOVADDR(BIOS_START + BIOS_SIZE);
  211 
  212     /* loop searching */
  213     while ((sp + sigofs + siglen) < end) {
  214         
  215         /* compare here */
  216         if (!bcmp(sp + sigofs, sig, siglen)) {
  217             /* convert back to physical address */
  218             return((u_int32_t)BIOS_VADDRTOPADDR(sp));
  219         }
  220         sp += paralen;
  221     }
  222     return(0);
  223 }
  224 
  225 /*
  226  * do not staticize, used by bioscall.s
  227  */
  228 union {
  229     struct {
  230         u_short offset;
  231         u_short segment;
  232     } vec16;
  233     struct {
  234         u_int   offset;
  235         u_short segment;
  236     } vec32;
  237 } bioscall_vector;                      /* bios jump vector */
  238 
  239 void
  240 set_bios_selectors(struct bios_segments *seg, int flags)
  241 {
  242     struct soft_segment_descriptor ssd = {
  243         0,                      /* segment base address (overwritten) */
  244         0,                      /* length (overwritten) */
  245         SDT_MEMERA,             /* segment type (overwritten) */
  246         0,                      /* priority level */
  247         1,                      /* descriptor present */
  248         0, 0,
  249         1,                      /* descriptor size (overwritten) */
  250         0                       /* granularity == byte units */
  251     };
  252     union descriptor *p_gdt;
  253 
  254 #ifdef SMP
  255     p_gdt = &gdt[cpuid * NGDT];
  256 #else
  257     p_gdt = gdt;
  258 #endif
  259         
  260     ssd.ssd_base = seg->code32.base;
  261     ssd.ssd_limit = seg->code32.limit;
  262     ssdtosd(&ssd, &p_gdt[GBIOSCODE32_SEL].sd);
  263 
  264     ssd.ssd_def32 = 0;
  265     if (flags & BIOSCODE_FLAG) {
  266         ssd.ssd_base = seg->code16.base;
  267         ssd.ssd_limit = seg->code16.limit;
  268         ssdtosd(&ssd, &p_gdt[GBIOSCODE16_SEL].sd);
  269     }
  270 
  271     ssd.ssd_type = SDT_MEMRWA;
  272     if (flags & BIOSDATA_FLAG) {
  273         ssd.ssd_base = seg->data.base;
  274         ssd.ssd_limit = seg->data.limit;
  275         ssdtosd(&ssd, &p_gdt[GBIOSDATA_SEL].sd);
  276     }
  277 
  278     if (flags & BIOSUTIL_FLAG) {
  279         ssd.ssd_base = seg->util.base;
  280         ssd.ssd_limit = seg->util.limit;
  281         ssdtosd(&ssd, &p_gdt[GBIOSUTIL_SEL].sd);
  282     }
  283 
  284     if (flags & BIOSARGS_FLAG) {
  285         ssd.ssd_base = seg->args.base;
  286         ssd.ssd_limit = seg->args.limit;
  287         ssdtosd(&ssd, &p_gdt[GBIOSARGS_SEL].sd);
  288     }
  289 }
  290 
  291 extern int vm86pa;
  292 extern void bios16_jmp(void);
  293 
  294 /*
  295  * this routine is really greedy with selectors, and uses 5:
  296  *
  297  * 32-bit code selector:        to return to kernel
  298  * 16-bit code selector:        for running code
  299  *        data selector:        for 16-bit data
  300  *        util selector:        extra utility selector
  301  *        args selector:        to handle pointers
  302  *
  303  * the util selector is set from the util16 entry in bios16_args, if a
  304  * "U" specifier is seen.
  305  *
  306  * See <machine/pc/bios.h> for description of format specifiers
  307  */
  308 int
  309 bios16(struct bios_args *args, char *fmt, ...)
  310 {
  311     char        *p, *stack, *stack_top;
  312     va_list     ap;
  313     int         flags = BIOSCODE_FLAG | BIOSDATA_FLAG;
  314     u_int       i, arg_start, arg_end;
  315     pt_entry_t  *pte;
  316     pd_entry_t  *ptd;
  317 
  318     arg_start = 0xffffffff;
  319     arg_end = 0;
  320 
  321     /*
  322      * Some BIOS entrypoints attempt to copy the largest-case
  323      * argument frame (in order to generalise handling for 
  324      * different entry types).  If our argument frame is 
  325      * smaller than this, the BIOS will reach off the top of
  326      * our constructed stack segment.  Pad the top of the stack
  327      * with some garbage to avoid this.
  328      */
  329     stack = (caddr_t)PAGE_SIZE - 32;
  330 
  331     va_start(ap, fmt);
  332     for (p = fmt; p && *p; p++) {
  333         switch (*p) {
  334         case 'p':                       /* 32-bit pointer */
  335             i = va_arg(ap, u_int);
  336             arg_start = min(arg_start, i);
  337             arg_end = max(arg_end, i);
  338             flags |= BIOSARGS_FLAG;
  339             stack -= 4;
  340             break;
  341 
  342         case 'i':                       /* 32-bit integer */
  343             i = va_arg(ap, u_int);
  344             stack -= 4;
  345             break;
  346 
  347         case 'U':                       /* 16-bit selector */
  348             flags |= BIOSUTIL_FLAG;
  349             /* FALLTHROUGH */
  350         case 'D':                       /* 16-bit selector */
  351         case 'C':                       /* 16-bit selector */
  352             stack -= 2;
  353             break;
  354             
  355         case 's':                       /* 16-bit integer */
  356             i = va_arg(ap, u_short);
  357             stack -= 2;
  358             break;
  359 
  360         default:
  361             return (EINVAL);
  362         }
  363     }
  364 
  365     if (flags & BIOSARGS_FLAG) {
  366         if (arg_end - arg_start > ctob(16))
  367             return (EACCES);
  368         args->seg.args.base = arg_start;
  369         args->seg.args.limit = 0xffff;
  370     }
  371 
  372     args->seg.code32.base = (u_int)&bios16_jmp & PG_FRAME;
  373     args->seg.code32.limit = 0xffff;    
  374 
  375     ptd = (pd_entry_t *)rcr3();
  376 #ifdef PAE
  377     ptd = (pd_entry_t *)(*ptd & PG_FRAME);
  378 #endif
  379     if (ptd == IdlePTD) {
  380         /*
  381          * no page table, so create one and install it.
  382          */
  383         pte = (pt_entry_t *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
  384         ptd = (pd_entry_t *)(KERNBASE + IdlePTD);
  385         *ptd = vtophys(pte) | PG_RW | PG_V;
  386     } else {
  387         /*
  388          * this is a user-level page table 
  389          */
  390         pte = PTmap;
  391     }
  392     /*
  393      * install pointer to page 0.  we don't need to flush the tlb,
  394      * since there should not be a previous mapping for page 0.
  395      */
  396     *pte = (vm86pa - PAGE_SIZE) | PG_RW | PG_V; 
  397 
  398     stack_top = stack;
  399     va_start(ap, fmt);
  400     for (p = fmt; p && *p; p++) {
  401         switch (*p) {
  402         case 'p':                       /* 32-bit pointer */
  403             i = va_arg(ap, u_int);
  404             *(u_int *)stack = (i - arg_start) |
  405                 (GSEL(GBIOSARGS_SEL, SEL_KPL) << 16);
  406             stack += 4;
  407             break;
  408 
  409         case 'i':                       /* 32-bit integer */
  410             i = va_arg(ap, u_int);
  411             *(u_int *)stack = i;
  412             stack += 4;
  413             break;
  414 
  415         case 'U':                       /* 16-bit selector */
  416             *(u_short *)stack = GSEL(GBIOSUTIL_SEL, SEL_KPL);
  417             stack += 2;
  418             break;
  419 
  420         case 'D':                       /* 16-bit selector */
  421             *(u_short *)stack = GSEL(GBIOSDATA_SEL, SEL_KPL);
  422             stack += 2;
  423             break;
  424 
  425         case 'C':                       /* 16-bit selector */
  426             *(u_short *)stack = GSEL(GBIOSCODE16_SEL, SEL_KPL);
  427             stack += 2;
  428             break;
  429 
  430         case 's':                       /* 16-bit integer */
  431             i = va_arg(ap, u_short);
  432             *(u_short *)stack = i;
  433             stack += 2;
  434             break;
  435 
  436         default:
  437             return (EINVAL);
  438         }
  439     }
  440 
  441     set_bios_selectors(&args->seg, flags);
  442     bioscall_vector.vec16.offset = (u_short)args->entry;
  443     bioscall_vector.vec16.segment = GSEL(GBIOSCODE16_SEL, SEL_KPL);
  444 
  445     i = bios16_call(&args->r, stack_top);
  446     
  447     if (pte == PTmap) {
  448         *pte = 0;                       /* remove entry */
  449     } else {
  450         *ptd = 0;                       /* remove page table */
  451         free(pte, M_TEMP);              /* ... and free it */
  452     }
  453 
  454     /*
  455      * XXX only needs to be invlpg(0) but that doesn't work on the 386 
  456      */
  457     invltlb();
  458 
  459     return (i);
  460 }
  461 
  462 #ifdef PNPBIOS                  /* remove conditional later */
  463 
  464 /*
  465  * PnP BIOS interface; enumerate devices only known to the system
  466  * BIOS and save information about them for later use.
  467  */
  468 
  469 struct pnp_sysdev 
  470 {
  471     u_int16_t   size;
  472     u_int8_t    handle;
  473     u_int32_t   devid;
  474     u_int8_t    type[3];
  475     u_int16_t   attrib;
  476 #define PNPATTR_NODISABLE       (1<<0)  /* can't be disabled */
  477 #define PNPATTR_NOCONFIG        (1<<1)  /* can't be configured */
  478 #define PNPATTR_OUTPUT          (1<<2)  /* can be primary output */
  479 #define PNPATTR_INPUT           (1<<3)  /* can be primary input */
  480 #define PNPATTR_BOOTABLE        (1<<4)  /* can be booted from */
  481 #define PNPATTR_DOCK            (1<<5)  /* is a docking station */
  482 #define PNPATTR_REMOVEABLE      (1<<6)  /* device is removeable */
  483 #define PNPATTR_CONFIG_STATIC   0x00
  484 #define PNPATTR_CONFIG_DYNAMIC  0x07
  485 #define PNPATTR_CONFIG_DYNONLY  0x17
  486     /* device-specific data comes here */
  487     u_int8_t    devdata[0];
  488 } __attribute__ ((packed));
  489 
  490 /* We have to cluster arguments within a 64k range for the bios16 call */
  491 struct pnp_sysdevargs
  492 {
  493     u_int16_t   next;
  494     struct pnp_sysdev node;
  495 };
  496 
  497 /*
  498  * This function is called after the bus has assigned resource
  499  * locations for a logical device.
  500  */
  501 static void
  502 pnpbios_set_config(void *arg, struct isa_config *config, int enable)
  503 {
  504 }
  505 
  506 /*
  507  * Quiz the PnP BIOS, build a list of PNP IDs and resource data.
  508  */
  509 static void
  510 pnpbios_identify(driver_t *driver, device_t parent)
  511 {
  512     struct PnPBIOS_table        *pt = PnPBIOStable;
  513     struct bios_args            args;
  514     struct pnp_sysdev           *pd;
  515     struct pnp_sysdevargs       *pda;
  516     u_int16_t                   ndevs, bigdev;
  517     int                         error, currdev;
  518     u_int8_t                    *devnodebuf, tag;
  519     u_int32_t                   *devid, *compid;
  520     int                         idx, left;
  521     device_t                    dev;
  522         
  523     /* no PnP BIOS information */
  524     if (pt == NULL)
  525         return;
  526     
  527     bzero(&args, sizeof(args));
  528     args.seg.code16.base = BIOS_PADDRTOVADDR(pt->pmentrybase);
  529     args.seg.code16.limit = 0xffff;             /* XXX ? */
  530     args.seg.data.base = BIOS_PADDRTOVADDR(pt->pmdataseg);
  531     args.seg.data.limit = 0xffff;
  532     args.entry = pt->pmentryoffset;
  533     
  534     if ((error = bios16(&args, PNP_COUNT_DEVNODES, &ndevs, &bigdev)) || (args.r.eax & 0xff))
  535         printf("pnpbios: error %d/%x getting device count/size limit\n", error, args.r.eax);
  536     ndevs &= 0xff;                              /* clear high byte garbage */
  537     if (bootverbose)
  538         printf("pnpbios: %d devices, largest %d bytes\n", ndevs, bigdev);
  539 
  540     devnodebuf = malloc(bigdev + (sizeof(struct pnp_sysdevargs) - sizeof(struct pnp_sysdev)),
  541                         M_DEVBUF, M_NOWAIT);
  542     pda = (struct pnp_sysdevargs *)devnodebuf;
  543     pd = &pda->node;
  544 
  545     for (currdev = 0, left = ndevs; (currdev != 0xff) && (left > 0); left--) {
  546 
  547         bzero(pd, bigdev);
  548         pda->next = currdev;
  549         /* get current configuration */
  550         if ((error = bios16(&args, PNP_GET_DEVNODE, &pda->next, &pda->node, (u_int16_t)1))) {
  551             printf("pnpbios: error %d making BIOS16 call\n", error);
  552             break;
  553         }
  554         if ((error = (args.r.eax & 0xff))) {
  555             if (bootverbose)
  556                 printf("pnpbios: %s 0x%x fetching node %d\n", error & 0x80 ? "error" : "warning", error, currdev);
  557             if (error & 0x80) 
  558                 break;
  559         }
  560         currdev = pda->next;
  561         if (pd->size < sizeof(struct pnp_sysdev)) {
  562             printf("pnpbios: bogus system node data, aborting scan\n");
  563             break;
  564         }
  565         
  566         /*
  567          * If we are in APIC_IO mode, we should ignore the ISA PIC if it
  568          * shows up.  Likewise, in !APIC_IO mode, we should ignore the
  569          * APIC (less important).
  570          * This is significant because the ISA PIC will claim IRQ 2 (which
  571          * it uses for chaining), while in APIC mode this is a valid IRQ
  572          * available for general use.
  573          */
  574 #ifdef APIC_IO
  575         if (!strcmp(pnp_eisaformat(pd->devid), "PNP0000"))      /* ISA PIC */
  576             continue;
  577 #else
  578         if (!strcmp(pnp_eisaformat(pd->devid), "PNP0003"))      /* APIC */
  579             continue;
  580 #endif  
  581         
  582         /* Add the device and parse its resources */
  583         dev = BUS_ADD_CHILD(parent, ISA_ORDER_PNP, NULL, -1);
  584         isa_set_vendorid(dev, pd->devid);
  585         isa_set_logicalid(dev, pd->devid);
  586         ISA_SET_CONFIG_CALLBACK(parent, dev, pnpbios_set_config, 0);
  587         pnp_parse_resources(dev, &pd->devdata[0],
  588                             pd->size - sizeof(struct pnp_sysdev));
  589         if (!device_get_desc(dev))
  590             device_set_desc_copy(dev, pnp_eisaformat(pd->devid));
  591 
  592         /* Find device IDs */
  593         devid = &pd->devid;
  594         compid = NULL;
  595 
  596         /* look for a compatible device ID too */
  597         left = pd->size - sizeof(struct pnp_sysdev);
  598         idx = 0;
  599         while (idx < left) {
  600             tag = pd->devdata[idx++];
  601             if (PNP_RES_TYPE(tag) == 0) {
  602                 /* Small resource */
  603                 switch (PNP_SRES_NUM(tag)) {
  604                 case PNP_TAG_COMPAT_DEVICE:
  605                     compid = (u_int32_t *)(pd->devdata + idx);
  606                     if (bootverbose)
  607                         printf("pnpbios: node %d compat ID 0x%08x\n", pd->handle, *compid);
  608                     /* FALLTHROUGH */
  609                 case PNP_TAG_END:
  610                     idx = left;
  611                     break;
  612                 default:
  613                     idx += PNP_SRES_LEN(tag);
  614                     break;
  615                 }
  616             } else
  617                 /* Large resource, skip it */
  618                 idx += *(u_int16_t *)(pd->devdata + idx) + 2;
  619         }
  620         if (bootverbose) {
  621             printf("pnpbios: handle %d device ID %s (%08x)", 
  622                    pd->handle, pnp_eisaformat(*devid), *devid);
  623             if (compid != NULL)
  624                 printf(" compat ID %s (%08x)",
  625                        pnp_eisaformat(*compid), *compid);
  626             printf("\n");
  627         }
  628     }
  629 }
  630 
  631 static device_method_t pnpbios_methods[] = {
  632         /* Device interface */
  633         DEVMETHOD(device_identify,      pnpbios_identify),
  634 
  635         { 0, 0 }
  636 };
  637 
  638 static driver_t pnpbios_driver = {
  639         "pnpbios",
  640         pnpbios_methods,
  641         1,                      /* no softc */
  642 };
  643 
  644 static devclass_t pnpbios_devclass;
  645 
  646 DRIVER_MODULE(pnpbios, isa, pnpbios_driver, pnpbios_devclass, 0, 0);
  647 
  648 #endif /* PNPBIOS */

Cache object: 38721cf5d3bed6256871622d0da7c655


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