mkinitrd-magellan/isolinux/bcopy32.inc

;; $Id: bcopy32.inc,v 1.1 2007-09-01 22:44:04 niro Exp $
;; -----------------------------------------------------------------------
;;   
;;   Copyright 1994-2005 H. Peter Anvin - All Rights Reserved
;;
;;   This program is free software; you can redistribute it and/or modify
;;   it under the terms of the GNU General Public License as published by
;;   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
;;   Boston MA 02111-1307, USA; either version 2 of the License, or
;;   (at your option) any later version; incorporated herein by reference.
;;
;; -----------------------------------------------------------------------

;;
;; bcopy32.inc
;; 
;; 32-bit bcopy routine for real mode
;;

;
; 32-bit bcopy routine for real mode
;
; We enter protected mode, set up a flat 32-bit environment, run rep movsd
; and then exit.  IMPORTANT: This code assumes cs == 0.
;
; This code is probably excessively anal-retentive in its handling of
; segments, but this stuff is painful enough as it is without having to rely
; on everything happening "as it ought to."
;
; NOTE: this code is relocated into low memory, just after the .earlybss
; segment, in order to support to "bcopy over self" operation.
;

		section .bcopy32
		align 8
__bcopy_start:

		; This is in the .text segment since it needs to be
		; contiguous with the rest of the bcopy stuff

bcopy_gdt:	dw bcopy_gdt_size-1	; Null descriptor - contains GDT
		dd bcopy_gdt		; pointer for LGDT instruction
		dw 0
		dd 0000ffffh		; Code segment, use16, readable,
		dd 00009b00h		; present, dpl 0, cover 64K
		dd 0000ffffh		; Data segment, use16, read/write,
		dd 008f9300h		; present, dpl 0, cover all 4G
		dd 0000ffffh		; Data segment, use16, read/write,
		dd 00009300h		; present, dpl 0, cover 64K
		; The rest are used for COM32 only
		dd 0000ffffh		; Code segment, use32, readable,
		dd 00cf9b00h		; present, dpl 0, cover all 4G
		dd 0000ffffh		; Data segment, use32, read/write,
		dd 00cf9300h		; present, dpl 0, cover all 4G
bcopy_gdt_size:	equ $-bcopy_gdt

;
; bcopy:
;	32-bit copy, overlap safe
;
; Inputs:
;	ESI	- source pointer
;	EDI	- target pointer
;	ECX	- byte count
;	DF	- zero
;
; Outputs:
;	ESI	- first byte after source
;	EDI	- first byte after target
;	ECX	- zero
;
bcopy:		push eax
		push esi
		push edi
		push ecx
		pushf			; Saves, among others, the IF flag
		push ds
		push es

		cli
		call enable_a20

		o32 lgdt [cs:bcopy_gdt]
		mov eax,cr0
		or al,1
		mov cr0,eax		; Enter protected mode
		jmp 08h:.in_pm

.in_pm:		mov ax,10h		; Data segment selector
		mov es,ax
		mov ds,ax

		; Don't mess with ss, fs, and gs.  They are never changed
		; and should be able to make it back out of protected mode.
		; This works because (and only because) we don't take
		; interrupt in protected mode.

		cmp esi,edi		; If source > destination, we might
		ja .reverse		; have to copy backwards

.forward:
		mov al,cl		; Save low bits
		and al,3
		shr ecx,2		; Convert to dwords
		a32 rep movsd		; Do our business
		; At this point ecx == 0

		mov cl,al		; Copy any fractional dword
		a32 rep movsb
		jmp .exit

.reverse:
		std			; Reverse copy
		lea esi,[esi+ecx-1]	; Point to final byte
		lea edi,[edi+ecx-1]
		mov eax,ecx
		and ecx,3
		shr eax,2
		a32 rep movsb
		
		; Change ESI/EDI to point to the last dword, instead
		; of the last byte.
		sub esi,3
		sub edi,3
		mov ecx,eax
		a32 rep movsd

		cld

.exit:
		mov ax,18h		; "Real-mode-like" data segment
		mov es,ax
		mov ds,ax

		mov eax,cr0
		and al,~1
		mov cr0,eax		; Disable protected mode
		jmp 0:.in_rm

.in_rm:		; Back in real mode
		pop es
		pop ds
		call disable_a20

		popf			; Re-enables interrupts
		pop eax
		pop edi
		pop esi
		add edi,eax
		add esi,eax
		pop eax
		ret

;
; Routines to enable and disable (yuck) A20.  These routines are gathered
; from tips from a couple of sources, including the Linux kernel and
; http://www.x86.org/.  The need for the delay to be as large as given here
; is indicated by Donnie Barnes of RedHat, the problematic system being an
; IBM ThinkPad 760EL.
;
; We typically toggle A20 twice for every 64K transferred.
; 
%define	io_delay	call _io_delay
%define IO_DELAY_PORT	80h		; Invalid port (we hope!)
%define disable_wait 	32		; How long to wait for a disable

; Note the skip of 2 here
%define A20_DUNNO	0		; A20 type unknown
%define A20_NONE	2		; A20 always on?
%define A20_BIOS	4		; A20 BIOS enable
%define A20_KBC		6		; A20 through KBC
%define A20_FAST	8		; A20 through port 92h

slow_out:	out dx, al		; Fall through

_io_delay:	out IO_DELAY_PORT,al
		out IO_DELAY_PORT,al
		ret

enable_a20:
		pushad
		mov byte [cs:A20Tries],255 ; Times to try to make this work

try_enable_a20:
;
; Flush the caches
;
%if DO_WBINVD
		call try_wbinvd
%endif

;
; If the A20 type is known, jump straight to type
;
		mov bp,[cs:A20Type]
		jmp word [cs:bp+A20List]

;
; First, see if we are on a system with no A20 gate
;
a20_dunno:
a20_none:
		mov byte [cs:A20Type], A20_NONE
		call a20_test
		jnz a20_done

;
; Next, try the BIOS (INT 15h AX=2401h)
;
a20_bios:
		mov byte [cs:A20Type], A20_BIOS
		mov ax,2401h
		pushf				; Some BIOSes muck with IF
		int 15h
		popf

		call a20_test
		jnz a20_done

;
; Enable the keyboard controller A20 gate
;
a20_kbc:
		mov dl, 1			; Allow early exit
		call empty_8042
		jnz a20_done			; A20 live, no need to use KBC

		mov byte [cs:A20Type], A20_KBC	; Starting KBC command sequence

		mov al,0D1h			; Command write
		out 064h, al
		call empty_8042_uncond

		mov al,0DFh			; A20 on
		out 060h, al
		call empty_8042_uncond

		; Verify that A20 actually is enabled.  Do that by
		; observing a word in low memory and the same word in
		; the HMA until they are no longer coherent.  Note that
		; we don't do the same check in the disable case, because
		; we don't want to *require* A20 masking (SYSLINUX should
		; work fine without it, if the BIOS does.)
.kbc_wait:	push cx
		xor cx,cx
.kbc_wait_loop:
		call a20_test
		jnz a20_done_pop
		loop .kbc_wait_loop

		pop cx
;
; Running out of options here.  Final attempt: enable the "fast A20 gate"
;
a20_fast:
		mov byte [cs:A20Type], A20_FAST	; Haven't used the KBC yet
		in al, 092h
		or al,02h
		and al,~01h			; Don't accidentally reset the machine!
		out 092h, al

.fast_wait:	push cx
		xor cx,cx
.fast_wait_loop:
		call a20_test
		jnz a20_done_pop
		loop .fast_wait_loop

		pop cx

;
; Oh bugger.  A20 is not responding.  Try frobbing it again; eventually give up
; and report failure to the user.
;


		dec byte [cs:A20Tries]
		jnz try_enable_a20

		mov si, err_a20
		jmp abort_load
;
; A20 unmasked, proceed...
;
a20_done_pop:	pop cx
a20_done:	popad
		ret

;
; This routine tests if A20 is enabled (ZF = 0).  This routine
; must not destroy any register contents.
;
a20_test:
		push es
		push cx
		push ax
		mov cx,0FFFFh		; HMA = segment 0FFFFh
		mov es,cx
		mov cx,32		; Loop count
		mov ax,[cs:A20Test]
.a20_wait:	inc ax
		mov [cs:A20Test],ax
		io_delay		; Serialize, and fix delay
		cmp ax,[es:A20Test+10h]
		loopz .a20_wait
.a20_done:	pop ax
		pop cx
		pop es
		ret

disable_a20:
		pushad
;
; Flush the caches
;
%if DO_WBINVD
		call try_wbinvd
%endif

		mov bp,[cs:A20Type]
		jmp word [cs:bp+A20DList]

a20d_bios:
		mov ax,2400h
		pushf				; Some BIOSes muck with IF
		int 15h
		popf
		jmp short a20d_snooze

;
; Disable the "fast A20 gate"
;
a20d_fast:
		in al, 092h
		and al,~03h
		out 092h, al
		jmp short a20d_snooze

;
; Disable the keyboard controller A20 gate
;
a20d_kbc:
		call empty_8042_uncond
		mov al,0D1h
		out 064h, al		; Command write
		call empty_8042_uncond
		mov al,0DDh		; A20 off
		out 060h, al
		call empty_8042_uncond
		; Wait a bit for it to take effect
a20d_snooze:
		push cx
		mov cx, disable_wait
.delayloop:	call a20_test
		jz .disabled
		loop .delayloop
.disabled:	pop cx
a20d_dunno:
a20d_none:
		popad
		ret

;
; Routine to empty the 8042 KBC controller.  If dl != 0
; then we will test A20 in the loop and exit if A20 is
; suddenly enabled.
;
empty_8042_uncond:
		xor dl,dl
empty_8042:
		call a20_test
		jz .a20_on
		and dl,dl
		jnz .done
.a20_on:	io_delay
		in al, 064h		; Status port
		test al,1
		jz .no_output
		io_delay
		in al, 060h		; Read input
		jmp short empty_8042
.no_output:
		test al,2
		jnz empty_8042
		io_delay
.done:		ret	

;
; Execute a WBINVD instruction if possible on this CPU
;
%if DO_WBINVD
try_wbinvd:
		wbinvd
		ret
%endif

;
; bcopy_over_self:
;
; This routine is used to shuffle memory around, followed by
; invoking an entry point somewhere in low memory.  This routine
; can clobber any memory above 7C00h, we therefore have to move
; necessary code into the trackbuf area before doing the copy,
; and do adjustments to anything except BSS area references.
;
; NOTE: Since PXELINUX relocates itself, put all these
; references in the ".earlybss" segment.
;
; After performing the copy, this routine resets the stack and
; jumps to the specified entrypoint.
;
; IMPORTANT: This routine does not canonicalize the stack or the
; SS register.  That is the responsibility of the caller.
;
; Inputs:
; 	DS:BX		-> Pointer to list of (dst, src, len) pairs
; 	AX		-> Number of list entries
;	[CS:EntryPoint]	-> CS:IP to jump to
;	On stack	- initial state (fd, ad, ds, es, fs, gs)
;
shuffle_and_boot:
		and ax,ax
		jz .done
.loop:
		mov edi,[bx]
		mov esi,[bx+4]
		mov ecx,[bx+8]
		call bcopy
		add bx,12
		dec ax
		jnz .loop

.done:
		pop gs
		pop fs
		pop es
		pop ds
		popad
		popfd
		jmp far [cs:EntryPoint]

		align 2
A20List		dw a20_dunno, a20_none, a20_bios, a20_kbc, a20_fast
A20DList	dw a20d_dunno, a20d_none, a20d_bios, a20d_kbc, a20d_fast
a20_adjust_cnt	equ ($-A20List)/2

A20Type		dw A20_NONE		; A20 type

		; Total size of .bcopy32 section
		alignb 4, db 0		; Even number of dwords
__bcopy_size	equ $-__bcopy_start

		section .earlybss
		alignb 2
EntryPoint	resd 1			; CS:IP for shuffle_and_boot
SavedSSSP	resd 1			; Saved real mode SS:SP
A20Test		resw 1			; Counter for testing status of A20
A20Tries	resb 1			; Times until giving up on A20
1	niro	532	;; $Id: bcopy32.inc,v 1.1 2007-09-01 22:44:04 niro Exp $
2			;; -----------------------------------------------------------------------
3			;;
4			;; Copyright 1994-2005 H. Peter Anvin - All Rights Reserved
5			;;
6			;; This program is free software; you can redistribute it and/or modify
7			;; it under the terms of the GNU General Public License as published by
8			;; the Free Software Foundation, Inc., 53 Temple Place Ste 330,
9			;; Boston MA 02111-1307, USA; either version 2 of the License, or
10			;; (at your option) any later version; incorporated herein by reference.
11			;;
12			;; -----------------------------------------------------------------------
13
14			;;
15			;; bcopy32.inc
16			;;
17			;; 32-bit bcopy routine for real mode
18			;;
19
20			;
21			; 32-bit bcopy routine for real mode
22			;
23			; We enter protected mode, set up a flat 32-bit environment, run rep movsd
24			; and then exit. IMPORTANT: This code assumes cs == 0.
25			;
26			; This code is probably excessively anal-retentive in its handling of
27			; segments, but this stuff is painful enough as it is without having to rely
28			; on everything happening "as it ought to."
29			;
30			; NOTE: this code is relocated into low memory, just after the .earlybss
31			; segment, in order to support to "bcopy over self" operation.
32			;
33
34			section .bcopy32
35			align 8
36			__bcopy_start:
37
38			; This is in the .text segment since it needs to be
39			; contiguous with the rest of the bcopy stuff
40
41			bcopy_gdt: dw bcopy_gdt_size-1 ; Null descriptor - contains GDT
42			dd bcopy_gdt ; pointer for LGDT instruction
43			dw 0
44			dd 0000ffffh ; Code segment, use16, readable,
45			dd 00009b00h ; present, dpl 0, cover 64K
46			dd 0000ffffh ; Data segment, use16, read/write,
47			dd 008f9300h ; present, dpl 0, cover all 4G
48			dd 0000ffffh ; Data segment, use16, read/write,
49			dd 00009300h ; present, dpl 0, cover 64K
50			; The rest are used for COM32 only
51			dd 0000ffffh ; Code segment, use32, readable,
52			dd 00cf9b00h ; present, dpl 0, cover all 4G
53			dd 0000ffffh ; Data segment, use32, read/write,
54			dd 00cf9300h ; present, dpl 0, cover all 4G
55			bcopy_gdt_size: equ $-bcopy_gdt
56
57			;
58			; bcopy:
59			; 32-bit copy, overlap safe
60			;
61			; Inputs:
62			; ESI - source pointer
63			; EDI - target pointer
64			; ECX - byte count
65			; DF - zero
66			;
67			; Outputs:
68			; ESI - first byte after source
69			; EDI - first byte after target
70			; ECX - zero
71			;
72			bcopy: push eax
73			push esi
74			push edi
75			push ecx
76			pushf ; Saves, among others, the IF flag
77			push ds
78			push es
79
80			cli
81			call enable_a20
82
83			o32 lgdt [cs:bcopy_gdt]
84			mov eax,cr0
85			or al,1
86			mov cr0,eax ; Enter protected mode
87			jmp 08h:.in_pm
88
89			.in_pm: mov ax,10h ; Data segment selector
90			mov es,ax
91			mov ds,ax
92
93			; Don't mess with ss, fs, and gs. They are never changed
94			; and should be able to make it back out of protected mode.
95			; This works because (and only because) we don't take
96			; interrupt in protected mode.
97
98			cmp esi,edi ; If source > destination, we might
99			ja .reverse ; have to copy backwards
100
101			.forward:
102			mov al,cl ; Save low bits
103			and al,3
104			shr ecx,2 ; Convert to dwords
105			a32 rep movsd ; Do our business
106			; At this point ecx == 0
107
108			mov cl,al ; Copy any fractional dword
109			a32 rep movsb
110			jmp .exit
111
112			.reverse:
113			std ; Reverse copy
114			lea esi,[esi+ecx-1] ; Point to final byte
115			lea edi,[edi+ecx-1]
116			mov eax,ecx
117			and ecx,3
118			shr eax,2
119			a32 rep movsb
120
121			; Change ESI/EDI to point to the last dword, instead
122			; of the last byte.
123			sub esi,3
124			sub edi,3
125			mov ecx,eax
126			a32 rep movsd
127
128			cld
129
130			.exit:
131			mov ax,18h ; "Real-mode-like" data segment
132			mov es,ax
133			mov ds,ax
134
135			mov eax,cr0
136			and al,~1
137			mov cr0,eax ; Disable protected mode
138			jmp 0:.in_rm
139
140			.in_rm: ; Back in real mode
141			pop es
142			pop ds
143			call disable_a20
144
145			popf ; Re-enables interrupts
146			pop eax
147			pop edi
148			pop esi
149			add edi,eax
150			add esi,eax
151			pop eax
152			ret
153
154			;
155			; Routines to enable and disable (yuck) A20. These routines are gathered
156			; from tips from a couple of sources, including the Linux kernel and
157			; http://www.x86.org/. The need for the delay to be as large as given here
158			; is indicated by Donnie Barnes of RedHat, the problematic system being an
159			; IBM ThinkPad 760EL.
160			;
161			; We typically toggle A20 twice for every 64K transferred.
162			;
163			%define io_delay call _io_delay
164			%define IO_DELAY_PORT 80h ; Invalid port (we hope!)
165			%define disable_wait 32 ; How long to wait for a disable
166
167			; Note the skip of 2 here
168			%define A20_DUNNO 0 ; A20 type unknown
169			%define A20_NONE 2 ; A20 always on?
170			%define A20_BIOS 4 ; A20 BIOS enable
171			%define A20_KBC 6 ; A20 through KBC
172			%define A20_FAST 8 ; A20 through port 92h
173
174			slow_out: out dx, al ; Fall through
175
176			_io_delay: out IO_DELAY_PORT,al
177			out IO_DELAY_PORT,al
178			ret
179
180			enable_a20:
181			pushad
182			mov byte [cs:A20Tries],255 ; Times to try to make this work
183
184			try_enable_a20:
185			;
186			; Flush the caches
187			;
188			%if DO_WBINVD
189			call try_wbinvd
190			%endif
191
192			;
193			; If the A20 type is known, jump straight to type
194			;
195			mov bp,[cs:A20Type]
196			jmp word [cs:bp+A20List]
197
198			;
199			; First, see if we are on a system with no A20 gate
200			;
201			a20_dunno:
202			a20_none:
203			mov byte [cs:A20Type], A20_NONE
204			call a20_test
205			jnz a20_done
206
207			;
208			; Next, try the BIOS (INT 15h AX=2401h)
209			;
210			a20_bios:
211			mov byte [cs:A20Type], A20_BIOS
212			mov ax,2401h
213			pushf ; Some BIOSes muck with IF
214			int 15h
215			popf
216
217			call a20_test
218			jnz a20_done
219
220			;
221			; Enable the keyboard controller A20 gate
222			;
223			a20_kbc:
224			mov dl, 1 ; Allow early exit
225			call empty_8042
226			jnz a20_done ; A20 live, no need to use KBC
227
228			mov byte [cs:A20Type], A20_KBC ; Starting KBC command sequence
229
230			mov al,0D1h ; Command write
231			out 064h, al
232			call empty_8042_uncond
233
234			mov al,0DFh ; A20 on
235			out 060h, al
236			call empty_8042_uncond
237
238			; Verify that A20 actually is enabled. Do that by
239			; observing a word in low memory and the same word in
240			; the HMA until they are no longer coherent. Note that
241			; we don't do the same check in the disable case, because
242			; we don't want to require A20 masking (SYSLINUX should
243			; work fine without it, if the BIOS does.)
244			.kbc_wait: push cx
245			xor cx,cx
246			.kbc_wait_loop:
247			call a20_test
248			jnz a20_done_pop
249			loop .kbc_wait_loop
250
251			pop cx
252			;
253			; Running out of options here. Final attempt: enable the "fast A20 gate"
254			;
255			a20_fast:
256			mov byte [cs:A20Type], A20_FAST ; Haven't used the KBC yet
257			in al, 092h
258			or al,02h
259			and al,~01h ; Don't accidentally reset the machine!
260			out 092h, al
261
262			.fast_wait: push cx
263			xor cx,cx
264			.fast_wait_loop:
265			call a20_test
266			jnz a20_done_pop
267			loop .fast_wait_loop
268
269			pop cx
270
271			;
272			; Oh bugger. A20 is not responding. Try frobbing it again; eventually give up
273			; and report failure to the user.
274			;
275
276
277			dec byte [cs:A20Tries]
278			jnz try_enable_a20
279
280			mov si, err_a20
281			jmp abort_load
282			;
283			; A20 unmasked, proceed...
284			;
285			a20_done_pop: pop cx
286			a20_done: popad
287			ret
288
289			;
290			; This routine tests if A20 is enabled (ZF = 0). This routine
291			; must not destroy any register contents.
292			;
293			a20_test:
294			push es
295			push cx
296			push ax
297			mov cx,0FFFFh ; HMA = segment 0FFFFh
298			mov es,cx
299			mov cx,32 ; Loop count
300			mov ax,[cs:A20Test]
301			.a20_wait: inc ax
302			mov [cs:A20Test],ax
303			io_delay ; Serialize, and fix delay
304			cmp ax,[es:A20Test+10h]
305			loopz .a20_wait
306			.a20_done: pop ax
307			pop cx
308			pop es
309			ret
310
311			disable_a20:
312			pushad
313			;
314			; Flush the caches
315			;
316			%if DO_WBINVD
317			call try_wbinvd
318			%endif
319
320			mov bp,[cs:A20Type]
321			jmp word [cs:bp+A20DList]
322
323			a20d_bios:
324			mov ax,2400h
325			pushf ; Some BIOSes muck with IF
326			int 15h
327			popf
328			jmp short a20d_snooze
329
330			;
331			; Disable the "fast A20 gate"
332			;
333			a20d_fast:
334			in al, 092h
335			and al,~03h
336			out 092h, al
337			jmp short a20d_snooze
338
339			;
340			; Disable the keyboard controller A20 gate
341			;
342			a20d_kbc:
343			call empty_8042_uncond
344			mov al,0D1h
345			out 064h, al ; Command write
346			call empty_8042_uncond
347			mov al,0DDh ; A20 off
348			out 060h, al
349			call empty_8042_uncond
350			; Wait a bit for it to take effect
351			a20d_snooze:
352			push cx
353			mov cx, disable_wait
354			.delayloop: call a20_test
355			jz .disabled
356			loop .delayloop
357			.disabled: pop cx
358			a20d_dunno:
359			a20d_none:
360			popad
361			ret
362
363			;
364			; Routine to empty the 8042 KBC controller. If dl != 0
365			; then we will test A20 in the loop and exit if A20 is
366			; suddenly enabled.
367			;
368			empty_8042_uncond:
369			xor dl,dl
370			empty_8042:
371			call a20_test
372			jz .a20_on
373			and dl,dl
374			jnz .done
375			.a20_on: io_delay
376			in al, 064h ; Status port
377			test al,1
378			jz .no_output
379			io_delay
380			in al, 060h ; Read input
381			jmp short empty_8042
382			.no_output:
383			test al,2
384			jnz empty_8042
385			io_delay
386			.done: ret
387
388			;
389			; Execute a WBINVD instruction if possible on this CPU
390			;
391			%if DO_WBINVD
392			try_wbinvd:
393			wbinvd
394			ret
395			%endif
396
397			;
398			; bcopy_over_self:
399			;
400			; This routine is used to shuffle memory around, followed by
401			; invoking an entry point somewhere in low memory. This routine
402			; can clobber any memory above 7C00h, we therefore have to move
403			; necessary code into the trackbuf area before doing the copy,
404			; and do adjustments to anything except BSS area references.
405			;
406			; NOTE: Since PXELINUX relocates itself, put all these
407			; references in the ".earlybss" segment.
408			;
409			; After performing the copy, this routine resets the stack and
410			; jumps to the specified entrypoint.
411			;
412			; IMPORTANT: This routine does not canonicalize the stack or the
413			; SS register. That is the responsibility of the caller.
414			;
415			; Inputs:
416			; DS:BX -> Pointer to list of (dst, src, len) pairs
417			; AX -> Number of list entries
418			; [CS:EntryPoint] -> CS:IP to jump to
419			; On stack - initial state (fd, ad, ds, es, fs, gs)
420			;
421			shuffle_and_boot:
422			and ax,ax
423			jz .done
424			.loop:
425			mov edi,[bx]
426			mov esi,[bx+4]
427			mov ecx,[bx+8]
428			call bcopy
429			add bx,12
430			dec ax
431			jnz .loop
432
433			.done:
434			pop gs
435			pop fs
436			pop es
437			pop ds
438			popad
439			popfd
440			jmp far [cs:EntryPoint]
441
442			align 2
443			A20List dw a20_dunno, a20_none, a20_bios, a20_kbc, a20_fast
444			A20DList dw a20d_dunno, a20d_none, a20d_bios, a20d_kbc, a20d_fast
445			a20_adjust_cnt equ ($-A20List)/2
446
447			A20Type dw A20_NONE ; A20 type
448
449			; Total size of .bcopy32 section
450			alignb 4, db 0 ; Even number of dwords
451			__bcopy_size equ $-__bcopy_start
452
453			section .earlybss
454			alignb 2
455			EntryPoint resd 1 ; CS:IP for shuffle_and_boot
456			SavedSSSP resd 1 ; Saved real mode SS:SP
457			A20Test resw 1 ; Counter for testing status of A20
458			A20Tries resb 1 ; Times until giving up on A20