src/arch/i386/transitions/librm.S

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