A proposed DMA-like I/O system for DCPU-16

	IOR target, location		; Reads a word from the I/O location to the given target register/memory
	IOW location, source		; Writes the word from the source register/memory to the I/O location

	IOR X, 0x0000			; Read the keyboard location and store it in X
	IFN X, 0			; If it's not zero...
		SET PC, gotkey		;    ...we got a key, so do something with it.

read_keyboard:
	SET PUSH, X			; Save X - which is the address of the target buffer at entry
	SET A, 0			; The number of characters read
	
readchar:
	IOR [X], 0x0000			; Read the keyboard location and store it in X
	IFE [X], 0			; If it's zero...
		SET PC, endread		;    ...we're done, so finish up
	
	ADD A, 0x0001			; Increment A and X
	ADD X, 0x0001
	IFN A, Y			; If our buffer isn't full loop again
		SET PC, readchar
		
endread:
	SET X, POP			; Restore X and return.   A on return has the number of keystrokes read
	SET PC, POP

	IOW 0x0008, 0x6000		; Write the location of your video buffer to the Transfer Video Buffer location - it'll do the rest.

wait_for_screen:
	SET PUSH, A			; Save A
wfsloop:
	IOR A, 0x0008			; Read the Transfer Video Buffer status
	IFN A, 0x00			; If it's doing something...
		SUB PC, 3		;    ...jump back to wfsloop

	SET A, POP			; Restore A
	SET PC, POP			; Return from subroutine

animate:
	SET PUSH, A			; Save A and Y
	SET PUSH, Y
	
animate_sequence:
	SET A, X			; Set A to the beginning of the array
	
frame_sequence:
	IFE [A],0			; If we're at the end of the array...
		SET PC, anim_checkend	;	Go see if we need to run through it again.
	JSR wait_for_screen		; Wait to see if the screen is done it's previous transfer
	IOW 0x0008, [A]			; Start a new transfer of the current frame
	SET PC, frame_sequence		; Loop for the next frame
	
anim_checkend:
	SUB Y, 1			; Decrement the animate loop counter
	IFN Y, 0			; If it's not yet zero, run the animate loop again
		SET PC, animate_sequence
	
	SET Y, POP			; Restore Y and A and return
	SET A, POP
	JMP PC, POP

scroll_vbuffer:
	JSR wait_for_screen		; Wait to see if the screen is done it's previous transfer
	SET PUSH, Y			; Save the Y register
	SHL Y, 5			; Multiply by 32 - since each line is 32 chars wide
	ADD Y, X			; Add the start of the video buffer to the offset
	IOW 0x0008, Y			; Scroll the screen to line Y
	SET Y, POP
	SET PC, POP

wait_for_io:
	SET PUSH, A			; Save A
wfioloop:
	IOR A, X			; Read the DMA transfer/action status from location X
	IFN A, 0x00			; If it's doing something...
		SUB PC, 3		;    ...jump back to wfioloop

	SET A, POP			; Restore A and return
	SET PC, POP

glyphs:
	DAT	0x4143, 0xff81, 0x8181, 0x8181, 0x81ff, 0xff81, 0xc3a5, 0xa5c3, 0x81ff, 0xff81, 0x8199, 0x9981, 0x81ff

set_checkbox_glyphs:
	SET PUSH, X			; Save X
	SET X, 0x000b			; Write Character Glyphs Port

	JSR wait_for_io			; Wait for any I/O to complete on port 0x0004
	IOW X, glyphs			; Set the 'A', 'B', and 'C' glyphs
	
	SET X, POP			; Restore X and return
	SET PC, POP

restore_checkbox_glyphs:
	SET PUSH, X			; Save X
	SET X, 0x000c			; Restore Character Glyphs Port

	JSR wait_for_io			; Wait for any I/O to complete on port 0x0005
	IOW X, 0x4143			; Restore the 'A' - 'C' glyphs
	
	SET X, POP			; Restore X and return
	SET PC, POP

; seek_sector - Seeks to the sector given in Y.
;    Returns zero if successful in A, otherwise it returns 1, and Y is changed to
;    the actual sector Seek says we're pointing to.
;
seek_sector:
	SET PUSH, X			; Save X
	SET X, 0x0010			; Seek Disk Location
	
	IOR A, X			; Read the current sector
	IFE A, Y			; If it's already the specified sector...
		SET PC, seek_complete	; Return that the seek was completed successfully
	
	IOW X, Y			; Start SEEKing to the requested sector
	
seek_wait:
	IOR A, X			; Read the current seek sector
	IFG A, 0x7fff			; If it's greater than 0x7fff (ie. has the high bit set)
		SET PC, seek_wait	; Loop on checking the seek sector again

	IFE A, Y			; If the final seek sector was the specified sector...
		SET PC, seek_complete	; Return that the seek was completed successfully
		
	SET Y, A			; Return a Seek error
	SET A, 1
	SET X, POP
	SET PC, POP
	
seek_complete:
	SET A, 0			; Return Seek Success
	SET X, POP
	SET PC, POP
	
; rw_sector - Seeks to the sector given in Y, and reads or writes that sector into the address given in Z.
;    The decision of whether it reads or writes is based on the I/O location specified in X - if it's 0x0011,
;    it will read, if it's 0x0012, it will write.
;    Returns zero if successful in A.   If unsuccessful due to a seek error, A will be 1 and Y will be
;    changed to the current seek sector.   If unsuccessful due to a read error, A will be 2 or more.
;
rw_sector:
	IOR A, X			; Read the current read/write status
	IFE A, 1			; If it's a 1, we're still doing a read/write...
		SET PC, rw_sector	; So loop on checking the read/write status again

	JSR seek_sector			; Seek to the desired sector
	IFE A, 0			; If the seek was successful...
		JMP do_rw_sector	; Do the actual read/write
	SET PC, POP			; Otherwise pass the seek error back up
	
do_rw_sector:
	IOW X, Z			; Start the read/write operation, storing the sector at the address in Z

rw_wait:
	IOR A, X			; Read the current read/write status
	IFE A, 1			; If it's a 1, we're still doing a read/write...
		SET PC, rw_wait		; So loop on checking the read/write status again
	
	SET PC, POP			; At this point, A is either 0 (success) or >1 (failed with error) so
					;    cleanup and return
	
; read_sector - Seeks to the sector given in Y, and reads from that sector into the address given in Z
;    Returns zero if successful in A.   If unsuccessful due to a seek error, A will be 1 and Y will be
;    changed to the current seek sector.   If unsuccessful due to a read error, A will be 2 or more.
;
read_sector:
	SET PUSH, X			; Save X
	SET X, 0x0011			; Read Disk Location
	JSR rw_sector			; Do the write
	SET X, POP
	SET PC, POP

; write_sector - Seeks to the sector given in Y, and writes to that sector from the address given in Z
;    Returns zero if successful in A.   If unsuccessful due to a seek error, A will be 1 and Y will be
;    changed to the current seek sector.   If unsuccessful due to a write error, A will be 2 or more.
;
write_sector:
	SET PUSH, X			; Save X
	SET X, 0x0012			; Write Disk Location
	JSR rw_sector			; Do the write
	SET X, POP
	SET PC, POP

; copy_drive0_to_drive1 - Copies the disk in drive0 to drive1, using the buffer in X, which has a length in Y,
;	as a transfer buffer.  The transfer buffer must be two time the size of a sector (or higher, although it
;	doesn't help to
;	be any higher as it only uses two buffers...)
;
;	Returns A = 0 if successful, A = 1 if the buffer given is too small, A = 2 if the disks aren't the same
;	size, or A = 3 if some kind of seek, read, or write error occurred
;
copy_drive0_to_drive1:

;
; Initial setup - we use almost every register here, and need to restore all but A, which
; is the return value
;
	SET PUSH, B			; Save B - we'll use it as a scratch register
	SET PUSH, C			; Save C - we'll use it to store the status flag mask for the Seek
	SET PUSH, I			; Save I - we'll use it as drive 0 next sector number
	SET PUSH, J			; Save J - we'll use it as drive 1 next sector number
	SET PUSH, X			; Save X - that's our first buffer pointer
	SET PUSH, Y			; Save Y - we'll use it as the second buffer pointer
	SET PUSH, Z			; Save Z - we'll use it as the maximum sector

;
; Determine the size of buffer we're going to need to hold two sectors in memory
; and return an error if the buffer given is too small.
;
cdd_checkbuffer:
	IOW, 0x0013, 0			; Drive select zero
	IOR A, 0x0014			; Get drive status
	AND A, 0x007f			; Get drive sector size
	SHL A, 0x09			; Multiply by 512 to get 2x sector word size
	IFN A, Y			; If the target buffer is the same size
		IFG Y, A		;    as 2x the sector or greater than that
			SET PC, cdd_checksector	;    continue.  (Yes this looks weird - work it out. :D )
			
cdd_buffertoosmall:
	SET A, 1			; If we get here, then the buffer is too small, so return an error
	SET PC, cdd_ret

;
; Make sure both drives are using the same sector size.   If not, return an error
;		
cdd_checksector:
	IOW, 0x0013, 1			; Drive select one
	IOR B, 0x0014			; Get drive status
	AND B, 0x007f			; Get drive sector size
	SHL B, 0x09			; Multiply by 256 to get 2x sector word size (to match A)
	IFE A, B			; If the two drives are using the same sector size, continue
		SET PC, cdd_setbuffers
		
cdd_notsamesize:
	SET A, 2			; If we get here, then the disks aren't the same size, so return an error
	SET PC, cdd_ret
	
;
; At this point we know the sector size, so we can set up Y to be the second buffer
; pointer.   We need two buffers because we'll be reading to one while writing from
; the other.
;
cdd_setbuffers:
	SHR A, 1			; Shift A back to get the actual sector size
	SET Y, X			; Set up the second buffer pointer in Y
	ADD Y, A			;    by adding the sector size to X

;
; Seek both drives to the end of the disk.   This is used to determine the number of
; sectors on each drive.
;	
cdd_seekend:	
	IOW, 0x0013, 0			; Drive select zero
	IOW, 0x0010, 0x7fff		; Seek drive 0 to the end of disk
	IOW, 0x0013, 1			; Drive select one
	IOW, 0x0010, 0x7fff		; Seek drive 1 to the end of disk
	SET C, 0x8000			; Bit Mask for the seek status bit

;
; Now wait for both seeks to complete, and check to make sure they have
; the same number of sectors, and store that number in Z for later comparison.
; If not, return an error.   Because a seek while a read or write operation
; is in progress will wait until that operation completes, this also guarantees
; that there was no outstanding read or write on either drive.
;	
cdd_waitsize:
	IOW, 0x0013, 0			; Drive select zero
	IOR, A, 0x0010			; Get seek status
	AND A, C			; Get the status bit
	IOW, 0x0013, 1			; Drive select one
	IOR, B, 0x0010			; Get seek status
	AND B, C			; Get the status bit
	IFE A, 0			; If either bit is set
		IFN B, 0		;    loop again.  (Hint - IFx like this works out to 
			SET PC, cdd_waitsize	;    if !(cond1) OR (cond2) action)

	IFE A, B			; If the numbers of sectors aren't the same,
		SET PC, cdd_notsamesize	;	report that the disks aren't the same size
		
	SET Z, A			; Save the highest sector number in Z, so we know when the
					;    copy will be done later.

;
; Seek both disks back to the beginning, and set up the B and C registers to reflect
; the next read and next write sector, respectively						
;
cdd_seekstart:	
	IOW, 0x0013, 1			; Drive select one
	IOW, 0x0010, 0x7fff		; Seek drive 1 to the start of disk
	IOW, 0x0013, 0			; Drive select zero
	IOW, 0x0010, 0x7fff		; Seek drive 0 to the start of disk
	SET I, 0			; Set the target sector for drive 0 to 0
	SET J, 0			; Set the target sector for drive 1 to 0

	
;
; Okay, now we can get into the main copy loop.   If we're done with the copy, because the next
; read sector is beyond the end of the disk, exit.   Otherwise run through the copy process for one
; sector, increment the sector counters, and swap the buffer pointers we're using for the next pass,
; and loop again.
;
cdd_mainloop:
	IFG I, Z			; Are we done? Go to exit
		SET PC, cdd_done
		
	JSR cdd_do_copy			; The meat of the copy process
	IFE A, 0			; If it didn't have an error, continue
		SET PC, cdd_nextsector	

cdd_diskerror:
	SET A, 3			; If we get here, then we had a disk error, so return an error
	SET PC, cdd_ret		

cdd_nextsector:
	ADD I, 1			; Increment the seek read counter.  The read operation should have incremented the Seek position on disk when it finished.
	ADD J, 1			; Increment the seek write counter.  The write operation will increment the Seek position on disk when done.
	SET PUSH, X			; 3 instruction SWAP X,Y using the stack
	SET X, Y
	SET Y, POP
	SET PC, cdd_nextsector	; Loop

;
; We're not quite done at this point -- the last write is still running, so we have to wait for that
; to finish before we can return success.
;
cdd_done:	
	IOR A, 0x0012			; Get write status on drive one
	IFE A, 1			; If it's still writing...
		SET PC, cdd_done	;    wait until it's done
	IFN A, 0			; If it had a write error - report a disk error
		SET PC, cdd_diskerror

;
; Finally, clean up and return success
;
	SET A, 0
	
cdd_ret:
	SET Z, POP
	SET Y, POP
	SET X, POP
	SET J, POP
	SET I, POP
	SET C, POP
	SET B, POP
	SET PC, POP

	
; cdd_do_copy - This is the inner disk copy routine.   It's job is to read sector I from drive 0,
;	into the buffer specified in X, and write it to sector J of drive 1.   The drives are expected
;	to already have Seeked to those sectors, and it uses I and J to check before reading or writing
;	from/to them.   Register C is expected to contain 0x8000 which is a mask bit for checking to see
;	if a Seek operation is in progress.
;
;	At entry, Seeks on either drive, or a write on drive 1 from a previous call to this function might
;	be in progress, but the 0 drive is assumed to have completed it's previous read operation.
;
;	The function waits for the previous seek to be done on drive 0, confirms at that point that the
;	drive is pointing to the sector given in register I, then begins the read operation for that sector,
;	into the buffer pointed to by X.   It will then wait until any previous write or seek on drive 1 is
;	complete, and the read it just scheduled on drive 0 to be complete as well, and when all three are
;	complete and it confirms drive one is pointing to the sector given in register J, it writes out the
;	buffer pointed to by X into that sector.   It returns without waiting for that write to complete,
;	leaving drive select set to 1.
;
;	By alternating buffers, you can call this immediately after to start the read/write process on the
;	next sector, as it will be reading sector N+1 on drive 0 while writing sector N on drive 1. 
;
;	If a disk error is detected on any Seek, Read or Write, it stops the copy and returns 1 in register A,
;	otherwise it returns 0 in register A.

cdd_do_copy:
	IOW, 0x0013, 0			; Drive select zero	
	
;
; At this point, we know we need to read a sector.   But we could be in the middle of
; a seek right now, so we need to check for that.   If we end up in a situation where the drive isn't
; seeking, but isn't pointing to the expected sector, then we need to stop and return an error.
;		
cdd_waitseekread:
	IOR A, 0x0010			; Get seek status on drive zero
	IFE A, I			; If we're pointing to the right sector (which after the initial seek ought to be always true)
		SET PC, cdd_read	;    go to reading the sector
	AND A, C			; If the high bit is still set...
	IFN A, 0			;    loop back until the seek completes
		SET PC, cdd_waitseekread

cdd_copyerror:
	SET A, 1			; If we get here, then return a disk error
	SET PC, POP

;
; We know we've done a successful seek now, so read the sector into the currently selected buffer,
; and increment the next seek location for reads.
;
cdd_read:
	IOW 0x0011, X			; Start reading from the current drive 0 sector to the first buffer

;
; Are we ready to write yet?  First, there might be an outstanding write going on, so lets check for
; that and wait for it to complete before we continue, and report an error if it fails.
;	
	IOW, 0x0013, 1			; Drive select one
cdd_waitwrite:
	IOR A, 0x0012			; Get write status on drive one
	IFE A, 1			; If it's still writing...
		SET PC, cdd_waitwrite	;    wait until it's done
	IFN A, 0			; If it had a write error - report a disk error
		SET PC, cdd_copyerror

;
; If we weren't writing, we might be seeking - especially first time through.  If we end up in a situation
; where the drive isn't seeking, but isn't pointing to the expected sector, then we need to stop and report
; a disk error.
;				
cdd_waitseekwrite:
	IOR A, 0x0010			; Get seek status on drive one
	IFE A, J			; If we're pointing to the right sector (which after the initial seek ought to be always true)
		SET PC, cdd_waitread	;    go to waiting for the read to finish
	AND A, C			; If the high bit is still set...
	IFN A, 0			;    loop back until the seek completes
		SET PC, cdd_waitseekwrite
	SET PC, cdd_copyerror		; Otherwise report a disk error

;
; The previous write (if any) is done, and we're ready to write - but we could still be reading.  If we are,
; then we need to wait for the read to finish, and should report a disk error if it fails.
;
cdd_waitread:
	IOW 0x0013, 0			; Drive select drive 0
	
cdd_waitread1:
	IOR A, 0x0011			; Get read status on drive zero
	IFE A, 1			; If it's still reading...
		SET PC, cdd_waitread1	;    wait until it's done
	IFN A, 0			; If it had a write error - report a disk error
		SET PC, cdd_copyerror
		
;
; At this point, the next sector has been read in the currently selected buffer, so write it to the disk,
; and increment the next seek location for writes.
;
cdd_write:
	SET 0x0013, 1		; Drive select drive 1
	IOW 0x0012, X		; Start writing to the current drive 1 sector from the first buffer

;
; We don't need to wait for the write to complete here.  Just return and let it start the next loop on
; reading
;
	SET A, 0
	SET PC, POP

;
; romboot - This code, located at address zero, is copied from ROM into RAM at power up time,
; and boots off of a floppy inserted into drive 0.   If no floppy exists in drive 0, or we have
; a seek or read failure, it will fail by going into an infinite loop.
;
@0x0000:

;
; First, we want to copy the main boot code to an address above 0x8000, since
; when we read the first sector of the boot drive, it will overwrite this initial
; code
;
; Yes, this is an inefficient copy routine, but it's written for clarity more than speed
;
	SET X, bootstart	; Start of actual boot code
	SET Y, bootend		; End of actual boot code
	SET Z, 0xf000		; Relocation target
	
bootcopy:
	SET [Z], [X]		; Relocate a word of the boot code
	ADD X, 1		; Increment X and Z
	ADD Z, 1
	IFN X, Y		; If we aren't done relocating it...
		SUB PC, 5 	;    loop back to bootcopy.
		
	SET PC, 0xf000		; Jump to bootstart at it's relocated address
	
;
; Since everything from this point on is relocated, it cannot use any fixed addresses,
; and all branches must be relative
;
bootstart:
	
	IOW 0x13, 0		; Drive select drive 0
	SET Y, 0x8000		; Seek status bit
	
;
; Seek to sector 0.  Technically, it's probably already there.
;
	IOW 0x10, 0		; Seek to sector 0
bootseek:
	IOR X, 0x10		; Get seek sector status
	IFE X, 0		; If we're done
		ADD PC,4	;    jump to bootread
	AND X, Y
	IFE X, 0		; If we're not seeking and not on sector 1,
		SUB PC, 1	;    fail by going into an infinite loop
	SUB PC, 7		; Loop back to bootseek

;
; Read sector 0 into address 0, and wait for it to complete
;
bootread:
	IOW	0x11, 0		; Read sector 0 into address 0
	
bootwait:
	IOR X, 0x0011		; Get read sector status
	IFE X, 1		; If we're still reading
		SUB PC, 3	;    jump back to bootwait
	IFN X, 0		; If we weren't successful
		SUB PC, 1	;    fail by going into an infinite loop

;
; At this point, the read is done, so jump to the start of the read sector
; to continue the boot.
;
bootdone:
	SET PC, 0

;
; romboot - This code, located at address zero, is copied from ROM into RAM at power up time,
; and boots off of firmware if it's available, enabled, and not empty, otherwise it attempts to
; boot from a floppy inserted into drive 0.   If in that case, no floppy exists in drive 0, or
; we have a seek or read failure, it will fail by going into an infinite loop.
;
@0x0000:

;
; First, we want to copy the main boot code to an address above 0x8000, since
; when we read firmware or the floppy, it will overwrite this initial code
;
; Yes, this is an inefficient copy routine, but it's written for clarity more than speed
;
	SET X, bootstart	; Start of actual boot code
	SET Y, bootend		; End of actual boot code
	SET Z, 0xf000		; Relocation target
	
bootcopy:
	SET [Z], [X]		; Relocate a word of the boot code
	ADD X, 1		; Increment X and Z
	ADD Z, 1
	IFN X, Y		; If we aren't done relocating it...
		SUB PC, 5 	;    loop back to bootcopy.
		
	SET PC, 0xf000		; Jump to bootstart at it's relocated address
	
;
; Since everything from this point on is relocated, it cannot use any fixed addresses,
; and all branches must be relative
;
bootstart:

	SET Y, 0x00f1		; FW Bank Select register
	SET Z, 0x00f2		; FW Read register
	
	SET X, 0		; Clear out X in case firmware doesn't exist
	IOR	X, 0xf0		; Get the firmware status register
	AND X, 0x0200		; Check to see if the firmware is enabled
	IFE X, 0		; If it's not enabled or doesn't exist, jump to bootfloppy
		ADD PC, 10

	IOW Y, 0		; Select Firmware bank 0
	IOW Z, 0		; and read it to address 0
	
bootfwread:
	IOR X, Z		; Check to see if the read is done
	IFE X, 1		; If not, loop back to bootfwread
		SUB PC, 3
	IFN X, 0		; If it had an error, jump to bootfloppy
		ADD PC, 3
	IFE [X], 0		; If the firmware was empty address 0 will be zero, so jump to bootfloppy
		ADD PC, 1
	
bootfwdone:
	SET PC, 0		; Jump to the loaded firmware
	
;
; Firmware couldn't load, so boot from floppy
;
bootfloppy:
	IOW 0x13, 0		; Drive select drive 0
	SET Y, 0x8000		; Seek status bit
	
;
; Seek to sector 0.  Technically, it's probably already there.
;
	IOW 0x10, 0		; Seek to sector 0
bootseek:
	IOR X, 0x10		; Get seek sector status
	IFE X, 0		; If we're done
		ADD PC,4	;    jump to bootread
	AND X, Y
	IFE X, 0		; If we're not seeking and not on sector 1,
		SUB PC, 1	;    fail by going into an infinite loop
	SUB PC, 7		; Loop back to bootseek

;
; Read sector 0 into address 0, and wait for it to complete
;
bootread:
	IOW	0x11, 0		; Read sector 0 into address 0
	
bootwait:
	IOR X, 0x0011		; Get read sector status
	IFE X, 1		; If we're still reading
		SUB PC, 3	;    jump back to bootwait
	IFN X, 0		; If we weren't successful
		SUB PC, 1	;    fail by going into an infinite loop

;
; At this point, the read is done, so jump to the start of the read sector
; to continue the boot.
;
bootdone:
	SET PC, 0

	STM iolocation			; Sets the I/O Message Location register M to iolocation
	GTM target			; Gets the current value of the I/O Message Location register and stores it in target
	IOW value			; Writes the given value to the I/O Message Location M
	IOR target			; Reads the I/O Message Location M and stores it in target

	aaaaaaoooooo0000		- Normal special opcode format, where certain opcodes require...
	bbbbbbccccccdddd		- ...a second word which defines operands b, c, and a 4 bit added constant d

	IO target,source,location,direction

	CPY target,source,len		; Copies the len length buffer from source to target, @ 1 or 2 cycles per word copied
	FIL target,source,len		; Fills the len length buffer at target with the source value, @ 1 cycles per word filled
	FND target,source,len,svr	; Searches for source in target buffer, for up to len words, leaving the offset found or
					;    len if not found, in the register specified by svr, @ 1 cycle per word checked