Preserve the whole of %esp across prot_call(). We have to split this
[people/lynusvaz/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", "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.  The
233  * high word of the real-mode %esp is set to zero.  All real-mode data
234  * segment registers are loaded from the saved rm_ds.  Interrupts are
235  * *not* enabled, since we want to be able to use prot_to_real in an
236  * ISR.  All other registers may be destroyed.
237  *
238  * The return address for this function should be a 32-bit (sic)
239  * real-mode offset within .code16.
240  *
241  * Parameters: 
242  *   %ecx : number of bytes to move from PM stack to RM stack
243  *
244  ****************************************************************************
245  */
246         .section ".text"
247         .code32
248 prot_to_real:
249         /* Add return address to data to be moved to RM stack */
250         addl    $4, %ecx
251         
252         /* Real-mode %ss:sp => %ebp:edx */
253         movzwl  rm_ss, %ebp
254         movzwl  rm_sp, %edx
255         subl    %ecx, %edx
256         
257         /* Move data from PM stack to RM stack */
258         movl    %ebp, %eax
259         shll    $4, %eax
260         leal    (%eax,%edx), %edi
261         subl    virt_offset, %edi
262         movl    %esp, %esi
263         rep movsb
264         
265         /* Record protected-mode %esp (after removal of data) */
266         movl    %esi, pm_esp
267
268         /* Load real-mode segment limits */
269         movw    $REAL_DS, %ax
270         movw    %ax, %ds
271         movw    %ax, %es
272         movw    %ax, %fs
273         movw    %ax, %gs
274         movw    %ax, %ss
275         ljmp    $REAL_CS, $1f
276         .section ".text16"
277         .code16
278 1:
279         /* Switch to real mode */
280         movl    %cr0, %eax
281         andb    $0!CR0_PE, %al
282         movl    %eax, %cr0
283         ljmp    *p2r_jump_vector
284 p2r_jump_target:
285
286         /* Set up real-mode stack */
287         movw    %bp, %ss
288         movl    %edx, %esp
289         
290         /* Set up real-mode data segments */
291         movw    %cs:rm_ds, %ax
292         movw    %ax, %ds
293         movw    %ax, %es
294         movw    %ax, %fs
295         movw    %ax, %gs
296
297         /* Return to real-mode address */
298         data32 ret
299
300
301         /* Real-mode code and data segments.  Assigned by the call to
302          * init_librm.  rm_cs doubles as the segment part of the jump
303          * vector used by prot_to_real.  rm_ds is located in .text16
304          * rather than .data16 because code needs to be able to locate
305          * the data segment.
306          */
307         .section ".data16"
308 p2r_jump_vector:
309         .word   p2r_jump_target
310 rm_cs:  .word 0
311         .section ".text16"
312 rm_ds:  .word 0
313         
314 /****************************************************************************
315  * prot_call (real-mode near call, 32-bit real-mode return address)
316  *
317  * Call a specific C function in the protected-mode code.  The
318  * prototype of the C function must be
319  *   void function ( struct i386_all_regs *ix86 ); 
320  * ix86 will point to a struct containing the real-mode registers
321  * at entry to prot_call.  
322  *
323  * All registers will be preserved across prot_call(), unless the C
324  * function explicitly overwrites values in ix86.  Interrupt status
325  * and GDT will also be preserved.  Gate A20 will be enabled.
326  *
327  * Parameters:
328  *   function : virtual address of protected-mode function to call
329  *
330  * Example usage:
331  *      pushl   $pxe_api_call
332  *      call    prot_call
333  *      addw    $4, %sp
334  * to call in to the C function
335  *      void pxe_api_call ( struct i386_all_regs *ix86 );
336  ****************************************************************************
337  */
338
339 #define PC_OFFSET_GDT ( 0 )
340 #define PC_OFFSET_IX86 ( PC_OFFSET_GDT + 8 /* pad to 8 to keep alignment */ )
341 #define PC_OFFSET_RETADDR ( PC_OFFSET_IX86 + SIZEOF_I386_ALL_REGS )
342 #define PC_OFFSET_FUNCTION ( PC_OFFSET_RETADDR + 4 )
343 #define PC_OFFSET_END ( PC_OFFSET_FUNCTION + 4 )
344
345         .section ".text16"
346         .code16
347         .globl prot_call
348 prot_call:
349         /* Preserve registers, flags and GDT on external RM stack */
350         pushfl
351         pushal
352         pushw   %gs
353         pushw   %fs
354         pushw   %es
355         pushw   %ds
356         pushw   %ss
357         pushw   %cs
358         subw    $8, %sp
359         movw    %sp, %bp
360         sgdt    (%bp)
361
362         /* For sanity's sake, clear the direction flag as soon as possible */
363         cld
364
365         /* Switch to protected mode and move register dump to PM stack */
366         movl    $PC_OFFSET_END, %ecx
367         pushl   $1f
368         jmp     real_to_prot
369         .section ".text"
370         .code32
371 1:
372         /* Set up environment expected by C code */
373         call    gateA20_set
374
375         /* Call function */
376         leal    PC_OFFSET_IX86(%esp), %eax
377         pushl   %eax
378         call    *(PC_OFFSET_FUNCTION+4)(%esp)
379         popl    %eax /* discard */
380
381         /* Switch to real mode and move register dump back to RM stack */
382         movl    $PC_OFFSET_END, %ecx
383         pushl   $1f
384         jmp     prot_to_real
385         .section ".text16"
386         .code16
387 1:      
388         /* Reload GDT, restore registers and flags and return.  Note
389          * that %esp is restored manually, since popal discards it.
390          */
391         movw    %sp, %bp
392         lgdt    (%bp)
393         addw    $12, %sp /* also skip %cs and %ss */
394         popw    %ds
395         popw    %es
396         popw    %fs
397         popw    %gs
398         popal
399         movl    -20(%esp), %esp /* -20(%sp) is not a valid 80386 expression.
400                                  * -20(%esp) is safe because prot_to_real
401                                  * zeroes the high word of %esp, and interrupts
402                                  * are still disabled at this point. */
403         popfl
404         data32 ret
405
406 /****************************************************************************
407  * real_call (protected-mode near call, 32-bit virtual return address)
408  *
409  * Call a real-mode function from protected-mode code.
410  *
411  * The non-segment register values will be passed directly to the
412  * real-mode code.  The segment registers will be set as per
413  * prot_to_real.  The non-segment register values set by the real-mode
414  * function will be passed back to the protected-mode caller.  A
415  * result of this is that this routine cannot be called directly from
416  * C code, since it clobbers registers that the C ABI expects the
417  * callee to preserve.  Gate A20 will be re-enabled in case the
418  * real-mode routine disabled it.
419  *
420  * librm.h defines two convenient macros for using real_call:
421  * REAL_CALL and REAL_EXEC.  See librm.h and realmode.h for details
422  * and examples.
423  *
424  * Parameters:
425  *   (32-bit) near pointer to real-mode function to call
426  *
427  * Returns: none
428  ****************************************************************************
429  */
430
431 #define RC_OFFSET_PRESERVE_REGS ( 0 )
432 #define RC_OFFSET_RETADDR ( RC_OFFSET_PRESERVE_REGS + SIZEOF_I386_REGS )
433 #define RC_OFFSET_FUNCTION ( RC_OFFSET_RETADDR + 4 )
434 #define RC_OFFSET_END ( RC_OFFSET_FUNCTION + 4 )
435
436         .section ".text"
437         .code32
438         .globl real_call
439 real_call:
440         /* Create register dump on PM stack */
441         pushal
442
443         /* Switch to real mode and move register dump to RM stack */
444         movl    $RC_OFFSET_END, %ecx
445         pushl   $1f
446         jmp     prot_to_real
447         .section ".text16"
448         .code16
449 1:
450         /* Construct call to real-mode function */
451         movw    %sp, %bp
452         movw    RC_OFFSET_FUNCTION(%bp), %ax
453         movw    %ax, rc_function
454
455         /* Call real-mode function */
456         popal
457         call    *rc_function
458         pushal
459
460         /* Switch to protected mode and move register dump back to PM stack */
461         movl    $RC_OFFSET_END, %ecx
462         pushl   $1f
463         jmp     real_to_prot
464         .section ".text"
465         .code32
466 1:
467         /* Set up environment expected by C code */
468         call    gateA20_set
469
470         /* Restore registers and return */
471         popal
472         ret
473
474
475         /* Function vector, used because */
476         .section ".data16"
477 rc_function:    .word 0
478         
479 /****************************************************************************
480  * Stored real-mode and protected-mode stack pointers
481  *
482  * The real-mode stack pointer is stored here whenever real_to_prot
483  * is called and restored whenever prot_to_real is called.  The
484  * converse happens for the protected-mode stack pointer.
485  *
486  * Despite initial appearances this scheme is, in fact re-entrant,
487  * because program flow dictates that we always return via the point
488  * we left by.  For example:
489  *    PXE API call entry
490  *  1   real => prot
491  *        ...
492  *        Print a text string
493  *          ...
494  *  2       prot => real
495  *            INT 10
496  *  3       real => prot
497  *          ...
498  *        ...
499  *  4   prot => real
500  *    PXE API call exit
501  *
502  * At point 1, the RM mode stack value, say RPXE, is stored in
503  * rm_ss,sp.  We want this value to still be present in rm_ss,sp when
504  * we reach point 4.
505  *
506  * At point 2, the RM stack value is restored from RPXE.  At point 3,
507  * the RM stack value is again stored in rm_ss,sp.  This *does*
508  * overwrite the RPXE that we have stored there, but it's the same
509  * value, since the code between points 2 and 3 has managed to return
510  * to us.
511  ****************************************************************************
512  */
513         .section ".data"
514         .globl rm_sp
515 rm_sp:  .word 0
516         .globl rm_ss
517 rm_ss:  .word 0
518         .globl pm_esp
519 pm_esp: .long _estack
520
521 /****************************************************************************
522  * Virtual address offsets
523  *
524  * These are used by the protected-mode code to map between virtual
525  * and physical addresses, and to access variables in the .text16 or
526  * .data16 segments.
527  ****************************************************************************
528  */
529         /* Internal copies, created by init_librm (which runs in real mode) */
530         .section ".data16"
531 _virt_offset:   .long 0
532 _text16:        .long 0
533 _data16:        .long 0
534
535         /* Externally-visible copies, created by real_to_prot */
536         .section ".data"
537         .globl virt_offset
538 virt_offset:    .long 0 
539         .globl text16
540 text16:         .long 0
541         .globl data16
542 data16:         .long 0