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/sysctl.h> 41 42 #include <contrib/x86emu/x86emu.h> 43 #include <contrib/x86emu/x86emu_regs.h> 44 #include <compat/x86bios/x86bios.h> 45 46 #include <dev/pci/pcireg.h> 47 #include <dev/pci/pcivar.h> 48 49 #include <vm/vm.h> 50 #include <vm/pmap.h> 51 52 #ifdef __amd64__ 53 #define X86BIOS_NATIVE_ARCH 54 #endif 55 #ifdef __i386__ 56 #define X86BIOS_NATIVE_VM86 57 #endif 58 59 #define X86BIOS_MEM_SIZE 0x00100000 /* 1M */ 60 61 #define X86BIOS_TRACE(h, n, r) do { \ 62 printf(__STRING(h) \ 63 " (ax=0x%04x bx=0x%04x cx=0x%04x dx=0x%04x es=0x%04x di=0x%04x)\n",\ 64 (n), (r)->R_AX, (r)->R_BX, (r)->R_CX, (r)->R_DX, \ 65 (r)->R_ES, (r)->R_DI); \ 66 } while (0) 67 68 static struct mtx x86bios_lock; 69 70 static SYSCTL_NODE(_debug, OID_AUTO, x86bios, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 71 "x86bios debugging"); 72 static int x86bios_trace_call; 73 SYSCTL_INT(_debug_x86bios, OID_AUTO, call, CTLFLAG_RWTUN, &x86bios_trace_call, 0, 74 "Trace far function calls"); 75 static int x86bios_trace_int; 76 SYSCTL_INT(_debug_x86bios, OID_AUTO, int, CTLFLAG_RWTUN, &x86bios_trace_int, 0, 77 "Trace software interrupt handlers"); 78 79 #ifdef X86BIOS_NATIVE_VM86 80 81 #include <machine/vm86.h> 82 #include <machine/vmparam.h> 83 #include <machine/pc/bios.h> 84 85 struct vm86context x86bios_vmc; 86 87 static void 88 x86bios_emu2vmf(struct x86emu_regs *regs, struct vm86frame *vmf) 89 { 90 91 vmf->vmf_ds = regs->R_DS; 92 vmf->vmf_es = regs->R_ES; 93 vmf->vmf_ax = regs->R_AX; 94 vmf->vmf_bx = regs->R_BX; 95 vmf->vmf_cx = regs->R_CX; 96 vmf->vmf_dx = regs->R_DX; 97 vmf->vmf_bp = regs->R_BP; 98 vmf->vmf_si = regs->R_SI; 99 vmf->vmf_di = regs->R_DI; 100 } 101 102 static void 103 x86bios_vmf2emu(struct vm86frame *vmf, struct x86emu_regs *regs) 104 { 105 106 regs->R_DS = vmf->vmf_ds; 107 regs->R_ES = vmf->vmf_es; 108 regs->R_FLG = vmf->vmf_flags; 109 regs->R_AX = vmf->vmf_ax; 110 regs->R_BX = vmf->vmf_bx; 111 regs->R_CX = vmf->vmf_cx; 112 regs->R_DX = vmf->vmf_dx; 113 regs->R_BP = vmf->vmf_bp; 114 regs->R_SI = vmf->vmf_si; 115 regs->R_DI = vmf->vmf_di; 116 } 117 118 void * 119 x86bios_alloc(uint32_t *offset, size_t size, int flags) 120 { 121 void *vaddr; 122 u_int i; 123 124 if (offset == NULL || size == 0) 125 return (NULL); 126 vaddr = contigmalloc(size, M_DEVBUF, flags, 0, X86BIOS_MEM_SIZE, 127 PAGE_SIZE, 0); 128 if (vaddr != NULL) { 129 *offset = vtophys(vaddr); 130 mtx_lock(&x86bios_lock); 131 for (i = 0; i < atop(round_page(size)); i++) 132 vm86_addpage(&x86bios_vmc, atop(*offset) + i, 133 (vm_offset_t)vaddr + ptoa(i)); 134 mtx_unlock(&x86bios_lock); 135 } 136 137 return (vaddr); 138 } 139 140 void 141 x86bios_free(void *addr, size_t size) 142 { 143 vm_paddr_t paddr; 144 int i, nfree; 145 146 if (addr == NULL || size == 0) 147 return; 148 paddr = vtophys(addr); 149 if (paddr >= X86BIOS_MEM_SIZE || (paddr & PAGE_MASK) != 0) 150 return; 151 mtx_lock(&x86bios_lock); 152 for (i = 0; i < x86bios_vmc.npages; i++) 153 if (x86bios_vmc.pmap[i].kva == (vm_offset_t)addr) 154 break; 155 if (i >= x86bios_vmc.npages) { 156 mtx_unlock(&x86bios_lock); 157 return; 158 } 159 nfree = atop(round_page(size)); 160 bzero(x86bios_vmc.pmap + i, sizeof(*x86bios_vmc.pmap) * nfree); 161 if (i + nfree == x86bios_vmc.npages) { 162 x86bios_vmc.npages -= nfree; 163 while (--i >= 0 && x86bios_vmc.pmap[i].kva == 0) 164 x86bios_vmc.npages--; 165 } 166 mtx_unlock(&x86bios_lock); 167 contigfree(addr, size, M_DEVBUF); 168 } 169 170 void 171 x86bios_init_regs(struct x86regs *regs) 172 { 173 174 bzero(regs, sizeof(*regs)); 175 } 176 177 void 178 x86bios_call(struct x86regs *regs, uint16_t seg, uint16_t off) 179 { 180 struct vm86frame vmf; 181 182 if (x86bios_trace_call) 183 X86BIOS_TRACE(Calling 0x%06x, (seg << 4) + off, regs); 184 185 bzero(&vmf, sizeof(vmf)); 186 x86bios_emu2vmf((struct x86emu_regs *)regs, &vmf); 187 vmf.vmf_cs = seg; 188 vmf.vmf_ip = off; 189 mtx_lock(&x86bios_lock); 190 vm86_datacall(-1, &vmf, &x86bios_vmc); 191 mtx_unlock(&x86bios_lock); 192 x86bios_vmf2emu(&vmf, (struct x86emu_regs *)regs); 193 194 if (x86bios_trace_call) 195 X86BIOS_TRACE(Exiting 0x%06x, (seg << 4) + off, regs); 196 } 197 198 uint32_t 199 x86bios_get_intr(int intno) 200 { 201 202 return (readl(BIOS_PADDRTOVADDR(intno * 4))); 203 } 204 205 void 206 x86bios_set_intr(int intno, uint32_t saddr) 207 { 208 209 writel(BIOS_PADDRTOVADDR(intno * 4), saddr); 210 } 211 212 void 213 x86bios_intr(struct x86regs *regs, int intno) 214 { 215 struct vm86frame vmf; 216 217 if (x86bios_trace_int) 218 X86BIOS_TRACE(Calling INT 0x%02x, intno, regs); 219 220 bzero(&vmf, sizeof(vmf)); 221 x86bios_emu2vmf((struct x86emu_regs *)regs, &vmf); 222 mtx_lock(&x86bios_lock); 223 vm86_datacall(intno, &vmf, &x86bios_vmc); 224 mtx_unlock(&x86bios_lock); 225 x86bios_vmf2emu(&vmf, (struct x86emu_regs *)regs); 226 227 if (x86bios_trace_int) 228 X86BIOS_TRACE(Exiting INT 0x%02x, intno, regs); 229 } 230 231 void * 232 x86bios_offset(uint32_t offset) 233 { 234 vm_offset_t addr; 235 236 addr = vm86_getaddr(&x86bios_vmc, X86BIOS_PHYSTOSEG(offset), 237 X86BIOS_PHYSTOOFF(offset)); 238 if (addr == 0) 239 addr = BIOS_PADDRTOVADDR(offset); 240 241 return ((void *)addr); 242 } 243 244 static int 245 x86bios_init(void) 246 { 247 248 mtx_init(&x86bios_lock, "x86bios lock", NULL, MTX_DEF); 249 bzero(&x86bios_vmc, sizeof(x86bios_vmc)); 250 251 return (0); 252 } 253 254 static int 255 x86bios_uninit(void) 256 { 257 258 mtx_destroy(&x86bios_lock); 259 260 return (0); 261 } 262 263 #else 264 265 #include <machine/iodev.h> 266 267 #define X86BIOS_PAGE_SIZE 0x00001000 /* 4K */ 268 269 #define X86BIOS_IVT_SIZE 0x00000500 /* 1K + 256 (BDA) */ 270 271 #define X86BIOS_IVT_BASE 0x00000000 272 #define X86BIOS_RAM_BASE 0x00001000 273 #define X86BIOS_ROM_BASE 0x000a0000 274 275 #define X86BIOS_ROM_SIZE (X86BIOS_MEM_SIZE - x86bios_rom_phys) 276 #define X86BIOS_SEG_SIZE X86BIOS_PAGE_SIZE 277 278 #define X86BIOS_PAGES (X86BIOS_MEM_SIZE / X86BIOS_PAGE_SIZE) 279 280 #define X86BIOS_R_SS _pad2 281 #define X86BIOS_R_SP _pad3.I16_reg.x_reg 282 283 static struct x86emu x86bios_emu; 284 285 static void *x86bios_ivt; 286 static void *x86bios_rom; 287 static void *x86bios_seg; 288 289 static vm_offset_t *x86bios_map; 290 291 static vm_paddr_t x86bios_rom_phys; 292 static vm_paddr_t x86bios_seg_phys; 293 294 static int x86bios_fault; 295 static uint32_t x86bios_fault_addr; 296 static uint16_t x86bios_fault_cs; 297 static uint16_t x86bios_fault_ip; 298 299 static void 300 x86bios_set_fault(struct x86emu *emu, uint32_t addr) 301 { 302 303 x86bios_fault = 1; 304 x86bios_fault_addr = addr; 305 x86bios_fault_cs = emu->x86.R_CS; 306 x86bios_fault_ip = emu->x86.R_IP; 307 x86emu_halt_sys(emu); 308 } 309 310 static void * 311 x86bios_get_pages(uint32_t offset, size_t size) 312 { 313 vm_offset_t addr; 314 315 if (offset + size > X86BIOS_MEM_SIZE + X86BIOS_IVT_SIZE) 316 return (NULL); 317 318 if (offset >= X86BIOS_MEM_SIZE) 319 offset -= X86BIOS_MEM_SIZE; 320 addr = x86bios_map[offset / X86BIOS_PAGE_SIZE]; 321 if (addr != 0) 322 addr += offset % X86BIOS_PAGE_SIZE; 323 324 return ((void *)addr); 325 } 326 327 static void 328 x86bios_set_pages(vm_offset_t va, vm_paddr_t pa, size_t size) 329 { 330 int i, j; 331 332 for (i = pa / X86BIOS_PAGE_SIZE, j = 0; 333 j < howmany(size, X86BIOS_PAGE_SIZE); i++, j++) 334 x86bios_map[i] = va + j * X86BIOS_PAGE_SIZE; 335 } 336 337 static uint8_t 338 x86bios_emu_rdb(struct x86emu *emu, uint32_t addr) 339 { 340 uint8_t *va; 341 342 va = x86bios_get_pages(addr, sizeof(*va)); 343 if (va == NULL) 344 x86bios_set_fault(emu, addr); 345 346 return (*va); 347 } 348 349 static uint16_t 350 x86bios_emu_rdw(struct x86emu *emu, uint32_t addr) 351 { 352 uint16_t *va; 353 354 va = x86bios_get_pages(addr, sizeof(*va)); 355 if (va == NULL) 356 x86bios_set_fault(emu, addr); 357 358 #ifndef __NO_STRICT_ALIGNMENT 359 if ((addr & 1) != 0) 360 return (le16dec(va)); 361 else 362 #endif 363 return (le16toh(*va)); 364 } 365 366 static uint32_t 367 x86bios_emu_rdl(struct x86emu *emu, uint32_t addr) 368 { 369 uint32_t *va; 370 371 va = x86bios_get_pages(addr, sizeof(*va)); 372 if (va == NULL) 373 x86bios_set_fault(emu, addr); 374 375 #ifndef __NO_STRICT_ALIGNMENT 376 if ((addr & 3) != 0) 377 return (le32dec(va)); 378 else 379 #endif 380 return (le32toh(*va)); 381 } 382 383 static void 384 x86bios_emu_wrb(struct x86emu *emu, uint32_t addr, uint8_t val) 385 { 386 uint8_t *va; 387 388 va = x86bios_get_pages(addr, sizeof(*va)); 389 if (va == NULL) 390 x86bios_set_fault(emu, addr); 391 392 *va = val; 393 } 394 395 static void 396 x86bios_emu_wrw(struct x86emu *emu, uint32_t addr, uint16_t val) 397 { 398 uint16_t *va; 399 400 va = x86bios_get_pages(addr, sizeof(*va)); 401 if (va == NULL) 402 x86bios_set_fault(emu, addr); 403 404 #ifndef __NO_STRICT_ALIGNMENT 405 if ((addr & 1) != 0) 406 le16enc(va, val); 407 else 408 #endif 409 *va = htole16(val); 410 } 411 412 static void 413 x86bios_emu_wrl(struct x86emu *emu, uint32_t addr, uint32_t val) 414 { 415 uint32_t *va; 416 417 va = x86bios_get_pages(addr, sizeof(*va)); 418 if (va == NULL) 419 x86bios_set_fault(emu, addr); 420 421 #ifndef __NO_STRICT_ALIGNMENT 422 if ((addr & 3) != 0) 423 le32enc(va, val); 424 else 425 #endif 426 *va = htole32(val); 427 } 428 429 static uint8_t 430 x86bios_emu_inb(struct x86emu *emu, uint16_t port) 431 { 432 433 #ifndef X86BIOS_NATIVE_ARCH 434 if (port == 0xb2) /* APM scratch register */ 435 return (0); 436 if (port >= 0x80 && port < 0x88) /* POST status register */ 437 return (0); 438 #endif 439 440 return (iodev_read_1(port)); 441 } 442 443 static uint16_t 444 x86bios_emu_inw(struct x86emu *emu, uint16_t port) 445 { 446 uint16_t val; 447 448 #ifndef X86BIOS_NATIVE_ARCH 449 if (port >= 0x80 && port < 0x88) /* POST status register */ 450 return (0); 451 452 if ((port & 1) != 0) { 453 val = iodev_read_1(port); 454 val |= iodev_read_1(port + 1) << 8; 455 } else 456 #endif 457 val = iodev_read_2(port); 458 459 return (val); 460 } 461 462 static uint32_t 463 x86bios_emu_inl(struct x86emu *emu, uint16_t port) 464 { 465 uint32_t val; 466 467 #ifndef X86BIOS_NATIVE_ARCH 468 if (port >= 0x80 && port < 0x88) /* POST status register */ 469 return (0); 470 471 if ((port & 1) != 0) { 472 val = iodev_read_1(port); 473 val |= iodev_read_2(port + 1) << 8; 474 val |= iodev_read_1(port + 3) << 24; 475 } else if ((port & 2) != 0) { 476 val = iodev_read_2(port); 477 val |= iodev_read_2(port + 2) << 16; 478 } else 479 #endif 480 val = iodev_read_4(port); 481 482 return (val); 483 } 484 485 static void 486 x86bios_emu_outb(struct x86emu *emu, uint16_t port, uint8_t val) 487 { 488 489 #ifndef X86BIOS_NATIVE_ARCH 490 if (port == 0xb2) /* APM scratch register */ 491 return; 492 if (port >= 0x80 && port < 0x88) /* POST status register */ 493 return; 494 #endif 495 496 iodev_write_1(port, val); 497 } 498 499 static void 500 x86bios_emu_outw(struct x86emu *emu, uint16_t port, uint16_t val) 501 { 502 503 #ifndef X86BIOS_NATIVE_ARCH 504 if (port >= 0x80 && port < 0x88) /* POST status register */ 505 return; 506 507 if ((port & 1) != 0) { 508 iodev_write_1(port, val); 509 iodev_write_1(port + 1, val >> 8); 510 } else 511 #endif 512 iodev_write_2(port, val); 513 } 514 515 static void 516 x86bios_emu_outl(struct x86emu *emu, uint16_t port, uint32_t val) 517 { 518 519 #ifndef X86BIOS_NATIVE_ARCH 520 if (port >= 0x80 && port < 0x88) /* POST status register */ 521 return; 522 523 if ((port & 1) != 0) { 524 iodev_write_1(port, val); 525 iodev_write_2(port + 1, val >> 8); 526 iodev_write_1(port + 3, val >> 24); 527 } else if ((port & 2) != 0) { 528 iodev_write_2(port, val); 529 iodev_write_2(port + 2, val >> 16); 530 } else 531 #endif 532 iodev_write_4(port, val); 533 } 534 535 void * 536 x86bios_alloc(uint32_t *offset, size_t size, int flags) 537 { 538 void *vaddr; 539 540 if (offset == NULL || size == 0) 541 return (NULL); 542 vaddr = contigmalloc(size, M_DEVBUF, flags, X86BIOS_RAM_BASE, 543 x86bios_rom_phys, X86BIOS_PAGE_SIZE, 0); 544 if (vaddr != NULL) { 545 *offset = vtophys(vaddr); 546 mtx_lock(&x86bios_lock); 547 x86bios_set_pages((vm_offset_t)vaddr, *offset, size); 548 mtx_unlock(&x86bios_lock); 549 } 550 551 return (vaddr); 552 } 553 554 void 555 x86bios_free(void *addr, size_t size) 556 { 557 vm_paddr_t paddr; 558 559 if (addr == NULL || size == 0) 560 return; 561 paddr = vtophys(addr); 562 if (paddr < X86BIOS_RAM_BASE || paddr >= x86bios_rom_phys || 563 paddr % X86BIOS_PAGE_SIZE != 0) 564 return; 565 mtx_lock(&x86bios_lock); 566 bzero(x86bios_map + paddr / X86BIOS_PAGE_SIZE, 567 sizeof(*x86bios_map) * howmany(size, X86BIOS_PAGE_SIZE)); 568 mtx_unlock(&x86bios_lock); 569 contigfree(addr, size, M_DEVBUF); 570 } 571 572 void 573 x86bios_init_regs(struct x86regs *regs) 574 { 575 576 bzero(regs, sizeof(*regs)); 577 regs->X86BIOS_R_SS = X86BIOS_PHYSTOSEG(x86bios_seg_phys); 578 regs->X86BIOS_R_SP = X86BIOS_PAGE_SIZE - 2; 579 } 580 581 void 582 x86bios_call(struct x86regs *regs, uint16_t seg, uint16_t off) 583 { 584 585 if (x86bios_trace_call) 586 X86BIOS_TRACE(Calling 0x%06x, (seg << 4) + off, regs); 587 588 mtx_lock(&x86bios_lock); 589 memcpy((struct x86regs *)&x86bios_emu.x86, regs, sizeof(*regs)); 590 x86bios_fault = 0; 591 spinlock_enter(); 592 x86emu_exec_call(&x86bios_emu, seg, off); 593 spinlock_exit(); 594 memcpy(regs, &x86bios_emu.x86, sizeof(*regs)); 595 mtx_unlock(&x86bios_lock); 596 597 if (x86bios_trace_call) { 598 X86BIOS_TRACE(Exiting 0x%06x, (seg << 4) + off, regs); 599 if (x86bios_fault) 600 printf("Page fault at 0x%06x from 0x%04x:0x%04x.\n", 601 x86bios_fault_addr, x86bios_fault_cs, 602 x86bios_fault_ip); 603 } 604 } 605 606 uint32_t 607 x86bios_get_intr(int intno) 608 { 609 610 return (le32toh(*((uint32_t *)x86bios_ivt + intno))); 611 } 612 613 void 614 x86bios_set_intr(int intno, uint32_t saddr) 615 { 616 617 *((uint32_t *)x86bios_ivt + intno) = htole32(saddr); 618 } 619 620 void 621 x86bios_intr(struct x86regs *regs, int intno) 622 { 623 624 if (intno < 0 || intno > 255) 625 return; 626 627 if (x86bios_trace_int) 628 X86BIOS_TRACE(Calling INT 0x%02x, intno, regs); 629 630 mtx_lock(&x86bios_lock); 631 memcpy((struct x86regs *)&x86bios_emu.x86, regs, sizeof(*regs)); 632 x86bios_fault = 0; 633 spinlock_enter(); 634 x86emu_exec_intr(&x86bios_emu, intno); 635 spinlock_exit(); 636 memcpy(regs, &x86bios_emu.x86, sizeof(*regs)); 637 mtx_unlock(&x86bios_lock); 638 639 if (x86bios_trace_int) { 640 X86BIOS_TRACE(Exiting INT 0x%02x, intno, regs); 641 if (x86bios_fault) 642 printf("Page fault at 0x%06x from 0x%04x:0x%04x.\n", 643 x86bios_fault_addr, x86bios_fault_cs, 644 x86bios_fault_ip); 645 } 646 } 647 648 void * 649 x86bios_offset(uint32_t offset) 650 { 651 652 return (x86bios_get_pages(offset, 1)); 653 } 654 655 static __inline void 656 x86bios_unmap_mem(void) 657 { 658 659 if (x86bios_map != NULL) { 660 free(x86bios_map, M_DEVBUF); 661 x86bios_map = NULL; 662 } 663 if (x86bios_ivt != NULL) { 664 #ifdef X86BIOS_NATIVE_ARCH 665 pmap_unmapbios((vm_offset_t)x86bios_ivt, X86BIOS_IVT_SIZE); 666 #else 667 free(x86bios_ivt, M_DEVBUF); 668 x86bios_ivt = NULL; 669 #endif 670 } 671 if (x86bios_rom != NULL) 672 pmap_unmapdev((vm_offset_t)x86bios_rom, X86BIOS_ROM_SIZE); 673 if (x86bios_seg != NULL) { 674 contigfree(x86bios_seg, X86BIOS_SEG_SIZE, M_DEVBUF); 675 x86bios_seg = NULL; 676 } 677 } 678 679 static __inline int 680 x86bios_map_mem(void) 681 { 682 683 x86bios_map = malloc(sizeof(*x86bios_map) * X86BIOS_PAGES, M_DEVBUF, 684 M_NOWAIT | M_ZERO); 685 if (x86bios_map == NULL) 686 goto fail; 687 688 #ifdef X86BIOS_NATIVE_ARCH 689 x86bios_ivt = pmap_mapbios(X86BIOS_IVT_BASE, X86BIOS_IVT_SIZE); 690 691 /* Probe EBDA via BDA. */ 692 x86bios_rom_phys = *(uint16_t *)((caddr_t)x86bios_ivt + 0x40e); 693 x86bios_rom_phys = x86bios_rom_phys << 4; 694 if (x86bios_rom_phys != 0 && x86bios_rom_phys < X86BIOS_ROM_BASE && 695 X86BIOS_ROM_BASE - x86bios_rom_phys <= 128 * 1024) 696 x86bios_rom_phys = 697 rounddown(x86bios_rom_phys, X86BIOS_PAGE_SIZE); 698 else 699 #else 700 x86bios_ivt = malloc(X86BIOS_IVT_SIZE, M_DEVBUF, M_NOWAIT | M_ZERO); 701 if (x86bios_ivt == NULL) 702 goto fail; 703 #endif 704 705 x86bios_rom_phys = X86BIOS_ROM_BASE; 706 x86bios_rom = pmap_mapdev(x86bios_rom_phys, X86BIOS_ROM_SIZE); 707 if (x86bios_rom == NULL) 708 goto fail; 709 #ifdef X86BIOS_NATIVE_ARCH 710 /* Change attribute for EBDA. */ 711 if (x86bios_rom_phys < X86BIOS_ROM_BASE && 712 pmap_change_attr((vm_offset_t)x86bios_rom, 713 X86BIOS_ROM_BASE - x86bios_rom_phys, PAT_WRITE_BACK) != 0) 714 goto fail; 715 #endif 716 717 x86bios_seg = contigmalloc(X86BIOS_SEG_SIZE, M_DEVBUF, M_NOWAIT, 718 X86BIOS_RAM_BASE, x86bios_rom_phys, X86BIOS_PAGE_SIZE, 0); 719 if (x86bios_seg == NULL) 720 goto fail; 721 x86bios_seg_phys = vtophys(x86bios_seg); 722 723 x86bios_set_pages((vm_offset_t)x86bios_ivt, X86BIOS_IVT_BASE, 724 X86BIOS_IVT_SIZE); 725 x86bios_set_pages((vm_offset_t)x86bios_rom, x86bios_rom_phys, 726 X86BIOS_ROM_SIZE); 727 x86bios_set_pages((vm_offset_t)x86bios_seg, x86bios_seg_phys, 728 X86BIOS_SEG_SIZE); 729 730 if (bootverbose) { 731 printf("x86bios: IVT 0x%06jx-0x%06jx at %p\n", 732 (vm_paddr_t)X86BIOS_IVT_BASE, 733 (vm_paddr_t)X86BIOS_IVT_SIZE + X86BIOS_IVT_BASE - 1, 734 x86bios_ivt); 735 printf("x86bios: SSEG 0x%06jx-0x%06jx at %p\n", 736 x86bios_seg_phys, 737 (vm_paddr_t)X86BIOS_SEG_SIZE + x86bios_seg_phys - 1, 738 x86bios_seg); 739 if (x86bios_rom_phys < X86BIOS_ROM_BASE) 740 printf("x86bios: EBDA 0x%06jx-0x%06jx at %p\n", 741 x86bios_rom_phys, (vm_paddr_t)X86BIOS_ROM_BASE - 1, 742 x86bios_rom); 743 printf("x86bios: ROM 0x%06jx-0x%06jx at %p\n", 744 (vm_paddr_t)X86BIOS_ROM_BASE, 745 (vm_paddr_t)X86BIOS_MEM_SIZE - X86BIOS_SEG_SIZE - 1, 746 (caddr_t)x86bios_rom + X86BIOS_ROM_BASE - x86bios_rom_phys); 747 } 748 749 return (0); 750 751 fail: 752 x86bios_unmap_mem(); 753 754 return (1); 755 } 756 757 static int 758 x86bios_init(void) 759 { 760 761 mtx_init(&x86bios_lock, "x86bios lock", NULL, MTX_DEF); 762 763 if (x86bios_map_mem() != 0) 764 return (ENOMEM); 765 766 bzero(&x86bios_emu, sizeof(x86bios_emu)); 767 768 x86bios_emu.emu_rdb = x86bios_emu_rdb; 769 x86bios_emu.emu_rdw = x86bios_emu_rdw; 770 x86bios_emu.emu_rdl = x86bios_emu_rdl; 771 x86bios_emu.emu_wrb = x86bios_emu_wrb; 772 x86bios_emu.emu_wrw = x86bios_emu_wrw; 773 x86bios_emu.emu_wrl = x86bios_emu_wrl; 774 775 x86bios_emu.emu_inb = x86bios_emu_inb; 776 x86bios_emu.emu_inw = x86bios_emu_inw; 777 x86bios_emu.emu_inl = x86bios_emu_inl; 778 x86bios_emu.emu_outb = x86bios_emu_outb; 779 x86bios_emu.emu_outw = x86bios_emu_outw; 780 x86bios_emu.emu_outl = x86bios_emu_outl; 781 782 return (0); 783 } 784 785 static int 786 x86bios_uninit(void) 787 { 788 789 x86bios_unmap_mem(); 790 mtx_destroy(&x86bios_lock); 791 792 return (0); 793 } 794 795 #endif 796 797 void * 798 x86bios_get_orm(uint32_t offset) 799 { 800 uint8_t *p; 801 802 /* Does the shadow ROM contain BIOS POST code for x86? */ 803 p = x86bios_offset(offset); 804 if (p == NULL || p[0] != 0x55 || p[1] != 0xaa || 805 (p[3] != 0xe9 && p[3] != 0xeb)) 806 return (NULL); 807 808 return (p); 809 } 810 811 int 812 x86bios_match_device(uint32_t offset, device_t dev) 813 { 814 uint8_t *p; 815 uint16_t device, vendor; 816 uint8_t class, progif, subclass; 817 818 /* Does the shadow ROM contain BIOS POST code for x86? */ 819 p = x86bios_get_orm(offset); 820 if (p == NULL) 821 return (0); 822 823 /* Does it contain PCI data structure? */ 824 p += le16toh(*(uint16_t *)(p + 0x18)); 825 if (bcmp(p, "PCIR", 4) != 0 || 826 le16toh(*(uint16_t *)(p + 0x0a)) < 0x18 || *(p + 0x14) != 0) 827 return (0); 828 829 /* Does it match the vendor, device, and classcode? */ 830 vendor = le16toh(*(uint16_t *)(p + 0x04)); 831 device = le16toh(*(uint16_t *)(p + 0x06)); 832 progif = *(p + 0x0d); 833 subclass = *(p + 0x0e); 834 class = *(p + 0x0f); 835 if (vendor != pci_get_vendor(dev) || device != pci_get_device(dev) || 836 class != pci_get_class(dev) || subclass != pci_get_subclass(dev) || 837 progif != pci_get_progif(dev)) 838 return (0); 839 840 return (1); 841 } 842 843 static int 844 x86bios_modevent(module_t mod __unused, int type, void *data __unused) 845 { 846 847 switch (type) { 848 case MOD_LOAD: 849 return (x86bios_init()); 850 case MOD_UNLOAD: 851 return (x86bios_uninit()); 852 default: 853 return (ENOTSUP); 854 } 855 } 856 857 static moduledata_t x86bios_mod = { 858 "x86bios", 859 x86bios_modevent, 860 NULL, 861 }; 862 863 DECLARE_MODULE(x86bios, x86bios_mod, SI_SUB_CPU, SI_ORDER_ANY); 864 MODULE_VERSION(x86bios, 1); 865