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