| blob | c90c9ec4c6e71b27f9d1e9b3c36342e82ba6003d |
1 ;; -----------------------------------------------------------------------
2 ;;
3 ;; Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
4 ;;
5 ;; This program is free software; you can redistribute it and/or modify
6 ;; it under the terms of the GNU General Public License as published by
7 ;; the Free Software Foundation, Inc., 53 Temple Place Ste 330,
8 ;; Boston MA 02111-1307, USA; either version 2 of the License, or
9 ;; (at your option) any later version; incorporated herein by reference.
10 ;;
11 ;; -----------------------------------------------------------------------
13 ;;
14 ;; com32.inc
15 ;;
16 ;; Common code for running a COM32 image
17 ;;
19 ;
20 ; Load a COM32 image. A COM32 image is the 32-bit analogue to a DOS
21 ; .com file. A COM32 image is loaded at address 0x101000, with %esp
22 ; set to the high end of usable memory.
23 ;
24 ; A COM32 image should begin with the magic bytes:
25 ; B8 FF 4C CD 21, which is "mov eax,0x21cd4cff" in 32-bit mode and
26 ; "mov ax,0x4cff; int 0x21" in 16-bit mode. This will abort the
27 ; program with an error if run in 16-bit mode.
28 ;
29 pm_idt: equ 0x100000
30 pm_entry: equ 0x101000
32 bits 16
33 section .data
34 align 2, db 0
35 com32_pmidt:
36 dw 8*256 ; Limit
37 dd pm_idt ; Address
39 com32_rmidt:
40 dw 0ffffh ; Limit
41 dd 0 ; Address
43 section .text
44 is_com32_image:
45 push si ; Save file handle
46 push dx ; File length held in DX:AX
47 push ax
49 call make_plain_cmdline
50 ; Copy the command line into the low cmdline buffer
51 mov ax,real_mode_seg
52 mov fs,ax
53 mov si,cmd_line_here
54 mov di,command_line
55 mov cx,[CmdLinePtr]
56 inc cx ; Include final null
57 sub cx,si
58 fs rep movsb
60 call highmemsize ; We need the high memory size...
61 call comboot_setup_api ; Set up the COMBOOT-style API
63 mov edi,pm_entry ; Load address
64 pop eax ; File length
65 pop si ; File handle
66 xor dx,dx ; No padding
67 mov bx,abort_check ; Don't print dots, but allow abort
68 call load_high
70 com32_start:
71 mov ebx,com32_call_start ; Where to go in PM
73 com32_enter_pm:
74 cli
75 mov ax,cs
76 mov ds,ax
77 mov [RealModeSSSP],sp
78 mov [RealModeSSSP+2],ss
79 cld
80 call a20_test
81 jnz .a20ok
82 call enable_a20
84 .a20ok:
85 mov byte [bcopy_gdt.TSS+5],89h ; Mark TSS unbusy
87 lgdt [bcopy_gdt] ; We can use the same GDT just fine
88 lidt [com32_pmidt] ; Set up the IDT
89 mov eax,cr0
90 or al,1
91 mov cr0,eax ; Enter protected mode
92 jmp PM_CS32:.in_pm
94 bits 32
95 .in_pm:
96 xor eax,eax ; Available for future use...
97 mov fs,eax
98 mov gs,eax
99 lldt ax
101 mov al,PM_DS32 ; Set up data segments
102 mov es,eax
103 mov ds,eax
104 mov ss,eax
106 mov al,PM_TSS ; Be nice to Intel's VT by
107 ltr ax ; giving it a valid TR
109 mov esp,[PMESP] ; Load protmode %esp if available
110 jmp ebx ; Go to where we need to go
112 ;
113 ; This is invoked right before the actually starting the COM32
114 ; progam, in 32-bit mode...
115 ;
116 com32_call_start:
117 ;
118 ; Point the stack to the end of high memory
119 ;
120 mov esp,[word HighMemSize]
122 ;
123 ; Set up the protmode IDT and the interrupt jump buffers
124 ; We set these up in the system area at 0x100000,
125 ; but we could also put them beyond the stack.
126 ;
127 mov edi,pm_idt
129 ; Form an interrupt gate descriptor
130 mov eax,0x00200000+((pm_idt+8*256)&0x0000ffff)
131 mov ebx,0x0000ee00+((pm_idt+8*256)&0xffff0000)
132 xor ecx,ecx
133 inc ch ; ecx <- 256
135 push ecx
136 .make_idt:
137 stosd
138 add eax,8
139 xchg eax,ebx
140 stosd
141 xchg eax,ebx
142 loop .make_idt
144 pop ecx
146 ; Each entry in the interrupt jump buffer contains
147 ; the following instructions:
148 ;
149 ; 00000000 60 pushad
150 ; 00000001 B0xx mov al,<interrupt#>
151 ; 00000003 E9xxxxxxxx jmp com32_handle_interrupt
153 mov eax,0e900b060h
154 mov ebx,com32_handle_interrupt-(pm_idt+8*256+8)
156 .make_ijb:
157 stosd
158 sub [edi-2],cl ; Interrupt #
159 xchg eax,ebx
160 stosd
161 sub eax,8
162 xchg eax,ebx
163 loop .make_ijb
165 ; Now everything is set up for interrupts...
167 push dword com32_cfarcall ; Cfarcall entry point
168 push dword com32_farcall ; Farcall entry point
169 push dword (1 << 16) ; 64K bounce buffer
170 push dword (comboot_seg << 4) ; Bounce buffer address
171 push dword com32_intcall ; Intcall entry point
172 push dword command_line ; Command line pointer
173 push dword 6 ; Argument count
174 sti ; Interrupts OK now
175 call pm_entry ; Run the program...
176 ; ... on return, fall through to com32_exit ...
178 com32_exit:
179 mov bx,com32_done ; Return to command loop
181 com32_enter_rm:
182 cli
183 cld
184 mov [PMESP],esp ; Save exit %esp
185 xor esp,esp ; Make sure the high bits are zero
186 jmp PM_CS16:.in_pm16 ; Return to 16-bit mode first
188 bits 16
189 .in_pm16:
190 mov ax,PM_DS16_RM ; Real-mode-like segment
191 mov es,ax
192 mov ds,ax
193 mov ss,ax
194 mov fs,ax
195 mov gs,ax
197 lidt [com32_rmidt] ; Real-mode IDT (rm needs no GDT)
198 mov eax,cr0
199 and al,~1
200 mov cr0,eax
201 jmp 0:.in_rm
203 .in_rm: ; Back in real mode
204 mov ax,cs ; Set up sane segments
205 mov ds,ax
206 mov es,ax
207 mov fs,ax
208 mov gs,ax
209 lss sp,[RealModeSSSP] ; Restore stack
210 jmp bx ; Go to whereever we need to go...
212 com32_done:
213 call disable_a20
214 sti
215 jmp enter_command
217 ;
218 ; 16-bit support code
219 ;
220 bits 16
222 ;
223 ; 16-bit interrupt-handling code
224 ;
225 com32_int_rm:
226 pushf ; Flags on stack
227 push cs ; Return segment
228 push word .cont ; Return address
229 push dword edx ; Segment:offset of IVT entry
230 retf ; Invoke IVT routine
231 .cont: ; ... on resume ...
232 mov ebx,com32_int_resume
233 jmp com32_enter_pm ; Go back to PM
235 ;
236 ; 16-bit intcall/farcall handling code
237 ;
238 com32_sys_rm:
239 pop gs
240 pop fs
241 pop es
242 pop ds
243 popad
244 popfd
245 mov [cs:Com32SysSP],sp
246 retf ; Invoke routine
247 .return:
248 ; We clean up SP here because we don't know if the
249 ; routine returned with RET, RETF or IRET
250 mov sp,[cs:Com32SysSP]
251 pushfd
252 pushad
253 push ds
254 push es
255 push fs
256 push gs
257 mov ebx,com32_syscall.resume
258 jmp com32_enter_pm
260 ;
261 ; 16-bit cfarcall handing code
262 ;
263 com32_cfar_rm:
264 retf
265 .return:
266 mov sp,[cs:Com32SysSP]
267 mov [cs:RealModeEAX],eax
268 mov ebx,com32_cfarcall.resume
269 jmp com32_enter_pm
271 ;
272 ; 32-bit support code
273 ;
274 bits 32
276 ;
277 ; This is invoked on getting an interrupt in protected mode. At
278 ; this point, we need to context-switch to real mode and invoke
279 ; the interrupt routine.
280 ;
281 ; When this gets invoked, the registers are saved on the stack and
282 ; AL contains the register number.
283 ;
284 com32_handle_interrupt:
285 movzx eax,al
286 xor ebx,ebx ; Actually makes the code smaller
287 mov edx,[ebx+eax*4] ; Get the segment:offset of the routine
288 mov bx,com32_int_rm
289 jmp com32_enter_rm ; Go to real mode
291 com32_int_resume:
292 popad
293 iret
295 ;
296 ; Intcall/farcall invocation. We manifest a structure on the real-mode stack,
297 ; containing the com32sys_t structure from <com32.h> as well as
298 ; the following entries (from low to high address):
299 ; - Target offset
300 ; - Target segment
301 ; - Return offset
302 ; - Return segment (== real mode cs == 0)
303 ; - Return flags
304 ;
305 com32_farcall:
306 pushfd ; Save IF among other things...
307 pushad ; We only need to save some, but...
309 mov eax,[esp+10*4] ; CS:IP
310 jmp com32_syscall
313 com32_intcall:
314 pushfd ; Save IF among other things...
315 pushad ; We only need to save some, but...
317 movzx eax,byte [esp+10*4] ; INT number
318 mov eax,[eax*4] ; Get CS:IP from low memory
320 com32_syscall:
321 cld
323 movzx edi,word [word RealModeSSSP]
324 movzx ebx,word [word RealModeSSSP+2]
325 sub edi,54 ; Allocate 54 bytes
326 mov [word RealModeSSSP],di
327 shl ebx,4
328 add edi,ebx ; Create linear address
330 mov esi,[esp+11*4] ; Source regs
331 xor ecx,ecx
332 mov cl,11 ; 44 bytes to copy
333 rep movsd
335 ; EAX is already set up to be CS:IP
336 stosd ; Save in stack frame
337 mov eax,com32_sys_rm.return ; Return seg:offs
338 stosd ; Save in stack frame
339 mov eax,[edi-12] ; Return flags
340 and eax,0x200cd7 ; Mask (potentially) unsafe flags
341 mov [edi-12],eax ; Primary flags entry
342 stosw ; Return flags
344 mov bx,com32_sys_rm
345 jmp com32_enter_rm ; Go to real mode
347 ; On return, the 44-byte return structure is on the
348 ; real-mode stack, plus the 10 additional bytes used
349 ; by the target address (see above.)
350 .resume:
351 movzx esi,word [word RealModeSSSP]
352 movzx eax,word [word RealModeSSSP+2]
353 mov edi,[esp+12*4] ; Dest regs
354 shl eax,4
355 add esi,eax ; Create linear address
356 and edi,edi ; NULL pointer?
357 jnz .do_copy
358 .no_copy: mov edi,esi ; Do a dummy copy-to-self
359 .do_copy: xor ecx,ecx
360 mov cl,11 ; 44 bytes
361 rep movsd ; Copy register block
363 add dword [word RealModeSSSP],54 ; Remove from stack
365 popad
366 popfd
367 ret ; Return to 32-bit program
369 ;
370 ; Cfarcall invocation. We copy the stack frame to the real-mode stack,
371 ; followed by the return CS:IP and the CS:IP of the target function.
372 ;
373 com32_cfarcall:
374 pushfd
375 pushad
377 cld
378 mov ecx,[esp+12*4] ; Size of stack frame
380 movzx edi,word [word RealModeSSSP]
381 movzx ebx,word [word RealModeSSSP+2]
382 mov [word Com32SysSP],di
383 sub edi,ecx ; Allocate space for stack frame
384 and edi,~3 ; Round
385 sub edi,4*2 ; Return pointer, return value
386 mov [word RealModeSSSP],di
387 shl ebx,4
388 add edi,ebx ; Create linear address
390 mov eax,[esp+10*4] ; CS:IP
391 stosd ; Save to stack frame
392 mov eax,com32_cfar_rm.return ; Return seg:off
393 stosd
394 mov esi,[esp+11*4] ; Stack frame
395 mov eax,ecx ; Copy the stack frame
396 shr ecx,2
397 rep movsd
398 mov ecx,eax
399 and ecx,3
400 rep movsb
402 mov bx,com32_cfar_rm
403 jmp com32_enter_rm
405 .resume:
406 popad
407 mov eax,[word RealModeEAX]
408 popfd
409 ret
411 bits 16
413 section .bss1
414 alignb 4
415 RealModeSSSP resd 1 ; Real-mode SS:SP
416 RealModeEAX resd 1 ; Real mode EAX
417 PMESP resd 1 ; Protected-mode ESP
418 Com32SysSP resw 1 ; SP saved during COM32 syscall
420 section .text