mkinitrd-magellan/isolinux/adv.inc

;; -----------------------------------------------------------------------
;;
;;   Copyright 2007-2008 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., 51 Franklin St, Fifth Floor,
;;   Boston MA 02110-1301, USA; either version 2 of the License, or
;;   (at your option) any later version; incorporated herein by reference.
;;
;; -----------------------------------------------------------------------

;;
;; adv.inc
;;
;; The auxillary data vector and its routines
;;
;; The auxillary data vector is a 512-byte aligned block that on the
;; disk-based derivatives can be part of the syslinux file itself.  It
;; exists in two copies; when written, both copies are written (with a
;; sync in between, if from the operating system.)  The first two
;; dwords are magic number and inverse checksum, then follows the data
;; area as a tagged array similar to BOOTP/DHCP, finally a tail
;; signature.
;;
;; Note that unlike BOOTP/DHCP, zero terminates the chain, and FF
;; has no special meaning.
;;

;;
;; List of ADV tags...
;;
ADV_BOOTONCE	equ 1

;;
;; Other ADV data...
;;
ADV_MAGIC1	equ 0x5a2d2fa5			; Head signature
ADV_MAGIC2	equ 0xa3041767			; Total checksum
ADV_MAGIC3	equ 0xdd28bf64			; Tail signature

ADV_LEN		equ 500				; Data bytes

adv_retries	equ 6				; Disk retries

		section .adv
		; Introduce the ADVs to valid but blank
adv0:
.head		resd 1
.csum		resd 1
.data		resb ADV_LEN
.tail		resd 1
.end		equ $
adv1:
.head		resd 1
.csum		resd 1
.data		resb ADV_LEN
.tail		resd 1
.end		equ $
		section .text

		;
		; This is called after config file parsing, so we know
		; the intended location of the ADV
		;
adv_init:
		cmp byte [ADVDrive],-1
		jne adv_read

;%if IS_SYSLINUX || IS_MDSLINUX || IS_EXTLINUX
%if IS_EXTLINUX		; Not yet implemented for the other derivatives
		;
		; Update pointers to default ADVs...
		;
		mov bx,[LDLSectors]
		shl bx,2
		mov ecx,[bsHidden]
		mov eax,[bx+SectorPtrs-8]
		mov edx,[bx+SectorPtrs-4]
		add eax,ecx
		add edx,ecx
		mov [ADVSec0],eax
		mov [ADVSec1],edx
		mov al,[DriveNumber]
		mov [ADVDrive],al
%endif
		; ** fall through to adv_verify **

		;
		; Initialize the ADV data structure in memory
		;
adv_verify:
		cmp byte [ADVDrive],-1		; No ADV configured, still?
		je .reset			; Then unconditionally reset

		mov si,adv0
		call .check_adv
		jz .ok				; Primary ADV okay
		mov si,adv1
		call .check_adv
		jz .adv1ok

		; Neither ADV is usable; initialize to blank
.reset:
		mov di,adv0
		mov eax,ADV_MAGIC1
		stosd
		mov eax,ADV_MAGIC2
		stosd
		xor eax,eax
		mov cx,ADV_LEN/4
		rep stosd
		mov eax,ADV_MAGIC3
		stosd

.ok:
		ret

		; The primary ADV is bad, but the backup is OK
.adv1ok:
		mov di,adv0
		mov cx,512/4
		rep movsd
		ret


		; SI points to the putative ADV; unchanged by routine
		; ZF=1 on return if good
.check_adv:
		push si
		lodsd
		cmp eax,ADV_MAGIC1
		jne .done			; ZF=0, i.e. bad
		xor edx,edx
		mov cx,ADV_LEN/4+1		; Remaining dwords
.csum:
		lodsd
		add edx,eax
		loop .csum
		cmp edx,ADV_MAGIC2
		jne .done
		lodsd
		cmp eax,ADV_MAGIC3
.done:
		pop si
		ret

;
; adv_get: find an ADV string if present
;
; Input:	DL	= ADV ID
; Output:	CX	= byte count (zero on not found)
;		SI	= pointer to data
;		DL	= unchanged
;
; Assumes CS == DS.
;

adv_get:
		push ax
		mov si,adv0.data
		xor ax,ax			; Keep AH=0 at all times
.loop:
		lodsb				; Read ID
		cmp al,dl
		je .found
		and al,al
		jz .end
		lodsb				; Read length
		add si,ax
		cmp si,adv0.tail
		jb .loop
		jmp .end

.found:
		lodsb
		mov cx,ax
		add ax,si			; Make sure it fits
		cmp ax,adv0.tail
		jbe .ok
.end:
		xor cx,cx
.ok:
		pop ax
		ret

;
; adv_set: insert a string into the ADV in memory
;
; Input:	DL	= ADV ID
;		FS:BX	= input buffer
;		CX	= byte count (max = 255!)
; Output:	CF=1 on error
;		CX	clobbered
;
; Assumes CS == DS == ES.
;
adv_set:
		push ax
		push si
		push di
		and ch,ch
		jnz .overflow

		push cx
		mov si,adv0.data
		xor ax,ax
.loop:
		lodsb
		cmp al,dl
		je .found
		and al,al
		jz .endz
		lodsb
		add si,ax
		cmp si,adv0.tail
		jb .loop
		jmp .end

.found:		; Found, need to delete old copy
		lodsb
		lea di,[si-2]
		push di
		add si,ax
		mov cx,adv0.tail
		sub cx,si
		jb .nukeit
		rep movsb			; Remove the old one
		mov [di],ah			; Termination zero
		pop si
		jmp .loop
.nukeit:
		pop si
		jmp .end
.endz:
		dec si
.end:
		; Now SI points to where we want to put our data
		pop cx
		mov di,si
		jcxz .empty
		add si,cx
		cmp si,adv0.tail-2
		jae .overflow			; CF=0

		mov si,bx
		mov al,dl
		stosb
		mov al,cl
		stosb
		fs rep movsb

.empty:
		mov cx,adv0.tail
		sub cx,di
		xor ax,ax
		rep stosb			; Zero-fill remainder

		clc
.done:
		pop di
		pop si
		pop ax
		ret
.overflow:
		stc
		jmp .done

;
; adv_cleanup:	checksum adv0 and copy to adv1
;		Assumes CS == DS == ES.
;
adv_cleanup:
		pushad
		mov si,adv0.data
		mov cx,ADV_LEN/4
		xor edx,edx
.loop:
		lodsd
		add edx,eax
		loop .loop
		mov eax,ADV_MAGIC2
		sub eax,edx
		lea di,[si+4]			; adv1
		mov si,adv0
		mov [si+4],eax			; Store checksum
		mov cx,(ADV_LEN+12)/4
		rep movsd
		popad
		ret

;
; adv_write:	write the ADV to disk.
;
;		Location is in memory variables.
;		Assumes CS == DS == ES.
;
;		Returns CF=1 if the ADV cannot be written.
;
adv_write:
		cmp dword [ADVSec0],0
		je .bad
		cmp dword [ADVSec1],0
		je .bad
		cmp byte [ADVDrive],-1
		je .bad

		push ax
		call adv_cleanup
		mov ah,3			; Write
		call adv_read_write
		pop ax

		clc
		ret
.bad:						; No location for ADV set
		stc
		ret

;
; adv_read:	read the ADV from disk
;
;		Location is in memory variables.
;		Assumes CS == DS == ES.
;
adv_read:
		push ax
		mov ah,2			; Read
		call adv_read_write
		call adv_verify
		pop ax
		ret

;
; adv_read_write: disk I/O for the ADV
;
;		On input, AH=2 for read, AH=3 for write.
;		Assumes CS == DS == ES.
;
adv_read_write:
		mov [ADVOp],ah
		pushad

		; Check for EDD
		mov bx,55AAh
		mov ah,41h			; EDD existence query
		mov dl,[ADVDrive]
		int 13h
		mov si,.cbios
		jc .noedd
		cmp bx,0AA55h
		jne .noedd
		test cl,1
		jz .noedd
		mov si,.ebios
.noedd:

		mov eax,[ADVSec0]
		mov bx,adv0
		call .doone

		mov eax,[ADVSec1]
		mov bx,adv1
		call .doone

		popad
		ret

.doone:
		xor edx,edx			; Zero-extend LBA
		push si
		jmp si

.ebios:
		mov cx,adv_retries
.eb_retry:
		; Form DAPA on stack
		push edx
		push eax
		push es
		push bx
		push word 1			; Sector count
		push word 16			; DAPA size
		mov si,sp
		pushad
		mov dl,[ADVDrive]
		mov ax,4000h
		or ah,[ADVOp]
		push ds
		push ss
		pop ds
		int 13h
		pop ds
		popad
		lea sp,[si+16]			; Remove DAPA
		jc .eb_error
		pop si
		ret
.eb_error:
		loop .eb_retry
		stc
		pop si
		ret

.cbios:
		push edx
		push eax
		push bp

		mov dl,[ADVDrive]
		and dl,dl
		; Floppies: can't trust INT 13h 08h, we better know
		; the geometry a priori, which means it better be our
		; boot device...
		jns .noparm			; Floppy drive... urk

		mov ah,08h			; Get disk parameters
		int 13h
		jc .noparm
		and ah,ah
		jnz .noparm
		shr dx,8
		inc dx
		movzx edi,dx			; EDI = heads
		and cx,3fh
		movzx esi,cx			; ESI = sectors/track
		jmp .parmok

.noparm:
		; No CHS info... this better be our boot drive, then
%if IS_SYSLINUX || IS_EXTLINUX
		cmp dl,[DriveNumber]
		jne .cb_overflow		; Fatal error!
		movzx esi,word [bsSecPerTrack]
		movzx edi,word [bsHeads]
%else
		; Not a disk-based derivative... there is no hope
		jmp .cb_overflow
%endif

.parmok:
                ;
                ; Dividing by sectors to get (track,sector): we may have
                ; up to 2^18 tracks, so we need to use 32-bit arithmetric.
                ;
                div esi
                xor cx,cx
                xchg cx,dx              ; CX <- sector index (0-based)
                                        ; EDX <- 0
                ; eax = track #
                div edi                 ; Convert track to head/cyl

		; Watch out for overflow, we might be writing!
		cmp eax,1023
                ja .cb_overflow

                ;
                ; Now we have AX = cyl, DX = head, CX = sector (0-based),
                ; BP = sectors to transfer, SI = bsSecPerTrack,
                ; ES:BX = data target
                ;

                shl ah,6                ; Because IBM was STOOPID
                                        ; and thought 8 bits were enough
                                        ; then thought 10 bits were enough...
                inc cx                  ; Sector numbers are 1-based, sigh
                or cl,ah
                mov ch,al
                mov dh,dl
                mov dl,[ADVDrive]
		mov al,01h		; Transfer one sector
                mov ah,[ADVOp]		; Operation

		mov bp,adv_retries
.cb_retry:
                pushad
                int 13h
                popad
                jc .cb_error

.cb_done:
                pop bp
                pop eax
                pop edx
		pop si
                ret

.cb_error:
                dec bp
                jnz .cb_retry
.cb_overflow:
		stc
		jmp .cb_done

		section .data
		alignz 4
ADVSec0		dd 0			; Not specified
ADVSec1		dd 0			; Not specified
ADVDrive	db -1			; No ADV defined
ADVCHSInfo	db -1			; We have CHS info for this drive

		section .bss
ADVOp		resb 1
1	niro	1133	;; -----------------------------------------------------------------------
2			;;
3			;; Copyright 2007-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., 51 Franklin St, Fifth Floor,
8			;; Boston MA 02110-1301, USA; either version 2 of the License, or
9			;; (at your option) any later version; incorporated herein by reference.
10			;;
11			;; -----------------------------------------------------------------------
12
13			;;
14			;; adv.inc
15			;;
16			;; The auxillary data vector and its routines
17			;;
18			;; The auxillary data vector is a 512-byte aligned block that on the
19			;; disk-based derivatives can be part of the syslinux file itself. It
20			;; exists in two copies; when written, both copies are written (with a
21			;; sync in between, if from the operating system.) The first two
22			;; dwords are magic number and inverse checksum, then follows the data
23			;; area as a tagged array similar to BOOTP/DHCP, finally a tail
24			;; signature.
25			;;
26			;; Note that unlike BOOTP/DHCP, zero terminates the chain, and FF
27			;; has no special meaning.
28			;;
29
30			;;
31			;; List of ADV tags...
32			;;
33			ADV_BOOTONCE equ 1
34
35			;;
36			;; Other ADV data...
37			;;
38			ADV_MAGIC1 equ 0x5a2d2fa5 ; Head signature
39			ADV_MAGIC2 equ 0xa3041767 ; Total checksum
40			ADV_MAGIC3 equ 0xdd28bf64 ; Tail signature
41
42			ADV_LEN equ 500 ; Data bytes
43
44			adv_retries equ 6 ; Disk retries
45
46			section .adv
47			; Introduce the ADVs to valid but blank
48			adv0:
49			.head resd 1
50			.csum resd 1
51			.data resb ADV_LEN
52			.tail resd 1
53			.end equ $
54			adv1:
55			.head resd 1
56			.csum resd 1
57			.data resb ADV_LEN
58			.tail resd 1
59			.end equ $
60			section .text
61
62			;
63			; This is called after config file parsing, so we know
64			; the intended location of the ADV
65			;
66			adv_init:
67			cmp byte [ADVDrive],-1
68			jne adv_read
69
70			;%if IS_SYSLINUX \|\| IS_MDSLINUX \|\| IS_EXTLINUX
71			%if IS_EXTLINUX ; Not yet implemented for the other derivatives
72			;
73			; Update pointers to default ADVs...
74			;
75			mov bx,[LDLSectors]
76			shl bx,2
77			mov ecx,[bsHidden]
78			mov eax,[bx+SectorPtrs-8]
79			mov edx,[bx+SectorPtrs-4]
80			add eax,ecx
81			add edx,ecx
82			mov [ADVSec0],eax
83			mov [ADVSec1],edx
84			mov al,[DriveNumber]
85			mov [ADVDrive],al
86			%endif
87			; fall through to adv_verify
88
89			;
90			; Initialize the ADV data structure in memory
91			;
92			adv_verify:
93			cmp byte [ADVDrive],-1 ; No ADV configured, still?
94			je .reset ; Then unconditionally reset
95
96			mov si,adv0
97			call .check_adv
98			jz .ok ; Primary ADV okay
99			mov si,adv1
100			call .check_adv
101			jz .adv1ok
102
103			; Neither ADV is usable; initialize to blank
104			.reset:
105			mov di,adv0
106			mov eax,ADV_MAGIC1
107			stosd
108			mov eax,ADV_MAGIC2
109			stosd
110			xor eax,eax
111			mov cx,ADV_LEN/4
112			rep stosd
113			mov eax,ADV_MAGIC3
114			stosd
115
116			.ok:
117			ret
118
119			; The primary ADV is bad, but the backup is OK
120			.adv1ok:
121			mov di,adv0
122			mov cx,512/4
123			rep movsd
124			ret
125
126
127			; SI points to the putative ADV; unchanged by routine
128			; ZF=1 on return if good
129			.check_adv:
130			push si
131			lodsd
132			cmp eax,ADV_MAGIC1
133			jne .done ; ZF=0, i.e. bad
134			xor edx,edx
135			mov cx,ADV_LEN/4+1 ; Remaining dwords
136			.csum:
137			lodsd
138			add edx,eax
139			loop .csum
140			cmp edx,ADV_MAGIC2
141			jne .done
142			lodsd
143			cmp eax,ADV_MAGIC3
144			.done:
145			pop si
146			ret
147
148			;
149			; adv_get: find an ADV string if present
150			;
151			; Input: DL = ADV ID
152			; Output: CX = byte count (zero on not found)
153			; SI = pointer to data
154			; DL = unchanged
155			;
156			; Assumes CS == DS.
157			;
158
159			adv_get:
160			push ax
161			mov si,adv0.data
162			xor ax,ax ; Keep AH=0 at all times
163			.loop:
164			lodsb ; Read ID
165			cmp al,dl
166			je .found
167			and al,al
168			jz .end
169			lodsb ; Read length
170			add si,ax
171			cmp si,adv0.tail
172			jb .loop
173			jmp .end
174
175			.found:
176			lodsb
177			mov cx,ax
178			add ax,si ; Make sure it fits
179			cmp ax,adv0.tail
180			jbe .ok
181			.end:
182			xor cx,cx
183			.ok:
184			pop ax
185			ret
186
187			;
188			; adv_set: insert a string into the ADV in memory
189			;
190			; Input: DL = ADV ID
191			; FS:BX = input buffer
192			; CX = byte count (max = 255!)
193			; Output: CF=1 on error
194			; CX clobbered
195			;
196			; Assumes CS == DS == ES.
197			;
198			adv_set:
199			push ax
200			push si
201			push di
202			and ch,ch
203			jnz .overflow
204
205			push cx
206			mov si,adv0.data
207			xor ax,ax
208			.loop:
209			lodsb
210			cmp al,dl
211			je .found
212			and al,al
213			jz .endz
214			lodsb
215			add si,ax
216			cmp si,adv0.tail
217			jb .loop
218			jmp .end
219
220			.found: ; Found, need to delete old copy
221			lodsb
222			lea di,[si-2]
223			push di
224			add si,ax
225			mov cx,adv0.tail
226			sub cx,si
227			jb .nukeit
228			rep movsb ; Remove the old one
229			mov [di],ah ; Termination zero
230			pop si
231			jmp .loop
232			.nukeit:
233			pop si
234			jmp .end
235			.endz:
236			dec si
237			.end:
238			; Now SI points to where we want to put our data
239			pop cx
240			mov di,si
241			jcxz .empty
242			add si,cx
243			cmp si,adv0.tail-2
244			jae .overflow ; CF=0
245
246			mov si,bx
247			mov al,dl
248			stosb
249			mov al,cl
250			stosb
251			fs rep movsb
252
253			.empty:
254			mov cx,adv0.tail
255			sub cx,di
256			xor ax,ax
257			rep stosb ; Zero-fill remainder
258
259			clc
260			.done:
261			pop di
262			pop si
263			pop ax
264			ret
265			.overflow:
266			stc
267			jmp .done
268
269			;
270			; adv_cleanup: checksum adv0 and copy to adv1
271			; Assumes CS == DS == ES.
272			;
273			adv_cleanup:
274			pushad
275			mov si,adv0.data
276			mov cx,ADV_LEN/4
277			xor edx,edx
278			.loop:
279			lodsd
280			add edx,eax
281			loop .loop
282			mov eax,ADV_MAGIC2
283			sub eax,edx
284			lea di,[si+4] ; adv1
285			mov si,adv0
286			mov [si+4],eax ; Store checksum
287			mov cx,(ADV_LEN+12)/4
288			rep movsd
289			popad
290			ret
291
292			;
293			; adv_write: write the ADV to disk.
294			;
295			; Location is in memory variables.
296			; Assumes CS == DS == ES.
297			;
298			; Returns CF=1 if the ADV cannot be written.
299			;
300			adv_write:
301			cmp dword [ADVSec0],0
302			je .bad
303			cmp dword [ADVSec1],0
304			je .bad
305			cmp byte [ADVDrive],-1
306			je .bad
307
308			push ax
309			call adv_cleanup
310			mov ah,3 ; Write
311			call adv_read_write
312			pop ax
313
314			clc
315			ret
316			.bad: ; No location for ADV set
317			stc
318			ret
319
320			;
321			; adv_read: read the ADV from disk
322			;
323			; Location is in memory variables.
324			; Assumes CS == DS == ES.
325			;
326			adv_read:
327			push ax
328			mov ah,2 ; Read
329			call adv_read_write
330			call adv_verify
331			pop ax
332			ret
333
334			;
335			; adv_read_write: disk I/O for the ADV
336			;
337			; On input, AH=2 for read, AH=3 for write.
338			; Assumes CS == DS == ES.
339			;
340			adv_read_write:
341			mov [ADVOp],ah
342			pushad
343
344			; Check for EDD
345			mov bx,55AAh
346			mov ah,41h ; EDD existence query
347			mov dl,[ADVDrive]
348			int 13h
349			mov si,.cbios
350			jc .noedd
351			cmp bx,0AA55h
352			jne .noedd
353			test cl,1
354			jz .noedd
355			mov si,.ebios
356			.noedd:
357
358			mov eax,[ADVSec0]
359			mov bx,adv0
360			call .doone
361
362			mov eax,[ADVSec1]
363			mov bx,adv1
364			call .doone
365
366			popad
367			ret
368
369			.doone:
370			xor edx,edx ; Zero-extend LBA
371			push si
372			jmp si
373
374			.ebios:
375			mov cx,adv_retries
376			.eb_retry:
377			; Form DAPA on stack
378			push edx
379			push eax
380			push es
381			push bx
382			push word 1 ; Sector count
383			push word 16 ; DAPA size
384			mov si,sp
385			pushad
386			mov dl,[ADVDrive]
387			mov ax,4000h
388			or ah,[ADVOp]
389			push ds
390			push ss
391			pop ds
392			int 13h
393			pop ds
394			popad
395			lea sp,[si+16] ; Remove DAPA
396			jc .eb_error
397			pop si
398			ret
399			.eb_error:
400			loop .eb_retry
401			stc
402			pop si
403			ret
404
405			.cbios:
406			push edx
407			push eax
408			push bp
409
410			mov dl,[ADVDrive]
411			and dl,dl
412			; Floppies: can't trust INT 13h 08h, we better know
413			; the geometry a priori, which means it better be our
414			; boot device...
415			jns .noparm ; Floppy drive... urk
416
417			mov ah,08h ; Get disk parameters
418			int 13h
419			jc .noparm
420			and ah,ah
421			jnz .noparm
422			shr dx,8
423			inc dx
424			movzx edi,dx ; EDI = heads
425			and cx,3fh
426			movzx esi,cx ; ESI = sectors/track
427			jmp .parmok
428
429			.noparm:
430			; No CHS info... this better be our boot drive, then
431			%if IS_SYSLINUX \|\| IS_EXTLINUX
432			cmp dl,[DriveNumber]
433			jne .cb_overflow ; Fatal error!
434			movzx esi,word [bsSecPerTrack]
435			movzx edi,word [bsHeads]
436			%else
437			; Not a disk-based derivative... there is no hope
438			jmp .cb_overflow
439			%endif
440
441			.parmok:
442			;
443			; Dividing by sectors to get (track,sector): we may have
444			; up to 2^18 tracks, so we need to use 32-bit arithmetric.
445			;
446			div esi
447			xor cx,cx
448			xchg cx,dx ; CX <- sector index (0-based)
449			; EDX <- 0
450			; eax = track #
451			div edi ; Convert track to head/cyl
452
453			; Watch out for overflow, we might be writing!
454			cmp eax,1023
455			ja .cb_overflow
456
457			;
458			; Now we have AX = cyl, DX = head, CX = sector (0-based),
459			; BP = sectors to transfer, SI = bsSecPerTrack,
460			; ES:BX = data target
461			;
462
463			shl ah,6 ; Because IBM was STOOPID
464			; and thought 8 bits were enough
465			; then thought 10 bits were enough...
466			inc cx ; Sector numbers are 1-based, sigh
467			or cl,ah
468			mov ch,al
469			mov dh,dl
470			mov dl,[ADVDrive]
471			mov al,01h ; Transfer one sector
472			mov ah,[ADVOp] ; Operation
473
474			mov bp,adv_retries
475			.cb_retry:
476			pushad
477			int 13h
478			popad
479			jc .cb_error
480
481			.cb_done:
482			pop bp
483			pop eax
484			pop edx
485			pop si
486			ret
487
488			.cb_error:
489			dec bp
490			jnz .cb_retry
491			.cb_overflow:
492			stc
493			jmp .cb_done
494
495			section .data
496			alignz 4
497			ADVSec0 dd 0 ; Not specified
498			ADVSec1 dd 0 ; Not specified
499			ADVDrive db -1 ; No ADV defined
500			ADVCHSInfo db -1 ; We have CHS info for this drive
501
502			section .bss
503			ADVOp resb 1