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