X-Git-Url: http://cloudbase.mooo.com/gitweb/z180-stamp.git/blobdiff_plain/5f7f3586b0444116d5c1340465ecae8d6daa2461..b51d2360e5a32408daae39b1c311868d0d34374c:/avr/z180-serv.c

diff --git a/avr/z180-serv.c b/avr/z180-serv.c
index c80daeb..58843fd 100644
--- a/avr/z180-serv.c
+++ b/avr/z180-serv.c
@@ -18,20 +18,15 @@
 #include "debug.h"
 #include "print-utils.h"
 #include "z180-serv.h"
+#include "timer.h"
+#include "time.h"
+#include "bcd.h"
+#include "rtc.h"
 
-/*--------------------------------------------------------------------------*/
-
+#define DEBUG_CPM_SDIO	0	/* set to 1 to debug */
 
-uint8_t z80_get_byte(uint32_t adr)
-{
-	uint8_t data;
-
-	z80_bus_cmd(Request);
-	data = z80_read(adr);
-	z80_bus_cmd(Release);
-
-	return data;
-}
+#define debug_cpmsd(fmt, args...)		                                            \
+	debug_cond(DEBUG_CPM_SDIO, fmt, ##args)
 
 
 /*--------------------------------------------------------------------------*/
@@ -102,28 +97,182 @@ void do_msg_echo(uint8_t subf, int len, uint8_t * msg)
 	msg_xmit(1, 3, len, msg);
 }
 
+/* get timer */
+void do_msg_get_timer(uint8_t subf, int len, uint8_t * msg)
+{
+	uint32_t time_ms = (len >= 4) ? *(uint32_t *) msg : 0;
+
+	time_ms = get_timer(time_ms);
+	msg_xmit(3, subf, sizeof(time_ms), (uint8_t *) &time_ms);
+}
+
 /* ---------------------------------------------------------------------------*/
 
-#define MAX_DEVICE	2
-#define MAX_DRIVE	2
-#define BLOCK_SIZE	512
+#define CPM_DAY_OFFSET ((1978-1900) * 365 + 19)		/* 19 leap years */
 
-struct fat_device_s {
-	FATFS dd;
-	bool active;
-};
+/*
+ * Convert CP/M time stamp to a broken-down time structure
+ *
+ */
+int mk_date_time (int len, uint8_t *msg, struct tm *tmp)
+{
+	time_t stamp;
+
+	if (len != 5)
+		return -1;
+
+	/* days since 2000-01-01 */
+	long days = msg[3] + (msg[4] << 8) - 8036;
+
+	if (days < 0)
+		return -1;
+
+	stamp = days * ONE_DAY;
+	stamp += bcd2bin(msg[0]);
+	stamp += bcd2bin(msg[1]) * 60 ;
+	stamp += bcd2bin(msg[2]) * 3600L;
+	gmtime_r(&stamp, tmp);
+	return 0;
+}
+
+void mk_cpm_time(struct tm *tmp, uint8_t cpm_time[5])
+{
+	uint16_t days = 1;
+	uint_fast8_t leap=2;
+
+	for (int year=78; year < tmp->tm_year; year++) {
+		days = days + 365 + (leap == 0);
+		leap = (leap+1)%4;
+	}
+	days += tmp->tm_yday;
+
+	cpm_time[0] = bin2bcd(tmp->tm_sec);
+	cpm_time[1] = bin2bcd(tmp->tm_min);
+	cpm_time[2] = bin2bcd(tmp->tm_hour);
+	cpm_time[3] = days;
+	cpm_time[4] = days >> 8;
+}
+
+/* get/set cp/m time */
+void do_msg_get_set_time(uint8_t subf, int len, uint8_t * msg)
+{
+	struct tm t;
+	uint8_t cpm_time[5];
+	int rc;
+
+	memset(cpm_time, 0, ARRAY_SIZE(cpm_time));
 
+	switch (subf) {
+	case 3:			/* set date & time */
+		/* initialize t with current time */
+		rc = rtc_get (&t);
+
+		if (rc >= 0) {
+			/* insert new date & time */
+			if (mk_date_time (len, msg, &t) != 0) {
+				my_puts_P(PSTR("## set_time: Bad date format\n"));
+				break;
+			}
+
+			time_t time;
+			time = mk_gmtime(&t);
+			gmtime_r(&time, &t);
+
+			/* and write to RTC */
+			rc = rtc_set (&t);
+			if(rc)
+				my_puts_P(PSTR("## set_time: Set date failed\n"));
+		} else {
+			my_puts_P(PSTR("## set_time: Get date failed\n"));
+		}
+		/* FALL TROUGH */
+	case 2:			/* get date & time */
+		rc = rtc_get (&t);
+		if (rc >= 0) {
+			time_t time;
+			time = mk_gmtime(&t);
+			//mktime(&t);
+			gmtime_r(&time, &t);
+
+			mk_cpm_time(&t, cpm_time);
+		} else {
+			my_puts_P(PSTR("## get_time: Get date failed\n"));
+		}
+		break;
+	}
+
+	msg_xmit(3, subf, sizeof(cpm_time), cpm_time);
+}
+
+/* ---------------------------------------------------------------------------*/
+
+#define MAX_DRIVE	4
+#define BLOCK_SIZE	512
+//#define TPA_BASE	0x10000
+//#define COMMON_BASE	0xC000
 
 struct cpm_drive_s {
 	uint8_t drv;
 	uint8_t device;
 	char *img_name;
+	bool dirty;
 	FIL fd;
 };
 
 static uint8_t disk_buffer[BLOCK_SIZE];
-static struct fat_device_s device_table[MAX_DEVICE];
 static struct cpm_drive_s drv_table[MAX_DRIVE];
+static int handle_cpm_drv_to;
+
+#define f_dirty(fp) ((fp)->fs->wflag != 0)
+
+
+int cpm_drv_to(int state)
+{
+	static uint32_t ts;
+
+	switch(state) {
+	case 0:
+		break;
+
+	case 1:
+		ts = get_timer(0);
+		state = 2;
+		break;
+
+	case 2:
+		if (get_timer(ts) > 1000) {
+			for (uint_fast8_t i=0; i < MAX_DRIVE; i++) {
+//				if (&drv_table[i].fd && f_dirty(&drv_table[i].fd)) {
+				if (drv_table[i].dirty) {
+					f_sync(&drv_table[i].fd);
+					drv_table[i].dirty = false;
+					debug_cpmsd("## %7lu f_sync: %c:\n", get_timer(0), i+'A');
+				}
+			}
+			state = 0;
+		}
+	}
+	return state;
+}
+
+
+void msg_cpm_result(uint8_t subf, uint8_t rc, int res)
+{
+	uint8_t result_msg[3];
+
+	if (res)
+		rc |= 0x80;
+
+	result_msg[0] = rc;
+	result_msg[1] = res;
+	result_msg[2] = res >> 8;
+
+	if (rc) {
+		debug_cpmsd("###%7lu  error rc: %.02x, res: %d\n", get_timer(0), rc, res);
+	}
+
+	msg_xmit(2, subf, sizeof(result_msg), result_msg);
+}
 
 /*
  	db	2	; disk command
@@ -137,36 +286,21 @@ void do_msg_cpm_login(uint8_t subf, int len, uint8_t * msg)
 {
 
 	FRESULT res = 0;
-	uint8_t rc = 0;
 	uint8_t drv;
 	char *np;
-	uint8_t result_msg[3];
 
 	(void)subf;
 
 	if (len != 5) {     /* TODO: check adrv, rdrv */
-		rc = 0x01;
-		goto out;
+		return msg_cpm_result(subf, 0x01, res);
 	}
 
-	debug("\n##  login: %c:\n", msg[0]+'A');
+	debug_cpmsd("\n## %7lu  login: %c:\n", get_timer(0), msg[0]+'A');
 
 
 	drv = msg[0];
 	if ( drv>= MAX_DRIVE) {
-		rc = 0x02;
-		goto out;
-	}
-
-	/* TODO: this has to be done somewhere globaly */
-
-	if (!device_table[0].active) {
-		f_mount(&device_table[0].dd, "0:", 0);
-		device_table[0].active = true;
-	}
-	if (!device_table[1].active) {
-		f_mount(&device_table[1].dd, "1:", 0);
-		device_table[1].active = true;
+		return msg_cpm_result(subf, 0x02, res);
 	}
 
 /*
@@ -174,150 +308,131 @@ void do_msg_cpm_login(uint8_t subf, int len, uint8_t * msg)
 */
 
 	if (drv_table[drv].img_name != NULL) {
-		debug("##  close: '%s'\n", drv_table[drv].img_name);
+		debug_cpmsd("## %7lu  close: '%s'\n", get_timer(0), drv_table[drv].img_name);
 		f_close(&drv_table[drv].fd);
+		drv_table[drv].dirty = false;
 		free(drv_table[drv].img_name);
 		drv_table[drv].img_name = NULL;
 	}
 
 	strcpy_P((char *)disk_buffer, PSTR("dsk0"));
 	disk_buffer[3] = msg[0] + '0';
-	if (((np = getenv((char*)disk_buffer)) == NULL) ||
+	if (((np = getenv_char((char*)disk_buffer)) == NULL) ||
 			((drv_table[drv].img_name = strdup(np)) == NULL)) {
-		rc = 0x03;
-		goto out;
+		return msg_cpm_result(subf, 0x03, res);
 	}
 
 
 	res = f_open(&drv_table[drv].fd, drv_table[drv].img_name,
 			FA_WRITE | FA_READ);
 
-    debug("##   open: '%s', (env: '%s'), res: %d\n",
+    debug_cpmsd("## %7lu   open: '%s', (env: '%s'), res: %d\n", get_timer(0),
 			drv_table[drv].img_name, disk_buffer, res);
 
-out:
-
-	if (res)
-		rc |= 0x80;
-
-	result_msg[0] = rc;
-	result_msg[1] = res;
-	result_msg[2] = res >> 8;
-
-	if (rc) {
-		debug("##   error    rc: %.02x, res: %d\n", rc, res);
-	};
-
 	/* send  result*/
-	msg_xmit(2, subf, sizeof(result_msg), result_msg);
+	msg_cpm_result(subf, 0x00, res);
 }
 
 
 /*
  	db	2	; disk command
 	ds	1	; subcommand (login/read/write)
-	ds	1	; @adrv (8 bits)	+0
-	ds	1	; @rdrv (8 bits)	+1
-	ds	1	; @cnt  (8 bits)	+2
-	ds	2	; @trk (16 bits)	+3
-	ds	2	; @sect(16 bits)	+5
+	ds	1	; @adrv (8 bits)		+0
+	ds	1	; @rdrv (8 bits)		+1
+	ds	2	; @trk (16 bits)		+2
+	ds	2	; @sect(16 bits)		+4
+	ds	1	; @cnt  (8 bits)		+6
 	ds	3	; phys. transfer addr	+7
 */
 
+#define ADRV	0
+#define RDRV	1
+#define TRK		2
+#define SEC		4
+#define CNT		6
+#define ADDR	7
+
 void do_msg_cpm_rw(uint8_t subf, int len, uint8_t * msg)
 {
 	uint8_t drv;
 	uint32_t addr;
 	uint32_t pos;
-
+	uint8_t secs;
 	bool dowrite = (subf == 2);
 	FRESULT res = 0;
 	uint8_t rc = 0;
 	bool buserr = 0;
-	uint8_t result_msg[3];
 
 	if (len != 10) {     /* TODO: check adrv, rdrv */
-		rc = 0x01;
-		goto out;
+		return msg_cpm_result(subf, 0x01, res);
 	}
 
-	drv = msg[0];
+	drv = msg[ADRV];
 	if ( drv>= MAX_DRIVE) {
-		rc = 0x02;
-		goto out;
+		return msg_cpm_result(subf, 0x02, res);
 	}
 
-	addr = ((uint32_t)msg[9] << 16) + ((uint16_t)msg[8] << 8) + msg[7];
-
-	/* bytes = BLOCK_SIZE; */			/* TODO: multi sector count */
-	pos = (((uint16_t)(msg[4] << 8) + msg[3]) * 8
-			+ ((uint32_t)(msg[6] << 8) + msg[5])) * BLOCK_SIZE;
-
-
-	debug("## cpm_rw: %s %c: trk: %4d, sec: %d, pos: 0x%.5lx, addr: 0x%.5lx\n",
-			dowrite ? "write" : " read", msg[0]+'A',
-			((uint16_t)(msg[4] << 8) + msg[3]), msg[5], pos, addr);
-
+	secs = msg[CNT];
+	addr = ((uint32_t)msg[ADDR+2] << 16) + ((uint16_t)msg[ADDR+1] << 8) + msg[ADDR];
 
 
-	/* TODO: check bank boundary crossing */
-	/*
-	   if (addr + BLOCK_SIZE > MAX_MEMORY)
-		... = MAX_MEMORY - addr;
-	*/
+	/* TODO: tracks per sector from dpb */
+	pos = (((uint16_t)(msg[TRK+1] << 8) + msg[TRK]) * 8
+			+ ((uint32_t)(msg[SEC+1] << 8) + msg[SEC])) * BLOCK_SIZE;
 
+	debug_cpmsd("## %7lu cpm_rw: %s %c: trk:%4d, sec: %d, pos: %.8lx, secs: %2d, "
+			"addr: %.5lx\n", get_timer(0), dowrite ? "write" : " read",
+			msg[ADRV]+'A', ((uint16_t)(msg[TRK+1] << 8) + msg[TRK]), msg[SEC],
+			pos, msg[CNT], addr);
 
 	res = f_lseek(&drv_table[drv].fd, pos);
-	if (!res) {
-		unsigned int br;
-
+	while (!res && secs--) {
+		unsigned int brw;
 		if (dowrite) {
 			if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
 				buserr = 1;
+				break;
 			} else {
 				z80_read_block(disk_buffer, addr, BLOCK_SIZE);
 				z80_bus_cmd(Release);
-				res = f_write(&drv_table[drv].fd, disk_buffer, BLOCK_SIZE, &br);
-				if (!res)
-					res = f_sync(&drv_table[drv].fd);
 			}
+			res = f_write(&drv_table[drv].fd, disk_buffer, BLOCK_SIZE, &brw);
 		} else {
-			res = f_read(&drv_table[drv].fd, disk_buffer, BLOCK_SIZE, &br);
-			if (res == FR_OK) {
+			res = f_read(&drv_table[drv].fd, disk_buffer, BLOCK_SIZE, &brw);
+			if (res == FR_OK && brw == BLOCK_SIZE) {
 				if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
 					buserr = 1;
+					break;
 				} else {
-					z80_write_block(disk_buffer, addr, br);
+					z80_write_block(disk_buffer, addr, BLOCK_SIZE);
 					z80_bus_cmd(Release);
 				}
 			}
 		}
 
-		if (br != BLOCK_SIZE) {
-			debug("##  f_read res: %d, bytes rd/wr: %u\n", res, br);
+		if (brw != BLOCK_SIZE) {
+			debug_cpmsd("## %7lu f_read res: %d, bytes rd/wr: %u\n", get_timer(0), res, brw);
 			dump_ram(disk_buffer, 0, 64, "Read Data");
 			res = -1;
 		}
+
+		addr += BLOCK_SIZE;
 	}
 
-out:
-	if (buserr) {
-		debug("Bus timeout\n");
-		rc = 0x03;
+	if (dowrite && !res) {
+//		res = f_sync(&drv_table[drv].fd);
+		drv_table[drv].dirty = true;
+		bg_setstat(handle_cpm_drv_to, 1);
 	}
-	if (res)
-		rc |= 0x80;
 
-	result_msg[0] = rc;
-	result_msg[1] = res;
-	result_msg[2] = res >> 8;
 
-	if (rc) {
-		debug("#### error rc: %.02x, res: %d\n", rc, res);
+	if (buserr) {
+		debug_cpmsd("Bus timeout\n");
+		rc = 0x03;
 	}
 
 	/* send  result*/
-	msg_xmit(2, subf, sizeof(result_msg), result_msg);
+	msg_cpm_result(subf, rc, res);
 }
 
 
@@ -338,6 +453,12 @@ const FLASH struct msg_item z80_messages[] =
 	{ 2,
 	  1, 2,
 	  do_msg_cpm_rw},
+	{ 3,
+	  1, 1,
+	  do_msg_get_timer},
+	{ 3,
+	  2, 3,				/* 2: get, 3: set time and date */
+	  do_msg_get_set_time},
 	{ 0xff,				/* end mark */
 	  0, 0,
 	  0},
@@ -430,7 +551,7 @@ void check_msg_fifo(void)
 
 int msg_handling(int state)
 {
-	uint8_t pending;
+	bool pending;
 
 	ATOMIC_BLOCK(ATOMIC_FORCEON) {
 		pending = (Stat & S_MSG_PENDING) != 0;
@@ -438,30 +559,27 @@ int msg_handling(int state)
 	}
 
 	if (pending) {
-		switch (state) {
-		case 0:			/* need init */
-			/* Get address of fifo_list */
+		uint8_t init_request;
+		z80_bus_cmd(Request);
+		init_request = z80_read(0x43);
+		z80_bus_cmd(Release);
+		if ( init_request != 0) {
+			/* Get address of fifo 0 */
 			z80_bus_cmd(Request);
-			uint32_t fifo_list = z80_read(0x40) +
-				((uint16_t) z80_read(0x41) << 8) +
-				((uint32_t) z80_read(0x42) << 16);
+			uint32_t fifo_addr = z80_read(0x40) +
+						((uint16_t) z80_read(0x40+1) << 8) +
+						((uint32_t) z80_read(0x40+2) << 16);
+			z80_write(0x43, 0);
 			z80_bus_cmd(Release);
-			if (fifo_list != 0) {
-				/* Get address of fifo 0 */
-				z80_bus_cmd(Request);
-				uint32_t fifo_addr = z80_read(fifo_list) +
-					((uint16_t) z80_read(fifo_list+1) << 8) +
-					((uint32_t) z80_read(fifo_list+2) << 16);
-				z80_bus_cmd(Release);
-				if (fifo_addr != 0) {
-					z80_memfifo_init(fifo_msgin, fifo_addr);
-					state = 1;
-				}
-			}
-			break;
-		case 1:			/* awaiting messages */
+
+			if (fifo_addr != 0) {
+				z80_memfifo_init(fifo_msgin, fifo_addr);
+				state = 1;
+			} else
+				state = 0;
+
+		} else {
 			check_msg_fifo();
-			break;
 		}
 	}
 
@@ -475,27 +593,22 @@ void setup_z180_serv(void)
 {
 
 	handle_msg_handling = bg_register(msg_handling, 0);
+	handle_cpm_drv_to = bg_register(cpm_drv_to, 0);
 }
 
 void restart_z180_serv(void)
 {
 	z80_bus_cmd(Request);
-	z80_write(0x40, 0);
-	z80_write(0x41, 0);
-	z80_write(0x42, 0);
+	z80_memset(0x40, 0, 4);
 	z80_bus_cmd(Release);
 
 	for (int i = 0; i < NUM_FIFOS; i++)
 		z80_memfifo_init(i, 0);
 	bg_setstat(handle_msg_handling, 0);
 
-	f_mount(NULL, "0:", 0);
-	device_table[0].active = false;
-	f_mount(NULL, "1:", 0);
-	device_table[1].active = false;
-
 }
 
+#if 0
 /*--------------------------------------------------------------------------*/
 
 const FLASH uint8_t iniprog[] = {
@@ -547,3 +660,4 @@ const FLASH uint8_t test1[] = {
 	0x00,              //	db	0		;dst
 	0x00, 0x00,        //	dw 	0		;count (64k)
 };
+#endif