collapseos/recipes/rc2014/zasm/glue.asm

; classic RC2014 setup (8K ROM + 32K RAM) and a stock Serial I/O module
; The RAM module is selected on A15, so it has the range 0x8000-0xffff
.equ	RAMSTART	0x8000
; kernel RAM usage, because of SDC, is a bit high and bring us almost to 0x8500
; We allocate at least 0x200 bytes for the stack, which is why we have this
; threshold.
.equ	RAMEND		0x8700
.equ	PGM_CODEADDR	RAMEND
.equ	ACIA_CTL	0x80	; Control and status. RS off.
.equ	ACIA_IO		0x81	; Transmit. RS on.

	jp	init	; 3 bytes

; *** Jump Table ***
	jp	strncmp
	jp	addDE
	jp	addHL
	jp	upcase
	jp	unsetZ
	jp	intoDE
	jp	intoHL
	jp	writeHLinDE
	jp	findchar
	jp	parseHex
	jp	parseHexPair
	jp	blkSel
	jp	blkSet
	jp	fsFindFN
	jp	fsOpen
	jp	fsGetC
	jp	cpHLDE		; approaching 0x38...

; interrupt hook
.fill	0x38-$
jp	aciaInt

; *** Jump Table (cont.) ***
	jp	parseArgs
	jp	printstr
	jp	_blkGetC
	jp	_blkPutC
	jp	_blkSeek
	jp	_blkTell
	jp	printHexPair
	jp	sdcGetC
	jp	sdcPutC
	jp	blkGetC

#include "err.h"
#include "core.asm"
#include "parse.asm"
.equ	ACIA_RAMSTART		RAMSTART
#include "acia.asm"
.equ	BLOCKDEV_RAMSTART	ACIA_RAMEND
.equ	BLOCKDEV_COUNT		4
#include "blockdev.asm"
; List of devices
.dw	sdcGetC, sdcPutC
.dw	blk1GetC, blk1PutC
.dw	blk2GetC, blk2PutC
.dw	mmapGetC, mmapPutC


.equ	MMAP_START	0xe000
#include "mmap.asm"

.equ	STDIO_RAMSTART	BLOCKDEV_RAMEND
#include "stdio.asm"

.equ	FS_RAMSTART	STDIO_RAMEND
.equ	FS_HANDLE_COUNT	2
#include "fs.asm"

.equ	SHELL_RAMSTART		FS_RAMEND
.equ	SHELL_EXTRA_CMD_COUNT	11
#include "shell.asm"
.dw	sdcInitializeCmd, sdcFlushCmd
.dw	blkBselCmd, blkSeekCmd, blkLoadCmd, blkSaveCmd
.dw	fsOnCmd, flsCmd, fnewCmd, fdelCmd, fopnCmd

#include "fs_cmds.asm"
#include "blockdev_cmds.asm"

.equ	PGM_RAMSTART	SHELL_RAMEND
#include "pgm.asm"

.equ	SDC_RAMSTART	PGM_RAMEND
.equ	SDC_PORT_CSHIGH	6
.equ	SDC_PORT_CSLOW	5
.equ	SDC_PORT_SPI	4
#include "sdc.asm"

.out	SDC_RAMEND

init:
	di
	; setup stack
	ld	hl, RAMEND
	ld	sp, hl
	im	1
	call	aciaInit
	ld	hl, aciaGetC
	ld	de, aciaPutC
	call	stdioInit
	call	fsInit
	call	shellInit
	ld	hl, pgmShellHook
	ld	(SHELL_CMDHOOK), hl

	xor	a
	ld	de, BLOCKDEV_SEL
	call	blkSel

	ei
	jp	shellLoop

; *** blkdev 1: file handle 0 ***

blk1GetC:
	ld	ix, FS_HANDLES
	jp	fsGetC

blk1PutC:
	ld	ix, FS_HANDLES
	jp	fsPutC

; *** blkdev 2: file handle 1 ***

blk2GetC:
	ld	ix, FS_HANDLES+FS_HANDLE_SIZE
	jp	fsGetC

blk2PutC:
	ld	ix, FS_HANDLES+FS_HANDLE_SIZE
	jp	fsPutC
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`; classic RC2014 setup (8K ROM + 32K RAM) and a stock Serial I/O module`
			`; The RAM module is selected on A15, so it has the range 0x8000-0xffff`
			`.equ RAMSTART 0x8000`
recipes/rc2014: add missing calls to fsInit Also, tighten RAM addresses. They were unecessarily loose. 2019-06-18 03:44:36 +10:00			`; kernel RAM usage, because of SDC, is a bit high and bring us almost to 0x8500`
			`; We allocate at least 0x200 bytes for the stack, which is why we have this`
			`; threshold.`
			`.equ RAMEND 0x8700`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`.equ PGM_CODEADDR RAMEND`
			`.equ ACIA_CTL 0x80 ; Control and status. RS off.`
			`.equ ACIA_IO 0x81 ; Transmit. RS on.`

			`jp init ; 3 bytes`

			`; * Jump Table *`
			`jp strncmp`
			`jp addDE`
			`jp addHL`
			`jp upcase`
			`jp unsetZ`
			`jp intoDE`
			`jp intoHL`
			`jp writeHLinDE`
			`jp findchar`
			`jp parseHex`
			`jp parseHexPair`
			`jp blkSel`
sdc: add second buffer 2019-06-07 12:16:28 +10:00			`jp blkSet`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`jp fsFindFN`
			`jp fsOpen`
			`jp fsGetC`
sdc: add second buffer 2019-06-07 12:16:28 +10:00			`jp cpHLDE ; approaching 0x38...`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00
			`; interrupt hook`
			`.fill 0x38-$`
			`jp aciaInt`

			`; * Jump Table (cont.) *`
			`jp parseArgs`
			`jp printstr`
blockdev: make implementors "random access" This huge refactoring remove the Seek and Tell routine from blockdev implementation requirements and change GetC and PutC's API so that they take an address to read and write (through HL/DE) at each call. The "PTR" approach in blockdev implementation was very redundant from device to device and it made more sense to generalize. It's possible that future device aren't "random access", but we'll be able to add more device types later. Another important change in this commit is that the "blockdev handle" is now opaque. Previously, consumers of the API would happily call routines directly from one of the 4 offsets. We can't do that any more. This makes the API more solid for future improvements. This change forced me to change a lot of things in fs, but overall, things are now simpler. No more `FS_PTR`: the "device handle" now holds the active pointer. Lots, lots of changes, but it also feels a lot cleaner and solid. 2019-06-05 01:53:02 +10:00			`jp _blkGetC`
			`jp _blkPutC`
			`jp _blkSeek`
			`jp _blkTell`
Add apps/sdct A new app to stress test the SD card driver. Also, accompanying this commit, changes solidifying the SD card driver so that stress tests actually pass :) 2019-06-11 05:13:46 +10:00			`jp printHexPair`
			`jp sdcGetC`
			`jp sdcPutC`
sdc: support 24-bit addressing Needed if we want to compile the kernel and zasm from within a SD card. I didn't go straight for 32-bit because it was significantly more complex and 24-bit give us 16M. Enough to go on for a while... 2019-06-16 03:41:20 +10:00			`jp blkGetC`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00
			`#include "err.h"`
			`#include "core.asm"`
			`#include "parse.asm"`
sdc: support 24-bit addressing Needed if we want to compile the kernel and zasm from within a SD card. I didn't go straight for 32-bit because it was significantly more complex and 24-bit give us 16M. Enough to go on for a while... 2019-06-16 03:41:20 +10:00			`.equ ACIA_RAMSTART RAMSTART`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`#include "acia.asm"`
			`.equ BLOCKDEV_RAMSTART ACIA_RAMEND`
recipes/rc2014/zasm: zasm can now assemble and write to file 2019-06-08 09:53:50 +10:00			`.equ BLOCKDEV_COUNT 4`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`#include "blockdev.asm"`
			`; List of devices`
blockdev: make implementors "random access" This huge refactoring remove the Seek and Tell routine from blockdev implementation requirements and change GetC and PutC's API so that they take an address to read and write (through HL/DE) at each call. The "PTR" approach in blockdev implementation was very redundant from device to device and it made more sense to generalize. It's possible that future device aren't "random access", but we'll be able to add more device types later. Another important change in this commit is that the "blockdev handle" is now opaque. Previously, consumers of the API would happily call routines directly from one of the 4 offsets. We can't do that any more. This makes the API more solid for future improvements. This change forced me to change a lot of things in fs, but overall, things are now simpler. No more `FS_PTR`: the "device handle" now holds the active pointer. Lots, lots of changes, but it also feels a lot cleaner and solid. 2019-06-05 01:53:02 +10:00			`.dw sdcGetC, sdcPutC`
recipes/rc2014/zasm: zasm can now assemble and write to file 2019-06-08 09:53:50 +10:00			`.dw blk1GetC, blk1PutC`
blockdev: make implementors "random access" This huge refactoring remove the Seek and Tell routine from blockdev implementation requirements and change GetC and PutC's API so that they take an address to read and write (through HL/DE) at each call. The "PTR" approach in blockdev implementation was very redundant from device to device and it made more sense to generalize. It's possible that future device aren't "random access", but we'll be able to add more device types later. Another important change in this commit is that the "blockdev handle" is now opaque. Previously, consumers of the API would happily call routines directly from one of the 4 offsets. We can't do that any more. This makes the API more solid for future improvements. This change forced me to change a lot of things in fs, but overall, things are now simpler. No more `FS_PTR`: the "device handle" now holds the active pointer. Lots, lots of changes, but it also feels a lot cleaner and solid. 2019-06-05 01:53:02 +10:00			`.dw blk2GetC, blk2PutC`
recipes/rc2014/zasm: zasm can now assemble and write to file 2019-06-08 09:53:50 +10:00			`.dw mmapGetC, mmapPutC`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00

			`.equ MMAP_START 0xe000`
			`#include "mmap.asm"`

blockdev: make implementors "random access" This huge refactoring remove the Seek and Tell routine from blockdev implementation requirements and change GetC and PutC's API so that they take an address to read and write (through HL/DE) at each call. The "PTR" approach in blockdev implementation was very redundant from device to device and it made more sense to generalize. It's possible that future device aren't "random access", but we'll be able to add more device types later. Another important change in this commit is that the "blockdev handle" is now opaque. Previously, consumers of the API would happily call routines directly from one of the 4 offsets. We can't do that any more. This makes the API more solid for future improvements. This change forced me to change a lot of things in fs, but overall, things are now simpler. No more `FS_PTR`: the "device handle" now holds the active pointer. Lots, lots of changes, but it also feels a lot cleaner and solid. 2019-06-05 01:53:02 +10:00			`.equ STDIO_RAMSTART BLOCKDEV_RAMEND`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`#include "stdio.asm"`

			`.equ FS_RAMSTART STDIO_RAMEND`
recipes/rc2014/zasm: zasm can now assemble and write to file 2019-06-08 09:53:50 +10:00			`.equ FS_HANDLE_COUNT 2`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`#include "fs.asm"`

			`.equ SHELL_RAMSTART FS_RAMEND`
			`.equ SHELL_EXTRA_CMD_COUNT 11`
			`#include "shell.asm"`
			`.dw sdcInitializeCmd, sdcFlushCmd`
			`.dw blkBselCmd, blkSeekCmd, blkLoadCmd, blkSaveCmd`
			`.dw fsOnCmd, flsCmd, fnewCmd, fdelCmd, fopnCmd`

blockdev: make implementors "random access" This huge refactoring remove the Seek and Tell routine from blockdev implementation requirements and change GetC and PutC's API so that they take an address to read and write (through HL/DE) at each call. The "PTR" approach in blockdev implementation was very redundant from device to device and it made more sense to generalize. It's possible that future device aren't "random access", but we'll be able to add more device types later. Another important change in this commit is that the "blockdev handle" is now opaque. Previously, consumers of the API would happily call routines directly from one of the 4 offsets. We can't do that any more. This makes the API more solid for future improvements. This change forced me to change a lot of things in fs, but overall, things are now simpler. No more `FS_PTR`: the "device handle" now holds the active pointer. Lots, lots of changes, but it also feels a lot cleaner and solid. 2019-06-05 01:53:02 +10:00			`#include "fs_cmds.asm"`
			`#include "blockdev_cmds.asm"`

recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`.equ PGM_RAMSTART SHELL_RAMEND`
			`#include "pgm.asm"`

			`.equ SDC_RAMSTART PGM_RAMEND`
			`.equ SDC_PORT_CSHIGH 6`
			`.equ SDC_PORT_CSLOW 5`
			`.equ SDC_PORT_SPI 4`
			`#include "sdc.asm"`

			`.out SDC_RAMEND`

			`init:`
			`di`
			`; setup stack`
			`ld hl, RAMEND`
			`ld sp, hl`
			`im 1`
			`call aciaInit`
			`ld hl, aciaGetC`
			`ld de, aciaPutC`
			`call stdioInit`
recipes/rc2014: add missing calls to fsInit Also, tighten RAM addresses. They were unecessarily loose. 2019-06-18 03:44:36 +10:00			`call fsInit`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`call shellInit`
			`ld hl, pgmShellHook`
			`ld (SHELL_CMDHOOK), hl`

			`xor a`
blockdev: make selection structure opaque I'm about to change that structure and I don't want fs to be messed up by this. I'm proceeding step by step... 2019-06-04 23:56:36 +10:00			`ld de, BLOCKDEV_SEL`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`call blkSel`

			`ei`
			`jp shellLoop`

recipes/rc2014/zasm: zasm can now assemble and write to file 2019-06-08 09:53:50 +10:00			`; * blkdev 1: file handle 0 *`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00
recipes/rc2014/zasm: zasm can now assemble and write to file 2019-06-08 09:53:50 +10:00			`blk1GetC:`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`ld ix, FS_HANDLES`
			`jp fsGetC`

recipes/rc2014/zasm: zasm can now assemble and write to file 2019-06-08 09:53:50 +10:00			`blk1PutC:`
recipe/rc2014/zasm: new recipe 2019-06-04 03:34:16 +10:00			`ld ix, FS_HANDLES`
			`jp fsPutC`
recipes/rc2014/zasm: zasm can now assemble and write to file 2019-06-08 09:53:50 +10:00
			`; * blkdev 2: file handle 1 *`

			`blk2GetC:`
			`ld ix, FS_HANDLES+FS_HANDLE_SIZE`
			`jp fsGetC`

			`blk2PutC:`
			`ld ix, FS_HANDLES+FS_HANDLE_SIZE`
			`jp fsPutC`