please dont rip this site

Scenix Lib IO OSI2 IR DA Irda

MainInfoSeg	MACRO
;********************************************************************************
;  Main Code
;********************************************************************************
		ENDM

MainCodeSeg	MACRO
;********************************************************************************
;  Main Code
;********************************************************************************

ledRX		=	ra.0
ledTX		=	ra.1
ledCON		=	ra.2
ledERR		=	ra.3

Startup
	mov	m, #TRIS
	mov	 ra, #%0000		;init Port A
	mov	!ra, #%0000		;Port A (LEDs) - Outputs

	mov	 rb, #%00001100		;init rb - UartTx (bit 2) and UartCTS (bit 3) = idle high
	mov	!rb, #%01110011		;Direction
	mov	m, #PLP
	mov	!rb, #%11001111		;Enable pullup on unused pins (bits 4 and 5)
	mov	m, #WKED
	mov	!rb, #%11111110		;IrRx (bit 6) = falling edge, UartRx (bit0) = rising edge

	clr	rc			;Init output to 0
	mov	m, #TRIS
	mov	!rc, #%10101011		;Port C (IO Port) direction - set for jumper use
	mov	m, #PLP
	mov	!rc, #%01010100		;Port C (IO Port) pullup - enabled on input pins

	clr	fsr			;reset all ram banks
:loop	setb	fsr.4
	clr	ind
	ijnz	fsr,:loop

	call	@IsrInit

	call	@a2flReset
	call	@a2plReset
	call	@a2lapReset
	call	@a2lmpReset
	call	@a2appReset

Asynchronous				;Note: flags are global
	snb	IrdaRxAvail		;Irda byte received ?
	call	@a2flRxAvail
	snb	IrdaTxEmpty		;Irda TxEmpty flag set ?
	call	@a2flTxEmpty
	snb	UartRxAvail		;Uart byte received ?
	call	@a2appRxAvail
	snb	TimerOverflow		;Timer Overflow flag set ?
	call	@a2lapTimer
	jmp	Asynchronous

;********************************************************************************

		ENDM
IsrInfoSeg	MACRO
;********************************************************************************
;  Interrupt Service Routine
;********************************************************************************
;  Updated 19 November 1999 - Nick Kelsey
;  * Fixed fault in IrdaTxData and UartTxData where the stop bit was one
;    interrupt cycle too long.
;  Updated 6 December 1999 - Nick Kelsey
;  * Added RTS/CTS defines for debug UART.
;********************************************************************************
		ENDM


IsrDataSeg	MACRO
;********************************************************************************
;  Interrupt Service Routine
;********************************************************************************

		org	$10	

IsrBank		= 	$10

IsrTime50MHz	=	-108			;50Mhz * 2.17us = 108.5
IsrTime		=	IsrTime50MHz		;Constant = MHz * 2.17us

;**** Isr ****

IsrMReg		ds	1
IsrIntFlags	ds	1

;**** IsrStatus **** (Global varible providing an interface to the Isr)

TimerOverflow	=	IsrStatus.0
IrdaTxStart	=	IsrStatus.1
IrdaTxEmpty	=	IsrStatus.2		;1 = finished sending byte
IrdaRxAvail	=	IsrStatus.3		;1 = received byte available to be read
UartTxStart	=	IsrStatus.4
UartTxEmpty	=	IsrStatus.5
UartRxAvail	=	IsrStatus.6		;1 = received byte available to be read
DebugSend	=	UartTxStart

;**** Irda & Uart Status ****

IrdaUartStatus	ds	1
IrdaRxPulse	=	IrdaUartStatus.0
IrdaRxMode	=	IrdaUartStatus.1	;1 = currently receiving a byte, 0 = idle
IrdaTxMode	=	IrdaUartStatus.2	;1 = currently transmitting a byte, 0 = idle
UartRxMode	=	IrdaUartStatus.3	;1 = currently receiving a byte, 0 = idle
UartTxMode	=	IrdaUartStatus.4	;1 = currently transmitting a byte, 0 = idle

;**** Irda ****

IrdaTxPin	=	rb.7			;Output - Idle Low
IrdaRxPin	=	rb.6			;Input  - Idle High
IrdaRxInt	=	6			;Interrupt = bit 6

Irda9600	=	48			;+0.47%
Irda19200	=	24			;+0.47%
Irda38400	=	12			;+0.47%
Irda57600	=	8			;+0.47%
Irda115200	=	4			;+0.47%

IrdaSpeed	ds	1
IrdaData	ds	1
IrdaRxBits	ds	1
IrdaBitCount	ds	1
IrdaDivide	ds	1

;**** Uart ****

UartTxPin	=	rb.2			;Output - Idle High
UartRxPin	=	rb.0			;Input  - Idle High
UartRtsPin	=	rb.1			;Output
UartCtsPin	=	rb.3			;Input

Uart9600	=	48			;+0.47%
Uart19200	=	24			;+0.47%
Uart38400	=	12			;+0.47%
Uart57600	=	8			;+0.47%
Uart115200	=	4			;+0.47%

UartSpeed	=	Uart115200

UartTxData	=	DebugData		;Global Variable
UartTxBits	ds	1
UartTxBitCount	ds	1
UartTxDivide	ds	1

UartRxData	ds	1
UartRxBits	ds	1
UartRxBitCount	ds	1
UartRxDivide	ds	1

		org	$30

TimerBank	= 	$30			;Shared with Framing layer

Random		ds	1			;Increments every timer interrupt (108 cycles @ 50MHz)
Timer1		ds	1			;Resetable, Increments every timer interrupt (108 cycles @ 50MHz)
Timer2		ds	1			;Resetable, Increments every Timer1 overflow (27648 cycles @ 50MHz)
Timer3		ds	1			;Resetable, Increments every Timer2 overflow (7077888 cycles @ 50MHz)

;********************************************************************************
		ENDM


IsrCodeSeg	MACRO
;********************************************************************************
;  Interrupt Service Routine
;********************************************************************************

GlobalIsr					;Interrupt = Timer
	bank	TimerBank
	inc	Random				;1	Random increment (Note: The main code is synchronous with RTCC and so RTCC is not a random number)
	inc	Timer1				;1	Timer: increment
	snz					;1/2	Timer: overflow ?
	inc	Timer2				;1	Timer: Yes => increment
	snz					;1/2	Timer: overflow ?
	inc	Timer3				;1	Timer: Yes => increment
	snz					;1/2	Timer: overflow ?
	setb	TimerOverflow			;1	Timer: Yes => set flag (Timer = 7 cycles)

	bank	IsrBank				;1
	mov	IsrMReg, m			;2	Backup M register
	mov	m, #WKPND			;1	Set mode to examine port b interrupt flags
	mov	w, #0				;1	Clear W
	mov	!rb, w				;1	Swap contents of W and WKPEN_B (interrupt flags are cleared)
	mov	IsrIntFlags, w			;1	Store cause of interrupt

IrdaIsr						;	Irda -> IrdaRet: Idle = 6 cycles, Tx = 9/19/23 cycles, Rx = 12/21/27 cycles, RxStart = 18 cycles
	snb	IrdaTxMode			;1/2	Irda Tx ?
	jmp	IrdaTxDataIsr			;3	Yes => IrdaTxDataIsr
	snb	IrdaTxStart			;1/2	Irda Tx ?
	jmp	IrdaTxStartIsr			;3	Yes => IrdaTxStartIsr
	snb	IrdaRxMode			;1/2	Irda Rx ?
	jmp	IrdaRxDataIsr			;3	Yes => IrdaRxDataIsr
	snb	IsrIntFlags.IrdaRxInt		;1/2	Falling edge of Rx pin indicating start bit ?
	jmp	IrdaRxStartIsr			;3	Yes => IrdaRxStartIsr
IrdaRet						;	Irda -> IrdaRet: Idle = 6 cycles, Tx = 9/19/23 cycles, Rx = 12/21/27 cycles, RxStart = 18 cycles

UartTxIsr
	snb	UartTxMode			;1/2	Transmitting ?
	jmp	UartTxDataIsr			;3	Yes => UartTxDataIsr
	snb	UartTxStart			;1/2	Start transmit ?
	jmp	UartTxStartIsr			;3	Yes => UartTxStartIsr
UartTxRet

UartRxIsr
	snb	UartRxMode			;1/2	Receiving ?
	jmp	UartRxDataIsr			;3	Yes => UartRxDataIsr
	sb	UartRxPin			;1/2	Start bit ? (start bit = 0)
	jmp	UartRxStartIsr			;3	Yes => UartRxStartIsr
UartRxRet

	mov	m, IsrMReg			;2	Restore M register
	mov	w, #IsrTime			;1	Interrupt in 108 @ 50Mhz cycles
	retiw					;3	Total Isr Time = x cycles


IrdaTxDataIsr					;	Time = 5/13/16/20 cycles
	clrb	IrdaTxPin			;1	return to idle
	decsz	IrdaDivide			;1/2
	jmp	IrdaRet				;3	Isr Time = +5 cycles from IrdaTxIsr
	decsz	IrdaBitCount			;1/2	Sent all bits?
	jmp	:Bit				;3	No => output next bit
:End	snb	IrdaTxStart			;1/2	Yes => complete, Another byte to transmit?
	jmp	IrdaTxStartIsr			;3	Yes => IrdaTxStartIsr
	clrb	IrdaTxMode			;1	Finished
	setb	IrdaTxEmpty			;1	Flag to indicate that the transmission is complete
	clrb	ledTX				;1	Turn off TX LED (indication LED not actual IR emitter)
	jmp	IrdaRet				;3	Isr Time = +19 cycles from IrdaTxIsr
:Bit	sb	IrdaData.0			;1/2	Output next bit
	setb	IrdaTxPin			;1	Output next bit
	stc					;1	Stop bit (idle = 1)
	rr	IrdaData			;1
	mov	IrdaDivide, IrdaSpeed		;2	Apply baud rate
	jmp	IrdaRet				;3	Isr Time = +16 cycles from IrdaTxIsr

IrdaTxStartIsr
	clrb	IrdaTxStart			;1	Clear start mode
	setb	ledTX				;1	Turn on TX LED (indication LED not actual IR emitter)
	setb	IrdaTxPin			;1	Output start pulse (note position of this instruction is such that it matches the setb of the TxDataIsr)
	mov	IrdaDivide, IrdaSpeed		;2	Apply baud rate
	mov	IrdaBitCount, #10		;2	Bit count = 8 data + 1 stop + 1 for stop bit to complete
	setb	IrdaTxMode			;1	Enter Tx mode
	jmp	IrdaRet				;3	Isr Time = +n cycles

IrdaRxDataIsr					;	Time = 4/13/19 cycles
	snb	IsrIntFlags.IrdaRxInt		;1/2	Was a pulse received ?
	setb	IrdaRxPulse			;1	Yes => Flag pulse
	decsz	IrdaDivide			;1/2
	jmp	IrdaRet				;3	Isr Time = +4 cycles from IrdaRxIsr
	clc					;1	Determine bit
	sb	IrdaRxPulse			;1/2	Determine bit
	stc					;1	Determine bit
	rr	IrdaRxBits			;1	Record bit
	clrb	IrdaRxPulse			;1	Reset pulse flag
	mov	IrdaDivide, IrdaSpeed		;2	Apply baud rate
	decsz	IrdaBitCount			;1/2
	jmp	IrdaRet				;3	Isr Time = +13 cycles from IrdaRxIsr
	mov	IrdaData, IrdaRxBits		;2	Copy bits into IrdaData
	clrb	IrdaRxMode			;1	Finished
	setb	IrdaRxAvail			;1
	clrb	ledRX				;1	Turn off RX LED (indication LED not actual IR emitter)
	jmp	IrdaRet				;3	Isr Time = +19 cycles from IrdaRxIsr

IrdaRxStartIsr					;	Time = 10 cycles
	setb	ledRX				;1	Turn on RX LED (indication LED not actual IR emitter)
	clc					;1
	mov	w, >>IrdaSpeed			;1	W = IrdaSpeed / 2
	mov	IrdaDivide, w			;1	IrdaDivide = IrdaSpeed * 0.5
	mov	IrdaBitCount, #9		;2	Bit count = 9 (1/2 start, 8 data, ignore stop)
	setb	IrdaRxMode			;1	Enter rx mode
	jmp	IrdaRet				;3	Isr Time = +10 cycles from IrdaRxStartIsr

UartTxDataIsr					;	Time = 4/11/17 cycles
	decsz	UartTxDivide			;1/2
	jmp	UartTxRet			;3	Isr Time = +n cycles from UartTxIsr
	decsz	UartTxBitCount			;1/2	Sent all bits?
	jmp	:Bit				;3	No  => output next bit
:End	snb	UartTxStart			;1/2	Yes => complete, Another byte to transmit?
	jmp	UartTxStartIsr			;3	Yes => UartTxStartIsr
	clrb	UartTxMode			;1	No => Complete
	setb	UartTxEmpty			;1	Flag to indicate that the transmission is complete
	jmp	UartTxRet			;3	Complete
:Bit	movb	UartTxPin, UartTxBits.0		;4	Output next bit
	stc					;1	Stop bit (idle = 1)
	rr	UartTxBits			;1
	mov	UartTxDivide, #UartSpeed	;2	Apply UartSpeed
	jmp	UartTxRet			;3	Isr Time = +n cycles from UartTxIsr

UartTxStartIsr
	clrb	UartTxPin			;1	Output start bit
	mov	UartTxBits, UartTxData		;2	Load data for transmission
	mov	UartTxDivide, #UartSpeed	;2	Apply UartSpeed
	mov	UartTxBitCount, #10		;2	Bit count = 8 data + 1 stop + 1 for stop bit to complete
	clrb	UartTxStart			;1	Clear start mode
	setb	UartTxMode			;1	Enter Tx mode
	jmp	UartTxRet			;3	Isr Time = +n cycles

UartRxDataIsr
	decsz	UartRxDivide			;1/2
	jmp	UartRxRet			;3	Isr Time = +n cycles
	decsz	UartRxBitCount			;1/2
	jmp	:Read				;3
:Stop	mov	UartRxData, UartRxBits		;2	Copy bits into UartData
	clrb	UartRxMode			;1	Finished
	setb	UartRxAvail			;1
	jmp	UartRxRet			;3	Isr Time = +n cycles
:Read	clc					;1	Determine bit
	snb	UartRxPin			;1/2	Determine bit
	stc					;1	Determine bit
	rr	UartRxBits			;1	Record bit
	mov	UartRxDivide, #UartSpeed	;2	Apply baud rate
	jmp	UartRxRet			;3	Isr Time = +n cycles

UartRxStartIsr
	mov	UartRxDivide, #UartSpeed / 2	;2	UartDivide = UartSpeed * 0.5
	mov	UartRxBitCount, #10		;2	Bit count = 10 (1/2 start, 8 data, 1 stop)
	setb	UartRxMode			;1	Enter rx mode
	jmp	UartRxRet			;3	Isr Time = +n cycles


IsrInit
	clr	IsrStatus
	bank	IsrBank
	clr	IrdaUartStatus
	mov	IrdaSpeed, #Irda9600
	mov	!option, #%10011111		;enable rtcc interrupt
	retp

;********************************************************************************
		ENDM
FrameInfoSeg		MACRO
;********************************************************************************
;  FRAMING LAYER
;********************************************************************************
;
; Receive  : Processes incomming characters and passes payload to payload layer
; Transmit : Frames and applies transparency to payload data
;
;********************************************************************************
;
; Normal Frame Format:  Allowable:  Send:
;   n * FF		n >= 0      n = 10
;   n * BOF		n >= 1      n = 1
;   n * Payload data
;   2 * FCS
;   1 * EOF
;
; FCS - Frame Check Sequence
;   16 bit CCITT CRC sent low byte first
;   Transmit : send the complement of the calculated FCS
;   Receive  : include FCS bytes in calculation of the FCS, FCS will equal $f0b8 if valid
;   Note : FCS covers the payload data only.
;          It is calculated prior to adding any transparency bytes (ie FCS bytes must also be transparent).
;
; Transparency:
;   CE(=$7D)	indicates transparency issue
;   CE EOF	incicates sender has terminated packet
;   CE BOF	indicates sender has restarted payload
;   CE *	anything else: XOR with $20 to recover origional data
;
;********************************************************************************
;
;Asynchronous Events
;
;	a2flRxAvail()					;Signal to indicate that a byte has been received
;	a2flTxEmpty()					;Signal to indicate that the last byte has finished transmitting
;
;Interface
;
;	fl2plRxData(w=Data)				;Data byte from frame
;	fl2plRxValid()					;Payload data is complete and valid
;	fl2plRxError()					;Payload data contains errors
;	pl2flRxIgnore() call				;Return to idle state thus terminating any frame being received
;
;	pl2flTxStart()					;Request from payload layer to send a frame - Does not test for media busy
;	fl2plTxData(ret w=Data ret z=Last) call		;Request data from payload layer - Z flag is set if its the last byte
;	fl2plTxComplete()				;Inform payload layer that the transmission is complete
;
;Notes
; - The Rx code does not time out but is reset by calling RxIgnore, by receiving a new frame, or by transmitting a frame
; - If a frame is transmitted (TxStart) while a frame is being recieved the RxCode will reset to the idle state
;   without indicating an error (RxError).
;
;********************************************************************************
			ENDM


FrameDataSeg		MACRO
;********************************************************************************
;  FRAMING LAYER
;********************************************************************************

		org	$38

flBank		= 	$38			;8 bytes used - Note bank shared with Uart

flState		ds	1			;flBank - current state
flData		ds	1			;flBank - storage for a byte received
flPosition	ds	1			;flBank - Counter used to count the FF codes at start of frame and to keep track of buffer
flBuffer	ds	2			;flBank - 2 byte buffer to delay the passing of payload data to allow the removal of the FCS
flFFCount	ds	1			;flBank - number of FFs to send at the start of each packet
flFCSl		ds	1			;flBank - 16-bit FCS value (low byte)
flFCSh		ds	1			;flBank - 16-bit FCS value (high byte)

flRxState		= %00000000
flTxState		= %10000000

flRxBeginState		= 1 + flRxState		;waiting for start of payload
flRxPayloadState	= 2 + flRxState		;receiving payload data
flRxCtrlState		= 3 + flRxState		;waiting for byte after CE code

flTxBeginState		= 1 + flTxState		;sending initial FF bytes
flTxCtrlState		= 2 + flTxState		;waiting to send an encoded payload data byte
flTxPayloadState	= 3 + flTxState		;waiting to send another payload byte
flTxFCSlState		= 4 + flTxState		;waiting to send FCSl
flTxFCShState		= 5 + flTxState		;waiting to send FCSh
flTxSendEndState	= 6 + flTxState		;waiting to send EOF to close frame
flTxWaitEndState	= 7 + flTxState		;waiting for EOF to finish begin sent

BOF			= $C0	; = %11000000	;Beginning of Frame code (refer IrLAP specification)
EOF			= $C1	; = %11000001	;End of Frame code (refer IrLAP specification)
CE			= $7D	; = %01111101	;Control Escape code (refer IrLAP specification)

ValidFCSh		= $F0
ValidFCSl		= $B8

;********************************************************************************
			ENDM


FrameCodeSeg		MACRO
;********************************************************************************
;  FRAMING LAYER
;********************************************************************************

;********** a2flReset **********

a2flReset
	bank	IsrBank
	mov	IrdaSpeed, #Irda9600		;IrDA UART speed = 9600
	bank	flBank
	clr	flState				;Reset to idle state
	mov	flFFCount, #10			;Default to 10 FFs @ 9600 = 10.42ms
	retp

;********** a2flRxAvail **********

a2flRxAvail					;The IrdaRxAvail flag was set
	bank	IsrBank
	mov	w, IrdaData			;Get received byte
	clrb	IrdaRxAvail			;Clear flag
	bank	flBank
	snb	flState.7			;Current state = receiving or idle ?
	retp					;No => ignore (do not need to inform lap layer of media busy as in transmit mode)
	mov	flData, w			;Store byte that was received
	debug	PhysicalDataRx			;Debug: pass data received
	call	@fl2lapMediaBusy		;Inform lap layer of media busy
	bank	flBank
	mov	w, flState			;Jump based on state
	jmp	PC+w
	jmp	flRxIdle			; 0 = Idle
	jmp	flRxBegin			; 1 = flRxBeginState
	jmp	flRxPayload			; 2 = flRxPayloadState
	jmp	flRxCtrl			; 3 = flRxCtrlState

;********** a2flTxEmpty **********

a2flTxEmpty					;From physical layer: Last byte has finished transmitting
	bank	IsrBank
	clrb	IrdaTxEmpty			;Clear flag
	bank	flBank
	sb	flState.7			;Check that it is a TxState
	retp					;Rx state or idle => return
	mov	w, flState			;Jump based on state
	and	w, #%01111111			;Remove Tx state flag
	jmp	PC+w
	retp					; 0 = Invalid state
	jmp	flTxBegin			; 1 = flTxBeginState
	jmp	flTxCtrl			; 2 = flTxCtrlState
	jmp	flTxPayload			; 3 = flTxPayloadState
	jmp	flTxFCSl			; 4 = flTxFCSlState
	jmp	flTxFCSh			; 5 = flTxFCShState
	jmp	flTxSendEnd			; 6 = flTxSendEndState
	jmp	flTxWaitEnd			; 7 = flTxWaitEndState

;********** pl2flRxIgnore **********

pl2flRxIgnore
	bank	flBank
	clr	flState				;Reset to idle state
	retp

;********************************************************************************
;  FRAMING LAYER - FCS Subroutines
;********************************************************************************

;********** FCS Subroutines **********

flFCSa		=	Temp			;Global - Tempory varable used in the FCS calculation

flFCSInit
	mov	w, #$ff				;Init FCS to $FFFF
	mov	flFCSh, w			;Init FCS to $FFFF
	mov	flFCSl, w			;Init FCS to $FFFF
	retp

flFCSData					;Add data to FCS (w = Data) (must be in flBank)
	xor	flFCSl, w			;FCSl[=X] = FCSl xor w
	mov	w,<>flFCSl			;w = FCSl[32107654]
	and	w,#%11110000			;w = FCSl[3210oooo]
	xor	flFCSl, w			;FCSl = FCSl xor (FCSl shl 4)
						;Calculate A = FCSh
	mov	w, <>flFCSl			;w = FCSl[32107654]
	mov	flFCSa, w			;A = FCSl[32107654]
	mov	w, >>flFCSa			;w = FCSl[x3210765]
	and	w, #%00000111			;w = FCSl[ooooo765]
	xor	w, flFCSl			;w = FCSl xor (FCSl shr 5)
	mov	flFCSa, w			;store w into A = new FCSh value
						;Calculate new FCSl value
	rl	flFCSl				;
	rl	flFCSl				;
	mov	w, <<flFCSl			;w = FCSl[43210xxx]
	and	w, #%11111000			;w = FCSl[43210ooo]
	xor	w, flFCSh			;w = (FCSl shl 3) xor FCSh
	mov	flFCSl, w			;Store w into FCSl
	mov	w, <>flFCSa			;w = A[32107654]
	and	w, #%00001111			;w = A[oooo7654]
	xor	flFCSl, w			;FCSl = (FCSl shl 3) xor FCSh xor (A shr 4)
						;Store new FCSh value
	mov	w, flFCSa			;A holds FCSh value
	mov	flFCSh, w			;Store A in FCSh
	retp

;********************************************************************************
;  FRAMING LAYER - Receive
;********************************************************************************

flRxPassData					;Adds data (flRxData) to FCS and passes data to payload layer
	mov	w, flData			;Last byte that was received
	call	flFCSData			;Add Data to FCS value
	mov	Temp, flBuffer+1		;Shift data out of buffer
	mov	flBuffer+1, flBuffer+0		;Shift data in buffer
	mov	flBuffer+0, flData		;Shift new data into buffer
	incsz	flPosition			;Inc position, Zero ?
	retp					;No  => buffer is not full, return
	dec	flPosition			;Set position to FF to indicate buffer is still full
	mov	w, Temp				;Data to pass
	jmp	@fl2plRxData			;pass data to payload layer (payload layer issues retp instruction)

;********** a2flRxAvail - Idle State **********

flRxIdle					;Waiting for a BOF to indicate start of frame
	csne	flData, #BOF			;Was byte a BOF ?
	inc	flState				;Yes => BOF received indicating start of frame => change to flRxBeginState
	retp

;********** a2flRxAvail - Begin State **********

flRxBegin					;Waiting for non BOF to indicate start of data
	csne	flData, #BOF			;Was byte a BOF ?
	retp					;Yes => ignore
	csne	flData, #EOF			;Was byte a EOF indicating sender has terminated frame ?
	jmp	:Idle				;Yes => return to idle state
	csne	flData, #CE			;Was byte a CE indicating a transparency issue ?
	jmp	:Ctrl				;Yes => change to Ctrl state
	mov	flState, #flRxPayloadState	;Must be data => Payload state
	call	flFCSInit			;Init FCS
	mov	flPosition, #-3			;Init buffer position
	jmp	flRxPassData			;pass data to payload layer (payload layer issues ret instruction)
:Idle	clr	flState				;EOF indicating sender has terminated frame => return to idle state
	retp
:Ctrl	mov	flState, #flRxCtrlState		;CE indicating transparency issue => change to Ctrl state
	retp

;********** a2flRxAvail - Payload State **********

flRxPayload					;Currently receiving payload
	csne	flData, #BOF			;Was byte a BOF indicating sender has terminated the payload and started again ?
	jmp	:Begin				;Yes => terminate payload and goto Begin state
	csne	flData, #EOF			;Was byte an EOF indicating the frame/payload is complete ?
	jmp	:Idle				;Yes => signal complete payload and retpurn to idle state
	csne	flData, #CE			;Was byte a CE indicating a transparency issue ?
	jmp	:Ctrl				;Yes => change to Ctrl state
	jmp	flRxPassData			;pass data to payload layer (payload layer issues retp instruction)
:Begin	mov	flState, #flRxBeginState	;premature BOF => indicate payload reset to payload layer and retpurn to RxBegin State
	jmp	@fl2plRxError			;indicate error to payload layer (payload layer issues retp instruction)
:Idle	clr	flState				;EOF => end of frame reached => inform payload layer and retpurn to idle state
	cse	flFCSh, #ValidFCSh		;valid FCS (high) ?
	jmp	@fl2plRxError			;No => indicate reset to payload layer (payload layer issues retp instruction)
	cse	flFCSl, #ValidFCSl		;valid FCS (low) ?
	jmp	@fl2plRxError			;No => indicate reset to payload layer (payload layer issues retp instruction)
	jmp	@fl2plRxValid			;FCS valid => indicate complete to payload layer (payload layer issues retp instruction)
:Ctrl	mov	flState, #flRxCtrlState
	retp

;********** a2flRxAvail - Ctrl State **********

flRxCtrl					;CE has been encountered, need to check next character
	csne	flData, #BOF			;Was byte BOF indicating sender has terminated payload and started again ?
	jmp	:Begin				;Yes => restart at Begin state (Note payload layer has been passed data => must inform payload layer of reset)
	csne	flData, #EOF			;Was byte EOF indicating sender has terminated frame ?
	jmp	:Idle				;Yes => retpurn to idle (Note: payload layer has been passed any data => must inform payload layer of reset)
	mov	flState, #flRxPayloadState	;Must be data => pass data to payload layer and retpurn to payload state
	xor	flData, #$20			;Recover data
	jmp	flRxPassData			;pass data to payload layer (payload layer issues retp instruction)
:Begin	mov	flState, #flRxBeginState	;BOF => sender has terminated payload and started again => retpurn to begin state
	jmp	@fl2plRxError			;indicate error to payload layer (payload layer issues retp instruction)
:Idle	clr	flState				;EOF => sender has terminated frame => retpurn to idle state
	jmp	@fl2plRxError			;indicate error to payload layer (payload layer issues retp instruction)

;********************************************************************************
;  FRAMING LAYER - Transmit
;********************************************************************************

flTxSendData					;Send byte (w) now (doesn't check for busy)
	bank	IsrBank
	mov	IrdaData, w			;Byte to send
	setb	IrdaTxStart			;Send byte
	debug	PhysicalDataTx			;Debug: pass data being transmitted
	retp					;WARNING - not in flBank

;********** pl2flTxFrame **********

pl2flTxFrame					;Request to start a new frame
	bank	flBank
	mov	flState, #flTxBeginState	;Next state = begin
	mov	flPosition, flFFCount		;Counter = FFCount
	mov	w, #$FF
	jmp	flTxSendData			;Send FF (flTxSendData issues ret instruction)

;********** a2flTxEmpty - Begin State **********

flTxBegin					;Sending prefex FF bytes
	dec	flPosition			;Decrement counter
	snz					;Zero ?
	jmp	:BOF				;Yes => send BOF and set next state to send payload data
	mov	w, #$FF				;No  => Send another FF
	jmp	flTxSendData			;(TxSendData issues ret instruction)
:BOF	mov	flState, #flTxPayloadState	;Will enter flTxPayload state after BOF has been sent
	call	flFCSInit			;Init FCS
	mov	w, #BOF				;Send BOF
	jmp	flTxSendData

;********** a2flTxEmpty - Send States **********

flTxPayload
	call	@fl2plTxData			;Get data from payload layer
	bank	flBank
	snz					;Is this the last byte ? (Z set)
	inc	flState				;Yes => Next State = FCSl
	mov	flData, w			;Store data
	debug	PayloadDataTx			;Debug: pass payload data being transmitted
	call	flFCSData			;w = flData - Add data to FCS
	jmp	flTxSend			;Check for control code and send

flTxFCSl
	mov	w, /flFCSl			;Next data to send = FCSl
	mov	flData, w			;Store in TxData
	inc	flState				;Next State = FCSh
	jmp	flTxSend			;Check for control code and send

flTxFCSh
	mov	w, /flFCSh			;Next data to send = FCSh
	mov	flData, w			;Store in TxData
	inc	flState				;Next State = End
	jmp	flTxSend			;Check for control code and send

flTxSend					;Send payload byte
	csne	flData, #BOF			;Is byte a control code ?
	jmp	:Ctrl				;Yes => transparency issue
	csne	flData, #EOF			;Is byte a control code ?
	jmp	:Ctrl				;Yes => transparency issue
	csne	flData, #CE			;Is byte a control code ?
	jmp	:Ctrl				;Yes => transparency issue
	mov	w, flData			;Yes => transmit data
	jmp	flTxSendData			;Send byte
:Ctrl	mov	flPosition, flState		;Store current state in position variable
	mov	flState, #flTxCtrlState		;Next state = TxCtrlState
	mov	w, #CE
	jmp	flTxSendData			;Send CE code (TxSendData issues ret instruction)

flTxCtrl
	mov	flState, flPosition		;Recover old state from position variable
	mov	w, flData
	xor	w, #$20				;Encode data
	jmp	flTxSendData

;********** a2flTxEmpty - SendEnd State **********

flTxSendEnd					;FCS finished => send EOF to close frame
	inc	flState				;Next state = flTxWaitEnd state
	mov	w, #EOF
	jmp	flTxSendData			;Send EOF (TxSendData issues ret instruction)

;********** a2flTxEmpty - WaitEnd State **********

flTxWaitEnd					;Frame finished and now last byte has finished sending
	clr	flState				;Return to idle state
	jmp	@fl2plTxComplete		;Inform payload layer that the transmission is complete (payload layer issues retp instruction)

;********************************************************************************
		ENDM
PayloadInfoSeg		MACRO
;********************************************************************************
;  PAYLOAD LAYER
;********************************************************************************
;
;Framing Layer Events
;
;	fl2plRxData(w=Data)				;Data byte from frame
;	fl2plRxValid()					;Payload data is complete and valid
;	fl2plRxError()					;Payload data contains errors
;	pl2flRxIgnore() call				;Tell framing layer to ignore the current frame
;
;	pl2flTxStart()					;Request framing layer to start a frame
;	fl2plTxData(var w=Data var z=Last) call		;Request for data from framing layer - Z flag is set if its the last byte
;	fl2plTxComplete()				;Transmission is complete
;
;LAP Layer Events
;
;	pl2lapRxFrame(w=Type)				;Incomming frame of given type
;	pl2lapRxValid()					;Frame was valid
;	pl2lapRxError()					;Frame was invalid
;	pl2lapRxXIDData(w=Data)				;Pass XID data to lap layer
;	pl2lapRxIData(w=Data)				;Pass I data to lap layer
;	pl2lapRxUIData(w=Data)				;Pass I data to lap layer
;	lap2plRxIgnore()				;LAP layer has requested that the frame should be ignored
;
;	lap2plSNRMAccept()				;Accept connection and send reply
;	lap2plTxXIDCmd(w=Slot)				;Send a XID command frame
;	lap2plTxXIDRsp()				;Send a XID response frame
;	lap2plTxSimpleRsp(w=Command)			;Send simple response frame
;	lap2plTxIRsp(w=Command)				;Send an I frame
;	pl2lapTxIData(ret w=Data ret z=Last) call	;Request for data
;	pl2lapTxComplete()				;Complete indication
;
;	lap2plGenerateNewAddr				;Request that a new 32-bit address be generated
;
;********************************************************************************
			ENDM


PayloadDataSeg		MACRO
;********************************************************************************
;  PAYLOAD LAYER
;********************************************************************************

		org	$50

plBank		= 	$50			;16 bytes used - Bank not shared

plState		ds	1			;Current state
plData		ds	1			;Incomming byte of payload data
plFrameType	ds	1			;The frame type for shared code / passed to lap layer
plCommand	ds	1
plPosition	ds	1			;Current position for multibyte states
plConnAddr	ds	1			;Connection address (must be FF if not connected)
plSelfAddr	ds	4			;Own 4 byte address
plDestAddr	ds	4			;Dest 4 byte address
plInfo		ds	2			;Frame specific information

plTxAddressByte	=	plData			;Address to be transmitted
plTxPostCommand	=	plPosition

plIDataDLSAP	=	plInfo+0		;DLSAP byte from/for a I Data frame
plIDataSLSAP	=	plInfo+1		;SLSAP byte from/for a I Data frame
plXIDSlot	=	plInfo+0		;Slot number from/for a XID frame
plXIDFlags	=	plInfo+1		;Discovery Flags from/for a XID frame
plSNRMConnAddr	=	plInfo+0		;Connection Address of SNRM frame
plSNRMBaudRate	=	plInfo+1		;Baudrate parameter from SNRM frame

iFrame		= 1
sRRFrame	= 2
sRNRFrame	= 3
sREJFrame	= 4
sSREJFrame	= 5
uUIFrame	= 6				;UICmd or UIRsp (same command)
uDISCFrame	= 7				;DISCCmd or RDRsp (same command)
uUARspFrame	= 8				;UARsp
uNRMFrame	= 9				;SNRMCmd or RNRMRsp (same command)
uTESTFrame	= 10				;TESTCmd or TESTRsp (same command)
uFRMRRspFrame	= 11				;FRMRRsp
uDMRspFrame	= 12				;DMRsp
uXIDCmdFrame	= 13				;XIDCmd
uXIDRspFrame	= 14				;XIDRsp

sRR		= %00010001			;%xxx10001
sRNR		= %00010101			;%xxx10101
sREJ		= %00011001			;%xxx11001
sSREJ		= %00011101			;%xxx11101

uSNRMCmd	= %10010011
uDISCCmd	= %01010011
uUICmd		= %00010011
uXIDCmd		= %00111111
uTESTCmd	= %11110011
uRNRMRsp	= %10010011
uUARsp		= %01110011
uFRMRRsp	= %10010111
uDMRsp		= %00011111
uRDRsp		= %01010011
uUIRsp		= %00010011
uXIDRsp		= %10111111
uTESTRsp	= %11110011

plRxState	= %00000000
plTxState	= %10000000

plRxCommandState	=  1 + plRxState	;
plRxDataIgnoreState	=  2 + plRxState
plRxIDataState		=  3 + plRxState	;RxI
plRxUIDataState		=  4 + plRxState	;RxUI
plRxXIDFormatState	=  5 + plRxState	;RxXID
plRxXIDSourceState	=  6 + plRxState	;RxXID
plRxXIDDestState	=  7 + plRxState	;RxXID
plRxXIDFlagsState	=  8 + plRxState	;RxXID
plRxXIDSlotState	=  9 + plRxState	;RxXID
plRxXIDVersionState	= 10 + plRxState	;RxXID
plRxXIDInfoState	= 11 + plRxState	;RxXID
plRxSNRMSourceState	= 12 + plRxState	;RxSNRM
plRxSNRMDestState	= 13 + plRxState	;RxSNRM
plRxSNRMAddrState	= 14 + plRxState	;RxSNRM
plRxSNRMParamTypeState	= 15 + plRxState	;RxSNRM
plRxSNRMParamSizeState	= 16 + plRxState	;RxSNRM
plRxSNRMParamDataState	= 17 + plRxState	;RxSNRM

plTxCompleteState	=  1 + plTxState	;Waiting for Complete indication from framing Layer
plTxAddressState	=  2 + plTxState	;
plTxCommandState	=  3 + plTxState	;
plTxIDataDLSAPState	=  4 + plTxState	;
plTxIDataSLSAPState	=  5 + plTxState	;
plTxIDataDataState	=  6 + plTxState	;
plTxUIDataState		=  7 + plTxState	;
plTxXIDFormatState	=  8 + plTxState	;
plTxXIDSourceState	=  9 + plTxState	;
plTxXIDDestState	= 10 + plTxState	;
plTxXIDFlagsState	= 11 + plTxState	;
plTxXIDSlotState	= 12 + plTxState	;
plTxXIDVersionState	= 13 + plTxState	;
plTxXIDFooterState	= 14 + plTxState	;
plTxUASourceState	= 15 + plTxState	;
plTxUADestState		= 16 + plTxState	;
plTxUABaudRateState	= 17 + plTxState	;
plTxUAParamState	= 18 + plTxState	;

;********************************************************************************
			ENDM


PayloadCodeSeg		MACRO
;********************************************************************************
;  PAYLOAD LAYER
;********************************************************************************

;********** a2plReset **********

a2plReset
	bank	plBank
	clr	plState				;Reset to idle state
	mov	plConnAddr,#$FF			;Not connected => address must be $FF
	retp

;********** fl2plRxData **********

fl2plRxData
	bank	plBank
	snb	plState.7			;Check that it is a RxState
	retp					;Tx state => return
	mov	plData, w			;Store incomming byte
	debug	PayloadDataRx			;Debug: Pass payload byte received
	mov	w, plState			;Jump based on state
	jmp	PC+w
	jmp	plRxIdle			; 0 = plIdleState
	jmp	plRxCommand			; 1 = plRxCommandState
	retp					; 2 = plRxDataIgnoreState
	jmp	plRxIData			; 3 = plRxIDataState
	jmp	plRxUIData			; 4 = plRxUIDataState
	jmp	plRxXIDFormat			; 5 = plRxXIDFormatState
	jmp	plRxXIDSource			; 6 = plRxXIDSourceState
	jmp	plRxXIDDest			; 7 = plRxXIDDestState
	jmp	plRxXIDFlags			; 8 = plRxXIDFlagsState
	jmp	plRxXIDSlot			; 9 = plRxXIDSlotState
	jmp	plRxXIDVersion			;10 = plRxXIDVersionState
	jmp	plRxXIDInfo			;11 = plRxXIDInfoState
	jmp	plRxSNRMSource			;12 = plRxSNRMSourceState
	jmp	plRxSNRMDest			;13 = plRxSNRMDestState
	jmp	plRxSNRMAddr			;14 = plRxSNRMAddrState
	jmp	plRxSNRMParamType		;15 = plRxSNRMParamTypeState
	jmp	plRxSNRMParamSize		;16 = plRxSNRMParamSizeState
	jmp	plRxSNRMParamData		;17 = plRxSNRMParamDataState

;********** fl2plTxData **********

fl2plTxData
	bank	plBank
	sb	plState.7			;Check that it is a TxState
	retp					;Rx state => return
	mov	w, plState			;Jump based on state
	and	w, #%01111111			;Remove Tx state flag
	jmp	PC+w
	retp					; 0 = Invalid state
	retp					; 1 = plTxCompleteState (Cannot receive TxData in this state)
	jmp	plTxAddress			; 2 = plTxAddressState
	jmp	plTxCommand			; 3 = plTxCommandState
	jmp	plTxIDataDLSAP			; 4 = plTxIDataDLSAPState
	jmp	plTxIDataSLSAP			; 5 = plTxIDataSLSAPState
	jmp	plTxIDataData			; 6 = plTxIDataDataState
	jmp	plTxUIData			; 7 = plTxUIDataState
	jmp	plTxXIDFormat			; 8 = plTxXIDFormatState
	jmp	plTxXIDSource			; 9 = plTxXIDSourceState
	jmp	plTxXIDDest			;10 = plTxXIDDestState
	jmp	plTxXIDFlags			;11 = plTxXIDFlagsState
	jmp	plTxXIDSlot			;12 = plTxXIDSlotState
	jmp	plTxXIDVersion			;13 = plTxXIDVersionState
	jmp	plTxXIDFooter			;14 = plTxXIDFooterState
	jmp	plTxUASource			;15 = plTxUASourceState
	jmp	plTxUADest			;16 = plTxUADestState
	jmp	plTxUABaudRate			;17 = plTxUABaudRateState
	jmp	plTxUAParam			;18 = plTxUAParamState

;********** fl2plTxComplete **********

fl2plTxComplete
	bank	plBank
	clr	plState					;return to idle state
	debugl	PayloadDataTx, '^'			;Debug: Payload data complete indication
	jmp	@pl2lapTxComplete			;Indicate complete to lap layer (pl2lapTxComplete will issue ret instrustion)

;********** lap2plTxUICmd **********

lap2plTxUICmd	jmp	plTxUICmd

;********************************************************************************
;  PAYLOAD LAYER - Internal Subroutines
;********************************************************************************

plRxDecodeSCmd						;WARNING - does not set pa bits when ret => must be callled form same half page
	mov	Temp, w					;Command: check bits %....nn..
	rr	Temp					;Shift command right 1
	mov	w, >>Temp				;Shift command right 1 and into w
	and	w, #%00000011				;Mask out unwanted bits
	jmp	PC+w					;jump based on w
	retw	sRRFrame				;....00.. = RR
	retw	sRNRFrame				;....01.. = RNR
	retw	sREJFrame				;....10.. = REJ
	retw	sSREJFrame				;....11.. = SREJ

plRxDecodeUNextState				;WARNING - does not set pa bits when ret => must be callled form same half page
	mov	Temp, w				;FrameType
	mov	w, #uUIFrame			;lowest FrameType constant for a U frame
	sub	Temp, w				;subtract lowest valid number so uUIFrame is now 0
	mov	w, Temp
	jmp	PC+w
	retw	plRxUIDataState			;uUIFrame	=	6	;UICmd or UIRsp (same command)
	retw	plRxDataIgnoreState		;uDISCFrame	=	7	;DISCCmd or RDRsp (same command)
	retw	plRxDataIgnoreState		;uUARspFrame	=	8	;UARsp
	retw	plRxSNRMSourceState		;uNRMFrame	=	9	;SNRMCmd or RNRMRsp (same command)
	retw	plRxDataIgnoreState		;uTESTFrame	=	10	;TESTCmd or TESTRsp (same command)
	retw	plRxDataIgnoreState		;uFRMRRspFrame	=	11	;FRMRRsp
	retw	plRxDataIgnoreState		;uDMRspFrame	=	12	;DMRsp
	retw	plRxXIDFormatState		;uXIDCmdFrame	=	13	;XIDCmd
	retw	plRxXIDFormatState		;uXIDRspFrame	=	14	;XIDRsp

lap2plGenerateNewAddr				;Note: code is synchronous with the ISR therfore RTCC and Timer registers are not random numbers
	bank	TimerBank
	mov	w, Random			;Random number
	bank	plBank
	mov	plSelfAddr+0, w			;Byte 0 = Random number
	mov	FSR, w
	mov	w, INDF
	bank	plBank
	mov	plSelfAddr+1, w			;Byte 1 = contents of the register pointer to by the Random number
	mov	m, w				;m = byte 1 number (semi random)
	mov	w, plSelfAddr+0			;w = byte 0 number (fully random)
	iread					;read ROM and address given by w and m
	mov	plSelfAddr+2, w			;Byte 2 = low contents of ROM pointed to by byte1:byte0
	mov	w, m				;w = m = high 4 bits of ROM contents
	mov	plSelfAddr+3, w			;Byte 3 = high contents of ROM pointed to by byte1:byte0
	retp

;********************************************************************************
;  PAYLOAD LAYER - Receive
;********************************************************************************

;********** fl2plRxValid **********

fl2plRxValid
	clrb	ledERR				;Turn ERR led off
	debugl	PayloadDataRx, '^'		;Debug: Indicate complete
	bank	plBank
	clr	plState				;Return to idle state
	jmp	@pl2lapRxValid			;Inform lap layer that frame was valid (lap layer will issue ret instruction)


;********** fl2plRxError **********

fl2plRxError
	setb	ledERR				;Turn ERR led on
	debugl	PayloadDataRx, '!'		;Debug: Indicate error
	bank	plBank
	clr	plState				;Return to idle state
	jmp	@pl2lapRxError			;Inform lap layer that frame was invalid (lap layer will issue ret instruction)

;********** lap2plRxIgnore **********

lap2plRxIgnore					;Ignore the current incomming frame
	bank	plBank
plRxIgnore
	clr	plState				;Return to idle state
	jmp	@pl2flRxIgnore
plRxInvalid
	clr	plState				;Return to idle state
	call	@pl2flRxIgnore
	jmp	@pl2lapRxError			;Inform lap layer of error

;********************************************************************************
;  PAYLOAD LAYER - RxData General
;********************************************************************************

plRxStoreSource
	mov	w, #plDestAddr				;pointer to DestAddress variable
	add	w, plPosition				;add offset
	mov	FSR, w					;Now can indirectly access
	mov	INDF, plData				;Store byte into SourceAddr
	inc	plPosition				;Move offset ready for next byte of SourceAddr
	cse	plPosition, #4				;Have 4 bytes been received ?
	retp						;No  => remain in this state waiting for next byte
	inc	plState					;Yes => end of Source. Change to next state
	clr	plPosition
	retp

plRxTestDest						;WARNING : will pass FF bytes in specific address (ie bytewise checking, not FFFFFFFF checking)
	csne	plData, #$FF				;Broadcast address ?
	jmp	:Cont					;Yes => Contiue
	mov	w, #plSelfAddr				;pointer to SelfAddress variable
	add	w, plPosition				;add offset
	mov	FSR, w					;Now can indirectly access
	cse	plData, INDF				;Self Address ?
	jmp	plRxInvalid				;No  => Ignore frame, Inform lap layer of error, and return to idle
:Cont	inc	plPosition				;Move offset ready for next byte of DestAddr
	cse	plPosition, #4				;Have 4 bytes been received ?
	retp						;No  => remain in this state waiting for next byte
	inc	plState					;Yes => end of DestAddr. Change to next state
	clr	plPosition
	retp

;********************************************************************************
;  PAYLOAD LAYER - RxData
;********************************************************************************

;********** fl2plRxData - Idle State **********

plRxIdle						;First byte = address
	mov	w, plData				;Received Address
	xor	w, plConnAddr				;Compare with interested address
	sz						;Valid address ?
	jmp	plRxIgnore				;No  => ignore
	mov	plState, #plRxCommandState		;Yes => next will receive command byte
	retp

;********** fl2plRxData - RxCommand State **********

plRxCommand
	mov	plCommand, plData			;Store command
	sb	plCommand.4				;Is the P/F bit set ?
	jmp	plRxIgnore				;No => Ignore frame (IrDA lite spec p10 and p16) and return to idle state
	sb	plCommand.0				;Is this an I frame ? (%.......0)
	jmp	plRxICommand				;Yes => process
	sb	plCommand.1				;No  => must be S or U frame. Is this a S frame ?
	jmp	plRxSCommand				;Yes (%......01) => process S frame 
	jmp	plRxUCommand				;No  (%......11) => process U frame

plRxICommand
	debugl	PayloadInfo, 'I'
	mov	plState, #plRxIDataState		;Next should be data
	mov	plFrameType, #iFrame			;store frame type and w will also be passed to lap layer
	jmp	@pl2lapRxFrame				;pass message (lap layer will issue ret instruction)

plRxSCommand
	debugl	PayloadInfo, 'S'
	mov	plState, #plRxDataIgnoreState		;Next should be complete indication (ie no data) but need waiting state
	mov	w, plCommand
	call	plRxDecodeSCmd				;pass w = plRxData, returns w for plFrameType
	mov	plFrameType, w				;store frame type and w will also be passed to lap layer
	jmp	@pl2lapRxFrame				;pass message (lap layer will issue ret instruction)

plRxUCommand
	debugl	PayloadInfo, 'U'
	mov	plPosition, #_plUCommands		;plPosition = 1st byte of data
:Loop	mov	m, #_plUCommands / 256			;m = Pointer to string (high)
	mov	w, plPosition				;w = Pointer to string (low)
	inc	plPosition				;Increment offset for next byte
	iread						;Read data byte from ROM
	xor	w, plCommand				;is the byte the same as the received command ?
	jz	:Found					;Yes => must be valid
	mov	w, m					;No  => try again. Move high part of data to w
	test	w					;Is this the last byte ?
	jz	:Loop					;No  => try again
	jmp	plRxIgnore				;Yes => Invalid command => ignore and return to idle state
:Found	mov	plFrameType, plPosition			;plFrameType = position
	mov	w, #_plUCommands + 1			;w = starting offset
	sub	plFrameType, w				;remove offset => FrameType 0 for a uUIFrame
	mov	w, #uUIFrame				;constant of first type of U command (uUIFrame = 6)
	add	plFrameType, w				;FrameType is now correct
	mov	w, plFrameType				;pass FrameType in w
	call	plRxDecodeUNextState			;Returns w = next state
	mov	plState, w				;Store state
	clr	plPosition				;Clear position for following states
	mov	w, plFrameType				;pass frame type to lap layer
	jmp	@pl2lapRxFrame				;pass message (lap layer will issue ret instruction)

;********************************************************************************
;  PAYLOAD LAYER - Receiving I Frame
;********************************************************************************

;********** fl2plRxData - RxIData State **********

plRxIData
	mov	w, plData				;Data to pass
	debug	IFrameDataRx				;Show debug info
	jmp	@pl2lapRxIData				;Pass data to lmp layer (via lap layer)

;********************************************************************************
;  PAYLOAD LAYER - Receiving UI Frame
;********************************************************************************

;********** fl2plRxData - RxUIData State **********

plRxUIData
	mov	w, plData				;Data to pass
	jmp	@pl2lapRxUIData				;Pass data to app layer (via lap layer)

;********************************************************************************
;  PAYLOAD LAYER - Receiving XID Frame
;********************************************************************************

;********** fl2plRxData - RxXIDFormat State **********

plRxXIDFormat
	cse	plData, #1				;Format must be 1
	jmp	plRxInvalid				;No  => Ignore frame, inform lap layer, and return to idle state
	inc	plState					;Next 4 bytes will be the source address => Enter plRxXIDSourceState
	clr	plPosition				;Byte 0 of the source address
	retp

;********** fl2plRxData - RxXIDSource State **********

plRxXIDSource	=	plRxStoreSource			;Store byte in DestAddr

;********** fl2plRxData - RxXIDDest State **********

plRxXIDDest	=	plRxTestDest			;Compare 4 bytes with SelfAddr (mismatch of not FFFFFFFF will change to ignore state)

;********** fl2plRxData - RxXIDFlags State **********

plRxXIDFlags
	mov	plXIDFlags, plData			;Store the flags for the response
	inc	plState					;Next will receive the slot number (plRxXIDSlotState)
	retp

;********** fl2plRxData - RxXIDSlot State **********

plRxXIDSlot
	mov	plXIDSlot, plData			;Store the slot number
	inc	plState					;plRxXIDVersionState
	retp

;********** fl2plRxData - RxXIDVersion State **********

plRxXIDVersion
	test	plData					;Is version = 0 ?
	jnz	plRxInvalid				;No  => Ignore frame, inform lap layer, and return to idle state
	inc	plState					;Next bytes will be the Descovery Info if any (plRxXIDInfoState)
	clr	plPosition				;Clear position for next state
	retp

;********** fl2plRxData - RxXIDInfo State **********

plRxXIDInfo
	mov	w, plData				;Get data byte
	jmp	@pl2lapRxXIDData			;Pass data to lap layer

;********************************************************************************
;  PAYLOAD LAYER - Receiving SNRM Frame
;********************************************************************************

;********** fl2plRxData - RxSNRMSource State **********

plRxSNRMSource	=	plRxStoreSource

;********** fl2plRxData - RxSNRMDest State **********

plRxSNRMDest	=	plRxTestDest

;********** fl2plRxData - RxSNRMAddr State **********

plRxSNRMAddr
	mov	plSNRMConnAddr, plData			;Store ConnAddr (only apply if frame is validated)
	mov	plSNRMBaudRate, #%00000010		;If no baud rate received then default to 9600 (bit 1 indicates 9600)
	inc	plState					;#plRxSNRMParamTypeState - Next bytes are the negioation parameters
	retp

;********** fl2plRxData - RxSNRMParam State **********

plRxSNRMParamType
	inc	plState					;#plRxSNRMParamSizeState - Next byte will state how many bytes of data
	csne	plData, #$01				;Receiving type $01 = baud rate ?
	setb	plSNRMBaudRate.0			;Yes => Set flag to indicate receiving baud rate (bit 0 is normally used to indicate 2400 which we do not support thus will be removed later)
	retp						;No  => continue

plRxSNRMParamSize
	mov	plPosition, plData			;RxData states how many bytes of data
	inc	plState					;#plRxSNRMParamDataState - Next bytes will be the param data
	retp

plRxSNRMParamData
	decsz	plPosition				;Decrement counter; Zero ?
	jmp	:More					;No  => wait for more
	mov	plState, #plRxSNRMParamTypeState	;Yes => Next byte will be another parameter
:More	sb	plSNRMBaudRate.0			;Is this byte the first byte of the baud rate parameter
	retp						;No => ignore
	mov	w, plData				;Get baud rate parameter
	and	w, #%00111110				;And with our supported baud rates = 9600(bit 1), 19200(bit 2), 38400(bit 3) 57600(bit 4) 115200(bit 5)
	mov	plSNRMBaudRate, w			;Store in SNRMBaudRate (note bit 0 is now clear => will correctly ignore next byte of parameter if it is a 2 byte parameter)
	setb	plSNRMBaudRate.1			;Force 9600 to be valid
	retp

;********************************************************************************
;  PAYLOAD LAYER - Tx
;********************************************************************************

plTxFooter						;w = Addr, m = Addr / 256
	add	w, plPosition				;Add offset
	inc	plPosition				;Increment offset for next byte
	iread
	mov	Temp, w					;Store data
	mov	w, m					;Move high part of data to w
	test	w					;Is this the last byte ?
	jnz	:Last					;Yes => Jump
	mov	w, Temp					;Data byte to be transmitted
	clz						;Indicate more data to follow
	retp						;Return data to framing layer
:Last	mov	plState, #plTxCompleteState		;Last byte => change to complete state
	mov	w, Temp					;Data byte to be transmitted
	stz						;Indicate complete
	retp						;Return data to framing layer

plTxSelfAddr
	mov	w, #plSelfAddr				;pointer to SelfAddress variable
	add	w, plPosition				;add offset
	mov	FSR, w					;Now can indirectly access
	inc	plPosition				;Move offset ready for next byte of SourceAddr
	cse	plPosition, #4				;Sent all 4 bytes ?
	jmp	:Send					;No  => Send current byte (stay in this state)
	inc	plState					;Yes => Send current byte (next state)
	clr	plPosition
:Send	mov	w, INDF					;Byte of Source Address
	clz						;Indicate more data to follow
	retp						;Return data to framing layer

plTxDestAddr
	mov	w, #plDestAddr				;pointer to recorded DestAddress variable
	add	w, plPosition				;add offset
	mov	FSR, w					;Now can indirectly access
	inc	plPosition				;Move offset ready for next byte
	cse	plPosition, #4				;Sent all 4 bytes ?
	jmp	:Send					;No  => Send current byte (stay in this state)
	inc	plState					;Yes => Send current byte (Next will send Discovery flags)
	clr	plPosition
:Send	mov	w, INDF					;Byte of Source Address
	clz						;Indicate more data to follow
	retp						;Return data to framing layer

;********************************************************************************

plTxCmdStart
	mov	plState, #plTxAddressState		;First byte = address
	mov	plTxAddressByte, plConnAddr		;Address = ConnAddr
	setb	plTxAddressByte.0			;Indicate Cmd frame
	jmp	@pl2flTxFrame				;Ask to framing layer to start a new frame

plTxRspStart
	mov	plState, #plTxAddressState		;First byte = address
	mov	plTxAddressByte, plConnAddr		;Address = ConnAddr
	clrb	plTxAddressByte.0			;Indicate Cmd frame
	jmp	@pl2flTxFrame				;Ask to framing layer to start a new frame

;********** fl2plTxData - TxAddress State **********

plTxAddress
	inc	plState					;After address will send command
	mov	w, plTxAddressByte			;Send Address
	clz						;Indicate more data to follow
	retp						;Return Data to framing layer

;********** fl2plTxData - TxCommand State **********

plTxCommand
	mov	plState, plTxPostCommand		;After command will change to state given in TxIState
	clr	plPosition				;Clear position just in case needed for following states
	csne	plState, #plTxCompleteState		;Is this the last byte to be sent ?
	jmp	:Last					;Yes
	mov	w, plCommand				;Send Command
	clz						;Indicate more data to follow
	retp						;Return Data to framing layer
:Last	mov	w, plCommand				;Send Command
	stz						;Indicate complete
	retp						;Return Data to framing layer

;********************************************************************************
;  PAYLOAD LAYER - Send Simple Frame
;********************************************************************************

lap2plTxSimpleCmd					;Transmit a frame of type specified in w
	bank	plBank
	mov	plCommand, w 				;Store command in plCommand
	mov	plTxPostCommand, #plTxCompleteState	;After address & command frame will be complete
	jmp	plTxCmdStart				;Set State and Address, and ask framing layer to start frame

lap2plTxSimpleRsp					;Transmit a frame of type specified in w
	bank	plBank
	mov	plCommand, w 				;Store command in plCommand
	mov	plTxPostCommand, #plTxCompleteState	;After address & command frame will be complete
	jmp	plTxRspStart				;Set State and Address, and ask framing layer to start frame

;********************************************************************************
;  PAYLOAD LAYER - Send I Frame
;********************************************************************************

lap2plTxIRsp
	bank	plBank
	mov	plCommand, w 				;Store command in plCommand
	mov	plTxPostCommand, #plTxIDataDLSAPState	;After address & command will send data
	jmp	plTxRspStart				;Set State and Address, and ask framing layer to start frame

plTxIDataDLSAP
	inc	plState					;Next state = plTxIDataSLSAP
	mov	w, plIDataDLSAP				;Send DLSAP byte
	debug	IFrameDataTx				;Show debug info
	clz						;Indicate more data to follow
	retp

plTxIDataSLSAP
	inc	plState					;Next state = plTxIDataData
	mov	w, plIDataSLSAP				;Send SLSAP byte
	debug	IFrameDataTx				;Show debug info
	clz						;Indicate more data to follow
	retp

plTxIDataData
	call	@pl2lapTxIData				;Get next byte to be transmitted (returns z = false if data)
	debug	IFrameDataTx				;Show debug info
	snz						;Is the z flag set (Last byte) ?
	jmp	:Last					;Yes => jump
	retp						;Z is still clear indicating more data to follow
:Last	mov	Temp, w					;Backup data
	bank	plBank
	mov	plState, #plTxCompleteState		;New state = Wait for complete indication
	mov	w, Temp					;Recover data
	stz						;Indicate no more data to follow
	retp

;********************************************************************************
;  PAYLOAD LAYER - Send UI Frame
;********************************************************************************

plTxUICmd
	bank	plBank
	mov	plCommand, #uUICmd			;Store command in plCommand
	mov	plTxPostCommand, #plTxUIDataState	;After address & command will send data
	jmp	plTxCmdStart				;Set State and Address, and ask framing layer to start frame

plTxUIData
	call	@pl2lapTxUIData				;Get next byte to be transmitted (returns z = false if data)
	snz						;Is the z flag set (Last byte) ?
	jmp	:Last					;Yes => jump
	retp						;Z is still clear indicating more data to follow
:Last	mov	Temp, w
	bank	plBank
	mov	plState, #plTxCompleteState		;New state = Wait for complete indication
	mov	w, Temp					;Recover data
	stz						;Indicate no more data to follow
	retp

;********************************************************************************
;  PAYLOAD LAYER - Send XID Frame
;********************************************************************************

;********** lap2plTxXIDCmd **********

lap2plTxXIDCmd
	bank	plBank
	mov	plXIDSlot, w				;Store slot number
	mov	plCommand, #uXIDCmd			;Command = XID command
	mov	w, #$FF
	mov	plDestAddr+0, w				;Dest address = FFFFFFFF
	mov	plDestAddr+1, w				;Dest address = FFFFFFFF
	mov	plDestAddr+2, w				;Dest address = FFFFFFFF
	mov	plDestAddr+3, w				;Dest address = FFFFFFFF
	mov	plXIDFlags, #2				;Set flags = 2 (=> 8 slots)
	mov	plFrameType, #uXIDCmdFrame		;Rember that this is a XID Command Frame
	mov	plTxPostCommand, #plTxXIDFormatState	;After address & command will send format
	jmp	plTxCmdStart				;Set State and Address, and ask framing layer to start frame

;********** lap2plTxXIDRsp **********

lap2plTxXIDRsp
	bank	plBank
	mov	plCommand, #uXIDRsp			;Command = XID response
	mov	plFrameType, #uXIDRspFrame		;Rember that this is a XID Response Frame
	mov	plTxPostCommand, #plTxXIDFormatState	;After address & command will send format
	jmp	plTxRspStart				;Set State and Address, and ask framing layer to start frame

;********** fl2plTxNext - TxXIDFormat State **********

plTxXIDFormat						;Send XID Format byte
	inc	plState					;Next will send source
	mov	w, #1					;Format = 1
	clz						;Indicate more data to follow
	retp						;Return data to framing layer

;********** fl2plTxNext - TxXIDSource State **********

plTxXIDSource	=	plTxSelfAddr

;********** fl2plTxNext - TxXIDDest State **********

plTxXIDDest	=	plTxDestAddr

;********** fl2plTxNext - TxXIDFlags State **********

plTxXIDFlags
	inc	plState					;After Flags will send slot number (plTxSlotState)
	mov	w, plXIDFlags				;Reply with same flags as received command frame
	clz						;Indicate more data to follow
	retp						;Return data to framing layer

;********** fl2plTxNext - TxXIDSlot State **********

plTxXIDSlot
	csne	plFrameType, #uXIDRspFrame		;Is the frame a XID response frame ?
	jmp	:Footer					;Yes => must send footer
	csne	plXIDSlot, #$FF				;Is the slot number FF ?
	jmp	:Footer					;Yes => must send footer
	mov	plState, #plTxXIDVersionState		;No => Send slot followed by version only
	jmp	:Send
:Footer	mov	plState, #plTxXIDFooterState
	clr	plPosition				;Set to 0 ready for footer
:Send	mov	w, plXIDSlot				;Transmit slot number
	clz						;Indicate more data to follow
	retp						;Return data to framing layer

;********** fl2plTxNext - TxXIDVersion State **********

plTxXIDVersion
	mov	plState, #plTxCompleteState		;After version will indicate complete
	mov	w, #0					;Version = 0
	stz						;Indicate complete
	retp						;Return data to framing layer

;********** fl2plTxNext - TxXIDFooter State **********

plTxXIDFooter
	mov	m, #_plXIDFooter / 256			;Pointer to string (high)
	mov	w, #_plXIDFooter			;Pointer to string
	jmp	plTxFooter

;********************************************************************************
;  PAYLOAD LAYER - Send UA Connection Frame
;********************************************************************************

lap2plSNRMAccept
	bank	plBank
	mov	plCommand, #uUARsp			;Send UA packet to accept connection
	mov	plConnAddr, plSNRMConnAddr		;Apply connection address
	setb	plConnAddr.0				;Only accept command frames
	mov	plTxPostCommand, #plTxUASourceState	;After address & command will send source
	jmp	plTxRspStart				;Set State and Address, and ask framing layer to start frame

plTxUASource	=	plTxSelfAddr

plTxUADest	=	plTxDestAddr

plTxUABaudRate						;Send $01, $01, BaudRate
	inc	plPosition
	csne	plPosition, #3				;Is position 3 indicating to send BaudRate ?
	jmp	:Baud					;Yes => send BaudRate
	mov	w, #$01					;Data to send = $01
	clz						;Indicate more data to follow
	retp						;Return data to framing layer
:Baud	inc	plState					;Next state = plTxUAParamState
	clr	plPosition				;Clear position ready for next state
	mov	w, plSNRMBaudRate			;Data to send = BaudRate
	clz						;Indicate more data to follow
	retp						;Return data to framing layer

plTxUAParam
	mov	m, #_plSNRMParam / 256			;Pointer to string (high)
	mov	w, #_plSNRMParam			;Pointer to string
	jmp	plTxFooter

;********************************************************************************
			ENDM

PayloadString1		MACRO
;********************************************************************************
;  PAYLOAD LAYER - String	;WARNING - Strings must not go over a 256 boundry !!!
;********************************************************************************

_plUCommands							;Must be in the same order as the FrameType constants !!!
_plUCommand6		dw	uUICmd				;UICmd or UIRsp (same command)
_plUCommand7		dw	uDISCCmd			;DISCCmd or RDRsp (same command)
_plUCommand8		dw	uUARsp				;UARsp
_plUCommand9		dw	uSNRMCmd			;SNRMCmd or RNRMRsp (same command)
_plUCommand10		dw	uTESTCmd			;TESTCmd or TESTRsp (same command)
_plUCommand11		dw	uFRMRRsp			;FRMRRsp
_plUCommand12		dw	uDMRsp				;DMRsp
_plUCommand13		dw	uXIDCmd				;XIDCmd
_plUCommand14		dw	uXIDRsp + $F00			;XIDRsp (F00 indicates end of string)

;********************************************************************************
			ENDM

PayloadString2		MACRO
;********************************************************************************
;  PAYLOAD LAYER - String	;WARNING - Strings must not go over a 256 boundry !!!
;********************************************************************************

;_plSNRMParam1		dw	$01, 1, %00000010		;Baud Rate       = 9600 bps	Flexible
_plSNRMParam
_plSNRMParam2		dw	$82, 1, %00000001		;Turnaround      = 500 ms	Solid
_plSNRMParam3		dw	$83, 1, %00000001		;Data Size       = 64 bytes	Flexible ?
_plSNRMParam4		dw	$84, 1, %00000001		;Window Size     = 1		Solid
_plSNRMParam5		dw	$85, 1, %10000000		;Additional BOFs = 0		Solid
_plSNRMParam6		dw	$86, 1, %00000011		;Min turnaround  = 5/10 ms	Solid to IrDA Transeiver spec
_plSNRMParam7		dw	$08, 1, %00000001+$F00		;Disconnect      = 3 s		Solid

;********************************************************************************
			ENDM

PayloadString3		MACRO
;********************************************************************************
;  PAYLOAD LAYER - String	;WARNING - Strings must not go over a 256 boundry !!!
;********************************************************************************

_plXIDFooter
_plXIDVersion		dw	0				;Version = 0 (only possible)
_plXIDHints		dw	$80, $04			;Hints   = IrComm
_plXIDCharset		dw	0				;Charset = ASCII
_plXIDNickname		dw	'SX IrComm Device'+$F00		;Nickname ($F00 indicates end)

;********************************************************************************
			ENDM
LapInfoSeg		MACRO
;********************************************************************************
;  LAP LAYER
;********************************************************************************
;
;Framing Layer Events
;
;	fl2lapMediaBusy()				;A byte has been received => the media is busy
;
;Payload Layer Events
;
;	pl2lapRxFrame(w=Type)				;Incomming frame of given type
;	pl2lapRxValid()					;Frame was valid
;	pl2lapRxError()					;Frame was invalid
;	pl2lapRxXIDData()				;XID data
;	pl2lapRxIData()					;I data
;	pl2lapRxUIData()				;UI data
;	lap2plRxIgnore()				;Tell the framing layer to ignore the frame
;
;	lap2plSNRMAccept()				;Accept connection and send reply
;	lap2plTxXIDCmd(w=Slot)				;Send a XID command frame
;	lap2plTxXIDRsp()				;Send a XID response frame
;	lap2plTxSimpleRsp()				;Send simple response frame
;	lap2plTxIRsp()					;Send an I frame
;	pl2lapTxIData(ret w=Data ret z=Last) call	;Request for data
;	pl2lapTxComplete()				;Complete indication
;
;	lap2plGenerateNewAddr				;Request that a new 32-bit address be generated
;
;LMP Layer Events
;
;	lap2lmpConnectIndication() call
;	lap2lmpDisconnectIndication()
;	lmp2lapDisconnectRequest()
;
;	lap2lmpRxData(w=Data)				;Incomming data bytes
;	lap2lmpRxValid() call				;Data bytes passed since RxFrame message are valid
;	lap2lmpRxError() call				;Data bytes passed since RxFrame message are invalid
;
;	lap2lmpTxFrame(ret z=None) call			;Lap layer can transmit a i-frame and will do so if z is returned false
;	lap2lmpTxData(ret w=Data ret z=Last) call	;Payload layer can accept a data byte (for an I frame) if there is one available. if there is data available then lmp returns data byte and sets z to false
;	lap2lmpTxValid() call				;Lap layer is indicating that all data passed since last TxStart message was acknowledged
;	lap2lmpTxError() call				;Lap layer is indicating that all data passed since last TxStart message will need to be sent again
;
;Application Events
;
;	app2lapDiscoveryRequest(ret z=Busy)		;Application wishes to initiate the XID discovery process
;	app2lapTxUIStart(ret z=Busy)			;Application wishes to send a UI command frame
;
;********************************************************************************
			ENDM


LapDataSeg		MACRO
;********************************************************************************
;  LAP LAYER
;********************************************************************************

		org	$70

lapBank		= 	$70				;8 bytes used

lapState	ds	1				;Current lap state
lapRxFrame	ds	1
lapRxData	ds	1
lapTxXIDSlot	ds	1

lapStatus	ds	1				;Status bits
lapRemoteBusy	=	lapStatus.0			;Remote busy flag
lapXIDDataFlag	=	lapStatus.1			;Indication that host has been informed that XID data will follow
lapRxUIDataFlag	=	lapStatus.2			;Indication that app layer has been informed that UI data will follow
lapTxUIDataFlag	=	lapStatus.3			;Indication that app layer has been informed that UI data will follow
lapLmpRxFlag	=	lapStatus.4			;Indication that lmp layer has sent data that has not been acknowledged
lapLmpTxFlag	=	lapStatus.5			;Indication that lmp layer has sent data that has not been acknowledged
lapMediaIdle	=	lapStatus.6			;Indication that the media has not been used in the past 500ms (NDM state only)

lapRxNs		ds	1				;%.....nnn = expected next I-frame sequence number (Ns)
lapRxNrAck	ds	1				;%.....nnn = expected next I-response sequence number if last frame that was transmitted has been acknowledged
lapRxNrNotAck	ds	1				;%.....nnn = expected next I-response sequence number if last frame that was transmitted has been not-acknowledged

lapNDMState		= 0				;NDM state
lapQUERYState		= 1				;QUERY state
lapNDM2NRMState		= 2				;internal state to wait for TxComplete so new connection parameters can be applied
lapNRMState		= 3				;NRM state
lapSCLOSEState		= 4				;SCLOSE state
lapSCLOSE2NDMState	= 5				;internal state to wait for TxComplete so default connection parameters can be applied

lapMaxFrameSize		= 64				;Max frame size = 64 bytes
lapMinTurnaround	= 116				;Number of additional BOFs to send @ 115200bps (116 = 10ms, 58 = 5ms)

Timer140ms		= -1				;1  =  1*256*256*108*(1/50MHz) =  141.56ms
Timer570ms		= -4				;4  =  4*256*256*108*(1/50MHz) =  566.23ms
Timer1000ms		= -7				;7  =  7*256*256*108*(1/50MHz) =  990.90ms
Timer3000ms		= -21				;21 = 21*256*256*108*(1/50MHz) = 2972.72ms
							;Note - For a different clock frequency the 108 ISR constant changes => these timeout numbers remain the same

;********************************************************************************
			ENDM


LapCodeSeg		MACRO
;********************************************************************************
;  LAP LAYER
;********************************************************************************

;********** a2lapReset **********

a2lapReset
	call	@lap2plGenerateNewAddr			;Generate new device address
	bank	lapBank
	mov	lapState, #lapNDMState			;Enter NDM state
	clr	lapStatus				;Init status
	jmp	lapMediaBusy				;Reset media idle detection (lapMediaBusy will issue retp instruction)

;********** a2lapTimer **********

a2lapTimer
	clrb	TimerOverflow				;Clear Timer flag
	bank	lapBank
	mov	w, lapState				;jump based on state
	jmp	PC+w
	jmp	lapNDMTimer				; 0 = lapNDMState
	jmp	lapQUERYTimer				; 1 = lapQUERYState
	retp						; 2 = lapNDM2NRMState
	jmp	lapNRMTimer				; 3 = lapNRMState
	jmp	lapSCLOSETimer				; 4 = lapSCLOSEState
	retp						; 5 = lapSCLOSE2NDMState

;********** pl2lapRxFrame **********

pl2lapRxFrame
	bank	lapBank
	mov	lapRxFrame, w				;Store frame type
	mov	w, lapState				;Jump based on state
	jmp	PC+w
	jmp	lapNDMRxFrame				; 0 = lapNDMState
	jmp	lapQUERYRxFrame				; 1 = lapQUERYState
	retp						; 2 = lapNDM2NRMState (RxFrame = impossable in this state)
	jmp	lapNRMRxFrame				; 3 = lapNRMState
	jmp	lapSCLOSERxFrame			; 4 = lapSCLOSEState
	retp						; 5 = lapSCLOSE2NDMState (RxFrame = impossable in this state)

;********** pl2lapRxValid **********

pl2lapRxValid
	bank	lapBank
	mov	w, lapState				;Jump based on state
	jmp	PC+w
	jmp	lapNDMRxValid				; 0 = lapNDMState
	jmp	lapQUERYRxValid				; 1 = lapQUERYState
	retp						; 2 = lapNDM2NRMState (RxValid is impossable in this state)
	jmp	lapNRMRxValid				; 3 = lapNRMState
	jmp	lapSCLOSERxValid			; 4 = lapSCLOSEState
	retp						; 5 = lapSCLOSE2NDMState (RxValid is impossable in this state)

;********** pl2lapRxValid - NRM State **********

lapNRMRxValid
	mov	w, lapRxFrame				;Jump based on frame type
	jmp	PC+w
	jmp	lapNRMXCmdValid				;xFrame		=	0
	jmp	lapNRMIValid				;iFrame		=	1
	jmp	lapNRMRRValid				;sRRFrame	=	2
	jmp	lapNRMRNRValid				;sRNRFrame	=	3
	jmp	lapNRMREJValid				;sREJFrame	=	4
	jmp	lapNRMSREJValid				;sSREJFrame	=	5
	jmp	lapNRMXCmdValid				;uUIFrame	=	6	;UICmd or UIRsp (same command)
	jmp	lapNRMDISCValid				;uDISCFrame	=	7	;DISCCmd or RDRsp (same command)
	jmp	lapNRMXCmdValid				;uUARspFrame	=	8	;UARsp
	jmp	lapNRMNRMValid				;uNRMFrame	=	9	;SNRMCmd or RNRMRsp (same command)
	jmp	lapNRMXCmdValid				;uTESTFrame	=	10	;TESTCmd or TESTRsp (same command)
	jmp	lapNRMXCmdValid				;uFRMRRspFrame	=	11	;FRMRRsp
	jmp	lapNRMXCmdValid				;uDMRspFrame	=	12	;DMRsp
	jmp	lapNRMXCmdValid				;uXIDCmdFrame	=	13	;XIDCmd
	jmp	lapNRMXCmdValid				;uXIDRspFrame	=	14	;XIDRsp

;********** pl2lapTxValid **********

pl2lapTxComplete
	bank	lapBank
	mov	w, lapState				;Jump based on state
	jmp	PC+w
	jmp	lapNDMTxComplete			; 0 = lapNDMState        (not interesting in TxComplete)
	retp						; 1 = lapQUERYState      (not interesting in TxComplete)
	jmp	lapNDM2NRMTxComplete			; 2 = lapNDM2NRMState    (now can apply connection parameters)
	retp						; 3 = lapNRMState        (not interesting in TxComplete)
	retp						; 4 = lapSCLOSEState     (not interesting in TxComplete)
	jmp	lapSCLOSE2NDMTxComplete			; 5 = lapSCLOSE2NDMState (now can apply defaultconnection parameters)

;********** fl2lapMediaBusy **********

fl2lapMediaBusy
	bank	lapBank
	cse	lapState, #lapNDMState			;NDM state ?
	retp						;No => ignore
	clrb	lapMediaIdle				;Clear MediaIdle flag
	test	lapRxFrame				;Is a frame being received ?
	sz
	retp						;Yes => do not reset timer
	mov	w, #Timer570ms				;No  => Reset timer to 500ms
	jmp	lapSetTimer				;Apply timer to wait for media idle

;********** DiscoveryRequest **********

app2lapDiscoveryRequest
	bank	lapBank
	cse	lapState, #lapNDMState			;NDM state ?
	clrb	lapMediaIdle				;No  => same as MediaIdle being false
	stz						;Indicate busy
	sb	lapMediaIdle				;Is the media idle ?
	retp						;No  => return busy indication
	bank	plBank
	mov	plConnAddr, #$FE			;Accept broadcast replys only
	bank	lapBank
	clr	lapTxXIDSlot				;Start at slot # 0
	mov	lapState, #lapQUERYState		;Enter QUERY state
	call	:Send					;Send first frame
	clz						;Indicate request was accepted
	retp
:Send	jmp	lapQUERYTimer

;********** DiscoveryRequest **********

app2lapTxUIStart
	bank	lapBank
	cse	lapState, #lapNDMState			;NDM state ?
	clrb	lapMediaIdle				;No  => same as MediaIdle being false
	stz						;Indicate busy
	sb	lapMediaIdle				;Is the media idle ?
	retp						;No  => return busy indication
	clrb	lapMediaIdle				;Remember that another frame cannot be sent
	setb	lapRxUIDataFlag				;Flag to pass messages to app layer
	call	@lap2plTxUICmd				;Request that the payload layer send a UI command frame
	clz						;Indicate request was accepted
	retp

;********************************************************************************
;  LAP LAYER - Internal Subroutines
;********************************************************************************

lapRandomFlags	=	Temp+0
lapRandomMask	=	Temp+1

;Slot bits: %00 =>  1 slot  => Mask = %0000 = 0 -> 0
;           %01 =>  6 slots => Mask = %0011 = 0 -> 3 (ie can't result in 4 or 5)
;           %10 =>  8 slots => Mask = %0111 = 0 -> 7
;           %11 => 16 slots => Mask = %1111 = 0 -> 15

lapRandomSlot						;returns Slot number to transmit in
	bank	plBank					;Peek at frame info
	mov	w, plXIDFlags				;get discovery flags
	bank	lapBank
	and	w, #%00000011				;Mask out non Slot bits
	snz						;Slot bits = 0 ?
	retp						;Yes => return 0
	mov	lapRandomFlags, w			;Store into Flags register
	mov	w, #%00000001				;If bit 1 = 0 then w = 0001
	snb	lapRandomFlags.1
	mov	w, #%00000111				;If bit 1 = 1 then w = 0111
	mov	lapRandomMask, w			;Mask = 0001 or 0111
	stc
	snb	lapRandomFlags.0			;If bit 0 = 1 then rotate left with carry set
	rl	lapRandomMask				;Rotate mask with carry set
	bank	TimerBank
	mov	w, Random				;random number (non resetable, increments every timer interrupt)
	bank	lapBank					;Note: The code is synchronous with RTCC and so RTCC is not a random number
	and	w, lapRandomMask			;Mask out unwanted bits
	mov	lapTxXIDSlot, w				;Store slot number
	retp

;********** SetTimer **********

lapSetTimer						;w = negative number to count up from
	bank	TimerBank				;-1 = 141.56ms
	clr	Timer1
	clr	Timer2
	mov	Timer3, w
	clrb	TimerOverflow
	bank	lapBank
	retp

;********** fl2lapMediaBusy **********

lapMediaBusy
	clr	lapRxFrame				;Reset frame type to none
	mov	w, #Timer570ms				;No  => Reset timer to 500ms
	jmp	lapSetTimer				;Apply timer to wait for media idle

;********************************************************************************
;  LAP LAYER
;********************************************************************************

;********** pl2lapRxError **********

pl2lapRxError
	bank	lapBank
	call	lapMediaBusy				;Reset media idle detection
	snb	laplmpRxFlag				;Has the lmp layer been receiving data ?
	jmp	:LMP					;Yes => must inform lmp layer
	snb	lapXIDDataFlag				;Has the host been informed to expect XID data ?
	jmp	:XID					;Yes => inform of error
	sb	lapRxUIDataFlag				;Is the app layer expecting data
	retp						;No  => return
:UI	clrb	lapRxUIDataFlag				;Yes => Inform app layer that UI frame is invalid
	jmp	@lap2appRxUIError
:LMP	clrb	laplmpRxFlag				;Clear flag
	jmp	@lap2lmpRxError				;Inform lmp layer of error (lmp layer will issue ret instruction)
:XID	clrb	lapXIDDataFlag				;Clear flag
	debugl	ShowXIDInfo, '}'			;Inform host of error
	retp


;********** pl2lapRxXIDData **********

pl2lapRxXIDData
	bank	lapBank
	sb	lapXIDDataFlag				;Is the host expecting XID Data ?
	retp						;No  => ignore data
	debug	ShowXIDInfo				;Yes => pass data
	retp

;********** pl2lapRxIData **********

pl2lapRxIData
	bank	lapBank
	sb	laplmpRxFlag				;Should we pass data ?
	retp						;No  => ignore data
	jmp	@lap2lmpRxData				;Yes => pass data

;********** pl2lapTxIData **********

pl2lapTxIData
	jmp	@lap2lmpTxData				;Get data from lmp layer

;********** pl2lapRxUIData **********

pl2lapRxUIData
	bank	lapBank
	sb	lapRxUIDataFlag				;Should we pass data ?
	retp						;No  => ignore data
	jmp	@lap2appRxUIData			;Yes => pass data

;********** pl2lapTxUIData **********

pl2lapTxUIData
	jmp	@lap2appTxUIData			;Get data from app layer

;********************************************************************************
;  LAP LAYER - NDM Events
;********************************************************************************

lapEnterNDMState					;Reset connection parameters
	mov	lapState, #lapNDMState			;Enter NDM state
	call	lapMediaBusy				;Reset media idle detection
:Tx	sb	laplmpTxFlag				;Is the lmp data waiting for comformation of data ?
	jmp	:Rx					;No  => contiue without message to lmp layer
	clrb	laplmpTxFlag				;Yes => inform lap layer that data was not-acknowledged and contiue
	call	@lap2lmpTxError
	bank	lapBank
:Rx	sb	lapLmpRxFlag				;Is the lmp layer expecting data ?
	jmp	:Cont					;No  => contiue without message to lmp layer
	clrb	lapLmpRxFlag				;Yes => must inform lmp layer that data is invalid
	call	@lap2lmpRxError
:Cont	bank	plBank
	mov	plConnAddr, #$FF			;Not connected => set ConnAddr to only accept be $FF
	bank	flBank
	mov	flFFCount, #10				;Default to 10 FFs @ 9600 = 10.42ms
	bank	IsrBank
	mov	IrdaSpeed, #Irda9600			;IrDA UART speed = 9600
	clrb	ledCON					;Turn off Connect LED
	debugl	ShowConnect, ']'
	jmp	@lap2lmpDisconnectIndication		;Inform lmp layer of disconnection

;********** NDM - RxFrame **********

lapNDMRxFrame
	csne	lapRxFrame, #uXIDCmdFrame		;XID Command frame ?
	jmp	:Accept					;Yes => Accept frame (may want to code to inform host of incommming XIDCmd frame ?)
	csne	lapRxFrame, #uNRMFrame			;SNRM Command frame ?
	jmp	:Accept					;Yes => Accept frame
	csne	lapRxFrame, #uUIFrame			;UI frame ?
	jmp	:UI					;Yes => Accept frame
	clr	lapRxFrame				;No  => Ignore frame
	jmp	@lap2plRxIgnore				;Request that the payload layer ignores the frame
:UI	setb	lapRxUIDataFlag				;Flag to pass data to app layer
:Accept	mov	w, #Timer570ms				;500ms Timeout
	jmp	lapSetTimer				;(lapSetTimer will issue retp instruction)

;********** NDM - Timer **********

lapNDMTimer
	test	lapRxFrame				;Was a frame being received ?
	jnz	pl2lapRxError				;Yes => treat as error, pl2lapRxError will reset the MediaBusy detection
	setb	lapMediaIdle				;No  => media must be idle
	retp

;********** NDM - RxValid **********

lapNDMRxValid
	csne	lapRxFrame, #uXIDCmdFrame		;XID Command frame ?
	jmp	:XID					;Yes => process
	csne	lapRxFrame, #uNRMFrame			;SNRM Command frame ?
	jmp	:SNRM					;Yes => process
							;No  => must be UI frame
:UI	call	lapMediaBusy				;Reset media idle detection
	sb	lapRxUIDataFlag				;Is the app layer expecting data
	retp						;No =>  ignore
	clrb	lapRxUIDataFlag				;Yes => Inform app layer that UI frame is complete
	jmp	@lap2appRxUIValid

:XID	call	lapMediaBusy				;Reset media idle detection
	bank	plBank					;Peek at frame info
	snb	plXIDFlags.2				;Is the "Generate new device address" flag set ?
	call	@lap2plGenerateNewAddr			;Yes => ask payload layer to generate a new 32-bit address
	bank	plBank					;Peek at frame info
	test	plXIDSlot				;is the slot number = 0 ?
	bank	lapBank
	snz
	call	lapRandomSlot				;Yes => generate random slot (slot returned in lapTxXIDSlot)
	mov	w, lapTxXIDSlot				;Get the slot number to transmit in
	bank	plBank
	mov	w, plXIDSlot-w				;Subtract (ie compare) with current slot number
	sz						;Are they the same ? (ie this slot to transmit in ?)
	retp						;No  => return
	bank	lapBank
	mov	w, lapTxXIDSlot
	clr	lapTxXIDSlot				;Reset slot number to indicate that a reply has been sent
	jmp	@lap2plTxXIDRsp				;Transmit response

:SNRM	mov	lapState, #lapNDM2NRMState		;Next state wil be NDM2NRM state to apply connection parameters after this reply has been sent
	clrb	lapRemoteBusy				;Initilise RemoteBusy flag to false
	clr	lapRxNs					;Initilise RxNs to 0
	clr	lapRxNrAck				;Initilise RxNrAck to zero
	clr	lapRxNrNotAck				;Initilise RxNrNotAck to zero
	mov	w, #Timer1000ms				;1s timeout IrDA Lite p15)
	call	lapSetTimer
	setb	ledCON					;Turn on Connect LED
	debugl	ShowConnect, '['
	call	@lap2lmpConnectIndication		;Inform lmp layer of connection
	jmp	@lap2plSNRMAccept			;Send reply

;********** NDM - TxComplete **********

lapNDMTxComplete
	call	lapMediaBusy				;Reset media idle test
	sb	lapRxUIDataFlag				;Is the app layer expecting data
	retp						;No =>  ignore
	clrb	lapRxUIDataFlag				;Yes => Inform app layer that UI frame is complete
	jmp	@lap2appTxUIComplete

;********************************************************************************
;  LAP LAYER - QUERY Events
;********************************************************************************

;********** QUERY - RxFrame **********

lapQUERYRxFrame
	cse	lapRxFrame, #uXIDRspFrame		;XID Response frame ?
	jmp	@lap2plRxIgnore				;No  => Ignore frame
	setb	lapXIDDataFlag				;Yes => Accept frame. Remember that currently passing data to host
	debugl	ShowXIDInfo, '{'			;Show XID info start
	retp

;********** QUERY - RxValid **********

lapQUERYRxValid
	sb	lapXIDDataFlag				;Is the host expecting data
	retp						;No =>  ignore
	clrb	lapXIDDataFlag				;Yes => Inform host that XID frame is complete
	debugl	ShowXIDInfo, '}'
	retp

;********** QUERY - Timer **********

lapQUERYTimer
	bank	TimerBank				;Set global timer
	clr	Timer1					;80ms timeout after transmission is complete (75-85ms IrDA Lite p21)
	mov	Timer2, #-198				;80ms timeout + 29.2 ms (28 bytes) to transmit = 109.2ms. 198 : 198*256*108*(1/50MHz) = 109.49ms
	mov	Timer3, #-1				;negitive number
	clrb	TimerOverflow
	bank	lapBank
	sb	lapXIDDataFlag				;Has the host been informed to expect XID data ?
	jmp	:Good					;Yes => inform of error
	clrb	lapXIDDataFlag				;Clear flag
	debugl	ShowXIDInfo, '}'			;Inform host of error
:Good	cse	lapTxXIDSlot, #08			;Last slot ?
	jmp	:Send					;No  => send
	mov	lapState, #lapNDMState			;Yes => After send will return to NDM state
	mov	w, #$FF					;w = FF
	mov	lapTxXIDSlot, w				;set slot to $FF to indicate complete
	bank	plBank
	mov	plConnAddr, w				;ConnAddr = FF => Accept broadcast commands only
	bank	lapBank
:Send	mov	w, lapTxXIDSlot				;Get current slot #
	inc	lapTxXIDSlot				;Increment for nexty slot #
	jmp	@lap2plTxXIDCmd				;Send XID command frame (payload layer will return)

;********************************************************************************
;  LAP LAYER - NRM Events
;********************************************************************************

;********** NDM2NRM - TxComplete **********

lapNDM2NRMTxComplete
	mov	lapState, #lapNRMState			;NRM state
	bank	plBank					;Agreed BaudRate is the most significant bit that is set in plSNRMBaudRate
	mov	w, #Irda9600				;Min = 9600
	snb	plSNRMBaudRate.2			;19200 ?
	mov	w, #Irda19200				;Yes => w = 19200
	snb	plSNRMBaudRate.3			;38400 ?
	mov	w, #Irda38400				;Yes => w = 38400
	snb	plSNRMBaudRate.4			;57600 ?
	mov	w, #Irda57600				;Yes => w = 57600
	snb	plSNRMBaudRate.5			;115200 ?
	mov	w, #Irda115200				;Yes => w = 115200
	bank	IsrBank
	mov	IrdaSpeed, w				;Apply baud rate
	bank	plBank					;Set FF Count to ensure 10ms. FFCount = BaudRate / 10 * 0.01s
	mov	w, #lapMinTurnaround / 11.6		;Min = 9600 => 10ms = 10 bytes
	snb	plSNRMBaudRate.2			;19200 ?
	mov	w, #lapMinTurnaround / 5.8		;Yes => 10ms = 20 bytes
	snb	plSNRMBaudRate.3			;38400 ?
	mov	w, #lapMinTurnaround / 2.9		;Yes => 10ms = 39 bytes
	snb	plSNRMBaudRate.4			;57600 ?
	mov	w, #lapMinTurnaround / 2		;Yes => 10ms = 58 bytes
	snb	plSNRMBaudRate.5			;115200 ?
	mov	w, #lapMinTurnaround			;Yes => 10ms = 116 bytes
	bank	flBank
	mov	flFFCount, w				;Apply FFCount
	retp

;********** NRM - SendResponse **********

lapSendNRMResponse
	snb	lapRemoteBusy				;Is the remote busy flag set ?
	jmp	lapSendSResponse			;Yes => send S-Response
	call	@lap2lmpTxFrame				;Returns z = false if data to be sent
	bank	lapBank
	snz						;Is there data to be sent ?
	jmp	lapSendSResponse			;No  => send S-Response
:Data	setb	laplmpTxFlag				;Yes => Rember that lmp layer is passing data
	mov	w, <<lapRxNs				;Send Nr = RxNs. w = RxNs %....nnn.
	and	w, #%00001110				;mask out non Ns bits
	mov	Temp, w					;Store in Temp
	swap	Temp					;Temp = RxNs %nnn.....
	setb	Temp.4					;Set bit 4 = final flag
	mov	w, <<lapRxNrAck				;Send Ns = RxNrAck. w = RxNrAck %....nnn.
	and	w, #%00001110				;mask out non Ns bits
	add	w, Temp					;Add Nr bits
	inc	lapRxNrAck				;add 1 to NrAck - the expect acknowledge
	jmp	@lap2plTxIRsp				;Transmit I frame
	
lapSendSResponse
	mov	w, <<lapRxNs				;Send Nr = RxNs. w = RxNs %....nnn.
	and	w, #%00001110				;mask out non Ns bits
	mov	Temp, w					;Store in Temp
	swap	Temp					;Temp = RxNs %nnn.....
	mov	w, #sRR					;frame will be of type RR
	add	w, Temp					;Set Nr of frame to RxNs = expected next I frame
	jmp	@lap2plTxSimpleRsp			;Send simple response frame

;********** NRM - SendRD **********

lapNRMSendRD
	mov	w, #Timer3000ms
	call	lapSetTimer				;Reset timer for SCLOSE state
	sb	lapLmpRxFlag				;Is the lmp layer expecting data ? (ie error caused by timeout)
	jmp	:Cont					;No  => contiue
	clrb	lapLmpRxFlag				;Yes => must inform lmp layer that data is invalid
	call	@lap2lmpRxError				;
	bank	lapBank
:Cont	mov	lapState, #lapSCLOSEState		;change to SCLOSE state
	mov	w, #uRDRsp				;frame will be of type RD
	jmp	@lap2plTxSimpleRsp			;Send simple response frame

;********** NRM - RxFrame **********

lapNRMRxFrame
	csne	lapRxFrame, #iFrame			;I Data frame ?
	setb	lapLmpRxFlag				;Yes => Flag to pass data to lmp layer
	retp						;Accept all frames

;********** NRM - SValid or IValid **********

lapNRMSIValid
	mov	w, #Timer3000ms
	call	lapSetTimer				;Reset timer on any S-Command
	bank	plBank
	mov	w, >>plCommand				;w = %.nnn.... get the received command byte (shifted)
	mov	Temp, w					;Temp = received Nr bits (%.nnn....)
	swap	Temp					;Temp = received Nr bits (%.....nnn)
	bank	lapBank
	mov	w, lapRxNrAck				;w = expected Nr if Ack
	xor	w, Temp					;compare received Nr with NrAck
	and	w, #%00000111				;only examine lowest bits
	snz						;Does Nr = NrAck (ie is this a valid ack) ?
	jmp	:Ack					;Yes => valid Ack
	mov	w, lapRxNrNotAck			;w = expected Nr if Not-Ack
	xor	w, Temp					;compare received Nr with NrNotAck
	and	w, #%00000111				;only examine lostest bits
	sz						;Does Nr = NrNotAck (ie is this a valid not-ack) ?
	jmp	lapNRMSendRD				;No  => Fatal Error - invalid Nr => must disconnect (Valid/Error message for LMP layer willbe sent prior to the DisconnectIndication)
:NotAck	dec	lapRxNrAck				;return NrAck back to what it was before transmission of the last I-Frame
	sb	laplmpTxFlag				;Is the lmp data waiting for comformation of data ?
	jmp	:Cont					;No  => contiue without message to lmp layer
	clrb	laplmpTxFlag				;Yes => inform lap layer that data was not-acknowledged and contiue
	call	@lap2lmpTxError
	jmp	:Cont
:Ack	mov	lapRxNrNotAck, lapRxNrAck		;Set NrNotAck to match NrAck
	sb	laplmpTxFlag				;Is the lmp data waiting for comformation of data ?
	jmp	:Cont					;No  => contiue without message to lmp layer
	clrb	laplmpTxFlag				;Yes => inform lap layer that data was acknowledged and contiue
	call	@lap2lmpTxValid
:Cont	bank	lapBank
	cse	lapRxFrame, #iFrame			;Is this an i frame ?
	jmp	lapSendNRMResponse			;No  => S frame => Send-NRM-Response
	bank	plBank					;Yes => must test Ns
	mov	w, >>plCommand				;get the received command byte (shifted right 1 bit)
	bank	lapBank
	xor	w, lapRxNs				;Compare with expected Ns
	and	w, #%00000111				;Only test lowest 3 bits
	jnz	:Ignore					;If Ns <> expected then ignore
:Valid	inc	lapRxNs					;increment RxNs
	sb	lapLmpRxFlag				;Is the lmp layer expecting data ?
	jmp	lapSendNRMResponse			;No  => send NRM-response
	clrb	lapLmpRxFlag				;Yes => must inform lmp layer that data is complete
	call	@lap2lmpRxValid				;Indicate data complete and valid
	bank	lapBank
	jmp	lapSendNRMResponse			;send NRM-response
:Ignore	sb	lapLmpRxFlag				;Is the lmp layer expecting data ?
	jmp	lapSendSResponse			;No  => send S-response
	clrb	lapLmpRxFlag				;Yes => must inform lmp layer that data is invalid
	call	@lap2lmpRxError				;
	bank	lapBank
	jmp	lapSendSResponse			;send S-response

lapNRMIValid	=	lapNRMSIValid			;A I frame has been received

lapNRMRRValid						;A RR frame has been received
	clrb	lapRemoteBusy				;Remember that remote is not busy and send reply
	jmp	lapNRMSIValid

lapNRMRNRValid						;A RNR frame has been received
	setb	lapRemoteBusy				;Remember that remote is busy and send reply
	jmp	lapNRMSIValid

lapNRMREJValid	=	lapNRMSIValid		;A REJ frame has been received
lapNRMSREJValid	=	lapNRMSIValid		;A SREJ frame has been received

;********** NRM - SNRMCmdValid **********

lapNRMNRMValid	=	lapNRMSendRD

;********** NRM - XCmdValid **********

lapNRMXCmdValid	=	lapSendSResponse

;********** NRM - DISCCmdValid **********

lapNRMDISCValid						;Disconnect command: ack and apply default parameters.
	mov	lapState, #lapSCLOSE2NDMState		;Next state = transition to apply origional connection parameters once this frame has been sent
	mov	w, #uUARsp				;Send UA frame to acknowledge disconnect
	jmp	@lap2plTxSimpleRsp			;Send simple response frame

;********** NRM - Timer **********

lapNRMTimer	=	lapEnterNDMState		;Timeout => return to NDM state.

;********** lmp2lapDisconnectRequestr **********

lmp2lapDisconnectRequest
	bank	lapBank
	cse	lapState, #lapNRMState			;Currenly in NRM state ?
	retp						;No  => ignore request
	mov	lapState, #lapSCLOSEState		;Yes => change to SCLOSE state
	retp

;********************************************************************************
;  LAP LAYER - NRM Events
;********************************************************************************

;********** SCLOSE - RxFrame **********

lapSCLOSERxFrame
	retp						;Accept all frames

;********** SCLOSE - RxValid **********

lapSCLOSERxValid
	csne	lapRxFrame, #uDISCFrame			;DISC Command frame ?
	jmp	lapNRMDISCValid				;Yes => Send ack, apply default parameters and enter NDM state
	mov	w, #Timer3000ms
	call	lapSetTimer				;No, however still must be a command frame (due to ConnAddr) => send RD frame
	mov	w, #uRDRsp				;Send RD Response frame to request disconnect
	jmp	@lap2plTxSimpleRsp			;Send simple response frame

;********** SCLOSE - Timer **********

lapSCLOSETimer		=	lapEnterNDMState

;********** SCLOSE2NDM - TxComplete **********

lapSCLOSE2NDMTxComplete	=	lapEnterNDMState

;********************************************************************************
		ENDM

LmpInfoSeg		MACRO
;********************************************************************************
;  LMP LAYER
;********************************************************************************
;
;	lap2lmpConnectIndication() call
;	lap2lmpDisconnectIndication()
;
;	lap2lmpRxData(w=Data)				;Incomming data bytes
;	lap2lmpRxValid() call				;Data bytes passed since RxFrame message are valid
;	lap2lmpRxError() call				;Data bytes passed since RxFrame message are invalid
;
;	lap2lmpTxFrame(ret z=None) call
;	lap2lmpTxData(ret w=Data ret z=Last) call	;Payload layer can accept a data byte (for an I frame) if there is one available. if there is data available then lmp returns data byte and sets z to false
;	lap2lmpTxValid() call				;Lap layer is indicating that all data passed since last TxStart message was acknowledged
;	lap2lmpTxError() call				;Lap layer is indicating that all data passed since last TxStart message will need to be sent again
;
;********************************************************************************
			ENDM


LmpDataSeg		MACRO
;********************************************************************************
;  LMP LAYER
;********************************************************************************

		org	$90

lmpBank		= 	$90			;16 bytes

lmpPosition	ds	1			;Position of multi byte stages
lmpData		ds	1			;Temporary Data storage
lmpAppLSAP	ds	1			;LSAP number of remote CommApp (or 0 if not connected)
lmpAppStatus	ds	1

lmpRxState	ds	1			;Current Rx state
lmpRxDLSAP	ds	1			;Received DLSAP
lmpRxSLSAP	ds	1			;Received SLSAP
lmpRxInfo	ds	4

lmpRxLMPCmdOpcode	=	lmpRxInfo + 0	;LMP Command frames : holds opcode
lmpRxIASErrOpcode	=	lmpRxInfo + 0	;IAS frame : holds service request
lmpRxIASErrRetCode	=	lmpRxInfo + 1	;IAS frame : holds return code for service request
lmpRxSendStringL	=	lmpRxInfo + 2	;SendStringH = _lmpTxStringSegment
lmpRxPostTest		=	lmpRxInfo + 3

lmpTxState	ds	1			;Current Tx state
lmpTxDLSAP	ds	1			;Transmit DLSAP = Received SLSAP
lmpTxSLSAP	ds	1			;Transmit SLSAP = Received DLSAP
lmpTxInfo	ds	2

lmpTxIASErrOpcode	=	lmpTxInfo + 0	;IAS frame : holds service request
lmpTxIASErrRetCode	=	lmpTxInfo + 1	;IAS frame : holds return code for service request
lmpTxStringH		=	lmpTxInfo + 0
lmpTxStringL		=	lmpTxInfo + 1

lmpConnectCmdOpcode		= $01
lmpConnectRspOpcode		= $81
lmpDisconnectOpcode		= $02
lmpAccessCmdOpcode		= $03
lmpAccessRspOpcode		= $83

lmpLSAPServer			= 0
lmpLSAPComm			= 5			;Random number between 1 and 6F

lmpAppRxFlag			= lmpAppStatus.0	;Indicates that app layer has been passed unacknoldged data
lmpAppTxFlag			= lmpAppStatus.1	;Indicates that app layer is passing data or has passed data that has not yet been acknoldged

lmpRxDataMode			= %00000000		;More data is required
lmpRxVerifyMode			= %10000000		;Waiting for frame to complete

lmpRxSLSAPState			= 1 + lmpRxDataMode	;Second byte = Source LSAP
lmpRxLMPCmdOpcodeState		= 2 + lmpRxDataMode	;LMP Command : Opcode
lmpRxIASCmdState		= 3 + lmpRxDataMode	;IAS Data :
lmpRxIASClassLengthState	= 4 + lmpRxDataMode	;IAS Data :
lmpRxIASClassTestState		= 5 + lmpRxDataMode	;IAS Data :
lmpRxIASDeviceAttribState	= 6 + lmpRxDataMode	;IAS Data :
lmpRxIASCommAttribState		= 7 + lmpRxDataMode	;IAS Data :
lmpRxIASAttribTestState		= 8 + lmpRxDataMode	;IAS Data :
lmpRxCommDataState		= 9 + lmpRxDataMode	;Comm Data

lmpRxBadLSAPState		= 1 + lmpRxVerifyMode	;Error state : Invalid Dest LSAP
lmpRxLMPCmdVerifyState		= 2 + lmpRxVerifyMode	;LMP Command : Verify
lmpRxIASAttribVerifyState	= 3 + lmpRxVerifyMode	;IAS Data :
lmpRxIASErrorState		= 4 + lmpRxVerifyMode	;IAS Data :

lmpTxStringState		= 1			;Send a string
lmpTxIASErrorState		= 2			;Reply stating that the IAS service is an un-supported option or error
lmpTxCommDataState		= 3			;Sending Comm Data

;********************************************************************************
			ENDM


LmpCodeSeg		MACRO
;********************************************************************************
;  LMP LAYER
;********************************************************************************

;********** a2lmpReset **********

a2lmpReset
	bank	lmpBank
	clr	lmpRxState
	clr	lmpTxState
	clr	lmpAppLSAP
	retp

;********** lap2lmpConnectIndication **********

lap2lmpConnectIndication	=	a2lmpReset

;********** lap2lmpDisconnectIndication **********

lap2lmpDisconnectIndication	=	a2lmpReset

;********** lap2lmpRxData **********

lap2lmpRxData
	bank	lmpBank
	mov	lmpData, w				;Store data
	snb	lmpRxState.7				;Interested in data ? (lmpRxDataMode)
	retp
	mov	w, lmpRxState				;Jump based on state
	jmp	PC+w
	jmp	lmpRxDLSAPByte				;  0 = lmpIdleState
	jmp	lmpRxSLSAPByte				;  1 = lmpRxSLSAPState
	jmp	lmpRxCmdOpcodeByte			;  2 = lmpRxLMPCmdOpcodeState
	jmp	lmpRxIASCmd				;  3 = lmpRxIASCmdState
	jmp	lmpRxIASClassLength			;  4 = lmpRxIASClassLengthState
	jmp	lmpRxIASStringTest			;  5 = lmpRxIASClassTestState
	jmp	lmpRxIASDeviceAttrib			;  6 = lmpRxIASDeviceAttribState
	jmp	lmpRxIASCommAttrib			;  7 = lmpRxIASCommAttribState
	jmp	lmpRxIASStringTest			;  8 = lmpRxIASAttribTestState
	jmp	lmpRxCommData				;  9 = lmpRxCommDataState

;********** lap2lmpRxValid **********

lap2lmpRxValid
	debugl	IFrameDataRx, '^'
	bank	lmpBank
	snb	lmpAppRxFlag				;CommData ?
	jmp	lmpRxValidCommData			;Yes => process
	sb	lmpRxState.7				;Interested in valid ? (lmpRxVerifyMode)
	retp
	mov	w, lmpRxState				;Jump based on state
	and	w, #%01111111				;Remove Mode bit
	clr	lmpRxState				;Clear RxState back to idle
	jmp	PC+w
	retp						;  0 = lmpIdleState (invalid)
	jmp	lmpRxBadLSAP				;  1 = lmpRxBadLSAPState
	jmp	lmpRxValidLMPCommand			;  2 = lmpRxLMPCmdVerifyState
	jmp	lmpRxValidIASAttribVerify		;  3 = lmpRxIASAttribVerifyState
	jmp	lmpRxValidIASError			;  4 = lmpRxIASErrorState

;********** lap2lmpRxInvalid **********

lap2lmpRxError
	debugl	IFrameDataRx, '!'
	setb	ledERR					;Turn ERR led on
	bank	lmpBank
	clr	lmpRxState				;Return to idle state
	sb	lmpAppRxFlag				;CommDataMode ?
	retp						;No  => return
	clrb	lmpAppRxFlag				;Clear flag
	jmp	@lmp2appRxCommError			;Yes => Inform app layer of valid (app layer will issue ret instruction)

;********** lap2lmpTxData **********

lap2lmpTxFrame
	bank	lmpBank
	clr	lmpPosition
	test	lmpTxState				;Idle state ?
	jnz	:Send
:Idle	test	lmpAppLSAP				;LMP Connection open to comm layer ?
	snz						;Zero indicates no connection
	retp						;No  => indicate no data and return
	call	@lmp2appTxCommStart			;Yes => find out if data to send
	snz						;Data to send
	retp						;No  => indicate no data and return
	bank	lmpBank
	mov	lmpTxState, #lmpTxCommDataState		;Prepare to transmit frame
	mov	lmpTxDLSAP, lmpAppLSAP			;Ensure correct DLSAP
	mov	lmpTxSLSAP, #lmpLSAPComm		;Ensure correct SLSAP
	mov	lmpPosition, #lapMaxFrameSize-2		;Protect frame size (LAP frame size less DLSAP and SLSAP bytes)
:Send	mov	w, lmpTxDLSAP				;Desired DLSAP
	bank	plBank
	mov	plIDataDLSAP, w				;Store for transmission
	bank	lmpBank
	mov	w, lmpTxSLSAP				;Desired SLSAP
	bank	plBank
	mov	plIDataSLSAP, w				;Store for transmission
	clz						;Indicate more data to follow
	retp

;********** lap2lmpTxData **********

lap2lmpTxData						;Lap layer can accept a data byte (for an I frame) if there is one available. if there is data available then lmp returns data byte and sets z to false
	bank	lmpBank
	mov	w, lmpTxState				;Jump based on state
	jmp	PC+w					;Jump based on state
	retp						;  0 = Idle state (cannot receive TxData in idle state)
	jmp	lmpTxString				;  1 = lmpTxStringState
	jmp	lmpTxIASError				;  2 = lmpTxIASErrorState
	jmp	lmpTxCommData				;  3 = lmpTxCommDataState

;********** lap2lmpTxValid **********

lap2lmpTxValid						;Lap layer is indicating that all data passed since last TxStart message was acknowledged
	debugl	IFrameDataTx, '^'
	bank	lmpBank
	clr	lmpTxState				;Return to idle state
	sb	lmpAppTxFlag				;Transmitting app data ?
	retp						;No  => return
	clrb	lmpAppTxFlag
	jmp	@lmp2appTxCommValid			;Yes => Inform app layer of valid (app layer will issue ret instruction)

;********** lap2lmpTxError **********

lap2lmpTxError						;Lap layer is indicating that all data passed since last TxStart message will need to be sent again
	debugl	IFrameDataTx, '!'
	setb	ledERR					;Turn ERR led on
	bank	lmpBank
	sb	lmpAppTxFlag				;Transmitting app data ?
	retp						;No  => return (stay in this state for retransmission)
	clrb	lmpAppTxFlag
	jmp	@lmp2appTxCommError			;Yes => Inform app layer of error (app layer will issue ret instruction)

;********************************************************************************
;  LMP LAYER - Rx
;********************************************************************************

lmpRx2TxSetup
	mov	lmpTxDLSAP, lmpRxSLSAP			;DLSAP = received SLSAP
	mov	lmpTxSLSAP, lmpRxDLSAP			;SLSAP = received DLSAP
	retp

;********************************************************************************

;********** lap2lmpRxData - RxDLSAPState **********

lmpRxDLSAPByte
	mov	lmpRxDLSAP, lmpData			;Store data
	inc	lmpRxState				;Next state = lmpRxSLSAPState
	retp

;********** lap2lmpRxData - RxSLSAPState **********

lmpRxSLSAPByte
	mov	lmpRxSLSAP, lmpData			;Store data
	clrb	lmpRxSLSAP.7				;Ensure MSB is clear
	snb	lmpRxDLSAP.7				;Is this a LMP-Command frame (DLSAP bit 7 set) ?
	jmp	:Cmd					;Yes => process command
	csne	lmpRxDLSAP, #lmpLSAPComm		;DLSAP addressing Comm ?
	jmp	:Comm					;Yes => accept
	mov	w, lmpRxBadLSAPState			;If not server then Bad LSAP
	test	lmpRxDLSAP				;0 = IAS Server
	snz						;Addressing IAS Server ?
	mov	w, #lmpRxIASCmdState			;Yes => IAS Server state
	mov	lmpRxState, w				;Apply state
	retp
:Cmd	mov	lmpRxState, #lmpRxLMPCmdOpcodeState	;No => change to RxCmdOpcodeState
	clrb	lmpRxDLSAP.7				;Ensure MSB is clear
	retp
:Comm	mov	w, #lmpRxCommDataState			;Comm data
	test	lmpAppLSAP				;Connected ?
	snz
	mov	w, lmpRxBadLSAPState			;No => error
	mov	lmpRxState, w				;Apply state
	retp

;********** lap2lmpRxData - RxCmdOpcodeState **********

lmpRxCmdOpcodeByte
	mov	lmpRxLMPCmdOpcode, lmpData		;Store data in opcode variable
	mov	lmpRxState, #lmpRxLMPCmdVerifyState	;Wait for Valid message
	retp

;********** lap2lmpRxData - RxIASCmdState **********

lmpRxIASCmd
	mov	w, lmpData				;IAS Service request
	and	w, #%10111111				;Mask out ack bit
	mov	lmpRxIASErrOpcode, w			;Store Service Request in case of error
	xor	w, #$84					;Is the service request GetValueByClass ?
	jnz	:Err					;No => must reply with service unsupported
	inc	lmpRxState				;Yes => wait for class name length
	retp
:Err	mov	lmpRxState, #lmpRxIASErrorState		;Will reply with Unsupported
	mov	lmpRxIASErrRetCode, #$FF		;Reply = $FF = unsupported service
	retp

;********** lap2lmpRxData - RxIASClassLengthState **********

lmpRxIASClassLength					;Data = lnegth of class name
	inc	lmpRxState				;Next state = lmpRxIASClassTestState
	mov	lmpRxIASErrRetCode, #$01		;If error then Reply = $01 = no such class
	csne	lmpData, #$06				;Is the class name length 6 indicating that we should test for "Device" ?
	jmp	:Dev					;Yes => test for "Device"
	csne	lmpData, #$0B				;Is the class name length 11 indicating that we should test for "IrDA:IrCOMM" ?
	jmp	:Comm					;Yes => test for "IrDA:IrCOMM"
	mov	lmpRxState, #lmpRxIASErrorState		;No => Will reply with IAS error
	retp
:Dev	mov	lmpRxPostTest, #lmpRxIASDeviceAttribState	;If class is correct then will cahnge to DeviceAttrib state
	mov	lmpPosition, #_lmpIASDeviceClass		;Pointer to string
	retp
:Comm	mov	lmpRxPostTest, #lmpRxIASCommAttribState		;If class is correct then will cahnge to CommAttrib state
	mov	lmpPosition, #_lmpIASCommClass			;Pointer to string
	retp

;********** lap2lmpRxData - RxIASDeviceAttribState **********

lmpRxIASDeviceAttrib
	mov	lmpRxState, #lmpRxIASAttribTestState		;Next will verify attrib string
	mov	lmpRxPostTest, #lmpRxIASAttribVerifyState	;If attrib is correct then will cahnge to AttribVerify state
	mov	lmpRxIASErrRetCode, #$02			;If error then Reply = $02 = no such attribute
	csne	lmpData, #$0A					;Is the class name length 10 indicating that we should test for "DeviceName" ?
	jmp	:Name						;Yes => test for "Device"
	csne	lmpData, #12					;Is the class name length 12 indicating that we should test for "IrLMPSupport" ?
	jmp	:Supp						;Yes => test for "IrLMPSupport"
	mov	lmpRxState, #lmpRxIASErrorState			;No => Will reply with IAS error
	retp
:Name	mov	lmpRxSendStringL, #_lmpIASDeviceName		;Pointer to string to send in reply if attrib verifies
	mov	lmpPosition, #_lmpIASDeviceAttribName		;Pointer to string to test
	retp
:Supp	mov	lmpRxSendStringL, #_lmpIASDeviceSupport		;Pointer to string to send in reply if attrib verifies
	mov	lmpPosition, #_lmpIASDeviceAttribSupport	;Pointer to string to test
	retp
	
;********** lap2lmpRxData - RxIASCommAttribState **********

lmpRxIASCommAttrib
	mov	lmpRxState, #lmpRxIASAttribTestState		;Next will verify attrib string
	mov	lmpRxPostTest, #lmpRxIASAttribVerifyState	;If attrib is correct then will cahnge to AttribVerify state
	mov	lmpRxIASErrRetCode, #$02			;If error then Reply = $02 = no such attribute
	csne	lmpData, #$0A					;Is the class name length 10 indicating that we should test for "Parameters" ?
	jmp	:Param						;Yes => test for "Parameters"
	csne	lmpData, #$12					;Is the class name length 18 indicating that we should test for "IrDA:IrLMP:LsapSel" ?
	jmp	:Lsap						;Yes => test for "IrDA:IrLMP:LsapSel"
	mov	lmpRxState, #lmpRxIASErrorState			;No => Will reply with IAS error
	retp
:Param	mov	lmpRxSendStringL, #_lmpIASCommParam		;Pointer to string to send in reply if attrib verifies
	mov	lmpPosition, #_lmpIASCommAttribParam		;Pointer to string to test
	retp
:Lsap	mov	lmpRxSendStringL, #_lmpIASCommLsapSel		;Pointer to string to send in reply if attrib verifies
	mov	lmpPosition, #_lmpIASCommAttribLsapSel		;Pointer to string to test
	retp

;********** lap2lmpRxData - RxIASStringTestState **********

lmpRxIASStringTest
	mov	m, #_lmpRxStringSegment / 256		;String Segment (high)
	mov	w, lmpPosition				;Pointer to string (low)
	inc	lmpPosition				;Increment offset for next byte
	iread						;Get data byte (in w)
	xor	w, lmpData				;Is the received data byte correct ?
	jnz	:Err					;No  => error
	mov	w, m					;Yes => continue. Move high part of data to w
	test	w					;Is this the last byte ? (m is not 0)
	snz
	retp						;No  => stay in this state
	mov	lmpRxState, lmpRxPostTest		;Yes => Change to next state
	retp
:Err	mov	lmpRxState, #lmpRxIASErrorState		;Will reply with Error code
	retp

;********** lap2lmpRxData - RxCommDataState **********

lmpRxCommData
	setb	lmpAppRxFlag				;remember passing data
	mov	w, lmpData				;Data to pass
	jmp	@lmp2appRxCommData			;Pass data to app layer

;********************************************************************************

;********** lap2lmpRxValid - RxBadLSAPState **********

lmpRxBadLSAP						;Should disconnect connection !!!
	jmp	@lmp2lapDisconnectRequest

;********** lap2lmpRxValid - RxLMPCmdVerifyState **********

lmpRxValidLMPCommand
	csne	lmpRxLMPCmdOpcode, #lmpConnectCmdOpcode	;Is this a request to open a connection ?
	jmp	:Conn					;Yes => accept
	csne	lmpRxLMPCmdOpcode, #lmpDisconnectOpcode	;Is this a request to clsoe a connection ?
	jmp	:Disc					;Yes => close
	retp						;No  => Unknown or unsupported command => ignore
:Conn	mov	lmpTxStringH, #_lmpLMPConnRsp / 256	;Pointer to string
	mov	lmpTxStringL, #_lmpLMPConnRsp		;Pointer to string
	mov	lmpTxState, #lmpTxStringState		;Prepare to transmit parameters
	setb	lmpRxSLSAP.7				;Indicate command (this will be the DLSAP byte when transmitted)
	cse	lmpRxDLSAP, #lmpLSAPComm		;DLSAP addressing Comm ?
	jmp	lmpRx2TxSetup				;No  => nothing more to do other than to prepare to send reply
	mov	lmpAppLSAP, lmpRxSLSAP			;Yes => Store Source LSAP in AppLSAP (ie remember the remote Comm App LSAP)
	clrb	lmpAppLSAP.7				;Set to information frame
	jmp	lmpRx2TxSetup				;prepare to send reply
:Disc	csne	lmpRxDLSAP, #lmpLSAPComm		;DLSAP addressing Comm ?
	clr	lmpAppLSAP				;Yes => clear connection
	retp

;********** lap2lmpRxValid - RxIASAttribVerifyState **********

lmpRxValidIASAttribVerify
	mov	lmpTxStringH, #_lmpTxStringSegment / 256	;Pointer to string
	mov	lmpTxStringL, lmpRxSendStringL			;Pointer to string
	mov	lmpTxState, #lmpTxStringState			;Prepare to transmit parameters
	jmp	lmpRx2TxSetup					;Prepare to transmit frame

;********** lap2lmpRxValid - RxIASErrorState **********

lmpRxValidIASError
	mov	lmpTxState, #lmpTxIASErrorState			;Prepare to transmit error return code
	mov	lmpTxIASErrOpcode, lmpRxIASErrOpcode
	mov	lmpTxIASErrRetCode, lmpRxIASErrRetCode
	jmp	lmpRx2TxSetup					;Prepare to transmit frame

;********** lap2lmpRxValid - RxCommDataState **********

lmpRxValidCommData
	clr	lmpRxState					;Clear RxState back to idle
	clrb	lmpAppRxFlag
	jmp	@lmp2appRxCommValid

;********************************************************************************
;  LMP LAYER - Tx
;********************************************************************************

;********** lap2lmpTxData - TxStringState **********

lmpTxString
	mov	m, lmpTxStringH				;Pointer to string (high)
	mov	w, lmpTxStringL				;Pointer to string (low)
	add	w, lmpPosition				;Add offset
	inc	lmpPosition				;Increment offset for next byte
	iread
	mov	Temp, w					;Store data
	mov	w, m					;Move high part of data to w
	test	w					;Is this the last byte ?
	jnz	:Last					;Yes
	mov	w, Temp					;Data to pass
	clz						;Indicate more data to follow Data
	retp						;Return data to framing layer
:Last	mov	w, Temp					;Data to pass
	stz						;Indicate last byte
	retp						;Return data to framing layer

;********** lap2lmpTxData - TxIASErrorState **********

lmpTxIASError
	test	lmpPosition
	jnz	:ErrCod
:Opcode	mov	w, lmpTxIASErrOpcode			;Opcode that was received
	inc	lmpPosition				;Next will send RetCode
	clz						;Indicate more data to follow
	retp
:ErrCod	mov	w, lmpTxIASErrRetCode			;RetCode
	stz						;Indicate last byte
	retp

;********** lap2lmpTxData - TxCommDataState **********

lmpTxCommData
	setb	lmpAppTxFlag				;remember receiving data
	call	@lmp2appTxCommData			;Get next data byte
	bank	lmpBank
	snz						;Skip if not last byte
	retp						;Z = 0 indicating last byte
	dec	lmpPosition				;Byte counter
	retp						;Returns Z = true if counter = 0 ie when counter reaches 0 last flag will be set

;********************************************************************************
			ENDM

LmpRxStringSeg		MACRO
;********************************************************************************
;  LMP LAYER - Strings		;WARNING - Strings must not go over a 256 boundry !!!
;********************************************************************************

_lmpRxStringSegment		;Rx strings must all be in the same segement !!!

_lmpIASDeviceClass		dw	'Device'+$F00				;Classname = "Device" ($F00 indicates end)
_lmpIASDeviceAttribName		dw	'DeviceName'+$F00			;Device Attribute: "DeviceName" ($F00 indicates end)
_lmpIASDeviceAttribSupport	dw	'IrLMPSupport'+$F00			;Device Attribute: "IrLMPSupporte" ($F00 indicates end)
_lmpIASCommClass		dw	'IrDA:IrCOMM'+$F00			;Classname = "IrDA:IrCOMM" ($F00 indicates end)
_lmpIASCommAttribParam		dw	'Parameters'+$F00			;IrCOMM Attribute: "Parameters" ($F00 indicates end)
_lmpIASCommAttribLsapSel	dw	'IrDA:IrLMP:LsapSel'+$F00		;IrCOMM Attribute: "LsapSel" ($F00 indicates end)

;********************************************************************************
			ENDM

LmpTxStringSeg		MACRO
;********************************************************************************
;  LMP LAYER - String		;WARNING - Strings must not go over a 256 boundry !!!
;********************************************************************************

_lmpTxStringSegment		;Tx strings must all be in the same segement !!!

_lmpLMPConnRsp			dw	lmpConnectRspOpcode, $00+$F00

_lmpIASDeviceName		dw	$84, $00				;$84 = Reply to GetValueByClass, $00 = success
_lmpIASDeviceName1		dw	$00, $01				;List length = 1 item
_lmpIASDeviceName2		dw	$00, $00				;Object identifier = 0
_lmpIASDeviceName3		dw	$03, $00				;Data is of type "User string", ASCII
_lmpIASDeviceName4		dw	28					;length of text = 28 octets
_lmpIASDeviceNameText		dw	'SX IrDA IrComm Demonstration'+$F00	;String to be displayed

_lmpIASDeviceSupport		dw	$84, $00				;$84 = Reply to GetValueByClass, $00 = success
_lmpIASDeviceSupport1		dw	$00, $01				;List length = 1 item
_lmpIASDeviceSupport2		dw	$00, $00				;Object identifier = 0
_lmpIASDeviceSupport3		dw	$02					;Data is of type "Octet Sequence"
_lmpIASDeviceSupport4		dw	$00, $03				;Data is 3 bytes in length
_lmpIASDeviceSupport5		dw	$01					;Data : IrLMP Version = 1 (refer LMP p 84)
_lmpIASDeviceSupport6		dw	$00					;Data : IAS Support = no additional features (refer LMP p 84)
_lmpIASDeviceSupport7		dw	$00+$F00				;Data : MUX Support = no additional features (refer LMP p 85) ($F00 indicates end)

_lmpIASCommParam		dw	$84, $00				;$84 = Reply to GetValueByClass, $00 = success
_lmpIASCommParam1		dw	$00, $01				;List length = 1 item
_lmpIASCommParam2		dw	$00, $00				;Object identifier = 0
_lmpIASCommParam3		dw	$02					;Data is of type "Octet Sequence"
_lmpIASCommParam4		dw	$00, $06				;Data is 6 bytes in length
_lmpIASCommParam5		dw	$00, 1, %00000001			;Data : Service types = 3 wire raw
_lmpIASCommParam6		dw	$01, 1, %00000011+$F00			;Data : Port type = serial or parallel ($F00 indicates end)

_lmpIASCommLsapSel		dw	$84, $00				;$84 = Reply to GetValueByClass, $00 = success
_lmpIASCommLsapSel1		dw	$00, $01				;List length = 1 item
_lmpIASCommLsapSel2		dw	$00, $00				;Object identifier = 0
_lmpIASCommLsapSel3		dw	$01					;Data is of type "Integer"
_lmpIASCommLsapSel4		dw	$00, $00, $00, lmpLSAPComm+$F00		;LsapSel = 5 ($F00 indicates end)

;********************************************************************************
			ENDM

AppInfoSeg		MACRO
;********************************************************************************
;  APP LAYER
;********************************************************************************
;  Updated 6 Decembet 1999 - Nick Kelsey
;  * TransApp: Increased UART buffer size from 7 to 16 bytes.
;  * TransApp: Added flow control for UART receive.
;********************************************************************************
;
;	lmp2appRxCommData(w = Data)			;Incomming data bytes
;	lmp2appRxCommValid()				;Data bytes passed since last Valid/Error message are valid
;	lmp2appRxCommError()				;Data bytes passed since last Valid/Error message are invalid and should be discarded
;
;	lmp2appTxCommStart(ret z=None)			;Data bytes can now be sent, Return Z=false if data to be sent
;	lmp2appTxCommData(ret w=TxData, z=Last)		;Data bytes can now be sent. Set Z if this is the last byte to be sent
;	lmp2appTxCommValid()				;All data passed since last Valid/Error message were acknowledged as received by the remote station
;	lmp2appTxCommError()				;All data passed since last Valid/Error message were discarded and will need to be sent again
;
;	lap2appRxUIData(w = Data)			;Incomming UI data bytes (outside of a connection only)
;	lap2appRxUIValid()				;Data bytes passed since last Valid/Error message are valid
;	lap2appRxUIError()				;Data bytes passed since last Valid/Error message are invalid and should be discarded
;
;	app2lapTxUIFrame(ret z=Busy)
;	lap2appTxUIData(ret w=TxData, z=Last)
;	lap2appTxUIComplete()
;
;	app2lapDiscoveryRequest(ret z=Busy)
;
;********************************************************************************
			ENDM


AppCommSX2PCCodeSeg	MACRO
;********************************************************************************
;  APP LAYER - CommSX2PC
;********************************************************************************

appBank		= 	$F0

appTxState	=	appBank + 0		;Current transmission type
appTxPosition	=	appBank + 1		;Current transmission position
appTxBank	=	appBank + 2		;Current transmission position
appRxData	=	appBank + 3		;Current received byte

appTxStrState	=	1
appTxRegState	=	2
appTxPortState	=	3

;********** Return **********

appReturn	retp

;********** a2appReset **********

a2appReset
	bank	appBank
	clr	appTxState
	retp

;********** lmp2appRxCommData **********

lmp2appRxCommData					;Incomming data bytes
	bank	appBank
	mov	appRxData, w				;Store data (if more bytes are received in frame then only last byte is reconised)
	retp

;********** lmp2appRxCommValid **********

lmp2appRxCommValid					;Data bytes passed since last Valid/Error message are valid
	bank	appBank
	test	appTxState				;Currently not sending anything ?
	sz
	retp						;Already sending a frame => ignore command
	debugf	1, appRxData				;Show command out debug port
	csne	appRxData, #'?'				;Is the command '?' ?
	jmp	:Str					;Yes => prepare to transmit a string
	csne	appRxData, #'r'				;Is the command 'r' ?
	jmp	:Reg					;Yes => prepare to transmit registers
	csne	appRxData, #'c'				;Is the command 'c' ?
	jmp	:Port					;Yes => prepare to transmit port c contents
	retp
:Str	mov	appTxState, #appTxStrState		;Will send string
	retp
:Reg	mov	appTxState, #appTxRegState		;Will send registers
	clr	appTxBank				;Clear TxBank ready for transmission
	retp
:Port	mov	appTxState, #appTxPortState		;Will send port c
	retp

;********** lmp2appRxCommError **********

lmp2appRxCommError					;Data bytes passed since last Valid/Error message are invalid and should be discarded
	retp

;********** lmp2appTxCommStart **********

lmp2appTxCommStart					;Data bytes can now be sent. Return Z = flase if data to be sent
	bank	appBank
	clr	appTxPosition				;Clear TxPosition ready for transmission
	test	appTxState				;Return z=false if TxState not 0 to indicate data to be sent
	retp

;********** lmp2appTxCommData **********

lmp2appTxCommData					;Data bytes can now be sent. If there is data available then return data byte and set Last (z) to false
	bank	appBank
	mov	w, appTxState				;Jump based on state
	jmp	PC+w
	retp						;0 = Invalid
	jmp	appTxStrData				;1 = appTxStrState
	jmp	appTxRegData				;2 = appTxRegState
	jmp	appTxPortData				;3 = appTxPortState

appTxStrData
	mov	m, #_lmpIASDeviceNameText / 256		;Pointer to string (high)
	mov	w, #_lmpIASDeviceNameText		;Pointer to string (low)
	add	w, appTxPosition			;index into string
	inc	appTxPosition				;Increment offset for next byte
	iread						;Read data from ROM
	mov	Temp, w					;Store data
	mov	w, m					;Move high part of data to w
	test	w					;Is this the last byte ?
	jnz	:Last					;Yes => indicate last
:More	mov	w, Temp					;No  => indicate more. Recover data to pass
	clz						;Indicate more data to follow Data
	retp						;Return data
:Last	mov	w, Temp					;Data to pass
	stz						;Indicate last byte
	retp						;Return data

appTxRegData
	mov	w, #$10					;w = $10
	add	w, appTxBank				;w = current bank (starting from $10)
	add	w, appTxPosition			;w = pointer to current register
	mov	FSR, w					;Apply pointer
	mov	Temp, INDF				;Obtain data from register
	bank	appBank
	csne	appTxPosition, #$0F			;Last byte to be transmitted in frame ?
	jmp	:Last					;Yes => indicate last
:More	inc	appTxPosition				;No  => indicate more. Increment position fo next data byte
	mov	w, Temp					;Recover data to send
	clz						;Indicate more data to follow
	retp
:Last	mov	w, Temp					;Recover data to send
	stz						;Indicate last byte
	retp

appTxPortData
	mov	w, rc					;Return contents of port c
	stz						;Indicate no more data to send
	retp						;Return data

;********** lmp2appTxCommValid **********

lmp2appTxCommValid					;All data passed since last Valid/Error message were acknowledged as received by the remote station
	bank	appBank
	csne	appTxState, #appTxRegState		;Currently transmitting registers ?
	jmp	:Reg					;Yes => send more registers (multi frame)
	clr	appTxState				;No  => finished transmitting, return to idle state
	retp
:Reg	add	appTxBank, #$20				;Add $20 for next bank
	sz						;Back to starting bank ?
	retp						;No  => more data to send, stay in this state
	clr	appTxState				;Yes => finished transmitting, return to idle state
	retp

;********** lmp2appTxCommError **********

lmp2appTxCommError					;All data passed since last Valid/Error message were discarded and will need to be sent again
	retp						;Stay in current state for retransmission

;********** UI Frames **********

lap2appRxUIData		=	appReturn
lap2appRxUIValid	=	appReturn
lap2appRxUIError	=	appReturn
lap2appTxUIData		=	appReturn
lap2appTxUIComplete	=	appReturn

;********** Uart **********

a2appRxAvail
	bank	IsrBank
	clrb	UartRxAvail				;Clear flag
	retp

;********************************************************************************
			ENDM

AppCommTransCodeSeg	MACRO
;********************************************************************************
;  APP LAYER - CommTrans
;********************************************************************************

appBank		= 	$D0			;Local variables
appData		=	$F0			;16-byte buffer

appHeadPtr	=	appBank + 0		;1 byte
appTailPtr	=	appBank + 1		;1 byte

;********** Return **********

appReturn	retp

;********** a2appReset **********

a2appReset
	bank	appBank
	clr	appHeadPtr			;Init buffer head pointer
	clr	appTailPtr			;Init buffer tail pointer
	clrb	UartCtsPin			;Indicate CTS to PC - ready to accept more data
	retp

;********** lmp2appRxCommData **********

lmp2appRxCommData				;Incomming data bytes
	debug	1				;Show data out debug port
	retp

;********** lmp2appRxCommValid **********

lmp2appRxCommValid				;Data bytes passed since last Valid/Error message are valid
	retp

;********** lmp2appRxCommError **********

lmp2appRxCommError				;Data bytes passed since last Valid/Error message are invalid and should be discarded
	retp

;********** lmp2appTxCommStart **********

lmp2appTxCommStart				;Data bytes can now be sent. Return Z = flase if data to be sent
	bank	appBank
	mov	w, appHeadPtr			;Compare head pointer with tail pointer
	xor	w, appTailPtr			;Z is true if they match => indicating no data to send
	retp					;Z is false if they do not match indicating data to send

;********** lmp2appTxCommData **********

lmp2appTxCommData				;Data bytes can now be sent. If there is data available then return data byte and set Last (z) to false
	bank	appBank
	mov	w, appTailPtr			;Index into buffer
	and	w, #%00001111			;16 byte buffer
	xor	w, #appData			;Add pointer to first byte of data
	mov	FSR, w				;Apply pointer
	mov	Temp, INDF			;Read byte out of buffer
	bank	appBank
	inc	appTailPtr			;move on tail ptr
	mov	w, appHeadPtr			;Compare head pointer with tail pointer
	xor	w, appTailPtr			;Do they match (indicating no more data)
	jz	:Last				;Yes => no more data
:More	mov	w, Temp				;No  => more data. Recover data
	clz					;Indicate more data to follow
	retp					;Return data
:Last	mov	w, Temp				;Recover data
	clrb	UartCtsPin			;Indicate CTS to PC - ready to accept more data
	stz					;Indicate last byte
	retp					;Return data

;********** lmp2appTxCommValid **********

lmp2appTxCommValid				;All data passed since last Valid/Error message were acknowledged as received by the remote station
	retp

;********** lmp2appTxCommError **********

lmp2appTxCommError				;All data passed since last Valid/Error message were discarded and will need to be sent again
	retp

;********** UI Frames **********

lap2appRxUIData		=	appReturn
lap2appRxUIValid	=	appReturn
lap2appRxUIError	=	appReturn
lap2appTxUIData		=	appReturn
lap2appTxUIComplete	=	appReturn

;********** Uart **********

a2appRxAvail
	setb	UartCtsPin			;Indicate NOT CTS after 1st byte (PC will send 16 bytes after loosing CTS!)
	bank	IsrBank
	mov	Temp, UartRxData		;Store received byte in buffer
	clrb	UartRxAvail			;Clear flag
	bank	appBank
	mov	w, appHeadPtr			;Index into buffer
	and	w, #%00001111			;16 byte buffer
	xor	w, #appData			;Add pointer to first byte of data
	mov	FSR, w				;Apply pointer
	mov	INDF, Temp			;Store data
	bank	appBank
	inc	appHeadPtr			;Record count
	retp

;********************************************************************************
			ENDM

AppSX2SXCodeSeg		MACRO
;********************************************************************************
;  APP LAYER - SX 2 SX
;********************************************************************************

appBank		= 	$F0

appTxState	=	appBank + 0		;Current transmission type
appTxPosition	=	appBank + 1		;Current transmission position

appTxStrState	=	1
appTxPortState	=	2

;********** Return **********

appReturn	retp

;********** a2appReset **********

a2appReset
	bank	appBank
	clr	appTxState
	retp

;********** lmp2appCommData **********

lmp2appRxCommData	=	appReturn
lmp2appRxCommValid	=	appReturn
lmp2appRxCommError	=	appReturn

lmp2appTxCommData	=	appReturn
lmp2appTxCommValid	=	appReturn
lmp2appTxCommError	=	appReturn

lmp2appTxCommStart
	stz
	retp

;********** UI Frames - Rx **********

lap2appRxUIData
	debug	1					;Show data
	retp

lap2appRxUIValid
	retp

lap2appRxUIError
	retp

;********** UI Frames - Tx **********

lap2appTxUIData
	bank	appBank
	mov	w, appTxState				;Jump based on state
	jmp	PC+w
	retp						;0 = Invalid
	jmp	appTxStrData				;1 = appTxStrState
	jmp	appTxPortData				;2 = appTxPortState

appTxStrData
	mov	m, #_lmpIASDeviceNameText / 256		;Pointer to string (high)
	mov	w, #_lmpIASDeviceNameText		;Pointer to string (low)
	add	w, appTxPosition			;index into string
	inc	appTxPosition				;Increment offset for next byte
	iread						;Read data from ROM
	mov	Temp, w					;Store data
	mov	w, m					;Move high part of data to w
	test	w					;Is this the last byte ?
	jnz	:Last					;Yes => indicate last
:More	mov	w, Temp					;No  => indicate more. Recover data to pass
	clz						;Indicate more data to follow Data
	retp						;Return data
:Last	mov	w, Temp					;Data to pass
	stz						;Indicate last byte
	retp						;Return data

appTxPortData
	mov	w, rc					;Return contents of port c
	stz						;Indicate no more data to send
	retp						;Return data

lap2appTxUIComplete
	bank	appBank
	retp

;********** Uart **********

a2appRxAvail
	bank	IsrBank
	mov	Temp, UartRxData			;Store received byte in Temp
	clrb	UartRxAvail				;Clear data available flag
	bank	appBank
	debugf	1, Temp					;Show command
	csne	Temp, #'d'				;Was the byte a 'd'
	jmp	:XID					;Yes => request discovery
	csne	Temp, #'s'				;Was the byte a 's'
	jmp	:STR					;Yes => send the broadcast string
	csne	Temp, #'c'				;Was the byte a 'c'
	jmp	:PORT					;Yes => send contents of port c
	retp
:XID	call	@app2lapDiscoveryRequest		;Request discovery
	mov	w, #'^'					;Assume accepted (zero false)
	snz						;Was the request accepted ?
	mov	w, #'!'					;No => refused
	debug	1					;Send character out the debug port for the user
	retp
:STR	mov	appTxState, #appTxStrState		;Will send string
	clr	appTxPosition				;Reset position
	jmp	:Send
:PORT	mov	appTxState, #appTxPortState		;Will send port
:Send	call	@app2lapTxUIStart
	mov	w, #'^'					;Assume accepted (zero false)
	snz						;Was the request accepted ?
	mov	w, #'!'					;No => refused
	debug	1					;Send character out the debug port for the user
	retp
	
;********************************************************************************
			ENDM
;********************************************************************************
;  debugl MACRO
;  Send a Literal out the debug port
;  Affects : w
;  Cycles  : 3
;********************************************************************************

debugl	MACRO	2
IF	\1 = 1
	mov	w, #\2
	mov	DebugData, w
	setb	DebugSend
ENDIF
	ENDM

;********************************************************************************
;  debugf MACRO
;  Send a Register out the debug port
;  Affects : w, Z
;  Cycles  : 3
;********************************************************************************

debugf	MACRO	2
IF	\1 = 1
	mov	w,\2
	mov	DebugData, w
	setb	DebugSend
ENDIF
	ENDM

;********************************************************************************
;  debug MACRO
;  Send w out the debug port
;  Affects : None
;  Cycles  : 2
;********************************************************************************

debug	MACRO	1
IF	\1 = 1
	mov	DebugData, w
	setb	DebugSend
ENDIF
	ENDM
;********************************************************************************
;  IrDA Project
;********************************************************************************

	device	SX28L, OSCXT4, TURBO, STACKX_OPTIONX
;	device	PINS28, PAGES4, BANKS8, OSCHS, TURBO, STACKX, OPTIONX
	id	'IrDA'
	reset	Startup
	freq	50000000

;********** Mode Constants **********

TRIS		=	$0F
PLP		=	$0E
LVL		=	$0D
ST		=	$0C
WKEN		=	$0B
WKED		=	$0A
WKPND		=	$09
COMP		=	$08

IsrStatus	=	$0C			;Global ISR status register
DebugData	=	$0D			;Debug data to be sent out the debug port
Temp		=	$0E			;2 bytes of tempory storage

PhysicalDataTx	=	0			;Shows all transmitted bytes to IR medium
PhysicalDataRx	=	0			;Shows all received bytes from IR medium
PayloadDataTx	=	0			;Shows all payload data bytes transmitted followed by ^ when frame is complete
PayloadDataRx	=	0			;Shows all payload data bytes received followed by ^ or ! for pass/fail when frame is complete
PayloadInfo	=	0			;Filters address and shows I, S, or U based on command type
IFrameDataTx	=	0			;Shows all I frame data bytes transmitted followed by ^ or ! for ack/!ack
IFrameDataRx	=	0			;Shows all I frame data bytes received followed by ^ or ! for ack/!ack

ShowXIDInfo	=	1
ShowConnect	=	1

	IsrDataSeg
	FrameDataSeg
	PayloadDataSeg
	LapDataSeg
	LmpDataSeg
	
	org		$0000

	IsrCodeSeg
	MainCodeSeg
	FrameCodeSeg
	LmpRxStringSeg

	org		$0200

	LapCodeSeg
	PayloadString3

	org		$0400

	PayloadCodeSeg
	PayloadString1
	PayloadString2

	org		$0600

; ====================================================================
; Application Code
; 
; Uncomment the following lines for the three different applications.
;
; SX to PC communications (IrComm):
;	AppCommSX2PCCodeSeg
;
; Transparent data transfer. PC to PC. (IrComm):
	AppCommTransCodeSeg
;
; SX to SX communications:
;	AppSX2SXCodeSeg
;
; ====================================================================

	LmpCodeSeg
	LmpTxStringSeg


file: /Techref/scenix/lib/io/osi2/ir/da/IRDA.SRC, 124KB, , updated: 1999/12/6 16:53, local time: 2017/10/23 05:08,
TOP NEW HELP FIND: 
54.162.154.91:LOG IN

 ©2017 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions?
Please DO link to this page! Digg it! / MAKE! / 

<A HREF="http://www.piclist.com/techref/scenix/lib/io/osi2/ir/da/IRDA.SRC"> scenix lib io osi2 ir da IRDA</A>

Did you find what you needed?

  PICList 2017 contributors:
o List host: MIT, Site host massmind.org, Top posters @20171023 RussellMc, Van Horn, David, James Cameron, Sean Breheny, IVP, alan.b.pearce, Neil, David C Brown, Bob Blick, Denny Esterline,
* Page Editors: James Newton, David Cary, and YOU!
* Roman Black of Black Robotics donates from sales of Linistep stepper controller kits.
* Ashley Roll of Digital Nemesis donates from sales of RCL-1 RS232 to TTL converters.
* Monthly Subscribers: Gregg Rew. on-going support is MOST appreciated!
* Contributors: Richard Seriani, Sr.
 

Welcome to www.piclist.com!

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  .