+---------------------------------------------+
¦					      ¦
¦	-=­ KBDF ­=-			      ¦
¦					      ¦
¦	Tangentbordskontroller		      ¦
¦	Avbrott, init och dispatch	      ¦
¦					      ¦
¦	Entry: ........... KBDF.TX	      ¦
¦	Version: ......... 1.0		      ¦
¦	Startad: ......... 92 04 20	      ¦
¦	Senast ändrad: ... 92 05 24	      ¦
¦					      ¦
¦	Mikael Pontén			      ¦
¦	Pons Data			      ¦
¦					      ¦
+---------------------------------------------+


; Initierande equates

		REFS	KBDEQU
WRK:		REF
MHZ4:		REF
MHZ6:		REF
MHZ8:		REF
		REM	KBDEQU
		REM	KBDCEQU
		REM	SYSEQU
		REFM	SYSMAC
		IF	WRK
		ORG	2000H
		ELSE
		ORG	0
		ENDIF
		IDNT	$,$
		WIDTH	12,96
		Z80


; Här börjar Z80 efter reset

		IF	WRK
KBD:		JP	START		;KBD
		JP	Poll		;KBD+3
		JP	EXEQ		;KBD+6
		ELSE
KBD:		LD	SP,KbdStack
		ELSE
START:		XOR	A
		ELSE
		XOR	A		;Släpp CLK & DATA och inga avbr
		ENDIF
		OUT	(KbdDataS),A
		LD	A,HSAInit
		OUT	(HostStatusA),A	;Busy status till host
		LD	HL,KBD
		LD	BC,KBDEnd-KBD
		CALL	GCRC		;Kolla CRC
		OR	DE		;Ok?
		JR	NZ,KBD		;Nej
		CALL	KbdInit		;Gör Init
		LD	A,1 SHL BKbdInt OR 1 SHL BHostAckR
		OUT	(KbdDataS),A	;EI till 74LS74
		CALL	Define		;Definiera vissa tangenter
		XOR	A
		OUT	(HostStatusA),A	;Klar med init, ej busy
		IF	WRK
Poll:		LD	HL,(DataBufLo)
		LD	(TempDataBuf),HL
		LD	A,(TempFlag)
		BIT	BRet,A		;Göra retur?
		RET	NZ		;Ja
		CALL	CkEsc
		RET	C
EXEQ:		LD	A,(TempCommand)
		OR	A		;Något att göra?
		JR	NZ,DO		;Ja
		CALL	Decode
		CALL	Output
		JR	Poll
DO:		PUSH	AF
		XOR	A
		LD	(TempCommand),A
		LD	HL,(TempDataBuf)
		LD	(DataBufLo),HL
		POP	AF
		LD	HL,Poll
		PUSH	HL
		LD	(RegSP),SP
		LD	HL,KbdCB
		LD	BC,KbdCB$
		CPDR			;Kommando?
		JR	Z,dokbd		;Ja
		Text	'Illegal command'
		RET
dokbd:		LD	HL,KbdCMD
		ADD	HL,BC,2
		LD	A,(HL)
		INC	HL
		LD	H,(HL)
		LD	L,A
		JP	(HL)
		ELSE
PollR:		LD	HL,PollR
		PUSH	HL
		LD	(RegSP),SP
Poll:		CALL	Decode
		CALL	Output
		JR	Poll
		ENDIF


; Avkoda koderna från tangentbordet och
; placera i utmatningsbuffer

Decode:		CALL	GetScanCode	;Hämta en
		RET	Z		;Tomt
		LD	(IY+$HostStatusAI),0 ;Bygg status A
		CALL	LEDS		;Caps, Num, Scroll?
		RET	C		;Ja, exit
		CALL	State		;Shift, Ctrl, Alt?
		RET	C		;Ja, exit
		CALL	HostReset	;Reset av host?
		RET	C		;Ja, klart
		CALL	KeyPadHex	;Hex på keypad?
		JR	C,decode1	;Ja, koden klar
		RET	NZ		;Hex pågår
		CALL	Accent		;Tecken med accent?
		JR	C,decode1	;Ja, koden klar
		RET	NZ		;Inväntar nästa tangent
		CALL	Umlaut		;Tyska ü?
		JR	C,decode1	;Ja, koden klar
		RET	NZ		;Inväntar nästa tangent
		CALL	Section		;§ eller ½?
		JR	C,decode1	;Ja
		CALL	Convert		;ASCII, funktion, keypad?
		RET	C		;Nej
		IF	WRK
decode1:	RST	ROUT
		CALL	QOut
		ELSE
decode1:	CALL	QOut		;Placera i utmatningsbuffer
		ENDIF
		RET


; Ta hand om lysdioderna
; Caps Lock påverkar konverteringen till ASCII
; IN:	A,E	tangentbordskod
; UT:	A,E	E orört, A orört om NC
;	CY	om tangentbordskoden är Caps, Num eller Scroll

LEDS:		OR	A		;Bort CY
		LD	HL,LEDTAB
		LD	BC,LEDTAB$
		CPDR			;Caps, Num, Scroll?
		RET	NZ		;Nej
		LD	BC,LEDTAB$+1
		ADD	HL,BC
		LD	A,(HL)
		XOR	(IY+$KbdLED)
		LD	(IY+$KbdLED),A
		LD	(DataBufLo),A
		CALL	SetStatusInd	;Tänd/släck
		SCF
		RET


; Kolla Shift, Ctrl, Alt etc så att konvertering
; till ASCII kan ske med hänsyn till deras läge
; IN:	A,E	tangentbordskod
; UT:	A,E	E orört, A orört om NC
;	CY	om tangentbordskoden är Shift, Ctrl, Alt eller AltGr

State:		BIT	BBreak,(IY+$KbdState) ;Inväntas break?
		JR	NZ,state1	;Ja
		CP	0F0H		;Är detta Break?
		JR	NZ,state4	;Nej, make
		SET	BBreak,(IY+$KbdState) ;Nästa kod är den släppta
		BIT	BInEmpty,(IY+$BufCtrl) ;RecBuffer tom?
		SCF
		RET	NZ		;Ja
		CALL	GetScanCode
state1:		LD	HL,STATETAB
		LD	BC,STATETAB$
		CPDR			;Shift, Ctrl, Alt?
		SCF
		RET	NZ		;Va? Ska inte kunna hända
		LD	BC,STATETAB$+1
		ADD	HL,BC
		LD	A,(HL)
		CPL
		RES	BBreak,A	;Fått tbk för släppt tangent
		AND	(IY+$KbdState)
		LD	(IY+$KbdState),A
		LD	B,A		;Cache
		LD	C,(IY+$KbdFlags) ;Cache
		AND	1 SHL BShiftL OR 1 SHL BShiftR ;Nån Shift kvar?
		JR	NZ,state2	;Ja
		RES	BShift,C
state2:		LD	A,B
		AND	1 SHL BCtrlL OR 1 SHL BCtrlR ;Någon Ctrl kvar?
		JR	NZ,state3	;Ja
		RES	BCtrl,C
state3:		LD	A,(HL)
		AND	1 SHL BAlt OR 1 SHL BAltGr
		CPL
		AND	C
		LD	C,A
		LD	A,B
		AND	AnyCMask	;Någon Ctrl, Alt, AltGr kvar?
		JR	NZ,stateBX	;Ja
		RES	BAnyC,C
stateBX:	LD	(IY+$KbdFlags),C
		SCF
		RET
state4:		OR	A		;Bort CY
		LD	HL,STATETAB
		LD	BC,STATETAB$
		CPDR			;Shift, Ctrl, Alt?
		RET	NZ		;Nej
		LD	BC,STATETAB$+1
		ADD	HL,BC
		LD	A,(HL)
		LD	B,A
		OR	(IY+$KbdState)
		LD	(IY+$KbdState),A
		LD	C,(IY+$KbdFlags) ;Cache
		LD	A,B
		AND	1 SHL BShiftL OR 1 SHL BShiftR ;Shift?
		JR	Z,state5	;Nej
		SET	BShift,C
		JR	stateMX
state5:		LD	A,B
		AND	1 SHL BCtrlL OR 1 SHL BCtrlR ;Ctrl?
		JR	Z,state6	;Nej
		SET	BCtrl,C
		SET	BAnyC,C
		JR	stateMX
state6:		LD	A,B
		AND	1 SHL BAlt OR 1 SHL BAltGr ;Alt eller AltGr
		OR	C		;Samma pos i State & Flags
		LD	C,A
		SET	BAnyC,C
stateMX:	LD	(IY+$KbdFlags),C
		SCF
		RET


; Ctrl/Alt/Shift + Del gör reset på host
; IN:	 E	tangentbordskod
; UT:	 E	orört
;	CY	har gjort reset

HostReset:	LD	A,(KbdState)
		CP	HostResetMask	;Ctrl/Alt/Shift nere?
		JR	Z,hr2		;Ja
hr1:		XOR	A
		RET
hr2:		LD	A,E
		CP	71H		;Del?
		JR	NZ,hr1		;Nej
		LD	A,1 SHL BHostReset OR 1 SHL BKbdClk
		OUT	(KbdDataS),A	;Reset till host, inhibit kbd
		LD	A,5
		CALL	Delay		;Vänta 50 µs
		LD	A,1 SHL BKbdInt
		OUT	(KbdDataS),A	;Bort reset, EI till kbd
		SCF
		RET


; Konvertera Alt + 3 siffror på keypad till hex
; IN:	 E	tangentbordskod
; UT:	 E	orört
;	CY	A: hex
;	NZ	pågår

KeyPadHex:	LD	A,(KbdFlags)
		CP	1 SHL BAlt OR 1 SHL BAnyC ;Bara Alt nere?
		JR	Z,hex2		;Ja
hex1:		RES	BHex,(IY+$MiscCtrl) ;Inaktiv
		XOR	A		;Z & NC
		RET
hex2:		BIT	BNum,(IY+$KbdLED) ;NumLock tänd?
		JR	Z,hex1		;Nej
		BIT	BHex,(IY+$MiscCtrl) ;Redan aktiv?
		JR	NZ,hex3		;Ja
		LD	(IY+$HexDig),0	;Nollställ
		LD	(IY+$HexCnt),3	;3 siffror
		SET	BHex,(IY+$MiscCtrl) ;Aktiv
hex3:		LD	H,HIGH(LookUpX)
		LD	L,E
		LD	A,(HL)
		OR	A		;Giltig kod?
		JR	Z,hex1		;Nej
		SUB	'0'		;Siffra?
		JR	C,hex1		;Nej
		LD	B,A		;Nya siffran
		LD	A,(HexDig)
		LD	C,A
		RLCA	2		;* 4
		ADD	A,C		;* 5
		RLCA			;* 10
		ADD	A,B
		LD	(HexDig),A
		DEC	(IY+$HexCnt)	;Fått 3?
		JR	NZ,hex4		;Nej
		RES	BHex,(IY+$MiscCtrl)
		SET	BHSHex,(IY+$HostStatusAI) ;Hex från keypad
		SCF
		RET
hex4:		OR	-1		;NC & NZ = pågår
		RET


; Vissa tecken modifieras av accenttangenten
; IN:	 E	tangentbordskod
; UT:	 E	orört
;	CY	A: "ascii" för modifierat tecken
;	NZ	inväntar nästa tangent

Accent:		LD	A,E
		BIT	BAccent,(IY+$MiscCtrl) ;Redan aktiv?
		JR	NZ,at4		;Ja
		CP	55H		;Accenttangenten?
		JR	Z,at2		;Ja
at1:		XOR	A		;NC & Z
		RET
at2:		RES	BGrave,(IY+$MiscCtrl) ;Antag akut accent
		BIT	BShift,(IY+$KbdFlags) ;Shift?
		JR	Z,at3		;Nej, accent agu (t ex é)
		SET	BGrave,(IY+$MiscCtrl) ;Accent grave (t ex à)
at3:		SET	BAccent,(IY+$MiscCtrl) ;Aktiv och inväntar
		OR	-1		;nästa tangent (NC & NZ)
		RET
at4:		RES	BAccent,(IY+$MiscCtrl) ;Engångs
		LD	HL,ACCTAB
		LD	BC,ACCTAB$
		CPDR			;Giltig tangent?
		JR	NZ,at1		;Nej
		INC	HL
		LD	BC,ACCTAB$
		ADD	HL,BC		;Små med akut accent (NC)
		BIT	BShift,(IY+$KbdFlags) ;Shift?
		JR	Z,at5		;Nej
		CCF			;Stora
at5:		BIT	BCaps,(IY+$KbdLED) ;Caps Lock?
		JR	Z,at6		;Nej
		CCF
at6:		JR	NC,at7		;Små
		ADD	HL,BC,2		;Stora med akut accent
at7:		BIT	BGrave,(IY+$MiscCtrl) ;Grav accent?
		JR	Z,at8		;Nej
		ADD	HL,BC		;Små/stora med grav accent
at8:		LD	A,(HL)
		SCF
		RET


; Hantera tecken med umlaut (t ex tyskt ü)
; IN:	 E	tangentbordskod
; UT:	 E	orört
;	CY	A: "ascii" för modifierat tecken
;	NZ	inväntar nästa tangent

Umlaut:		LD	A,E
		BIT	BUmlaut,(IY+$MiscCtrl) ;Redan aktiv?
		JR	NZ,ut3		;Ja
		CP	5BH		;Umlauttangenten?
		JR	Z,ut2		;Ja
ut1:		XOR	A		;NC & Z
		RET
ut2:		BIT	BShift,(IY+$KbdFlags) ;Shift?
		JR	NZ,ut1		;Ja, det är ju cirkumflex
		SET	BUmlaut,(IY+$MiscCtrl) ;Aktiv och inväntar
		OR	-1		;nästa tangent (NC & NZ)
		RET
ut3:		RES	BUmlaut,(IY+$MiscCtrl) ;Engångs
		LD	HL,UMLTAB
		LD	BC,UMLTAB$
		CPDR			;Giltig tangent?
		JR	NZ,ut1		;Nej
		INC	HL
		LD	BC,UMLTAB$
		ADD	HL,BC		;Små med umlaut (NC)
		BIT	BShift,(IY+$KbdFlags) ;Shift?
		JR	Z,ut4		;Nej
		CCF			;Stora
ut4:		BIT	BCaps,(IY+$KbdLED) ;Caps Lock?
		JR	Z,ut5		;Nej
		CCF
ut5:		JR	NC,ut6		;Små
		ADD	HL,BC		;Stora med umlaut
ut6:		LD	A,(HL)
		SCF
		RET


; Hantera § och ½
; IN:	 E	tangentbordskod
; UT:	 E	orört
;	CY	A: ascii
;	NC	inte min sak

Section:	LD	A,E
		CP	0EH		;Rätt tangent?
		JR	Z,sn1		;Ja
		XOR	A
		RET
sn1:		SCF
		LD	A,15H		;Antag §
		BIT	BShift,(IY+$KbdFlags) ;Shift?
		RET	Z		;Nej
		LD	A,0ABH		;½
		RET


; Konvertera tangentbordskod
; IN:	 E	tangentbordskod
; UT:	 E	orört
;	NC	A: ASCII eller funktion

Convert:	LD	A,E
		LD	D,(IY+$KbdFlags) ;Cache
		BIT	BShift,D	;Shift?
		JR	Z,ct1		;Nej
		OR	80H
ct1:		LD	L,A
		LD	H,HIGH(LookUpS)
		LD	A,(HL)		;ASCII
		OR	A		;Giltig kod?
		JR	NZ,ct3		;Ja
		LD	L,E		;Prova utan Shift
		LD	A,(HL)		;ASCII
		OR	A		;Giltig kod?
		JR	NZ,ct3		;Ja
		SET	BHSFunKeyX,(IY+$HostStatusAI)
		INC	H		;LookUpX
		BIT	BNum,(IY+$KbdLED) ;NumLock tänd?
		JR	NZ,ct2		;Ja
		RES	BHSFunKeyX,(IY+$HostStatusAI)
		SET	BHSFunKeyY,(IY+$HostStatusAI)
		INC	H		;LookUpY
ct2:		LD	A,(HL)
		OR	A		;Giltig kod?
		SCF
		RET	Z		;Nej
		CCF			;Jo
		RET
ct3:		SET	BHSAscii,(IY+$HostStatusAI) ;Från tabell S
		CP	'A'		;< A?
		JR	C,ct10		;Ja, kolla AltGr
		CP	'Å'+1		;> Ö?
		JR	NC,ct10		;Ja
		BIT	BShift,D	;Ok, stor bokstav. Shift?
		JR	Z,ct4		;Nej
		CCF			;NC => liten bokstav
ct4:		BIT	BAnyC,D		;Någon av Ctrl, Alt, AltGr?
		JR	NZ,ct5		;Ja, strunta i Caps lock
		BIT	BCaps,(IY+$KbdLED) ;Caps Lock?
		JR	NZ,ct5		;Ja
		CCF			;Reversera inverkan av Shift
ct5:		JR	C,ct6		;Stor bokstav
		ADD	A,20H		;Gör liten bokstav
ct6:		BIT	BCtrl,D		;Ctrl?
		JR	Z,ct7		;Nej
		XOR	40H		;Ge Ctrl och Alt samma funktion
		BIT	BAlt,D		;Ctrl/Alt?
		JR	NZ,ct8		;Ja, hantera som Ctrl
ct7:		BIT	BAlt,D		;Alt?
		JR	Z,ct8		;Nej
		XOR	40H
ct8:		BIT	BAltGr,D	;AltGr?
		JR	Z,ct9		;Nej
		OR	80H
ct9:		OR	A
		RET
ct10:		BIT	BAltGr,D	;AltGr?
		JR	Z,ct6		;Nej
		LD	HL,ALTGRTAB
		LD	BC,ALTGRTAB$
		CPDR
		JR	NZ,ct6		;Finns inte
		LD	BC,ALTGRTAB$+1
		ADD	HL,BC
		LD	A,(HL)
		CP	'@'		;40H?
		JR	NZ,ct9		;Nej
		BIT	BCtrl,D		;Ctrl?
		JR	Z,ct11		;Nej
		XOR	A		;00
ct11:		BIT	BAlt,D		;Alt?
		RET	Z		;Nej
		OR	80H		;Alt får sätta bit 7
		RET


; Placera avkodad byte tillsammans med info om
; Shift, Ctrl etc i utmatningsbyffer
; IN:	 A	avkodad byte till host

QOut:		LD	HL,(OutBufPtrIn)
		LD	BC,OutBufferEnd
		OR	A
		SBC	HL,BC		;Fullt?
		ADD	HL,BC
		SET	BOutFull,(IY+$BufCtrl)
		RET	NC		;Ja
		RES	BOutFull,(IY+$BufCtrl)
		RES	BOutEmpty,(IY+$BufCtrl)
		LD	(HL),A		;HostData
		INC	HL
		LD	A,(HostStatusAI)
		LD	(HL),A		;HostStatusA
		INC	HL
		LD	A,(KbdState)
		AND	3FH
		BIT	BScroll,(IY+$KbdLED) ;Scroll Lock tänd?
		JR	Z,qout1		;Nej
		SET	BHSScroll,A
qout1:		LD	(HL),A		;HostStatusB
		INC	HL
		LD	(OutBufPtrIn),HL
		RET


; Mata ut data till host, om det går
; IN:	inget
; Host måste göra en dummy read av HostData för
; att kontrollern ska börja utmatningen.

Output:		IN	A,(KbdDataG)
		BIT	BHostAck,A	;Har host läst föregående byte?
		RET	Z		;Nej
		LD	HL,(OutBufPtrIn)
		LD	DE,OutBuffer
		OR	A
		SBC	HL,DE		;Finns mer att skicka ut?
		JR	NZ,output2	;Ja
		BIT	BStatUpd,A	;Önskas avbr vid ändrad status?
		RET	Z		;Nej
		LD	A,(KbdState)	;Kolla om StatusB har ändrats
		AND	3FH
		BIT	BScroll,(IY+$KbdLED) ;Scroll Lock tänd?
		JR	Z,output1	;Nej
		SET	BHSScroll,A
output1:	CP	(IY+$LastStatusB) ;Samma som förra gången?
		RET	Z		;Ja
		LD	(LastStatusB),A	;Uppdatera
		OUT	(HostStatusB),A
		LD	A,1 SHL BKbdInt OR 1 SHL BHostAckR
		OUT	(KbdDataS),A	;Reset på ACK-vippan
		RES	BHostAckR,A
		OUT	(KbdDataS),A
		XOR	A		;Avbrott med HostData och
		OUT	(HostData),A	;HostStatusA = 0 betyder
		OUT	(HostStatusA),A	;förändrad StatusB
		LD	A,StatUpdMask
		OUT	(KbdDataS),A	;Avbrott till host, inhibit kbd
		LD	A,1 SHL BKbdInt
		OUT	(KbdDataS),A
		RET
output2:	ADD	HL,DE
		PUSH	HL		;OutBufPtrIn
		LD	A,1 SHL BKbdInt OR 1 SHL BHostAckR
		OUT	(KbdDataS),A	;Reset på ACK-vippan
		RES	BHostAckR,A
		OUT	(KbdDataS),A
		LD	C,HostData	;Skicka ut data och status för
		LD	HL,(OutBufPtrOut) ;en tangenttryckning
		OUTI			;ASCII eller funktionstangent
		INC	C
		OUTI			;Status A
		INC	C
		OUTI			;Status B
		LD	(OutBufPtrOut),HL
		LD	A,StatUpdMask
		OUT	(KbdDataS),A	;Avbrott till host, inhibit kbd
		LD	A,1 SHL BKbdInt
		OUT	(KbdDataS),A
		POP	BC
		SBC	HL,BC		;Ikapp inmatningen?
		RET	NZ		;Nej
		LD	HL,OutBuffer	;Nollställ
		LD	(OutBufPtrIn),HL
		LD	(OutBufPtrOut),HL
		RES	BOutFull,(IY+$BufCtrl)
		SET	BOutEmpty,(IY+$BufCtrl)
		RET


; Hämta tangentbordskoder och kolla att de duger
; IN:	 B	antal att hämta
; UT:	A,E	tangentbordskod
; Ingen retur om något fel upptäcks

FetchOne:	LD	B,1
Fetch:		PUSH	BC
		CALL	GetScanCode
		JP	Z,KbdError	;Tomt (!), inget avbrott alls
		POP	BC
		DJNZ	Fetch
		RET


; Hämta tangentbordskod (FIFO)
; IN:	inget
; UT:	A,E	tangentbordskod
;	BC,HL	skräp
;	 F	Z: tomt, NZ: A,E gäller

GetScanCode:	SET	BInLock,(IY+$BufCtrl) ;Upptaget här nu
		CALL	getSC
		RES	BInLock,(IY+$BufCtrl) ;Inte upptaget längre
		PUSH	DE,AF
		LD	A,(ScanCode)
		LD	(IY+$ScanCode),0
		OR	A		;Kommit något under låsningen?
		JR	Z,gsc1		;Nej
		LD	E,A
		CALL	QIn
gsc1:		POP	AF,DE
		LD	A,E
		RET
getSC:		LD	HL,(RecBufPtrIn)
		LD	DE,RecBuffer
		OR	A
		SBC	HL,DE		;Finns något?
		RET	Z		;Nej
		ADD	HL,DE
		PUSH	HL
		LD	HL,(RecBufPtrOut)
		LD	E,(HL)
		INC	HL
		LD	(RecBufPtrOut),HL
		POP	BC
		SBC	HL,BC		;Ikapp inmatningen?
		RET	NZ		;Nej
		LD	HL,RecBuffer	;Nollställ
		LD	(RecBufPtrIn),HL
		LD	(RecBufPtrOut),HL
		RES	BInFull,(IY+$BufCtrl)
		SET	BInEmpty,(IY+$BufCtrl)
		OR	-1		;E gäller
		RET


; Gör kallstart

KbdInit:	LD	IY,BufCtrl	;Pekar IY alltid på
		LD	HL,KBDWrk	;Nollställ en del av wrk
		LD	DE,KBDWrk+1
		LD	BC,KBDClear$-1
		LD	(HL),0
		LDIR
		LD	(IY+$BufCtrl),BufCtrlInit
		LD	HL,RecBuffer	;Tom inmatningsbuffer
		LD	(RecBufPtrIn),HL
		LD	(RecBufPtrOut),HL
		LD	HL,OutBuffer	;Tom utmatningsbuffer
		LD	(OutBufPtrIn),HL
		LD	(OutBufPtrOut),HL
		IF	WRK
		XOR	A
		OUT	(0C2H),A
		ENDIF
		IN	A,(KbdVector)	;IntAck ifall Int är aktiv
		LD	HL,KbdInterrupt
		LD	A,H
		LD	I,A
		LD	A,L
		OUT	(KbdVector),A
		IM	2
		EI
		RET


; Avbrott från tangentbordet (KBDDATA låg)
; För 4 och 8 MHz

		ALIGN
KbdInterrupt:	DW	KbdService
KbdService:	PUSH	HL,DE,BC,AF
		IF	MHZ8
		LD	A,1		;Vänta 10 µs efter startbitens
		CALL	Delay		;flank
		ENDIF
		CALL	Receive
		XOR	A
		OUT	(KbdDataS),A
		SET	BKbdInt,A
		OUT	(KbdDataS),A	;EI till 74LS74
		SET	BInt,(IY+$BufCtrl) ;Kommit avbrott
		POP	AF,BC,DE,HL
		EI
		RET


; Ta emot en byte data från tangentbordet
; IN:	inget
; UT:	A,BC,HL	skräp
;	 D	B0: paritet, B1: stoppbit
;	 E	erhållen databyte
; RecBufPtrIn pekar efter läst data (E) i RecBuffer

Receive:	LD	B,10		;8 bitar + paritet + stopp
		LD	DE,0
receive1:	IN	A,(KbdDataG)
		BIT	BKbdClk,A	;KbdClk gått hög?
		JR	Z,receive1	;Nej, vänta på det
receive2:	IN	A,(KbdDataG)
		BIT	BKbdClk,A	;KbdClk gått låg?
		JR	NZ,receive2	;Nej, vänta på det
		RRA			;Flytta biten till CY
		RR	D,E		;och spara i DE
		DJNZ	receive1	;Alla 10
		LD	B,6
receive3:	RR	D,E		;Justera
		DJNZ	receive3
		LD	A,E
		OR	A		;Rätt paritet?
		JP	PO,receive4	;Data har udda
		BIT	0,D		;Vid jämn paritet ska bit 0=1
		JR	NZ,QIn		;Ok
		RET
receive4:	BIT	0,D		;Då ska paritetsbiten vara 0
		RET	NZ		;Paritetsfel


; Placera erhållen tangentbordskod i inmatningsbuffer
; Spara koden i ScanCode om buffern är låst
; IN:	 E	tangentbordskod

QIn:		BIT	BInLock,(IY+$BufCtrl) ;Låst?
		JR	Z,qin1		;Nej
		LD	(IY+$ScanCode),E
		RET
qin1:		LD	HL,(RecBufPtrIn)
		LD	BC,RecBufferEnd
		OR	A
		SBC	HL,BC		;Fullt?
		ADD	HL,BC
		SET	BInFull,(IY+$BufCtrl)
		RET	NC		;Ja
		RES	BInFull,(IY+$BufCtrl)
		RES	BInEmpty,(IY+$BufCtrl)
		LD	(HL),E
		INC	HL
		LD	(RecBufPtrIn),HL
		RET


; Sänd en byte data till tangentbordet
; IN:	 A	byte att sända

Send:		LD	E,A		;Bilda udda paritet
		LD	D,0
		OR	A
		JP	PO,send1	;Data är redan udda
		INC	D		;Udda nu
send1:		SET	1,D		;Garantera 1 som stoppbit
		CPL	DE		;Kompensera för 7406
		XOR	A
		OUT	(KbdDataS),A	;Inga avbrott
		LD	B,10		;8 bitar + paritet + stopp
		LD	A,1 SHL BKbdData
		OUT	(KbdDataS),A	;KbdData låg är RTS
send2:		IN	A,(KbdDataG)
		BIT	BKbdClk,A	;KbdClk gått låg?
		JR	NZ,send2	;Nej, vänta på det
		XOR	A
		RR	D,E		;Ta en bit från DE och
		RLA			;driv KbdData med den
		OUT	(KbdDataS),A
send3:		IN	A,(KbdDataG)
		BIT	BKbdClk,A	;KbdClk gått hög?
		JR	Z,send3		;Nej, vänta på det
		DJNZ	send2		;Alla 10
send4:		IN	A,(KbdDataG)	;Vänta på tangentbordet
		BIT	BKbdClk,A	;KbdClk gått låg?
		JR	NZ,send4	;Nej, vänta på det
send5:		IN	A,(KbdDataG)
		BIT	BKbdClk,A	;KbdClk gått hög?
		JR	Z,send5		;Nej, vänta på det
send6:		IN	A,(KbdDataG)	;Vänta tills KbdData gått hög
		BIT	BKbdData,A	;KbdData gått hög?
		JR	Z,send6		;Nej, vänta på det
		LD	A,1 SHL BKbdInt
		OUT	(KbdDataS),A	;EI
		RET


; Vänta i B * 50 µs och testa under tiden BInt
; IN:	 B	multipel av tidbasen
;	DE	reserverat
; UT:	AF	status:
;	 Z	tiden har gått ut
;	NZ	avbrott har kommit

DelayIntD:	LD	B,0		;Default ca 13 ms
DelayInt:	LD	HL,BufCtrl
		RES	BInt,(HL)	;Har inte fått avbrott
DelayIntC:	BIT	BInt,(HL)	;Fått avbrott?
		RET	NZ		;Ja
		LD	A,5		;50 µs
		CALL	Delay
		DJNZ	DelayIntC
		RET


; Vänta i A * 10 µs (exakt)
; IN:	 A	multipel av tidbasen
; UT:	 A	0
;	 Z	1
;	Resten orört
; OBS!	CALL (17 T) förutsätts.
;	För avbrott ansvaras ej!

Delay:		NOP	2		;8
		IF	MHZ6
delay20:	INC	IX		;10
		DEC	IX		;10
		ENDIF
		IF	MHZ8
delay40:	INC	IX,2		;10 + 10
		DEC	IX,2		;10 + 10
		ENDIF
delay1:		DEC	A		;4
		RET	Z		;5/11
		PUSH	AF		;11
		POP	AF		;10
		IF	MHZ4
		JP	delay1		;10
		ENDIF			;4 MHz = 40 T
		IF	MHZ6
		JP	delay20		;10
		ENDIF			;6 MHz = 60 T
		IF	MHZ8
		JP	delay40		;10
		ENDIF			;8 MHz = 80 T


; Generera 16 bitars CRC
; Polynom: X^16 + X^15 + X^2 + 1
; IN:	BC	antal byte
;	HL	startadress
; UT:	HL	adressen till nästa byte
;	DE	beräknad CRC

GCRC:		EXX
		LD	HL,-1		;Init CRC
		LD	DE,8005H	;Polynom
		EXX
gc1:		LD	A,(HL)
		INC	HL
		EXX
		LD	B,8
gc2:		LD	C,A
		AND	80H
		XOR	H
		LD	H,A
		ADD	HL,HL
		JR	NC,gc3
		XOR	HL,DE
gc3:		LD	A,C
		RLA
		DJNZ	gc2
		EXX
		DEC	BC
		OR	BC
		JR	NZ,gc1
		PUSH	HL'
		POP	DE
		RET
		FILE	KBDK

+---------------------------------------------+
¦					      ¦
¦	-=­ KBDK ­=-			      ¦
¦					      ¦
¦	Tangentbordskontroller		      ¦
¦	Kommandon			      ¦
¦					      ¦
¦	Entry: ........... KBDK.TX	      ¦
¦	Version: ......... 1.0		      ¦
¦	Startad: ......... 92 04 28	      ¦
¦	Senast ändrad: ... 92 05 23	      ¦
¦					      ¦
¦	Mikael Pontén			      ¦
¦	Pons Data			      ¦
¦					      ¦
+---------------------------------------------+


; Kommando Set Status Indicators

SetStatusInd:	LD	A,SetStatusIndC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		LD	A,(DataBufLo)	;Status att sätta
		CALL	Send		;Till tangentbordet
		CALL	DelayIntD	;Vänta på ACK
		LD	B,2
		JP	Fetch


; Kommando Echo

Echo:		LD	A,EchoC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på EE
		CALL	FetchOne
		CP	0EEH		;Det är väl EE?
		RET	Z		;Ja
		JP	EchoError


; Kommando Select Alternate Mode

SelAltMode:	LD	A,SelAltModeC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK (ca 200 µs)
		LD	A,(DataBufLo)	;Option byte från host
		PUSH	AF		;Minns typ av option
		CALL	Send		;Till tangentbordet
		CALL	DelayIntD	;Vänta på ACK (ca 300 µs)
		CALL	DelayIntD	;Invänta mod från kbd (ca 600µs)
		LD	B,2
		CALL	Fetch
		POP	AF
		OR	A		;Sätta eller fråga mod?
		RET	NZ		;Sätta
		CALL	FetchOne	;Hämta mode
		LD	(DataBufLo),A
		RET


; Kommando Enhanced Keyboard Indicator

EnhKbdInd:	LD	A,EnhKbdIndC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		CALL	DelayIntD	;Vänta på idkod 1
		CALL	DelayIntD	;Vänta på idkod 2
		LD	B,2
		CALL	Fetch		;ID-kod 1 (låg)
		LD	(DataBufLo),A
		CALL	FetchOne	;ID-kod 2 (hög)
		LD	(DataBufHi),A
		RET


; Kommando Set Key Repeat Rate

SetKeyRepeat:	LD	A,SetKeyRepeatC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		LD	A,(DataBufLo)	;Rate från host
		CALL	Send		;Till tangentbordet
		CALL	DelayIntD	;Vänta på ACK
		LD	B,2
		JP	Fetch


; Kommando Enable keyboard

Enable:		LD	A,EnableC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		CALL	FetchOne
		CP	0FAH		;Det är väl FA?
		RET	Z		;Ja
		JP	ACKError


; Kommando Default Disable

Disable:	LD	A,DisableC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		CALL	FetchOne
		CP	0FAH		;Det är väl ACK (FA)?
		RET	Z		;Ja
		JP	ACKError


; Kommando Set Default Conditions

Default:	LD	A,DefaultC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		CALL	FetchOne
		CP	0FAH		;Det är väl ACK (FA)?
		RET	Z		;Ja
		JP	ACKError


; Kommando Set All Keycodes

SetAllT:	LD	A,SetAllTC
		JR	SetAll
SetAllMB:	LD	A,SetAllMBC
		JR	SetAll
SetAllM:	LD	A,SetAllMC
		JR	SetAll
SetAllTMB:	LD	A,SetAllTMBC
SetAll:		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		CALL	FetchOne
		CP	0FAH		;Det är väl ACK (FA)?
		RET	Z		;Ja
		JP	ACKError


; Kommando Set Individual Keycodes

SetKeyT:	LD	A,SetKeyTC
		JR	SetKey
SetKeyMB:	LD	A,SetKeyMBC
		JR	SetKey
SetKeyM:	LD	A,SetKeyMC
SetKey:		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		LD	A,(DataBufLo)
		CALL	Send		;Det gäller denna tangent
		CALL	FetchOne
		CP	0FAH		;Fick väl ACK?
		RET	Z		;Ja
		JP	ACKError


; Kommando Resend

Resend:		LD	A,ResendC
		JP	Send		;Sänd kommandot


; Kommando Reset

Reset:		LD	A,ResetC
		CALL	Send		;Sänd kommandot
		CALL	DelayIntD	;Vänta på ACK
		CALL	DelayIntD	;Vänta på AA
		JR	NZ,reset2
		LD	DE,100		;> 1 s
reset1:		PUSH	DE
		CALL	DelayIntC	;Kan ta ett tag
		POP	DE
		JR	NZ,reset2
		DEC	DE
		OR	DE
		JR	NZ,reset1
		JP	ResetError
reset2:		LD	B,2
		CALL	Fetch
		CP	0AAH		;Har väl fått AA?
		RET	Z		;Ja
		JP	ResetError


; Kommando Define
; Aktivera tangentbordet med inmatade tabeller

Define:		LD	A,(MODE)	;Man kan bara definiera
		CP	3		;tangenter i mod 3
		RET	NZ
		CALL	Reset		;Reset först
		LD	A,3		;Mode är 3
		LD	(DataBufLo),A
		CALL	SelAltMode	;Definiera mod 3
		LD	A,(RATE)
		LD	(DataBufLo),A
		CALL	SetKeyRepeat	;Definiera repeteringshastighet
		CALL	SetAllT		;Alla T och sen de avvikande
		LD	HL,MBTAB	;Definiera Make/Break
		LD	BC,MBTAB$
		LD	DE,DataBufLo
		OR	BC		;Något i tabellen?
		JR	Z,de2		;Nej
de1:		LD	A,(HL)
		LD	(DE),A
		INC	HL
		DEC	BC
		PUSH	HL,DE,BC
		CALL	SetKeyMB
		POP	BC,DE,HL
		OR	BC		;Fler?
		JR	NZ,de1		;Ja
de2:		LD	HL,MTAB		;Definiera Make
		LD	BC,MTAB$
		OR	BC		;Något i tabellen?
		JR	Z,de4		;Nej
de3:		LD	A,(HL)
		LD	(DE),A
		INC	HL
		DEC	BC
		PUSH	HL,DE,BC
		CALL	SetKeyM
		POP	BC,DE,HL
		OR	BC		;Fler?
		JR	NZ,de3		;Ja
de4:		CALL	BuildS		;För snabb ASCII-konvertering
		CALL	BuildX
		CALL	BuildY
		LD	A,(STATUS)	;Sätt LED status
		LD	(DataBufLo),A
		LD	(IY+$KbdLED),A
		JP	SetStatusInd


; Bygg en lookup tabell av KBDT
; Detta är en ren lyx, som bara kostar 256 byte RAM.
; Det går mycket, mycket snabbare att få fram ASCII genom
; att gå in i en "lookup" än att avsöka KBDT i värsta fall
; 2 gånger med CPDR. LookUpS börjar på xx00.

BuildS:		LD	HL,LookUpS
		LD	DE,LookUpS+1
		LD	BC,255
		LD	(HL),0
		LDIR			;Allt är 0
		LD	HL,KBDT		;Sista byte i tabellen
		LD	B,KBDT$		;# byte i KBDT och ASCII+1
		DEC	D		;HIGH LookUpS
bs1:		LD	E,(HL)		;Läs tangentbordskod i KBDT
		DEC	HL
		INC	E		;-1?
		JR	Z,bs2		;Ja, glöm den
		DEC	E
		LD	A,B
		DEC	A		;Bilda ASCII
		LD	(DE),A		;Tangentbordskod = ASCII
bs2:		DJNZ	bs1
		RET


; Bygg en lookup tabell av KBDTX
; LookUpX används när NumLock är tänd.
; Det finns ingen anledning att spara minne -
; varken i ROM eller RAM. Det här ska gå fort.
; LookUpX börjar på xx00.

BuildX:		LD	HL,LookUpX
		LD	DE,LookUpX+1
		LD	BC,255
		LD	(HL),0
		LDIR			;Allt är 0
		LD	HL,KBDTX	;Sista byte i tabellen
		LD	B,KBDTX$	;# byte i KBDTX
		DEC	D		;HIGH LookUpX
bx1:		LD	E,(HL)		;Läs tangentbordskod i KBDTX
		DEC	HL
		INC	E		;-1?
		JR	Z,bx2		;Ja, glöm den
		DEC	E
		LD	A,B
		DEC	A		;Bilda min kod
		LD	(DE),A
bx2:		DJNZ	bx1
		RET


; Bygg en lookup tabell av KBDTY
; LookUpY används när NumLock är släckt.
; LookUpY börjar på xx00.

BuildY:		LD	HL,LookUpY
		LD	DE,LookUpY+1
		LD	BC,255
		LD	(HL),0
		LDIR			;Allt är 0
		LD	HL,KBDTY	;Sista byte i tabellen
		LD	B,KBDTY$	;# byte i KBDTY
		DEC	D		;HIGH LookUpY
by1:		LD	E,(HL)		;Läs tangentbordskod i KBDTY
		DEC	HL
		INC	E		;-1?
		JR	Z,by2		;Ja, glöm den
		DEC	E
		LD	A,B
		DEC	A		;Bilda min kod
		LD	(DE),A
by2:		DJNZ	by1
		RET


; Diverse fel

KbdError:	LD	A,KbdErr	;Fel på tangentbordet
		JR	ERROR
ResetError:	LD	A,ResetErr	;Fel på tangentbordet
		JR	ERROR
EchoError:	LD	A,EchoErr	;Inget EE
		JR	ERROR
ACKError:	LD	A,ACKErr	;Ingen ACK
		JR	ERROR


; Fel lämnas utan åtgärd, vad göra?
; IN:	 A	felkod

		IF	WRK
ERROR:		RST	BRKPT
		LD	SP,(RegSP)
		ELSE
ERROR:		LD	SP,(RegSP)
		ENDIF
		RET
		FILE	KBDT

+---------------------------------------------+
¦					      ¦
¦	-=­ KBDT ­=-			      ¦
¦					      ¦
¦	Tangentbordskontroller		      ¦
¦	Tabeller			      ¦
¦					      ¦
¦	Entry: ........... KBDT.TX	      ¦
¦	Version: ......... 1.0		      ¦
¦	Startad: ......... 92 04 29	      ¦
¦	Senast ändrad: ... 92 05 24	      ¦
¦					      ¦
¦	Mikael Pontén			      ¦
¦	Pons Data			      ¦
¦					      ¦
+---------------------------------------------+


; Kommandon från host till kontroller
;
; Kommandon till tangentbordet

KbdCBS:		DB	1	;SetStatusInd
		DB	2	;Echo
		DB	3	;SelAltMode
		DB	4	;EnhKbdInd
		DB	5	;SetKeyRepeat
		DB	6	;Enable
		DB	7	;Disable
		DB	8	;Default
		DB	9	;SetAllT
		DB	10	;SetAllMB
		DB	11	;SetAllM
		DB	12	;SetAllTMB
		DB	13	;SetKeyT
		DB	14	;SetKeyMB
		DB	15	;SetKeyM
		DB	16	;Resend
		DB	17	;Reset


; Kommandon till kontrollern

		DB	ICC+1	;Define
KbdCB:		EQU	$-1
KbdCB$:		EQU	$-KbdCBS


; Adresser till kontrollerns kommandon

KbdCMD:		DW	SetStatusInd
[ 2]		DW	Echo
[ 3]		DW	SelAltMode
[ 4]		DW	EnhKbdInd
[ 5]		DW	SetKeyRepeat
[ 6]		DW	Enable
[ 7]		DW	Disable
[ 8]		DW	Default
[ 9]		DW	SetAllT
[10]		DW	SetAllMB
[11]		DW	SetAllM
[12]		DW	SetAllTMB
[13]		DW	SetKeyT
[14]		DW	SetKeyMB
[15]		DW	SetKeyM
[16]		DW	Resend
[17]		DW	Reset
[ICC+1]		DW	Define


; Tangentbordstabell för standardtangenter
;
;		SCAN CODE		ASCII

KBDTS:	DB	-1,-1,-1,-1		;00
	DB	-1,-1,-1,-1		;04
	DB	66H,0DH,-1,-1		;08
	DB	-1,5AH,-1,-1		;0C
	DB	-1,61H,6AH,63H		;10
	DB	60H,64H,67H,-1		;14
	DB	-1,6EH,65H,8		;18
	DB	-1,-1,-1,-1		;1C
	DB	29H,96H,9EH,0A6H	;20
	DB	0A5H,0AEH,0B6H,5CH	;24
	DB	0BEH,0C6H,0DCH,4EH	;28
	DB	41H,4AH,49H,0BDH	;2C
	DB	45H,16H,1EH,26H		;30
	DB	25H,2EH,36H,3DH		;34
	DB	3EH,46H,0C9H,0C1H	;38
	DB	13H,0C5H,93H,0CEH	;3C
	DB	-1,1CH,32H,21H		;40
	DB	23H,24H,2BH,34H		;44
	DB	33H,43H,3BH,42H		;48
	DB	4BH,3AH,31H,44H		;4C
	DB	4DH,15H,2DH,1BH		;50
	DB	2CH,3CH,2AH,1DH		;54
	DB	22H,35H,1AH,52H		;58
	DB	4CH,54H,0DBH,0CAH	;5C
KBDT:	EQU	$-1
KBDT$:	EQU	$-KBDTS


; Tangentbordstabell för funktionstangenter och keypad
; Denna tabell används när NumLock är tänd.
;
;		SCAN CODE		ASCII/NUMMER

KBDTXS:	DB	-1,7,0FH,17H		;00 F1 - F3
	DB	1FH,27H,2FH,37H		;04 F4 - F7
	DB	3FH,47H,4FH,56H		;08 F8 - F11
	DB	5EH,79H,57H,62H		;0C F12, Enter, PrSc, Pause
	DB	6FH,6DH,-1,-1		;10 Page Up, Page Down
	DB	-1,-1,-1,-1		;14
	DB	-1,-1,-1,-1		;18
	DB	-1,-1,-1,-1		;1C
	DB	-1,-1,-1,-1		;20
	DB	-1,-1,-1,-1		;24
	DB	-1,-1,7EH,7CH		;28 * +
	DB	-1,84H,71H,77H		;2C - . /
	DB	70H,69H,72H,7AH		;30 0 - 3
	DB	6BH,73H,74H,6CH		;34 4 - 7
	DB	75H,7DH			;38 8 - 9
KBDTX:	EQU	$-1
KBDTX$:	EQU	$-KBDTXS


; Tangentbordstabell för funktionstangenter och keypad
; Denna tabell används när NumLock är släckt.
;
;		SCAN CODE		ASCII/NUMMER

KBDTYS:	DB	-1,7,0FH,17H		;00 F1 - F3
	DB	1FH,27H,2FH,37H		;04 F4 - F7
	DB	3FH,47H,4FH,56H		;08 F8 - F11
	DB	5EH,79H,57H,62H		;0C F12, Enter, PrSc, Pause
	DB	6FH,6DH,70H,69H		;10 Page Up, Page Down, 0, 1
	DB	72H,7AH,6BH,73H		;14 2 - 5
	DB	74H,6CH,75H,7DH		;18 6 - 9
	DB	77H,7EH,84H,7CH		;1C / * - +
	DB	71H			;20 .
KBDTY:	EQU	$-1
KBDTY$:	EQU	$-KBDTYS


; Tangentbordskoder för modifierare:
; ShiftL, ShiftR, CtrlL, CtrlR, Alt, AltGr

STATETABS:	DB	12H,59H,11H,58H,19H,39H
STATETAB:	EQU	$-1
STATETAB$:	EQU	$-STATETABS
		DB	1 SHL BShiftL,1 SHL BShiftR
		DB	1 SHL BCtrlL,1 SHL BCtrlR
		DB	1 SHL BAlt,1 SHL BAltGr


; Tangenter som påverkas av AltGr
; 2, 3, 4, 7, 8, 9, 0, +, <

ALTGRTABS:	DB	'2347890+<'
ALTGRTAB:	EQU	$-1
ALTGRTAB$:	EQU	$-ALTGRTABS
		DB	'@#${[]}\|'


; Tangenter som påverkas av accenttangenten
; eaiou; små bokstäver först, sedan stora
; Översättningen gäller för Seikosha Set 2 IBM Mod
; Om motsvarighet för stor bokstav saknas återges den lilla.

ACCTABS:	DB	24H,1CH,43H,44H,3CH
ACCTAB:		EQU	$-1
ACCTAB$:	EQU	$-ACCTABS
[ akut ]	DB	82H,0A0H,0A1H,0A2H,0A3H
[ grav ]	DB	8AH,85H,8DH,95H,97H
[ AKUT ]	DB	90H,0A0H,0A1H,0A2H,0A3H
[ GRAV ]	DB	8AH,85H,8DH,95H,97H


; Tangenter som påverkas av umlauttangenten
; uaeioy; små bokstäver först, sedan stora
; Översättningen gäller för Seikosha Set 2 IBM Mod
; Om motsvarighet för stor bokstav saknas återges den lilla.

UMLTABS:	DB	3CH,1CH,24H,43H,44H,35H
UMLTAB:		EQU	$-1
UMLTAB$:	EQU	$-UMLTABS
[ små ]		DB	81H,84H,89H,8BH,94H,98H
[ STORA ]	DB	9AH,8EH,89H,8BH,99H,98H


; Scankoder till tangenter för lysdioderna
; Num Lock, Scroll Lock, Caps Lock

LEDTABS:	DB	76H,5FH,14H
LEDTAB:		EQU	$-1
LEDTAB$:	EQU	$-LEDTABS
		DB	1 SHL BNum,1 SHL BScroll,1 SHL BCaps


; Scankoder till tangenter som är Make/Break
; VShift, HShift, VCtrl, HCtrl, VAlt, AltGr

MBTAB:		DB	12H,59H,11H,58H,19H,39H
MBTAB$:		EQU	$-MBTAB


; Scankoder till tangenter som är Make
; Caps Lock, Num Lock, Scroll Lock, Accenttangent

MTAB:		DB	14H,76H,5FH,55H
MTAB$:		EQU	$-MTAB


; Diverse

MODE:		DB	3	;Tangentbordsmod, PS/2
RATE:		DB	0	;Repeteringshastighet, snabbaste
STATUS:		DB	1 SHL BNum ;Num Lock tänd
		CRC
KBDEnd:		EQU	$
		END


+---------------------------------------------+
¦					      ¦
¦	-=­ KBDQ ­=-			      ¦
¦					      ¦
¦	Tangentbordskontroller		      ¦
¦	Equates och workspace		      ¦
¦					      ¦
¦	Entry: ........... KBDQ.TX	      ¦
¦	Version: ......... 1.0		      ¦
¦	Startad: ......... 92 04 16	      ¦
¦	Senast ändrad: ... 92 05 24	      ¦
¦					      ¦
¦	Mikael Pontén			      ¦
¦	Pons Data			      ¦
¦					      ¦
+---------------------------------------------+


; Initierande villkor

FALSE:		EQU	0
TRUE:		EQU	NOT(FALSE)
WRK:		EQU	TRUE	;Utveckling
WLIST:		EQU	TRUE	;Hjälpsymboler för SD
MHZ4:		EQU	TRUE	;CPU clk = 4  MHz
MHZ6:		EQU	FALSE	; 6  MHz
MHZ8:		EQU	FALSE	; 8  MHz
MHZ10:		EQU	FALSE	; 10 MHz
		WIDTH	12,96


; Portarnas organisation
;
; Portar som avkodas av chip KEYDC

PORT:		EQU	010H	;Basadress för portar
		IF	WLIST
UPORTZ:		EQU	0
		ENDIF
KbdVector:	EQU	PORT+0	;Avbrottsvektor			RW
KbdDataS:	EQU	PORT+1	;Data till tangentbordet	W
KbdDataG:	EQU	PORT+2	;Data från tangentbordet	R
HostData:	EQU	PORT+3	;Data till host			W
HostStatusA:	EQU	PORT+4	;Status A till host		W
HostStatusB:	EQU	PORT+5	;Status B till host		W
		IF	WLIST
EPORTZ:		EQU	0
		ENDIF


; Bitar i KbdDataS, aktiva = 1

BKbdData:	EQU	0	;Datalinan
BKbdClk:	EQU	1	;Klocklinan
BKbdInt:	EQU	2	;Iff till 74LS74
BHostInt:	EQU	3	;Avbrott till host
BHostReset:	EQU	4	;Reset på host
BHostAckR:	EQU	5	;Reset HostAck FF
StatUpdMask:	EQU	00001110B ;Vid uppdatering av StatusB


; Bitar i KbdDataG

[  RESERVERAD	EQU	0	;Datalinan   ]
[  RESERVERAD	EQU	1	;Klocklinan  ]
BHostAck:	EQU	2	;Host har läst HostData
BStatUpd:	EQU	3	;Shift, Ctrl etc & Scroll Lock ger avbr


; Bitar i HostStatusA

BHSAscii:	EQU	0	;Data är ASCII, tabell S
BHSFunKeyX:	EQU	1	;Data från tabell X
BHSFunKeyY:	EQU	2	;Data från tabell Y
BHSHex:		EQU	3	;Data är hex från keypad
BHSBusy:	EQU	7	;Busy
HSAInit:	EQU	1 SHL BHSBusy


; Bitar i HostStatusB, uppdateras kontinuerligt
; Bit 0 - 5 är en kopia av KbdState

BHSScroll:	EQU	6	;Läget av Scroll Lock


; Kommandon
; Kontroller till tangentbord
; Host till kontroller inom []

SetStatusIndC:	EQU	0EDH	;Set status indicators		[ 1]
EchoC:		EQU	0EEH	;Echo (för diagnostik)		[ 2]
SelAltModeC:	EQU	0F0H	;Select alternate mode		[ 3]
EnhKbdIndC:	EQU	0F2H	;Enhanced keyboard indicator	[ 4]
SetKeyRepeatC:	EQU	0F3H	;Set key repeat speed		[ 5]
EnableC:	EQU	0F4H	;Enable keyboard		[ 6]
DisableC:	EQU	0F5H	;Disable keyboard		[ 7]
DefaultC:	EQU	0F6H	;Set default conditions		[ 8]
SetAllTC:	EQU	0F7H	;Set all keys typematic only	[ 9]
SetAllMBC:	EQU	0F8H	;Set all keys Make/Break only	[10]
SetAllMC:	EQU	0F9H	;Set all keys Make only		[11]
SetAllTMBC:	EQU	0FAH	;Set all keys Typematic/Make/Break [12]
SetKeyTC:	EQU	0FBH	;Set key typematic only		[13]
SetKeyMBC:	EQU	0FCH	;Set key Make/Break only	[14]
SetKeyMC:	EQU	0FDH	;Set key Make only		[15]
ResendC:	EQU	0FEH	;Resend				[16]
ResetC:		EQU	0FFH	;Reset				[17]
ICC:		EQU	17


; Kommandon till kontrollern

DefineC:	EQU	ICC+1	;Aktivera inmatade tabeller


; Interna felkoder

KbdErr:		EQU	-1	;Fel på tangentbordet
ResetErr:	EQU	-2	;Fel på tangentbordet
EchoErr:	EQU	-3	;Fick inte EE
ACKErr:		EQU	-4	;Fick inte ACK


; Minnets uppdelning

		IF	WRK
RWM:		ORG	0B000H
		ELSE
RWM:		ORG	08000H
		ENDIF
$RWM:		EQU	RWM+2048
		IF	WLIST
SOWIDZ:		EQU	0
		ENDIF
KBDWrk:		EQU	$
BufCtrl:	DS	1	;Flaggor
KbdFlags:	DS	1	;Flaggor
KbdState:	DS	1	;Flaggor
KbdLED:		DS	1	;Flaggor
MiscCtrl:	DS	1	;Flaggor
HexDig:		DS	1	;Blivande hex
HexCnt:		DS	1	;Räknare
ScanCode:	DS	1	;Tangentbordskod erhållen under BInLock
HostStatusAI:	DS	1	;Status A till host
LastStatusB:	DS	1	;Förra läget av HostStatusB
		ALIGN
KBDClear$:	EQU	$-KBDWrk ;Hit nollställs vid kallstart
RegSP:		DS	2	;Sparad SP
DataBufLo:	DS	1
DataBufHi:	DS	1
RecBufPtrIn:	DS	2
RecBufPtrOut:	DS	2
OutBufPtrIn:	DS	2
OutBufPtrOut:	DS	2
RecBuffer:	DS	32
RecBufferEnd:	EQU	$
		IF	WLIST
EOWIDZ:		EQU	$
		ENDIF
		ALIGN	256
KbdStack:	EQU	$	;Programmets stack
LookUpS:	DS	256	;Korsreferens tangentbord - ASCII
LookUpX:	DS	256	;Funktionstangenter och keypad (ASCII)
LookUpY:	DS	256	;Funktionstangenter och keypad
OutBuffer:	DS	$RWM-$	;Type ahead buffer
OutBufferEnd:	EQU	$


; Bitar i BufCtrl, aktiva = 1

BInt:		EQU	0	;Kommit avbrott från tangentbordet
BInFull:	EQU	1	;Inmatningsbuffern är full
BInEmpty:	EQU	2	;Inmatningsbuffern är tom
BOutFull:	EQU	3	;Utmatningsbuffern är full
BOutEmpty:	EQU	4	;Utmatningsbuffern är tom
BInLock:	EQU	5	;Inmatningsbuffern är låst
BufCtrlInit:	EQU	1 SHL BInEmpty OR 1 SHL BOutEmpty


; Bitar i KbdFlags, aktiva = 1

BShift:		EQU	0	;Någon av ShiftL, ShiftR
BCtrl:		EQU	1	;Någon av CtrlL, CtrlR
BAnyC:		EQU	2	;Någon av Ctrl, Alt, AltGr
[		EQU	3	;LEDIG	]
[  RESERVERAD	EQU	4	;Alt	]
[  RESERVERAD	EQU	5	;AltGr	]


; Bitar i KbdState, aktiva = 1

BShiftL:	EQU	0	;Vänster Shift
BShiftR:	EQU	1	; höger
BCtrlL:		EQU	2	;Vänster Ctrl
BCtrlR:		EQU	3	; höger
BAlt:		EQU	4	;Alt
BAltGr:		EQU	5	;AltGr
BBreak:		EQU	7	;Väntar på Break
AnyCMask:	EQU	00111100B ;Någon av Ctrl, Alt eller AltGr
HostResetMask:	EQU	00010101B ;Ctrl/Alt/Shift


; Bitar i KbdLED, aktiva = 1

BScroll:	EQU	0	;Scroll Lock
BNum:		EQU	1	;Num Lock
BCaps:		EQU	2	;Caps Lock


; Bitar i MiscCtrl, aktiva = 1

BHex:		EQU	0	;Inmatning av hex på keypad pågår
BAccent:	EQU	1	;Inmatning av tecken med accent pågår
BGrave:		EQU	2	;Accent grave
BUmlaut:	EQU	3	;Umlaut


; Offset IY relativt BufCtrl

OFFIYZ:		EQU	0
$BufCtrl:	EQU	BufCtrl-BufCtrl
$KbdFlags:	EQU	KbdFlags-BufCtrl
$KbdState:	EQU	KbdState-BufCtrl
$KbdLED:	EQU	KbdLED-BufCtrl
$MiscCtrl:	EQU	MiscCtrl-BufCtrl
$HexDig:	EQU	HexDig-BufCtrl
$HexCnt:	EQU	HexCnt-BufCtrl
$ScanCode:	EQU	ScanCode-BufCtrl
$HostStatusAI:	EQU	HostStatusAI-BufCtrl
$LastStatusB:	EQU	LastStatusB-BufCtrl
OFFIYE:		EQU	0
$KBDEND:	END