mkinitrd-6_3_1/isolinux/conio.inc

;; -----------------------------------------------------------------------
;;
;;   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
;;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
;;
;;   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.
;;
;; -----------------------------------------------------------------------

;;
;; conio.inc
;;
;; Console I/O code, except:
;;   writechr, writestr_early		- module-dependent
;;   writestr, crlf		- writestr.inc
;;   writehex*			- writehex.inc
;;

;
; loadkeys:	Load a LILO-style keymap; file is open on the top of the
;		getc stack.
;
		section .text

loadkeys:
		mov cx,256
		mov di,trackbuf
		call readc
		jc .done				; EOF already?

		; Make sure we are at EOF now...
		call getc
		jnc .done			; We should be at EOF now!

		; It was okay, we can now move it into the KbdMap
		mov si,trackbuf
		mov di,KbdMap
		mov cx,256 >> 2
		rep movsd

.done:
		call close
		ret

;
; get_msg_file: Load a text file and write its contents to the screen,
;               interpreting color codes.  Call with the file already
;		on the top of the open/getc stack.
;
;		Assumes CS == DS == ES.
;
get_msg_file:
                mov byte [TextAttribute],07h	; Default grey on white
		mov byte [DisplayMask],07h	; Display text in all modes
		call msg_initvars

print_msg_file:
.getc:
		call getc
		jc .done
                cmp al,1Ah                      ; DOS EOF?
		je .done
		movzx cx,byte [UsingVGA]
		and cl,01h
		inc cx				; CL <- 01h = text mode,
						;       02h = graphics mode
                call [NextCharJump]		; Do what shall be done
		jmp .getc
.done:
		jmp close			; Tailcall!

msg_putchar:                                    ; Normal character
                cmp al,0Fh                      ; ^O = color code follows
                je msg_ctrl_o
                cmp al,0Dh                      ; Ignore <CR>
                je msg_ignore
                cmp al,0Ah                      ; <LF> = newline
                je msg_newline
                cmp al,0Ch                      ; <FF> = clear screen
                je msg_formfeed
		cmp al,07h			; <BEL> = beep
		je msg_beep
		cmp al,19h			; <EM> = return to text mode
		je msg_novga
		cmp al,18h			; <CAN> = VGA filename follows
		je msg_vga
		jnb .not_modectl
		cmp al,10h			; 10h to 17h are mode controls
		jae msg_modectl
.not_modectl:

msg_normal:	call write_serial_displaymask	; Write to serial port
		test [DisplayMask],cl
		jz msg_ignore			; Not screen
		test byte [DisplayCon],01h
		jz msg_ignore
                mov bl,[TextAttribute]
		mov bh,[BIOS_page]
                mov ah,09h                      ; Write character/attribute
                mov cx,1                        ; One character only
                int 10h                         ; Write to screen
                mov al,[CursorCol]
                inc ax
                cmp al,[VidCols]
                ja msg_line_wrap		; Screen wraparound
                mov [CursorCol],al

msg_gotoxy:     mov bh,[BIOS_page]
                mov dx,[CursorDX]
                mov ah,02h                      ; Set cursor position
                int 10h
msg_ignore:     ret

msg_beep:	mov ax,0E07h			; Beep
		xor bx,bx
		int 10h
		ret

msg_ctrl_o:                                     ; ^O = color code follows
                mov word [NextCharJump],msg_setbg
                ret
msg_newline:                                    ; Newline char or end of line
		mov si,crlf_msg
		call write_serial_str_displaymask
msg_line_wrap:					; Screen wraparound
		test [DisplayMask],cl
		jz msg_ignore
                mov byte [CursorCol],0
                mov al,[CursorRow]
                inc ax
                cmp al,[VidRows]
                ja msg_scroll
                mov [CursorRow],al
                jmp short msg_gotoxy
msg_scroll:     xor cx,cx                       ; Upper left hand corner
                mov dx,[ScreenSize]
                mov [CursorRow],dh		; New cursor at the bottom
                mov bh,[ScrollAttribute]
                mov ax,0601h                    ; Scroll up one line
                int 10h
                jmp short msg_gotoxy
msg_formfeed:                                   ; Form feed character
		mov si,crff_msg
		call write_serial_str_displaymask
		test [DisplayMask],cl
		jz msg_ignore
                xor cx,cx
                mov [CursorDX],cx		; Upper lefthand corner
                mov dx,[ScreenSize]
                mov bh,[TextAttribute]
                mov ax,0600h                    ; Clear screen region
                int 10h
                jmp msg_gotoxy
msg_setbg:                                      ; Color background character
                call unhexchar
                jc msg_color_bad
                shl al,4
		test [DisplayMask],cl
		jz .dontset
                mov [TextAttribute],al
.dontset:
                mov word [NextCharJump],msg_setfg
                ret
msg_setfg:                                      ; Color foreground character
                call unhexchar
                jc msg_color_bad
		test [DisplayMask],cl
		jz .dontset
                or [TextAttribute],al		; setbg set foreground to 0
.dontset:
		jmp short msg_putcharnext
msg_vga:
		mov word [NextCharJump],msg_filename
		mov di, VGAFileBuf
		jmp short msg_setvgafileptr

msg_color_bad:
                mov byte [TextAttribute],07h	; Default attribute
msg_putcharnext:
                mov word [NextCharJump],msg_putchar
		ret

msg_filename:					; Getting VGA filename
		cmp al,0Ah			; <LF> = end of filename
		je msg_viewimage
		cmp al,' '
		jbe msg_ret			; Ignore space/control char
		mov di,[VGAFilePtr]
		cmp di,VGAFileBufEnd
		jnb msg_ret
		mov [di],al			; Can't use stosb (DS:)
		inc di
msg_setvgafileptr:
		mov [VGAFilePtr],di
msg_ret:	ret

msg_novga:
		call vgaclearmode
		jmp short msg_initvars

msg_viewimage:
		mov si,[VGAFilePtr]
		mov byte [si],0			; Zero-terminate filename
		mov si,VGAFileBuf
		mov di,VGAFileMBuf
		call mangle_name
		call open
		jz msg_putcharnext		; Not there
		call vgadisplayfile
		; Fall through

		; Subroutine to initialize variables, also needed
		; after loading a graphics file
msg_initvars:
                pusha
                mov bh,[BIOS_page]
                mov ah,03h                      ; Read cursor position
                int 10h
                mov [CursorDX],dx
                popa
		jmp short msg_putcharnext	; Initialize state machine

msg_modectl:
		and al,07h
		mov [DisplayMask],al
		jmp short msg_putcharnext

;
; write_serial:	If serial output is enabled, write character on serial port
; write_serial_displaymask: d:o, but ignore if DisplayMask & 04h == 0
;
write_serial_displaymask:
		test byte [DisplayMask], 04h
		jz write_serial.end
write_serial:
		pushfd
		pushad
		mov bx,[SerialPort]
		and bx,bx
		je .noserial
		push ax
		mov ah,[FlowInput]
.waitspace:
		; Wait for space in transmit register
		lea dx,[bx+5]			; DX -> LSR
		in al,dx
		test al,20h
		jz .waitspace

		; Wait for input flow control
		inc dx				; DX -> MSR
		in al,dx
		and al,ah
		cmp al,ah
		jne .waitspace
.no_flow:

		xchg dx,bx			; DX -> THR
		pop ax
		slow_out dx,al			; Send data
.noserial:	popad
		popfd
.end:		ret

;
; write_serial_str: write_serial for strings
; write_serial_str_displaymask: d:o, but ignore if DisplayMask & 04h == 0
;
write_serial_str_displaymask:
		test byte [DisplayMask], 04h
		jz write_serial_str.end

write_serial_str:
.loop		lodsb
		and al,al
		jz .end
		call write_serial
		jmp short .loop
.end:		ret

;
; pollchar: check if we have an input character pending (ZF = 0)
;
pollchar:
		pushad
		mov ah,11h		; Poll keyboard
		int 16h
		jnz .done		; Keyboard response
		mov dx,[SerialPort]
		and dx,dx
		jz .done		; No serial port -> no input
		mov ax,[SerialTail]	; Already-queued input?
		cli
		cmp ax,[SerialHead]
		jne .done_sti		; If so, return ZF = 0
		add dx,5		; DX -> LSR
		in al,dx
		test al,1		; ZF = 0 if data pending
		jz .done_sti
		inc dx			; DX -> MSR
		mov ah,[FlowIgnore]	; Required status bits
		in al,dx
		and al,ah
		cmp al,ah
		setne al
		dec al			; Set ZF = 0 if equal
.done_sti:	sti
.done:		popad
		ret

;
; getchar: Read a character from keyboard or serial port
;
getchar.sti_again:
		sti
getchar:
.again:
		call do_idle
		mov ah,11h		; Poll keyboard
		int 16h
		jnz .kbd		; Keyboard input?
		mov bx,[SerialPort]
		and bx,bx
		jz .again
		mov ax,[SerialTail]
		cli
		cmp ax,[SerialHead]
		jne .serial_queued
		lea dx,[bx+5]		; DX -> LSR
		in al,dx
		test al,1
		jz .sti_again
		inc dx			; DX -> MSR
		mov ah,[FlowIgnore]
		in al,dx
		and al,ah
		cmp al,ah
		jne .sti_again
.serial:	xor ah,ah		; Avoid confusion
		mov dx,bx		; Data port
		in al,dx		; Read data
		sti
		jmp .done
.serial_queued:
		sti			; We already know we'll consume data
		xchg bx,ax
		push ds
		mov ax,aux_seg + (aux.serial >> 4)
		mov ds,ax
		mov al,[bx]
		pop ds
		inc bx
		and bx,serial_buf_size-1
		mov [SerialTail],bx
		jmp .done

.kbd:		mov ah,10h		; Get keyboard input
		int 16h
		cmp al,0E0h
		jnz .not_ext
		xor al,al
.not_ext:
		and al,al
		jz .func_key
		mov bx,KbdMap		; Convert character sets
		xlatb
.func_key:
.done:
		jmp reset_idle		; Character received

%ifdef DEBUG_TRACERS
;
; debug hack to print a character with minimal code impact
;
debug_tracer:	pushad
		pushfd
		mov bp,sp
		mov bx,[bp+9*4]		; Get return address
		mov al,[cs:bx]		; Get data byte
		inc word [bp+9*4]	; Return to after data byte
		call writechr
		popfd
		popad
		ret
%endif	; DEBUG_TRACERS

		section .data
%if IS_ISOLINUX == 0			; Defined elsewhere for ISOLINUX
crlf_msg	db CR, LF
null_msg	db 0
%endif
crff_msg	db CR, FF, 0

		section .config
		; This is a word to pc_setint16 can set it
DisplayCon	dw 01h			; Console display enabled

ScrollAttribute	db 07h			; Grey on white (normal text color)

		section .bss
		alignb 2
NextCharJump    resw 1			; Routine to interpret next print char
CursorDX        equ $
CursorCol       resb 1			; Cursor column for message file
CursorRow       resb 1			; Cursor row for message file
ScreenSize      equ $
VidCols         resb 1			; Columns on screen-1
VidRows         resb 1			; Rows on screen-1

; Serial console stuff; don't put this in .config becasue we don't want
; loading a new config file to undo this setting.
		section .data
		alignz 4
SerialPort	dw 0			; Serial port base (or 0 for no serial port)
BaudDivisor	dw 115200/9600		; Baud rate divisor
FlowControl	equ $
FlowOutput	db 0			; Outputs to assert for serial flow
FlowInput	db 0			; Input bits for serial flow
FlowIgnore	db 0			; Ignore input unless these bits set
FlowDummy	db 0			; Unused

		section .bss
TextAttribute   resb 1			; Text attribute for message file
DisplayMask	resb 1			; Display modes mask

%include "serirq.inc"
1	niro	532	;; -----------------------------------------------------------------------
2			;;
3	niro	1133	;; Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
4			;; Copyright 2009 Intel Corporation; author: H. Peter Anvin
5			;;
6	niro	532	;; 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			;; conio.inc
16			;;
17			;; Console I/O code, except:
18	niro	1133	;; writechr, writestr_early - module-dependent
19			;; writestr, crlf - writestr.inc
20	niro	532	;; writehex* - writehex.inc
21			;;
22
23			;
24	niro	1133	; loadkeys: Load a LILO-style keymap; file is open on the top of the
25			; getc stack.
26	niro	532	;
27			section .text
28
29			loadkeys:
30	niro	1133	mov cx,256
31			mov di,trackbuf
32			call readc
33			jc .done ; EOF already?
34	niro	532
35	niro	1133	; Make sure we are at EOF now...
36			call getc
37			jnc .done ; We should be at EOF now!
38	niro	532
39	niro	1133	; It was okay, we can now move it into the KbdMap
40	niro	532	mov si,trackbuf
41			mov di,KbdMap
42			mov cx,256 >> 2
43			rep movsd
44
45	niro	1133	.done:
46			call close
47			ret
48
49	niro	532	;
50			; get_msg_file: Load a text file and write its contents to the screen,
51	niro	1133	; interpreting color codes. Call with the file already
52			; on the top of the open/getc stack.
53	niro	532	;
54	niro	1133	; Assumes CS == DS == ES.
55			;
56	niro	532	get_msg_file:
57			mov byte [TextAttribute],07h ; Default grey on white
58			mov byte [DisplayMask],07h ; Display text in all modes
59			call msg_initvars
60
61			print_msg_file:
62	niro	1133	.getc:
63			call getc
64			jc .done
65	niro	532	cmp al,1Ah ; DOS EOF?
66	niro	1133	je .done
67			movzx cx,byte [UsingVGA]
68			and cl,01h
69			inc cx ; CL <- 01h = text mode,
70			; 02h = graphics mode
71	niro	532	call [NextCharJump] ; Do what shall be done
72	niro	1133	jmp .getc
73			.done:
74			jmp close ; Tailcall!
75
76	niro	532	msg_putchar: ; Normal character
77			cmp al,0Fh ; ^O = color code follows
78			je msg_ctrl_o
79			cmp al,0Dh ; Ignore <CR>
80			je msg_ignore
81			cmp al,0Ah ; <LF> = newline
82			je msg_newline
83			cmp al,0Ch ; <FF> = clear screen
84			je msg_formfeed
85			cmp al,07h ; <BEL> = beep
86			je msg_beep
87			cmp al,19h ; <EM> = return to text mode
88			je msg_novga
89			cmp al,18h ; <CAN> = VGA filename follows
90			je msg_vga
91			jnb .not_modectl
92			cmp al,10h ; 10h to 17h are mode controls
93			jae msg_modectl
94			.not_modectl:
95
96			msg_normal: call write_serial_displaymask ; Write to serial port
97			test [DisplayMask],cl
98			jz msg_ignore ; Not screen
99			test byte [DisplayCon],01h
100			jz msg_ignore
101			mov bl,[TextAttribute]
102			mov bh,[BIOS_page]
103			mov ah,09h ; Write character/attribute
104			mov cx,1 ; One character only
105			int 10h ; Write to screen
106			mov al,[CursorCol]
107			inc ax
108			cmp al,[VidCols]
109			ja msg_line_wrap ; Screen wraparound
110			mov [CursorCol],al
111
112			msg_gotoxy: mov bh,[BIOS_page]
113			mov dx,[CursorDX]
114			mov ah,02h ; Set cursor position
115			int 10h
116			msg_ignore: ret
117
118			msg_beep: mov ax,0E07h ; Beep
119			xor bx,bx
120			int 10h
121			ret
122
123			msg_ctrl_o: ; ^O = color code follows
124			mov word [NextCharJump],msg_setbg
125			ret
126			msg_newline: ; Newline char or end of line
127			mov si,crlf_msg
128			call write_serial_str_displaymask
129			msg_line_wrap: ; Screen wraparound
130			test [DisplayMask],cl
131			jz msg_ignore
132			mov byte [CursorCol],0
133			mov al,[CursorRow]
134			inc ax
135			cmp al,[VidRows]
136			ja msg_scroll
137			mov [CursorRow],al
138			jmp short msg_gotoxy
139			msg_scroll: xor cx,cx ; Upper left hand corner
140			mov dx,[ScreenSize]
141			mov [CursorRow],dh ; New cursor at the bottom
142			mov bh,[ScrollAttribute]
143			mov ax,0601h ; Scroll up one line
144			int 10h
145			jmp short msg_gotoxy
146			msg_formfeed: ; Form feed character
147			mov si,crff_msg
148			call write_serial_str_displaymask
149			test [DisplayMask],cl
150			jz msg_ignore
151			xor cx,cx
152			mov [CursorDX],cx ; Upper lefthand corner
153			mov dx,[ScreenSize]
154			mov bh,[TextAttribute]
155			mov ax,0600h ; Clear screen region
156			int 10h
157			jmp msg_gotoxy
158			msg_setbg: ; Color background character
159			call unhexchar
160			jc msg_color_bad
161			shl al,4
162			test [DisplayMask],cl
163			jz .dontset
164			mov [TextAttribute],al
165			.dontset:
166			mov word [NextCharJump],msg_setfg
167			ret
168			msg_setfg: ; Color foreground character
169			call unhexchar
170			jc msg_color_bad
171			test [DisplayMask],cl
172			jz .dontset
173			or [TextAttribute],al ; setbg set foreground to 0
174			.dontset:
175			jmp short msg_putcharnext
176			msg_vga:
177			mov word [NextCharJump],msg_filename
178			mov di, VGAFileBuf
179			jmp short msg_setvgafileptr
180
181			msg_color_bad:
182			mov byte [TextAttribute],07h ; Default attribute
183			msg_putcharnext:
184			mov word [NextCharJump],msg_putchar
185			ret
186
187			msg_filename: ; Getting VGA filename
188			cmp al,0Ah ; <LF> = end of filename
189			je msg_viewimage
190			cmp al,' '
191			jbe msg_ret ; Ignore space/control char
192			mov di,[VGAFilePtr]
193			cmp di,VGAFileBufEnd
194			jnb msg_ret
195			mov [di],al ; Can't use stosb (DS:)
196			inc di
197			msg_setvgafileptr:
198			mov [VGAFilePtr],di
199			msg_ret: ret
200
201			msg_novga:
202			call vgaclearmode
203			jmp short msg_initvars
204
205			msg_viewimage:
206			mov si,[VGAFilePtr]
207			mov byte [si],0 ; Zero-terminate filename
208			mov si,VGAFileBuf
209			mov di,VGAFileMBuf
210			call mangle_name
211	niro	1133	call open
212	niro	532	jz msg_putcharnext ; Not there
213			call vgadisplayfile
214			; Fall through
215
216			; Subroutine to initialize variables, also needed
217			; after loading a graphics file
218			msg_initvars:
219			pusha
220			mov bh,[BIOS_page]
221			mov ah,03h ; Read cursor position
222			int 10h
223			mov [CursorDX],dx
224			popa
225			jmp short msg_putcharnext ; Initialize state machine
226
227			msg_modectl:
228			and al,07h
229			mov [DisplayMask],al
230			jmp short msg_putcharnext
231
232			;
233			; write_serial: If serial output is enabled, write character on serial port
234			; write_serial_displaymask: d:o, but ignore if DisplayMask & 04h == 0
235			;
236			write_serial_displaymask:
237			test byte [DisplayMask], 04h
238			jz write_serial.end
239			write_serial:
240			pushfd
241			pushad
242			mov bx,[SerialPort]
243			and bx,bx
244			je .noserial
245			push ax
246			mov ah,[FlowInput]
247			.waitspace:
248			; Wait for space in transmit register
249			lea dx,[bx+5] ; DX -> LSR
250			in al,dx
251			test al,20h
252			jz .waitspace
253
254			; Wait for input flow control
255			inc dx ; DX -> MSR
256			in al,dx
257			and al,ah
258			cmp al,ah
259	niro	1133	jne .waitspace
260			.no_flow:
261	niro	532
262			xchg dx,bx ; DX -> THR
263			pop ax
264	niro	1133	slow_out dx,al ; Send data
265	niro	532	.noserial: popad
266			popfd
267			.end: ret
268
269			;
270			; write_serial_str: write_serial for strings
271			; write_serial_str_displaymask: d:o, but ignore if DisplayMask & 04h == 0
272			;
273			write_serial_str_displaymask:
274			test byte [DisplayMask], 04h
275			jz write_serial_str.end
276
277			write_serial_str:
278			.loop lodsb
279			and al,al
280			jz .end
281			call write_serial
282			jmp short .loop
283			.end: ret
284
285			;
286			; pollchar: check if we have an input character pending (ZF = 0)
287			;
288			pollchar:
289			pushad
290			mov ah,11h ; Poll keyboard
291			int 16h
292			jnz .done ; Keyboard response
293			mov dx,[SerialPort]
294			and dx,dx
295			jz .done ; No serial port -> no input
296	niro	1133	mov ax,[SerialTail] ; Already-queued input?
297			cli
298			cmp ax,[SerialHead]
299			jne .done_sti ; If so, return ZF = 0
300			add dx,5 ; DX -> LSR
301	niro	532	in al,dx
302			test al,1 ; ZF = 0 if data pending
303	niro	1133	jz .done_sti
304	niro	532	inc dx ; DX -> MSR
305			mov ah,[FlowIgnore] ; Required status bits
306			in al,dx
307			and al,ah
308			cmp al,ah
309			setne al
310			dec al ; Set ZF = 0 if equal
311	niro	1133	.done_sti: sti
312	niro	532	.done: popad
313			ret
314
315			;
316			; getchar: Read a character from keyboard or serial port
317			;
318	niro	1133	getchar.sti_again:
319			sti
320	niro	532	getchar:
321			.again:
322	niro	1133	call do_idle
323	niro	532	mov ah,11h ; Poll keyboard
324			int 16h
325			jnz .kbd ; Keyboard input?
326			mov bx,[SerialPort]
327			and bx,bx
328			jz .again
329	niro	1133	mov ax,[SerialTail]
330			cli
331			cmp ax,[SerialHead]
332			jne .serial_queued
333	niro	532	lea dx,[bx+5] ; DX -> LSR
334			in al,dx
335			test al,1
336	niro	1133	jz .sti_again
337	niro	532	inc dx ; DX -> MSR
338			mov ah,[FlowIgnore]
339			in al,dx
340			and al,ah
341			cmp al,ah
342	niro	1133	jne .sti_again
343	niro	532	.serial: xor ah,ah ; Avoid confusion
344	niro	1133	mov dx,bx ; Data port
345			in al,dx ; Read data
346			sti
347			jmp .done
348			.serial_queued:
349			sti ; We already know we'll consume data
350			xchg bx,ax
351			push ds
352			mov ax,aux_seg + (aux.serial >> 4)
353			mov ds,ax
354			mov al,[bx]
355			pop ds
356			inc bx
357			and bx,serial_buf_size-1
358			mov [SerialTail],bx
359			jmp .done
360
361	niro	532	.kbd: mov ah,10h ; Get keyboard input
362			int 16h
363			cmp al,0E0h
364			jnz .not_ext
365			xor al,al
366			.not_ext:
367			and al,al
368			jz .func_key
369			mov bx,KbdMap ; Convert character sets
370			xlatb
371	niro	1133	.func_key:
372			.done:
373			jmp reset_idle ; Character received
374	niro	532
375			%ifdef DEBUG_TRACERS
376			;
377			; debug hack to print a character with minimal code impact
378			;
379			debug_tracer: pushad
380			pushfd
381			mov bp,sp
382			mov bx,[bp+9*4] ; Get return address
383			mov al,[cs:bx] ; Get data byte
384			inc word [bp+9*4] ; Return to after data byte
385			call writechr
386			popfd
387			popad
388			ret
389			%endif ; DEBUG_TRACERS
390
391			section .data
392	niro	1133	%if IS_ISOLINUX == 0 ; Defined elsewhere for ISOLINUX
393			crlf_msg db CR, LF
394			null_msg db 0
395			%endif
396			crff_msg db CR, FF, 0
397
398			section .config
399	niro	532	; This is a word to pc_setint16 can set it
400			DisplayCon dw 01h ; Console display enabled
401
402			ScrollAttribute db 07h ; Grey on white (normal text color)
403
404			section .bss
405			alignb 2
406			NextCharJump resw 1 ; Routine to interpret next print char
407			CursorDX equ $
408			CursorCol resb 1 ; Cursor column for message file
409			CursorRow resb 1 ; Cursor row for message file
410			ScreenSize equ $
411			VidCols resb 1 ; Columns on screen-1
412			VidRows resb 1 ; Rows on screen-1
413
414	niro	1133	; Serial console stuff; don't put this in .config becasue we don't want
415			; loading a new config file to undo this setting.
416			section .data
417			alignz 4
418			SerialPort dw 0 ; Serial port base (or 0 for no serial port)
419			BaudDivisor dw 115200/9600 ; Baud rate divisor
420	niro	532	FlowControl equ $
421	niro	1133	FlowOutput db 0 ; Outputs to assert for serial flow
422			FlowInput db 0 ; Input bits for serial flow
423			FlowIgnore db 0 ; Ignore input unless these bits set
424			FlowDummy db 0 ; Unused
425	niro	532
426	niro	1133	section .bss
427	niro	532	TextAttribute resb 1 ; Text attribute for message file
428			DisplayMask resb 1 ; Display modes mask
429	niro	1133
430			%include "serirq.inc"