mkinitrd-magellan/isolinux/comboot.inc

;; $Id: comboot.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.
;;
;; -----------------------------------------------------------------------

;;
;; comboot.inc
;; 
;; Common code for running a COMBOOT image
;;

		section .text

; Parameter registers definition; this is the definition
; of the stack frame used by INT 21h and INT 22h.
%define		P_FLAGS		word [bp+44]
%define		P_FLAGSL	byte [bp+44]
%define		P_FLAGSH	byte [bp+45]
%define		P_CS		word [bp+42]
%define		P_IP		word [bp+40]
%define		P_DS		word [bp+38]
%define		P_ES		word [bp+36]
%define		P_FS		word [bp+34]
%define		P_GS		word [bp+32]
%define		P_EAX		dword [bp+28]
%define		P_AX		word [bp+28]
%define		P_HAX		word [bp+30]
%define		P_AL		byte [bp+28]
%define		P_AH		byte [bp+29]
%define		P_ECX		dword [bp+24]
%define		P_CX		word [bp+24]
%define		P_HCX		word [bp+26]
%define		P_CL		byte [bp+24]
%define		P_CH		byte [bp+25]
%define		P_EDX		dword [bp+20]
%define		P_DX		word [bp+20]
%define		P_HDX		word [bp+22]
%define		P_DL		byte [bp+20]
%define		P_DH		byte [bp+21]
%define		P_EBX		dword [bp+16]
%define		P_BX		word [bp+16]
%define		P_HBX		word [bp+18]
%define		P_BL		byte [bp+16]
%define		P_BH		byte [bp+17]
%define		P_EBP		dword [bp+8]
%define		P_BP		word [bp+8]
%define		P_HBP		word [bp+10]
%define		P_ESI		dword [bp+4]
%define		P_SI		word [bp+4]
%define		P_HSI		word [bp+6]
%define		P_EDI		dword [bp]
%define		P_DI		word [bp]
%define		P_HDI		word [bp+2]

; Looks like a COMBOOT image but too large
comboot_too_large:
		mov si,err_comlarge
		call cwritestr
		jmp enter_command

;
; Load a COMBOOT image.  A COMBOOT image is basically a DOS .COM file,
; except that it may, of course, not contain any DOS system calls.  We
; do, however, allow the execution of INT 20h to return to SYSLINUX.
;
is_comboot_image:
		and dx,dx
		jnz comboot_too_large
		cmp ax,0ff00h		; Max size in bytes
		jae comboot_too_large

		push si			; Save file handle

		call make_plain_cmdline

		call comboot_setup_api

		mov cx,comboot_seg
		mov es,cx

		xor di,di
		mov cx,64		; 256 bytes (size of PSP)
		xor eax,eax		; Clear PSP
		rep stosd

		mov word [es:0], 020CDh	; INT 20h instruction
		; First non-free paragraph
		; This is valid because comboot_seg == real_mode_seg
		; == the highest segment used by all derivatives
		int 12h			; Get DOS memory size
		shl ax,6		; Kilobytes -> paragraphs
		mov word [es:02h],ax

%ifndef DEPEND
%if real_mode_seg != comboot_seg
%error "This code assumes real_mode_seg == comboot_seg"
%endif
%endif
		; Copy the command line from high memory
		mov si,cmd_line_here
		mov cx,125		; Max cmdline len (minus space and CR)
		mov di,081h		; Offset in PSP for command line
		mov al,' '		; DOS command lines begin with a space
		stosb

.loop:		es lodsb
		and al,al
		jz .done
		stosb
		loop .loop
.done:

		mov al,0Dh		; CR after last character
		stosb
		mov ax,di
		sub al,82h		; Include space but not CR
		mov [es:80h],al		; Store command line length

		; Now actually load the file...
		pop si			; File handle
		mov bx,100h		; Load at <seg>:0100h
		mov cx,0FF00h >> SECTOR_SHIFT
					; Absolute maximum # of sectors
		call getfssec

		; And invoke the program...
		mov [SavedSSSP],sp
		mov [SavedSSSP+2],ss	; Save away SS:SP

		mov ax,es
		mov ds,ax
		mov ss,ax
		xor sp,sp
		push word 0		; Return to address 0 -> exit

		jmp comboot_seg:100h	; Run it

; Proper return vector
comboot_return:	cli			; Don't trust anyone
		xor ax,ax
		jmp comboot_exit

;
; Set up the COMBOOT API interrupt vectors.  This is also used
; by the COM32 code.
;
comboot_setup_api:
		mov di,4*0x20		; DOS interrupt vectors
		mov eax,comboot_return	; INT 20h = exit
		stosd
		mov ax,comboot_int21	; INT 21h = DOS-compatible syscalls
		stosd
		mov ax,comboot_int22	; INT 22h = proprietary syscalls
		stosd
		mov ax,comboot_bogus
		mov cx,29		; All remaining DOS vectors
		rep stosd
		ret

; INT 21h: generic DOS system call
comboot_int21:	cli
		push ds
		push es
		push fs
		push gs
		pushad
		cld
		mov bp,cs
		mov ds,bp
		mov es,bp
		mov bp,sp			; Set up stack frame

		call adjust_screen		; The COMBOOT program might have changed the screen

		mov cx,int21_count
		mov si,int21_table
.again:		lodsb
		cmp al,P_AH
		lodsw
		loopne .again
		; The last function in the list is the
		; "no such function" function
		clc
		call ax			; Call the invoked function
comboot_resume:
		setc P_FLAGSL		; Propagate CF->error
		popad
		pop gs
		pop fs
		pop es
		pop ds
		iret

; Attempted to execute non-21h DOS system call
comboot_bogus:	cli			; Don't trust anyone
		mov ax,err_notdos
;
; Generic COMBOOT return to command line code
;  AX -> message (if any)
;  BX -> where to go next
;
comboot_exit:
		mov bx,enter_command	; Normal return to command prompt
comboot_exit_special:
		xor dx,dx
		mov ds,dx
		mov es,dx
		lss sp,[SavedSSSP]
		sti
		cld
		call adjust_screen	; The COMBOOT program might have changed the screen
		and ax,ax
		je .nomsg
		mov si,KernelCName
		call cwritestr
		xchg si,ax
		call cwritestr
.nomsg:		jmp bx

;
; INT 21h system calls
;
comboot_getkey:				; 01 = get key with echo
		call vgashowcursor
		call comboot_getchar
		call vgahidecursor
		call writechr
		clc
		ret

comboot_writechr:			; 02 = writechr
		mov al,P_DL
		call writechr
		clc
		ret

comboot_writeserial:			; 04 = write serial port
		mov al,P_DL
		call write_serial
		clc
		ret

comboot_getkeynoecho:			; 08 = get key w/o echo
		call comboot_getchar
		clc
		ret

comboot_writestr:			; 09 = write DOS string
		mov es,P_DS
		mov si,P_DX
.loop:		es lodsb
		cmp al,'$'		; End string with $ - bizarre
		je .done
		call writechr
		jmp short .loop
.done:		clc
		ret

comboot_checkkey:			; 0B = check keyboard status
		cmp byte [APIKeyFlag],00h
		jnz .waiting
		call pollchar
.waiting:	setz al
		dec al			; AL = 0FFh if present, 0 if not
		mov P_AL,al
		clc
		ret

comboot_checkver:			; 30 = check DOS version
		; We return 0 in all DOS-compatible version registers,
		; but the high part of eax-ebx-ecx-edx spell "SYSLINUX"
		mov P_EAX,'SY' << 16
		mov P_EBX,'SL' << 16
		mov P_ECX,'IN' << 16
		mov P_EDX,'UX' << 16
		ret

comboot_getchar:
		cmp byte [APIKeyFlag],00h
		jne .queued
		call getchar		; If not queued get input
		and al,al		; Function key?  (CF <- 0)
		jnz .done
		mov [APIKeyWait],ah	; High part of key
		inc byte [APIKeyFlag]	; Set flag
.done:		mov P_AL,al
		ret
.queued:	mov al,[APIKeyWait]
		dec byte [APIKeyFlag]
		jmp .done

;
; INT 22h - SYSLINUX-specific system calls
;           System call number in ax
;
comboot_int22:
		cli
		push ds
		push es
		push fs
		push gs
		pushad
		cld
		mov bp,cs
		mov ds,bp
		mov es,bp
		mov bp,sp			; Set up stack frame

		call adjust_screen		; The COMBOOT program might have changed the screen

		cmp ax,int22_count
		jb .ok
		xor ax,ax			; Function 0 -> unimplemented
.ok:
		xchg ax,bx
		add bx,bx			; CF <- 0
		call [bx+int22_table]
		jmp comboot_resume		; On return

;
; INT 22h AX=0000h	Unimplemented call
;
comapi_err:
		stc
		ret

;
; INT 22h AX=0001h	Get SYSLINUX version
;
comapi_get_version:
		; Number of API functions supported
		mov P_AX,int22_count
		; SYSLINUX version
		mov P_CX,(VER_MAJOR << 8)+VER_MINOR
		; SYSLINUX derivative ID byte
		mov P_DX,my_id
		; For future use
		mov P_BX,cs	; cs == 0

		mov P_ES,ds
		; ES:SI -> version banner
		mov P_SI,syslinux_banner
		; ES:DI -> copyright string
		mov P_DI,copyright_str

comapi_nop:
		clc
		ret

;
; INT 22h AX=0002h	Write string
;
; Write null-terminated string in ES:BX
;
comapi_writestr:
		mov ds,P_ES
		mov si,P_BX
		call writestr
		clc
		ret

;
; INT 22h AX=0003h	Run command
;
; Terminates the COMBOOT program and executes the command line in
; ES:BX as if it had been entered by the user.
;
comapi_run:
		mov ds,P_ES
		mov si,P_BX
		mov di,command_line
		call strcpy
		xor ax,ax
		mov bx,load_kernel		; Run a new kernel
		jmp comboot_exit_special	; Terminate task, clean up

;
; INT 22h AX=0004h	Run default command		
;
; Terminates the COMBOOT program and executes the default command line
; as if a timeout had happened or the user pressed <Enter>.
;
comapi_run_default:
		mov bx,auto_boot
		jmp comboot_exit_special

;
; INT 22h AX=0005h	Force text mode
;
; Puts the video in standard text mode
;
comapi_textmode:
		call vgaclearmode
		clc
		ret

;
; INT 22h AX=0006h	Open file
;
comapi_open:
		push ds
		mov ds,P_ES
		mov si,P_SI
		mov di,InitRD
		push di
		call mangle_name
		pop di
		pop ds
		call searchdir
		jz comapi_err
		mov P_AX,ax
		mov P_HAX,dx
		mov P_CX,SECTOR_SIZE
		mov P_SI,si
		clc
		ret

;
; INT 22h AX=0007h	Read file
;
comapi_read:
		mov es,P_ES
		mov bx,P_BX
		mov si,P_SI
		mov cx,P_CX
		call getfssec
		jnc .noteof
		xor si,si		; SI <- 0 on EOF, CF <- 0
.noteof:	mov P_SI,si
		ret

;
; INT 22h AX=0008h	Close file
;
comapi_close:
		; Do nothing for now.  Eventually implement
		; an internal API for this.
		clc
		ret

;
; INT 22h AX=0009h	Call PXE stack
;
%if IS_PXELINUX
comapi_pxecall:
		mov bx,P_BX
		mov es,P_ES
		mov di,P_DI
		call pxenv
		mov P_AX,ax
		clc
		ret
%else
comapi_pxecall	equ comapi_err			; Not available
%endif

;
; INT 22h AX=000Ah	Get Derivative-Specific Info
;
comapi_derinfo:
		mov P_AL,my_id
%if IS_SYSLINUX || IS_MDSLINUX || IS_EXTLINUX
		mov al,[DriveNumber]
		mov P_DL,al
		mov P_ES,cs
		mov P_BX,PartInfo
%elif IS_PXELINUX
		mov ax,[APIVer]
		mov P_DX,ax
		mov ax,[StrucPtr]
		mov P_BX,ax
		mov ax,[StrucPtr+2]
		mov P_ES,ax
		mov ax,[InitStack]
		mov P_SI,ax
		mov ax,[InitStack+2]
		mov P_FS,ax
%elif IS_ISOLINUX
		mov al,[DriveNo]
		mov P_DL,al
		mov P_ES,cs
		mov P_BX,spec_packet
%endif
		clc
		ret

;
; INT 22h AX=000Bh	Get Serial Console Configuration
;
comapi_serialcfg:
		mov ax,[SerialPort]
		mov P_DX,ax
		mov ax,[BaudDivisor]
		mov P_CX,ax
		mov ax,[FlowControl]
		or al,ah
		mov ah,[FlowIgnore]
		shr ah,4
		test byte [DisplayCon],01h
		jnz .normalconsole
		or ah,80h
.normalconsole:
		mov P_BX,ax
		clc
		ret

;
; INT 22h AX=000Ch	Perform final cleanup
;
comapi_cleanup:
%if IS_PXELINUX
		; Unload PXE if requested
		test dl,3
		setnz [KeepPXE]
		sub bp,sp		; unload_pxe may move the stack around
		call unload_pxe
		add bp,sp		; restore frame pointer...
%elif IS_SYSLINUX || IS_MDSLINUX || IS_EXTLINUX
		; Restore original FDC table
		mov eax,[OrigFDCTabPtr]
		mov [fdctab],eax
%endif
		; Reset the floppy disk subsystem
		xor ax,ax
		xor dx,dx
		int 13h
		clc
		ret

;
; INT 22h AX=000Dh	Clean up then replace bootstrap
;
comapi_chainboot:
		call comapi_cleanup
		mov eax,P_EDI
		mov [trackbuf+4],eax		; Copy from
		mov eax,P_ECX
		mov [trackbuf+8],eax		; Total bytes
		mov eax,7C00h
		mov [trackbuf],eax		; Copy to
		mov [EntryPoint],eax		; CS:IP entry point
		mov esi,P_ESI
		mov edx,P_EBX
		mov bx,P_DS
		jmp replace_bootstrap_one


;
; INT 22h AX=000Eh	Get configuration file name
;
comapi_configfile:
		mov P_ES,cs
		mov P_BX,ConfigName
		clc
		ret

;
; INT 22h AX=000Fh	Get IPAPPEND strings
;
%if IS_PXELINUX
comapi_ipappend:
		mov P_ES,cs
		mov P_CX,numIPAppends
		mov P_BX,IPAppends
		clc
		ret

		section .data
		alignb 2, db 0
IPAppends	dw IPOption
		dw BOOTIFStr
numIPAppends	equ ($-IPAppends)/2

%else
comapi_ipappend equ comapi_err
%endif

		section .text

;
; INT 22h AX=0010h	Resolve hostname
;
%if IS_PXELINUX
comapi_dnsresolv:
		mov ds,P_ES
		mov si,P_BX
		call dns_resolv
		mov P_EAX,eax
		ret
%else
comapi_dnsresolv equ comapi_err
%endif
		
		section .text

;
; INT 22h AX=0011h	Maximum number of shuffle descriptors
;
comapi_maxshuffle:
		mov P_CX,(2*trackbufsize)/12
		ret

;
; INT 22h AX=0012h	Cleanup, shuffle and boot
;
comapi_shuffle:
		call comapi_cleanup
		mov cx,P_CX
		cmp cx,(2*trackbufsize)/12
		ja .error

		push cx				; On stack: descriptor count

		lea cx,[ecx+ecx*2]		; CX *= 3

		mov fs,P_ES
		mov si,P_DI
		mov di,trackbuf
		push di				; On stack: descriptor list address
		fs rep movsd			; Copy the list

		mov eax,P_EBP
		mov [EntryPoint],eax		; CS:IP entry point
		mov esi,P_ESI
		mov edx,P_EBX
		mov bx,P_DS
		jmp replace_bootstrap
.error:
		stc
		ret

;
; INT 22h AX=0013h	Idle call
;
;
; *** FIX THIS ***
; The idle call seems to have detrimental effects on some machines when
; called from a COM32 context (WHY?) --  disable it for now.
;
%if 0 ; def HAVE_IDLE

comapi_idle:
		DO_IDLE
		clc
		ret

%else

comapi_idle	equ comapi_err

%endif

;
; INT 22h AX=0014h	Local boot
;
%if IS_PXELINUX || IS_ISOLINUX
comapi_localboot:
		mov ax,P_DX
		jmp local_boot
%else
comapi_localboot equ comapi_err
%endif

;
; INT 22h AX=0015h	Feature flags
;
comapi_features:
		mov P_ES,cs
		mov P_BX,feature_flags
		mov P_CX,feature_flags_len
		clc
		ret

;
; INT 22h AX=0016h	Run kernel image
;
comapi_runkernel:
		push ds
		mov ds,P_DS
		mov si,P_SI
		mov di,KernelName
		push di
		call mangle_name
		pop di
		pop ds
		call searchdir
		jz comapi_err

		; The kernel image was found, so we can load it...
		mov [Kernel_SI],si
		mov [Kernel_EAX],ax
		mov [Kernel_EAX+2],dx
		
		; It's not just possible, but quite likely, that ES:BX
		; points into real_mode_seg, so we need to exercise some
		; special care here... use xfer_buf_seg as an intermediary
		push ds
		push es
		mov ax,xfer_buf_seg
		mov ds,P_ES
		mov si,P_BX
		mov es,ax
		xor di,di
		call strcpy
		pop es
		pop ds

%if IS_PXELINUX
		mov al,P_CL
		mov [IPAppend],al
%endif

		xor ax,ax
		mov bx,.finish
		jmp comboot_exit_special

.finish:
		; Copy the command line into its proper place
		push ds
		push es
		mov ax,xfer_buf_seg
		mov dx,real_mode_seg
		mov ds,ax
		mov es,dx
		xor si,si
		mov di,cmd_line_here
		call strcpy
		mov byte [es:di-1],' '		; Simulate APPEND
		pop es
		pop ds
		mov [CmdLinePtr],di
		mov word [CmdOptPtr],zero_string
		jmp kernel_good_saved

		section .data

%macro 		int21 2
		db %1
		dw %2
%endmacro

int21_table:
		int21	00h, comboot_return
		int21	01h, comboot_getkey
		int21	02h, comboot_writechr
		int21	04h, comboot_writeserial
		int21	08h, comboot_getkeynoecho
		int21	09h, comboot_writestr
		int21	0Bh, comboot_checkkey
		int21	30h, comboot_checkver
		int21	4Ch, comboot_return
		int21	 -1, comboot_bogus
int21_count	equ ($-int21_table)/3

		align 2, db 0
int22_table:
		dw comapi_err		; 0000 unimplemented syscall
		dw comapi_get_version	; 0001 get SYSLINUX version
		dw comapi_writestr	; 0002 write string
		dw comapi_run		; 0003 run specified command
		dw comapi_run_default	; 0004 run default command
		dw comapi_textmode	; 0005 force text mode
		dw comapi_open		; 0006 open file
		dw comapi_read		; 0007 read file
		dw comapi_close		; 0008 close file
		dw comapi_pxecall	; 0009 call PXE stack
		dw comapi_derinfo	; 000A derivative-specific info
		dw comapi_serialcfg	; 000B get serial port config
		dw comapi_cleanup	; 000C perform final cleanup
		dw comapi_chainboot	; 000D clean up then bootstrap
		dw comapi_configfile	; 000E get name of config file
		dw comapi_ipappend	; 000F get ipappend strings
		dw comapi_dnsresolv	; 0010 resolve hostname
		dw comapi_maxshuffle	; 0011 maximum shuffle descriptors
		dw comapi_shuffle	; 0012 cleanup, shuffle and boot
		dw comapi_idle		; 0013 idle call
		dw comapi_localboot	; 0014 local boot
		dw comapi_features	; 0015 feature flags
		dw comapi_runkernel	; 0016 run kernel image
int22_count	equ ($-int22_table)/2

APIKeyWait	db 0
APIKeyFlag	db 0

zero_string	db 0			; Empty, null-terminated string

;
; This is the feature flag array for INT 22h AX=0015h
feature_flags:
%if IS_PXELINUX
		db 1			; Have local boot, idle not noop
%elif IS_ISOLINUX
		db 3			; Have local boot, idle is noop
%else
		db 2			; No local boot, idle is noop
%endif
feature_flags_len equ ($-feature_flags)
1	niro	532	;; $Id: comboot.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			;; comboot.inc
16			;;
17			;; Common code for running a COMBOOT image
18			;;
19
20			section .text
21
22			; Parameter registers definition; this is the definition
23			; of the stack frame used by INT 21h and INT 22h.
24			%define P_FLAGS word [bp+44]
25			%define P_FLAGSL byte [bp+44]
26			%define P_FLAGSH byte [bp+45]
27			%define P_CS word [bp+42]
28			%define P_IP word [bp+40]
29			%define P_DS word [bp+38]
30			%define P_ES word [bp+36]
31			%define P_FS word [bp+34]
32			%define P_GS word [bp+32]
33			%define P_EAX dword [bp+28]
34			%define P_AX word [bp+28]
35			%define P_HAX word [bp+30]
36			%define P_AL byte [bp+28]
37			%define P_AH byte [bp+29]
38			%define P_ECX dword [bp+24]
39			%define P_CX word [bp+24]
40			%define P_HCX word [bp+26]
41			%define P_CL byte [bp+24]
42			%define P_CH byte [bp+25]
43			%define P_EDX dword [bp+20]
44			%define P_DX word [bp+20]
45			%define P_HDX word [bp+22]
46			%define P_DL byte [bp+20]
47			%define P_DH byte [bp+21]
48			%define P_EBX dword [bp+16]
49			%define P_BX word [bp+16]
50			%define P_HBX word [bp+18]
51			%define P_BL byte [bp+16]
52			%define P_BH byte [bp+17]
53			%define P_EBP dword [bp+8]
54			%define P_BP word [bp+8]
55			%define P_HBP word [bp+10]
56			%define P_ESI dword [bp+4]
57			%define P_SI word [bp+4]
58			%define P_HSI word [bp+6]
59			%define P_EDI dword [bp]
60			%define P_DI word [bp]
61			%define P_HDI word [bp+2]
62
63			; Looks like a COMBOOT image but too large
64			comboot_too_large:
65			mov si,err_comlarge
66			call cwritestr
67			jmp enter_command
68
69			;
70			; Load a COMBOOT image. A COMBOOT image is basically a DOS .COM file,
71			; except that it may, of course, not contain any DOS system calls. We
72			; do, however, allow the execution of INT 20h to return to SYSLINUX.
73			;
74			is_comboot_image:
75			and dx,dx
76			jnz comboot_too_large
77			cmp ax,0ff00h ; Max size in bytes
78			jae comboot_too_large
79
80			push si ; Save file handle
81
82			call make_plain_cmdline
83
84			call comboot_setup_api
85
86			mov cx,comboot_seg
87			mov es,cx
88
89			xor di,di
90			mov cx,64 ; 256 bytes (size of PSP)
91			xor eax,eax ; Clear PSP
92			rep stosd
93
94			mov word [es:0], 020CDh ; INT 20h instruction
95			; First non-free paragraph
96			; This is valid because comboot_seg == real_mode_seg
97			; == the highest segment used by all derivatives
98			int 12h ; Get DOS memory size
99			shl ax,6 ; Kilobytes -> paragraphs
100			mov word [es:02h],ax
101
102			%ifndef DEPEND
103			%if real_mode_seg != comboot_seg
104			%error "This code assumes real_mode_seg == comboot_seg"
105			%endif
106			%endif
107			; Copy the command line from high memory
108			mov si,cmd_line_here
109			mov cx,125 ; Max cmdline len (minus space and CR)
110			mov di,081h ; Offset in PSP for command line
111			mov al,' ' ; DOS command lines begin with a space
112			stosb
113
114			.loop: es lodsb
115			and al,al
116			jz .done
117			stosb
118			loop .loop
119			.done:
120
121			mov al,0Dh ; CR after last character
122			stosb
123			mov ax,di
124			sub al,82h ; Include space but not CR
125			mov [es:80h],al ; Store command line length
126
127			; Now actually load the file...
128			pop si ; File handle
129			mov bx,100h ; Load at <seg>:0100h
130			mov cx,0FF00h >> SECTOR_SHIFT
131			; Absolute maximum # of sectors
132			call getfssec
133
134			; And invoke the program...
135			mov [SavedSSSP],sp
136			mov [SavedSSSP+2],ss ; Save away SS:SP
137
138			mov ax,es
139			mov ds,ax
140			mov ss,ax
141			xor sp,sp
142			push word 0 ; Return to address 0 -> exit
143
144			jmp comboot_seg:100h ; Run it
145
146			; Proper return vector
147			comboot_return: cli ; Don't trust anyone
148			xor ax,ax
149			jmp comboot_exit
150
151			;
152			; Set up the COMBOOT API interrupt vectors. This is also used
153			; by the COM32 code.
154			;
155			comboot_setup_api:
156			mov di,4*0x20 ; DOS interrupt vectors
157			mov eax,comboot_return ; INT 20h = exit
158			stosd
159			mov ax,comboot_int21 ; INT 21h = DOS-compatible syscalls
160			stosd
161			mov ax,comboot_int22 ; INT 22h = proprietary syscalls
162			stosd
163			mov ax,comboot_bogus
164			mov cx,29 ; All remaining DOS vectors
165			rep stosd
166			ret
167
168			; INT 21h: generic DOS system call
169			comboot_int21: cli
170			push ds
171			push es
172			push fs
173			push gs
174			pushad
175			cld
176			mov bp,cs
177			mov ds,bp
178			mov es,bp
179			mov bp,sp ; Set up stack frame
180
181			call adjust_screen ; The COMBOOT program might have changed the screen
182
183			mov cx,int21_count
184			mov si,int21_table
185			.again: lodsb
186			cmp al,P_AH
187			lodsw
188			loopne .again
189			; The last function in the list is the
190			; "no such function" function
191			clc
192			call ax ; Call the invoked function
193			comboot_resume:
194			setc P_FLAGSL ; Propagate CF->error
195			popad
196			pop gs
197			pop fs
198			pop es
199			pop ds
200			iret
201
202			; Attempted to execute non-21h DOS system call
203			comboot_bogus: cli ; Don't trust anyone
204			mov ax,err_notdos
205			;
206			; Generic COMBOOT return to command line code
207			; AX -> message (if any)
208			; BX -> where to go next
209			;
210			comboot_exit:
211			mov bx,enter_command ; Normal return to command prompt
212			comboot_exit_special:
213			xor dx,dx
214			mov ds,dx
215			mov es,dx
216			lss sp,[SavedSSSP]
217			sti
218			cld
219			call adjust_screen ; The COMBOOT program might have changed the screen
220			and ax,ax
221			je .nomsg
222			mov si,KernelCName
223			call cwritestr
224			xchg si,ax
225			call cwritestr
226			.nomsg: jmp bx
227
228			;
229			; INT 21h system calls
230			;
231			comboot_getkey: ; 01 = get key with echo
232			call vgashowcursor
233			call comboot_getchar
234			call vgahidecursor
235			call writechr
236			clc
237			ret
238
239			comboot_writechr: ; 02 = writechr
240			mov al,P_DL
241			call writechr
242			clc
243			ret
244
245			comboot_writeserial: ; 04 = write serial port
246			mov al,P_DL
247			call write_serial
248			clc
249			ret
250
251			comboot_getkeynoecho: ; 08 = get key w/o echo
252			call comboot_getchar
253			clc
254			ret
255
256			comboot_writestr: ; 09 = write DOS string
257			mov es,P_DS
258			mov si,P_DX
259			.loop: es lodsb
260			cmp al,'$' ; End string with $ - bizarre
261			je .done
262			call writechr
263			jmp short .loop
264			.done: clc
265			ret
266
267			comboot_checkkey: ; 0B = check keyboard status
268			cmp byte [APIKeyFlag],00h
269			jnz .waiting
270			call pollchar
271			.waiting: setz al
272			dec al ; AL = 0FFh if present, 0 if not
273			mov P_AL,al
274			clc
275			ret
276
277			comboot_checkver: ; 30 = check DOS version
278			; We return 0 in all DOS-compatible version registers,
279			; but the high part of eax-ebx-ecx-edx spell "SYSLINUX"
280			mov P_EAX,'SY' << 16
281			mov P_EBX,'SL' << 16
282			mov P_ECX,'IN' << 16
283			mov P_EDX,'UX' << 16
284			ret
285
286			comboot_getchar:
287			cmp byte [APIKeyFlag],00h
288			jne .queued
289			call getchar ; If not queued get input
290			and al,al ; Function key? (CF <- 0)
291			jnz .done
292			mov [APIKeyWait],ah ; High part of key
293			inc byte [APIKeyFlag] ; Set flag
294			.done: mov P_AL,al
295			ret
296			.queued: mov al,[APIKeyWait]
297			dec byte [APIKeyFlag]
298			jmp .done
299
300			;
301			; INT 22h - SYSLINUX-specific system calls
302			; System call number in ax
303			;
304			comboot_int22:
305			cli
306			push ds
307			push es
308			push fs
309			push gs
310			pushad
311			cld
312			mov bp,cs
313			mov ds,bp
314			mov es,bp
315			mov bp,sp ; Set up stack frame
316
317			call adjust_screen ; The COMBOOT program might have changed the screen
318
319			cmp ax,int22_count
320			jb .ok
321			xor ax,ax ; Function 0 -> unimplemented
322			.ok:
323			xchg ax,bx
324			add bx,bx ; CF <- 0
325			call [bx+int22_table]
326			jmp comboot_resume ; On return
327
328			;
329			; INT 22h AX=0000h Unimplemented call
330			;
331			comapi_err:
332			stc
333			ret
334
335			;
336			; INT 22h AX=0001h Get SYSLINUX version
337			;
338			comapi_get_version:
339			; Number of API functions supported
340			mov P_AX,int22_count
341			; SYSLINUX version
342			mov P_CX,(VER_MAJOR << 8)+VER_MINOR
343			; SYSLINUX derivative ID byte
344			mov P_DX,my_id
345			; For future use
346			mov P_BX,cs ; cs == 0
347
348			mov P_ES,ds
349			; ES:SI -> version banner
350			mov P_SI,syslinux_banner
351			; ES:DI -> copyright string
352			mov P_DI,copyright_str
353
354			comapi_nop:
355			clc
356			ret
357
358			;
359			; INT 22h AX=0002h Write string
360			;
361			; Write null-terminated string in ES:BX
362			;
363			comapi_writestr:
364			mov ds,P_ES
365			mov si,P_BX
366			call writestr
367			clc
368			ret
369
370			;
371			; INT 22h AX=0003h Run command
372			;
373			; Terminates the COMBOOT program and executes the command line in
374			; ES:BX as if it had been entered by the user.
375			;
376			comapi_run:
377			mov ds,P_ES
378			mov si,P_BX
379			mov di,command_line
380			call strcpy
381			xor ax,ax
382			mov bx,load_kernel ; Run a new kernel
383			jmp comboot_exit_special ; Terminate task, clean up
384
385			;
386			; INT 22h AX=0004h Run default command
387			;
388			; Terminates the COMBOOT program and executes the default command line
389			; as if a timeout had happened or the user pressed <Enter>.
390			;
391			comapi_run_default:
392			mov bx,auto_boot
393			jmp comboot_exit_special
394
395			;
396			; INT 22h AX=0005h Force text mode
397			;
398			; Puts the video in standard text mode
399			;
400			comapi_textmode:
401			call vgaclearmode
402			clc
403			ret
404
405			;
406			; INT 22h AX=0006h Open file
407			;
408			comapi_open:
409			push ds
410			mov ds,P_ES
411			mov si,P_SI
412			mov di,InitRD
413			push di
414			call mangle_name
415			pop di
416			pop ds
417			call searchdir
418			jz comapi_err
419			mov P_AX,ax
420			mov P_HAX,dx
421			mov P_CX,SECTOR_SIZE
422			mov P_SI,si
423			clc
424			ret
425
426			;
427			; INT 22h AX=0007h Read file
428			;
429			comapi_read:
430			mov es,P_ES
431			mov bx,P_BX
432			mov si,P_SI
433			mov cx,P_CX
434			call getfssec
435			jnc .noteof
436			xor si,si ; SI <- 0 on EOF, CF <- 0
437			.noteof: mov P_SI,si
438			ret
439
440			;
441			; INT 22h AX=0008h Close file
442			;
443			comapi_close:
444			; Do nothing for now. Eventually implement
445			; an internal API for this.
446			clc
447			ret
448
449			;
450			; INT 22h AX=0009h Call PXE stack
451			;
452			%if IS_PXELINUX
453			comapi_pxecall:
454			mov bx,P_BX
455			mov es,P_ES
456			mov di,P_DI
457			call pxenv
458			mov P_AX,ax
459			clc
460			ret
461			%else
462			comapi_pxecall equ comapi_err ; Not available
463			%endif
464
465			;
466			; INT 22h AX=000Ah Get Derivative-Specific Info
467			;
468			comapi_derinfo:
469			mov P_AL,my_id
470			%if IS_SYSLINUX \|\| IS_MDSLINUX \|\| IS_EXTLINUX
471			mov al,[DriveNumber]
472			mov P_DL,al
473			mov P_ES,cs
474			mov P_BX,PartInfo
475			%elif IS_PXELINUX
476			mov ax,[APIVer]
477			mov P_DX,ax
478			mov ax,[StrucPtr]
479			mov P_BX,ax
480			mov ax,[StrucPtr+2]
481			mov P_ES,ax
482			mov ax,[InitStack]
483			mov P_SI,ax
484			mov ax,[InitStack+2]
485			mov P_FS,ax
486			%elif IS_ISOLINUX
487			mov al,[DriveNo]
488			mov P_DL,al
489			mov P_ES,cs
490			mov P_BX,spec_packet
491			%endif
492			clc
493			ret
494
495			;
496			; INT 22h AX=000Bh Get Serial Console Configuration
497			;
498			comapi_serialcfg:
499			mov ax,[SerialPort]
500			mov P_DX,ax
501			mov ax,[BaudDivisor]
502			mov P_CX,ax
503			mov ax,[FlowControl]
504			or al,ah
505			mov ah,[FlowIgnore]
506			shr ah,4
507			test byte [DisplayCon],01h
508			jnz .normalconsole
509			or ah,80h
510			.normalconsole:
511			mov P_BX,ax
512			clc
513			ret
514
515			;
516			; INT 22h AX=000Ch Perform final cleanup
517			;
518			comapi_cleanup:
519			%if IS_PXELINUX
520			; Unload PXE if requested
521			test dl,3
522			setnz [KeepPXE]
523			sub bp,sp ; unload_pxe may move the stack around
524			call unload_pxe
525			add bp,sp ; restore frame pointer...
526			%elif IS_SYSLINUX \|\| IS_MDSLINUX \|\| IS_EXTLINUX
527			; Restore original FDC table
528			mov eax,[OrigFDCTabPtr]
529			mov [fdctab],eax
530			%endif
531			; Reset the floppy disk subsystem
532			xor ax,ax
533			xor dx,dx
534			int 13h
535			clc
536			ret
537
538			;
539			; INT 22h AX=000Dh Clean up then replace bootstrap
540			;
541			comapi_chainboot:
542			call comapi_cleanup
543			mov eax,P_EDI
544			mov [trackbuf+4],eax ; Copy from
545			mov eax,P_ECX
546			mov [trackbuf+8],eax ; Total bytes
547			mov eax,7C00h
548			mov [trackbuf],eax ; Copy to
549			mov [EntryPoint],eax ; CS:IP entry point
550			mov esi,P_ESI
551			mov edx,P_EBX
552			mov bx,P_DS
553			jmp replace_bootstrap_one
554
555
556			;
557			; INT 22h AX=000Eh Get configuration file name
558			;
559			comapi_configfile:
560			mov P_ES,cs
561			mov P_BX,ConfigName
562			clc
563			ret
564
565			;
566			; INT 22h AX=000Fh Get IPAPPEND strings
567			;
568			%if IS_PXELINUX
569			comapi_ipappend:
570			mov P_ES,cs
571			mov P_CX,numIPAppends
572			mov P_BX,IPAppends
573			clc
574			ret
575
576			section .data
577			alignb 2, db 0
578			IPAppends dw IPOption
579			dw BOOTIFStr
580			numIPAppends equ ($-IPAppends)/2
581
582			%else
583			comapi_ipappend equ comapi_err
584			%endif
585
586			section .text
587
588			;
589			; INT 22h AX=0010h Resolve hostname
590			;
591			%if IS_PXELINUX
592			comapi_dnsresolv:
593			mov ds,P_ES
594			mov si,P_BX
595			call dns_resolv
596			mov P_EAX,eax
597			ret
598			%else
599			comapi_dnsresolv equ comapi_err
600			%endif
601
602			section .text
603
604			;
605			; INT 22h AX=0011h Maximum number of shuffle descriptors
606			;
607			comapi_maxshuffle:
608			mov P_CX,(2*trackbufsize)/12
609			ret
610
611			;
612			; INT 22h AX=0012h Cleanup, shuffle and boot
613			;
614			comapi_shuffle:
615			call comapi_cleanup
616			mov cx,P_CX
617			cmp cx,(2*trackbufsize)/12
618			ja .error
619
620			push cx ; On stack: descriptor count
621
622			lea cx,[ecx+ecx2] ; CX = 3
623
624			mov fs,P_ES
625			mov si,P_DI
626			mov di,trackbuf
627			push di ; On stack: descriptor list address
628			fs rep movsd ; Copy the list
629
630			mov eax,P_EBP
631			mov [EntryPoint],eax ; CS:IP entry point
632			mov esi,P_ESI
633			mov edx,P_EBX
634			mov bx,P_DS
635			jmp replace_bootstrap
636			.error:
637			stc
638			ret
639
640			;
641			; INT 22h AX=0013h Idle call
642			;
643			;
644			; * FIX THIS *
645			; The idle call seems to have detrimental effects on some machines when
646			; called from a COM32 context (WHY?) -- disable it for now.
647			;
648			%if 0 ; def HAVE_IDLE
649
650			comapi_idle:
651			DO_IDLE
652			clc
653			ret
654
655			%else
656
657			comapi_idle equ comapi_err
658
659			%endif
660
661			;
662			; INT 22h AX=0014h Local boot
663			;
664			%if IS_PXELINUX \|\| IS_ISOLINUX
665			comapi_localboot:
666			mov ax,P_DX
667			jmp local_boot
668			%else
669			comapi_localboot equ comapi_err
670			%endif
671
672			;
673			; INT 22h AX=0015h Feature flags
674			;
675			comapi_features:
676			mov P_ES,cs
677			mov P_BX,feature_flags
678			mov P_CX,feature_flags_len
679			clc
680			ret
681
682			;
683			; INT 22h AX=0016h Run kernel image
684			;
685			comapi_runkernel:
686			push ds
687			mov ds,P_DS
688			mov si,P_SI
689			mov di,KernelName
690			push di
691			call mangle_name
692			pop di
693			pop ds
694			call searchdir
695			jz comapi_err
696
697			; The kernel image was found, so we can load it...
698			mov [Kernel_SI],si
699			mov [Kernel_EAX],ax
700			mov [Kernel_EAX+2],dx
701
702			; It's not just possible, but quite likely, that ES:BX
703			; points into real_mode_seg, so we need to exercise some
704			; special care here... use xfer_buf_seg as an intermediary
705			push ds
706			push es
707			mov ax,xfer_buf_seg
708			mov ds,P_ES
709			mov si,P_BX
710			mov es,ax
711			xor di,di
712			call strcpy
713			pop es
714			pop ds
715
716			%if IS_PXELINUX
717			mov al,P_CL
718			mov [IPAppend],al
719			%endif
720
721			xor ax,ax
722			mov bx,.finish
723			jmp comboot_exit_special
724
725			.finish:
726			; Copy the command line into its proper place
727			push ds
728			push es
729			mov ax,xfer_buf_seg
730			mov dx,real_mode_seg
731			mov ds,ax
732			mov es,dx
733			xor si,si
734			mov di,cmd_line_here
735			call strcpy
736			mov byte [es:di-1],' ' ; Simulate APPEND
737			pop es
738			pop ds
739			mov [CmdLinePtr],di
740			mov word [CmdOptPtr],zero_string
741			jmp kernel_good_saved
742
743			section .data
744
745			%macro int21 2
746			db %1
747			dw %2
748			%endmacro
749
750			int21_table:
751			int21 00h, comboot_return
752			int21 01h, comboot_getkey
753			int21 02h, comboot_writechr
754			int21 04h, comboot_writeserial
755			int21 08h, comboot_getkeynoecho
756			int21 09h, comboot_writestr
757			int21 0Bh, comboot_checkkey
758			int21 30h, comboot_checkver
759			int21 4Ch, comboot_return
760			int21 -1, comboot_bogus
761			int21_count equ ($-int21_table)/3
762
763			align 2, db 0
764			int22_table:
765			dw comapi_err ; 0000 unimplemented syscall
766			dw comapi_get_version ; 0001 get SYSLINUX version
767			dw comapi_writestr ; 0002 write string
768			dw comapi_run ; 0003 run specified command
769			dw comapi_run_default ; 0004 run default command
770			dw comapi_textmode ; 0005 force text mode
771			dw comapi_open ; 0006 open file
772			dw comapi_read ; 0007 read file
773			dw comapi_close ; 0008 close file
774			dw comapi_pxecall ; 0009 call PXE stack
775			dw comapi_derinfo ; 000A derivative-specific info
776			dw comapi_serialcfg ; 000B get serial port config
777			dw comapi_cleanup ; 000C perform final cleanup
778			dw comapi_chainboot ; 000D clean up then bootstrap
779			dw comapi_configfile ; 000E get name of config file
780			dw comapi_ipappend ; 000F get ipappend strings
781			dw comapi_dnsresolv ; 0010 resolve hostname
782			dw comapi_maxshuffle ; 0011 maximum shuffle descriptors
783			dw comapi_shuffle ; 0012 cleanup, shuffle and boot
784			dw comapi_idle ; 0013 idle call
785			dw comapi_localboot ; 0014 local boot
786			dw comapi_features ; 0015 feature flags
787			dw comapi_runkernel ; 0016 run kernel image
788			int22_count equ ($-int22_table)/2
789
790			APIKeyWait db 0
791			APIKeyFlag db 0
792
793			zero_string db 0 ; Empty, null-terminated string
794
795			;
796			; This is the feature flag array for INT 22h AX=0015h
797			feature_flags:
798			%if IS_PXELINUX
799			db 1 ; Have local boot, idle not noop
800			%elif IS_ISOLINUX
801			db 3 ; Have local boot, idle is noop
802			%else
803			db 2 ; No local boot, idle is noop
804			%endif
805			feature_flags_len equ ($-feature_flags)