[z180-stamp.git] / avr / z180-serv.c

/*
 * (C) Copyright 2014-2016 Leo C. <erbl259-lmu@yahoo.de>
 *
 * SPDX-License-Identifier:	GPL-2.0
 */

#include "z180-serv.h"
#include "common.h"
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <util/atomic.h>

#include "config.h"
#include "background.h"
#include "env.h"
#include "ff.h"
#include "serial.h"
#include "z80-if.h"
#include "debug.h"
#include "print-utils.h"
#include "timer.h"
#include "time.h"
#include "bcd.h"
#include "rtc.h"

#define DEBUG_CPM_SDIO	0	/* set to 1 to debug */

#define debug_cpmsd(fmt, args...)		                                            \
	debug_cond(DEBUG_CPM_SDIO, fmt, ##args)


/*--------------------------------------------------------------------------*/

struct msg_item {
	uint8_t fct;
	uint8_t sub_min, sub_max;
	void (*func)(uint8_t, int, uint8_t *);
};

uint32_t msg_to_addr(uint8_t *msg)
{
	union {
		uint32_t as32;
		uint8_t as8[4];
	} addr;

	addr.as8[0] = msg[0];
	addr.as8[1] = msg[1];
	addr.as8[2] = msg[2];
	addr.as8[3] = 0;

	return addr.as32;
}


static int msg_xmit_header(uint8_t func, uint8_t subf, int len)
{
	z80_memfifo_putc(fifo_msgout, 0xAE);
	z80_memfifo_putc(fifo_msgout, len+2);
	z80_memfifo_putc(fifo_msgout, func);
	z80_memfifo_putc(fifo_msgout, subf);

	return 0;
}

int msg_xmit(uint8_t func, uint8_t subf, int len, uint8_t *msg)
{
	msg_xmit_header(func, subf, len);
	while (len--)
		z80_memfifo_putc(fifo_msgout, *msg++);

	return 0;
}

void do_msg_ini_memfifo(uint8_t subf, int len, uint8_t * msg)
{
	(void)len;

	z80_memfifo_init(subf, msg_to_addr(msg));
}


void do_msg_char_out(uint8_t subf, int len, uint8_t * msg)
{
	(void)subf;

	while (len--)
		putchar(*msg++);
}

/* echo message */
void do_msg_echo(uint8_t subf, int len, uint8_t * msg)
{
	(void)subf;

	/* send re-echo */
	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 CPM_DAY_OFFSET ((1978-1900) * 365 + 19)		/* 19 leap years */

/*
 * 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);
}

/* ---------------------------------------------------------------------------*/

static uint8_t drv;
static uint8_t disk_buffer[CONFIG_CPM_BLOCK_SIZE];
static struct cpm_drive_s drv_table[CONFIG_CPM_MAX_DRIVE];
static int handle_cpm_drv_to;

typedef enum {SINGLE, START, MIDDLE, END} dbgmsg_t;

void drv_debug(dbgmsg_t phase, const FLASH char *const fmt, ...)		                                            \
{
	struct cpm_drive_s *dp = &drv_table[drv];

	if (dp->opt & DRV_OPT_DEBUG) {

		va_list ap;
		va_start (ap, fmt);

		if (phase == SINGLE || phase == START)
			printf_P(PSTR("# %7lu dsk%d: "), get_timer(0), drv);

		vfprintf_P (stdout, fmt, ap);

		if (phase == SINGLE || phase == END)
			putc('\n', stdout);

		va_end (ap);
	}
}

int drv_list(void)
{
	for (uint8_t i = 0; i < CONFIG_CPM_MAX_DRIVE; i++) {
		struct cpm_drive_s * p = &drv_table[i];
		if (p->img_name) {
			printf_P(PSTR("  dsk%d: %2s %3s attached to %s\n"), i,
					p->opt&DRV_OPT_RO ? "RO":"RW", p->opt&DRV_OPT_DEBUG ? "DBG":"",
					p->img_name);
		}
	}
	return 0;
}

int drv_detach(uint8_t unit)
{
	drv = unit;
	if (drv < CONFIG_CPM_MAX_DRIVE) {
		struct cpm_drive_s *p = &drv_table[drv];

		drv_debug(SINGLE, PSTR("detach from '%s'"), p->img_name ? p->img_name : "-");

		if (p->img_name) {
			f_close(&p->fd);
			free(p->img_name);
			p->opt = 0;
			p->flags &= ~DRV_FLG_DIRTY;
			p->img_name = NULL;

			uint32_t scb = getenv_ulong(ENV_CPM3_SCB, 16, 0);
			if (scb && (z80_bus_cmd(Request) & ZST_ACQUIRED)) {
				z80_write(scb + 0xf0, 0xff);
				z80_write(p->dph + 11, 0xff);
				z80_bus_cmd(Release);
			}
		}
	}
	return 0;
}

static int drv_find_file_attached(const char *fn)
{
	for (uint8_t i = 0; i < CONFIG_CPM_MAX_DRIVE; i++) {
		struct cpm_drive_s *p = &drv_table[i];
		if (p->img_name && !strcmp(fn, p->img_name)) {
			return i;
		}
	}
	return -1;
}

int drv_attach(uint8_t unit, const char *filename, drv_opt_t options)
{
	int res;

	drv = unit;
	if (drv >= CONFIG_CPM_MAX_DRIVE)
		return AT_RANGE;

	struct cpm_drive_s *p = &drv_table[drv];

	if (options & DRV_OPT_REATTATCH) {
		if (filename) {
			return AT_ERROR;
		}

		if (!p->img_name) {
			return AT_NOT;
		}

		/* change options */
		if ((p->opt ^ options) & DRV_OPT_RO) {
			f_close(&p->fd);
			res = f_open(&p->fd, p->img_name,
					FA_READ | (options&DRV_OPT_RO ? 0 : FA_WRITE));
		}

		p->opt = options & ~DRV_OPT_REATTATCH;

	} else {

		if (p->img_name)
			return AT_ALREADY;
		if (drv_find_file_attached(filename) >= 0)
			return AT_OTHER;

		p->opt = options;

		/* new attachment */

		if ((p->img_name = strdup(filename)) == NULL)
			return AT_NOMEM;

		res = f_open(&p->fd, p->img_name,
				FA_READ | (options&DRV_OPT_RO ? 0 : FA_WRITE));

		if (!res && f_size(&p->fd) < CONFIG_CPM_DISKSIZE) {
#if 0
			unsigned int bw;
			debug_cpmsd("            expanding image file from %ld to %ld\n",
					f_size(&p->fd), CONFIG_CPM_DISKSIZE);

			res = f_lseek(&p->fd, CONFIG_CPM_DISKSIZE-CONFIG_CPM_BLOCK_SIZE);
			if (!res) {
				memset(disk_buffer, 0xe5, CONFIG_CPM_BLOCK_SIZE);
				res = f_write(&p->fd, disk_buffer, CONFIG_CPM_BLOCK_SIZE, &bw);
				if (res || bw < CONFIG_CPM_BLOCK_SIZE) {
					debug_cpmsd("               failed! res: %d, bytes written: %u\n",	res, bw);
				}
				p->flags |= DRV_FLG_DIRTY;
				bg_setstat(handle_cpm_drv_to, 1);
			}
#else
			drv_debug(SINGLE, PSTR("wrong image file size: %ld, should be %ld"),
					f_size(&p->fd), CONFIG_CPM_DISKSIZE);
			res = 64;
#endif
		}
		if (res) {
			drv_detach(drv);
			return AT_OPEN;
		}
	}

	return AT_OK;
}


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 < CONFIG_CPM_MAX_DRIVE; i++) {
				if (drv_table[i].flags & DRV_FLG_DIRTY) {
					drv_table[i].flags &= ~DRV_FLG_DIRTY;
					f_sync(&drv_table[i].fd);
					drv = i;
					drv_debug(SINGLE, PSTR("f_sync"));
				}
			}
			state = 0;
		}
	}
	return state;
}

static const FLASH char * const FLASH rc_messages[] = {
			FSTR("OK"),
			FSTR("Internal error: wrong message len"),	/* 01 */
			FSTR("Invalid relative drive #"),			/* 02 */
			FSTR("Bus timeout"),						/* 03 */
			FSTR("Access byond disk size"),				/* 04 */
			FSTR("Write protect"),						/* 05 */
			FSTR("No media"),							/* 06 */
		};

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;

	msg_xmit(2, subf, sizeof(result_msg), result_msg);

	if (rc)
		drv_debug(END, PSTR(" rc: %.02x/%d, '%S'"),
					rc, res, rc_messages[rc & 0x7f]);
	else
		drv_debug(END, PSTR(""));

}

/*
 	db	2	; disk command
	ds	1	; subcommand (login/read/write)
	ds	1	; @adrv (8 bits)	+0
	ds	1	; @rdrv (8 bits)	+1
	ds	3	; @xdph (24 bits)	+2
*/

void do_msg_cpm_login(uint8_t subf, int len, uint8_t * msg)
{
	struct cpm_drive_s *dp;
	FRESULT res = 0;

	(void)subf;

	/* Get relative drive number */
	drv = msg[1];
	drv_debug(START, PSTR("login"));

	if (len != 5) {
		return msg_cpm_result(subf, 0x01, res);
	}

	if ( drv >= CONFIG_CPM_MAX_DRIVE) {
		/* invalid relative drive number */
		return msg_cpm_result(subf, 0x02, res);
	}

	dp = &drv_table[drv];
	dp->flags &= ~DRV_FLG_OPEN;
	dp->dph = ((uint32_t)msg[4] << 16) + ((uint16_t)msg[3] << 8) + msg[2];

	if (dp->img_name == NULL) {
		/* no file attached */
		return msg_cpm_result(subf, 0x06, res);
	}

	f_close(&dp->fd);
	res = f_open(&dp->fd, dp->img_name,
			FA_READ | (dp->opt&DRV_OPT_RO ? 0 : FA_WRITE));

	dp->flags |= DRV_FLG_OPEN;

	/* send  result*/
	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	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)
{
	struct cpm_drive_s *dp;
	uint32_t addr;
	uint32_t pos;
	uint16_t track;
	uint16_t sec;
	uint8_t secs;
	bool dowrite;
	FRESULT res = 0;
	uint8_t rc = 0;
	bool buserr = 0;

	drv = msg[RDRV];
	dowrite = (subf == 2);

	drv_debug(START, PSTR("%2S"), dowrite ? PSTR("W ") : PSTR(" R"));

	if (len != 10) {
		return msg_cpm_result(subf, 0x01, res);
	}
	if ( drv>= CONFIG_CPM_MAX_DRIVE) {
		return msg_cpm_result(subf, 0x02, res);
	}

	dp = &drv_table[drv];
	track = (uint16_t)(msg[TRK+1] << 8) + msg[TRK];
	sec  = (uint16_t)(msg[SEC+1] << 8) + msg[SEC];
	secs = msg[CNT];
	addr = ((uint32_t)msg[ADDR+2] << 16) + ((uint16_t)msg[ADDR+1] << 8) + msg[ADDR];

	if (dp->img_name == NULL) {
		/* no media */
		return msg_cpm_result(subf, 0x06, res);
	}

	/* TODO: tracks per sector from dpb */
	pos = (track * 8UL + sec) * CONFIG_CPM_BLOCK_SIZE;

	drv_debug(MIDDLE, PSTR(" T:%4d, S:%2d, cnt:%2d, lba: %.8lx, addr: %.5lx"),
				track, sec, secs, pos, addr);

	if (dowrite && dp->opt & DRV_OPT_RO) {
		return msg_cpm_result(subf, 0x05, res);
	}


	if (pos + secs * CONFIG_CPM_BLOCK_SIZE > CONFIG_CPM_DISKSIZE) {
		drv_debug(MIDDLE, PSTR(" access > DISKSIZE:%.8lx!"),
						CONFIG_CPM_DISKSIZE);
		return msg_cpm_result(subf, 0x04, res);
	}

	res = f_lseek(&dp->fd, pos);

	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, CONFIG_CPM_BLOCK_SIZE);
				z80_bus_cmd(Release);
			}
			res = f_write(&dp->fd, disk_buffer, CONFIG_CPM_BLOCK_SIZE, &brw);
		} else {
			res = f_read(&dp->fd, disk_buffer, CONFIG_CPM_BLOCK_SIZE, &brw);
			if (res == FR_OK) {
				if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
					buserr = 1;
					break;
				} else {
					z80_write_block(disk_buffer, addr, CONFIG_CPM_BLOCK_SIZE);
					z80_bus_cmd(Release);
				}
			}
		}
		if (brw != CONFIG_CPM_BLOCK_SIZE) {
			drv_debug(MIDDLE, PSTR(" short rd/wr: res: %d, brw: %u"),
						res, brw);
			res = 64;
		}
		addr += CONFIG_CPM_BLOCK_SIZE;
	}

	if (dowrite && !res) {
		dp->flags |= DRV_FLG_DIRTY;
		bg_setstat(handle_cpm_drv_to, 1);
	}

	if (buserr) {
		/* Bus timeout. how can this happen? */
		rc = 0x03;
	}

	/* send  result*/
	msg_cpm_result(subf, rc, res);
}


const FLASH struct msg_item z80_messages[] =
{
	{ 0,			/* fct nr. */
	  1, 3,			/* sub fct nr. from, to */
	  do_msg_ini_memfifo},
	{ 1,
	  1, 1,
	  do_msg_char_out},
	{ 1,
	  2, 2,
	  do_msg_echo},
	{ 2,
	  0, 0,
	  do_msg_cpm_login},
	{ 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},

};


void do_message(int len, uint8_t *msg)
{
	uint8_t fct, sub_fct;
	int_fast8_t i = 0;

	if (len >= 2) {
		fct = *msg++;
		sub_fct = *msg++;
		len -= 2;

		while (fct != z80_messages[i].fct) {
			if (z80_messages[i].fct == 0xff) {
				DBG_P(1, "do_message: Unknown function: %i, %i\n",
						fct, sub_fct);
				return; /* TODO: unknown message # */
			}

			++i;
		}

		while (fct == z80_messages[i].fct) {
			if (sub_fct >= z80_messages[i].sub_min &&
					sub_fct <= z80_messages[i].sub_max )
				break;
			++i;
		}

		if (z80_messages[i].fct != fct) {
			DBG_P(1, "do_message: Unknown sub function: %i, %i\n",
					fct, sub_fct);
			return; /* TODO: unknown message sub# */
		}

		(z80_messages[i].func)(sub_fct, len, msg);


	} else {
		/* TODO: error */
		DBG_P(1, "do_message: to few arguments (%i); this shouldn't happen!\n", len);
	}
}


#define CTRBUF_LEN 256

void check_msg_fifo(void)
{
	int ch;
	static int_fast8_t state;
	static int msglen,idx;
	static uint8_t buffer[CTRBUF_LEN];

	while ((ch = z80_memfifo_getc(fifo_msgin)) >= 0) {
		switch (state) {
		case 0:		/* wait for start of message */
			if (ch == 0xAE)	{ /* TODO: magic number */
				msglen = 0;
				idx = 0;
				state = 1;
			}
			break;
		case 1:		/* get msg len */
			if (ch > 0 && ch <= CTRBUF_LEN) {
				msglen = ch;
				state = 2;
			} else
				state = 0;
			break;
		case 2: 	/* get message */
			buffer[idx++] = ch;
			if (idx == msglen) {
				do_message(msglen, buffer);
				state = 0;
			}
			break;
		}
	}
}


int msg_handling(int state)
{
	bool pending;

	ATOMIC_BLOCK(ATOMIC_FORCEON) {
		pending = (Stat & S_MSG_PENDING) != 0;
		Stat &= ~S_MSG_PENDING;
	}

	if (pending) {
		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_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_addr != 0) {
				z80_memfifo_init(fifo_msgin, fifo_addr);
				state = 1;
			} else
				state = 0;

		} else {
			check_msg_fifo();
		}
	}

	return state;
}


static int handle_msg_handling;

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_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);

}

#if 0
/*--------------------------------------------------------------------------*/

const FLASH uint8_t iniprog[] = {
	0xAF,			// xor     a
	0xED, 0x39, 0x36,	// out0    (rcr),a         ;disable  DRAM refresh
	0x3E, 0x30,		// ld      a,030h
	0xED, 0x39, 0x32	//out0    (dcntl),a       ;0 mem, max i/0 wait states
};

const FLASH uint8_t sertest[] = {
	0xAF,              //  	xor	a
	0xED, 0x39, 0x36,  //  	out0	(rcr),a		;disable  DRAM refresh
	0x3E, 0x30,        //  	ld	a,030h
	0xED, 0x39, 0x32,  //  	out0	(dcntl),a	;0 mem, max i/0 wait states
	0x3E, 0x80,        //  	ld	a,M_MPBT		;no MP, PS=10, DR=16, SS=0
	0xED, 0x39, 0x03,  //  	out0	(cntlb1),a
	0x3E, 0x64,        //  	ld	a,M_RE + M_TE + M_MOD2	;
	0xED, 0x39, 0x01,  //  	out0	(cntla1),a
	0x3E, 0x00,        //  	ld	a,0
	0xED, 0x39, 0x05,  //  	out0	(stat1),a	;Enable rx interrupts
	0xED, 0x38, 0x05,  //l0:in0	a,(stat1)
	0xE6, 0x80,        //  	and	80h
	0x28, 0xF9,        //  	jr	z,l0
	0xED, 0x00, 0x09,  //  	in0	b,(rdr1)
	0xED, 0x38, 0x05,  //l1:in0	a,(stat1)
	0xE6, 0x02,        //  	and	02h
	0x28, 0xF9,        //  	jr	z,l1
	0xED, 0x01, 0x07,  //  	out0	(tdr1),b
	0x18, 0xEA,        //  	jr	l0
};

const FLASH uint8_t test1[] = {
	0xAF,              //	xor	a
	0xED, 0x39, 0x36,  //	out0	(rcr),a		;disable  DRAM refresh
	0x3E, 0x30,        //	ld	a,030h
	0xED, 0x39, 0x32,  //	out0	(dcntl),a	;0 mem, max i/0 wait states
	0x21, 0x1E, 0x00,  // 	ld	hl,dmclrt	;load DMA registers
	0x06, 0x08,        //	ld	b,dmct_e-dmclrt
	0x0E, 0x20,        //	ld	c,sar0l
	0xED, 0x93,        //	otimr
	0x3E, 0xC3,        //	ld	a,0c3h		;dst +1, src +1, burst
	0xED, 0x39, 0x31,  //	out0	(dmode),a	;
	0x3E, 0x62,        //	ld	a,062h		;enable dma0,
	0xED, 0x39, 0x30,  //cl_1:	out0	(dstat),a	;copy 64k
	0x18, 0xFB,        //	jr	cl_1		;
	0x00, 0x00,        //dmclrt:	dw	0		;src (inc)
	0x00,              //	db 	0		;src
	0x00, 0x00,        //	dw	0		;dst (inc),
	0x00,              //	db	0		;dst
	0x00, 0x00,        //	dw 	0		;count (64k)
};
#endif
Commit	Line	Data
35edb766	1	/*
1aed7fd5	2	* (C) Copyright 2014-2016 Leo C. <erbl259-lmu@yahoo.de>
35edb766	3	*
ad12f284	4	* SPDX-License-Identifier: GPL-2.0
35edb766 L	5	*/
35edb766 L	6
cb4fb1ed	7	#include "z180-serv.h"
72f58822	8	#include "common.h"
5f7f3586 L	9	#include <stdlib.h>
	10	#include <string.h>
	11	#include <stdbool.h>
89adce76	12	#include <util/atomic.h>
72f58822	13
1aed7fd5	14	#include "config.h"
89adce76	15	#include "background.h"
5f7f3586 L	16	#include "env.h"
5f7f3586 L	17	#include "ff.h"
72f58822 L	18	#include "serial.h"
72f58822 L	19	#include "z80-if.h"
889202c4	20	#include "debug.h"
5f7f3586	21	#include "print-utils.h"
daacc6f9	22	#include "timer.h"
845cbdbd L	23	#include "time.h"
	24	#include "bcd.h"
	25	#include "rtc.h"
7d60b20b	26
2ca8d8c7	27	#define DEBUG_CPM_SDIO 0 /* set to 1 to debug */
7d60b20b L	28
	29	#define debug_cpmsd(fmt, args...) \
	30	debug_cond(DEBUG_CPM_SDIO, fmt, ##args)
	31
	32
72f58822 L	33	/--------------------------------------------------------------------------/
	34
	35	struct msg_item {
	36	uint8_t fct;
	37	uint8_t sub_min, sub_max;
	38	void (func)(uint8_t, int, uint8_t );
	39	};
	40
	41	uint32_t msg_to_addr(uint8_t *msg)
	42	{
	43	union {
	44	uint32_t as32;
	45	uint8_t as8[4];
	46	} addr;
	47
	48	addr.as8[0] = msg[0];
	49	addr.as8[1] = msg[1];
	50	addr.as8[2] = msg[2];
	51	addr.as8[3] = 0;
	52
	53	return addr.as32;
	54	}
	55
72f58822	56
1a2460dc L	57	static int msg_xmit_header(uint8_t func, uint8_t subf, int len)
	58	{
	59	z80_memfifo_putc(fifo_msgout, 0xAE);
	60	z80_memfifo_putc(fifo_msgout, len+2);
	61	z80_memfifo_putc(fifo_msgout, func);
	62	z80_memfifo_putc(fifo_msgout, subf);
	63
	64	return 0;
	65	}
	66
	67	int msg_xmit(uint8_t func, uint8_t subf, int len, uint8_t *msg)
	68	{
	69	msg_xmit_header(func, subf, len);
	70	while (len--)
	71	z80_memfifo_putc(fifo_msgout, *msg++);
	72
	73	return 0;
	74	}
	75
72f58822 L	76	void do_msg_ini_memfifo(uint8_t subf, int len, uint8_t * msg)
	77	{
	78	(void)len;
	79
89adce76	80	z80_memfifo_init(subf, msg_to_addr(msg));
72f58822 L	81	}
	82
	83
	84	void do_msg_char_out(uint8_t subf, int len, uint8_t * msg)
	85	{
	86	(void)subf;
	87
	88	while (len--)
	89	putchar(*msg++);
	90	}
	91
1a2460dc L	92	/* echo message */
	93	void do_msg_echo(uint8_t subf, int len, uint8_t * msg)
	94	{
	95	(void)subf;
	96
	97	/* send re-echo */
	98	msg_xmit(1, 3, len, msg);
	99	}
	100
8590a76b L	101	/* get timer */
	102	void do_msg_get_timer(uint8_t subf, int len, uint8_t * msg)
	103	{
a8eb521f	104	uint32_t time_ms = (len >= 4) ? (uint32_t ) msg : 0;
8590a76b	105
a8eb521f	106	time_ms = get_timer(time_ms);
8590a76b L	107	msg_xmit(3, subf, sizeof(time_ms), (uint8_t *) &time_ms);
	108	}
	109
5f7f3586 L	110	/* ---------------------------------------------------------------------------*/
5f7f3586 L	111
845cbdbd L	112	#define CPM_DAY_OFFSET ((1978-1900) * 365 + 19) /* 19 leap years */
	113
	114	/*
	115	* Convert CP/M time stamp to a broken-down time structure
	116	*
	117	*/
	118	int mk_date_time (int len, uint8_t msg, struct tm tmp)
	119	{
	120	time_t stamp;
	121
	122	if (len != 5)
	123	return -1;
	124
	125	/* days since 2000-01-01 */
	126	long days = msg[3] + (msg[4] << 8) - 8036;
	127
	128	if (days < 0)
	129	return -1;
	130
	131	stamp = days * ONE_DAY;
	132	stamp += bcd2bin(msg[0]);
	133	stamp += bcd2bin(msg[1]) * 60 ;
8d0fad4c	134	stamp += bcd2bin(msg[2]) * 3600L;
845cbdbd L	135	gmtime_r(&stamp, tmp);
	136	return 0;
	137	}
	138
	139	void mk_cpm_time(struct tm *tmp, uint8_t cpm_time[5])
	140	{
	141	uint16_t days = 1;
	142	uint_fast8_t leap=2;
	143
	144	for (int year=78; year < tmp->tm_year; year++) {
	145	days = days + 365 + (leap == 0);
	146	leap = (leap+1)%4;
	147	}
	148	days += tmp->tm_yday;
	149
	150	cpm_time[0] = bin2bcd(tmp->tm_sec);
	151	cpm_time[1] = bin2bcd(tmp->tm_min);
	152	cpm_time[2] = bin2bcd(tmp->tm_hour);
	153	cpm_time[3] = days;
	154	cpm_time[4] = days >> 8;
845cbdbd L	155	}
	156
	157	/* get/set cp/m time */
	158	void do_msg_get_set_time(uint8_t subf, int len, uint8_t * msg)
	159	{
	160	struct tm t;
	161	uint8_t cpm_time[5];
	162	int rc;
	163
	164	memset(cpm_time, 0, ARRAY_SIZE(cpm_time));
	165
	166	switch (subf) {
	167	case 3: /* set date & time */
	168	/* initialize t with current time */
	169	rc = rtc_get (&t);
	170
85046f8c	171	if (rc >= 0) {
845cbdbd L	172	/* insert new date & time */
	173	if (mk_date_time (len, msg, &t) != 0) {
	174	my_puts_P(PSTR("## set_time: Bad date format\n"));
	175	break;
	176	}
	177
	178	time_t time;
	179	time = mk_gmtime(&t);
	180	gmtime_r(&time, &t);
	181
	182	/* and write to RTC */
	183	rc = rtc_set (&t);
	184	if(rc)
	185	my_puts_P(PSTR("## set_time: Set date failed\n"));
	186	} else {
	187	my_puts_P(PSTR("## set_time: Get date failed\n"));
	188	}
	189	/* FALL TROUGH */
	190	case 2: /* get date & time */
	191	rc = rtc_get (&t);
85046f8c L	192	if (rc >= 0) {
	193	time_t time;
	194	time = mk_gmtime(&t);
	195	//mktime(&t);
	196	gmtime_r(&time, &t);
845cbdbd	197
85046f8c L	198	mk_cpm_time(&t, cpm_time);
85046f8c L	199	} else {
845cbdbd	200	my_puts_P(PSTR("## get_time: Get date failed\n"));
845cbdbd	201	}
845cbdbd L	202	break;
	203	}
	204
	205	msg_xmit(3, subf, sizeof(cpm_time), cpm_time);
	206	}
	207
	208	/* ---------------------------------------------------------------------------*/
	209
78c90027	210	static uint8_t drv;
1aed7fd5 L	211	static uint8_t disk_buffer[CONFIG_CPM_BLOCK_SIZE];
1aed7fd5 L	212	static struct cpm_drive_s drv_table[CONFIG_CPM_MAX_DRIVE];
393b1897 L	213	static int handle_cpm_drv_to;
393b1897 L	214
78c90027	215	typedef enum {SINGLE, START, MIDDLE, END} dbgmsg_t;
393b1897	216
78c90027	217	void drv_debug(dbgmsg_t phase, const FLASH char *const fmt, ...) \
9461ecf3 L	218	{
	219	struct cpm_drive_s *dp = &drv_table[drv];
	220
	221	if (dp->opt & DRV_OPT_DEBUG) {
	222
	223	va_list ap;
78c90027	224	va_start (ap, fmt);
9461ecf3	225
78c90027 L	226	if (phase == SINGLE \|\| phase == START)
78c90027 L	227	printf_P(PSTR("# %7lu dsk%d: "), get_timer(0), drv);
9461ecf3	228
9461ecf3	229	vfprintf_P (stdout, fmt, ap);
9461ecf3	230
78c90027 L	231	if (phase == SINGLE \|\| phase == END)
	232	putc('\n', stdout);
	233
	234	va_end (ap);
9461ecf3 L	235	}
	236	}
	237
cb4fb1ed L	238	int drv_list(void)
	239	{
	240	for (uint8_t i = 0; i < CONFIG_CPM_MAX_DRIVE; i++) {
	241	struct cpm_drive_s * p = &drv_table[i];
	242	if (p->img_name) {
	243	printf_P(PSTR(" dsk%d: %2s %3s attached to %s\n"), i,
	244	p->opt&DRV_OPT_RO ? "RO":"RW", p->opt&DRV_OPT_DEBUG ? "DBG":"",
	245	p->img_name);
	246	}
	247	}
	248	return 0;
	249	}
	250
78c90027	251	int drv_detach(uint8_t unit)
cb4fb1ed	252	{
78c90027	253	drv = unit;
cb4fb1ed L	254	if (drv < CONFIG_CPM_MAX_DRIVE) {
	255	struct cpm_drive_s *p = &drv_table[drv];
	256
78c90027	257	drv_debug(SINGLE, PSTR("detach from '%s'"), p->img_name ? p->img_name : "-");
cb4fb1ed L	258
	259	if (p->img_name) {
	260	f_close(&p->fd);
cb4fb1ed	261	free(p->img_name);
4122fe90 L	262	p->opt = 0;
4122fe90 L	263	p->flags &= ~DRV_FLG_DIRTY;
cb4fb1ed	264	p->img_name = NULL;
e34ae619 L	265
	266	uint32_t scb = getenv_ulong(ENV_CPM3_SCB, 16, 0);
	267	if (scb && (z80_bus_cmd(Request) & ZST_ACQUIRED)) {
	268	z80_write(scb + 0xf0, 0xff);
	269	z80_write(p->dph + 11, 0xff);
	270	z80_bus_cmd(Release);
	271	}
cb4fb1ed L	272	}
	273	}
	274	return 0;
	275	}
	276
	277	static int drv_find_file_attached(const char *fn)
	278	{
	279	for (uint8_t i = 0; i < CONFIG_CPM_MAX_DRIVE; i++) {
	280	struct cpm_drive_s *p = &drv_table[i];
	281	if (p->img_name && !strcmp(fn, p->img_name)) {
	282	return i;
	283	}
	284	}
	285	return -1;
	286	}
	287
78c90027	288	int drv_attach(uint8_t unit, const char *filename, drv_opt_t options)
cb4fb1ed L	289	{
	290	int res;
	291
78c90027	292	drv = unit;
cb4fb1ed L	293	if (drv >= CONFIG_CPM_MAX_DRIVE)
	294	return AT_RANGE;
	295
	296	struct cpm_drive_s *p = &drv_table[drv];
	297
	298	if (options & DRV_OPT_REATTATCH) {
	299	if (filename) {
	300	return AT_ERROR;
	301	}
	302
	303	if (!p->img_name) {
	304	return AT_NOT;
	305	}
	306
9baecc6b L	307	/* change options */
	308	if ((p->opt ^ options) & DRV_OPT_RO) {
	309	f_close(&p->fd);
	310	res = f_open(&p->fd, p->img_name,
	311	FA_READ \| (options&DRV_OPT_RO ? 0 : FA_WRITE));
	312	}
cb4fb1ed	313
9baecc6b	314	p->opt = options & ~DRV_OPT_REATTATCH;
cb4fb1ed L	315
	316	} else {
	317
	318	if (p->img_name)
	319	return AT_ALREADY;
	320	if (drv_find_file_attached(filename) >= 0)
	321	return AT_OTHER;
	322
4122fe90	323	p->opt = options;
cb4fb1ed L	324
	325	/* new attachment */
	326
	327	if ((p->img_name = strdup(filename)) == NULL)
	328	return AT_NOMEM;
	329
	330	res = f_open(&p->fd, p->img_name,
9baecc6b	331	FA_READ \| (options&DRV_OPT_RO ? 0 : FA_WRITE));
cb4fb1ed L	332
cb4fb1ed L	333	if (!res && f_size(&p->fd) < CONFIG_CPM_DISKSIZE) {
9baecc6b	334	#if 0
cb4fb1ed	335	unsigned int bw;
cb4fb1ed L	336	debug_cpmsd(" expanding image file from %ld to %ld\n",
	337	f_size(&p->fd), CONFIG_CPM_DISKSIZE);
	338
	339	res = f_lseek(&p->fd, CONFIG_CPM_DISKSIZE-CONFIG_CPM_BLOCK_SIZE);
	340	if (!res) {
	341	memset(disk_buffer, 0xe5, CONFIG_CPM_BLOCK_SIZE);
	342	res = f_write(&p->fd, disk_buffer, CONFIG_CPM_BLOCK_SIZE, &bw);
	343	if (res \|\| bw < CONFIG_CPM_BLOCK_SIZE) {
	344	debug_cpmsd(" failed! res: %d, bytes written: %u\n", res, bw);
	345	}
4122fe90	346	p->flags \|= DRV_FLG_DIRTY;
cb4fb1ed L	347	bg_setstat(handle_cpm_drv_to, 1);
cb4fb1ed L	348	}
9baecc6b	349	#else
78c90027	350	drv_debug(SINGLE, PSTR("wrong image file size: %ld, should be %ld"),
9baecc6b L	351	f_size(&p->fd), CONFIG_CPM_DISKSIZE);
	352	res = 64;
	353	#endif
cb4fb1ed L	354	}
	355	if (res) {
	356	drv_detach(drv);
	357	return AT_OPEN;
	358	}
	359	}
	360
	361	return AT_OK;
	362	}
	363
	364
393b1897 L	365	int cpm_drv_to(int state)
	366	{
	367	static uint32_t ts;
	368
	369	switch(state) {
	370	case 0:
	371	break;
	372
	373	case 1:
	374	ts = get_timer(0);
	375	state = 2;
	376	break;
	377
	378	case 2:
	379	if (get_timer(ts) > 1000) {
1aed7fd5	380	for (uint_fast8_t i=0; i < CONFIG_CPM_MAX_DRIVE; i++) {
4122fe90	381	if (drv_table[i].flags & DRV_FLG_DIRTY) {
4122fe90	382	drv_table[i].flags &= ~DRV_FLG_DIRTY;
9461ecf3	383	f_sync(&drv_table[i].fd);
78c90027 L	384	drv = i;
78c90027 L	385	drv_debug(SINGLE, PSTR("f_sync"));
393b1897 L	386	}
	387	}
	388	state = 0;
	389	}
	390	}
	391	return state;
	392	}
	393
78c90027 L	394	static const FLASH char * const FLASH rc_messages[] = {
	395	FSTR("OK"),
	396	FSTR("Internal error: wrong message len"), /* 01 */
	397	FSTR("Invalid relative drive #"), /* 02 */
	398	FSTR("Bus timeout"), /* 03 */
	399	FSTR("Access byond disk size"), /* 04 */
	400	FSTR("Write protect"), /* 05 */
	401	FSTR("No media"), /* 06 */
	402	};
393b1897 L	403
	404	void msg_cpm_result(uint8_t subf, uint8_t rc, int res)
	405	{
	406	uint8_t result_msg[3];
	407
	408	if (res)
	409	rc \|= 0x80;
	410
	411	result_msg[0] = rc;
	412	result_msg[1] = res;
	413	result_msg[2] = res >> 8;
	414
393b1897	415	msg_xmit(2, subf, sizeof(result_msg), result_msg);
78c90027 L	416
	417	if (rc)
	418	drv_debug(END, PSTR(" rc: %.02x/%d, '%S'"),
	419	rc, res, rc_messages[rc & 0x7f]);
	420	else
	421	drv_debug(END, PSTR(""));
	422
393b1897	423	}
5f7f3586 L	424
	425	/*
	426	db 2 ; disk command
	427	ds 1 ; subcommand (login/read/write)
	428	ds 1 ; @adrv (8 bits) +0
	429	ds 1 ; @rdrv (8 bits) +1
	430	ds 3 ; @xdph (24 bits) +2
	431	*/
	432
	433	void do_msg_cpm_login(uint8_t subf, int len, uint8_t * msg)
	434	{
9baecc6b	435	struct cpm_drive_s *dp;
4122fe90	436	FRESULT res = 0;
5f7f3586 L	437
	438	(void)subf;
	439
78c90027 L	440	/* Get relative drive number */
	441	drv = msg[1];
	442	drv_debug(START, PSTR("login"));
	443
afc7c4b4	444	if (len != 5) {
393b1897	445	return msg_cpm_result(subf, 0x01, res);
5f7f3586 L	446	}
5f7f3586 L	447
cb4fb1ed	448	if ( drv >= CONFIG_CPM_MAX_DRIVE) {
78c90027	449	/* invalid relative drive number */
393b1897	450	return msg_cpm_result(subf, 0x02, res);
5f7f3586 L	451	}
5f7f3586 L	452
9baecc6b L	453	dp = &drv_table[drv];
	454	dp->flags &= ~DRV_FLG_OPEN;
	455	dp->dph = ((uint32_t)msg[4] << 16) + ((uint16_t)msg[3] << 8) + msg[2];
cb4fb1ed	456
9baecc6b	457	if (dp->img_name == NULL) {
4122fe90	458	/* no file attached */
78c90027	459	return msg_cpm_result(subf, 0x06, res);
5f7f3586 L	460	}
5f7f3586 L	461
019dc5f9 L	462	f_close(&dp->fd);
	463	res = f_open(&dp->fd, dp->img_name,
	464	FA_READ \| (dp->opt&DRV_OPT_RO ? 0 : FA_WRITE));
	465
9baecc6b	466	dp->flags \|= DRV_FLG_OPEN;
afc7c4b4	467
5f7f3586	468	/* send result*/
393b1897	469	msg_cpm_result(subf, 0x00, res);
5f7f3586 L	470	}
	471
	472
	473	/*
	474	db 2 ; disk command
	475	ds 1 ; subcommand (login/read/write)
daacc6f9 L	476	ds 1 ; @adrv (8 bits) +0
	477	ds 1 ; @rdrv (8 bits) +1
	478	ds 2 ; @trk (16 bits) +2
	479	ds 2 ; @sect(16 bits) +4
	480	ds 1 ; @cnt (8 bits) +6
5f7f3586 L	481	ds 3 ; phys. transfer addr +7
	482	*/
	483
daacc6f9 L	484	#define ADRV 0
	485	#define RDRV 1
	486	#define TRK 2
	487	#define SEC 4
	488	#define CNT 6
	489	#define ADDR 7
	490
5f7f3586 L	491	void do_msg_cpm_rw(uint8_t subf, int len, uint8_t * msg)
5f7f3586 L	492	{
9baecc6b	493	struct cpm_drive_s *dp;
5f7f3586 L	494	uint32_t addr;
5f7f3586 L	495	uint32_t pos;
9461ecf3 L	496	uint16_t track;
9461ecf3 L	497	uint16_t sec;
7d60b20b	498	uint8_t secs;
9baecc6b	499	bool dowrite;
5f7f3586 L	500	FRESULT res = 0;
	501	uint8_t rc = 0;
	502	bool buserr = 0;
5f7f3586	503
78c90027 L	504	drv = msg[RDRV];
	505	dowrite = (subf == 2);
	506
	507	drv_debug(START, PSTR("%2S"), dowrite ? PSTR("W ") : PSTR(" R"));
	508
afc7c4b4	509	if (len != 10) {
393b1897	510	return msg_cpm_result(subf, 0x01, res);
5f7f3586	511	}
1aed7fd5	512	if ( drv>= CONFIG_CPM_MAX_DRIVE) {
393b1897	513	return msg_cpm_result(subf, 0x02, res);
5f7f3586 L	514	}
5f7f3586 L	515
9baecc6b	516	dp = &drv_table[drv];
9461ecf3 L	517	track = (uint16_t)(msg[TRK+1] << 8) + msg[TRK];
9461ecf3 L	518	sec = (uint16_t)(msg[SEC+1] << 8) + msg[SEC];
7d60b20b	519	secs = msg[CNT];
daacc6f9	520	addr = ((uint32_t)msg[ADDR+2] << 16) + ((uint16_t)msg[ADDR+1] << 8) + msg[ADDR];
5f7f3586	521
78c90027 L	522	if (dp->img_name == NULL) {
	523	/* no media */
	524	return msg_cpm_result(subf, 0x06, res);
	525	}
5f7f3586	526
daacc6f9	527	/* TODO: tracks per sector from dpb */
9461ecf3	528	pos = (track * 8UL + sec) * CONFIG_CPM_BLOCK_SIZE;
5f7f3586	529
78c90027 L	530	drv_debug(MIDDLE, PSTR(" T:%4d, S:%2d, cnt:%2d, lba: %.8lx, addr: %.5lx"),
	531	track, sec, secs, pos, addr);
	532
	533	if (dowrite && dp->opt & DRV_OPT_RO) {
	534	return msg_cpm_result(subf, 0x05, res);
	535	}
	536
5f7f3586	537
1aed7fd5	538	if (pos + secs * CONFIG_CPM_BLOCK_SIZE > CONFIG_CPM_DISKSIZE) {
78c90027 L	539	drv_debug(MIDDLE, PSTR(" access > DISKSIZE:%.8lx!"),
78c90027 L	540	CONFIG_CPM_DISKSIZE);
1aed7fd5 L	541	return msg_cpm_result(subf, 0x04, res);
	542	}
	543
9baecc6b	544	res = f_lseek(&dp->fd, pos);
1aed7fd5	545
7d60b20b	546	while (!res && secs--) {
8bbf185e	547	unsigned int brw;
5f7f3586 L	548	if (dowrite) {
	549	if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
	550	buserr = 1;
7d60b20b	551	break;
5f7f3586	552	} else {
1aed7fd5	553	z80_read_block(disk_buffer, addr, CONFIG_CPM_BLOCK_SIZE);
5f7f3586	554	z80_bus_cmd(Release);
5f7f3586	555	}
9baecc6b	556	res = f_write(&dp->fd, disk_buffer, CONFIG_CPM_BLOCK_SIZE, &brw);
5f7f3586	557	} else {
9baecc6b	558	res = f_read(&dp->fd, disk_buffer, CONFIG_CPM_BLOCK_SIZE, &brw);
1aed7fd5	559	if (res == FR_OK) {
5f7f3586 L	560	if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
5f7f3586 L	561	buserr = 1;
7d60b20b	562	break;
5f7f3586	563	} else {
afc7c4b4	564	z80_write_block(disk_buffer, addr, CONFIG_CPM_BLOCK_SIZE);
5f7f3586 L	565	z80_bus_cmd(Release);
	566	}
	567	}
	568	}
1aed7fd5	569	if (brw != CONFIG_CPM_BLOCK_SIZE) {
78c90027 L	570	drv_debug(MIDDLE, PSTR(" short rd/wr: res: %d, brw: %u"),
78c90027 L	571	res, brw);
afc7c4b4	572	res = 64;
5f7f3586	573	}
1aed7fd5	574	addr += CONFIG_CPM_BLOCK_SIZE;
5f7f3586 L	575	}
5f7f3586 L	576
393b1897	577	if (dowrite && !res) {
9baecc6b	578	dp->flags \|= DRV_FLG_DIRTY;
393b1897 L	579	bg_setstat(handle_cpm_drv_to, 1);
	580	}
	581
5f7f3586	582	if (buserr) {
78c90027	583	/* Bus timeout. how can this happen? */
5f7f3586 L	584	rc = 0x03;
5f7f3586 L	585	}
5f7f3586 L	586
5f7f3586 L	587	/* send result*/
393b1897	588	msg_cpm_result(subf, rc, res);
5f7f3586 L	589	}
5f7f3586 L	590
72f58822 L	591
	592	const FLASH struct msg_item z80_messages[] =
	593	{
	594	{ 0, /* fct nr. */
89adce76	595	1, 3, /* sub fct nr. from, to */
72f58822 L	596	do_msg_ini_memfifo},
	597	{ 1,
	598	1, 1,
	599	do_msg_char_out},
1a2460dc L	600	{ 1,
	601	2, 2,
	602	do_msg_echo},
5f7f3586 L	603	{ 2,
	604	0, 0,
	605	do_msg_cpm_login},
	606	{ 2,
	607	1, 2,
	608	do_msg_cpm_rw},
8590a76b L	609	{ 3,
	610	1, 1,
	611	do_msg_get_timer},
845cbdbd L	612	{ 3,
	613	2, 3, /* 2: get, 3: set time and date */
	614	do_msg_get_set_time},
72f58822 L	615	{ 0xff, /* end mark */
	616	0, 0,
	617	0},
	618
	619	};
	620
	621
	622
	623
	624	void do_message(int len, uint8_t *msg)
	625	{
	626	uint8_t fct, sub_fct;
	627	int_fast8_t i = 0;
	628
	629	if (len >= 2) {
	630	fct = *msg++;
	631	sub_fct = *msg++;
	632	len -= 2;
	633
89adce76 L	634	while (fct != z80_messages[i].fct) {
	635	if (z80_messages[i].fct == 0xff) {
	636	DBG_P(1, "do_message: Unknown function: %i, %i\n",
	637	fct, sub_fct);
	638	return; /* TODO: unknown message # */
	639	}
8a7decea	640
72f58822	641	++i;
72f58822 L	642	}
	643
	644	while (fct == z80_messages[i].fct) {
8a7decea	645	if (sub_fct >= z80_messages[i].sub_min &&
89adce76	646	sub_fct <= z80_messages[i].sub_max )
72f58822 L	647	break;
	648	++i;
	649	}
	650
	651	if (z80_messages[i].fct != fct) {
	652	DBG_P(1, "do_message: Unknown sub function: %i, %i\n",
	653	fct, sub_fct);
	654	return; /* TODO: unknown message sub# */
	655	}
	656
	657	(z80_messages[i].func)(sub_fct, len, msg);
	658
	659
	660	} else {
	661	/* TODO: error */
	662	DBG_P(1, "do_message: to few arguments (%i); this shouldn't happen!\n", len);
	663	}
	664	}
	665
	666
	667
	668	#define CTRBUF_LEN 256
	669
	670	void check_msg_fifo(void)
	671	{
	672	int ch;
	673	static int_fast8_t state;
	674	static int msglen,idx;
	675	static uint8_t buffer[CTRBUF_LEN];
	676
89adce76	677	while ((ch = z80_memfifo_getc(fifo_msgin)) >= 0) {
72f58822 L	678	switch (state) {
72f58822 L	679	case 0: /* wait for start of message */
3531528e	680	if (ch == 0xAE) { /* TODO: magic number */
72f58822 L	681	msglen = 0;
	682	idx = 0;
	683	state = 1;
	684	}
	685	break;
	686	case 1: /* get msg len */
	687	if (ch > 0 && ch <= CTRBUF_LEN) {
	688	msglen = ch;
	689	state = 2;
	690	} else
	691	state = 0;
	692	break;
	693	case 2: /* get message */
	694	buffer[idx++] = ch;
89adce76 L	695	if (idx == msglen) {
	696	do_message(msglen, buffer);
	697	state = 0;
	698	}
	699	break;
	700	}
	701	}
	702	}
	703
	704
	705	int msg_handling(int state)
	706	{
50939dec	707	bool pending;
8a7decea L	708
8a7decea L	709	ATOMIC_BLOCK(ATOMIC_FORCEON) {
89adce76 L	710	pending = (Stat & S_MSG_PENDING) != 0;
	711	Stat &= ~S_MSG_PENDING;
	712	}
8a7decea	713
89adce76	714	if (pending) {
215ec4b2 L	715	uint8_t init_request;
	716	z80_bus_cmd(Request);
	717	init_request = z80_read(0x43);
	718	z80_bus_cmd(Release);
	719	if ( init_request != 0) {
8bbf185e	720	/* Get address of fifo 0 */
89adce76	721	z80_bus_cmd(Request);
8bbf185e L	722	uint32_t fifo_addr = z80_read(0x40) +
	723	((uint16_t) z80_read(0x40+1) << 8) +
	724	((uint32_t) z80_read(0x40+2) << 16);
215ec4b2 L	725	z80_write(0x43, 0);
	726	z80_bus_cmd(Release);
	727
	728	if (fifo_addr != 0) {
	729	z80_memfifo_init(fifo_msgin, fifo_addr);
	730	state = 1;
	731	} else
	732	state = 0;
	733
	734	} else {
89adce76	735	check_msg_fifo();
72f58822 L	736	}
	737	}
	738
89adce76 L	739	return state;
89adce76 L	740	}
89adce76 L	741
	742
	743	static int handle_msg_handling;
	744
	745	void setup_z180_serv(void)
	746	{
8a7decea	747
89adce76	748	handle_msg_handling = bg_register(msg_handling, 0);
393b1897	749	handle_cpm_drv_to = bg_register(cpm_drv_to, 0);
72f58822 L	750	}
72f58822 L	751
89adce76 L	752	void restart_z180_serv(void)
	753	{
	754	z80_bus_cmd(Request);
215ec4b2	755	z80_memset(0x40, 0, 4);
89adce76	756	z80_bus_cmd(Release);
8a7decea L	757
	758	for (int i = 0; i < NUM_FIFOS; i++)
	759	z80_memfifo_init(i, 0);
89adce76	760	bg_setstat(handle_msg_handling, 0);
5f7f3586	761
89adce76	762	}
72f58822	763
845cbdbd	764	#if 0
72f58822 L	765	/--------------------------------------------------------------------------/
72f58822 L	766
72f58822 L	767	const FLASH uint8_t iniprog[] = {
	768	0xAF, // xor a
	769	0xED, 0x39, 0x36, // out0 (rcr),a ;disable DRAM refresh
	770	0x3E, 0x30, // ld a,030h
	771	0xED, 0x39, 0x32 //out0 (dcntl),a ;0 mem, max i/0 wait states
	772	};
	773
	774	const FLASH uint8_t sertest[] = {
	775	0xAF, // xor a
	776	0xED, 0x39, 0x36, // out0 (rcr),a ;disable DRAM refresh
	777	0x3E, 0x30, // ld a,030h
	778	0xED, 0x39, 0x32, // out0 (dcntl),a ;0 mem, max i/0 wait states
	779	0x3E, 0x80, // ld a,M_MPBT ;no MP, PS=10, DR=16, SS=0
	780	0xED, 0x39, 0x03, // out0 (cntlb1),a
	781	0x3E, 0x64, // ld a,M_RE + M_TE + M_MOD2 ;
	782	0xED, 0x39, 0x01, // out0 (cntla1),a
	783	0x3E, 0x00, // ld a,0
	784	0xED, 0x39, 0x05, // out0 (stat1),a ;Enable rx interrupts
	785	0xED, 0x38, 0x05, //l0:in0 a,(stat1)
	786	0xE6, 0x80, // and 80h
	787	0x28, 0xF9, // jr z,l0
	788	0xED, 0x00, 0x09, // in0 b,(rdr1)
	789	0xED, 0x38, 0x05, //l1:in0 a,(stat1)
	790	0xE6, 0x02, // and 02h
	791	0x28, 0xF9, // jr z,l1
	792	0xED, 0x01, 0x07, // out0 (tdr1),b
	793	0x18, 0xEA, // jr l0
	794	};
	795
	796	const FLASH uint8_t test1[] = {
	797	0xAF, // xor a
	798	0xED, 0x39, 0x36, // out0 (rcr),a ;disable DRAM refresh
	799	0x3E, 0x30, // ld a,030h
	800	0xED, 0x39, 0x32, // out0 (dcntl),a ;0 mem, max i/0 wait states
	801	0x21, 0x1E, 0x00, // ld hl,dmclrt ;load DMA registers
	802	0x06, 0x08, // ld b,dmct_e-dmclrt
	803	0x0E, 0x20, // ld c,sar0l
8a7decea	804	0xED, 0x93, // otimr
72f58822 L	805	0x3E, 0xC3, // ld a,0c3h ;dst +1, src +1, burst
72f58822 L	806	0xED, 0x39, 0x31, // out0 (dmode),a ;
8a7decea	807	0x3E, 0x62, // ld a,062h ;enable dma0,
72f58822 L	808	0xED, 0x39, 0x30, //cl_1: out0 (dstat),a ;copy 64k
72f58822 L	809	0x18, 0xFB, // jr cl_1 ;
8a7decea	810	0x00, 0x00, //dmclrt: dw 0 ;src (inc)
72f58822 L	811	0x00, // db 0 ;src
	812	0x00, 0x00, // dw 0 ;dst (inc),
	813	0x00, // db 0 ;dst
	814	0x00, 0x00, // dw 0 ;count (64k)
	815	};
845cbdbd	816	#endif