Mercurial > repos > blastem

comparison gst.c @ 487:c08a4efeee7f opengl

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update opengl branch from default. Fix build breakage unrelated to merge
author Mike Pavone <pavone@retrodev.com>
date Sat, 26 Oct 2013 22:38:47 -0700
parents 140af5509ce7
children 5439ae7946ca
comparison
equal deleted inserted replaced
449:7696d824489d 487:c08a4efeee7f
1 /*
2 Copyright 2013 Michael Pavone
3 This file is part of BlastEm.
4 BlastEm is free software distributed under the terms of the GNU General Public License version 3 or greater. See COPYING for full license text.
5 */
6 #include "gst.h"
7 #include <string.h>
8
9 #define GST_68K_REGS 0x80
10 #define GST_68K_REG_SIZE (0xDA-GST_68K_REGS)
11 #define GST_68K_PC_OFFSET (0xC8-GST_68K_REGS)
12 #define GST_68K_SR_OFFSET (0xD0-GST_68K_REGS)
13 #define GST_68K_USP_OFFSET (0xD2-GST_68K_REGS)
14 #define GST_68K_SSP_OFFSET (0xD6-GST_68K_REGS)
15 #define GST_68K_RAM 0x2478
16 #define GST_Z80_REGS 0x404
17 #define GST_Z80_REG_SIZE (0x440-GST_Z80_REGS)
18 #define GST_Z80_RAM 0x474
19 #define GST_VDP_REGS 0xFA
20 #define GST_VDP_MEM 0x12478
21 #define GST_YM_OFFSET 0x1E4
22 #define GST_YM_SIZE (0x3E4-GST_YM_OFFSET)
23
24 uint32_t read_le_32(uint8_t * data)
25 {
26 return data[3] << 24 | data[2] << 16 | data[1] << 8 | data[0];
27 }
28
29 uint16_t read_le_16(uint8_t * data)
30 {
31 return data[1] << 8 | data[0];
32 }
33
34 uint16_t read_be_16(uint8_t * data)
35 {
36 return data[0] << 8 | data[1];
37 }
38
39 void write_le_32(uint8_t * dst, uint32_t val)
40 {
41 dst[0] = val;
42 dst[1] = val >> 8;
43 dst[2] = val >> 16;
44 dst[3] = val >> 24;
45 }
46
47 void write_le_16(uint8_t * dst, uint16_t val)
48 {
49 dst[0] = val;
50 dst[1] = val >> 8;
51 }
52
53 void write_be_32(uint8_t * dst, uint32_t val)
54 {
55 dst[0] = val >> 24;
56 dst[1] = val >> 16;
57 dst[2] = val >> 8;
58 dst[3] = val;
59 }
60
61 void write_be_16(uint8_t * dst, uint16_t val)
62 {
63 dst[0] = val >> 8;
64 dst[1] = val;
65 }
66
67 uint32_t m68k_load_gst(m68k_context * context, FILE * gstfile)
68 {
69 uint8_t buffer[4096];
70 fseek(gstfile, GST_68K_REGS, SEEK_SET);
71 if (fread(buffer, 1, GST_68K_REG_SIZE, gstfile) != GST_68K_REG_SIZE) {
72 fputs("Failed to read 68K registers from savestate\n", stderr);
73 return 0;
74 }
75 uint8_t * curpos = buffer;
76 for (int i = 0; i < 8; i++) {
77 context->dregs[i] = read_le_32(curpos);
78 curpos += sizeof(uint32_t);
79 }
80 for (int i = 0; i < 8; i++) {
81 context->aregs[i] = read_le_32(curpos);
82 curpos += sizeof(uint32_t);
83 }
84 uint32_t pc = read_le_32(buffer + GST_68K_PC_OFFSET);
85 uint16_t sr = read_le_16(buffer + GST_68K_SR_OFFSET);
86 context->status = sr >> 8;
87 for (int flag = 4; flag >= 0; flag--) {
88 context->flags[flag] = sr & 1;
89 sr >>= 1;
90 }
91 if (context->status & (1 << 5)) {
92 context->aregs[8] = read_le_32(buffer + GST_68K_USP_OFFSET);
93 } else {
94 context->aregs[8] = read_le_32(buffer + GST_68K_SSP_OFFSET);
95 }
96 fseek(gstfile, GST_68K_RAM, SEEK_SET);
97 for (int i = 0; i < (32*1024);) {
98 if (fread(buffer, 1, sizeof(buffer), gstfile) != sizeof(buffer)) {
99 fputs("Failed to read 68K RAM from savestate\n", stderr);
100 return 0;
101 }
102 for(curpos = buffer; curpos < (buffer + sizeof(buffer)); curpos += sizeof(uint16_t)) {
103 context->mem_pointers[1][i++] = read_be_16(curpos);
104 }
105 }
106 return pc;
107 }
108
109 uint8_t m68k_save_gst(m68k_context * context, uint32_t pc, FILE * gstfile)
110 {
111 uint8_t buffer[4096];
112 uint8_t * curpos = buffer;
113 for (int i = 0; i < 8; i++) {
114 write_le_32(curpos, context->dregs[i]);
115 curpos += sizeof(uint32_t);
116 }
117 for (int i = 0; i < 8; i++) {
118 write_le_32(curpos, context->aregs[i]);
119 curpos += sizeof(uint32_t);
120 }
121 write_le_32(buffer + GST_68K_PC_OFFSET, pc);
122 uint16_t sr = context->status << 3;
123 for (int flag = 4; flag >= 0; flag--) {
124 sr <<= 1;
125 sr |= context->flags[flag];
126 }
127 write_le_16(buffer + GST_68K_SR_OFFSET, sr);
128 if (context->status & (1 << 5)) {
129 write_le_32(buffer + GST_68K_USP_OFFSET, context->aregs[8]);
130 write_le_32(buffer + GST_68K_SSP_OFFSET, context->aregs[7]);
131 } else {
132 write_le_32(buffer + GST_68K_USP_OFFSET, context->aregs[7]);
133 write_le_32(buffer + GST_68K_SSP_OFFSET, context->aregs[8]);
134 }
135 fseek(gstfile, GST_68K_REGS, SEEK_SET);
136 if (fwrite(buffer, 1, GST_68K_REG_SIZE, gstfile) != GST_68K_REG_SIZE) {
137 fputs("Failed to write 68K registers to savestate\n", stderr);
138 return 0;
139 }
140
141 fseek(gstfile, GST_68K_RAM, SEEK_SET);
142 for (int i = 0; i < (32*1024);) {
143 for(curpos = buffer; curpos < (buffer + sizeof(buffer)); curpos += sizeof(uint16_t)) {
144 write_be_16(curpos, context->mem_pointers[1][i++]);
145 }
146 if (fwrite(buffer, 1, sizeof(buffer), gstfile) != sizeof(buffer)) {
147 fputs("Failed to write 68K RAM to savestate\n", stderr);
148 return 0;
149 }
150 }
151 return 1;
152 }
153
154 uint8_t z80_load_gst(z80_context * context, FILE * gstfile)
155 {
156 uint8_t regdata[GST_Z80_REG_SIZE];
157 fseek(gstfile, GST_Z80_REGS, SEEK_SET);
158 if (fread(regdata, 1, sizeof(regdata), gstfile) != sizeof(regdata)) {
159 fputs("Failed to read Z80 registers from savestate\n", stderr);
160 return 0;
161 }
162 uint8_t * curpos = regdata;
163 uint8_t f = *(curpos++);
164 context->flags[ZF_C] = f & 1;
165 f >>= 1;
166 context->flags[ZF_N] = f & 1;
167 f >>= 1;
168 context->flags[ZF_PV] = f & 1;
169 f >>= 2;
170 context->flags[ZF_H] = f & 1;
171 f >>= 2;
172 context->flags[ZF_Z] = f & 1;
173 f >>= 1;
174 context->flags[ZF_S] = f;
175
176 context->regs[Z80_A] = *curpos;
177 curpos += 3;
178 for (int reg = Z80_C; reg <= Z80_IYH; reg++) {
179 context->regs[reg++] = *(curpos++);
180 context->regs[reg] = *curpos;
181 curpos += 3;
182 }
183 context->pc = read_le_16(curpos);
184 curpos += 4;
185 context->sp = read_le_16(curpos);
186 curpos += 4;
187 f = *(curpos++);
188 context->alt_flags[ZF_C] = f & 1;
189 f >>= 1;
190 context->alt_flags[ZF_N] = f & 1;
191 f >>= 1;
192 context->alt_flags[ZF_PV] = f & 1;
193 f >>= 2;
194 context->alt_flags[ZF_H] = f & 1;
195 f >>= 2;
196 context->alt_flags[ZF_Z] = f & 1;
197 f >>= 1;
198 context->alt_flags[ZF_S] = f;
199 context->alt_regs[Z80_A] = *curpos;
200 curpos += 3;
201 for (int reg = Z80_C; reg <= Z80_H; reg++) {
202 context->alt_regs[reg++] = *(curpos++);
203 context->alt_regs[reg] = *curpos;
204 curpos += 3;
205 }
206 context->regs[Z80_I] = *curpos;
207 curpos += 2;
208 context->iff1 = context->iff2 = *curpos;
209 curpos += 2;
210 reset = !*(curpos++);
211 busreq = *curpos;
212 curpos += 3;
213 uint32_t bank = read_le_32(curpos);
214 if (bank < 0x400000) {
215 context->mem_pointers[1] = context->mem_pointers[2] + bank;
216 } else {
217 context->mem_pointers[1] = NULL;
218 }
219 context->bank_reg = bank >> 15;
220 fseek(gstfile, GST_Z80_RAM, SEEK_SET);
221 if(fread(context->mem_pointers[0], 1, 8*1024, gstfile) != (8*1024)) {
222 fputs("Failed to read Z80 RAM from savestate\n", stderr);
223 return 0;
224 }
225 return 1;
226 }
227
228 uint8_t vdp_load_gst(vdp_context * context, FILE * state_file)
229 {
230 uint8_t tmp_buf[CRAM_SIZE*2];
231 fseek(state_file, GST_VDP_REGS, SEEK_SET);
232 if (fread(context->regs, 1, VDP_REGS, state_file) != VDP_REGS) {
233 fputs("Failed to read VDP registers from savestate\n", stderr);
234 return 0;
235 }
236 context->double_res = (context->regs[REG_MODE_4] & (BIT_INTERLACE | BIT_DOUBLE_RES)) == (BIT_INTERLACE | BIT_DOUBLE_RES);
237 if (!context->double_res) {
238 context->framebuf = context->oddbuf;
239 }
240 latch_mode(context);
241 if (fread(tmp_buf, 1, sizeof(tmp_buf), state_file) != sizeof(tmp_buf)) {
242 fputs("Failed to read CRAM from savestate\n", stderr);
243 return 0;
244 }
245 for (int i = 0; i < CRAM_SIZE; i++) {
246 uint16_t value;
247 context->cram[i] = value = (tmp_buf[i*2+1] << 8) | tmp_buf[i*2];
248 context->colors[i] = color_map[value & 0xEEE];
249 context->colors[i + CRAM_SIZE] = color_map[(value & 0xEEE) | FBUF_SHADOW];
250 context->colors[i + CRAM_SIZE*2] = color_map[(value & 0xEEE) | FBUF_HILIGHT];
251 }
252 if (fread(tmp_buf, 2, VSRAM_SIZE, state_file) != VSRAM_SIZE) {
253 fputs("Failed to read VSRAM from savestate\n", stderr);
254 return 0;
255 }
256 for (int i = 0; i < VSRAM_SIZE; i++) {
257 context->vsram[i] = (tmp_buf[i*2+1] << 8) | tmp_buf[i*2];
258 }
259 fseek(state_file, GST_VDP_MEM, SEEK_SET);
260 if (fread(context->vdpmem, 1, VRAM_SIZE, state_file) != VRAM_SIZE) {
261 fputs("Failed to read VRAM from savestate\n", stderr);
262 return 0;
263 }
264 return 1;
265 }
266
267 uint8_t vdp_save_gst(vdp_context * context, FILE * outfile)
268 {
269 uint8_t tmp_buf[CRAM_SIZE*2];
270 fseek(outfile, GST_VDP_REGS, SEEK_SET);
271 if(fwrite(context->regs, 1, VDP_REGS, outfile) != VDP_REGS) {
272 fputs("Error writing VDP regs to savestate\n", stderr);
273 return 0;
274 }
275 for (int i = 0; i < CRAM_SIZE; i++)
276 {
277 tmp_buf[i*2] = context->cram[i];
278 tmp_buf[i*2+1] = context->cram[i] >> 8;
279 }
280 if (fwrite(tmp_buf, 1, sizeof(tmp_buf), outfile) != sizeof(tmp_buf)) {
281 fputs("Error writing CRAM to savestate\n", stderr);
282 return 0;
283 }
284 for (int i = 0; i < VSRAM_SIZE; i++)
285 {
286 tmp_buf[i*2] = context->vsram[i];
287 tmp_buf[i*2+1] = context->vsram[i] >> 8;
288 }
289 if (fwrite(tmp_buf, 2, VSRAM_SIZE, outfile) != VSRAM_SIZE) {
290 fputs("Error writing VSRAM to savestate\n", stderr);
291 return 0;
292 }
293 fseek(outfile, GST_VDP_MEM, SEEK_SET);
294 if (fwrite(context->vdpmem, 1, VRAM_SIZE, outfile) != VRAM_SIZE) {
295 fputs("Error writing VRAM to savestate\n", stderr);
296 return 0;
297 }
298 return 1;
299 }
300
301 uint8_t z80_save_gst(z80_context * context, FILE * gstfile)
302 {
303 uint8_t regdata[GST_Z80_REG_SIZE];
304 uint8_t * curpos = regdata;
305 memset(regdata, 0, sizeof(regdata));
306 uint8_t f = context->flags[ZF_S];
307 f <<= 1;
308 f |= context->flags[ZF_Z] ;
309 f <<= 2;
310 f |= context->flags[ZF_H];
311 f <<= 2;
312 f |= context->flags[ZF_PV];
313 f <<= 1;
314 f |= context->flags[ZF_N];
315 f <<= 1;
316 f |= context->flags[ZF_C];
317 *(curpos++) = f;
318 *curpos = context->regs[Z80_A];
319
320 curpos += 3;
321 for (int reg = Z80_C; reg <= Z80_IYH; reg++) {
322 *(curpos++) = context->regs[reg++];
323 *curpos = context->regs[reg];
324 curpos += 3;
325 }
326 write_le_16(curpos, context->pc);
327 curpos += 4;
328 write_le_16(curpos, context->sp);
329 curpos += 4;
330 f = context->alt_flags[ZF_S];
331 f <<= 1;
332 f |= context->alt_flags[ZF_Z] ;
333 f <<= 2;
334 f |= context->alt_flags[ZF_H];
335 f <<= 2;
336 f |= context->alt_flags[ZF_PV];
337 f <<= 1;
338 f |= context->alt_flags[ZF_N];
339 f <<= 1;
340 f |= context->alt_flags[ZF_C];
341 *(curpos++) = f;
342 *curpos = context->alt_regs[Z80_A];
343 curpos += 3;
344 for (int reg = Z80_C; reg <= Z80_H; reg++) {
345 *(curpos++) = context->alt_regs[reg++];
346 *curpos = context->alt_regs[reg];
347 curpos += 3;
348 }
349 *curpos = context->regs[Z80_I];
350 curpos += 2;
351 *curpos = context->iff1;
352 curpos += 2;
353 *(curpos++) = !reset;
354 *curpos = busreq;
355 curpos += 3;
356 uint32_t bank = context->bank_reg << 15;
357 write_le_32(curpos, bank);
358 fseek(gstfile, GST_Z80_REGS, SEEK_SET);
359 if (fwrite(regdata, 1, sizeof(regdata), gstfile) != sizeof(regdata)) {
360 return 0;
361 }
362 fseek(gstfile, GST_Z80_RAM, SEEK_SET);
363 if(fwrite(context->mem_pointers[0], 1, 8*1024, gstfile) != (8*1024)) {
364 fputs("Failed to write Z80 RAM to savestate\n", stderr);
365 return 0;
366 }
367 return 1;
368 }
369
370 uint8_t ym_load_gst(ym2612_context * context, FILE * gstfile)
371 {
372 uint8_t regdata[GST_YM_SIZE];
373 fseek(gstfile, GST_YM_OFFSET, SEEK_SET);
374 if (fread(regdata, 1, sizeof(regdata), gstfile) != sizeof(regdata)) {
375 return 0;
376 }
377 for (int i = 0; i < sizeof(regdata); i++) {
378 if (i & 0x100) {
379 ym_address_write_part2(context, i & 0xFF);
380 } else {
381 ym_address_write_part1(context, i);
382 }
383 ym_data_write(context, regdata[i]);
384 }
385 return 1;
386 }
387
388 uint8_t ym_save_gst(ym2612_context * context, FILE * gstfile)
389 {
390 uint8_t regdata[GST_YM_SIZE];
391 for (int i = 0; i < sizeof(regdata); i++) {
392 if (i & 0x100) {
393 int reg = (i & 0xFF);
394 if (reg >= YM_PART2_START && reg < YM_REG_END) {
395 regdata[i] = context->part2_regs[reg-YM_PART2_START];
396 } else {
397 regdata[i] = 0xFF;
398 }
399 } else {
400 if (i >= YM_PART1_START && i < YM_REG_END) {
401 regdata[i] = context->part1_regs[i-YM_PART1_START];
402 } else {
403 regdata[i] = 0xFF;
404 }
405 }
406 }
407 fseek(gstfile, GST_YM_OFFSET, SEEK_SET);
408 if (fwrite(regdata, 1, sizeof(regdata), gstfile) != sizeof(regdata)) {
409 return 0;
410 }
411 return 1;
412 }
413
414 uint32_t load_gst(genesis_context * gen, char * fname)
415 {
416 FILE * gstfile = fopen(fname, "rb");
417 if (!gstfile) {
418 fprintf(stderr, "Could not open file %s for reading\n", fname);
419 goto error;
420 }
421 char ident[5];
422 if (fread(ident, 1, sizeof(ident), gstfile) != sizeof(ident)) {
423 fprintf(stderr, "Could not read ident code from %s\n", fname);
424 goto error_close;
425 }
426 if (memcmp(ident, "GST\x40\xE0", 5) != 0) {
427 fprintf(stderr, "%s doesn't appear to be a GST savestate. The ident code is %c%c%c\\x%X\\x%X instead of GST\\x40\\xE0.\n", fname, ident[0], ident[1], ident[2], ident[3], ident[4]);
428 goto error_close;
429 }
430 uint32_t pc = m68k_load_gst(gen->m68k, gstfile);
431 if (!pc) {
432 goto error_close;
433 }
434 if (!vdp_load_gst(gen->vdp, gstfile)) {
435 goto error_close;
436 }
437 if (!ym_load_gst(gen->ym, gstfile)) {
438 goto error_close;
439 }
440 if (!z80_load_gst(gen->z80, gstfile)) {
441 goto error_close;
442 }
443 gen->ports[0].control = 0x40;
444 gen->ports[1].control = 0x40;
445 fclose(gstfile);
446 return pc;
447
448 error_close:
449 fclose(gstfile);
450 error:
451 return 0;
452 }
453
454 uint8_t save_gst(genesis_context * gen, char *fname, uint32_t m68k_pc)
455 {
456 FILE * gstfile = fopen(fname, "wb");
457 if (!gstfile) {
458 fprintf(stderr, "Could not open %s for writing\n", fname);
459 goto error;
460 }
461 if (fwrite("GST\x40\xE0", 1, 5, gstfile) != 5) {
462 fputs("Error writing signature to savestate\n", stderr);
463 goto error_close;
464 }
465 if (!m68k_save_gst(gen->m68k, m68k_pc, gstfile)) {
466 goto error_close;
467 }
468 if (!z80_save_gst(gen->z80, gstfile)) {
469 goto error_close;
470 }
471 if (!vdp_save_gst(gen->vdp, gstfile)) {
472 goto error_close;
473 }
474 if (!ym_save_gst(gen->ym, gstfile)) {
475 goto error_close;
476 }
477 return 1;
478
479 error_close:
480 fclose(gstfile);
481 error:
482 return 0;
483 }