path: root/misc/sims/z80sim/src/main.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <signal.h>
#include <errno.h>

#include "Z80.h"

/* This is the simulated z80 16-bit address space */

static unsigned char memory[65536];

/* This is the simulatin execution context */

static Z80 gR;

/* Command line options */

static int gtrace = 0;
static const char *gfilename = NULL;

/* Name:        RdZ80 and WrZ80
 * Description: These functions are called when access to RAM occurs.
 *              They allow to control memory access.
 */

void WrZ80(register word Addr, register byte Value)
{
	memory[Addr] = Value;
}

byte RdZ80(register word Addr)
{
	return memory[Addr];
}

/* Name:        InZ80 and OutZ80
 * Description: Z80 emulation calls these functions to read/write from
 *              I/O ports. There can be 65536 I/O ports, but only first
 *              256 are usually used.
 */

void OutZ80(register word Port,register byte Value)
{
	/* We recognize only one port, 0xbe, which is mapped to stdout */

	if ((Port & 0x00ff) == 0xbe)
	{
		putchar(Value);
		fflush(stdout);
	}
}

byte InZ80(register word Port)
{
	/* We recognize only one port, 0xbe, which is mapped to stdin */

	if ((Port & 0x00ff) == 0xbe)
	{
		return getchar();
	}
	return 0;
}

/* Name:        PatchZ80
 * Description: Z80 emulation calls this function when it encounters a
 *              special patch command (ED FE) provided for user needs.
 *              For example, it can be called to emulate BIOS calls,
 *              such as disk and tape access. Replace it with an empty
 *              macro for no patching.
 */

void PatchZ80(register Z80 *R)
{
}

/* Name:        LoopZ80
 * Description: Z80 emulation calls this function periodically to check
 *              if the system hardware requires any interrupts. This
 *              function must return an address of the interrupt vector
 *              (0x0038, 0x0066, etc.) or INT_NONE for no interrupt.
 *               Return INT_QUIT to exit the emulation loop.
 */

word LoopZ80(register Z80 *R)
{
	return INT_NONE;
}

/* Name:        JumpZ80
 * Description: Z80 emulation calls this function when it executes a
 *              JP, JR, CALL, RST, or RET. You can use JumpZ80() to
 *              trap these opcodes and switch memory layout.
 */

#ifdef JUMPZ80
void JumpZ80(word PC)
{
	if (gtrace)
	{
		printf("PC: %04X [%02X] HL: %04X SP: %04X [%04X, %04X, ...]\n",
			gR.PC.W, memory[gR.PC.W], gR.HL.W, gR.SP.W,
			((int)memory[gR.SP.W]   | ((int)memory[gR.SP.W+1]) << 8),
			((int)memory[gR.SP.W+2] | ((int)memory[gR.SP.W+3]) << 8));
	}
}
#endif

/* Intel hex code based largely on code taken from the PJRC website.
 * Licensing requires the following:
 *
 * Author:  Paul Stoffregen
 * Contact: paul@ece.orst.edu
 */

/* Name:        parse_hex
 * Description: Parse one line from an Intel hex file
 */

static int parse_hex(const char *hex, unsigned char *binary, int *addr, int *nbytes, int *code)
{
	const char *ptr;
	int accum;
	int chksum;
	int len;
	
	*nbytes = 0;

	/* Each valid hex begins with a colon */

	ptr = hex;
	if (*hex != ':')
	{
		return 0;
	}
	ptr++;

	/* The minimun size is ':'(1) + (0) + addr(4) + type(2) + data(2) + chechksum(2) = 11 */

	if (strlen(hex) < 11)
	{
		return 0;
	}

	/* Get the length byte */

	if (!sscanf(ptr, "%02x", &len))
	{
		return 0;
	}
	ptr += 2;

	/* Now verify the length is ':'(1) + l2*len + addr(4) + type(2) + data(2) + chechksum(2) */

	if (strlen(hex) < (11 + (2*len)))
	{
		return 0;
	}

	/* Get the address */

	if (!sscanf(ptr, "%04x", addr))
	{
		return 0;
	}
	ptr += 4;

	/* Get the code byte */

	if (!sscanf(ptr, "%02x", code))
	{
		return 0;
	}
	ptr += 2;

	/* Copy the data and calculate the chechksum */

	accum = len + (*addr >> 8) + *addr + *code;
	while (*nbytes < len)
	{
		int tmp;

		/* Get the next data byte */

		if (!sscanf(ptr, "%02x", &tmp))
		{
			return 0;
		}
		ptr += 2;

		/* Transfer the data to the user binary */

		binary[*nbytes] = tmp;

		/* Update the accum */

		accum += binary[*nbytes];
		(*nbytes)++;
	}

	/* Get the checksum */

	if (!sscanf(ptr, "%02x", &chksum))
	{
		return 0;
	}

	/* Verify the checksum */

	if (((accum + chksum) & 0xff) != 0)
	{
		return 0;
	}
	return 1;
}

/* Name:        load_file
 * Description: Read an entire Intel hex file into (simulated) z80 memory
 */

int load_file(const char *filename)
{
	char hex[1000];
	FILE *stream;
	unsigned char binary[256];
	int i;
	int total = 0;
	int lineno = 1;
	int minaddr = 65536;
	int maxaddr = 0;
	int addr;
	int nbytes;
	int status;

	/* Open the ascii hex file */

	stream = fopen(filename, "r");
	if (stream == NULL)
	{
		printf("ERROR: Failed to open file '%s' for reading: %s\n", filename, strerror(errno));
		return 0;
	}

	/* Loop until every line has been read */

	while (!feof(stream) && !ferror(stream))
	{
		/* Read the next line from the Intel hex file */

		hex[0] = '\0';
		fgets(hex, 1000, stream);

		/* Remove any trailing CR/LF */

		if (hex[strlen(hex)-1] == '\n')
		{
			hex[strlen(hex)-1] = '\0';
		}

		if (hex[strlen(hex)-1] == '\r')
		{
			hex[strlen(hex)-1] = '\0';
		}

		/* Parse the hex line */

		if (parse_hex(hex, binary, &addr, &nbytes, &status))
		{
			/* Valid data? */

			if (status == 0)
			{
				/* Yes.. move it into the z80 memory image */

				for (i = 0; i <= (nbytes-1); i++)
				{
					memory[addr] = binary[i];
					total++;

					/* Keep track of the highest and lowest addresses written */

					if (addr < minaddr)
					{
						minaddr = addr;
					}

					if (addr > maxaddr)
					{
						maxaddr = addr;
					}
					addr++;
				}
			}

			/* End of file? */

			else if (status == 1)
			{
				fclose(stream);
				printf("Loaded %d bytes between %04x to %04x\n", total, minaddr, maxaddr);
				return 1;
			}
			else if (status != 2)  /* begin of file */
			{
				printf("ERROR: Unrecognized status=%d at line=%d\n", status, lineno);
				return 0;
			}
		}
		else
		{
			printf("ERROR: Failed to parse %s at line: %d\n", filename, lineno);
			return 0;
		}
		lineno++;
	}
	printf("ERROR: No end of file marker encountered in %s\n", filename);
	return 0;
}

/* Name:        sighandler
 * Description: Catch program termination via control-C
 */

void sighandler(int signo)
{
	sigset_t set;
	char command[80];
	int i;
	int j;

	sigemptyset(&set);
	sigaddset(&set, SIGINT);
	sigprocmask(SIG_UNBLOCK, &set, NULL);
	signal(SIGINT, SIG_DFL);

	printf("AF:%04X HL:%04X DE:%04X BC:%04X PC:%04X SP:%04X IX:%04X IY:%04X I:%02X\n",
		gR.AF.W, gR.HL.W, gR.DE.W, gR.BC.W, gR.PC.W, gR.SP.W, gR.IX.W, gR.IY.W, gR.I);

	printf("AT PC: [%02X]  AT SP: [%04X]  %s: %s\n",
		RdZ80(gR.PC.W), RdZ80(gR.SP.W) + RdZ80(gR.SP.W+1) * 256,
		gR.IFF & 0x04? "IM2" : gR.IFF & 0x02? "IM1" : "IM0",
		gR.IFF & 0x01? "EI" : "DI");

	for (;;)
	{
		printf("\n[Command,'?']-> ");
		fflush(stdout);
		fflush(stdin);

		fgets(command, 50, stdin);

		switch(command[0])
		{
		case 'H':
		case 'h':
		case '?':
			puts("\n***** Built-in Z80 Debugger Commands *****");
			puts("m <addr>   : Memory dump at addr");
			puts("?,h        : Show this help text");
			puts("q          : Exit Z80 emulation");
			break;

		case 'M':
		case 'm':
			{
				unsigned short addr;

				if (strlen(command) > 1)
				{
					sscanf(command+1, "%hX", &addr);
				}
				else
				{
					addr = gR.PC.W;
				}

				puts("");
				for (j = 0; j < 16; j++)
				{
					printf("%04X: ",addr);
					for (i = 0; i < 16; i++, addr++)
					{
						printf("%02X ", memory[addr]);
					}
					printf(" | ");
					addr -= 16;
					for (i = 0; i < 16; i++, addr++)
					{
						putchar(isprint(memory[addr])? memory[addr]:'.');
					}
					puts("");
				}
			}
			break;

		case 'Q':
		case 'q':
			exit(0);
		}
	}
	exit(0);
}

static void show_usage(const char *progname, int exitcode)
{
	fprintf(stderr, "\nUSAGE: %s [OPTIONS] <Intel-Hex-File>\n", progname);
	fprintf(stderr, "\nWhere [OPTIONS] include:\n");
	fprintf(stderr, "\n\t-t\tEnable trace output\n");
	fprintf(stderr, "\t-h\tShow this message\n");
	exit(exitcode);
}

static void parse_commandline(int argc, char **argv)
{
	int opt;

	while ((opt = getopt(argc, argv, ":th")) != -1)
	{
		switch (opt)
		{
		case 't':
			gtrace++;
			break;
		case 'h':
			show_usage(argv[0], 0);
			break;
		case '?':
			fprintf(stderr, "ERROR: Unrecognized option: %c\n", optopt);
			show_usage(argv[0], 1);
			break;
		case ':':
			fprintf(stderr, "ERROR: Missing argument to option: %c\n", optopt);
			show_usage(argv[0], 1);
			break;
		}
	}

	if (optind >= argc)
	{
		fprintf(stderr, "ERROR: Missing filename argument\n");
		show_usage(argv[0], 1);
	}

	gfilename = argv[optind];
	optind++;

	if (optind < argc)
	{
		fprintf(stderr, "ERROR: Extra stuff on command line after filename\n");
		show_usage(argv[0], 1);
	}
}

/* Name:        main
 * Description: Program entry point
 */

int main(int argc, char **argv, char **envp)
{
	/* Parse the command line options */

	parse_commandline(argc, argv);

	/* Set all simulated z80 memory to a known value and load the Intel hex file */

	memset(memory, 0, 65536);
	load_file(gfilename);

	/* Configure the simulation */

	memset(&gR, 0, sizeof(Z80));
	gR.IPeriod    = 10000; /* 100Hz at 10MHz */
	gR.IAutoReset = 1;

	/* Set up to catch SIGINT (control-C from console) */

	(void)signal(SIGINT, sighandler);

	/* Then start the simulation */

	RunZ80(&gR);
	return 0;
}