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