root/arch/i386/i386/bios.c

DEFINITIONS

1. biosprobe
2. biosattach
3. bios_getopt
4. bios_print
5. bios32_service
6. biosopen
7. biosclose
8. biosioctl
9. bioscnprobe
10. bioscninit
11. bioscnputc
12. bioscngetc
13. bioscnpollc
14. bios_sysctl
15. bios_getdiskinfo
16. smbios_find_table
17. smbios_get_string
18. fixstring
19. smbios_info

    1 /*      $OpenBSD: bios.c,v 1.70 2007/08/06 16:12:25 gwk Exp $   */
    3 /*
    4  * Copyright (c) 1997-2001 Michael Shalayeff
    5  * 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  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   19  * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
   20  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   22  * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   24  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
   25  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   26  * THE POSSIBILITY OF SUCH DAMAGE.
   27  */
   29 /* #define BIOS_DEBUG */
   31 #include <sys/param.h>
   32 #include <sys/systm.h>
   33 #include <sys/kernel.h>
   34 #include <sys/device.h>
   35 #include <sys/errno.h>
   36 #include <sys/proc.h>
   37 #include <sys/malloc.h>
   38 #include <sys/reboot.h>
   39 #include <sys/extent.h>
   41 #include <uvm/uvm_extern.h>
   42 #include <sys/sysctl.h>
   44 #include <dev/cons.h>
   45 #include <stand/boot/bootarg.h>
   47 #include <machine/cpu.h>
   48 #include <machine/pio.h>
   49 #include <machine/cpufunc.h>
   50 #include <machine/conf.h>
   51 #include <machine/gdt.h>
   52 #include <machine/pcb.h>
   53 #include <machine/biosvar.h>
   54 #include <machine/apmvar.h>
   55 #include <machine/smbiosvar.h>
   57 #include <dev/isa/isareg.h>
   58 #include <i386/isa/isa_machdep.h>
   60 #include "apm.h"
   61 #include "pcibios.h"
   62 #include "pci.h"
   64 struct bios_softc {
   65         struct  device sc_dev;
   66 };
   68 int biosprobe(struct device *, void *, void *);
   69 void biosattach(struct device *, struct device *, void *);
   70 int bios_print(void *, const char *);
   71 char *fixstring(char *);
   73 struct cfattach bios_ca = {
   74         sizeof(struct bios_softc), biosprobe, biosattach
   75 };
   77 struct cfdriver bios_cd = {
NULL, "bios", DV_DULL
   79 };
   81 extern dev_t bootdev;
   83 #if NAPM > 0 || defined(DEBUG)
bios_apminfo_t *apm;
   85 #endif
   86 #if NPCI > 0
bios_pciinfo_t *bios_pciinfo;
   88 #endif
bios_diskinfo_t *bios_diskinfo;
bios_memmap_t  *bios_memmap;
u_int32_t       bios_cksumlen;
   92 struct bios32_entry bios32_entry;
   93 struct smbios_entry smbios_entry;
   94 #ifdef MULTIPROCESSOR
   95 void            *bios_smpinfo;
   96 #endif
   97 #ifdef NFSCLIENT
bios_bootmac_t  *bios_bootmac;
   99 #endif
  101 void            smbios_info(char*);
bios_diskinfo_t *bios_getdiskinfo(dev_t);
  105 /*
  106  * used by hw_sysctl
  107  */
  108 extern char *hw_vendor, *hw_prod, *hw_uuid, *hw_serial, *hw_ver;
  109 const char *smbios_uninfo[] = {
  110         "System",
  111         "Not ",
  112         "To be",
  113         "SYS-"
  114 };
  117 int
biosprobe(struct device *parent, void *match, void *aux)
  119 {
  120         struct bios_attach_args *bia = aux;
  122 #ifdef BIOS_DEBUG
printf("%s%d: boot API ver %x, %x; args %p[%d]\n",
bia->bios_dev, bios_cd.cd_ndevs,
bootapiver, BOOTARG_APIVER, bootargp, bootargc);
  126 #endif
  127         /* there could be only one */
  128         if (bios_cd.cd_ndevs || strcmp(bia->bios_dev, bios_cd.cd_name))
  129                 return 0;
  131         if (!(bootapiver & BAPIV_VECTOR) || bootargp == NULL)
  132                 return 0;
  134         return 1;
  135 }
  137 void
biosattach(struct device *parent, struct device *self, void *aux)
  139 {
  140         struct bios_softc *sc = (struct bios_softc *)self;
  141 #if (NPCI > 0 && NPCIBIOS > 0) || NAPM > 0
  142         struct bios_attach_args *bia = aux;
  143 #endif
  144         struct smbios_struct_bios *sb;
  145         struct smbtable bios;
  146         volatile u_int8_t *va;
  147         char scratch[64], *str;
  148         int flags;
  150         /* remember flags */
flags = sc->sc_dev.dv_cfdata->cf_flags;
va = ISA_HOLE_VADDR(0xffff0);
  154         switch (va[14]) {
  155         default:
  156         case 0xff: str = "PC";          break;
  157         case 0xfe: str = "PC/XT";       break;
  158         case 0xfd: str = "PCjr";        break;
  159         case 0xfc: str = "AT/286+";     break;
  160         case 0xfb: str = "PC/XT+";      break;
  161         case 0xfa: str = "PS/2 25/30";  break;
  162         case 0xf9: str = "PC Convertible";break;
  163         case 0xf8: str = "PS/2 386+";   break;
  164         }
printf(": %s BIOS, date %c%c/%c%c/%c%c",
str, va[5], va[6], va[8], va[9], va[11], va[12]);
  168         /*
  169          * Determining whether BIOS32 extensions are available is
  170          * done by searching for the BIOS32 service directory.
  171          * This 16-byte structure can be found somewhere in the
  172          * range 0E0000h - 0FFFFFh and must be 16-byte aligned.
  173          *
  174          *  _______________________________________________________
  175          * | Offset | Bytes | Description                          |
  176          * |-------------------------------------------------------|
  177          * |    0   |   4   | ASCII signature string of "_32_".    |
  178          * |    4   |   4   | 32-bit entry point.                  |
  179          * |    8   |   1   | Revision Level. Typically 00h.       |
  180          * |    9   |   1   | Header length in 16-byte units. So   |
  181          * |        |       | would have the value of 01h.         |
  182          * |    A   |   1   | Checksum. The sum of all bytes in    |
  183          * |        |       | this header must be zero.            |
  184          * |    B   |   5   | Reserved. Set to zero.               |
  185          *  -------------------------------------------------------
  186          *
  187          * To find the service directory, we first search for the
  188          * signature. If we find a match, we must also verify the
  189          * checksum. This service directory may then be used to
  190          * determine whether a PCI BIOS is present.
  191          *
  192          * For more information see the PCI BIOS Specification,
  193          * Revision 2.1 (August 26, 1994).
  194          */
  196         if (!(flags & BIOSF_BIOS32)) {
  197                 for (va = ISA_HOLE_VADDR(BIOS32_START);
va < (u_int8_t *)ISA_HOLE_VADDR(BIOS32_END); va += 16) {
bios32_header_t h = (bios32_header_t)va;
u_int8_t cksum;
  201                         int i;
  203                         if (h->signature != BIOS32_SIGNATURE)
  204                                 continue;
  206                         /* verify checksum */
  207                         for (cksum = 0, i = h->length * 16; i--; cksum += va[i])
  208                                 ;
  209                         if (cksum != 0)
  210                                 continue;
  212                         if (h->entry <= BIOS32_START || h->entry >= BIOS32_END)
  213                                 continue;
bios32_entry.segment = GSEL(GCODE_SEL, SEL_KPL);
bios32_entry.offset = (u_int32_t)ISA_HOLE_VADDR(h->entry);
printf(", BIOS32 rev. %d @ 0x%lx", h->rev, h->entry);
  218                         break;
  219                 }
  220         }
  222         /* see if we have SMBIOS extensions */
  223         if (!(flags & BIOSF_SMBIOS)) {
  224                 for (va = ISA_HOLE_VADDR(SMBIOS_START);
va < (u_int8_t *)ISA_HOLE_VADDR(SMBIOS_END); va+= 16) {
  226                         struct smbhdr * sh = (struct smbhdr *)va;
u_int8_t chksum;
vaddr_t eva;
paddr_t pa, end;
  230                         int i;
  232                         if (sh->sig != SMBIOS_SIGNATURE)
  233                                 continue;
i = sh->len;
  235                         for (chksum = 0; i--; chksum += va[i])
  236                                 ;
  237                         if (chksum != 0)
  238                                 continue;
va += 0x10;
  240                         if (va[0] != '_' && va[1] != 'D' && va[2] != 'M' &&
va[3] != 'I' && va[4] != '_')
  242                                 continue;
  243                         for (chksum = 0, i = 0xf; i--; chksum += va[i]);
  244                                 ;
  245                         if (chksum != 0)
  246                                 continue;
pa = trunc_page(sh->addr);
end = round_page(sh->addr + sh->size);
eva = uvm_km_valloc(kernel_map, end-pa);
  251                         if (eva == 0)
  252                                 break;
smbios_entry.addr = (u_int8_t *)(eva +
  255                             (sh->addr & PGOFSET));
smbios_entry.len = sh->size;
smbios_entry.mjr = sh->majrev;
smbios_entry.min = sh->minrev;
smbios_entry.count = sh->count;
  261                         for (; pa < end; pa+= NBPG, eva+= NBPG)
pmap_kenter_pa(eva, pa, VM_PROT_READ);
printf(", SMBIOS rev. %d.%d @ 0x%lx (%d entries)",
sh->majrev, sh->minrev, sh->addr, sh->count);
bios.cookie = 0;
  268                         if (smbios_find_table(SMBIOS_TYPE_BIOS, &bios)) {
sb = bios.tblhdr;
printf("\n%s:", sc->sc_dev.dv_xname);
  272                                 if ((smbios_get_string(&bios, sb->vendor,
scratch, sizeof(scratch))) != NULL)
printf(" vendor %s", scratch);
  275                                 if ((smbios_get_string(&bios, sb->version,
scratch, sizeof(scratch))) != NULL)
printf(" version \"%s\"", scratch);
  278                                 if ((smbios_get_string(&bios, sb->release,
scratch, sizeof(scratch))) != NULL)
printf(" date %s", scratch);
  281                         }
smbios_info(sc->sc_dev.dv_xname);
  283                         break;
  284                 }
  285         }
printf("\n");
  289 #if NAPM > 0
  290         if (apm) {
  291                 struct bios_attach_args ba;
  292 #if defined(DEBUG) || defined(APMDEBUG)
printf("apminfo: %x, code %x[%x]/%x[%x], data %x[%x], ept %x\n",
apm->apm_detail,
apm->apm_code32_base, apm->apm_code_len,
apm->apm_code16_base, apm->apm_code16_len,
apm->apm_data_base, apm->apm_data_len, apm->apm_entry);
  298 #endif
ba.bios_dev = "apm";
ba.bios_func = 0x15;
ba.bios_memt = bia->bios_memt;
ba.bios_iot = bia->bios_iot;
ba.bios_apmp = apm;
config_found(self, &ba, bios_print);
  305         }
  306 #endif
  307 #if NPCI > 0 && NPCIBIOS > 0
  308         if (!(flags & BIOSF_PCIBIOS)) {
  309                 struct bios_attach_args ba;
ba.bios_dev = "pcibios";
ba.bios_func = 0x1A;
ba.bios_memt = bia->bios_memt;
ba.bios_iot = bia->bios_iot;
config_found(self, &ba, bios_print);
  316         }
  317 #endif
  319         /*
  320          * now that we gave 'em a chance to attach,
  321          * scan and map all the proms we can find
  322          */
  323         if (!(flags & BIOSF_PROMSCAN)) {
  324                 volatile u_int8_t *eva;
  326                 for (str = NULL, va = ISA_HOLE_VADDR(0xc0000),
eva = ISA_HOLE_VADDR(0xf0000);
va < eva; va += 512) {
  329                         extern struct extent *iomem_ex;
bios_romheader_t romh = (bios_romheader_t)va;
u_int32_t off, len;
u_int8_t cksum;
  333                         int i;
  335                         if (romh->signature != 0xaa55)
  336                                 continue;
  338                         /*
  339                          * for this and the next check we probably want
  340                          * to reserve the page in the extent anyway
  341                          */
  342                         if (!romh->len || romh->len == 0xff)
  343                                 continue;
len = romh->len * 512;
  346                         if (va + len > eva)
  347                                 continue;
  349                         for (cksum = 0, i = len; i--; cksum += va[i])
  350                                 ;
  351 #ifdef __stinkpad_sucks__
  352                         if (cksum != 0)
  353                                 continue;
  354 #endif
off = 0xc0000 + (va - (u_int8_t *)
ISA_HOLE_VADDR(0xc0000));
  359                         if (!str)
printf("%s: ROM list:",
str = sc->sc_dev.dv_xname);
printf(" 0x%05x/0x%x%s", off, len,
cksum? "!" : "");
  365                         if ((i = extent_alloc_region(iomem_ex,
  366                             (paddr_t)off, len, EX_NOWAIT)))
printf(":%d", i);
va += len - 512;
  370                 }
  371         }
  373         if (str)
printf("\n");
  375 }
  377 void
bios_getopt()
  379 {
bootarg_t *q;
  382 #ifdef BIOS_DEBUG
printf("bootargv:");
  384 #endif
  386         for(q = bootargp; q->ba_type != BOOTARG_END; q = q->ba_next) {
q->ba_next = (bootarg_t *)((caddr_t)q + q->ba_size);
  388                 switch (q->ba_type) {
  389                 case BOOTARG_MEMMAP:
bios_memmap = (bios_memmap_t *)q->ba_arg;
  391 #ifdef BIOS_DEBUG
printf(" memmap %p", bios_memmap);
  393 #endif
  394                         break;
  395                 case BOOTARG_DISKINFO:
bios_diskinfo = (bios_diskinfo_t *)q->ba_arg;
  397 #ifdef BIOS_DEBUG
printf(" diskinfo %p", bios_diskinfo);
  399 #endif
  400                         break;
  401 #if NAPM > 0 || defined(DEBUG)
  402                 case BOOTARG_APMINFO:
  403 #ifdef BIOS_DEBUG
printf(" apminfo %p", q->ba_arg);
  405 #endif
apm = (bios_apminfo_t *)q->ba_arg;
  407                         break;
  408 #endif
  409                 case BOOTARG_CKSUMLEN:
bios_cksumlen = *(u_int32_t *)q->ba_arg;
  411 #ifdef BIOS_DEBUG
printf(" cksumlen %d", bios_cksumlen);
  413 #endif
  414                         break;
  415 #if NPCI > 0
  416                 case BOOTARG_PCIINFO:
bios_pciinfo = (bios_pciinfo_t *)q->ba_arg;
  418 #ifdef BIOS_DEBUG
printf(" pciinfo %p", bios_pciinfo);
  420 #endif
  421                         break;
  422 #endif
  423                 case BOOTARG_CONSDEV:
  424                         if (q->ba_size >= sizeof(bios_consdev_t))
  425                         {
bios_consdev_t *cdp = (bios_consdev_t*)q->ba_arg;
  427 #include "com.h"
  428 #include "pccom.h"
  429 #if NCOM + NPCCOM > 0
  430                                 extern int comdefaultrate; /* ic/com.c */
comdefaultrate = cdp->conspeed;
  432 #endif
  433 #ifdef BIOS_DEBUG
printf(" console 0x%x:%d",
cdp->consdev, cdp->conspeed);
  436 #endif
cnset(cdp->consdev);
  438                         }
  439                         break;
  440 #ifdef MULTIPROCESSOR
  441                 case BOOTARG_SMPINFO:
bios_smpinfo = q->ba_arg;
printf(" smpinfo %p", bios_smpinfo);
  444                         break;
  445 #endif
  447 #ifdef NFSCLIENT
  448                 case BOOTARG_BOOTMAC:
bios_bootmac = (bios_bootmac_t *)q->ba_arg;
  450                         break;
  451 #endif
  453                 default:
  454 #ifdef BIOS_DEBUG
printf(" unsupported arg (%d) %p", q->ba_type,
q->ba_arg);
  457 #endif
  458                         break;
  459                 }
  460         }
printf("\n");
  463 }
  465 int
bios_print(void *aux, const char *pnp)
  467 {
  468         struct bios_attach_args *ba = aux;
  470         if (pnp)
printf("%s at %s function 0x%x",
ba->bios_dev, pnp, ba->bios_func);
  473         return (UNCONF);
  474 }
  476 int
bios32_service(u_int32_t service, bios32_entry_t e, bios32_entry_info_t ei)
  478 {
u_long pa, endpa;
vaddr_t va, sva;
u_int32_t base, count, off, ent;
  482         int slot;
  484         if (bios32_entry.offset == 0)
  485                 return 0;
base = 0;
  488         __asm __volatile("lcall *(%4)"
  489             : "+a" (service), "+b" (base), "=c" (count), "=d" (off)
  490             : "D" (&bios32_entry)
  491             : "%esi", "cc", "memory");
  493         if (service & 0xff)
  494                 return 0;       /* not found */
ent = base + off;
  497         if (ent <= BIOS32_START || ent >= BIOS32_END)
  498                 return 0;
endpa = round_page(BIOS32_END);
sva = va = uvm_km_valloc(kernel_map, endpa);
  504         if (va == 0)
  505                 return (0);
slot = gdt_get_slot();
setgdt(slot, (caddr_t)va, BIOS32_END, SDT_MEMERA, SEL_KPL, 1, 0);
  510         for (pa = trunc_page(BIOS32_START),
va += trunc_page(BIOS32_START);
pa < endpa; pa += NBPG, va += NBPG) {
pmap_enter(pmap_kernel(), va, pa,
VM_PROT_READ | VM_PROT_WRITE,
VM_PROT_READ | VM_PROT_WRITE | PMAP_WIRED);
  517                 /* for all you, broken hearted */
  518                 if (pa >= trunc_page(base)) {
pmap_enter(pmap_kernel(), sva, pa,
VM_PROT_READ | VM_PROT_WRITE,
VM_PROT_READ | VM_PROT_WRITE | PMAP_WIRED);
sva += NBPG;
  523                 }
  524         }
e->segment = GSEL(slot, SEL_KPL);
e->offset = (vaddr_t)ent;
ei->bei_base = base;
ei->bei_size = count;
ei->bei_entry = ent;
  533         return 1;
  534 }
  536 int
biosopen(dev_t dev, int flag, int mode, struct proc *p)
  538 {
  539         struct bios_softc *sc = bios_cd.cd_devs[0];
  541         if (minor(dev))
  542                 return (ENXIO);
  544         (void)sc;
  546         return 0;
  547 }
  549 int
biosclose(dev_t dev, int flag, int mode, struct proc *p)
  551 {
  552         struct bios_softc *sc = bios_cd.cd_devs[0];
  554         if (minor(dev))
  555                 return (ENXIO);
  557         (void)sc;
  559         return 0;
  560 }
  562 int
biosioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
  564 {
  565         struct bios_softc *sc = bios_cd.cd_devs[0];
  567         if (minor(dev))
  568                 return (ENXIO);
  570         switch (cmd) {
  571         default:
  572                 return ENXIO;
  573         }
  575         (void)sc;
  577         return 0;
  578 }
  580 void
bioscnprobe(struct consdev *cn)
  582 {
  583 #if 0
bios_init(I386_BUS_SPACE_MEM); /* XXX */
  585         if (!bios_cd.cd_ndevs)
  586                 return;
  588         if (0 && bios_call(BOOTC_CHECK, NULL))
  589                 return;
cn->cn_pri = CN_NORMAL;
cn->cn_dev = makedev(48, 0);
  593 #endif
  594 }
  596 void
bioscninit(struct consdev *cn)
  598 {
  600 }
  602 void
bioscnputc(dev_t dev, int ch)
  604 {
  606 }
  608 int
bioscngetc(dev_t dev)
  610 {
  611         return -1;
  612 }
  614 void
bioscnpollc(dev_t dev, int on)
  616 {
  617 }
  619 int
bios_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen, struct proc *p)
  622 {
bios_diskinfo_t *pdi;
  624         int biosdev;
  626         /* all sysctl names at this level except diskinfo are terminal */
  627         if (namelen != 1 && name[0] != BIOS_DISKINFO)
  628                 return (ENOTDIR);               /* overloaded */
  630         if (!(bootapiver & BAPIV_VECTOR))
  631                 return EOPNOTSUPP;
  633         switch (name[0]) {
  634         case BIOS_DEV:
  635                 if ((pdi = bios_getdiskinfo(bootdev)) == NULL)
  636                         return ENXIO;
biosdev = pdi->bios_number;
  638                 return sysctl_rdint(oldp, oldlenp, newp, biosdev);
  639         case BIOS_DISKINFO:
  640                 if (namelen != 2)
  641                         return ENOTDIR;
  642                 if ((pdi = bios_getdiskinfo(name[1])) == NULL)
  643                         return ENXIO;
  644                 return sysctl_rdstruct(oldp, oldlenp, newp, pdi, sizeof(*pdi));
  645         case BIOS_CKSUMLEN:
  646                 return sysctl_rdint(oldp, oldlenp, newp, bios_cksumlen);
  647         default:
  648                 return EOPNOTSUPP;
  649         }
  650         /* NOTREACHED */
  651 }
bios_diskinfo_t *
bios_getdiskinfo(dev_t dev)
  655 {
bios_diskinfo_t *pdi;
  658         if (bios_diskinfo == NULL)
  659                 return NULL;
  661         for (pdi = bios_diskinfo; pdi->bios_number != -1; pdi++) {
  662                 if ((dev & B_MAGICMASK) == B_DEVMAGIC) { /* search by bootdev */
  663                         if (pdi->bsd_dev == dev)
  664                                 break;
  665                 } else {
  666                         if (pdi->bios_number == dev)
  667                                 break;
  668                 }
  669         }
  671         if (pdi->bios_number == -1)
  672                 return NULL;
  673         else
  674                 return pdi;
  675 }
  677 /*
  678  * smbios_find_table() takes a caller supplied smbios struct type and
  679  * a pointer to a handle (struct smbtable) returning one if the structure
  680  * is sucessfully located and zero otherwise. Callers should take care
  681  * to initialize the cookie field of the smbtable structure to zero before
  682  * the first invocation of this function.
  683  * Multiple tables of the same type can be located by repeatedly calling
  684  * smbios_find_table with the same arguments.
  685  */
  686 int
smbios_find_table(u_int8_t type, struct smbtable *st)
  688 {
u_int8_t *va, *end;
  690         struct smbtblhdr *hdr;
  691         int ret = 0, tcount = 1;
va = smbios_entry.addr;
end = va + smbios_entry.len;
  696         /*
  697          * The cookie field of the smtable structure is used to locate
  698          * multiple instances of a table of an arbitrary type. Following the
  699          * sucessful location of a table, the type is encoded as bits 0:7 of
  700          * the cookie value, the offset in terms of the number of structures
  701          * preceding that referenced by the handle is encoded in bits 15:31.
  702          */
  703         if ((st->cookie & 0xfff) == type && st->cookie >> 16) {
  704                 if ((u_int8_t *)st->hdr >= va && (u_int8_t *)st->hdr < end) {
hdr = st->hdr;
  706                         if (hdr->type == type) {
va = (u_int8_t *)hdr + hdr->size;
  708                                 for (; va + 1 < end; va++)
  709                                         if (*va == NULL && *(va + 1) == NULL)
  710                                                 break;
va+= 2;
tcount = st->cookie >> 16;
  713                         }
  714                 }
  715         }
  716         for (; va + sizeof(struct smbtblhdr) < end && tcount <=
smbios_entry.count; tcount++) {
hdr = (struct smbtblhdr *)va;
  719                 if (hdr->type == type) {
ret = 1;
st->hdr = hdr;
st->tblhdr = va + sizeof(struct smbtblhdr);
st->cookie = (tcount + 1) << 16 | type;
  724                         break;
  725                 }
  726                 if (hdr->type == SMBIOS_TYPE_EOT)
  727                         break;
va+= hdr->size;
  729                 for (; va + 1 < end; va++)
  730                         if (*va == NULL && *(va + 1) == NULL)
  731                                 break;
va+=2;
  733         }
  735         return ret;
  736 }
  738 char *
smbios_get_string(struct smbtable *st, u_int8_t indx, char *dest, size_t len)
  740 {
u_int8_t *va, *end;
  742         char *ret = NULL;
  743         int i;
va = (u_int8_t *)st->hdr + st->hdr->size;
end = smbios_entry.addr + smbios_entry.len;
  747         for (i = 1; va < end && i < indx && *va; i++)
  748                 while (*va++)
  749                         ;
  750         if (i == indx) {
  751                 if (va + len < end) {
ret = dest;
bcopy(va, ret, len);
ret[len - 1] = '\0';
  755                 }
  756         }
  758         return ret;
  759 }
  761 char *
fixstring(char *s)
  763 {
  764         char *p, *e;
  765         int i;
  767         for (i= 0; i < sizeof(smbios_uninfo)/sizeof(smbios_uninfo[0]); i++)
  768                 if ((strncasecmp(s, smbios_uninfo[i], strlen(smbios_uninfo[i])))==0)
  769                         return NULL;
  770         /*
  771          * Remove leading and trailing whitespace
  772          */
  773         for (p = s; *p == ' '; p++)
  774                 ;
  775         /*
  776          * Special case entire string is whitespace
  777          */
  778         if (p == s + strlen(s))
  779                 return NULL;
  780         for (e = s + strlen(s) - 1; e > s && *e == ' '; e--)
  781                 ;
  782         if (p > s || e < s + strlen(s) - 1) {
bcopy(p, s, e-p + 1);
s[e - p + 1] = '\0';
  785         }
  787         return s;
  788 }
  790 void
smbios_info(char * str)
  792 {
  793         char *sminfop, sminfo[64];
  794         struct smbtable stbl, btbl;
  795         struct smbios_sys *sys;
  796         struct smbios_board *board;
  797         int i, infolen, uuidf, havebb;
  798         char *p;
  800         if (smbios_entry.mjr < 2)
  801                 return;
  802         /*
  803          * According to the spec the system table among others is required,
  804          * if it is not we do not bother with this smbios implementation.
  805          */
stbl.cookie = btbl.cookie = 0;
  807         if (!smbios_find_table(SMBIOS_TYPE_SYSTEM, &stbl))
  808                 return;
havebb = smbios_find_table(SMBIOS_TYPE_BASEBOARD, &btbl);
sys = (struct smbios_sys *)stbl.tblhdr;
  812         if (havebb)
board = (struct smbios_board *)btbl.tblhdr;
  814         /*
  815          * Some smbios implementations have no system vendor or product strings,
  816          * some have very uninformative data which is harder to work around
  817          * and we must rely upon various heuristics to detect this. In both
  818          * cases we attempt to fall back on the base board information in the
  819          * perhaps naive belief that motherboard vendors will supply this
  820          * information.
  821          */
sminfop = NULL;
  823         if ((p = smbios_get_string(&stbl, sys->vendor, sminfo,
  824             sizeof(sminfo))) != NULL)
sminfop = fixstring(p);
  826         if (sminfop == NULL) {
  827                 if (havebb) {
  828                         if ((p = smbios_get_string(&btbl, board->vendor,
sminfo, sizeof(sminfo))) != NULL)
sminfop = fixstring(p);
  831                 }
  832         }
  833         if (sminfop) {
infolen = strlen(sminfop) + 1;
hw_vendor = malloc(infolen, M_DEVBUF, M_NOWAIT);
  836                 if (hw_vendor)
strlcpy(hw_vendor, sminfop, infolen);
sminfop = NULL;
  839         }
  840         if ((p = smbios_get_string(&stbl, sys->product, sminfo,
  841             sizeof(sminfo))) != NULL)
sminfop = fixstring(p);
  843         if (sminfop == NULL) {
  844                 if (havebb) {
  845                         if ((p = smbios_get_string(&btbl, board->product,
sminfo, sizeof(sminfo))) != NULL)
sminfop = fixstring(p);
  848                 }
  849         }
  850         if (sminfop) {
infolen = strlen(sminfop) + 1;
hw_prod = malloc(infolen, M_DEVBUF, M_NOWAIT);
  853                 if (hw_prod)
strlcpy(hw_prod, sminfop, infolen);
sminfop = NULL;
  856         }
  857         if (hw_vendor != NULL && hw_prod != NULL)
printf("\n%s: %s %s", str, hw_vendor, hw_prod);
  859         if ((p = smbios_get_string(&stbl, sys->version, sminfo,
  860             sizeof(sminfo))) != NULL)
sminfop = fixstring(p);
  862         if (sminfop) {
infolen = strlen(sminfop) + 1;
hw_ver = malloc(infolen, M_DEVBUF, M_NOWAIT);
  865                 if (hw_ver)
strlcpy(hw_ver, sminfop, infolen);
sminfop = NULL;
  868         }
  869         if ((p = smbios_get_string(&stbl, sys->serial, sminfo,
  870             sizeof(sminfo))) != NULL)
sminfop = fixstring(p);
  872         if (sminfop) {
infolen = strlen(sminfop) + 1;
hw_serial = malloc(infolen, M_DEVBUF, M_NOWAIT);
  875                 if (hw_serial)
strlcpy(hw_serial, sminfop, infolen);
  877         }
  878         if (smbios_entry.mjr > 2 || (smbios_entry.mjr == 2 &&
smbios_entry.min >= 1)) {
  880                 /*
  881                  * If the uuid value is all 0xff the uuid is present but not
  882                  * set, if its all 0 then the uuid isn't present at all.
  883                  */
uuidf |= SMBIOS_UUID_NPRESENT|SMBIOS_UUID_NSET;
  885                 for (i = 0; i < sizeof(sys->uuid); i++) {
  886                         if (sys->uuid[i] != 0xff)
uuidf &= ~SMBIOS_UUID_NSET;
  888                         if (sys->uuid[i] != 0)
uuidf &= ~SMBIOS_UUID_NPRESENT;
  890                 }
  892                 if (uuidf & SMBIOS_UUID_NPRESENT)
hw_uuid = NULL;
  894                 else if (uuidf & SMBIOS_UUID_NSET)
hw_uuid = "Not Set";
  896                 else {
hw_uuid = malloc(SMBIOS_UUID_REPLEN, M_DEVBUF,
M_NOWAIT);
  899                         if (hw_uuid) {
snprintf(hw_uuid, SMBIOS_UUID_REPLEN,
SMBIOS_UUID_REP,
sys->uuid[0], sys->uuid[1], sys->uuid[2],
sys->uuid[3], sys->uuid[4], sys->uuid[5],
sys->uuid[6], sys->uuid[7], sys->uuid[8],
sys->uuid[9], sys->uuid[10], sys->uuid[11],
sys->uuid[12], sys->uuid[13], sys->uuid[14],
sys->uuid[15]);
  908                         }
  909                 }
  910         }
  911 }