3b1emu: src/musashi/example/sim.c@2f8afb9e5baa (annotated)

file
revisions
annotate
diff
raw

src/musashi/example/sim.c@2f8afb9e5baa (annotated)

src/musashi/example/sim.c

Tue, 15 Nov 2011 10:12:37 +0000

author: Philip Pemberton <philpem@philpem.me.uk>
date: Tue, 15 Nov 2011 10:12:37 +0000
changeset 109: 2f8afb9e5baa
parent 0: 8bf1bf91a36d
permissions: -rw-r--r--

[musashi] Fix handling of bus errors

Patch-Author: Andrew Warkentin <andreww591!gmail>
Patch-MessageID: <4EC200CE.2020304@gmail.com>

I have fixed the first page fault test failure in FreeBee (the page fault test now hangs rather than errors out, because it is trying to read from the hard drive to test DMA page faults).

There were actually two bugs (the first bug was masking the second one).

First, the ancient version of Musashi that you used is unable to properly resume from bus errors that happen in the middle of certain instructions (some instructions are fetched in stages, with the PC being advanced to each part of the instruction, so basically what happens is the CPU core attempts to read the memory location referenced by the first operand, the bus error occurs, causing the PC to jump to the exception vector, but the faulting instruction is still in the middle of being fetched, so the PC is then advanced past the beginning of the exception handler). I fixed this by delaying the jump to the bus error vector until after the faulting instruction finishes.

The second bug is simpler - you had the UDS and LDS bits in BSR0 inverted (they are supposed to be active low).

 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <time.h>
 #include "sim.h"
 #include "m68k.h"
 /* Memory-mapped IO ports */
 #define INPUT_ADDRESS 0x800000
 #define OUTPUT_ADDRESS 0x400000
 /* IRQ connections */
 #define IRQ_NMI_DEVICE 7
 #define IRQ_INPUT_DEVICE 2
 #define IRQ_OUTPUT_DEVICE 1
 /* Time between characters sent to output device (seconds) */
 #define OUTPUT_DEVICE_PERIOD 1
 /* ROM and RAM sizes */
 #define MAX_ROM 0xfff
 #define MAX_RAM 0xff
 /* Read/write macros */
 #define READ_BYTE(BASE, ADDR) (BASE)[ADDR]
 #define READ_WORD(BASE, ADDR) (((BASE)[ADDR]<<8) |			\
 							  (BASE)[(ADDR)+1])
 #define READ_LONG(BASE, ADDR) (((BASE)[ADDR]<<24) |			\
 							  ((BASE)[(ADDR)+1]<<16) |		\
 							  ((BASE)[(ADDR)+2]<<8) |		\
 							  (BASE)[(ADDR)+3])
 #define WRITE_BYTE(BASE, ADDR, VAL) (BASE)[ADDR] = (VAL)%0xff
 #define WRITE_WORD(BASE, ADDR, VAL) (BASE)[ADDR] = ((VAL)>>8) & 0xff;		\
 									(BASE)[(ADDR)+1] = (VAL)&0xff
 #define WRITE_LONG(BASE, ADDR, VAL) (BASE)[ADDR] = ((VAL)>>24) & 0xff;		\
 									(BASE)[(ADDR)+1] = ((VAL)>>16)&0xff;	\
 									(BASE)[(ADDR)+2] = ((VAL)>>8)&0xff;		\
 									(BASE)[(ADDR)+3] = (VAL)&0xff
 /* Prototypes */
 void exit_error(char* fmt, ...);
 int osd_get_char(void);
 unsigned int m68k_read_memory_8(unsigned int address);
 unsigned int m68k_read_memory_16(unsigned int address);
 unsigned int m68k_read_memory_32(unsigned int address);
 void m68k_write_memory_8(unsigned int address, unsigned int value);
 void m68k_write_memory_16(unsigned int address, unsigned int value);
 void m68k_write_memory_32(unsigned int address, unsigned int value);
 void cpu_pulse_reset(void);
 void cpu_set_fc(unsigned int fc);
 int cpu_irq_ack(int level);
 void nmi_device_reset(void);
 void nmi_device_update(void);
 int nmi_device_ack(void);
 void input_device_reset(void);
 void input_device_update(void);
 int input_device_ack(void);
 unsigned int input_device_read(void);
 void input_device_write(unsigned int value);
 void output_device_reset(void);
 void output_device_update(void);
 int output_device_ack(void);
 unsigned int output_device_read(void);
 void output_device_write(unsigned int value);
 void int_controller_set(unsigned int value);
 void int_controller_clear(unsigned int value);
 void get_user_input(void);
 /* Data */
 unsigned int g_quit = 0;						/* 1 if we want to quit */
 unsigned int g_nmi = 0;							/* 1 if nmi pending */
 int g_input_device_value = -1;					/* Current value in input device */
 unsigned int g_output_device_ready = 0;			/* 1 if output device is ready */
 time_t g_output_device_last_output;				/* Time of last char output */
 unsigned int g_int_controller_pending = 0;		/* list of pending interrupts */
 unsigned int g_int_controller_highest_int = 0;	/* Highest pending interrupt */
 unsigned char g_rom[MAX_ROM+1];					/* ROM */
 unsigned char g_ram[MAX_RAM+1];					/* RAM */
 unsigned int g_fc;								/* Current function code from CPU */
 /* Exit with an error message.  Use printf syntax. */
 void exit_error(char* fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
 	vfprintf(stderr, fmt, args);
 	va_end(args);
 	fprintf(stderr, "\n");
 	exit(EXIT_FAILURE);
 }
 /* OS-dependant code to get a character from the user.
  * This function must not block, and must either return an ASCII code or -1.
  */
 //#include <conio.h>
 int osd_get_char(void)
 {
 	int ch = -1;
 /*	if(kbhit())
 	{
 		while(kbhit())
 			ch = getch();
 	}
 */	return ch;
 }
 /* Read data from RAM, ROM, or a device */
 unsigned int m68k_read_memory_8(unsigned int address)
 {
 	if(g_fc & 2)	/* Program */
 	{
 		if(address > MAX_ROM)
 			exit_error("Attempted to read byte from ROM address %08x", address);
 		return READ_BYTE(g_rom, address);
 	}
 	/* Otherwise it's data space */
 	switch(address)
 	{
 		case INPUT_ADDRESS:
 			return input_device_read();
 		case OUTPUT_ADDRESS:
 			return output_device_read();
 		default:
 			break;
 	}
 	if(address > MAX_RAM)
 		exit_error("Attempted to read byte from RAM address %08x", address);
 		return READ_BYTE(g_ram, address);
 }
 unsigned int m68k_read_memory_16(unsigned int address)
 {
 	if(g_fc & 2)	/* Program */
 	{
 		if(address > MAX_ROM)
 			exit_error("Attempted to read word from ROM address %08x", address);
 		return READ_WORD(g_rom, address);
 	}
 	/* Otherwise it's data space */
 	switch(address)
 	{
 		case INPUT_ADDRESS:
 			return input_device_read();
 		case OUTPUT_ADDRESS:
 			return output_device_read();
 		default:
 			break;
 	}
 	if(address > MAX_RAM)
 		exit_error("Attempted to read word from RAM address %08x", address);
 		return READ_WORD(g_ram, address);
 }
 unsigned int m68k_read_memory_32(unsigned int address)
 {
 	if(g_fc & 2)	/* Program */
 	{
 		if(address > MAX_ROM)
 			exit_error("Attempted to read long from ROM address %08x", address);
 		return READ_LONG(g_rom, address);
 	}
 	/* Otherwise it's data space */
 	switch(address)
 	{
 		case INPUT_ADDRESS:
 			return input_device_read();
 		case OUTPUT_ADDRESS:
 			return output_device_read();
 		default:
 			break;
 	}
 	if(address > MAX_RAM)
 		exit_error("Attempted to read long from RAM address %08x", address);
 		return READ_LONG(g_ram, address);
 }
 /* Write data to RAM or a device */
 void m68k_write_memory_8(unsigned int address, unsigned int value)
 {
 	if(g_fc & 2)	/* Program */
 		exit_error("Attempted to write %02x to ROM address %08x", value&0xff, address);
 	/* Otherwise it's data space */
 	switch(address)
 	{
 		case INPUT_ADDRESS:
 			input_device_write(value&0xff);
 			return;
 		case OUTPUT_ADDRESS:
 			output_device_write(value&0xff);
 			return;
 		default:
 			break;
 	}
 	if(address > MAX_RAM)
 		exit_error("Attempted to write %02x to RAM address %08x", value&0xff, address);
 	WRITE_BYTE(g_ram, address, value);
 }
 void m68k_write_memory_16(unsigned int address, unsigned int value)
 {
 	if(g_fc & 2)	/* Program */
 		exit_error("Attempted to write %04x to ROM address %08x", value&0xffff, address);
 	/* Otherwise it's data space */
 	switch(address)
 	{
 		case INPUT_ADDRESS:
 			input_device_write(value&0xffff);
 			return;
 		case OUTPUT_ADDRESS:
 			output_device_write(value&0xffff);
 			return;
 		default:
 			break;
 	}
 	if(address > MAX_RAM)
 		exit_error("Attempted to write %04x to RAM address %08x", value&0xffff, address);
 	WRITE_WORD(g_ram, address, value);
 }
 void m68k_write_memory_32(unsigned int address, unsigned int value)
 {
 	if(g_fc & 2)	/* Program */
 		exit_error("Attempted to write %08x to ROM address %08x", value, address);
 	/* Otherwise it's data space */
 	switch(address)
 	{
 		case INPUT_ADDRESS:
 			input_device_write(value);
 			return;
 		case OUTPUT_ADDRESS:
 			output_device_write(value);
 			return;
 		default:
 			break;
 	}
 	if(address > MAX_RAM)
 		exit_error("Attempted to write %08x to RAM address %08x", value, address);
 	WRITE_LONG(g_ram, address, value);
 }
 /* Called when the CPU pulses the RESET line */
 void cpu_pulse_reset(void)
 {
 	nmi_device_reset();
 	output_device_reset();
 	input_device_reset();
 }
 /* Called when the CPU changes the function code pins */
 void cpu_set_fc(unsigned int fc)
 {
 	g_fc = fc;
 }
 /* Called when the CPU acknowledges an interrupt */
 int cpu_irq_ack(int level)
 {
 	switch(level)
 	{
 		case IRQ_NMI_DEVICE:
 			return nmi_device_ack();
 		case IRQ_INPUT_DEVICE:
 			return input_device_ack();
 		case IRQ_OUTPUT_DEVICE:
 			return output_device_ack();
 	}
 	return M68K_INT_ACK_SPURIOUS;
 }
 /* Implementation for the NMI device */
 void nmi_device_reset(void)
 {
 	g_nmi = 0;
 }
 void nmi_device_update(void)
 {
 	if(g_nmi)
 	{
 		g_nmi = 0;
 		int_controller_set(IRQ_NMI_DEVICE);
 	}
 }
 int nmi_device_ack(void)
 {
 	printf("\nNMI\n");fflush(stdout);
 	int_controller_clear(IRQ_NMI_DEVICE);
 	return M68K_INT_ACK_AUTOVECTOR;
 }
 /* Implementation for the input device */
 void input_device_reset(void)
 {
 	g_input_device_value = -1;
 	int_controller_clear(IRQ_INPUT_DEVICE);
 }
 void input_device_update(void)
 {
 	if(g_input_device_value >= 0)
 		int_controller_set(IRQ_INPUT_DEVICE);
 }
 int input_device_ack(void)
 {
 	return M68K_INT_ACK_AUTOVECTOR;
 }
 unsigned int input_device_read(void)
 {
 	int value = g_input_device_value > 0 ? g_input_device_value : 0;
 	int_controller_clear(IRQ_INPUT_DEVICE);
 	g_input_device_value = -1;
 	return value;
 }
 void input_device_write(unsigned int value)
 {
 }
 /* Implementation for the output device */
 void output_device_reset(void)
 {
 	g_output_device_last_output = time(NULL);
 	g_output_device_ready = 0;
 	int_controller_clear(IRQ_OUTPUT_DEVICE);
 }
 void output_device_update(void)
 {
 	if(!g_output_device_ready)
 	{
 		if((time(NULL) - g_output_device_last_output) >= OUTPUT_DEVICE_PERIOD)
 		{
 			g_output_device_ready = 1;
 			int_controller_set(IRQ_OUTPUT_DEVICE);
 		}
 	}
 }
 int output_device_ack(void)
 {
 	return M68K_INT_ACK_AUTOVECTOR;
 }
 unsigned int output_device_read(void)
 {
 	int_controller_clear(IRQ_OUTPUT_DEVICE);
 	return 0;
 }
 void output_device_write(unsigned int value)
 {
 	char ch;
 	if(g_output_device_ready)
 	{
 		ch = value & 0xff;
 		printf("%c", ch);
 		g_output_device_last_output = time(NULL);
 		g_output_device_ready = 0;
 		int_controller_clear(IRQ_OUTPUT_DEVICE);
 	}
 }
 /* Implementation for the interrupt controller */
 void int_controller_set(unsigned int value)
 {
 	unsigned int old_pending = g_int_controller_pending;
 	g_int_controller_pending |= (1<<value);
 	if(old_pending != g_int_controller_pending && value > g_int_controller_highest_int)
 	{
 		g_int_controller_highest_int = value;
 		m68k_set_irq(g_int_controller_highest_int);
 	}
 }
 void int_controller_clear(unsigned int value)
 {
 	g_int_controller_pending &= ~(1<<value);
 	for(g_int_controller_highest_int = 7;g_int_controller_highest_int > 0;g_int_controller_highest_int--)
 		if(g_int_controller_pending & (1<<g_int_controller_highest_int))
 			break;
 	m68k_set_irq(g_int_controller_highest_int);
 }
 /* Parse user input and update any devices that need user input */
 void get_user_input(void)
 {
 	static int last_ch = -1;
 	int ch = osd_get_char();
 	if(ch >= 0)
 	{
 		switch(ch)
 		{
 			case 0x1b:
 				g_quit = 1;
 				break;
 			case '~':
 				if(last_ch != ch)
 					g_nmi = 1;
 				break;
 			default:
 				g_input_device_value = ch;
 		}
 	}
 	last_ch = ch;
 }
 /* The main loop */
 int main(int argc, char* argv[])
 {
 	FILE* fhandle;
 	if(argc != 2)
 		exit_error("Usage: sim <program file>");
 	if((fhandle = fopen(argv[1], "rb")) == NULL)
 		exit_error("Unable to open %s", argv[1]);
 	if(fread(g_rom, 1, MAX_ROM+1, fhandle) <= 0)
 		exit_error("Error reading %s", argv[1]);
 	m68k_pulse_reset();
 	input_device_reset();
 	output_device_reset();
 	nmi_device_reset();
 	g_quit = 0;
 	while(!g_quit)
 	{
 		get_user_input();
 		/* Note that I am not emulating the correct clock speed! */
 		m68k_execute(1000);
 		output_device_update();
 		input_device_update();
 		nmi_device_update();
 	}
 	return 0;
 }

3b1emu / annotate

src/musashi/example/sim.c@2f8afb9e5baa (annotated)

src/musashi/example/sim.c