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