;
	; Keyboard BIOS
	;
	; (C)1997-2003 Pascal Dornier / PC Engines; All rights reserved.
	; This file is licensed pursuant to the COMMON PUBLIC LICENSE 0.5.
	;
	; pd 030219 add explicit wait for acknowledge, option STPC_KBD -
	;	    required for funky KBC in STPC Atlas and Industrial.
	;
	; Limitations:
	;
	; - Doesn't call INT15 on key wait, system request key
	; - Screen dump is called, but not implemented by BIOS. This function
	;   considered risky for embedded systems, and is also highly
	;   printer specific. Recommend implementation as TSR if required.
	; - We currently don't detect whether the keyboard is enhanced
	;   (101 key) or not. Most keyboards are, so we set the status bit
	;   kb_fkbx.
	; - XT keyboard support is not tested !
	;
	; Note:
	;
	; - If interrupt latency is critical, recommend disabling keyboard
	;   LED updates -> comment out option LED_UPDATE.
	;

	;
	; Flag bit definitions
	;

	; m_kbf bits
	
kb_frsh	equ	01h	;right shift pressed
kb_flsh	equ	02h	;left shift pressed
kb_fcsh	equ	04h	;control pressed
kb_fash	equ	08h	;alt pressed
kb_fscrs	equ	10h	;scroll lock active
kb_fnums	equ	20h	;num lock active
kb_fcaps	equ	40h	;caps lock active
kb_finss	equ	80h	;ins active

	; m_kbf1 bits
	
kb_flct	equ	01h	;left control pressed
kb_flal	equ	02h	;left alt pressed
kb_fsys	equ	04h	;system key pressed
kb_fhld	equ	08h	;hold active
kb_fscr	equ	10h	;scroll lock pressed
kb_fnum	equ	20h	;num lock pressed
kb_fcap	equ	40h	;caps lock pressed
kb_fins	equ	80h	;ins key pressed

	; m_kbf2 bits

kb_fled	equ	07h	;led mask
kb_fscrl	equ	01h	;scroll lock led
kb_fnuml	equ	02h	;num lock led
kb_fcapl	equ	04h	;caps lock led
kb_fack	equ	10h	;kbd ACK received
kb_fres	equ	20h	;kbd RESEND received
kb_fcled	equ	40h	;led update
kb_ferr	equ	80h	;kbd transmit error
	
	; m_kbf3 bits

kb_fe1	equ	01h	;e1 prefix was last
kb_fe0	equ	02h	;e0 prefix was last
kb_frct	equ	04h	;right control pressed
kb_fral	equ	08h	;right alt pressed
kb_fkbx	equ	10h	;enhanced kbd installed
kb_fnumf	equ	20h	;force num lock if kbx
kb_fab	equ	40h	;ab read ID was last
kb_fid	equ	80h	;doing a read ID
	;
	; put keystroke in buffer
	;
putbuf: 	mov 	si,[m_kbtail]
 	mov 	di,si
 	inc 	si
 	inc 	si
 	cmp 	si,[m_kbend]	;end of buffer ?
 	jnz 	pb1	;:no
 	mov 	si,[m_kbstart]	;:restart at beg
pb1: 	cmp 	si,[m_kbhead]	;buffer full ?
 	jz 	pbovr	;:overrun;:yes
 	mov 	[di.bofs],ax	;store keystroke
 	mov 	[m_kbtail],si
 	clc		;ok
 	ret
pbovr: 	stc		;overrun: return error
 	ret
	;
	; wait for AT kbd
	;
waitkbd: 	push 	cx
 	xor 	cx,cx	;timeout
wk1: 	out	iowait,ax
	in 	al,kb_stat	;read status port
 	test 	al,2	;output buffer full ?
 	loopnz 	wk1	;:yes
 	pop 	cx
 	ret
	;
	; disable AT kbd
	;
disakbd: 	cli
 	call 	waitkbd
 	mov 	al,0adh	;disable
 	out 	kb_stat,al
 	sti
 	ret
	;
	; send command to AT kbd
	;
kb_send: 	push 	ax	;save
 	push 	cx
 	mov 	ah,3	;3 retries
sk1: 	cli
 	and 	byte [m_kbf2],kb_fled+kb_fcled+8	;clear error bits
 	push 	ax
 	call 	waitkbd
 	pop 	ax
 	out 	kb_dat,al	;store command
 	sti
 	mov 	cx,2000h	;wait
sk2: 	test 	byte [m_kbf2],kb_fack+kb_fres
 	jnz 	sk4	;:response
 	out	iowait,ax
 	loop 	sk2	;wait
sk3: 	dec 	ah
 	jnz 	sk1	;:another retry
 	or 	byte [m_kbf2],kb_ferr	;set error bit
 	jmp 	short sk9	;done

sk4: 	test 	byte [m_kbf2],kb_fres	;resend flag ?
 	jnz 	sk3	;:retry
sk9: 	cli
 	pop 	cx
 	pop 	ax
 	ret
	;
	; read char from kbd
	;
readchar:
#if ! def	XTKBD

 	call 	disakbd
 	cli
 	call 	waitkbd
 	in 	al,kb_dat	;read scan code
 	sti
 	cmp 	al,0feh	;resend ?
 	jz 	rch3	;:yes
 	cmp 	al,0fah	;ack ?
 	jnz 	setled	;:no
 	mov 	al,kb_fack
 	jmp 	short rch4

rch3: 	mov 	al,kb_fres
rch4: 	cli
 	or 	byte [m_kbf2],al
 	pop 	bx
 	jmp 	done

setled:

#if def	LED_UPDATE
	cli
	push	dx
	mov	dx,pic0
	call	setleds	;set mode LEDs
	pop	dx
#endif
 	sti
 	ret

#else	;XT keyboard

 	in 	al,kb_dat	;read char
 	xchg 	bx,ax
 	in 	al,port61	;restore kbd
 	mov 	ah,al
 	or 	al,80h
 	out 	port61,al
 	mov 	al,ah
 	out 	port61,al
 	xchg 	bx,ax	;scan code -> AL
 	ret
#endif

#if def	LED_UPDATE
	;
	; update LEDs
	;
setleds:	push	ax
	push	cx
 	mov 	ah,[m_kbf]	;current mode flags
 	rol	ah,4	;-> low bits
 	mov 	al,[m_kbf2]	;current LED status
 	and	ax,0707h	;LED bits only
 	cmp 	ah,al	;same ?
 	jz 	setled9	;:done
 	test 	byte [m_kbf2],kb_fcled	;led update pending ?
 	jnz 	setled9	;:yes, don't reenter
 	or 	byte [m_kbf2],kb_fcled	;set update flag
 	mov 	al,eoi	;reset interrupt controller
	out 	dx,al	;(or iowait, depending on DX)
 	mov 	al,0edh	;set mode indicators
 	call 	kb_send	;send kbd command

#if def	STPC_KBD	;funky KBC - insist on acknowledge

	xor     cx,cx
setled2:	mov	al,[m_kbf2]
	test	al,kb_ferr	;transmit error ?
	jnz	setled8
	test	al,kb_fack	;acknowledge ?
	jnz	setled3	;:yes
	dec	cx
	jnz	setled2	;keep waiting
	jmp	setled8	;bail out
	
setled3:	and	byte [m_kbf2],!kb_fack	;clear acknowledge flag
	
#else
 	test 	byte [m_kbf2],kb_ferr	;transmit error ?
 	jnz 	setled8	;:yes
#endif
 	mov 	al,ah	;send mode
 	call 	kb_send
 	test 	byte [m_kbf2],kb_ferr	;transmit error ?
 	jnz 	setled8	;:yes
 	and 	byte [m_kbf2],255-kb_fled	;set new state
 	or 	[m_kbf2],ah
setled8: 	and 	byte [m_kbf2],3fh	;reset update flag
setled9:	pop	cx
	pop	ax
	ret
#endif
	;
	; invalid key: ignore
	;
kinval: 	ret
	;
	; left shift
	;
kshlt: 	mov 	al,kb_flsh
kshlt1: 	test	byte [m_kbf3],kb_fe0	;did we get E0 prefix ?
	jnz	kshlt2	;yes: ignore (extended key)
	or 	[m_kbf],al	;set flag
 	and 	cl,cl	;break ?
 	jns 	kshlt2
 	xor 	[m_kbf],al	;:clear flag
kshlt2: 	ret
	;
	; right shift
	;
kshrt: 	mov 	al,kb_frsh
 	jmp 	kshlt1
	;
	; left control
	;
kctlt: 	or 	byte [m_kbf1],kb_flct	;set flag
 	and 	cl,cl	;break ?
 	jns 	kctlt1
 	xor 	byte [m_kbf1],kb_flct	;:clear flag
kctlt1: 	or 	byte [m_kbf],kb_fcsh	;set left & right flag
 	test 	byte [m_kbf1],kb_flct
 	jnz 	kctlt2 	;:ok
 	test 	byte [m_kbf3],kb_frct
 	jnz 	kctlt2	;:ok
 	xor 	byte [m_kbf],kb_fcsh	;clear control flag
 	ret
kctlt2: 	pop 	ax	;don't clear hold flag
 	jmp 	i12
	;
	; right control
	;
kctrt: 	test 	byte [m_kbf3],kb_fe0+kb_fe1	;no E0/E1: caps lock
 	jz 	kcaps
kctrt1: 	or 	byte [m_kbf3],kb_frct	;set flag
 	and 	cl,cl	;break ?
 	jns 	kctlt1
 	xor 	byte [m_kbf3],kb_frct	;:clear flag
 	jmp 	kctlt1
	;
	; left alt
	;
kallt: 	test 	byte [m_kbf3],kb_fe0	;E0: right alt
 	jnz 	kalrt
 	or 	byte [m_kbf1],kb_flal	;set flag
 	and 	cl,cl	;break ?
 	jns 	kallt1
 	xor 	byte [m_kbf1],kb_flal	;:clear flag
kallt1: 	or 	byte [m_kbf],kb_fash	;set left & right flag
 	test 	byte [m_kbf1],kb_flal
 	jnz 	kallt2	;:ok
 	test 	byte [m_kbf3],kb_fral
 	jnz 	kallt2	;:ok
 	xor 	byte [m_kbf],kb_fash	;clear alt flag
 	xor 	ax,ax	;any char entered via alt ?
 	xchg 	al,[m_kbnum]
 	and 	al,al
 	jz 	kallt2	;:no
 	call 	putbuf	;put it in buffer
kallt2: 	ret
	;
	; right alt
	;
kalrt: 	or 	byte [m_kbf3],kb_fral	;set flag
 	and 	cl,cl	;break ?
 	jns 	kallt1
 	xor 	byte [m_kbf3],kb_fral	;:clear flag
 	jmp 	kallt1
	;
	; handle toggle keys &pd fixed autorepeat 980115
	;
kcaps:	mov	ch,kb_fcaps	;caps lock
	jmp	short ktog
kscrl:	mov	ch,kb_fscrs	;scroll lock
	jmp	short ktog
knums:	mov	ch,kb_fnums
ktog:	and	cl,cl	;break ?
	jns	knums2	;:no
	not	ch	;clear key pressed flag
	and	[m_kbf1],ch
knums1:	ret

knums2:	test	[m_kbf1],ch	;already pressed ?
	jnz	knums3	;:don't toggle again
	xor	[m_kbf],ch	;toggle numlock flag
knums3:	or	[m_kbf1],ch	;set pressed flag
 	ret
	;
	; pause
	;
kpaus: 	and	cl,cl	;break ?
	js	knums1	;:ignore
	test	byte [m_kbf1],kb_fhld	;in hold mode ?
	jnz	knums1	;:yes -> ret
 	or 	byte [m_kbf1],kb_fhld	;set hold flag
 	mov 	al,eoi	;reset interrupt controller
 	out 	pic0,al
 	call	enakbd	;enable keyboard
kpaus1: 	sti		;wait for next event
	hlt
	test 	byte [m_kbf1],kb_fhld	;still on ?
 	jnz 	kpaus1	;yes: hold
 	pop 	ax	;remove return address
 	jmp 	done2	;exit
	;
	; print screen
	;
kprts: 	and	cl,cl
	js	knums1	;:ignore break
	cli
 	mov 	al,eoi	;reset interrupt controller
 	out 	pic0,al
 	int 	5	;do screen dump
 	pop 	ax	;remove return address
 	jmp 	done2	;return
	;
	; reboot system
	;
kboot: 	mov 	word [m_rstflg],1234h	;set cookie
 	jmp	far 0f000h:0fff0h	;reset jump
	;
	; system request
	;
ksysr: 	mov 	al,eoi	;reset interrupt controller
 	out 	pic0,al
 	mov 	ax,8500h
 	and 	cl,cl
 	jns 	ksysr1	;:make
 	inc 	ax	;break code
ksysr1:	int 	15h	;sys req interrupt
 	pop 	ax	;remove return address
 	jmp 	done2	;exit
	;
	; break
	;
kbrk:	and	cl,cl	;ignore key release
	js	knums1
	or 	byte [m_brkflg],128	;set break flag
 	mov 	ax,[m_kbstart]	;clear kbd buffer
 	mov 	[m_kbhead],ax
 	mov 	[m_kbtail],ax
 	int 	1bh	;break interrupt
 	xor 	ax,ax
 	jmp 	putbuf	;put break char
	;
	; alt + digit
	;
kdigtab: 	db 	7,8,9,0,4,5,6,0,1,2,3,0

kdig: 	and	cl,cl	;ignore break
	js	kdig1
	test 	byte [m_kbf3],kb_fe0	;E0 prefix ?
	jnz	kdig2	;yes: cursor keys, not Alt-number
	mov 	al,cl
 	mov 	bx,offset kdigtab-47h
 	cs: 	xlat
 	mov 	ch,al
 	mov 	al,[m_kbnum]	;old value * 10
 	mov 	ah,10
 	mul 	ah
 	add 	al,ch	;add digit
 	mov 	[m_kbnum],al
kdig1: 	ret
 	
kdig2:	mov	ah,cl	;handle Alt-cursor keys
	add	ah,50h
	mov	al,0
	jmp	putbuf
	;
	; action vector table
	;
vectab: 	dw	kinval	;FFFF = ignore key
 	dw 	kshlt 	;FFFE = left shift
 	dw 	kshrt 	;FFFD = right shift
 	dw 	kctlt 	;FFFC = left control
 	dw 	kctrt 	;FFFB = right control
 	dw 	kallt 	;FFFA = left alt
 	dw 	kalrt 	;FFF9 = right alt
 	dw 	kcaps 	;FFF8 = caps lock
 	dw 	knums 	;FFF7 = num lock
 	dw 	kscrl 	;FFF6 = scroll lock
 	dw 	kpaus 	;FFF5 = pause
 	dw 	kprts 	;FFF4 = print screen
 	dw 	kboot 	;FFF3 = reboot system
 	dw 	ksysr 	;FFF2 = system request
 	dw 	kbrk 	;FFF1 = break
 	dw 	kctrt1 	;FFF0 = right control
 	dw 	kdig 	;FFEF = alt + digit
	;
	; shift offset table
	;
shftab: 	db 	1,3,3,3,5,5,5,5,7,7,7,7,9,9,9,9
	;
	; kbd interrupt routine
	;
irq1: 	sti		;enable interrupt
 	push 	ax	;save registers
	push 	bx
 	push 	cx
 	push 	dx
 	push 	si
 	push 	di
 	push 	ds
 	push 	es
 	cld		;forward direction
 	xor	ax,ax	;BIOS segment
 	mov 	ds,ax
 	call 	readchar
 	stc		;give TSRs an opportunity to grap
 	mov	ah,4fh	;this key: call Int15 AH=4F
 	int	15h
 	jb	irq1a	;:not taken
 	jmp	i11	;skip this key
 	
irq1a: 	mov 	cl,al	;copy scan code
	cmp 	al,0e0h	;prefix code ?
 	jnz 	i1
 	or 	byte [m_kbf3],kb_fe0	;set prefix flag
 	jmp 	done
 	
i1: 	cmp 	al,0e1h	;prefix code ?
 	jnz 	i2
 	or 	byte [m_kbf3],kb_fe1	;set prefix flag
 	jmp 	done
 	
i2: 	cmp 	al,0ffh	;overrun ?
	jnz	i2a	;:no

#if def	STPC_KBD
	jmp	done
#else
 	jmp 	overrun
#endif
 	
i2a: 	test 	byte [m_kbf1],kb_fhld	;hold mode ?
 	jz 	i3	;:no
 	and 	cl,cl	;make code ?
 	js 	i3	;no - break
 	xor 	byte [m_kbf1],kb_fhld	;clear hold mode
i3: 	and 	al,127	;make = break
 	jz	overrun1	;zero: ignore
 	cmp 	al,maxscan	;too high ?
 	ja 	overrun1	;yes: ignore char
 	mov	ah,11	;11 bytes per key entry
 	mul	ah
 	add	ax,offset kb_tab-11	;add offset of key table
 	mov	si,ax
 	mov 	ah,[cs:si]	;get control byte
 	mov 	al,[m_kbf]	;get shift flag
 	test 	al,kb_flsh+kb_frsh	;shift set ?
 	jz 	i4	;:no
 	or 	al,kb_flsh+kb_frsh	;set both bits
i4: 	shr 	ah,1	;caps lock ?
 	jnb 	i5	;:no
 	test 	al,kb_fcaps
 	jnz 	i6	;:set
i5: 	shr 	ah,1	;num lock ?
 	jnb 	i7	;:no
 	test	byte [m_kbf3],kb_fe0	;E0 prefix ?
 	jz	i5a	;:no
 	and	al,255-kb_flsh-kb_frsh	;extended key - force unshifted scan
 	jmp	short i7
i5a: 	test 	al,kb_fnums
 	jz 	i7	;:not set
i6: 	xor 	al,kb_flsh+kb_frsh	;toggle shift
i7: 	and 	ax,15
 	mov 	bx,offset shftab	;shift state
 	cs: 	xlat
 	xchg 	bx,ax	;-> entry offset
 	mov 	ax,[cs:bx+si]	;get scan/action code
 	cmp 	ax,vecmin
 	jb 	ikey	;:scan code
 	not 	ax	;action key: convert to jump vector
 	shl 	ax,1
 	xchg 	bx,ax

 	; Dispatch special keys.

  	mov 	bx,[cs:bx+vectab]	;get vector of special key handler
 	call 	bx	;call special key handler
iact2: 	jmp 	short i11	;done

overrun1:	jmp	short overrun

ikey: 	and 	cl,cl	;is it break ?
 	js 	i11	;yes: ignore
 	
 	test 	byte [m_kbf3],kb_fe0	;E0 prefix ?
 	jz	ikey9	;:no
 	test	al,al
 	jnz	ikey4
 	
 	cmp	ah,96h	;Ctrl * -> Ctrl PrtSc
 	jnz	ikey1
 	mov	ah,72h
 	jmp	short ikey9
 	
ikey1: 	cmp	ah,1ch	;Alt keypad enter -> A600
	jnz	ikey2
	mov	ah,0a6h

ikey2:	cmp	ah,35h	;Alt keypad -> A400
	jnz	ikey3
	mov	ah,0a4h

ikey3:	cmp	ah,84h	;high extended keys -> no change
 	jae	ikey9
 	mov	al,0e0h	;remember this was a extended key
 	jmp	short ikey9

ikey4:	cmp	ah,1ch	;keypad enter ?
	jz	ikey8
	cmp	ah,35h	;keypad / ?
	jnz	ikey9
ikey8:	mov	ah,0e0h	;extended key, translated back by
			;kb_xlat
ikey9: 	call 	putbuf	;put scan code in buffer
 	jnb 	i11	;:ok
overrun: 	cli
 	mov 	al,eoi	;reset interrupt controller
 	out 	pic0,al
 	call 	beep
 	jmp 	short done2
i11:
i12: 	and 	byte [m_kbf3],255-kb_fe0-kb_fe1	;reset prefix flag

#if ! def	XTKBD		;if AT

 	cli
 	mov 	al,eoi	;reset interrupt controller
 	out 	pic0,al
 	call 	enakbd
 	jmp 	short done3
#endif

done: 	cli
 	mov 	al,eoi	;reset interrupt controller
 	out 	pic0,al
done2 :

#if ! def	XTKBD
 	call 	enakbd
#endif

done3: 	pop 	es
 	pop 	ds
 	pop 	di
 	pop 	si
 	pop 	dx
 	pop 	cx
 	pop 	bx
 	pop 	ax
 	iret
	;
	; INT 16 entry
	;
int16:	sti		;enable interrupts
	push	bx
	push	cx
	push	dx
	push	ds
	
	xor	dx,dx	;access BIOS segment
	mov	ds,dx
	add	dl,ah	;command code
	jz	kb_get	;AH=00: get key
	dec	dx
	jz	kb_check	;AH=01: check if key available
	dec	dx
	jz	kb_shift	;AH=02: return shift status
	dec	dx
	jz	kb_rate	;AH=03: set repetition rate
	dec	dx
	dec	dx
#if def	STPC_KBD
	jnz	int16b
	jmp	kb_write	;AH=05: place scan code in buffer
int16b:
#else
	jz	kb_write	;AH=05: place scan code in buffer
#endif
	sub	dl,11
	jz	kb_extrd	;AH=10: extended read
	dec	dx
	jz	kb_extst	;AH=11: extended status
	dec	dx
	jz	kb_extsh	;AH=12: extended shift status
kb_exit:	pop	ds
	pop	dx
	pop	cx
	pop	bx
	iret
	;
	; AH=00: get key from buffer
	;
kb_get:	call	kb_getch	;get character from buffer
	call	kb_xlat	;translate extended characters
	jb	kb_get	;:extended character, try again
	jmp	kb_exit
	;
	; AH=01: check if key available
	;
kb_check0: call	kb_getch	;skip extended character
kb_check:	call	kb_chk	;check for character
	jz	kb_exitst	;:nothing available
	call	kb_xlat	;check if extended character
	jb	kb_check0	;:extended character, skip
kb_extst2: inc	dx	;clear Z flag
kb_exitst: pop	ds	;exit, flags modified
	pop	dx
	pop	cx
	pop	bx
	retf	2
	;
	; AH=10: extended read
	;
kb_extrd:	call	kb_getch	;get character
	call	kb_exlat	;convert extended codes
	jmp	kb_exit
	;
	; AH=11: extended status
	;
kb_extst:	call	kb_chk	;check status
	jz	kb_exitst	;:nothing, return Z flag
	call	kb_exlat
	jmp	kb_extst2	;return result
	;
	; AH=12: extended shift status
	;
kb_extsh:	xor	ah,ah
	mov	al,[m_kbf1]	;system request shift
	test	al,kb_fsys	;system request ?
	jz	kb_extsh2
	mov	ah,80h	;yes: set bit 7
kb_extsh2: and	al,01110011xb
	or	ah,al
	mov	al,[m_kbf3]	;right control and alt keys
	and	al,00001100xb
	or	ah,al
	;
	; AH=02: return current shift status
	;
kb_shift:	mov	al,[m_kbf]	;get shift status
	jmp	kb_exit
	;
	; AH=03: set key repetition rate
	;
kb_rate:	cmp	al,5	;correct command ?
	jnz	kb_exit
	cmp	bl,31	;test rate
	ja	kb_exit
	cmp	bh,3	;test delay
	ja	kb_exit
	push	ax	;save AX
	shl	bh,5
	mov	al,0f3h	;set repeat rate / delay command
	call	kb_send	;send to keyboard

#if def	STPC_KBD	;funky KBC - insist on acknowledge

	xor     cx,cx
kbrate2:	mov	al,[m_kbf2]
	test	al,kb_ferr	;transmit error ?
	jnz	kbrate8
	test	al,kb_fack	;acknowledge ?
	jnz	kbrate3	;:yes
	dec	cx
	jnz	kbrate2	;keep waiting
	jmp	kbrate8	;bail out
	
kbrate3:	and	byte [m_kbf2],!kb_fack	;clear acknowledge flag
	
#endif

	mov	al,bl	;combine delay, rate
	add	al,bh
	call	kb_send
kbrate8:	pop	ax	;restore AX
	jmp	kb_exit
	;
	; AH=05: place scan code in buffer
	;
kb_write:	mov	al,1	;error status
	cli		;prevent conflict
	mov	bx,[m_kbtail]	;^kb buffer
	inc	bx	;increment
	inc	bx
	cmp	bx,[m_kbend]  	;at end ?
	jnz	kb_write2
          mov	bx,[m_kbstart]	;yes: go to start
kb_write2: cmp	bx,[m_kbhead]	;buffer full ?
	jz	kb_write3	;:yes
	xchg	bx,[m_kbtail]	;update tail, get old value
	dec	ax	;clear AL
	mov	[bx+bofs],cx	;store scan code
kb_write3: sti		;end of critical section
	jmp	kb_exit
	;
	; get scan code from buffer
	;
kb_getch0: sti		;reenable interrupts
	hlt		;wait for next event
kb_getch:	cli		;critical section
	mov	bx,[m_kbhead]	;^head of buffer
	cmp	bx,[m_kbtail]	;= tail of buffer ?
	jz	kb_getch0	;yes: wait
	mov	ax,[bx+bofs]	;get scan code
	inc	bx	;increment pointer
	inc	bx
	cmp	bx,[m_kbend]  	;at end ?
	jnz	kb_getch2
          mov	bx,[m_kbstart]	;yes: go to start
kb_getch2: mov	[m_kbhead],bx	;update pointer
	sti		;end of critical section
	ret
	;
	; check if there is anything in buffer (Z set if not)
	;
kb_chk:	cli		;critical section
	mov	bx,[m_kbhead]	;^head of buffer
	cmp	bx,[m_kbtail]	;= tail of buffer ?
	sti		;end of critical section
	mov	ax,[bx+bofs]	;get scan code
	ret
	;
	; check if extended character, set C if yes
	;
kb_xlat:	cmp	ah,84h	;extended ?
	jbe	kb_xlat83
	cmp	ah,0e0h
	jnz	kb_stc1	;:bad
	mov	ah,1ch	;keypad Enter fixed code
	cmp	al,13	;keypad Enter ?
	jz	kb_xlatok	;:yes
	cmp	al,10	;keypad ^Enter
	jz	kb_xlatok	;:yes
	mov	ah,35h	;keypad /
	jmp	short kb_xlatok
	
kb_xlat83: cmp	ax,00e0h	;extension ?
	jz	kb_xlatok
	cmp	ax,00f0h
	jz	kb_xlatok
	cmp	al,0f0h	;fill-in ?
	jz	kb_stc1
	cmp	al,0e0h
	jnz	kb_xlatok
	mov	al,0
kb_xlatok: clc		;ok to use
	ret
	
kb_stc1:	stc		;extended code - bad
	ret
	;
	; translate extended characters
	;
kb_exlat:	cmp	al,0f0h	;special ?
	jnz	kb_exlat2
	or	ah,ah	;0: more special
	jz	kb_exlat2
	mov	al,0
kb_exlat2: ret
	;
	; initialize keyboard controller
	;
kb_ini:

#if ! def	XTKBD

#if def	NO_KBC		;bail quickly if no KBC present
	in	al,kb_stat	;check status
	cmp	al,0ffh	;nothing ?
	jnz	kb_ini0
	mov	byte [tmp_kbc],0ffh	;set flag - KBC not present
	stc
	ret
kb_ini0:
#endif
	xor	cx,cx
kb_ini1:	in	al,kb_stat	;check status
	mov	bl,al
	and	al,1	;buffer full ?
	jz	kb_ini2
	in	al,kb_dat	;flush data
kb_ini2:	and	bl,2
	jz	kb_ini3	;:empty
	loop	kb_ini1
kb_ini9:	stc		;error
	ret
	
kb_ini3:	mov	al,0aah	;self test command
	call	kb_cmd
	jb	kb_ini9	;:timeout
	call	kb_read	;wait for data
	jb	kb_ini9
	cmp	al,55h	;expect $55 response
	jnz	kb_ini9
	
	mov	al,0abh	;test interface
	call	kb_cmd
	jb	kb_ini9	;:timeout
	call	kb_read	;wait for data
	jb	kb_ini9
	cmp	al,0	;expect 0 response
	jnz	kb_ini9

	mov	al,60h	;write mode register
	call	kb_cmd
	jb	kb_ini9
	mov	al,6dh 	;initial mode (keep system flag off,
			;disable mouse interface)
	call	kb_writ
	jb	kb_ini9

#else	;XT keyboard

	in	al,port61
	out	iowait,ax
	or	al,0c0h	;set reset bit
	out	port61,al
	out	iowait,ax
	and	al,7fh	;clear reset bit
	out	port61,al
#endif
kb_clc1:	clc		;ok
	ret
	;
	; send keyboard command AL
	;
kb_cmd:	out	kb_stat,al	;send command
kb_cmd1:	out	iowait,ax
	;
	; wait until input (to 8042) buffer empty, C if timeout
	;	
kb_ibf:	xor	cx,cx
kb_ibf2:	out	iowait,ax
	in	al,kb_stat
	and	al,2	;input buffer full ?
	jz	kb_clc1	;:ok return
	loop	kb_ibf2
	stc
	ret
	;
	; send keyboard data AL
	;
kb_writ:	out	kb_dat,al
	jmp	kb_cmd1
	;
	; wait until output (from 8042) buffer full, read data -> AL
	;	
kb_read:	xor	cx,cx
kb_obf2:	out	iowait,ax
	in	al,kb_stat
	and	al,1	;output buffer full ?
	jnz	kb_obf3
	loop	kb_obf2
	stc
	ret
	
kb_obf3:	in	al,kb_dat
	clc
	ret
	;
	; second keyboard initialization (after base memory test)
	;
kb_inb:	

#if def	NO_KBC		;skip if no KBC present
	ror	byte [tmp_kbc],1
	jb	kb_inb9
#endif

	call	kb_ibf	;wait for 8042 ready
	
	in	al,kb_stat	;anything in 8042 output buffer ?
	and	al,1
	jz	kb_inb2	;:no
	in	al,kb_dat
	mov	[tmp_kbd],al	;save keyboard response
	cmp	al,0aah	;keyboard test ok ?
	jz	kb_inb9	;:yes, don't reset again

kb_inb2:	mov	al,0ffh	;reset keyboard
	out	kb_dat,al
	call	kb_read	;get acknowledge

kb_inb9: 	mov 	byte [m_kbf],kb_fnums	;set Numlock
	mov	byte [m_kbf3],kb_fkbx	;assume enhanced keyboard
 	mov	ax,m_kbbuf-bofs	;initialize keyboard buffer pointers
 	mov 	[m_kbstart],ax
 	mov 	[m_kbhead],ax
 	mov 	[m_kbtail],ax
 	mov 	word [m_kbend],m_kbbuf9-bofs
	ret
	;
	; third keyboard initialization (after extended memory test)
	;
kb_inc:	
#if def	NO_KBC		;skip if no KBC present
	ror	byte [tmp_kbc],1
	jnb	kb_inc1
	ret
kb_inc1:
#endif
	cmp	byte [tmp_kbd],0aah	;keyboard reset ok ?
	jz	kb_inc2	;:yes
	call	kb_read	;wait until data in buffer
	jb	kb_err
	cmp	al,0aah	;AA = keyboard response
	jz	kb_inc2	;:ok
kb_err:	inc	byte [tmp_kbfail]
#if ! def	NO_KBC
	mov	si,offset msg_kbd	;"Keyboard failure"
	call	v_msg
#endif
kb_inc2:	call	kb_ibf	;wait for 8042 ready
	mov	al,0f4h	;enable keyboard
	out	kb_dat,al
	jmp	kb_read	;get acknowledge
	;
	; set keyboard LEDs, enable keyboard
	;
kb_ind:	
#if def	NO_KBC		;skip if no KBC present
	ror	byte [tmp_kbc],1
	jnb	kb_ind1
	ret
kb_ind1:
#endif

#if def	KEY_RATE
	mov	ax,0305h	;set keyboard repeat rate
	mov	bx,KEY_RATE
	int	16h
#endif
	
	call	disakbd	;disable keyboard interface

#if def	LED_UPDATE
	mov	dx,iowait
	call	setleds	;set keyboard LEDs
#endif
	;-> fall through
	;
	; enable AT kbd
	;
enakbd: 	cli
 	call 	waitkbd
 	mov 	al,0aeh
 	out 	kb_stat,al
 	sti
 	ret