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