![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dimension.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src / dimension|
Return to dimension.cpp CVS log | Up to [Previous NeXT emulator] / previous_trunk / src / dimension |
1.1 root 1: #include "configuration.h"
2: #include "m68000.h"
3: #include "dimension.hpp"
4: #include "nd_nbic.hpp"
5: #include "nd_mem.hpp"
6: #include "nd_sdl.hpp"
7:
8: NextDimension::NextDimension(int slot) :
9: NextBusBoard(slot),
10: sdl(slot, (Uint32*)vram),
11: i860(this),
12: nbic(slot, ND_NBIC_ID),
13: mc(this),
14: dp(this),
15: dmcd(this),
16: dcsc0(this, 0),
17: dcsc1(this, 1),
18: rom_command(0),
19: rom_last_addr(0)
20: {
21: i860.uninit();
22: nbic.init();
23: mc.init();
24: dp.init();
25: mem_init();
26: i860.init();
27: sdl.init();
28: }
29:
30: NextDimension::~NextDimension() {
31: i860.uninit();
32: sdl.destroy();
33: }
34:
35: void NextDimension::reset(void) {
36: i860.set_run_func();
37: sdl.start_interrupts();
38: }
39:
40: void NextDimension::pause(bool pause) {
41: i860.pause(pause);
42: sdl.pause(pause);
43: }
44:
45: /* NeXTdimension board memory access (m68k) */
46:
47: Uint32 NextDimension::board_lget(Uint32 addr) {
48: addr |= ND_BOARD_BITS;
49: Uint32 result = nd68k_longget(addr);
50: // (SC) delay m68k read on csr0 while in ROM (CS8=1)to give ND some time to start up.
51: if(addr == 0xFF800000 && (result & 0x02))
52: M68000_AddCycles(ConfigureParams.System.nCpuFreq * 100);
53: return result;
54: }
55:
56: Uint16 NextDimension::board_wget(Uint32 addr) {
57: addr |= ND_BOARD_BITS;
58: return nd68k_wordget(addr);
59: }
60:
61: Uint8 NextDimension::board_bget(Uint32 addr) {
62: addr |= ND_BOARD_BITS;
63: return nd68k_byteget(addr);
64: }
65:
66: void NextDimension::board_lput(Uint32 addr, Uint32 l) {
67: addr |= ND_BOARD_BITS;
68: nd68k_longput(addr, l);
69: }
70:
71: void NextDimension::board_wput(Uint32 addr, Uint16 w) {
72: addr |= ND_BOARD_BITS;
73: nd68k_wordput(addr, w);
74: }
75:
76: void NextDimension::board_bput(Uint32 addr, Uint8 b) {
77: addr |= ND_BOARD_BITS;
78: nd68k_byteput(addr, b);
79: }
80:
81: /* NeXTdimension slot memory access */
82: Uint32 NextDimension::slot_lget(Uint32 addr) {
83: addr |= ND_SLOT_BITS;
84:
85: if (addr<ND_NBIC_SPACE) {
86: return nd68k_longget(addr);
87: } else {
88: return nbic.lget(addr);
89: }
90: }
91:
92: Uint16 NextDimension::slot_wget(Uint32 addr) {
93: addr |= ND_SLOT_BITS;
94:
95: if (addr<ND_NBIC_SPACE) {
96: return nd68k_wordget(addr);
97: } else {
98: return nbic.wget(addr);
99: }
100: }
101:
102: Uint8 NextDimension::slot_bget(Uint32 addr) {
103: addr |= ND_SLOT_BITS;
104:
105: if (addr<ND_NBIC_SPACE) {
106: return nd68k_byteget(addr);
107: } else {
108: return nbic.bget(addr);
109: }
110: }
111:
112: void NextDimension::slot_lput(Uint32 addr, Uint32 l) {
113: addr |= ND_SLOT_BITS;
114:
115: if (addr<ND_NBIC_SPACE) {
116: nd68k_longput(addr, l);
117: } else {
118: nbic.lput(addr, l);
119: }
120: }
121:
122: void NextDimension::slot_wput(Uint32 addr, Uint16 w) {
123: addr |= ND_SLOT_BITS;
124:
125: if (addr<ND_NBIC_SPACE) {
126: nd68k_wordput(addr, w);
127: } else {
128: nbic.wput(addr, w);
129: }
130: }
131:
132: void NextDimension::slot_bput(Uint32 addr, Uint8 b) {
133: addr |= ND_SLOT_BITS;
134:
135: if (addr<ND_NBIC_SPACE) {
136: nd68k_byteput(addr, b);
137: } else {
138: nbic.bput(addr, b);
139: }
140: }
141:
142: void NextDimension::send_msg(int msg) {
143: host_lock(&m_port_lock);
144: m_port |= msg;
145: host_unlock(&m_port_lock);
146: }
147:
148: /* NeXTdimension board memory access (i860) */
149:
150: Uint8 NextDimension::i860_cs8get(NextDimension* nd, Uint32 addr) {
151: addr |= ND_BOARD_BITS;
152: return nd_cs8get(addr);
153: }
154:
155: void NextDimension::i860_rd8_be(NextDimension* nd, Uint32 addr, Uint32* val) {
156: addr |= ND_BOARD_BITS;
157: *((Uint8*)val) = nd_byteget(addr);
158: }
159:
160: void NextDimension::i860_rd16_be(NextDimension* nd, Uint32 addr, Uint32* val) {
161: addr |= ND_BOARD_BITS;
162: *((Uint16*)val) = nd_wordget(addr);
163: }
164:
165: void NextDimension::i860_rd32_be(NextDimension* nd, Uint32 addr, Uint32* val) {
166: addr |= ND_BOARD_BITS;
167: val[0] = nd_longget(addr);
168: }
169:
170: void NextDimension::i860_rd64_be(NextDimension* nd, Uint32 addr, Uint32* val) {
171: addr |= ND_BOARD_BITS;
172: val[0] = nd_longget(addr+4);
173: val[1] = nd_longget(addr+0);
174: }
175:
176: void NextDimension::i860_rd128_be(NextDimension* nd, Uint32 addr, Uint32* val) {
177: addr |= ND_BOARD_BITS;
178: val[0] = nd_longget(addr+4);
179: val[1] = nd_longget(addr+0);
180: val[2] = nd_longget(addr+12);
181: val[3] = nd_longget(addr+8);
182: }
183:
184: void NextDimension::i860_wr8_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
185: addr |= ND_BOARD_BITS;
186: nd_byteput(addr, *((const Uint8*)val));
187: }
188:
189: void NextDimension::i860_wr16_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
190: addr |= ND_BOARD_BITS;
191: nd_wordput(addr, *((const Uint16*)val));
192: }
193:
194: void NextDimension::i860_wr32_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
195: addr |= ND_BOARD_BITS;
196: nd_longput(addr, val[0]);
197: }
198:
199: void NextDimension::i860_wr64_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
200: addr |= ND_BOARD_BITS;
201: nd_longput(addr+4, val[0]);
202: nd_longput(addr+0, val[1]);
203: }
204:
205: void NextDimension::i860_wr128_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
206: addr |= ND_BOARD_BITS;
207: nd_longput(addr+4, val[0]);
208: nd_longput(addr+0, val[1]);
209: nd_longput(addr+12, val[2]);
210: nd_longput(addr+8, val[3]);
211: }
212:
213: void NextDimension::i860_rd8_le(NextDimension* nd, Uint32 addr, Uint32* val) {
214: addr |= ND_BOARD_BITS;
215: *((Uint8*)val) = nd_byteget(addr^7);
216: }
217:
218: void NextDimension::i860_rd16_le(NextDimension* nd, Uint32 addr, Uint32* val) {
219: addr |= ND_BOARD_BITS;
220: *((Uint16*)val) = nd_wordget(addr^6);
221: }
222:
223: void NextDimension::i860_rd32_le(NextDimension* nd, Uint32 addr, Uint32* val) {
224: addr |= ND_BOARD_BITS;
225: val[0] = nd_longget(addr^4);
226: }
227:
228: void NextDimension::i860_rd64_le(NextDimension* nd, Uint32 addr, Uint32* val) {
229: addr |= ND_BOARD_BITS;
230: val[0] = nd_longget(addr+0);
231: val[1] = nd_longget(addr+4);
232: }
233:
234: void NextDimension::i860_rd128_le(NextDimension* nd, Uint32 addr, Uint32* val) {
235: addr |= ND_BOARD_BITS;
236: val[0] = nd_longget(addr+0);
237: val[1] = nd_longget(addr+4);
238: val[2] = nd_longget(addr+8);
239: val[3] = nd_longget(addr+12);
240: }
241:
242: void NextDimension::i860_wr8_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
243: addr |= ND_BOARD_BITS;
244: nd_byteput(addr^7, *((const Uint8*)val));
245: }
246:
247: void NextDimension::i860_wr16_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
248: addr |= ND_BOARD_BITS;
249: nd_wordput(addr^6, *((const Uint16*)val));
250: }
251:
252: void NextDimension::i860_wr32_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
253: addr |= ND_BOARD_BITS;
254: nd_longput(addr^4, val[0]);
255: }
256:
257: void NextDimension::i860_wr64_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
258: addr |= ND_BOARD_BITS;
259: nd_longput(addr+0, val[0]);
260: nd_longput(addr+4, val[1]);
261: }
262:
263: void NextDimension::i860_wr128_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
264: addr |= ND_BOARD_BITS;
265: nd_longput(addr+0, val[0]);
266: nd_longput(addr+4, val[1]);
267: nd_longput(addr+8, val[2]);
268: nd_longput(addr+12, val[3]);
269: }
270:
271: /* Message disaptcher - executed on i860 thread, safe to call i860 methods */
272: bool NextDimension::handle_msgs(void) {
273: host_lock(&m_port_lock);
274: int msg = m_port;
275: m_port = 0;
276: host_unlock(&m_port_lock);
277:
278: if(msg & MSG_DISPLAY_BLANK)
279: set_blank_state(ND_DISPLAY, host_blank_state(slot, ND_DISPLAY));
280: if(msg & MSG_VIDEO_BLANK)
281: set_blank_state(ND_VIDEO, host_blank_state(slot, ND_VIDEO));
282:
283: return i860.handle_msgs(msg);
284: }
285:
286: void nd_start_debugger(void) {
287: FOR_EACH_SLOT(slot) {
288: IF_NEXT_DIMENSION(slot, nd) {
289: nd->send_msg(MSG_DBG_BREAK);
290: }
291: }
292: }
293:
294: extern "C" {
295: void nd_display_blank(int slot) {
296: ((NextDimension*)nextbus[slot])->send_msg(MSG_DISPLAY_BLANK);
297: }
298:
299: void nd_video_blank(int slot) {
300: ((NextDimension*)nextbus[slot])->send_msg(MSG_VIDEO_BLANK);
301: }
302:
303: const char* nd_reports(int slot, double realTime, double hostTime) {
304: return ((NextDimension*)nextbus[slot])->i860.reports(realTime, hostTime);
305: }
306:
307: Uint32* nd_vram_for_slot(int slot) {
308: IF_NEXT_DIMENSION(slot, nd)
309: return (Uint32*)nd->vram;
310: else
311: return NULL;
312: }
313: }
314:
315:
316:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.