Mercurial > repos > blastem

comparison genesis.c @ 2500:d44fe974fb85

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Get blastem compiling with new 68K core
author Michael Pavone <pavone@retrodev.com>
date Tue, 30 Apr 2024 22:32:08 -0700
parents d74d3998482c
children 25e40370e0e4
comparison
equal deleted inserted replaced
2499:d74d3998482c 2500:d44fe974fb85
135 135
136 static uint8_t *serialize(system_header *sys, size_t *size_out) 136 static uint8_t *serialize(system_header *sys, size_t *size_out)
137 { 137 {
138 genesis_context *gen = (genesis_context *)sys; 138 genesis_context *gen = (genesis_context *)sys;
139 uint32_t address; 139 uint32_t address;
140 #ifndef NEW_CORE
140 if (gen->m68k->resume_pc) { 141 if (gen->m68k->resume_pc) {
141 142
142 gen->header.save_state = SERIALIZE_SLOT+1; 143 gen->header.save_state = SERIALIZE_SLOT+1;
143 while (!gen->serialize_tmp) 144 while (!gen->serialize_tmp)
144 { 145 {
149 *size_out = gen->serialize_size; 150 *size_out = gen->serialize_size;
150 } 151 }
151 uint8_t *ret = gen->serialize_tmp; 152 uint8_t *ret = gen->serialize_tmp;
152 gen->serialize_tmp = NULL; 153 gen->serialize_tmp = NULL;
153 return ret; 154 return ret;
154 } else { 155 } else
156 #endif
157 {
155 serialize_buffer state; 158 serialize_buffer state;
156 init_serialize(&state); 159 init_serialize(&state);
157 uint32_t address = read_word(4, (void **)gen->m68k->mem_pointers, &gen->m68k->opts->gen, gen->m68k) << 16; 160 uint32_t address = read_word(4, (void **)gen->m68k->mem_pointers, &gen->m68k->opts->gen, gen->m68k) << 16;
158 address |= read_word(6, (void **)gen->m68k->mem_pointers, &gen->m68k->opts->gen, gen->m68k); 161 address |= read_word(6, (void **)gen->m68k->mem_pointers, &gen->m68k->opts->gen, gen->m68k);
159 genesis_serialize(gen, &state, address, 1); 162 genesis_serialize(gen, &state, address, 1);
221 } 224 }
222 225
223 static void adjust_int_cycle(m68k_context * context, vdp_context * v_context); 226 static void adjust_int_cycle(m68k_context * context, vdp_context * v_context);
224 static void check_tmss_lock(genesis_context *gen); 227 static void check_tmss_lock(genesis_context *gen);
225 static void toggle_tmss_rom(genesis_context *gen); 228 static void toggle_tmss_rom(genesis_context *gen);
229 #ifndef NEW_CORE
226 #include "m68k_internal.h" //needed for get_native_address_trans, should be eliminated once handling of PC is cleaned up 230 #include "m68k_internal.h" //needed for get_native_address_trans, should be eliminated once handling of PC is cleaned up
231 #endif
227 void genesis_deserialize(deserialize_buffer *buf, genesis_context *gen) 232 void genesis_deserialize(deserialize_buffer *buf, genesis_context *gen)
228 { 233 {
229 register_section_handler(buf, (section_handler){.fun = m68k_deserialize, .data = gen->m68k}, SECTION_68000); 234 register_section_handler(buf, (section_handler){.fun = m68k_deserialize, .data = gen->m68k}, SECTION_68000);
230 register_section_handler(buf, (section_handler){.fun = vdp_deserialize, .data = gen->vdp}, SECTION_VDP); 235 register_section_handler(buf, (section_handler){.fun = vdp_deserialize, .data = gen->vdp}, SECTION_VDP);
231 register_section_handler(buf, (section_handler){.fun = psg_deserialize, .data = gen->psg}, SECTION_PSG); 236 register_section_handler(buf, (section_handler){.fun = psg_deserialize, .data = gen->psg}, SECTION_PSG);
266 } 271 }
267 check_tmss_lock(gen); 272 check_tmss_lock(gen);
268 } 273 }
269 update_z80_bank_pointer(gen); 274 update_z80_bank_pointer(gen);
270 adjust_int_cycle(gen->m68k, gen->vdp); 275 adjust_int_cycle(gen->m68k, gen->vdp);
276 #ifndef NEW_CORE
271 //HACK: Fix this once PC/IR is represented in a better way in 68K core 277 //HACK: Fix this once PC/IR is represented in a better way in 68K core
272 //Would be better for this hack to live in side the 68K core itself, but it's better to do it 278 //Would be better for this hack to live in side the 68K core itself, but it's better to do it
273 //after RAM has been loaded to avoid any unnecessary retranslation 279 //after RAM has been loaded to avoid any unnecessary retranslation
274 gen->m68k->resume_pc = get_native_address_trans(gen->m68k, gen->m68k->last_prefetch_address); 280 gen->m68k->resume_pc = get_native_address_trans(gen->m68k, gen->m68k->last_prefetch_address);
275 if (gen->expansion) { 281 if (gen->expansion) {
276 segacd_context *cd = gen->expansion; 282 segacd_context *cd = gen->expansion;
277 cd->m68k->resume_pc = get_native_address_trans(cd->m68k, cd->m68k->last_prefetch_address); 283 cd->m68k->resume_pc = get_native_address_trans(cd->m68k, cd->m68k->last_prefetch_address);
278 } 284 }
285 #endif
279 free(buf->handlers); 286 free(buf->handlers);
280 buf->handlers = NULL; 287 buf->handlers = NULL;
281 } 288 }
282 289
283 static void deserialize(system_header *sys, uint8_t *data, size_t size) 290 static void deserialize(system_header *sys, uint8_t *data, size_t size)
299 if (genesis->expansion) { 306 if (genesis->expansion) {
300 segacd_context *cd = genesis->expansion; 307 segacd_context *cd = genesis->expansion;
301 uint32_t word_ram = cd->base + 0x200000; 308 uint32_t word_ram = cd->base + 0x200000;
302 uint32_t word_ram_end = cd->base + 0x240000; 309 uint32_t word_ram_end = cd->base + 0x240000;
303 if (address >= word_ram && address < word_ram_end) { 310 if (address >= word_ram && address < word_ram_end) {
304 //FIXME: first word should just be garbage
305 if (!cd->has_vdp_dma_value) { 311 if (!cd->has_vdp_dma_value) {
312 #ifdef NEW_CORE
313 cd->vdp_dma_value = genesis->m68k->prefetch;
314 #else
306 cd->vdp_dma_value = read_word(genesis->m68k->last_prefetch_address, (void **)genesis->m68k->mem_pointers, &genesis->m68k->opts->gen, genesis->m68k); 315 cd->vdp_dma_value = read_word(genesis->m68k->last_prefetch_address, (void **)genesis->m68k->mem_pointers, &genesis->m68k->opts->gen, genesis->m68k);
316 #endif
307 cd->has_vdp_dma_value = 1; 317 cd->has_vdp_dma_value = 1;
308 } 318 }
309 uint16_t ret = cd->vdp_dma_value; 319 uint16_t ret = cd->vdp_dma_value;
310 cd->vdp_dma_value = read_word(address, (void **)genesis->m68k->mem_pointers, &genesis->m68k->opts->gen, genesis->m68k); 320 cd->vdp_dma_value = read_word(address, (void **)genesis->m68k->mem_pointers, &genesis->m68k->opts->gen, genesis->m68k);
311 return ret; 321 return ret;
326 336
327 337
328 static uint16_t get_open_bus_value(system_header *system) 338 static uint16_t get_open_bus_value(system_header *system)
329 { 339 {
330 genesis_context *genesis = (genesis_context *)system; 340 genesis_context *genesis = (genesis_context *)system;
341 #ifdef NEW_CORE
342 return genesis->m68k->prefetch;
343 #else
331 return read_dma_value(genesis->m68k->last_prefetch_address/2); 344 return read_dma_value(genesis->m68k->last_prefetch_address/2);
345 #endif
332 } 346 }
333 347
334 static void adjust_int_cycle(m68k_context * context, vdp_context * v_context) 348 static void adjust_int_cycle(m68k_context * context, vdp_context * v_context)
335 { 349 {
336 //static int old_int_cycle = CYCLE_NEVER; 350 //static int old_int_cycle = CYCLE_NEVER;
1943 genesis_context *gen = (genesis_context *)system; 1957 genesis_context *gen = (genesis_context *)system;
1944 char *statepath = get_slot_name(system, slot, "state"); 1958 char *statepath = get_slot_name(system, slot, "state");
1945 deserialize_buffer state; 1959 deserialize_buffer state;
1946 uint32_t pc = 0; 1960 uint32_t pc = 0;
1947 uint8_t ret; 1961 uint8_t ret;
1962 #ifndef NEW_CORE
1948 if (!gen->m68k->resume_pc) { 1963 if (!gen->m68k->resume_pc) {
1949 system->delayed_load_slot = slot + 1; 1964 system->delayed_load_slot = slot + 1;
1950 gen->m68k->should_return = 1; 1965 gen->m68k->should_return = 1;
1951 ret = get_modification_time(statepath) != 0; 1966 ret = get_modification_time(statepath) != 0;
1952 if (!ret) { 1967 if (!ret) {
1953 strcpy(statepath + strlen(statepath)-strlen("state"), "gst"); 1968 strcpy(statepath + strlen(statepath)-strlen("state"), "gst");
1954 ret = get_modification_time(statepath) != 0; 1969 ret = get_modification_time(statepath) != 0;
1955 } 1970 }
1956 goto done; 1971 goto done;
1957 } 1972 }
1973 #endif
1958 if (load_from_file(&state, statepath)) { 1974 if (load_from_file(&state, statepath)) {
1959 genesis_deserialize(&state, gen); 1975 genesis_deserialize(&state, gen);
1960 free(state.data); 1976 free(state.data);
1961 ret = 1; 1977 ret = 1;
1962 } else { 1978 } else {
2013 deserialize_buffer state; 2029 deserialize_buffer state;
2014 uint32_t pc; 2030 uint32_t pc;
2015 if (load_from_file(&state, statefile)) { 2031 if (load_from_file(&state, statefile)) {
2016 genesis_deserialize(&state, gen); 2032 genesis_deserialize(&state, gen);
2017 free(state.data); 2033 free(state.data);
2034 #ifdef NEW_CORE
2035 pc = gen->m68k->pc;
2036 #else
2018 //HACK 2037 //HACK
2019 pc = gen->m68k->last_prefetch_address; 2038 pc = gen->m68k->last_prefetch_address;
2039 #endif
2020 } else { 2040 } else {
2021 pc = load_gst(gen, statefile); 2041 pc = load_gst(gen, statefile);
2022 if (!pc) { 2042 if (!pc) {
2023 fatal_error("Failed to load save state %s\n", statefile); 2043 fatal_error("Failed to load save state %s\n", statefile);
2024 } 2044 }
2045 insert_breakpoint(gen->m68k, address, gen->header.debugger_type == DEBUGGER_NATIVE ? debugger : gdb_debug_enter); 2065 insert_breakpoint(gen->m68k, address, gen->header.debugger_type == DEBUGGER_NATIVE ? debugger : gdb_debug_enter);
2046 #endif 2066 #endif
2047 } 2067 }
2048 m68k_reset(gen->m68k); 2068 m68k_reset(gen->m68k);
2049 } 2069 }
2070 #ifdef NEW_CORE
2071 while (!gen->m68k->should_return) {
2072 sync_components(gen->m68k, 0);
2073 m68k_execute(gen->m68k, gen->m68k->target_cycle);
2074 }
2075 #endif
2050 handle_reset_requests(gen); 2076 handle_reset_requests(gen);
2051 return; 2077 return;
2052 } 2078 }
2053 2079
2054 static void resume_genesis(system_header *system) 2080 static void resume_genesis(system_header *system)