![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to librm.S CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / arch / i386 / transitions|
Return to librm.S CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / arch / i386 / transitions |
1.1 ! root 1: /* ! 2: * librm: a library for interfacing to real-mode code ! 3: * ! 4: * Michael Brown <[email protected]> ! 5: * ! 6: */ ! 7: ! 8: FILE_LICENCE ( GPL2_OR_LATER ) ! 9: ! 10: /* Drag in local definitions */ ! 11: #include "librm.h" ! 12: ! 13: /* For switches to/from protected mode */ ! 14: #define CR0_PE 1 ! 15: ! 16: /* Size of various C data structures */ ! 17: #define SIZEOF_I386_SEG_REGS 12 ! 18: #define SIZEOF_I386_REGS 32 ! 19: #define SIZEOF_REAL_MODE_REGS ( SIZEOF_I386_SEG_REGS + SIZEOF_I386_REGS ) ! 20: #define SIZEOF_I386_FLAGS 4 ! 21: #define SIZEOF_I386_ALL_REGS ( SIZEOF_REAL_MODE_REGS + SIZEOF_I386_FLAGS ) ! 22: ! 23: .arch i386 ! 24: ! 25: /**************************************************************************** ! 26: * Global descriptor table ! 27: * ! 28: * Call init_librm to set up the GDT before attempting to use any ! 29: * protected-mode code. ! 30: * ! 31: * NOTE: This must be located before prot_to_real, otherwise gas ! 32: * throws a "can't handle non absolute segment in `ljmp'" error due to ! 33: * not knowing the value of REAL_CS when the ljmp is encountered. ! 34: * ! 35: * Note also that putting ".word gdt_end - gdt - 1" directly into ! 36: * gdt_limit, rather than going via gdt_length, will also produce the ! 37: * "non absolute segment" error. This is most probably a bug in gas. ! 38: **************************************************************************** ! 39: */ ! 40: .section ".data16", "aw", @progbits ! 41: .align 16 ! 42: gdt: ! 43: gdtr: /* The first GDT entry is unused, the GDTR can fit here. */ ! 44: gdt_limit: .word gdt_length - 1 ! 45: gdt_base: .long 0 ! 46: .word 0 /* padding */ ! 47: ! 48: .org gdt + VIRTUAL_CS, 0 ! 49: virtual_cs: /* 32 bit protected mode code segment, virtual addresses */ ! 50: .word 0xffff, 0 ! 51: .byte 0, 0x9f, 0xcf, 0 ! 52: ! 53: .org gdt + VIRTUAL_DS, 0 ! 54: virtual_ds: /* 32 bit protected mode data segment, virtual addresses */ ! 55: .word 0xffff, 0 ! 56: .byte 0, 0x93, 0xcf, 0 ! 57: ! 58: .org gdt + PHYSICAL_CS, 0 ! 59: physical_cs: /* 32 bit protected mode code segment, physical addresses */ ! 60: .word 0xffff, 0 ! 61: .byte 0, 0x9f, 0xcf, 0 ! 62: ! 63: .org gdt + PHYSICAL_DS, 0 ! 64: physical_ds: /* 32 bit protected mode data segment, physical addresses */ ! 65: .word 0xffff, 0 ! 66: .byte 0, 0x93, 0xcf, 0 ! 67: ! 68: .org gdt + REAL_CS, 0 ! 69: real_cs: /* 16 bit flat real mode code segment */ ! 70: .word 0xffff, 0 ! 71: .byte 0, 0x9b, 0x8f, 0 ! 72: ! 73: .org gdt + REAL_DS ! 74: real_ds: /* 16 bit flat real mode data segment */ ! 75: .word 0xffff, 0 ! 76: .byte 0, 0x93, 0x8f, 0 ! 77: ! 78: gdt_end: ! 79: .equ gdt_length, gdt_end - gdt ! 80: ! 81: /**************************************************************************** ! 82: * init_librm (real-mode far call, 16-bit real-mode far return address) ! 83: * ! 84: * Initialise the GDT ready for transitions to protected mode. ! 85: * ! 86: * Parameters: ! 87: * %cs : .text16 segment ! 88: * %ds : .data16 segment ! 89: * %edi : Physical base of protected-mode code (virt_offset) ! 90: **************************************************************************** ! 91: */ ! 92: .section ".text16", "ax", @progbits ! 93: .code16 ! 94: .globl init_librm ! 95: init_librm: ! 96: /* Preserve registers */ ! 97: pushl %eax ! 98: pushl %ebx ! 99: ! 100: /* Store _virt_offset and set up virtual_cs and virtual_ds segments */ ! 101: movl %edi, %eax ! 102: movw $virtual_cs, %bx ! 103: call set_seg_base ! 104: movw $virtual_ds, %bx ! 105: call set_seg_base ! 106: movl %edi, _virt_offset ! 107: ! 108: /* Negate virt_offset */ ! 109: negl %edi ! 110: ! 111: /* Store rm_cs and _text16, set up real_cs segment */ ! 112: xorl %eax, %eax ! 113: movw %cs, %ax ! 114: movw %ax, rm_cs ! 115: shll $4, %eax ! 116: movw $real_cs, %bx ! 117: call set_seg_base ! 118: addr32 leal (%eax, %edi), %ebx ! 119: movl %ebx, _text16 ! 120: ! 121: /* Store rm_ds and _data16, set up real_ds segment */ ! 122: xorl %eax, %eax ! 123: movw %ds, %ax ! 124: movw %ax, %cs:rm_ds ! 125: shll $4, %eax ! 126: movw $real_ds, %bx ! 127: call set_seg_base ! 128: addr32 leal (%eax, %edi), %ebx ! 129: movl %ebx, _data16 ! 130: ! 131: /* Set GDT and IDT base */ ! 132: movl %eax, gdt_base ! 133: addl $gdt, gdt_base ! 134: call idt_init ! 135: ! 136: /* Restore registers */ ! 137: negl %edi ! 138: popl %ebx ! 139: popl %eax ! 140: lret ! 141: ! 142: .section ".text16", "ax", @progbits ! 143: .code16 ! 144: .weak idt_init ! 145: set_seg_base: ! 146: 1: movw %ax, 2(%bx) ! 147: rorl $16, %eax ! 148: movb %al, 4(%bx) ! 149: movb %ah, 7(%bx) ! 150: roll $16, %eax ! 151: idt_init: /* Reuse the return opcode here */ ! 152: ret ! 153: ! 154: /**************************************************************************** ! 155: * real_to_prot (real-mode near call, 32-bit virtual return address) ! 156: * ! 157: * Switch from 16-bit real-mode to 32-bit protected mode with virtual ! 158: * addresses. The real-mode %ss:sp is stored in rm_ss and rm_sp, and ! 159: * the protected-mode %esp is restored from the saved pm_esp. ! 160: * Interrupts are disabled. All other registers may be destroyed. ! 161: * ! 162: * The return address for this function should be a 32-bit virtual ! 163: * address. ! 164: * ! 165: * Parameters: ! 166: * %ecx : number of bytes to move from RM stack to PM stack ! 167: * ! 168: **************************************************************************** ! 169: */ ! 170: .section ".text16", "ax", @progbits ! 171: .code16 ! 172: real_to_prot: ! 173: /* Enable A20 line */ ! 174: call enable_a20 ! 175: /* A failure at this point is fatal, and there's nothing we ! 176: * can do about it other than lock the machine to make the ! 177: * problem immediately visible. ! 178: */ ! 179: 1: jc 1b ! 180: ! 181: /* Make sure we have our data segment available */ ! 182: movw %cs:rm_ds, %ax ! 183: movw %ax, %ds ! 184: ! 185: /* Add _virt_offset, _text16 and _data16 to stack to be ! 186: * copied, and also copy the return address. ! 187: */ ! 188: pushl _virt_offset ! 189: pushl _text16 ! 190: pushl _data16 ! 191: addw $16, %cx /* %ecx must be less than 64kB anyway */ ! 192: ! 193: /* Real-mode %ss:%sp => %ebp:%edx and virtual address => %esi */ ! 194: xorl %ebp, %ebp ! 195: movw %ss, %bp ! 196: movzwl %sp, %edx ! 197: movl %ebp, %eax ! 198: shll $4, %eax ! 199: addr32 leal (%eax,%edx), %esi ! 200: subl _virt_offset, %esi ! 201: ! 202: /* Switch to protected mode */ ! 203: cli ! 204: data32 lgdt gdtr ! 205: data32 lidt idtr ! 206: movl %cr0, %eax ! 207: orb $CR0_PE, %al ! 208: movl %eax, %cr0 ! 209: data32 ljmp $VIRTUAL_CS, $1f ! 210: .section ".text", "ax", @progbits ! 211: .code32 ! 212: 1: ! 213: /* Set up protected-mode data segments and stack pointer */ ! 214: movw $VIRTUAL_DS, %ax ! 215: movw %ax, %ds ! 216: movw %ax, %es ! 217: movw %ax, %fs ! 218: movw %ax, %gs ! 219: movw %ax, %ss ! 220: movl pm_esp, %esp ! 221: ! 222: /* Record real-mode %ss:sp (after removal of data) */ ! 223: movw %bp, rm_ss ! 224: addl %ecx, %edx ! 225: movw %dx, rm_sp ! 226: ! 227: /* Move data from RM stack to PM stack */ ! 228: subl %ecx, %esp ! 229: movl %esp, %edi ! 230: rep movsb ! 231: ! 232: /* Publish virt_offset, text16 and data16 for PM code to use */ ! 233: popl data16 ! 234: popl text16 ! 235: popl virt_offset ! 236: ! 237: /* Return to virtual address */ ! 238: ret ! 239: ! 240: /* Default IDTR with no interrupts */ ! 241: .section ".data16", "aw", @progbits ! 242: .weak idtr ! 243: idtr: ! 244: rm_idtr: ! 245: .word 0xffff /* limit */ ! 246: .long 0 /* base */ ! 247: ! 248: /**************************************************************************** ! 249: * prot_to_real (protected-mode near call, 32-bit real-mode return address) ! 250: * ! 251: * Switch from 32-bit protected mode with virtual addresses to 16-bit ! 252: * real mode. The protected-mode %esp is stored in pm_esp and the ! 253: * real-mode %ss:sp is restored from the saved rm_ss and rm_sp. The ! 254: * high word of the real-mode %esp is set to zero. All real-mode data ! 255: * segment registers are loaded from the saved rm_ds. Interrupts are ! 256: * *not* enabled, since we want to be able to use prot_to_real in an ! 257: * ISR. All other registers may be destroyed. ! 258: * ! 259: * The return address for this function should be a 32-bit (sic) ! 260: * real-mode offset within .code16. ! 261: * ! 262: * Parameters: ! 263: * %ecx : number of bytes to move from PM stack to RM stack ! 264: * ! 265: **************************************************************************** ! 266: */ ! 267: .section ".text", "ax", @progbits ! 268: .code32 ! 269: prot_to_real: ! 270: /* Add return address to data to be moved to RM stack */ ! 271: addl $4, %ecx ! 272: ! 273: /* Real-mode %ss:sp => %ebp:edx and virtual address => %edi */ ! 274: movzwl rm_ss, %ebp ! 275: movzwl rm_sp, %edx ! 276: subl %ecx, %edx ! 277: movl %ebp, %eax ! 278: shll $4, %eax ! 279: leal (%eax,%edx), %edi ! 280: subl virt_offset, %edi ! 281: ! 282: /* Move data from PM stack to RM stack */ ! 283: movl %esp, %esi ! 284: rep movsb ! 285: ! 286: /* Record protected-mode %esp (after removal of data) */ ! 287: movl %esi, pm_esp ! 288: ! 289: /* Load real-mode segment limits */ ! 290: movw $REAL_DS, %ax ! 291: movw %ax, %ds ! 292: movw %ax, %es ! 293: movw %ax, %fs ! 294: movw %ax, %gs ! 295: movw %ax, %ss ! 296: ljmp $REAL_CS, $1f ! 297: .section ".text16", "ax", @progbits ! 298: .code16 ! 299: 1: ! 300: /* Switch to real mode */ ! 301: movl %cr0, %eax ! 302: andb $0!CR0_PE, %al ! 303: movl %eax, %cr0 ! 304: ljmp *p2r_jump_vector ! 305: p2r_jump_target: ! 306: ! 307: /* Set up real-mode data segments and stack pointer */ ! 308: movw %cs:rm_ds, %ax ! 309: movw %ax, %ds ! 310: movw %ax, %es ! 311: movw %ax, %fs ! 312: movw %ax, %gs ! 313: movw %bp, %ss ! 314: movl %edx, %esp ! 315: ! 316: /* Reset IDTR to the real-mode defaults */ ! 317: data32 lidt rm_idtr ! 318: ! 319: /* Return to real-mode address */ ! 320: data32 ret ! 321: ! 322: ! 323: /* Real-mode code and data segments. Assigned by the call to ! 324: * init_librm. rm_cs doubles as the segment part of the jump ! 325: * vector used by prot_to_real. rm_ds is located in .text16 ! 326: * rather than .data16 because code needs to be able to locate ! 327: * the data segment. ! 328: */ ! 329: .section ".data16", "aw", @progbits ! 330: p2r_jump_vector: ! 331: .word p2r_jump_target ! 332: .globl rm_cs ! 333: rm_cs: .word 0 ! 334: .globl rm_ds ! 335: .section ".text16.data", "aw", @progbits ! 336: rm_ds: .word 0 ! 337: ! 338: /**************************************************************************** ! 339: * prot_call (real-mode far call, 16-bit real-mode far return address) ! 340: * ! 341: * Call a specific C function in the protected-mode code. The ! 342: * prototype of the C function must be ! 343: * void function ( struct i386_all_regs *ix86 ); ! 344: * ix86 will point to a struct containing the real-mode registers ! 345: * at entry to prot_call. ! 346: * ! 347: * All registers will be preserved across prot_call(), unless the C ! 348: * function explicitly overwrites values in ix86. Interrupt status ! 349: * and GDT will also be preserved. Gate A20 will be enabled. ! 350: * ! 351: * Note that prot_call() does not rely on the real-mode stack ! 352: * remaining intact in order to return, since everything relevant is ! 353: * copied to the protected-mode stack for the duration of the call. ! 354: * In particular, this means that a real-mode prefix can make a call ! 355: * to main() which will return correctly even if the prefix's stack ! 356: * gets vapourised during the Etherboot run. (The prefix cannot rely ! 357: * on anything else on the stack being preserved, so should move any ! 358: * critical data to registers before calling main()). ! 359: * ! 360: * Parameters: ! 361: * function : virtual address of protected-mode function to call ! 362: * ! 363: * Example usage: ! 364: * pushl $pxe_api_call ! 365: * call prot_call ! 366: * addw $4, %sp ! 367: * to call in to the C function ! 368: * void pxe_api_call ( struct i386_all_regs *ix86 ); ! 369: **************************************************************************** ! 370: */ ! 371: ! 372: #define PC_OFFSET_GDT ( 0 ) ! 373: #define PC_OFFSET_IDT ( PC_OFFSET_GDT + 8 /* pad to 8 to keep alignment */ ) ! 374: #define PC_OFFSET_IX86 ( PC_OFFSET_IDT + 8 /* pad to 8 to keep alignment */ ) ! 375: #define PC_OFFSET_RETADDR ( PC_OFFSET_IX86 + SIZEOF_I386_ALL_REGS ) ! 376: #define PC_OFFSET_FUNCTION ( PC_OFFSET_RETADDR + 4 ) ! 377: #define PC_OFFSET_END ( PC_OFFSET_FUNCTION + 4 ) ! 378: ! 379: .section ".text16", "ax", @progbits ! 380: .code16 ! 381: .globl prot_call ! 382: prot_call: ! 383: /* Preserve registers, flags and GDT on external RM stack */ ! 384: pushfl ! 385: pushal ! 386: pushw %gs ! 387: pushw %fs ! 388: pushw %es ! 389: pushw %ds ! 390: pushw %ss ! 391: pushw %cs ! 392: subw $16, %sp ! 393: movw %sp, %bp ! 394: sidt 8(%bp) ! 395: sgdt (%bp) ! 396: ! 397: /* For sanity's sake, clear the direction flag as soon as possible */ ! 398: cld ! 399: ! 400: /* Switch to protected mode and move register dump to PM stack */ ! 401: movl $PC_OFFSET_END, %ecx ! 402: pushl $1f ! 403: jmp real_to_prot ! 404: .section ".text", "ax", @progbits ! 405: .code32 ! 406: 1: ! 407: /* Call function */ ! 408: leal PC_OFFSET_IX86(%esp), %eax ! 409: pushl %eax ! 410: call *(PC_OFFSET_FUNCTION+4)(%esp) ! 411: popl %eax /* discard */ ! 412: ! 413: /* Switch to real mode and move register dump back to RM stack */ ! 414: movl $PC_OFFSET_END, %ecx ! 415: pushl $1f ! 416: jmp prot_to_real ! 417: .section ".text16", "ax", @progbits ! 418: .code16 ! 419: 1: ! 420: /* Reload GDT and IDT, restore registers and flags and return */ ! 421: movw %sp, %bp ! 422: data32 lgdt (%bp) ! 423: data32 lidt 8(%bp) ! 424: addw $20, %sp /* also skip %cs and %ss */ ! 425: popw %ds ! 426: popw %es ! 427: popw %fs ! 428: popw %gs ! 429: popal ! 430: /* popal skips %esp. We therefore want to do "movl -20(%sp), ! 431: * %esp", but -20(%sp) is not a valid 80386 expression. ! 432: * Fortunately, prot_to_real() zeroes the high word of %esp, so ! 433: * we can just use -20(%esp) instead. ! 434: */ ! 435: addr32 movl -20(%esp), %esp ! 436: popfl ! 437: lret ! 438: ! 439: /**************************************************************************** ! 440: * real_call (protected-mode near call, 32-bit virtual return address) ! 441: * ! 442: * Call a real-mode function from protected-mode code. ! 443: * ! 444: * The non-segment register values will be passed directly to the ! 445: * real-mode code. The segment registers will be set as per ! 446: * prot_to_real. The non-segment register values set by the real-mode ! 447: * function will be passed back to the protected-mode caller. A ! 448: * result of this is that this routine cannot be called directly from ! 449: * C code, since it clobbers registers that the C ABI expects the ! 450: * callee to preserve. ! 451: * ! 452: * librm.h defines a convenient macro REAL_CODE() for using real_call. ! 453: * See librm.h and realmode.h for details and examples. ! 454: * ! 455: * Parameters: ! 456: * (32-bit) near pointer to real-mode function to call ! 457: * ! 458: * Returns: none ! 459: **************************************************************************** ! 460: */ ! 461: ! 462: #define RC_OFFSET_PRESERVE_REGS ( 0 ) ! 463: #define RC_OFFSET_RETADDR ( RC_OFFSET_PRESERVE_REGS + SIZEOF_I386_REGS ) ! 464: #define RC_OFFSET_FUNCTION ( RC_OFFSET_RETADDR + 4 ) ! 465: #define RC_OFFSET_END ( RC_OFFSET_FUNCTION + 4 ) ! 466: ! 467: .section ".text", "ax", @progbits ! 468: .code32 ! 469: .globl real_call ! 470: real_call: ! 471: /* Create register dump and function pointer copy on PM stack */ ! 472: pushal ! 473: pushl RC_OFFSET_FUNCTION(%esp) ! 474: ! 475: /* Switch to real mode and move register dump to RM stack */ ! 476: movl $( RC_OFFSET_RETADDR + 4 /* function pointer copy */ ), %ecx ! 477: pushl $1f ! 478: jmp prot_to_real ! 479: .section ".text16", "ax", @progbits ! 480: .code16 ! 481: 1: ! 482: /* Call real-mode function */ ! 483: popl rc_function ! 484: popal ! 485: call *rc_function ! 486: pushal ! 487: ! 488: /* For sanity's sake, clear the direction flag as soon as possible */ ! 489: cld ! 490: ! 491: /* Switch to protected mode and move register dump back to PM stack */ ! 492: movl $RC_OFFSET_RETADDR, %ecx ! 493: pushl $1f ! 494: jmp real_to_prot ! 495: .section ".text", "ax", @progbits ! 496: .code32 ! 497: 1: ! 498: /* Restore registers and return */ ! 499: popal ! 500: ret ! 501: ! 502: ! 503: /* Function vector, used because "call xx(%sp)" is not a valid ! 504: * 16-bit expression. ! 505: */ ! 506: .section ".data16", "aw", @progbits ! 507: rc_function: .word 0, 0 ! 508: ! 509: /**************************************************************************** ! 510: * Stored real-mode and protected-mode stack pointers ! 511: * ! 512: * The real-mode stack pointer is stored here whenever real_to_prot ! 513: * is called and restored whenever prot_to_real is called. The ! 514: * converse happens for the protected-mode stack pointer. ! 515: * ! 516: * Despite initial appearances this scheme is, in fact re-entrant, ! 517: * because program flow dictates that we always return via the point ! 518: * we left by. For example: ! 519: * PXE API call entry ! 520: * 1 real => prot ! 521: * ... ! 522: * Print a text string ! 523: * ... ! 524: * 2 prot => real ! 525: * INT 10 ! 526: * 3 real => prot ! 527: * ... ! 528: * ... ! 529: * 4 prot => real ! 530: * PXE API call exit ! 531: * ! 532: * At point 1, the RM mode stack value, say RPXE, is stored in ! 533: * rm_ss,sp. We want this value to still be present in rm_ss,sp when ! 534: * we reach point 4. ! 535: * ! 536: * At point 2, the RM stack value is restored from RPXE. At point 3, ! 537: * the RM stack value is again stored in rm_ss,sp. This *does* ! 538: * overwrite the RPXE that we have stored there, but it's the same ! 539: * value, since the code between points 2 and 3 has managed to return ! 540: * to us. ! 541: **************************************************************************** ! 542: */ ! 543: .section ".data", "aw", @progbits ! 544: .globl rm_sp ! 545: rm_sp: .word 0 ! 546: .globl rm_ss ! 547: rm_ss: .word 0 ! 548: pm_esp: .long _estack ! 549: ! 550: /**************************************************************************** ! 551: * Virtual address offsets ! 552: * ! 553: * These are used by the protected-mode code to map between virtual ! 554: * and physical addresses, and to access variables in the .text16 or ! 555: * .data16 segments. ! 556: **************************************************************************** ! 557: */ ! 558: /* Internal copies, created by init_librm (which runs in real mode) */ ! 559: .section ".data16", "aw", @progbits ! 560: _virt_offset: .long 0 ! 561: _text16: .long 0 ! 562: _data16: .long 0 ! 563: ! 564: /* Externally-visible copies, created by real_to_prot */ ! 565: .section ".data", "aw", @progbits ! 566: .globl virt_offset ! 567: virt_offset: .long 0 ! 568: .globl text16 ! 569: text16: .long 0 ! 570: .globl data16 ! 571: data16: .long 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.