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