b1f9dd594a06bc2d1c4461f3ca5f6d713e234497
[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 /* 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