| 1 | /*- |
| 2 | * Copyright (c) 1990 The Regents of the University of California. |
| 3 | * All rights reserved. |
| 4 | * |
| 5 | * This code is derived from software contributed to Berkeley by |
| 6 | * William Jolitz. |
| 7 | * |
| 8 | * Redistribution and use in source and binary forms, with or without |
| 9 | * modification, are permitted provided that the following conditions |
| 10 | * are met: |
| 11 | * 1. Redistributions of source code must retain the above copyright |
| 12 | * notice, this list of conditions and the following disclaimer. |
| 13 | * 2. Redistributions in binary form must reproduce the above copyright |
| 14 | * notice, this list of conditions and the following disclaimer in the |
| 15 | * documentation and/or other materials provided with the distribution. |
| 16 | * 3. All advertising materials mentioning features or use of this software |
| 17 | * must display the following acknowledgement: |
| 18 | * This product includes software developed by the University of |
| 19 | * California, Berkeley and its contributors. |
| 20 | * 4. Neither the name of the University nor the names of its contributors |
| 21 | * may be used to endorse or promote products derived from this software |
| 22 | * without specific prior written permission. |
| 23 | * |
| 24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| 25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 34 | * SUCH DAMAGE. |
| 35 | * |
| 36 | * from: @(#)locore.s 7.3 (Berkeley) 5/13/91 |
| 37 | * $FreeBSD: src/sys/i386/i386/locore.s,v 1.132.2.10 2003/02/03 20:54:49 jhb Exp $ |
| 38 | * $DragonFly: src/sys/platform/pc32/i386/locore.s,v 1.13 2007/01/08 03:33:42 dillon Exp $ |
| 39 | * |
| 40 | * originally from: locore.s, by William F. Jolitz |
| 41 | * |
| 42 | * Substantially rewritten by David Greenman, Rod Grimes, |
| 43 | * Bruce Evans, Wolfgang Solfrank, Poul-Henning Kamp |
| 44 | * and many others. |
| 45 | */ |
| 46 | |
| 47 | #include "opt_bootp.h" |
| 48 | #include "opt_nfsroot.h" |
| 49 | |
| 50 | #include <sys/syscall.h> |
| 51 | #include <sys/reboot.h> |
| 52 | |
| 53 | #include <machine/asmacros.h> |
| 54 | #include <machine/cputypes.h> |
| 55 | #include <machine/psl.h> |
| 56 | #include <machine/pmap.h> |
| 57 | #include <machine/specialreg.h> |
| 58 | |
| 59 | #include "assym.s" |
| 60 | |
| 61 | /* |
| 62 | * XXX |
| 63 | * |
| 64 | * Note: This version greatly munged to avoid various assembler errors |
| 65 | * that may be fixed in newer versions of gas. Perhaps newer versions |
| 66 | * will have more pleasant appearance. |
| 67 | */ |
| 68 | |
| 69 | /* |
| 70 | * PTmap is recursive pagemap at top of virtual address space. |
| 71 | * Within PTmap, the page directory can be found (third indirection). |
| 72 | */ |
| 73 | .globl PTmap,PTD,PTDpde |
| 74 | .set PTmap,(PTDPTDI << PDRSHIFT) |
| 75 | .set PTD,PTmap + (PTDPTDI * PAGE_SIZE) |
| 76 | .set PTDpde,PTD + (PTDPTDI * PDESIZE) |
| 77 | |
| 78 | /* |
| 79 | * APTmap, APTD is the alternate recursive pagemap. |
| 80 | * It's used when modifying another process's page tables. |
| 81 | */ |
| 82 | .globl APTmap,APTD,APTDpde |
| 83 | .set APTmap,APTDPTDI << PDRSHIFT |
| 84 | .set APTD,APTmap + (APTDPTDI * PAGE_SIZE) |
| 85 | .set APTDpde,PTD + (APTDPTDI * PDESIZE) |
| 86 | |
| 87 | /* |
| 88 | * Compiled KERNBASE location |
| 89 | */ |
| 90 | .globl kernbase |
| 91 | .set kernbase,KERNBASE |
| 92 | |
| 93 | /* |
| 94 | * Globals |
| 95 | */ |
| 96 | .data |
| 97 | ALIGN_DATA /* just to be sure */ |
| 98 | |
| 99 | .globl .tmpstk |
| 100 | .space 0x2000 /* space for tmpstk - temporary stack */ |
| 101 | .tmpstk: |
| 102 | |
| 103 | .globl boothowto,bootdev |
| 104 | |
| 105 | .globl cpu,cpu_vendor,cpu_id,bootinfo |
| 106 | .globl cpu_high, cpu_feature, cpu_feature2, cpu_procinfo |
| 107 | |
| 108 | cpu: .long 0 /* are we 386, 386sx, or 486 */ |
| 109 | cpu_id: .long 0 /* stepping ID */ |
| 110 | cpu_high: .long 0 /* highest arg to CPUID */ |
| 111 | cpu_feature: .long 0 /* features */ |
| 112 | cpu_feature2: .long 0 /* additional features */ |
| 113 | cpu_procinfo: .long 0 /* brand index / HTT info */ |
| 114 | cpu_vendor: .space 20 /* CPU origin code */ |
| 115 | bootinfo: .space BOOTINFO_SIZE /* bootinfo buffer space */ |
| 116 | |
| 117 | KERNend: .long 0 /* phys addr end of kernel (just after bss) */ |
| 118 | physfree: .long 0 /* phys addr of next free page */ |
| 119 | |
| 120 | #if 0 |
| 121 | .globl cpu0prvpage |
| 122 | cpu0prvpage: .long 0 /* relocated version */ |
| 123 | #endif |
| 124 | cpu0pp: .long 0 /* phys addr cpu0 private pg */ |
| 125 | cpu0idlestk: .long 0 /* stack for the idle thread */ |
| 126 | |
| 127 | .globl SMPpt |
| 128 | SMPptpa: .long 0 /* phys addr SMP page table */ |
| 129 | SMPpt: .long 0 /* relocated version */ |
| 130 | |
| 131 | .globl IdlePTD |
| 132 | IdlePTD: .long 0 /* phys addr of kernel PTD */ |
| 133 | |
| 134 | .globl KPTphys |
| 135 | KPTphys: .long 0 /* PA of kernel page tables */ |
| 136 | |
| 137 | .globl proc0paddr |
| 138 | proc0paddr: .long 0 /* VA of proc 0 address space */ |
| 139 | p0upa: .long 0 /* PA of proc0's UPAGES */ |
| 140 | |
| 141 | vm86phystk: .long 0 /* PA of vm86/bios stack */ |
| 142 | |
| 143 | .globl vm86paddr, vm86pa |
| 144 | vm86paddr: .long 0 /* address of vm86 region */ |
| 145 | vm86pa: .long 0 /* phys addr of vm86 region */ |
| 146 | |
| 147 | #ifdef BDE_DEBUGGER |
| 148 | .globl bdb_exists /* BDE debugger is present */ |
| 149 | bdb_exists: .long 0 |
| 150 | #endif |
| 151 | |
| 152 | /********************************************************************** |
| 153 | * |
| 154 | * Some handy macros |
| 155 | * |
| 156 | */ |
| 157 | |
| 158 | #define R(foo) ((foo)-KERNBASE) |
| 159 | |
| 160 | #define ALLOCPAGES(foo) \ |
| 161 | movl R(physfree), %esi ; \ |
| 162 | movl $((foo)*PAGE_SIZE), %eax ; \ |
| 163 | addl %esi, %eax ; \ |
| 164 | movl %eax, R(physfree) ; \ |
| 165 | movl %esi, %edi ; \ |
| 166 | movl $((foo)*PAGE_SIZE),%ecx ; \ |
| 167 | xorl %eax,%eax ; \ |
| 168 | cld ; \ |
| 169 | rep ; \ |
| 170 | stosb |
| 171 | |
| 172 | /* |
| 173 | * fillkpt |
| 174 | * eax = page frame address |
| 175 | * ebx = index into page table |
| 176 | * ecx = how many pages to map |
| 177 | * base = base address of page dir/table |
| 178 | * prot = protection bits |
| 179 | */ |
| 180 | #define fillkpt(base, prot) \ |
| 181 | shll $2,%ebx ; \ |
| 182 | addl base,%ebx ; \ |
| 183 | orl $PG_V,%eax ; \ |
| 184 | orl prot,%eax ; \ |
| 185 | 1: movl %eax,(%ebx) ; \ |
| 186 | addl $PAGE_SIZE,%eax ; /* increment physical address */ \ |
| 187 | addl $4,%ebx ; /* next pte */ \ |
| 188 | loop 1b |
| 189 | |
| 190 | /* |
| 191 | * fillkptphys(prot) |
| 192 | * eax = physical address |
| 193 | * ecx = how many pages to map |
| 194 | * prot = protection bits |
| 195 | */ |
| 196 | #define fillkptphys(prot) \ |
| 197 | movl %eax, %ebx ; \ |
| 198 | shrl $PAGE_SHIFT, %ebx ; \ |
| 199 | fillkpt(R(KPTphys), prot) |
| 200 | |
| 201 | .text |
| 202 | /********************************************************************** |
| 203 | * |
| 204 | * This is where the bootblocks start us, set the ball rolling... |
| 205 | * |
| 206 | */ |
| 207 | NON_GPROF_ENTRY(btext) |
| 208 | |
| 209 | #ifdef BDE_DEBUGGER |
| 210 | #ifdef BIOS_STEALS_3K |
| 211 | cmpl $0x0375c339,0x95504 |
| 212 | #else |
| 213 | cmpl $0x0375c339,0x96104 /* XXX - debugger signature */ |
| 214 | #endif |
| 215 | jne 1f |
| 216 | movb $1,R(bdb_exists) |
| 217 | 1: |
| 218 | #endif |
| 219 | /* Tell the bios to warmboot next time */ |
| 220 | movw $0x1234,0x472 |
| 221 | |
| 222 | /* Set up a real frame in case the double return in newboot is executed. */ |
| 223 | pushl %ebp |
| 224 | movl %esp, %ebp |
| 225 | |
| 226 | /* Don't trust what the BIOS gives for eflags. */ |
| 227 | pushl $PSL_KERNEL |
| 228 | popfl |
| 229 | |
| 230 | /* |
| 231 | * Don't trust what the BIOS gives for %fs and %gs. Trust the bootstrap |
| 232 | * to set %cs, %ds, %es and %ss. |
| 233 | */ |
| 234 | mov %ds, %ax |
| 235 | mov %ax, %fs |
| 236 | mov %ax, %gs |
| 237 | |
| 238 | /* |
| 239 | * Clear the bss. Not all boot programs do it, and it is our job anyway. |
| 240 | * |
| 241 | * XXX we don't check that there is memory for our bss and page tables |
| 242 | * before using it. |
| 243 | * |
| 244 | * Note: we must be careful to not overwrite an active gdt or idt. They |
| 245 | * inactive from now until we switch to new ones, since we don't load any |
| 246 | * more segment registers or permit interrupts until after the switch. |
| 247 | */ |
| 248 | movl $R(_end),%ecx |
| 249 | movl $R(_edata),%edi |
| 250 | subl %edi,%ecx |
| 251 | xorl %eax,%eax |
| 252 | cld |
| 253 | rep |
| 254 | stosb |
| 255 | |
| 256 | call recover_bootinfo |
| 257 | |
| 258 | /* Get onto a stack that we can trust. */ |
| 259 | /* |
| 260 | * XXX this step is delayed in case recover_bootinfo needs to return via |
| 261 | * the old stack, but it need not be, since recover_bootinfo actually |
| 262 | * returns via the old frame. |
| 263 | */ |
| 264 | movl $R(.tmpstk),%esp |
| 265 | |
| 266 | call identify_cpu |
| 267 | |
| 268 | call create_pagetables |
| 269 | |
| 270 | /* |
| 271 | * If the CPU has support for VME, turn it on. |
| 272 | */ |
| 273 | testl $CPUID_VME, R(cpu_feature) |
| 274 | jz 1f |
| 275 | movl %cr4, %eax |
| 276 | orl $CR4_VME, %eax |
| 277 | movl %eax, %cr4 |
| 278 | 1: |
| 279 | |
| 280 | #ifdef BDE_DEBUGGER |
| 281 | /* |
| 282 | * Adjust as much as possible for paging before enabling paging so that the |
| 283 | * adjustments can be traced. |
| 284 | */ |
| 285 | call bdb_prepare_paging |
| 286 | #endif |
| 287 | |
| 288 | /* Now enable paging */ |
| 289 | movl R(IdlePTD), %eax |
| 290 | movl %eax,%cr3 /* load ptd addr into mmu */ |
| 291 | movl %cr0,%eax /* get control word */ |
| 292 | orl $CR0_PE|CR0_PG,%eax /* enable paging */ |
| 293 | movl %eax,%cr0 /* and let's page NOW! */ |
| 294 | |
| 295 | |
| 296 | #ifdef BDE_DEBUGGER |
| 297 | /* |
| 298 | * Complete the adjustments for paging so that we can keep tracing through |
| 299 | * initi386() after the low (physical) addresses for the gdt and idt become |
| 300 | * invalid. |
| 301 | */ |
| 302 | call bdb_commit_paging |
| 303 | #endif |
| 304 | |
| 305 | pushl $begin /* jump to high virtualized address */ |
| 306 | ret |
| 307 | |
| 308 | /* now running relocated at KERNBASE where the system is linked to run */ |
| 309 | begin: |
| 310 | |
| 311 | /* |
| 312 | * set up the bootstrap stack. The pcb sits at the end of the |
| 313 | * bootstrap stack. |
| 314 | */ |
| 315 | /* set up bootstrap stack */ |
| 316 | movl proc0paddr,%esp /* location of in-kernel pages */ |
| 317 | addl $UPAGES*PAGE_SIZE-PCB_SIZE,%esp |
| 318 | xorl %eax,%eax /* mark end of frames */ |
| 319 | movl %eax,%ebp |
| 320 | /*movl proc0paddr,%eax*/ |
| 321 | movl IdlePTD, %esi |
| 322 | movl %esi,PCB_CR3(%esp) |
| 323 | |
| 324 | testl $CPUID_PGE, R(cpu_feature) |
| 325 | jz 1f |
| 326 | movl %cr4, %eax |
| 327 | orl $CR4_PGE, %eax |
| 328 | movl %eax, %cr4 |
| 329 | 1: |
| 330 | |
| 331 | movl physfree, %esi |
| 332 | pushl %esi /* value of first for init386(first) */ |
| 333 | |
| 334 | call init386 /* wire 386 chip for unix operation */ |
| 335 | popl %esi |
| 336 | |
| 337 | call mi_startup /* autoconfiguration, mountroot etc */ |
| 338 | |
| 339 | hlt /* never returns to here */ |
| 340 | |
| 341 | /* |
| 342 | * Signal trampoline, copied to top of user stack |
| 343 | */ |
| 344 | NON_GPROF_ENTRY(sigcode) |
| 345 | call *SIGF_HANDLER(%esp) /* call signal handler */ |
| 346 | lea SIGF_UC(%esp),%eax /* get ucontext_t */ |
| 347 | pushl %eax |
| 348 | testl $PSL_VM,UC_EFLAGS(%eax) |
| 349 | jne 9f |
| 350 | 9: |
| 351 | movl $SYS_sigreturn,%eax |
| 352 | pushl %eax /* junk to fake return addr. */ |
| 353 | int $0x80 /* enter kernel with args */ |
| 354 | 0: jmp 0b |
| 355 | |
| 356 | ALIGN_TEXT |
| 357 | esigcode: |
| 358 | |
| 359 | .data |
| 360 | .globl szsigcode |
| 361 | szsigcode: |
| 362 | .long esigcode - sigcode |
| 363 | .text |
| 364 | |
| 365 | /********************************************************************** |
| 366 | * |
| 367 | * Recover the bootinfo passed to us from the boot program |
| 368 | * |
| 369 | */ |
| 370 | recover_bootinfo: |
| 371 | /* |
| 372 | * This code is called in different ways depending on what loaded |
| 373 | * and started the kernel. This is used to detect how we get the |
| 374 | * arguments from the other code and what we do with them. |
| 375 | * |
| 376 | * Old disk boot blocks: |
| 377 | * (*btext)(howto, bootdev, cyloffset, esym); |
| 378 | * [return address == 0, and can NOT be returned to] |
| 379 | * [cyloffset was not supported by the FreeBSD boot code |
| 380 | * and always passed in as 0] |
| 381 | * [esym is also known as total in the boot code, and |
| 382 | * was never properly supported by the FreeBSD boot code] |
| 383 | * |
| 384 | * Old diskless netboot code: |
| 385 | * (*btext)(0,0,0,0,&nfsdiskless,0,0,0); |
| 386 | * [return address != 0, and can NOT be returned to] |
| 387 | * If we are being booted by this code it will NOT work, |
| 388 | * so we are just going to halt if we find this case. |
| 389 | * |
| 390 | * New uniform boot code: |
| 391 | * (*btext)(howto, bootdev, 0, 0, 0, &bootinfo) |
| 392 | * [return address != 0, and can be returned to] |
| 393 | * |
| 394 | * There may seem to be a lot of wasted arguments in here, but |
| 395 | * that is so the newer boot code can still load very old kernels |
| 396 | * and old boot code can load new kernels. |
| 397 | */ |
| 398 | |
| 399 | /* |
| 400 | * The old style disk boot blocks fake a frame on the stack and |
| 401 | * did an lret to get here. The frame on the stack has a return |
| 402 | * address of 0. |
| 403 | */ |
| 404 | cmpl $0,4(%ebp) |
| 405 | je olddiskboot |
| 406 | |
| 407 | /* |
| 408 | * We have some form of return address, so this is either the |
| 409 | * old diskless netboot code, or the new uniform code. That can |
| 410 | * be detected by looking at the 5th argument, if it is 0 |
| 411 | * we are being booted by the new uniform boot code. |
| 412 | */ |
| 413 | cmpl $0,24(%ebp) |
| 414 | je newboot |
| 415 | |
| 416 | /* |
| 417 | * Seems we have been loaded by the old diskless boot code, we |
| 418 | * don't stand a chance of running as the diskless structure |
| 419 | * changed considerably between the two, so just halt. |
| 420 | */ |
| 421 | hlt |
| 422 | |
| 423 | /* |
| 424 | * We have been loaded by the new uniform boot code. |
| 425 | * Let's check the bootinfo version, and if we do not understand |
| 426 | * it we return to the loader with a status of 1 to indicate this error |
| 427 | */ |
| 428 | newboot: |
| 429 | movl 28(%ebp),%ebx /* &bootinfo.version */ |
| 430 | movl BI_VERSION(%ebx),%eax |
| 431 | cmpl $1,%eax /* We only understand version 1 */ |
| 432 | je 1f |
| 433 | movl $1,%eax /* Return status */ |
| 434 | leave |
| 435 | /* |
| 436 | * XXX this returns to our caller's caller (as is required) since |
| 437 | * we didn't set up a frame and our caller did. |
| 438 | */ |
| 439 | ret |
| 440 | |
| 441 | 1: |
| 442 | /* |
| 443 | * If we have a kernelname copy it in |
| 444 | */ |
| 445 | movl BI_KERNELNAME(%ebx),%esi |
| 446 | cmpl $0,%esi |
| 447 | je 2f /* No kernelname */ |
| 448 | movl $MAXPATHLEN,%ecx /* Brute force!!! */ |
| 449 | movl $R(kernelname),%edi |
| 450 | cmpb $'/',(%esi) /* Make sure it starts with a slash */ |
| 451 | je 1f |
| 452 | movb $'/',(%edi) |
| 453 | incl %edi |
| 454 | decl %ecx |
| 455 | 1: |
| 456 | cld |
| 457 | rep |
| 458 | movsb |
| 459 | |
| 460 | 2: |
| 461 | /* |
| 462 | * Determine the size of the boot loader's copy of the bootinfo |
| 463 | * struct. This is impossible to do properly because old versions |
| 464 | * of the struct don't contain a size field and there are 2 old |
| 465 | * versions with the same version number. |
| 466 | */ |
| 467 | movl $BI_ENDCOMMON,%ecx /* prepare for sizeless version */ |
| 468 | testl $RB_BOOTINFO,8(%ebp) /* bi_size (and bootinfo) valid? */ |
| 469 | je got_bi_size /* no, sizeless version */ |
| 470 | movl BI_SIZE(%ebx),%ecx |
| 471 | got_bi_size: |
| 472 | |
| 473 | /* |
| 474 | * Copy the common part of the bootinfo struct |
| 475 | */ |
| 476 | movl %ebx,%esi |
| 477 | movl $R(bootinfo),%edi |
| 478 | cmpl $BOOTINFO_SIZE,%ecx |
| 479 | jbe got_common_bi_size |
| 480 | movl $BOOTINFO_SIZE,%ecx |
| 481 | got_common_bi_size: |
| 482 | cld |
| 483 | rep |
| 484 | movsb |
| 485 | |
| 486 | #ifdef NFS_ROOT |
| 487 | #ifndef BOOTP_NFSV3 |
| 488 | /* |
| 489 | * If we have a nfs_diskless structure copy it in |
| 490 | */ |
| 491 | movl BI_NFS_DISKLESS(%ebx),%esi |
| 492 | cmpl $0,%esi |
| 493 | je olddiskboot |
| 494 | movl $R(nfs_diskless),%edi |
| 495 | movl $NFSDISKLESS_SIZE,%ecx |
| 496 | cld |
| 497 | rep |
| 498 | movsb |
| 499 | movl $R(nfs_diskless_valid),%edi |
| 500 | movl $1,(%edi) |
| 501 | #endif |
| 502 | #endif |
| 503 | |
| 504 | /* |
| 505 | * The old style disk boot. |
| 506 | * (*btext)(howto, bootdev, cyloffset, esym); |
| 507 | * Note that the newer boot code just falls into here to pick |
| 508 | * up howto and bootdev, cyloffset and esym are no longer used |
| 509 | */ |
| 510 | olddiskboot: |
| 511 | movl 8(%ebp),%eax |
| 512 | movl %eax,R(boothowto) |
| 513 | movl 12(%ebp),%eax |
| 514 | movl %eax,R(bootdev) |
| 515 | |
| 516 | ret |
| 517 | |
| 518 | |
| 519 | /********************************************************************** |
| 520 | * |
| 521 | * Identify the CPU and initialize anything special about it |
| 522 | * |
| 523 | */ |
| 524 | identify_cpu: |
| 525 | |
| 526 | /* Try to toggle alignment check flag; does not exist on 386. */ |
| 527 | pushfl |
| 528 | popl %eax |
| 529 | movl %eax,%ecx |
| 530 | orl $PSL_AC,%eax |
| 531 | pushl %eax |
| 532 | popfl |
| 533 | pushfl |
| 534 | popl %eax |
| 535 | xorl %ecx,%eax |
| 536 | andl $PSL_AC,%eax |
| 537 | pushl %ecx |
| 538 | popfl |
| 539 | |
| 540 | testl %eax,%eax |
| 541 | jnz try486 |
| 542 | |
| 543 | /* NexGen CPU does not have aligment check flag. */ |
| 544 | pushfl |
| 545 | movl $0x5555, %eax |
| 546 | xorl %edx, %edx |
| 547 | movl $2, %ecx |
| 548 | clc |
| 549 | divl %ecx |
| 550 | jz trynexgen |
| 551 | popfl |
| 552 | movl $CPU_386,R(cpu) |
| 553 | jmp 3f |
| 554 | |
| 555 | trynexgen: |
| 556 | popfl |
| 557 | movl $CPU_NX586,R(cpu) |
| 558 | movl $0x4778654e,R(cpu_vendor) # store vendor string |
| 559 | movl $0x72446e65,R(cpu_vendor+4) |
| 560 | movl $0x6e657669,R(cpu_vendor+8) |
| 561 | movl $0,R(cpu_vendor+12) |
| 562 | jmp 3f |
| 563 | |
| 564 | try486: /* Try to toggle identification flag; does not exist on early 486s. */ |
| 565 | pushfl |
| 566 | popl %eax |
| 567 | movl %eax,%ecx |
| 568 | xorl $PSL_ID,%eax |
| 569 | pushl %eax |
| 570 | popfl |
| 571 | pushfl |
| 572 | popl %eax |
| 573 | xorl %ecx,%eax |
| 574 | andl $PSL_ID,%eax |
| 575 | pushl %ecx |
| 576 | popfl |
| 577 | |
| 578 | testl %eax,%eax |
| 579 | jnz trycpuid |
| 580 | movl $CPU_486,R(cpu) |
| 581 | |
| 582 | /* |
| 583 | * Check Cyrix CPU |
| 584 | * Cyrix CPUs do not change the undefined flags following |
| 585 | * execution of the divide instruction which divides 5 by 2. |
| 586 | * |
| 587 | * Note: CPUID is enabled on M2, so it passes another way. |
| 588 | */ |
| 589 | pushfl |
| 590 | movl $0x5555, %eax |
| 591 | xorl %edx, %edx |
| 592 | movl $2, %ecx |
| 593 | clc |
| 594 | divl %ecx |
| 595 | jnc trycyrix |
| 596 | popfl |
| 597 | jmp 3f /* You may use Intel CPU. */ |
| 598 | |
| 599 | trycyrix: |
| 600 | popfl |
| 601 | /* |
| 602 | * IBM Bluelighting CPU also doesn't change the undefined flags. |
| 603 | * Because IBM doesn't disclose the information for Bluelighting |
| 604 | * CPU, we couldn't distinguish it from Cyrix's (including IBM |
| 605 | * brand of Cyrix CPUs). |
| 606 | */ |
| 607 | movl $0x69727943,R(cpu_vendor) # store vendor string |
| 608 | movl $0x736e4978,R(cpu_vendor+4) |
| 609 | movl $0x64616574,R(cpu_vendor+8) |
| 610 | jmp 3f |
| 611 | |
| 612 | trycpuid: /* Use the `cpuid' instruction. */ |
| 613 | xorl %eax,%eax |
| 614 | cpuid # cpuid 0 |
| 615 | movl %eax,R(cpu_high) # highest capability |
| 616 | movl %ebx,R(cpu_vendor) # store vendor string |
| 617 | movl %edx,R(cpu_vendor+4) |
| 618 | movl %ecx,R(cpu_vendor+8) |
| 619 | movb $0,R(cpu_vendor+12) |
| 620 | |
| 621 | movl $1,%eax |
| 622 | cpuid # cpuid 1 |
| 623 | movl %eax,R(cpu_id) # store cpu_id |
| 624 | movl %ebx,R(cpu_procinfo) # store cpu_procinfo |
| 625 | movl %edx,R(cpu_feature) # store cpu_feature |
| 626 | movl %ecx,R(cpu_feature2) # store cpu_feature2 |
| 627 | rorl $8,%eax # extract family type |
| 628 | andl $15,%eax |
| 629 | cmpl $5,%eax |
| 630 | jae 1f |
| 631 | |
| 632 | /* less than Pentium; must be 486 */ |
| 633 | movl $CPU_486,R(cpu) |
| 634 | jmp 3f |
| 635 | 1: |
| 636 | /* a Pentium? */ |
| 637 | cmpl $5,%eax |
| 638 | jne 2f |
| 639 | movl $CPU_586,R(cpu) |
| 640 | jmp 3f |
| 641 | 2: |
| 642 | /* Greater than Pentium...call it a Pentium Pro */ |
| 643 | movl $CPU_686,R(cpu) |
| 644 | 3: |
| 645 | ret |
| 646 | |
| 647 | |
| 648 | /********************************************************************** |
| 649 | * |
| 650 | * Create the first page directory and its page tables. |
| 651 | * |
| 652 | */ |
| 653 | |
| 654 | create_pagetables: |
| 655 | |
| 656 | /* Find end of kernel image (rounded up to a page boundary). */ |
| 657 | movl $R(end),%esi |
| 658 | |
| 659 | /* Include symbols, if any. */ |
| 660 | movl R(bootinfo+BI_ESYMTAB),%edi |
| 661 | testl %edi,%edi |
| 662 | je over_symalloc |
| 663 | movl %edi,%esi |
| 664 | movl $KERNBASE,%edi |
| 665 | addl %edi,R(bootinfo+BI_SYMTAB) |
| 666 | addl %edi,R(bootinfo+BI_ESYMTAB) |
| 667 | over_symalloc: |
| 668 | |
| 669 | /* If we are told where the end of the kernel space is, believe it. */ |
| 670 | movl R(bootinfo+BI_KERNEND),%edi |
| 671 | testl %edi,%edi |
| 672 | je no_kernend |
| 673 | movl %edi,%esi |
| 674 | no_kernend: |
| 675 | |
| 676 | addl $PAGE_MASK,%esi |
| 677 | andl $~PAGE_MASK,%esi |
| 678 | movl %esi,R(KERNend) /* save end of kernel */ |
| 679 | movl %esi,R(physfree) /* next free page is at end of kernel */ |
| 680 | |
| 681 | |
| 682 | /* Allocate Kernel Page Tables */ |
| 683 | ALLOCPAGES(NKPT) |
| 684 | movl %esi,R(KPTphys) |
| 685 | |
| 686 | /* Allocate Page Table Directory */ |
| 687 | ALLOCPAGES(1) |
| 688 | movl %esi,R(IdlePTD) |
| 689 | |
| 690 | /* Allocate UPAGES */ |
| 691 | ALLOCPAGES(UPAGES) |
| 692 | movl %esi,R(p0upa) |
| 693 | addl $KERNBASE, %esi |
| 694 | movl %esi, R(proc0paddr) |
| 695 | |
| 696 | ALLOCPAGES(1) /* vm86/bios stack */ |
| 697 | movl %esi,R(vm86phystk) |
| 698 | |
| 699 | ALLOCPAGES(3) /* pgtable + ext + IOPAGES */ |
| 700 | movl %esi,R(vm86pa) |
| 701 | addl $KERNBASE, %esi |
| 702 | movl %esi, R(vm86paddr) |
| 703 | |
| 704 | /* Allocate cpu0's mdglobaldata */ |
| 705 | ALLOCPAGES(MDGLOBALDATA_BASEALLOC_PAGES) |
| 706 | movl %esi,R(cpu0pp) |
| 707 | #if 0 |
| 708 | addl $KERNBASE, %esi |
| 709 | movl %esi, R(cpu0prvpage) /* relocated to KVM space */ |
| 710 | #endif |
| 711 | |
| 712 | /* Allocate cpu0's idle stack */ |
| 713 | ALLOCPAGES(UPAGES) |
| 714 | movl %esi,R(cpu0idlestk) |
| 715 | |
| 716 | /* Allocate SMP page table page */ |
| 717 | ALLOCPAGES(1) |
| 718 | movl %esi,R(SMPptpa) |
| 719 | addl $KERNBASE, %esi |
| 720 | movl %esi, R(SMPpt) /* relocated to KVM space */ |
| 721 | |
| 722 | /* Map read-only from zero to the end of the kernel text section */ |
| 723 | xorl %eax, %eax |
| 724 | #ifdef BDE_DEBUGGER |
| 725 | /* If the debugger is present, actually map everything read-write. */ |
| 726 | cmpl $0,R(bdb_exists) |
| 727 | jne map_read_write |
| 728 | #endif |
| 729 | xorl %edx,%edx |
| 730 | |
| 731 | #if !defined(SMP) |
| 732 | testl $CPUID_PGE, R(cpu_feature) |
| 733 | jz 2f |
| 734 | orl $PG_G,%edx |
| 735 | #endif |
| 736 | |
| 737 | 2: movl $R(etext),%ecx |
| 738 | addl $PAGE_MASK,%ecx |
| 739 | shrl $PAGE_SHIFT,%ecx |
| 740 | fillkptphys(%edx) |
| 741 | |
| 742 | /* Map read-write, data, bss and symbols */ |
| 743 | movl $R(etext),%eax |
| 744 | addl $PAGE_MASK, %eax |
| 745 | andl $~PAGE_MASK, %eax |
| 746 | map_read_write: |
| 747 | movl $PG_RW,%edx |
| 748 | #if !defined(SMP) |
| 749 | testl $CPUID_PGE, R(cpu_feature) |
| 750 | jz 1f |
| 751 | orl $PG_G,%edx |
| 752 | #endif |
| 753 | |
| 754 | 1: movl R(KERNend),%ecx |
| 755 | subl %eax,%ecx |
| 756 | shrl $PAGE_SHIFT,%ecx |
| 757 | fillkptphys(%edx) |
| 758 | |
| 759 | /* Map page directory. */ |
| 760 | movl R(IdlePTD), %eax |
| 761 | movl $1, %ecx |
| 762 | fillkptphys($PG_RW) |
| 763 | |
| 764 | /* Map proc0's UPAGES in the physical way ... */ |
| 765 | movl R(p0upa), %eax |
| 766 | movl $UPAGES, %ecx |
| 767 | fillkptphys($PG_RW) |
| 768 | |
| 769 | /* Map ISA hole */ |
| 770 | movl $ISA_HOLE_START, %eax |
| 771 | movl $ISA_HOLE_LENGTH>>PAGE_SHIFT, %ecx |
| 772 | fillkptphys($PG_RW) |
| 773 | |
| 774 | /* Map space for the vm86 region */ |
| 775 | movl R(vm86phystk), %eax |
| 776 | movl $4, %ecx |
| 777 | fillkptphys($PG_RW) |
| 778 | |
| 779 | /* Map page 0 into the vm86 page table */ |
| 780 | movl $0, %eax |
| 781 | movl $0, %ebx |
| 782 | movl $1, %ecx |
| 783 | fillkpt(R(vm86pa), $PG_RW|PG_U) |
| 784 | |
| 785 | /* ...likewise for the ISA hole */ |
| 786 | movl $ISA_HOLE_START, %eax |
| 787 | movl $ISA_HOLE_START>>PAGE_SHIFT, %ebx |
| 788 | movl $ISA_HOLE_LENGTH>>PAGE_SHIFT, %ecx |
| 789 | fillkpt(R(vm86pa), $PG_RW|PG_U) |
| 790 | |
| 791 | #if 0 |
| 792 | /* Map cpu0's mdglobaldata into global kmem (N pages @ cpu0pp) */ |
| 793 | movl R(cpu0pp), %eax |
| 794 | movl $MDGLOBALDATA_BASEALLOC_PAGES, %ecx |
| 795 | fillkptphys($PG_RW) |
| 796 | #endif |
| 797 | |
| 798 | /* Map SMP page table page into global kmem FWIW */ |
| 799 | movl R(SMPptpa), %eax |
| 800 | movl $1, %ecx |
| 801 | fillkptphys($PG_RW) |
| 802 | |
| 803 | /* Map the private page into the SMP page table */ |
| 804 | movl R(cpu0pp), %eax |
| 805 | movl $0, %ebx /* pte offset = 0 */ |
| 806 | /* N private pages coming right up */ |
| 807 | movl $MDGLOBALDATA_BASEALLOC_PAGES, %ecx |
| 808 | fillkpt(R(SMPptpa), $PG_RW) |
| 809 | |
| 810 | /* Map the cpu0's idle thread stack */ |
| 811 | movl R(cpu0idlestk), %eax |
| 812 | movl $PS_IDLESTACK_PAGE, %ebx |
| 813 | movl $UPAGES, %ecx |
| 814 | fillkpt(R(SMPptpa), $PG_RW) |
| 815 | |
| 816 | /* ... and put the page table table in the pde. */ |
| 817 | movl R(SMPptpa), %eax |
| 818 | movl $MPPTDI, %ebx |
| 819 | movl $1, %ecx |
| 820 | fillkpt(R(IdlePTD), $PG_RW) |
| 821 | |
| 822 | /* Fakeup VA for the local apic to allow early traps. */ |
| 823 | ALLOCPAGES(1) |
| 824 | movl %esi, %eax |
| 825 | movl $(NPTEPG-1), %ebx /* pte offset = NTEPG-1 */ |
| 826 | movl $1, %ecx /* one private pt coming right up */ |
| 827 | fillkpt(R(SMPptpa), $PG_RW) |
| 828 | |
| 829 | #ifdef SMP |
| 830 | /* Initialize mp lock to allow early traps */ |
| 831 | movl $0, R(mp_lock) |
| 832 | #endif /* SMP */ |
| 833 | |
| 834 | /* install a pde for temporary double map of bottom of VA */ |
| 835 | movl R(KPTphys), %eax |
| 836 | xorl %ebx, %ebx |
| 837 | movl $NKPT, %ecx |
| 838 | fillkpt(R(IdlePTD), $PG_RW) |
| 839 | |
| 840 | /* install pde's for pt's */ |
| 841 | movl R(KPTphys), %eax |
| 842 | movl $KPTDI, %ebx |
| 843 | movl $NKPT, %ecx |
| 844 | fillkpt(R(IdlePTD), $PG_RW) |
| 845 | |
| 846 | /* install a pde recursively mapping page directory as a page table */ |
| 847 | movl R(IdlePTD), %eax |
| 848 | movl $PTDPTDI, %ebx |
| 849 | movl $1,%ecx |
| 850 | fillkpt(R(IdlePTD), $PG_RW) |
| 851 | |
| 852 | ret |
| 853 | |
| 854 | #ifdef BDE_DEBUGGER |
| 855 | bdb_prepare_paging: |
| 856 | cmpl $0,R(bdb_exists) |
| 857 | je bdb_prepare_paging_exit |
| 858 | |
| 859 | subl $6,%esp |
| 860 | |
| 861 | /* |
| 862 | * Copy and convert debugger entries from the bootstrap gdt and idt |
| 863 | * to the kernel gdt and idt. Everything is still in low memory. |
| 864 | * Tracing continues to work after paging is enabled because the |
| 865 | * low memory addresses remain valid until everything is relocated. |
| 866 | * However, tracing through the setidt() that initializes the trace |
| 867 | * trap will crash. |
| 868 | */ |
| 869 | sgdt (%esp) |
| 870 | movl 2(%esp),%esi /* base address of bootstrap gdt */ |
| 871 | movl $R(gdt),%edi |
| 872 | movl %edi,2(%esp) /* prepare to load kernel gdt */ |
| 873 | movl $8*18/4,%ecx |
| 874 | cld |
| 875 | rep /* copy gdt */ |
| 876 | movsl |
| 877 | movl $R(gdt),-8+2(%edi) /* adjust gdt self-ptr */ |
| 878 | movb $0x92,-8+5(%edi) |
| 879 | lgdt (%esp) |
| 880 | |
| 881 | sidt (%esp) |
| 882 | movl 2(%esp),%esi /* base address of current idt */ |
| 883 | movl 8+4(%esi),%eax /* convert dbg descriptor to ... */ |
| 884 | movw 8(%esi),%ax |
| 885 | movl %eax,R(bdb_dbg_ljmp+1) /* ... immediate offset ... */ |
| 886 | movl 8+2(%esi),%eax |
| 887 | movw %ax,R(bdb_dbg_ljmp+5) /* ... and selector for ljmp */ |
| 888 | movl 24+4(%esi),%eax /* same for bpt descriptor */ |
| 889 | movw 24(%esi),%ax |
| 890 | movl %eax,R(bdb_bpt_ljmp+1) |
| 891 | movl 24+2(%esi),%eax |
| 892 | movw %ax,R(bdb_bpt_ljmp+5) |
| 893 | movl R(idt),%edi |
| 894 | movl %edi,2(%esp) /* prepare to load kernel idt */ |
| 895 | movl $8*4/4,%ecx |
| 896 | cld |
| 897 | rep /* copy idt */ |
| 898 | movsl |
| 899 | lidt (%esp) |
| 900 | |
| 901 | addl $6,%esp |
| 902 | |
| 903 | bdb_prepare_paging_exit: |
| 904 | ret |
| 905 | |
| 906 | /* Relocate debugger gdt entries and gdt and idt pointers. */ |
| 907 | bdb_commit_paging: |
| 908 | cmpl $0,_bdb_exists |
| 909 | je bdb_commit_paging_exit |
| 910 | |
| 911 | movl $_gdt+8*9,%eax /* adjust slots 9-17 */ |
| 912 | movl $9,%ecx |
| 913 | reloc_gdt: |
| 914 | movb $KERNBASE>>24,7(%eax) /* top byte of base addresses, was 0, */ |
| 915 | addl $8,%eax /* now KERNBASE>>24 */ |
| 916 | loop reloc_gdt |
| 917 | |
| 918 | subl $6,%esp |
| 919 | sgdt (%esp) |
| 920 | addl $KERNBASE,2(%esp) |
| 921 | lgdt (%esp) |
| 922 | sidt (%esp) |
| 923 | addl $KERNBASE,2(%esp) |
| 924 | lidt (%esp) |
| 925 | addl $6,%esp |
| 926 | |
| 927 | int $3 |
| 928 | |
| 929 | bdb_commit_paging_exit: |
| 930 | ret |
| 931 | |
| 932 | #endif /* BDE_DEBUGGER */ |