![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reg68k.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / src|
Return to reg68k.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / src |
1.1 root 1: /*****************************************************************************/
2: /* Generator - Sega Genesis emulation - (c) James Ponder 1997-2000 */
3: /*****************************************************************************/
4: /* */
5: /* reg68k.c */
6: /* */
7: /*****************************************************************************/
8:
9: #include "generator.h"
10: #include "registers.h"
11:
12: #include <stdio.h>
13: #include <string.h>
14: #include <stdlib.h>
15: #include <setjmp.h>
16:
17: #include "mem68k.h"
18: #include "cpu68k.h"
19: #include "cpuz80.h"
20: #include "vdp.h"
21: #include "ui.h"
22: #include "compile.h"
23: #include "gensound.h"
24:
25: /*** externed variables ***/
26:
27: #if (!(defined(PROCESSOR_ARM) || defined(PROCESSOR_SPARC) \
28: || defined(PROCESSOR_INTEL)))
29: uint32 reg68k_pc;
30: uint32 *reg68k_regs;
31: t_sr reg68k_sr;
32: #endif
33:
34: /*** forward references ***/
35:
36: inline void reg68k_checkevent(void);
37: void reg68k_autovector(int avno);
38:
39: static unsigned int reg68k_eventdelay;
40:
41: void reg68k_step(void)
42: {
43: /* PAL: 312 lines, 224 or 240 visible @ 50Hz - CPU @ 7.60Mhz */
44: /* NTSC: 262 lines, 224 visible @ 60Hz - CPU @ 7.67Mhz */
45:
46: static t_ipc ipc;
47: static t_iib *piib;
48: jmp_buf jb;
49:
50: /* !!! entering global register usage area !!! */
51:
52: if (!setjmp(jb)) {
53: if (!(piib = cpu68k_iibtable[fetchword(regs.pc)]))
54: ui_err("Invalid instruction @ %08X\n", regs.pc);
55: /* move PC and register block into global variables */
56: reg68k_pc = regs.pc;
57: reg68k_regs = regs.regs;
58: reg68k_sr = regs.sr;
59:
60: cpu68k_ipc(reg68k_pc,
61: mem68k_memptr[(reg68k_pc>>12) & 0xfff](reg68k_pc & 0xFFFFFF),
62: piib, &ipc);
63: cpu68k_functable[fetchword(reg68k_pc)*2+1](&ipc);
64: cpu68k_clocks+= piib->clocks;
65: reg68k_checkevent();
66: /* restore global registers back to permanent storage */
67: regs.pc = reg68k_pc;
68: regs.sr = reg68k_sr;
69: longjmp(jb, 1);
70: }
71: }
72:
73: inline void reg68k_checkevent(void)
74: {
75: switch(vdp_event) {
76: case 0:
77: if (cpu68k_clocks >= vdp_event_start) {
78: vdp_event_startofcurrentline = vdp_event_start;
79: LOG_USER(("%08X due %08X, %d A: %d (cd=%d)",
80: cpu68k_clocks, vdp_event_start, vdp_line, vdp_reg[10],
81: vdp_hskip_countdown));
82: vdp_event++;
83: vdp_event_start+= vdp_clksperline_68k;
84: cpuz80_sync();
85: if (vdp_line == 0) {
86: vdp_vblank = 0;
87: vdp_hskip_countdown = vdp_reg[10];
88: ui_line(0);
89: }
90: if (vdp_line < vdp_vislines)
91: ui_line(vdp_line);
92: }
93: break;
94: case 1:
95: if (cpu68k_clocks >= vdp_event_vint) {
96: LOG_USER(("%08X due %08X, %d B: %d (cd=%d)",
97: cpu68k_clocks, vdp_event_vint, vdp_line, vdp_reg[10],
98: vdp_hskip_countdown));
99: vdp_event++;
100: vdp_event_vint+= vdp_clksperline_68k;
101: if (vdp_line == vdp_vislines) {
102: vdp_vblank = 1;
103: vdp_vsync = 1;
104: if (vdp_reg[1] & 1<<5)
105: reg68k_autovector(6); /* vertical interrupt */
106: }
107: }
108: break;
109: case 2:
110: if (cpu68k_clocks >= vdp_event_hint) {
111: LOG_USER(("%08X due %08X, %d C: %d (cd=%d)",
112: cpu68k_clocks, vdp_event_hint, vdp_line, vdp_reg[10],
113: vdp_hskip_countdown));
114: /* delay hdisplay if hint is delayed */
115: vdp_event++;
116: vdp_event_hint+= vdp_clksperline_68k;
117: cpuz80_sync();
118: /* if (vdp_line < vdp_vislines) */
119: vdp_hblank = 1;
120: if (vdp_reg[0] & 1<<4) {
121: if (vdp_hskip_countdown-- == 0) {
122: /* re-initialise counter */
123: vdp_hskip_countdown = vdp_reg[10];
124: if (vdp_line < vdp_vislines)
125: reg68k_autovector(4); /* horizontal interrupt */
126: /* since this game is obviously timing sensitive, we sacrifice
127: executing the right number of 68k clocks this frame in order
128: to accurately do the moments following H-Int */
129: cpu68k_clocks = vdp_event_hint - vdp_clksperline_68k;
130: }
131: }
132: }
133: break;
134: case 3:
135: if (cpu68k_clocks >= vdp_event_hdisplay) {
136: LOG_USER(("%08X due %08X, %d D: %d (cd=%d)",
137: cpu68k_clocks, vdp_event_hdisplay, vdp_line, vdp_reg[10],
138: vdp_hskip_countdown));
139: vdp_event_hdisplay-= reg68k_eventdelay;
140: vdp_event++;
141: vdp_event_hdisplay+= vdp_clksperline_68k;
142: cpuz80_sync();
143: /* err
144: if (vdp_line+1 < vdp_vislines)
145: ui_line(vdp_line+1);
146: */
147: }
148: break;
149: case 4:
150: if (cpu68k_clocks >= vdp_event_end) {
151: /* end of line, do sound, platform stuff */
152: LOG_USER(("%08X due %08X, %d E: %d (cd=%d)",
153: cpu68k_clocks, vdp_event_end, vdp_line, vdp_reg[10],
154: vdp_hskip_countdown));
155: vdp_event = 0;
156: vdp_event_end+= vdp_clksperline_68k;
157: /* if (vdp_line < vdp_vislines) */
158: vdp_hblank = 0;
159: cpuz80_sync();
160: sound_process();
161: vdp_line++;
162: if (vdp_line == vdp_totlines) {
163: ui_endfield();
164: sound_endfield();
165: cpuz80_interrupt();
166: vdp_endfield();
167: cpuz80_endfield();
168: cpu68k_endfield();
169: cpu68k_frames++;
170: }
171: }
172: break;
173: } /* switch */
174: }
175:
176: /*** reg68k_framestep - do a frame and return ***/
177:
178: void reg68k_framestep(void)
179: {
180: /* PAL: 312 lines, 224 or 240 visible @ 50Hz - CPU @ 7.60Mhz */
181: /* NTSC: 262 lines, 224 visible @ 60Hz - CPU @ 7.67Mhz */
182:
183: unsigned int startframe = cpu68k_frames;
184: unsigned int index, i;
185: t_ipclist *list;
186: t_ipc *ipc;
187: uint32 pc24;
188: jmp_buf jb;
189: static t_ipc step_ipc;
190: static t_iib *step_piib;
191:
192: if (!setjmp(jb)) {
193: /* move PC and register block into global variables */
194: reg68k_pc = regs.pc;
195: reg68k_regs = regs.regs;
196: reg68k_sr = regs.sr;
197:
198: do {
199: pc24 = reg68k_pc & 0xffffff;
200: if ((pc24 & 0xff0000) == 0xff0000) {
201: /* executing code from RAM, do not use compiled information */
202: do {
203: step_piib = cpu68k_iibtable[fetchword(reg68k_pc)];
204: cpu68k_ipc(reg68k_pc,
205: mem68k_memptr[(reg68k_pc>>12) &
206: 0xfff](reg68k_pc & 0xFFFFFF),
207: step_piib, &step_ipc);
208: cpu68k_functable[fetchword(reg68k_pc)*2+1](&step_ipc);
209: cpu68k_clocks+= step_piib->clocks;
210: } while (!step_piib->flags.endblk);
211: list = NULL; /* stop compiler warning ;( */
212: } else {
213: index = (pc24>>1) & (LEN_IPCLISTTABLE-1);
214: list = ipclist[index];
215: while(list && (list->pc != pc24)) {
216: list = list->next;
217: }
218: #ifdef PROCESSOR_ARM
219: if (!list) {
220: list = cpu68k_makeipclist(pc24);
221: list->next = ipclist[index];
222: ipclist[index] = list;
223: list->compiled = compile_make(list);
224: }
225: list->compiled((t_ipc *)(list+1));
226: #else
227: if (!list) {
228: /* LOG_USER(("Making IPC list @ %08x", pc24)); */
229: list = cpu68k_makeipclist(pc24);
230: list->next = ipclist[index];
231: ipclist[index] = list;
232: }
233: ipc = (t_ipc *)(list+1);
234: do {
235: ipc->function(ipc);
236: ipc++;
237: } while (*(int *)ipc);
238: #endif
239: cpu68k_clocks+= list->clocks;
240: }
241: reg68k_checkevent();
242: } while (cpu68k_frames == startframe);
243: /* restore global registers back to permanent storage */
244: regs.pc = reg68k_pc;
245: regs.sr = reg68k_sr;
246: longjmp(jb, 1);
247: }
248: }
249:
250: void reg68k_autovector(int avno)
251: {
252: int curlevel = (reg68k_sr.sr_int>>8) & 7;
253: uint32 tmpaddr;
254:
255: LOG_VERBOSE(("autovector %d\n", avno));
256: if (curlevel < avno || avno == 7) {
257: if (!reg68k_sr.sr_struct.s) {
258: regs.regs[15]^= regs.sp; /* swap A7 and SP */
259: regs.sp^= regs.regs[15];
260: regs.regs[15]^= regs.sp;
261: reg68k_sr.sr_struct.s = 1;
262: }
263: regs.regs[15]-=4;
264: storelong(regs.regs[15], reg68k_pc);
265: regs.regs[15]-=2;
266: storeword(regs.regs[15], reg68k_sr.sr_int);
267: reg68k_sr.sr_struct.t = 0;
268: reg68k_sr.sr_int&= ~0x0700;
269: reg68k_sr.sr_int|= avno << 8;
270: tmpaddr = reg68k_pc;
271: reg68k_pc = fetchlong((V_AUTO+avno-1)*4);
272: LOG_DEBUG1(("AUTOVECTOR %d: %X -> %X", avno, tmpaddr, reg68k_pc));
273: }
274: }
275:
276: void reg68k_vector(int vno, uint32 oldpc)
277: {
278: LOG_DEBUG1(("Vector %d called from %8x!", vno, regs.pc));
279: if (!reg68k_sr.sr_struct.s) {
280: regs.regs[15]^= regs.sp; /* swap A7 and SP */
281: regs.sp^= regs.regs[15];
282: regs.regs[15]^= regs.sp;
283: reg68k_sr.sr_struct.s = 1;
284: }
285: regs.regs[15]-=4;
286: storelong(regs.regs[15], oldpc);
287: regs.regs[15]-=2;
288: storeword(regs.regs[15], reg68k_sr.sr_int);
289: reg68k_pc = fetchlong(vno*4);
290: LOG_DEBUG1(("VECTOR %d: %X -> %X\n", vno, oldpc, reg68k_pc));
291: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.