emu_rom_interface.c

/* Xep128: Minimalistic Enterprise-128 emulator with focus on "exotic" hardware
   Copyright (C)2015,2016 LGB (Gábor Lénárt) <lgblgblgb@gmail.com>
   http://xep128.lgb.hu/

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#include "xep128.h"
#include "emu_rom_interface.h"
#include "data/xep_rom_syms.h"
#include "z80.h"
#include "cpu.h"
#include "roms.h"
#include "emu_monitor.h"
#include "configuration.h"
#include "fileio.h"

#include "main.h"

#include <unistd.h>
#include <time.h>

#define XEPSYM_ADDR(sym) (xep_rom_addr + (sym) - 0xC000)
#define XEPSYM_P(sym) (memory + XEPSYM_ADDR(sym))
#define COBUF ((char*)XEPSYM_P(xepsym_cobuf))
#define SET_XEPSYM_BYTE(sym, value) *XEPSYM_P(sym) = (value)
#define SET_XEPSYM_WORD(sym, value) do {	\
	SET_XEPSYM_BYTE(sym, (value) & 0xFF);	\
	SET_XEPSYM_BYTE((sym) + 1, (value) >> 8);	\
} while(0)
#define BIN2BCD(bin) ((((bin) / 10) << 4) | ((bin) % 10))

static const char EXOS_NEWLINE[] = "\r\n";
Uint8 exos_version = 0;
Uint8 exos_info[8];

#define EXOS_ADDR(n)		(0x3FC000 | ((n) & 0x3FFF))
#define EXOS_BYTE(n)		memory[EXOS_ADDR(n)]
#define EXOS_GET_WORD(n)	(EXOS_BYTE(n) | (EXOS_BYTE((n) + 1) << 8))



void exos_get_status_line ( char *buffer )
{
	Uint8 *s = memory + EXOS_ADDR(EXOS_GET_WORD(0xBFF6));
	int a = 40;
	while (a--)
		*(buffer++) = *(s++) & 0x7F;
	*buffer = '\0';
}


void xep_set_error ( const char *msg )
{
	int l = strlen(msg);
	if (l > 63)
		l = 63;
	SET_XEPSYM_BYTE(xepsym_error_message_buffer, l);
	memcpy(XEPSYM_P(xepsym_error_message_buffer + 1), msg, l);
	DEBUG("XEP: error msg set len=%d len_stored=%d \"%s\"" NL, l, *XEPSYM_P(xepsym_error_message_buffer), msg);
}


void xep_set_time_consts ( char *descbuffer )
{
	struct tm *t = localtime(&unix_time);
	SET_XEPSYM_BYTE(xepsym_settime_hour,    BIN2BCD(t->tm_hour));
	SET_XEPSYM_WORD(xepsym_settime_minsec,  (BIN2BCD(t->tm_min) << 8) | BIN2BCD(t->tm_sec));
	SET_XEPSYM_BYTE(xepsym_setdate_year,    BIN2BCD(t->tm_year - 80));
	SET_XEPSYM_WORD(xepsym_setdate_monday,  (BIN2BCD(t->tm_mon + 1) << 8) | BIN2BCD(t->tm_mday));
	if (descbuffer)
		sprintf(descbuffer, "%04d-%02d-%02d %02d:%02d:%02d",
			t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
			t->tm_hour, t->tm_min, t->tm_sec
		);
	SET_XEPSYM_WORD(xepsym_jump_on_rom_entry, xepsym_set_time);
}



/* Sets XEP ROM jump to the code fragment to utilize EXOS 19 call
   to set default device name provided, with also storing the given
   name */
void xep_set_default_device_name ( const char *name )
{
	int l;
	if (!name)
		name = config_getopt_str("ddn");
	if (!strcasecmp(name, "none"))
		name = "";
	l = strlen(name);
	if (l < 16) {
		if (l)
			memcpy(XEPSYM_P(xepsym_default_device_name_string + 1), name, l);
		SET_XEPSYM_BYTE(xepsym_default_device_name_string, l);
		SET_XEPSYM_WORD(xepsym_jump_on_rom_entry, xepsym_set_default_device_name);
		SET_XEPSYM_BYTE(xepsym_set_default_device_name_is_file_handler, strncasecmp(name, "TAPE", 4) ? 1 : 0);
	} else
		ERROR_WINDOW("Too long default device name is tried to be set, ignoring!");
}



static int exos_cmd_name_match ( const char *that, Uint16 addr )
{
	if (strlen(that) != Z80_B) return 0;
	while (*that)
		if (*(that++) != read_cpu_byte(addr++))
			return 0;
	return 1;
}



static void xep_exos_command_trap ( void )
{
	Uint8 c = Z80_C, b = Z80_B;
	Uint16 de = Z80_DE;
	int size;
	*COBUF = 0; // no ans by def
	DEBUG("XEP: COMMAND TRAP: C=%02Xh, B=%02Xh, DE=%04Xh" NL, c, b, de);
	/* restore exos command handler jump address */
	SET_XEPSYM_WORD(xepsym_jump_on_rom_entry, xepsym_print_xep_buffer);
	switch (c) {
		case 2: // EXOS command
			if (exos_cmd_name_match("XEP", de + 1)) {
				char buffer[256];
				char *p = buffer;
				b = read_cpu_byte(de) - 3;
				de += 4;
				while (b--)
					*(p++) = read_cpu_byte(de++);
				*p = '\0';
				monitor_execute(
					buffer,			// input buffer
					1,			// source system (XEP ROM)
					COBUF,			// output buffer (directly into the co-buffer area!)
					xepsym_cobuf_size - 1,	// max allowed output size
					EXOS_NEWLINE		// newline delimiter requested (for EXOS we use this fixed value! unlike with console/monitor where it's host-OS dependent!)
				);
				Z80_A = 0;
				Z80_C = 0;
			}
			break;
		case 3: // EXOS help
			if (!b) {
				// eg on :HELP (ROM list) we patch the request as ROMNAME monitor command ...
				monitor_execute("ROMNAME", 1, COBUF, xepsym_cobuf_size - 1, EXOS_NEWLINE);
				Z80_A = 0;
			} else if (exos_cmd_name_match("XEP", de + 1)) {
				monitor_execute("HELP", 1, COBUF, xepsym_cobuf_size - 1, EXOS_NEWLINE);
				Z80_A = 0;
				Z80_C = 0;
			}
			break;
		case 8:	// Initialization
			// Tell XEP ROM to set EXOS date/time with setting we will provide here
			xep_set_time_consts(NULL);
			SET_XEPSYM_WORD(xepsym_jump_on_rom_entry, xepsym_system_init);
			break;
		case 1:	// Cold reset (app program can take control here) after the copyright msg ...
			SET_XEPSYM_WORD(xepsym_jump_on_rom_entry, xepsym_cold_reset);
			break;
		case 5:	// explain error code ...
			DEBUG("XEP: explain error code of %02Xh our=%d" NL, Z80_B, Z80_B == XEP_ERROR_CODE);
			if (Z80_B == XEP_ERROR_CODE) {
				Z80_B = xep_rom_seg;
				Z80_DE = xepsym_error_message_buffer;
				Z80_C = 0; // signal that we recognized the error code
			}
			break;
	}
	size = strlen(COBUF);
	if (size)
		DEBUG("XEP: ANSWER: [%d bytes] = \"%s\"" NL, size, COBUF);
	// just a sanity check, monitor_execute() would not allow - in theory ... - to store more data than specified (by MPRINTF)
	if (size > xepsym_cobuf_size - 1)
		FATAL("FATAL: XEP ROM answer is too large, %d bytes.", size);
	SET_XEPSYM_WORD(xepsym_print_size, size);	// set print-out size (0 = no print)
}



void xep_rom_trap ( Uint16 pc, Uint8 opcode )
{
	xep_rom_write_support(0);	// to be safe, let's switch writable XEP ROM off (maybe it was enabled by previous trap?)
	DEBUG("XEP: ROM trap at PC=%04Xh OPC=%02Xh" NL, pc, opcode);
	if (opcode != xepsym_ed_trap_opcode)
		FATAL("FATAL: Unknown ED-trap opcode in XEP ROM: PC=%04Xh ED_OP=%02Xh", pc, opcode);
	switch (pc) {
		case xepsym_trap_enable_rom_write:
			DEBUG("XEP: write access to XEP ROM was requested" NL);
			xep_rom_write_support(1);	// special ROM request to enable ROM write ... Danger Will Robinson!!
			break;
		case xepsym_trap_exos_command:
			xep_exos_command_trap();
			break;
		case xepsym_trap_on_system_init:
			exos_version = Z80_B;	// store EXOS version number we got ...
			memcpy(exos_info, memory + ((xepsym_exos_info_struct & 0x3FFF) | (xep_rom_seg << 14)), 8);
			if (config_getopt_int("skiplogo")) {
				DEBUG("XEP: skiplogo option requested logo skip, etting EXOS variable 0xBFEF to 1 on system init ROM call" NL);
				EXOS_BYTE(0xBFEF) = 1; // use this, to skip Enterprise logo when it would come :-)
			}
			break;
		default:
			FATAL("FATAL: Unknown ED-trap location in XEP ROM: PC=%04Xh (ED_OP=%02Xh)", pc, opcode);
			break;
		//
		/* ---- FILEIO RELATED TRAPS ---- */
		//
		case xepsym_trap_set_default_device_name_feedback:
			// TODO: handle this :)
			break;
		case xepsym_fileio_open_channel_remember:
			fileio_func_open_channel_remember();
			break;
		case xepsym_fileio_no_used_call:
			fileio_func_not_used_call();
			break;
		case xepsym_fileio_open_channel:
			fileio_func_open_or_create_channel(0);
			break;
		case xepsym_fileio_create_channel:
			fileio_func_open_or_create_channel(1);
			break;
		case xepsym_fileio_close_channel:
			fileio_func_close_channel();
			break;
		case xepsym_fileio_destroy_channel:
			fileio_func_destroy_channel();
			break;
		case xepsym_fileio_read_character:
			fileio_func_read_character();
			break;
		case xepsym_fileio_read_block:
			fileio_func_read_block();
			break;
		case xepsym_fileio_write_character:
			fileio_func_write_character();
			break;
		case xepsym_fileio_write_block:
			fileio_func_write_block();
			break;
		case xepsym_fileio_channel_read_status:
			fileio_func_channel_read_status();
			break;
		case xepsym_fileio_set_channel_status:
			fileio_func_set_channel_status();
			break;
		case xepsym_fileio_special_function:
			fileio_func_special_function();
			break;
		case xepsym_fileio_init:
			fileio_func_init();
			break;
		case xepsym_fileio_buffer_moved:
			fileio_func_buffer_moved();
			break;
	}
}