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