1 /* CPU emulation loop and memory access
3 * (C) 2018 by Andreas Eversberg <jolly@eversberg.eu>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "../libsdl/print.h"
30 #define IOMASK 0xfffff000
31 #define IOBASE 0x00dff000
33 static uint8_t *memory = NULL;
34 static uint32_t memory_size = 0;
35 static uint16_t *chipreg = NULL;
36 static uint16_t (*io_read)(uint32_t address) = NULL;
37 static void (*io_write)(uint32_t address, uint16_t value) = NULL;
40 static uint16_t read_io_16(unsigned int address)
43 printf("Chip read from 0x%08x\n", address);
45 return io_read(address);
48 static void write_io_16(unsigned int address, uint16_t value)
51 printf("Chip write to 0x%08x\n", address);
53 if ((address & IOMASK) == IOBASE)
54 chipreg[address & ~IOMASK] = value;
55 io_write(address, value);
58 unsigned int m68k_read_memory_8(unsigned int address)
60 if (address > memory_size - 1) {
62 /* read lower (right) byte */
63 return read_io_16(address & ~1);
65 /* read upper (left) byte */
66 return read_io_16(address) >> 8;
69 return *((uint8_t *)(memory + address));
72 unsigned int m68k_read_memory_16(unsigned int address)
74 if (address > memory_size - 2) {
75 return read_io_16(address);
77 return (memory[address] << 8) |
81 unsigned int m68k_read_memory_32(unsigned int address)
83 if (address > memory_size - 4) {
85 value = read_io_16(address) << 16;
86 value |= read_io_16(address + 2);
89 return (memory[address] << 24)|
90 (memory[address + 1] << 16) |
91 (memory[address + 2] << 8) |
95 void m68k_write_memory_8(unsigned int address, unsigned int value)
97 if (address > memory_size - 1) {
99 /* write lower (right) byte */
100 write_io_16(address & ~1, 0xff00 | value);
102 /* write upper (left) byte */
103 write_io_16(address, 0x00ff | (value << 8));
107 *((uint8_t *)(memory + address)) = value;
110 void m68k_write_memory_16(unsigned int address, unsigned int value)
112 if (address > memory_size - 2) {
113 write_io_16(address, value);
116 memory[address] = value >> 8;
117 memory[address + 1] = value;
120 void m68k_write_memory_32(unsigned int address, unsigned int value)
122 if (address > memory_size - 4) {
123 write_io_16(address, value >> 16);
124 write_io_16(address + 2, value);
127 memory[address] = value >> 24;
128 memory[address + 1] = value >> 16;
129 memory[address + 2] = value >> 8;
130 memory[address + 3] = value;
133 void execute_init(int32_t _memory_size, uint8_t *_memory, uint16_t *_chipreg, uint16_t (*_io_read)(uint32_t address), void (*_io_write)(uint32_t address, uint16_t value))
135 memory_size = _memory_size;
139 io_write = _io_write;
143 m68k_set_cpu_type(M68K_CPU_TYPE_68000);
151 int execute_cpu(int irq, const struct cpu_stop stop_at[], int *event)
154 int instruction_count = 0;
161 /* loop until we returned from interrupt */
163 /* execute one opcode */
164 cycle_count += m68k_execute(0);
166 } while (REG_PC != save_pc);
168 printf("interrupt %d took %d opcodes\n", irq, instruction_count);
172 /* execute one opcode */
173 cycle_count += m68k_execute(0);
176 /* checking if game does not hit any 'stop_at' break point, give error output */
177 if (instruction_count >= 10000000) {
178 if (instruction_count == 10000000)
179 print_error("!!! games seems to got stuck in an endless loop, please fix !!!\n");
180 fprintf(stderr, "program counter at: %06x\n", REG_PC);
181 if (instruction_count == 10000020)
185 for (i = 0; stop_at[i].event; i++) {
186 if (REG_PC == stop_at[i].pc) {
188 print_error("execution to address 0x%06x took %d opcodes\n", REG_PC, instruction_count);
190 *event = stop_at[i].event;