;;;
;;;  Boot OS9 via CoCoBoot interface
;;;
;;;


	include "sd.def"

	export	prestart

	import	start.bss
	import  length.bss
	
CR	equ	13
SP	equ	32
	
DBUF0	equ	$600			; we'll borrow some memory from basic
DBUF1	equ	$700			; another buffer
SCRPTR	equ	$0002		; point to the os screen pointer


DD.BIT	equ	$6		; 2B no of sectors per cluster
DD.NAM	equ	$1f		; 32B volume name field
DD.DIR	equ	$8		; 3B descriptor cluster for root dir

FD.SIZ	equ	$9		; 4B size of file in bytes
	

		.area	.bss
root		rmb	3		; 3b lsn of root dir
;; FCB - vars needed to control file access.
sptr		rmb	2		; ptr to current segment
dptr		rmb	2		; ptr to data buffer
bcount	rmb	2		; number of bytes left in buffer
fcounth	rmb	2		; number of bytes left in file (high word)
fcount 	rmb	2		; number of bytes left in file (low word)
cptr		rmb	2		; pointer in block (boot cpu address)
blocks	rmb	1		; number of regular contigeous blocks
block		rmb	1		; current block number
dirbuf	rmb	32		;
ksize		rmb	2		; "stacked" size of os9 boot file
offset	rmb	3		; 3B offset of root partition
stack1	rmb	64
stackb

		.area	.bounce
BOUNCE	rmb	255

		.area	.code
prestart
		jmp	start		; me first, but jump over DATA

BOOT		fcn	"OS9Boot"
KRN		fcn	"ccbkrn"
str0		fcn	"Loading OS9Boot"
str1		fcn	"Loading ccbkrn"
str2		fcn	"Xfr Control to KRN..."
str3		fcn	"CoCoBoot SDIO"
str4		fcn	"Vol Name: "

start
		orcc	#$50		; shut off interrupts
		clr	$ffa0		; set mmu bank 0 to phys 0
		clr	$ffdf		; set SAM RAM mode
		clr	$ffd9		; high speed poke
;; clear ram vars
		ldx	#start.bss
a@		clr	,x+
		cmpx	#(start.bss+length.bss)
		bne	a@
;; 
		lds	#stackb	; set stack
		ldx	#$ff90	; setup gimme
		jsr	gime		;
;; setup screen
		jsr	scrSetup	; setup screen
		ldx	#str3		; print banner
		jsr	putscr		;
;; init SD card
		jsr	ll_init		
		lbcs	initerr
;; get LSN0
		ldx	#DBUF0	; set disk arg
		stx	DPTR
		clr	LSN
		clr	LSN+1
		clr	LSN+2
;; Test for CCPT
		jsr	ccpttest
;; try to mount os9 filesystem
		jsr	getlsn
;; print volume name
		ldx	#str4
		jsr	puts
		ldx	#DBUF0+DD.NAM
		jsr	putscr
;; get root dir's lsn
		ldx	#DBUF0+DD.DIR
		ldu	#root
		jsr	cpy3
;; open boot file
		ldx	#str0
		jsr	puts
		ldx	#BOOT
		jsr	nopen
		lbcs	fnferr
		ldx	#dirbuf+$1d	; !!! replace with constant
		ldu	#LSN		;
		jsr	cpy3		; set LSN = lsn of dirent
		jsr	open		; and open the file
		ldd	fcounth	; check size 
		lbne	toobig	; 
;; calculate start address
		ldd	fcount	; save os9 size for passing to KRN
		std	ksize		;
		ldd	#$f000	; f000 - fcount = start address
		subd	fcount	;
		clrb			; and round it down to near page boundary
		tfr	d,x		; X = cpu load address
		pshs	x		; push onto stack ( cpustart )
		cmpx	#$2000		; cant go lower
		lblo	toobig
;; set calc init mmu for bounce routine
		lsra			; make A = mmu reg no
		lsra			; take top three bits
		lsra			;
		lsra			;
		lsra			;
		pshs	a		; push start mmu no ( cpustart mmustart )
;; calc no of contigeous block for os9boot loading routine
		ldb	#7		; A = no of contigeous block
		subb	,s		;
		stb	blocks	; save for loading routine
;; calc beginning cpu address
		ldd	1,s		; D = cpu start
		anda	#$1f
		addd	#$4000	; adjust for loader
		std	cptr
;; copy os9boot into memory
b@		jsr	testload	; load os9boot into memory
		jsr	putCR
;; open krn file
		ldx	#str1
		jsr	puts
		ldx	#KRN
		jsr	nopen
		bcs	fnferr
		ldx	#dirbuf+$1d	; !!! replace with constant
		ldu	#LSN		;
		jsr	cpy3		; set LSN = lsn of dirent
		jsr	open		; and open the file
		ldx	fcounth	; check size of krn file
		lbne	krnsize	; is way too big
		ldx	fcount	; 
		cmpx	#$f00		;
		lbne	krnsize	; wrong size
;; copy krn file into memory
		ldx	#$f000
		jsr	fload		; load ccbkrn into memory
		jsr	putCR
;; done with disk go high speed :(
		clr	$ffd9
;; clear out DP page
		ldx	#0
		clrb
		jsr	memz
;; set dp
		tfr	b,dp
;; set gime mirror
		ldx	#$90
		jsr	gime
;; copy bounce routine down to RAM
		ldx	#bounce
		ldu	#BOUNCE
		ldb	#bounceend-bounce
c@		lda	,x+
		sta	,u+
		decb
		bne	c@
;; jump to OS9
		ldx	#str2
		jsr	putscr
		jmp	BOUNCE

	
iloop	bra	iloop

	
fnferr	ldx	#p0@
	jsr	puts
a@	bra	a@
p0@	fcn	": FNF Error!"

initerr	ldx	#p0@
	jsr	puts
a@	bra	a@
p0@	fcn	"Driver Init Error!"

mnterr	ldx	#p0@
	jsr	puts
a@	bra	a@
p0@	fcn	"LSN0: bad format!"

toobig	ldx	#p0@
	jsr	puts
a@	bra	a@
p0@	fcn	"Too Big!"

krnsize
	ldx	#p0@
	jsr	puts
a@	bra	a@
p0@	fcn	"Wrong Size!"
	

;;; Test for presence of CCPT partitioning
ccpttest
	pshs	d,x
	ldd	DBUF0		; get magic
	cmpd	#$4343		; check for "CC"
	lbne	no@
	ldd	DBUF0+2		; check for "PT"
	cmpd	#$5054
	lbne	no@		;
no@	ldx	#p0@
	jsr	putscr
	puls	d,x,pc
p0@	fcn	"CCPT not found."

	
;;; Setup Screen for os9 (sigh)
scrSetup
	pshs	d,x
	;; set colors: green on black
	ldb	#$12
	stb	$ffbc
	ldb	#0
	stb	$ffbd
	;; clear a screen's worth of video memory
	ldb	#$3b
	stb	$ffa0
	ldx	#$0000
	ldd	#$2020
a@	std	,x++
	cmpx	#$0400
	bne	a@
	;; set screen pointer up
	ldd	#8
	std	SCRPTR
	clr	$ffa0
	puls	d,x,pc

	
;;; Setup memory with gimme setting, aka Do os9's work :(
;;;   takes: X = address
;;;   returns: nothing
;;;   modifies: nothing
gime
	pshs	d,x,u
	ldu	#table@
	lda	#16
a@	ldb	,u+
	stb	,x+
	deca
	bne	a@
	puls	d,x,u,pc
table@	.dw	$6c00
	.dw	$0000
	.dw	$0900
	.dw	$0000
	.dw	$0320
	.dw	$0000
	.db	$00
	.dw	$ec01
	.db	$00

;;; This bounce routine gets copied down into low memory
;;;   is completes the memory map.  Plz jump to me.
bounce			      ; ( cpustart mmustart )
	;; setup mmu to how os9 expects it
	clr	$ffa0		; phys block 0 is always mapped to $0000
	puls	a		; get mmu start ( cpustart )
	ldy	#$ffa0
	leay	a,y		; Y = beginning mmu
	ldb	#1		; 1 is first os9 system block
a@	stb	,y+		; store bank no in mmu
	cmpy	#$ffa7		; did we move to the last mmu block
	beq	b@		; yes, then quit looping
	incb			; increment bank no
	bra	a@		; repeat	
b@	ldb	#$3f		; and mmu7 is always $3f
	stb	,y
	;; find and jump to KRN module
	ldx	$f009		; KRN relative start address
	leax	$f000,x		; make it absolute
	ldu	#ksize		; U = ptr to os9boot size
	orcc	#$50		; really, really turn off interrupts
	jmp	,x		; jump to kernel (bye!)
bounceend




;;; Read os9 file into memory
;;;   takes: open os9 file,
testload
	pshs	d,x
	ldb	#1		; set initial bank to 1
	stb	block		;
	stb	$ffa2		;
	;; loop until EOF
a@	ldx	cptr		; get block pointer
	jsr	readb		; read a byte
	bcs	out@		; done!
	stb	,x+
	stx	cptr
	;; check for end of bank
	cmpx	#$6000
	bne	a@
	;; end of bank
	ldd	#$4000		; reset block pointer
	std	cptr
	dec	blocks		; any more blocks left
	bne	b@
	;; no more blocks left set $3f
	ldb	#$3f
	bra	c@
b@	inc	block
	ldb	block
c@	stb	$ffa2		; set mmu
	bra	a@
out@	puls	d,x,pc

;;; Read file into memory
;;;   takes: X = address to load, file opened.
;;;   modifies: nothing
fload	pshs	b,x
a@	jsr	readb
	bcs	done@
	stb	,x+
	bra	a@
done@	puls	b,x,pc


	
;;; open a file via a name
;;;    takes: X = filename (zero termed)
;;;    returns: dirbuf set to file's FD, C set on error.
nopen
	pshs	d,x,u
	;; open root directory
	ldx	#root
	ldu	#LSN
	jsr	cpy3
	jsr	open
	;; get a dirent into buffer
	ldu	2,s		; U = filename
b@	lda	#32
	ldx	#dirbuf
a@	jsr	readb
	bcs	nfound@
	stb	,x+
	deca
	bne	a@
	jsr	os9toz
	ldx	#dirbuf
	jsr	strcmp
	bcc	found@
	bra	b@
nfound@	coma
	puls	d,x,u,pc
found@	clra
	puls	d,x,u,pc


;;; zero mem
;;;   takes: X = ptr, B = number of byte to zero
;;;   returns: nothing
;;;   modifies: nothing
memz
	pshs	b,x
a@	clr	,x+
	decb
	bne	a@
	puls	b,x,pc

	

;;; strcmp
;;;   takes: X = zstring, U = zstring
;;;   returns: C clear if equal
strcmp
	pshs	b,x,u
a@	ldb	,x+
	cmpb	,u+
	bne	ne@		; not equal
	tstb
	beq	e@		; equal
	bra	a@		; loop
e@	clrb
	puls	b,x,u,pc
ne@	comb
	puls	b,x,u,pc
	
;;; change dirbuf's name to a z-string
os9toz
	pshs	b,x
	ldx	#dirbuf
	tst	,x
	beq	out@
a@	ldb	,x+
	bpl	a@
	andb	#$7f
	stb	-1,x
	clr	,x
out@	puls	b,x,pc
	

;;; Open file
;;;   takes: LSN = lsn of file's FD
;;;   returns: nothing
open
	pshs	d,x
	ldx	#DBUF1		; load dbuf1 with file's FD
	stx	DPTR
	jsr	getlsn
	ldd	#DBUF1+$10	; first segment
	std	sptr		; save ptr
	jsr	fill		; and get first sector
	;; set fcount
	ldd	DBUF1+FD.SIZ
	std	fcounth
	ldd	DBUF1+FD.SIZ+2
	std	fcount
	puls	d,x,pc

;;; get one byte from file
;;;   takes: nothing,
;;;   returns: B = byte, C set on EOF
readb
	pshs	a,x
	ldd	fcount		; is the entire file out of bytes?
	beq	eof@
	ldd	bcount
	bne	a@		; if left don't refill
	;; refill file's data buffer
	jsr	fill
	;; 
a@	ldd	fcount
	subd	#1
	std	fcount
	ldd	bcount
	subd	#1
	std	bcount
	ldx	dptr
	ldb	,x+
	stx	dptr
	clra
	puls	a,x,pc
eof@	coma
	puls	a,x,pc
	
	
fill
	pshs	d,x,u		; save regs
	jsr	spin1
	ldx	sptr
	ldd	3,x		; get sector count
	bne	a@		; no more secs left in seg?
	;; get next segment
	ldx	sptr
	leax	5,x
	stx	sptr
	;; fill buffer
a@	ldx	sptr		; copy segment's LSN to args
	ldu	#LSN		;
	jsr	cpy3		;
	ldx	#DBUF0		; set data buffer
	stx	DPTR		;
	jsr	getlsn		; and get the sector
	;; increment segment
	ldx	sptr		; increment segment's LSN
	jsr	inc3		; 
	ldd	3,x		; decrement segment's sector count
	subd	#1		;
	std	3,x		;
	;; set file dirs
	ldd	#256
	std	bcount
	ldd	#DBUF0
	std	dptr
	puls	d,x,u,pc	; return
	

;;; Spin the ticker
;;;   takes: nothing
;;;   returns: nothing
;;;   modifies: nothing
spin1
	pshs	b
	ldb	#'.
	jsr	putc
	puls	b,pc

	
;;; Copy 3 bytes value
;;;   take: X = src ptr, U = dst ptr
;;;   modifies: nothing
cpy3
	pshs	d,x,u
	ldd	,x++
	std	,u++
	ldb	,x
	stb	,u
	puls	d,x,u,pc

	
;;; Add 3 byte value store result in X ptr
;;;   takes: X = 3B ptr, U = 3B ptr
;;;   modifies: nothing
add3
	pshs	d
	ldd	1,u
	addd	1,x
	std	1,x
	ldb	,u
	adcb	,x
	stb	,x
	puls	d,pc
	


;;; increment 3 byte value by one
;;;  takes: X = ptr to 3 bytes
;;;  returns: nothing
inc3
	pshs	d,x
	ldd	1,x
	addd	#1
	std	1,x
	ldb	,x
	adcb	#0
	stb	,x
	puls	d,x,pc
	

;;; deblocker to translate 256B LSN to a 512B LSN
;;;   takes: args in LSN/DPTR
;;;   modifies: nothing
getlsn
	pshs	b,x
	ldx	#LSN		; get pointer
	lsr 	,x+
	ror	,x+
	ror	,x+
	ldb	#1		; 256b lower read
	bcc	a@
	negb
a@	stb	SMALL
	ldx	#LSN		; add partition offset
	ldu	#offset
	jsr	add3
	jsr	ll_read
	puls	b,x,pc
	


;;; Dump 128 byte to screen
;;;   takes: X = ptr to data
;;;   modifies: nothing
dump
	pshs	d,x
	jsr	putCR
	lda	#8
	pshs	a		; put row counter
b@	lda	#8		; column counter
	pshs	x
a@	ldb	,x+
	jsr	putb
	jsr	putSP
	deca
	bne	a@
	puls	x
	clr	8,x
	jsr	putscr
	dec	,s
	bne	b@
	leas	1,s
	puls	d,x,pc

;;; Print a Space
putSP
	pshs	b
	ldb	#SP
	jsr	putc
	puls	b,pc

	
;;; Print a CR
putCR
	pshs	d
	ldb	#$3b
	stb	$ffa0
	ldd	SCRPTR
	addd	#32-8
	andb	#~$1f
	addd	#8
	std	SCRPTR
	clr	$ffa0
	puls	d,pc


;;; Print a Z string
;;;   takes: X = ptr to string
;;;   modifies: nothing
puts
	pshs	b,x
a@	ldb	,x+
	beq	done@
	jsr	putc
	bra	a@
done@	puls	b,x,pc	
	
;;; Print a 3 byte value ( in hex )
;;;   takes: X = ptr to value
;;;   modifies: nothing
put3
	pshs	d,x
	ldd	,x++
	jsr	putw
	ldb	,x
	jsr	putb
	puls	d,x,pc
	

;;; Print a word ( in hex)
;;;   takes: D = word
;;;   modifies: nothing
putw
	pshs	b
	tfr	a,b
	bsr	putb
	puls	b
	bsr	putb
	rts
	
;;; Print a byte (in hex)
;;;   takes: B = byte
;;;   modifies: nothing
putb
	pshs	d
	lsrb
	lsrb
	lsrb
	lsrb
	bsr	putn
	ldb	1,s
	bsr	putn
	puls	d,pc

;;; Print a Char
;;;   takes: B = charactor
;;;   modifies: nothing
putc
	pshs	d,x
	lda	#$3b		; put 3b in bank 0
	sta	$ffa0
	ldx	SCRPTR
	stb	,x+
	stx	SCRPTR
	clr	$ffa0		; put 0 in bank 0
	puls	d,x,pc
	
	
;;; Print a nibble
;;;   takes: B = nibble
;;;   modifies: nothing
putn
	pshs	b
	andb	#$f
	addb	#$30
	cmpb	#$39
	bls	a@
	addb	#7
a@	jsr	putc
	puls	b,pc
	

;;; Print a string followed by a CR
;;;   takes: X = zero termed string
;;;   returns: nothing
;;;   modifies: nothing
putscr
	jsr	puts
	jsr	putCR
	rts