sys/compat/x86bios/x86bios.c

   1 /*-
   2  * Copyright (c) 2009 Alex Keda <admin@lissyara.su>
   3  * Copyright (c) 2009-2010 Jung-uk Kim <jkim@FreeBSD.org>
   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
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include "opt_x86bios.h"
  32
  33 #include <sys/param.h>
  34 #include <sys/bus.h>
  35 #include <sys/kernel.h>
  36 #include <sys/lock.h>
  37 #include <sys/malloc.h>
  38 #include <sys/module.h>
  39 #include <sys/mutex.h>
  40 #include <sys/proc.h>
  41 #include <sys/sysctl.h>
  42
  43 #include <contrib/x86emu/x86emu.h>
  44 #include <contrib/x86emu/x86emu_regs.h>
  45 #include <compat/x86bios/x86bios.h>
  46
  47 #include <dev/pci/pcireg.h>
  48 #include <dev/pci/pcivar.h>
  49
  50 #include <machine/cpufunc.h>
  51
  52 #include <vm/vm.h>
  53 #include <vm/pmap.h>
  54
  55 #define X86BIOS_PAGE_SIZE       0x00001000      /* 4K */
  56
  57 #define X86BIOS_IVT_SIZE        0x00000500      /* 1K + 256 (BDA) */
  58 #define X86BIOS_SEG_SIZE        0x00010000      /* 64K */
  59 #define X86BIOS_MEM_SIZE        0x00100000      /* 1M */
  60
  61 #define X86BIOS_IVT_BASE        0x00000000
  62 #define X86BIOS_RAM_BASE        0x00001000
  63 #define X86BIOS_ROM_BASE        0x000a0000
  64
  65 #define X86BIOS_ROM_SIZE        (X86BIOS_MEM_SIZE - (uint32_t)x86bios_rom_phys)
  66
  67 #define X86BIOS_PAGES           (X86BIOS_MEM_SIZE / X86BIOS_PAGE_SIZE)
  68
  69 #define X86BIOS_R_DS            _pad1
  70 #define X86BIOS_R_SS            _pad2
  71
  72 static struct x86emu x86bios_emu;
  73
  74 static struct mtx x86bios_lock;
  75
  76 static void *x86bios_ivt;
  77 static void *x86bios_rom;
  78 static void *x86bios_seg;
  79
  80 static vm_offset_t *x86bios_map;
  81
  82 static vm_paddr_t x86bios_rom_phys;
  83 static vm_paddr_t x86bios_seg_phys;
  84
  85 static int x86bios_fault;
  86 static uint32_t x86bios_fault_addr;
  87 static uint16_t x86bios_fault_cs;
  88 static uint16_t x86bios_fault_ip;
  89
  90 SYSCTL_NODE(_debug, OID_AUTO, x86bios, CTLFLAG_RD, NULL, "x86bios debugging");
  91 static int x86bios_trace_call;
  92 TUNABLE_INT("debug.x86bios.call", &x86bios_trace_call);
  93 SYSCTL_INT(_debug_x86bios, OID_AUTO, call, CTLFLAG_RW, &x86bios_trace_call, 0,
  94     "Trace far function calls");
  95 static int x86bios_trace_int;
  96 TUNABLE_INT("debug.x86bios.int", &x86bios_trace_int);
  97 SYSCTL_INT(_debug_x86bios, OID_AUTO, int, CTLFLAG_RW, &x86bios_trace_int, 0,
  98     "Trace software interrupt handlers");
  99
 100 static void
 101 x86bios_set_fault(struct x86emu *emu, uint32_t addr)
 102 {
 103
 104         x86bios_fault = 1;
 105         x86bios_fault_addr = addr;
 106         x86bios_fault_cs = emu->x86.R_CS;
 107         x86bios_fault_ip = emu->x86.R_IP;
 108         x86emu_halt_sys(emu);
 109 }
 110
 111 static void *
 112 x86bios_get_pages(uint32_t offset, size_t size)
 113 {
 114         vm_offset_t page;
 115
 116         if (offset + size > X86BIOS_MEM_SIZE + X86BIOS_IVT_SIZE)
 117                 return (NULL);
 118
 119         if (offset >= X86BIOS_MEM_SIZE)
 120                 offset -= X86BIOS_MEM_SIZE;
 121         page = x86bios_map[offset / X86BIOS_PAGE_SIZE];
 122         if (page != 0)
 123                 return ((void *)(page + offset % X86BIOS_PAGE_SIZE));
 124
 125         return (NULL);
 126 }
 127
 128 static void
 129 x86bios_set_pages(vm_offset_t va, vm_paddr_t pa, size_t size)
 130 {
 131         int i, j;
 132
 133         for (i = pa / X86BIOS_PAGE_SIZE, j = 0;
 134             j < howmany(size, X86BIOS_PAGE_SIZE); i++, j++)
 135                 x86bios_map[i] = va + j * X86BIOS_PAGE_SIZE;
 136 }
 137
 138 static uint8_t
 139 x86bios_emu_rdb(struct x86emu *emu, uint32_t addr)
 140 {
 141         uint8_t *va;
 142
 143         va = x86bios_get_pages(addr, sizeof(*va));
 144         if (va == NULL)
 145                 x86bios_set_fault(emu, addr);
 146
 147         return (*va);
 148 }
 149
 150 static uint16_t
 151 x86bios_emu_rdw(struct x86emu *emu, uint32_t addr)
 152 {
 153         uint16_t *va;
 154
 155         va = x86bios_get_pages(addr, sizeof(*va));
 156         if (va == NULL)
 157                 x86bios_set_fault(emu, addr);
 158
 159 #ifndef __NO_STRICT_ALIGNMENT
 160         if ((addr & 1) != 0)
 161                 return (le16dec(va));
 162         else
 163 #endif
 164         return (le16toh(*va));
 165 }
 166
 167 static uint32_t
 168 x86bios_emu_rdl(struct x86emu *emu, uint32_t addr)
 169 {
 170         uint32_t *va;
 171
 172         va = x86bios_get_pages(addr, sizeof(*va));
 173         if (va == NULL)
 174                 x86bios_set_fault(emu, addr);
 175
 176 #ifndef __NO_STRICT_ALIGNMENT
 177         if ((addr & 3) != 0)
 178                 return (le32dec(va));
 179         else
 180 #endif
 181         return (le32toh(*va));
 182 }
 183
 184 static void
 185 x86bios_emu_wrb(struct x86emu *emu, uint32_t addr, uint8_t val)
 186 {
 187         uint8_t *va;
 188
 189         va = x86bios_get_pages(addr, sizeof(*va));
 190         if (va == NULL)
 191                 x86bios_set_fault(emu, addr);
 192
 193         *va = val;
 194 }
 195
 196 static void
 197 x86bios_emu_wrw(struct x86emu *emu, uint32_t addr, uint16_t val)
 198 {
 199         uint16_t *va;
 200
 201         va = x86bios_get_pages(addr, sizeof(*va));
 202         if (va == NULL)
 203                 x86bios_set_fault(emu, addr);
 204
 205 #ifndef __NO_STRICT_ALIGNMENT
 206         if ((addr & 1) != 0)
 207                 le16enc(va, val);
 208         else
 209 #endif
 210         *va = htole16(val);
 211 }
 212
 213 static void
 214 x86bios_emu_wrl(struct x86emu *emu, uint32_t addr, uint32_t val)
 215 {
 216         uint32_t *va;
 217
 218         va = x86bios_get_pages(addr, sizeof(*va));
 219         if (va == NULL)
 220                 x86bios_set_fault(emu, addr);
 221
 222 #ifndef __NO_STRICT_ALIGNMENT
 223         if ((addr & 3) != 0)
 224                 le32enc(va, val);
 225         else
 226 #endif
 227         *va = htole32(val);
 228 }
 229
 230 static uint8_t
 231 x86bios_emu_inb(struct x86emu *emu, uint16_t port)
 232 {
 233
 234         if (port == 0xb2) /* APM scratch register */
 235                 return (0);
 236         if (port >= 0x80 && port < 0x88) /* POST status register */
 237                 return (0);
 238
 239         return (inb(port));
 240 }
 241
 242 static uint16_t
 243 x86bios_emu_inw(struct x86emu *emu, uint16_t port)
 244 {
 245
 246         if (port >= 0x80 && port < 0x88) /* POST status register */
 247                 return (0);
 248
 249         return (inw(port));
 250 }
 251
 252 static uint32_t
 253 x86bios_emu_inl(struct x86emu *emu, uint16_t port)
 254 {
 255
 256         if (port >= 0x80 && port < 0x88) /* POST status register */
 257                 return (0);
 258
 259         return (inl(port));
 260 }
 261
 262 static void
 263 x86bios_emu_outb(struct x86emu *emu, uint16_t port, uint8_t val)
 264 {
 265
 266         if (port == 0xb2) /* APM scratch register */
 267                 return;
 268         if (port >= 0x80 && port < 0x88) /* POST status register */
 269                 return;
 270
 271         outb(port, val);
 272 }
 273
 274 static void
 275 x86bios_emu_outw(struct x86emu *emu, uint16_t port, uint16_t val)
 276 {
 277
 278         if (port >= 0x80 && port < 0x88) /* POST status register */
 279                 return;
 280
 281         outw(port, val);
 282 }
 283
 284 static void
 285 x86bios_emu_outl(struct x86emu *emu, uint16_t port, uint32_t val)
 286 {
 287
 288         if (port >= 0x80 && port < 0x88) /* POST status register */
 289                 return;
 290
 291         outl(port, val);
 292 }
 293
 294 static void
 295 x86bios_emu_get_intr(struct x86emu *emu, int intno)
 296 {
 297         uint16_t *sp;
 298         uint32_t iv;
 299
 300         emu->x86.R_SP -= 6;
 301
 302         sp = (uint16_t *)((vm_offset_t)x86bios_seg + emu->x86.R_SP);
 303         sp[0] = htole16(emu->x86.R_IP);
 304         sp[1] = htole16(emu->x86.R_CS);
 305         sp[2] = htole16(emu->x86.R_FLG);
 306
 307         iv = x86bios_get_intr(intno);
 308         emu->x86.R_IP = iv & 0xffff;
 309         emu->x86.R_CS = (iv >> 16) & 0xffff;
 310         emu->x86.R_FLG &= ~(F_IF | F_TF);
 311 }
 312
 313 void *
 314 x86bios_alloc(uint32_t *offset, size_t size)
 315 {
 316         void *vaddr;
 317
 318         if (offset == NULL || size == 0)
 319                 return (NULL);
 320
 321         vaddr = contigmalloc(size, M_DEVBUF, M_NOWAIT, X86BIOS_RAM_BASE,
 322             x86bios_rom_phys, X86BIOS_PAGE_SIZE, 0);
 323         if (vaddr != NULL) {
 324                 *offset = vtophys(vaddr);
 325                 x86bios_set_pages((vm_offset_t)vaddr, *offset, size);
 326         }
 327
 328         return (vaddr);
 329 }
 330
 331 void
 332 x86bios_free(void *addr, size_t size)
 333 {
 334         vm_paddr_t paddr;
 335
 336         if (addr == NULL || size == 0)
 337                 return;
 338
 339         paddr = vtophys(addr);
 340         if (paddr < X86BIOS_RAM_BASE || paddr >= x86bios_rom_phys ||
 341             paddr % X86BIOS_PAGE_SIZE != 0)
 342                 return;
 343
 344         bzero(x86bios_map + paddr / X86BIOS_PAGE_SIZE,
 345             sizeof(*x86bios_map) * howmany(size, X86BIOS_PAGE_SIZE));
 346         contigfree(addr, size, M_DEVBUF);
 347 }
 348
 349 void
 350 x86bios_init_regs(struct x86regs *regs)
 351 {
 352
 353         bzero(regs, sizeof(*regs));
 354         regs->X86BIOS_R_DS = 0x40;
 355         regs->X86BIOS_R_SS = x86bios_seg_phys >> 4;
 356 }
 357
 358 void
 359 x86bios_call(struct x86regs *regs, uint16_t seg, uint16_t off)
 360 {
 361
 362         if (x86bios_map == NULL)
 363                 return;
 364
 365         if (x86bios_trace_call)
 366                 printf("Calling 0x%05x (ax=0x%04x bx=0x%04x "
 367                     "cx=0x%04x dx=0x%04x es=0x%04x di=0x%04x)\n",
 368                     (seg << 4) + off, regs->R_AX, regs->R_BX, regs->R_CX,
 369                     regs->R_DX, regs->R_ES, regs->R_DI);
 370
 371         mtx_lock_spin(&x86bios_lock);
 372         memcpy(&x86bios_emu.x86, regs, sizeof(*regs));
 373         x86bios_fault = 0;
 374         x86emu_exec_call(&x86bios_emu, seg, off);
 375         memcpy(regs, &x86bios_emu.x86, sizeof(*regs));
 376         mtx_unlock_spin(&x86bios_lock);
 377
 378         if (x86bios_trace_call) {
 379                 printf("Exiting 0x%05x (ax=0x%04x bx=0x%04x "
 380                     "cx=0x%04x dx=0x%04x es=0x%04x di=0x%04x)\n",
 381                     (seg << 4) + off, regs->R_AX, regs->R_BX, regs->R_CX,
 382                     regs->R_DX, regs->R_ES, regs->R_DI);
 383                 if (x86bios_fault)
 384                         printf("Page fault at 0x%05x from 0x%04x:0x%04x.\n",
 385                             x86bios_fault_addr, x86bios_fault_cs,
 386                             x86bios_fault_ip);
 387         }
 388 }
 389
 390 uint32_t
 391 x86bios_get_intr(int intno)
 392 {
 393         uint32_t *iv;
 394
 395         iv = (uint32_t *)((vm_offset_t)x86bios_ivt + intno * 4);
 396
 397         return (le32toh(*iv));
 398 }
 399
 400 void
 401 x86bios_intr(struct x86regs *regs, int intno)
 402 {
 403
 404         if (intno < 0 || intno > 255)
 405                 return;
 406
 407         if (x86bios_map == NULL)
 408                 return;
 409
 410         if (x86bios_trace_int)
 411                 printf("Calling int 0x%x (ax=0x%04x bx=0x%04x "
 412                     "cx=0x%04x dx=0x%04x es=0x%04x di=0x%04x)\n",
 413                     intno, regs->R_AX, regs->R_BX, regs->R_CX,
 414                     regs->R_DX, regs->R_ES, regs->R_DI);
 415
 416         mtx_lock_spin(&x86bios_lock);
 417         memcpy(&x86bios_emu.x86, regs, sizeof(*regs));
 418         x86bios_fault = 0;
 419         x86emu_exec_intr(&x86bios_emu, intno);
 420         memcpy(regs, &x86bios_emu.x86, sizeof(*regs));
 421         mtx_unlock_spin(&x86bios_lock);
 422
 423         if (x86bios_trace_int) {
 424                 printf("Exiting int 0x%x (ax=0x%04x bx=0x%04x "
 425                     "cx=0x%04x dx=0x%04x es=0x%04x di=0x%04x)\n",
 426                     intno, regs->R_AX, regs->R_BX, regs->R_CX,
 427                     regs->R_DX, regs->R_ES, regs->R_DI);
 428                 if (x86bios_fault)
 429                         printf("Page fault at 0x%05x from 0x%04x:0x%04x.\n",
 430                             x86bios_fault_addr, x86bios_fault_cs,
 431                             x86bios_fault_ip);
 432         }
 433 }
 434
 435 void *
 436 x86bios_offset(uint32_t offset)
 437 {
 438
 439         return (x86bios_get_pages(offset, 1));
 440 }
 441
 442 void *
 443 x86bios_get_orm(uint32_t offset)
 444 {
 445         uint8_t *p;
 446
 447         /* Does the shadow ROM contain BIOS POST code for x86? */
 448         p = x86bios_offset(offset);
 449         if (p == NULL || p[0] != 0x55 || p[1] != 0xaa || p[3] != 0xe9)
 450                 return (NULL);
 451
 452         return (p);
 453 }
 454
 455 int
 456 x86bios_match_device(uint32_t offset, device_t dev)
 457 {
 458         uint8_t *p;
 459         uint16_t device, vendor;
 460         uint8_t class, progif, subclass;
 461
 462         /* Does the shadow ROM contain BIOS POST code for x86? */
 463         p = x86bios_get_orm(offset);
 464         if (p == NULL)
 465                 return (0);
 466
 467         /* Does it contain PCI data structure? */
 468         p += le16toh(*(uint16_t *)(p + 0x18));
 469         if (bcmp(p, "PCIR", 4) != 0 ||
 470             le16toh(*(uint16_t *)(p + 0x0a)) < 0x18 || *(p + 0x14) != 0)
 471                 return (0);
 472
 473         /* Does it match the vendor, device, and classcode? */
 474         vendor = le16toh(*(uint16_t *)(p + 0x04));
 475         device = le16toh(*(uint16_t *)(p + 0x06));
 476         progif = *(p + 0x0d);
 477         subclass = *(p + 0x0e);
 478         class = *(p + 0x0f);
 479         if (vendor != pci_get_vendor(dev) || device != pci_get_device(dev) ||
 480             class != pci_get_class(dev) || subclass != pci_get_subclass(dev) ||
 481             progif != pci_get_progif(dev))
 482                 return (0);
 483
 484         return (1);
 485 }
 486
 487 #if defined(__amd64__) || (defined(__i386__) && !defined(PC98))
 488 #define PROBE_EBDA      1
 489 #else
 490 #define PROBE_EBDA      0
 491 #endif
 492
 493 static __inline int
 494 x86bios_map_mem(void)
 495 {
 496
 497         x86bios_ivt = pmap_mapbios(X86BIOS_IVT_BASE, X86BIOS_IVT_SIZE);
 498         if (x86bios_ivt == NULL)
 499                 return (1);
 500
 501 #if PROBE_EBDA
 502         /* Probe EBDA via BDA. */
 503         x86bios_rom_phys = *(uint16_t *)((vm_offset_t)x86bios_ivt + 0x40e);
 504         x86bios_rom_phys = le16toh(x86bios_rom_phys) << 4;
 505         if (x86bios_rom_phys != 0 && x86bios_rom_phys < X86BIOS_ROM_BASE &&
 506             X86BIOS_ROM_BASE - x86bios_rom_phys <= 128 * 1024)
 507                 x86bios_rom_phys =
 508                     rounddown(x86bios_rom_phys, X86BIOS_PAGE_SIZE);
 509         else
 510 #endif
 511         x86bios_rom_phys = X86BIOS_ROM_BASE;
 512         x86bios_rom = pmap_mapdev(x86bios_rom_phys, X86BIOS_ROM_SIZE);
 513         if (x86bios_rom == NULL) {
 514                 pmap_unmapdev((vm_offset_t)x86bios_ivt, X86BIOS_IVT_SIZE);
 515                 return (1);
 516         }
 517 #if PROBE_EBDA
 518         /* Change attribute for EBDA. */
 519         if (x86bios_rom_phys < X86BIOS_ROM_BASE &&
 520             pmap_change_attr((vm_offset_t)x86bios_rom,
 521             X86BIOS_ROM_BASE - x86bios_rom_phys, PAT_WRITE_BACK) != 0) {
 522                 pmap_unmapdev((vm_offset_t)x86bios_ivt, X86BIOS_IVT_SIZE);
 523                 pmap_unmapdev((vm_offset_t)x86bios_rom, X86BIOS_ROM_SIZE);
 524                 return (1);
 525         }
 526 #endif
 527
 528         x86bios_seg = contigmalloc(X86BIOS_SEG_SIZE, M_DEVBUF, M_WAITOK,
 529             X86BIOS_RAM_BASE, x86bios_rom_phys, X86BIOS_PAGE_SIZE, 0);
 530         x86bios_seg_phys = vtophys(x86bios_seg);
 531
 532         if (bootverbose) {
 533                 printf("x86bios:   IVT 0x%06x-0x%06x at %p\n",
 534                     X86BIOS_IVT_BASE, X86BIOS_IVT_SIZE + X86BIOS_IVT_BASE - 1,
 535                     x86bios_ivt);
 536                 printf("x86bios:  SSEG 0x%06x-0x%06x at %p\n",
 537                     (uint32_t)x86bios_seg_phys,
 538                     X86BIOS_SEG_SIZE + (uint32_t)x86bios_seg_phys - 1,
 539                     x86bios_seg);
 540 #if PROBE_EBDA
 541                 if (x86bios_rom_phys < X86BIOS_ROM_BASE)
 542                         printf("x86bios:  EBDA 0x%06x-0x%06x at %p\n",
 543                             (uint32_t)x86bios_rom_phys, X86BIOS_ROM_BASE - 1,
 544                             x86bios_rom);
 545 #endif
 546                 printf("x86bios:   ROM 0x%06x-0x%06x at %p\n",
 547                     X86BIOS_ROM_BASE, X86BIOS_MEM_SIZE - X86BIOS_SEG_SIZE - 1,
 548                     (void *)((vm_offset_t)x86bios_rom + X86BIOS_ROM_BASE -
 549                     (vm_offset_t)x86bios_rom_phys));
 550         }
 551
 552         return (0);
 553 }
 554
 555 #undef PROBE_EBDA
 556
 557 static __inline void
 558 x86bios_unmap_mem(void)
 559 {
 560
 561         pmap_unmapdev((vm_offset_t)x86bios_ivt, X86BIOS_IVT_SIZE);
 562         pmap_unmapdev((vm_offset_t)x86bios_rom, X86BIOS_ROM_SIZE);
 563         contigfree(x86bios_seg, X86BIOS_SEG_SIZE, M_DEVBUF);
 564 }
 565
 566 static void
 567 x86bios_init(void *arg __unused)
 568 {
 569         int i;
 570
 571         mtx_init(&x86bios_lock, "x86bios lock", NULL, MTX_SPIN);
 572
 573         if (x86bios_map_mem() != 0)
 574                 return;
 575
 576         x86bios_map = malloc(sizeof(*x86bios_map) * X86BIOS_PAGES, M_DEVBUF,
 577             M_WAITOK | M_ZERO);
 578         x86bios_set_pages((vm_offset_t)x86bios_ivt, X86BIOS_IVT_BASE,
 579             X86BIOS_IVT_SIZE);
 580         x86bios_set_pages((vm_offset_t)x86bios_rom, x86bios_rom_phys,
 581             X86BIOS_ROM_SIZE);
 582         x86bios_set_pages((vm_offset_t)x86bios_seg, x86bios_seg_phys,
 583             X86BIOS_SEG_SIZE);
 584
 585         bzero(&x86bios_emu, sizeof(x86bios_emu));
 586
 587         x86bios_emu.emu_rdb = x86bios_emu_rdb;
 588         x86bios_emu.emu_rdw = x86bios_emu_rdw;
 589         x86bios_emu.emu_rdl = x86bios_emu_rdl;
 590         x86bios_emu.emu_wrb = x86bios_emu_wrb;
 591         x86bios_emu.emu_wrw = x86bios_emu_wrw;
 592         x86bios_emu.emu_wrl = x86bios_emu_wrl;
 593
 594         x86bios_emu.emu_inb = x86bios_emu_inb;
 595         x86bios_emu.emu_inw = x86bios_emu_inw;
 596         x86bios_emu.emu_inl = x86bios_emu_inl;
 597         x86bios_emu.emu_outb = x86bios_emu_outb;
 598         x86bios_emu.emu_outw = x86bios_emu_outw;
 599         x86bios_emu.emu_outl = x86bios_emu_outl;
 600
 601         for (i = 0; i < 256; i++)
 602                 x86bios_emu._x86emu_intrTab[i] = x86bios_emu_get_intr;
 603 }
 604
 605 static void
 606 x86bios_uninit(void *arg __unused)
 607 {
 608         vm_offset_t *map = x86bios_map;
 609
 610         mtx_lock_spin(&x86bios_lock);
 611         if (x86bios_map != NULL) {
 612                 free(x86bios_map, M_DEVBUF);
 613                 x86bios_map = NULL;
 614         }
 615         mtx_unlock_spin(&x86bios_lock);
 616
 617         if (map != NULL)
 618                 x86bios_unmap_mem();
 619
 620         mtx_destroy(&x86bios_lock);
 621 }
 622
 623 static int
 624 x86bios_modevent(module_t mod __unused, int type, void *data __unused)
 625 {
 626
 627         switch (type) {
 628         case MOD_LOAD:
 629                 x86bios_init(NULL);
 630                 break;
 631         case MOD_UNLOAD:
 632                 x86bios_uninit(NULL);
 633                 break;
 634         default:
 635                 return (ENOTSUP);
 636         }
 637
 638         return (0);
 639 }
 640
 641 static moduledata_t x86bios_mod = {
 642         "x86bios",
 643         x86bios_modevent,
 644         NULL,
 645 };
 646
 647 DECLARE_MODULE(x86bios, x86bios_mod, SI_SUB_CPU, SI_ORDER_ANY);
 648 MODULE_VERSION(x86bios, 1);