MainLoader_chip.spin2

''
'' fast loader for CHIP mode
'' this small loader is downloaded by the usual ROM loader, and can
'' then do more sophisticated and slightly faster loading (using binary
'' rather than hex or base64) of the main binary, which is typically much
'' larger
''

' for debug use, look for #ifdef DEBUG
'#define DEBUG 1

CON
		R_READBURST  = $B << 28
		R_WRITEBURST = $F << 28
		tx_pin = 62
		rx_pin = 63
		dbg_pin = 56
		
		FLAGBIT_ZERO = $1		' if set, zero HUB memory
		FLAGBIT_PATCHED = $2		' if set, clock frequency was patched into binary

  '' smart pin modes
  ser_txmode       = %0000_0000_000_0000000000000_01_11110_0 'async tx mode, output enabled for smart output
  ser_rxmode       = %0000_0000_000_0000000000000_00_11111_0 'async rx mode, input  enabled for smart input
		
DAT		org

begin
		mov	mailbox, #0
		test	flagbits, #FLAGBIT_ZERO wz
	if_z	jmp	#skipzero
		'' zero out memory
		mov	pb, ##$7c000/16 - 1
		mov	ptrb, #0
		setq	pb
		wrlong	#0, ptrb
skipzero

restart		

		'' set up uart smart pins
		'' we don't know for sure what the frequency is, so use
		'' auto baud rate detection for this
		dirl	#rx_pin
		dirl	#tx_pin


		call	#autobaud
		mov     pa, waitbit	' autobaud set waitbit
		shl	pa, #13
		or      pa, #7	' set for 8 bits
		wrpin   ##ser_txmode, #tx_pin
		wxpin   pa, #tx_pin
		dirh    #tx_pin
		wrpin   ##ser_rxmode, #rx_pin
		wxpin   pa, #rx_pin
		dirh    #rx_pin

		'' try to receive a $55
		'' if it works, autobaud is OK, otherwise re-try
.space
		testp	#rx_pin wc
	if_nc	jmp	#.space
		rdpin	rxbyte, #rx_pin
		shr	rxbyte, #24
		cmp	rxbyte, #$80 wz
	if_nz	jmp	#restart
	
#ifdef DEBUG
		drvl	#dbg_pin
#endif		
		'' send 0 to host to indicate we are ready
setup
		mov	chksum, #0
		call	#send_chksum

next_request
		'' get request from host
		'' the requests we're aware of:
		''   = address size : download "size" bytes to address
		''   F address size : copy "size" bytes from hub to flash
		''   !              : execute the last download blob, then wait for more
		''   -              : terminate downloads then execute
		''
		call	#ser_rx
		cmp	rxbyte, #"=" wz
	if_z	jmp	#read_file
		cmp	rxbyte, #"!" wz
	if_z	jmp	#call_last
		cmp	rxbyte, #"F" wz
	if_z	jmp	#copy_hub_to_flash
		cmp	rxbyte, #"-" wz
	if_z	jmp	#done_and_exec

		'' bad request
		'' set an LED high and loop
		drvh	#56
		drvl	#57
error
		waitx	##10_000_000
		drvnot	#56
		drvnot	#57
		jmp	#error


read_file
		mov	chksum, #0
		'' read file address
		call	#ser_rx_long
		mov	loadaddr, rxlong

		'' if first time through, set starting address
		cmp	startaddr, ##-1 wz
	if_z	mov	startaddr, loadaddr
	
		'' read file size
		call	#ser_rx_long
		mov	filesize, rxlong

		'' check for himem (bit 31 of address set)
		testb	 loadaddr, #31 wc
	if_c	jmp	 #use_himem

		'' respond that we are ready to stream data in
		mov	temp, #"s"
		call	#ser_tx

		'' and get the data
		wrfast	#0,loadaddr		'ready to write entire memory starting at address
		nop		       		' give time to settle
		
.mainloop
		call	#ser_rx
		wfbyte	rxbyte			'write to hub
		add	chksum, rxbyte

		djnz	filesize,#.mainloop	'loop until all bytes received

                rdfast  #0,#0                   'wait for last byte to be written

done_file
		'' respond to host
		call	#send_chksum

		jmp	#next_request
		
call_last
		call	startaddr
		'' response is in ptra (a mailbox)
		mov	mailbox, ptra
		neg	startaddr, #1
		jmp	#next_request

done_and_exec
		waitx	##80_000_000/10		' short pause to ensure sync

		'' shut down auxiliary cog
		tjz	mailbox, #.no_mbox
		neg	mailinfo+0, #1		' send all 1's for shutdown	
		call	#send_mbox

.no_mbox
		'' shut down smart pins
		dirl	#tx_pin
		dirl	#rx_pin
		wrpin	#0, #tx_pin
		wrpin	#0, #rx_pin

		' switch to new clock mode, maybe
		' if the binary was patched with -PATCH then we
		' set the clock mode to clkmode_
		test	flagbits, #FLAGBIT_PATCHED wz
	if_z	jmp	#start_cog		 ' not patched, so start right now
		' set clock to clkmode_
		' do this in two steps, first clkmode_ & ~3 for rcfast
		mov	pa, clkmode_ wz
		' clkmode_ == 0 means RCFAST, and we're already in that mode
	if_z	jmp	#start_cog
		andn	pa, clkmode_
		hubset	pa			' set up oscillator
		waitx	##25_000_000/100	' wait 10 ms
		test	clkmode_, #3 wz		' does clkmode include a crystal mode?
	if_z	or	clkmode_, #3 		' if not, set it
		hubset	 clkmode_
start_cog
		waitx	 ##25_000_000/10
		coginit	#0,startaddr		'launch cog 0 from starting address
		'' never returns

		'' send mailbox info to the other COG
send_mbox
		'' make sure himem cog is free
.wait_himem
		rdlong	resp, mailbox wcz
	if_c	jmp	#.wait_himem		' negative -> still executing command
	if_nz	jmp	#himem_error		' positive -> error message

		'' write out the mailbox info (4 longs)
		setq	#3
		wrlong	mailinfo, mailbox
		ret
		
		''
		'' routine to copy HUB memory to flash
		'' the host will send us how much to copy (a 32 bit value)
		''
copy_hub_to_flash
		call	#ser_rx_long		' get the length

		'' set up mailbox data
		mov	mailinfo+0, ##R_WRITEBURST	' starting hub address
		mov	mailinfo+1, ##$8000_0400	' starting flash address
		mov	mailinfo+2, rxlong		' length sent to us by the host

		'' send it to the mailbox
		call	#send_mbox

		'' and now go
		jmp	#done_and_exec

		''
		'' routine to load code into high memory
		'' via the mailbox set up earlier
		''
use_himem
		tjz	mailbox, #no_himem

		'' set up to receive ping-pong data in the upper 2K of memory
		'' the R_WRITEBURST command goes in the upper nybble and makes
		'' the whole address negative, which we use to test results
		mov	pingpong, ##$7FC00 | R_WRITEBURST
next_buffer
		xor	pingpong, onek
		mov	bufsiz, onek
		cmp	filesize, onek wcz	' if filesize < 1K
	if_c	mov	bufsiz, filesize	' use that as the buffer size

		'' set up mailbox data for this buffer
		mov	mailinfo+0, pingpong	' hub address
		mov	mailinfo+1, loadaddr	' flash address
		mov	mailinfo+2, bufsiz	' current size
		
		'' tell the host to send us the next data
		mov	temp, #"k"
		call	#ser_tx

		'' and now receive the data
		mov	ptrb, pingpong
		mov	pb, bufsiz
.buf_lp
		call	#ser_rx
		wrbyte	rxbyte, ptrb++
		add	chksum, rxbyte
		djnz	pb, #.buf_lp

		'' chunk received
		'' send the next mailbox command to the himem cog
		call	#send_mbox
		'' now move on to the next chunk
		add	loadaddr, bufsiz
		sub	filesize, bufsiz wcz
	if_nz	jmp	#next_buffer
chunks_done
		'' all done file
		'' wait for the final chunk to be processed
.wait_himem
		rdlong	resp, mailbox wcz
	if_c	jmp	#.wait_himem		' negative -> still executing command
	if_nz	jmp	#himem_error		' positive -> error message


		'' and go do the next file
		jmp    #done_file

		'' no mailbox set up, return an error for himem
no_himem
		mov	temp, #"h"	' no himem kernel loaded
		call	#ser_tx
		jmp	#read_file

' relay an error message from the himem kernel
' the error message is a non-zero HUB memory address
himem_error
		mov	temp, #"e"
		call	#ser_tx
		mov	ptrb, resp
.eloop
		rdbyte	temp, ptrb++ wz
	if_z	jmp	#read_file
		call	#ser_tx
		jmp	#.eloop

' send the current checksum back to the host
send_chksum
		mov	temp, chksum
		shr	temp, #4
		and	temp, #$f
		add	temp, #"@"
		call	#ser_tx
		mov	temp, chksum
		and	temp, #$f
		add	temp, #"@"
		call	#ser_tx
		mov	temp, #" "
		jmp	#ser_tx
		
ser_tx
		wypin	temp, #tx_pin
		waitx	#20
.txflush
		testp	#tx_pin wc
	if_nc	jmp	#.txflush
		ret

' receive a byte from serial
ser_rx
		testp	#rx_pin wc
	if_nc	jmp	#ser_rx
		rdpin	rxbyte, #rx_pin
	_ret_	shr	rxbyte, #24

' receive a long from serial
ser_rx_long
  	    	call	#ser_rx
		mov	rxlong, rxbyte
		call	#ser_rx
		shl	rxbyte, #8
		or	rxlong, rxbyte
		call	#ser_rx
		shl	rxbyte, #16
		or	rxlong, rxbyte
		call	#ser_rx
		shl	rxbyte, #24
	_ret_	or	rxlong, rxbyte

' automatically detect baud rate
' based on length of shortest 1 or 0
' we see next
autobaud
		dirl	#rx_pin
		waitx	##1000
		mov	mask, ##(1<<(rx_pin-32))
		mov	port, #1

    	        test    port, #1 wc	' set C to distinguish INA/OUTA
    	        test    port, #2 wz    ' set Z (match on =)

                setpat  mask, #0	' wait for pin lo (start bit)
    	        waitpat
		getct   a
		setpat  mask, mask	' wait for pin hi (first 1)
		waitpat
                getct   waitbit 

	_ret_	sub     waitbit, a


startaddr	long	-1			'starting address
waitbit		long	99999
onek		long	1024

		orgf	$100
		'' the first two values here are set up by loadp2
		'' (it sends a additional longs of data representing
		'' these values as part of the load process)
clkmode_	res	1			'clock mode
flagbits	res	1			'flag bits, see definitions above
loadaddr	res	1			'address for load
filesize	res	1			'binary file size in bytes
count		res	1
rxbyte		res	1			'received byte
rxlong		res	1			'received longword
temp		res	1
chksum		res	1
mask		res	1
port		res	1
a		res	1
mailbox		res	1			' address of himem mailbox
pingpong	res	1			' ping pong buffer address
bufsiz		res	1			' current size of ping pong buffer
mailinfo	res	4			' info to store in himem mailbox
resp		res	1			' space for response from himem