![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to memory.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src / cpu|
Return to memory.c CVS log | Up to [Previous NeXT emulator] / previous / src / cpu |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator - CPU core
3: *
4: * Memory management
5: *
6: * (c) 1995 Bernd Schmidt
7: *
8: * Adaptation to Hatari by Thomas Huth
9: *
10: * This file is distributed under the GNU Public License, version 2 or at
11: * your option any later version. Read the file gpl.txt for details.
12: */
13: const char Memory_fileid[] = "Hatari memory.c : " __DATE__ " " __TIME__;
14:
15: #include "config.h"
16: #include "sysdeps.h"
17: #include "hatari-glue.h"
18: #include "maccess.h"
19: #include "memory.h"
20:
21: #include "main.h"
22: #include "ioMem.h"
23: #include "reset.h"
24: #include "nextMemory.h"
25: #include "m68000.h"
26: #include "configuration.h"
27:
28: #include "newcpu.h"
29:
30:
31: /* Set illegal_mem to 1 for debug output: */
32: #define illegal_mem 1
33:
1.1.1.2 ! root 34: #define illegal_trace(s) {static int count=0; if (count++<50) { s; }}
1.1 root 35:
36: /*
37: approximative next memory map (source netbsd/next68k file cpu.h)
38:
39: EPROM 128k (>cube 040)
40: 0x00000000-0x0001FFFF
41: mirrored at
42: 0x01000000-0x0101FFFF
43:
44: RAM (16x4=64Mb max)
45: 0x04000000-0x07FFFFFF (0x047FFFFF for 8Mb)
46:
47: device
48: 0x02000000-0x0201BFFF
49: mirrored at
50: 0x02100000-0x0211BFFF
51:
52: SCREEN
53: 0x0B000000-0x0B03A7FF
54:
55: */
56: #define NEXT_EPROM_START 0x00000000
57: #define NEXT_EPROM2_START 0x01000000
58: #define ROMmem_mask 0x0001FFFF
59: #define ROMmem_size 0x00020000
60: #define NEXT_EPROM_SIZE 0x00020000
61:
62: // ram is flat?
1.1.1.2 ! root 63: /* Main memory */
! 64: /* Main memory constants */
1.1 root 65: #define NEXT_RAM_START 0x04000000
66: #define NEXT_RAM_SPACE 0x40000000
1.1.1.2 ! root 67: #define N_BANKS 4
1.1 root 68:
1.1.1.2 ! root 69: /* Main memory variables (machine dependent) */
! 70: uae_u32 NEXT_RAM_SIZE; // 0x04000000
1.1 root 71: uae_u32 NEXTmem_size; // unused
1.1.1.2 ! root 72: uae_u32 NEXTmem_mask; // 0x03FFFFFF
! 73: uae_u8 bankshift;
! 74:
! 75: /* Video memory for monochrome systems */
1.1 root 76: #define NEXT_SCREEN 0x0B000000
77: #define NEXT_SCREEN_SIZE 0x00040000
78: #define NEXTvideo_size NEXT_SCREEN_SIZE
79: #define NEXTvideo_mask 0x0003FFFF
80: uae_u8 NEXTVideo[256*1024];
81:
1.1.1.2 ! root 82: /* Video memory for color systems */
! 83: #define NEXT_COLORSCREEN 0x2C000000
! 84: #define NEXT_COLORSCREEN_SIZE 0x00200000
! 85: #define NEXTcolorvideo_size NEXT_COLORSCREEN_SIZE
! 86: #define NEXTcolorvideo_mask 0x001FFFFF
! 87: uae_u8 NEXTColorVideo[2*1024*1024];
1.1 root 88:
89:
90: #define IOmem_mask 0x0001FFFF
91: #define IOmem_size 0x0001C000
1.1.1.2 ! root 92: #define NEXT_IO_START 0x02000000 /* IO for 68030 based NeXT Computer */
! 93: #define NEXT_IO2_START 0x02100000 /* additional IO for 68040 based systems */
! 94: #define NEXT_IO3_START 0x02200000 /* additional IO for turbo systems */
1.1 root 95: #define NEXT_IO_SIZE 0x00020000
96:
97: #define NEXT_BMAP_START 0x020C0000
98: #define NEXT_BMAP_SIZE 0x10000
99: #define NEXTbmap_size NEXT_BMAP_SIZE
100: #define NEXTbmap_mask 0x0000FFFF
101: uae_u8 NEXTbmap[NEXT_BMAP_SIZE];
102:
103: #define NEXT_X06_START 0x06000000
104: #define NEXT_X06_SIZE 0x10000
105: #define NEXTx06_size NEXT_X06_SIZE
106: #define NEXTx06_mask 0x0000FFFF
107: uae_u8 NEXTx06[NEXT_X06_SIZE];
108:
109:
110: #ifdef SAVE_MEMORY_BANKS
111: addrbank *mem_banks[65536];
112: #else
113: addrbank mem_banks[65536];
114: #endif
115:
116: #ifdef NO_INLINE_MEMORY_ACCESS
117: __inline__ uae_u32 longget (uaecptr addr)
118: {
119: return call_mem_get_func (get_mem_bank (addr).lget, addr);
120: }
121: __inline__ uae_u32 wordget (uaecptr addr)
122: {
123: return call_mem_get_func (get_mem_bank (addr).wget, addr);
124: }
125: __inline__ uae_u32 byteget (uaecptr addr)
126: {
127: return call_mem_get_func (get_mem_bank (addr).bget, addr);
128: }
129: __inline__ void longput (uaecptr addr, uae_u32 l)
130: {
131: call_mem_put_func (get_mem_bank (addr).lput, addr, l);
132: }
133: __inline__ void wordput (uaecptr addr, uae_u32 w)
134: {
135: call_mem_put_func (get_mem_bank (addr).wput, addr, w);
136: }
137: __inline__ void byteput (uaecptr addr, uae_u32 b)
138: {
139: call_mem_put_func (get_mem_bank (addr).bput, addr, b);
140: }
141: #endif
142:
143:
144: /* Some prototypes: */
145: extern void SDL_Quit(void);
146: static int NEXTmem_check (uaecptr addr, uae_u32 size) REGPARAM;
147: static uae_u8 *NEXTmem_xlate (uaecptr addr) REGPARAM;
148:
149: uae_u8 ce_banktype[65536];
150: uae_u8 ce_cachable[65536];
151:
152:
153: /* A dummy bank that only contains zeros */
154:
155: static uae_u32 dummy_lget(uaecptr addr)
156: {
1.1.1.2 ! root 157: illegal_trace(write_log ("Illegal lget at %08lx PC=%08x\n", (long)addr,m68k_getpc()));
1.1 root 158: return 0;
159: }
160:
161: static uae_u32 dummy_wget(uaecptr addr)
162: {
1.1.1.2 ! root 163: illegal_trace(write_log ("Illegal wget at %08lx PC=%08x\n", (long)addr,m68k_getpc()));
1.1 root 164: return 0;
165: }
166:
167: static uae_u32 dummy_bget(uaecptr addr)
168: {
1.1.1.2 ! root 169: illegal_trace(write_log ("Illegal bget at %08lx PC=%08x\n", (long)addr,m68k_getpc()));
1.1 root 170: return 0;
171: }
172:
173: static void dummy_lput(uaecptr addr, uae_u32 l)
174: {
1.1.1.2 ! root 175: illegal_trace(write_log ("Illegal lput at %08lx PC=%08x\n", (long)addr,m68k_getpc()));
1.1 root 176: }
177:
178: static void dummy_wput(uaecptr addr, uae_u32 w)
179: {
1.1.1.2 ! root 180: illegal_trace(write_log ("Illegal wput at %08lx PC=%08x\n", (long)addr,m68k_getpc()));
1.1 root 181: }
182:
183: static void dummy_bput(uaecptr addr, uae_u32 b)
184: {
1.1.1.2 ! root 185: illegal_trace(write_log ("Illegal bput at %08lx PC=%08x\n", (long)addr,m68k_getpc()));
1.1 root 186: }
187:
188: static int dummy_check(uaecptr addr, uae_u32 size)
189: {
190: return 0;
191: }
192:
193: static uae_u8 *dummy_xlate(uaecptr addr)
194: {
1.1.1.2 ! root 195: write_log("Your program just did something terribly stupid:"
1.1 root 196: " dummy_xlate($%x)\n", addr);
1.1.1.2 ! root 197: abort();
1.1 root 198: }
199:
200:
201: /* **** This memory bank only generates bus errors **** */
202:
203: static uae_u32 BusErrMem_lget(uaecptr addr)
204: {
205: if (illegal_mem)
206: write_log ("Bus error lget at %08lx\n", (long)addr);
207:
208: M68000_BusError(addr, 1);
209: return 0;
210: }
211:
212: static uae_u32 BusErrMem_wget(uaecptr addr)
213: {
214: if (illegal_mem)
215: write_log ("Bus error wget at %08lx\n", (long)addr);
216:
217: M68000_BusError(addr, 1);
218: return 0;
219: }
220:
221: static uae_u32 BusErrMem_bget(uaecptr addr)
222: {
223: if (illegal_mem)
224: write_log ("Bus error bget at %08lx\n", (long)addr);
225:
226: M68000_BusError(addr, 1);
227: return 0;
228: }
229:
230: static void BusErrMem_lput(uaecptr addr, uae_u32 l)
231: {
232: if (illegal_mem)
233: write_log ("Bus error lput at %08lx\n", (long)addr);
234:
235: M68000_BusError(addr, 0);
236: }
237:
238: static void BusErrMem_wput(uaecptr addr, uae_u32 w)
239: {
240: if (illegal_mem)
241: write_log ("Bus error wput at %08lx\n", (long)addr);
242:
243: M68000_BusError(addr, 0);
244: }
245:
246: static void BusErrMem_bput(uaecptr addr, uae_u32 b)
247: {
248: if (illegal_mem)
249: write_log ("Bus error bput at %08lx\n", (long)addr);
250:
251: M68000_BusError(addr, 0);
252: }
253:
254: static int BusErrMem_check(uaecptr addr, uae_u32 size)
255: {
256: if (illegal_mem)
257: write_log ("Bus error check at %08lx\n", (long)addr);
258:
259: return 0;
260: }
261:
262: static uae_u8 *BusErrMem_xlate (uaecptr addr)
263: {
264: write_log("Your NeXT program just did something terribly stupid:"
265: " BusErrMem_xlate($%x)\n", addr);
266:
1.1.1.2 ! root 267: abort();
! 268: M68000_BusError(addr,0);
1.1 root 269: return NEXTmem_xlate(addr); /* So we don't crash. */
270: }
271:
272:
273: /* **** NEXT RAM memory **** */
274:
275: static uae_u32 NEXTmem_lget(uaecptr addr)
276: {
277: addr &= NEXTmem_mask;
278: return do_get_mem_long(NEXTRam + addr);
279: }
280:
281: static uae_u32 NEXTmem_wget(uaecptr addr)
282: {
283: addr &= NEXTmem_mask;
284: return do_get_mem_word(NEXTRam + addr);
285: }
286:
287: static uae_u32 NEXTmem_bget(uaecptr addr)
288: {
289: addr &= NEXTmem_mask;
290: return NEXTRam[addr];
291: }
292:
293: static void NEXTmem_lput(uaecptr addr, uae_u32 l)
294: {
295: addr &= NEXTmem_mask;
296: do_put_mem_long(NEXTRam + addr, l);
297: }
298:
299: static void NEXTmem_wput(uaecptr addr, uae_u32 w)
300: {
301: addr &= NEXTmem_mask;
302: do_put_mem_word(NEXTRam + addr, w);
303: }
304:
305: static void NEXTmem_bput(uaecptr addr, uae_u32 b)
306: {
307: addr &= NEXTmem_mask;
308: NEXTRam[addr] = b;
309: }
310:
311: static int NEXTmem_check(uaecptr addr, uae_u32 size)
312: {
1.1.1.2 ! root 313: return (size) < NEXT_RAM_SIZE;
1.1 root 314: }
315:
316: static uae_u8 *NEXTmem_xlate(uaecptr addr)
317: {
318: addr &= NEXTmem_mask;
319: return NEXTRam + addr;
320: }
321:
1.1.1.2 ! root 322:
! 323: /* **** NEXT RAM empty areas **** NEED TO CHECK: really do bus errors ??? **** */
! 324:
! 325: static uae_u32 NEXTempty_lget(uaecptr addr)
! 326: {
! 327: if (illegal_mem)
! 328: write_log ("Empty mem area lget at %08lx\n", (long)addr);
! 329:
! 330: M68000_BusError(addr, 1);
! 331: return addr;
! 332: }
! 333:
! 334: static uae_u32 NEXTempty_wget(uaecptr addr)
! 335: {
! 336: if (illegal_mem)
! 337: write_log ("Empty mem area wget at %08lx\n", (long)addr);
! 338:
! 339: M68000_BusError(addr, 1);
! 340: return 0;
! 341: }
! 342:
! 343: static uae_u32 NEXTempty_bget(uaecptr addr)
! 344: {
! 345: if (illegal_mem)
! 346: write_log ("Empty mem area bget at %08lx\n", (long)addr);
! 347:
! 348: M68000_BusError(addr, 1);
! 349: return 0;
! 350: }
! 351: /*------------------- this part is experimental ---------------------*/
! 352:
! 353: static void NEXTempty_lput(uaecptr addr, uae_u32 l)
! 354: {
! 355: if (illegal_mem)
! 356: write_log ("Empty mem area lput at %08lx\n", (long)addr);
! 357:
! 358: uae_u8 bank = ((addr-NEXT_RAM_START)>>bankshift)&0x3;
! 359:
! 360: if (MemBank_Size[bank]) {
! 361: addr = (((addr%MemBank_Size[bank])+(bank<<bankshift))+NEXT_RAM_START)&NEXTmem_mask;
! 362: do_put_mem_long(NEXTRam + addr, l);
! 363: }
! 364:
! 365: M68000_BusError(addr, 0);
! 366: }
! 367: /*-------------------- end of experimental code ----------------------*/
! 368:
! 369: static void NEXTempty_wput(uaecptr addr, uae_u32 w)
! 370: {
! 371: if (illegal_mem)
! 372: write_log ("Empty mem area wput at %08lx\n", (long)addr);
! 373:
! 374: M68000_BusError(addr, 0);
! 375: }
! 376:
! 377: static void NEXTempty_bput(uaecptr addr, uae_u32 b)
! 378: {
! 379: if (illegal_mem)
! 380: write_log ("Empty mem area bput at %08lx\n", (long)addr);
! 381:
! 382: M68000_BusError(addr, 0);
! 383: }
! 384:
! 385: static int NEXTempty_check(uaecptr addr, uae_u32 size)
! 386: {
! 387: if (illegal_mem)
! 388: write_log ("Empty mem area check at %08lx\n", (long)addr);
! 389:
! 390: return 0;
! 391: }
! 392:
! 393: static uae_u8 *NEXTempty_xlate (uaecptr addr)
! 394: {
! 395: write_log("Your NeXT program just did something terribly stupid:"
! 396: " BusErrMem_xlate($%x)\n", addr);
! 397:
! 398: abort();
! 399: M68000_BusError(addr,0);
! 400: return NEXTmem_xlate(addr); /* So we don't crash. */
! 401: }
! 402:
! 403:
1.1 root 404: /* bank2 */
405:
406: static uae_u32 NEXTmem2_lget(uaecptr addr)
407: {
408: addr &= NEXTmem_mask;
409: return do_get_mem_long(NEXTRam + 0x00400000 + addr);
410: }
411:
412: static uae_u32 NEXTmem2_wget(uaecptr addr)
413: {
414: addr &= NEXTmem_mask;
415: return do_get_mem_word(NEXTRam + 0x00400000 + addr);
416: }
417:
418: static uae_u32 NEXTmem2_bget(uaecptr addr)
419: {
420: addr &= NEXTmem_mask;
421: return NEXTRam[addr+0x00400000];
422: }
423:
424: static void NEXTmem2_lput(uaecptr addr, uae_u32 l)
425: {
426: addr &= NEXTmem_mask;
427: do_put_mem_long(NEXTRam + addr + 0x00400000, l);
428: }
429:
430: static void NEXTmem2_wput(uaecptr addr, uae_u32 w)
431: {
432: addr &= NEXTmem_mask;
433: do_put_mem_word(NEXTRam + addr + 0x00400000, w);
434: }
435:
436: static void NEXTmem2_bput(uaecptr addr, uae_u32 b)
437: {
438: addr &= NEXTmem_mask;
439: NEXTRam[addr+0x00400000] = b;
440: }
441:
442: static int NEXTmem2_check(uaecptr addr, uae_u32 size)
443: {
444: addr &= NEXTmem_mask;
445: return (addr + size) <= 0x003FFFFF;
446: }
447:
448: static uae_u8 *NEXTmem2_xlate(uaecptr addr)
449: {
450: addr &= NEXTmem_mask;
451: return NEXTRam + addr + 0x00400000;
452: }
453:
454:
1.1.1.2 ! root 455: /* **** NEXT VRAM memory for monochrome systems **** */
1.1 root 456:
457: static uae_u32 NEXTvideo_lget(uaecptr addr)
458: {
459: addr &= NEXTvideo_mask;
460: return do_get_mem_long(NEXTVideo + addr);
461: }
462:
463: static uae_u32 NEXTvideo_wget(uaecptr addr)
464: {
465: addr &= NEXTvideo_mask;
466: return do_get_mem_word(NEXTVideo + addr);
467: }
468:
469: static uae_u32 NEXTvideo_bget(uaecptr addr)
470: {
471: addr &= NEXTvideo_mask;
472: return NEXTVideo[addr];
473: }
474:
475: static void NEXTvideo_lput(uaecptr addr, uae_u32 l)
476: {
477: addr &= NEXTvideo_mask;
478: do_put_mem_long(NEXTVideo + addr, l);
479: }
480:
481: static void NEXTvideo_wput(uaecptr addr, uae_u32 w)
482: {
483: addr &= NEXTvideo_mask;
484: do_put_mem_word(NEXTVideo + addr, w);
485: }
486:
487: static void NEXTvideo_bput(uaecptr addr, uae_u32 b)
488: {
489: addr &= NEXTvideo_mask;
490: NEXTVideo[addr] = b;
491: }
492:
493: static int NEXTvideo_check(uaecptr addr, uae_u32 size)
494: {
495: addr &= NEXTvideo_mask;
496: return (addr + size) <= NEXTvideo_size;
497: }
498:
499: static uae_u8 *NEXTvideo_xlate(uaecptr addr)
500: {
501: addr &= NEXTvideo_mask;
502: return (uae_u8*)NEXTVideo + addr;
503: }
504:
1.1.1.2 ! root 505:
! 506: /* **** NEXT VRAM memory for color systems **** */
! 507:
! 508: static uae_u32 NEXTcolorvideo_lget(uaecptr addr)
! 509: {
! 510: addr &= NEXTcolorvideo_mask;
! 511: return do_get_mem_long(NEXTColorVideo + addr);
! 512: }
! 513:
! 514: static uae_u32 NEXTcolorvideo_wget(uaecptr addr)
! 515: {
! 516: addr &= NEXTcolorvideo_mask;
! 517: return do_get_mem_word(NEXTColorVideo + addr);
! 518: }
! 519:
! 520: static uae_u32 NEXTcolorvideo_bget(uaecptr addr)
! 521: {
! 522: addr &= NEXTcolorvideo_mask;
! 523: return NEXTColorVideo[addr];
! 524: }
! 525:
! 526: static void NEXTcolorvideo_lput(uaecptr addr, uae_u32 l)
! 527: {
! 528: addr &= NEXTcolorvideo_mask;
! 529: do_put_mem_long(NEXTColorVideo + addr, l);
! 530: }
! 531:
! 532: static void NEXTcolorvideo_wput(uaecptr addr, uae_u32 w)
! 533: {
! 534: addr &= NEXTcolorvideo_mask;
! 535: do_put_mem_word(NEXTColorVideo + addr, w);
! 536: }
! 537:
! 538: static void NEXTcolorvideo_bput(uaecptr addr, uae_u32 b)
! 539: {
! 540: addr &= NEXTcolorvideo_mask;
! 541: NEXTColorVideo[addr] = b;
! 542: }
! 543:
! 544: static int NEXTcolorvideo_check(uaecptr addr, uae_u32 size)
! 545: {
! 546: addr &= NEXTcolorvideo_mask;
! 547: return (addr + size) <= NEXTcolorvideo_size;
! 548: }
! 549:
! 550: static uae_u8 *NEXTcolorvideo_xlate(uaecptr addr)
! 551: {
! 552: addr &= NEXTcolorvideo_mask;
! 553: return (uae_u8*)NEXTColorVideo + addr;
! 554: }
! 555:
! 556:
1.1 root 557: /* **** NEXT BMAP memory **** */
558:
559: static uae_u32 NEXTbmap_lget(uaecptr addr)
560: {
561: write_log ("bmap lget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
562: addr &= NEXTbmap_mask;
563: return do_get_mem_long(NEXTbmap + addr);
564: }
565:
566: static uae_u32 NEXTbmap_wget(uaecptr addr)
567: {
568: write_log ("bmap wget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
569: addr &= NEXTbmap_mask;
570: return do_get_mem_word(NEXTbmap + addr);
571: }
572:
573: static uae_u32 NEXTbmap_bget(uaecptr addr)
574: {
575: write_log ("bmap bget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
576: addr &= NEXTbmap_mask;
577: return NEXTbmap[addr];
578: }
579:
580: static void NEXTbmap_lput(uaecptr addr, uae_u32 l)
581: {
582: write_log ("bmap lput at %08lx val=%x PC=%08x\n", (long)addr,l,m68k_getpc());
583: addr &= NEXTbmap_mask;
584: do_put_mem_long(NEXTbmap + addr, l);
585: }
586:
587: static void NEXTbmap_wput(uaecptr addr, uae_u32 w)
588: {
589: write_log ("bmap wput at %08lx val=%x PC=%08x\n", (long)addr,w,m68k_getpc());
590: addr &= NEXTbmap_mask;
591: do_put_mem_word(NEXTbmap + addr, w);
592: }
593:
594: static void NEXTbmap_bput(uaecptr addr, uae_u32 b)
595: {
596: write_log ("bmap bput at %08lx val=%x PC=%08x\n", (long)addr,b,m68k_getpc());
597: addr &= NEXTbmap_mask;
598: NEXTbmap[addr] = b;
599: }
600:
601: static int NEXTbmap_check(uaecptr addr, uae_u32 size)
602: {
603: addr &= NEXTbmap_mask;
604: return (addr + size) <= NEXTbmap_size;
605: }
606:
607: static uae_u8 *NEXTbmap_xlate(uaecptr addr)
608: {
609: addr &= NEXTbmap_mask;
610: return (uae_u8*)NEXTbmap + addr;
611: }
612:
613: /* **** NEXT x06 memory **** */
614:
615: static uae_u32 NEXTx06_lget(uaecptr addr)
616: {
617: write_log ("x06 lget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
618: addr &= NEXTx06_mask;
619: // return do_get_mem_long(NEXTx06 + addr);
620: return 0xFFFFFFFF;
621: }
622:
623: static uae_u32 NEXTx06_wget(uaecptr addr)
624: {
625: write_log ("x06 wget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
626: addr &= NEXTx06_mask;
627: // return do_get_mem_word(NEXTx06 + addr);
628: return 0xFFFF;
629: }
630:
631: static uae_u32 NEXTx06_bget(uaecptr addr)
632: {
633: write_log ("x06 bget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
634: addr &= NEXTx06_mask;
635: // return NEXTx06[addr];
636: return 0xFF;
637: }
638:
639: static void NEXTx06_lput(uaecptr addr, uae_u32 l)
640: {
641: write_log ("x06 lput at %08lx val=%x PC=%08x\n", (long)addr,l,m68k_getpc());
642: addr &= NEXTx06_mask;
643: do_put_mem_long(NEXTx06 + addr, l);
644: }
645:
646: static void NEXTx06_wput(uaecptr addr, uae_u32 w)
647: {
648: write_log ("x06 wput at %08lx val=%x PC=%08x\n", (long)addr,w,m68k_getpc());
649: addr &= NEXTx06_mask;
650: do_put_mem_word(NEXTx06 + addr, w);
651: }
652:
653: static void NEXTx06_bput(uaecptr addr, uae_u32 b)
654: {
655: write_log ("x06 bput at %08lx val=%x PC=%08x\n", (long)addr,b,m68k_getpc());
656: addr &= NEXTx06_mask;
657: NEXTx06[addr] = b;
658: }
659:
660: static int NEXTx06_check(uaecptr addr, uae_u32 size)
661: {
662: addr &= NEXTx06_mask;
663: return (addr + size) <= NEXTx06_size;
664: }
665:
666: static uae_u8 *NEXTx06_xlate(uaecptr addr)
667: {
668: addr &= NEXTx06_mask;
669: return (uae_u8*)NEXTx06 + addr;
670: }
671:
672:
673: /*
674: * **** Void memory ****
675: * lots of free space in next's full 32bits memory map
676: * Reading always returns the same value and writing does nothing at all.
677: */
678:
679: static uae_u32 VoidMem_lget(uaecptr addr)
680: {
681: return 0;
682: }
683:
684: static uae_u32 VoidMem_wget(uaecptr addr)
685: {
686: return 0;
687: }
688:
689: static uae_u32 VoidMem_bget(uaecptr addr)
690: {
691: return 0;
692: }
693:
694: static void VoidMem_lput(uaecptr addr, uae_u32 l)
695: {
696: }
697:
698: static void VoidMem_wput(uaecptr addr, uae_u32 w)
699: {
700: }
701:
702: static void VoidMem_bput (uaecptr addr, uae_u32 b)
703: {
704: }
705:
706: static int VoidMem_check(uaecptr addr, uae_u32 size)
707: {
708: if (illegal_mem)
709: write_log ("Void memory check at %08lx\n", (long)addr);
710:
711: return 0;
712: }
713:
714: static uae_u8 *VoidMem_xlate (uaecptr addr)
715: {
716: write_log("Your Next program just did something terribly stupid:"
717: " VoidMem_xlate($%x)\n", addr);
718:
719: return NEXTmem_xlate(addr); /* So we don't crash. */
720: }
721:
722:
723: /* **** ROM memory **** */
724:
1.1.1.2 ! root 725: extern int SCR_ROM_overlay;
! 726:
1.1 root 727: uae_u8 *ROMmemory;
728:
729: static uae_u32 ROMmem_lget(uaecptr addr)
730: {
1.1.1.2 ! root 731: if ((addr<0x2000) && (SCR_ROM_overlay)) {do_get_mem_long(NEXTRam + 0x03FFE000 +addr);}
1.1 root 732: addr &= ROMmem_mask;
733: return do_get_mem_long(ROMmemory + addr);
734: }
735:
736: static uae_u32 ROMmem_wget(uaecptr addr)
737: {
1.1.1.2 ! root 738: if ((addr<0x2000) && (SCR_ROM_overlay)) {do_get_mem_word(NEXTRam + 0x03FFE000 +addr);}
1.1 root 739: addr &= ROMmem_mask;
1.1.1.2 ! root 740: return do_get_mem_word(ROMmemory + addr);
! 741:
1.1 root 742: }
743:
744: static uae_u32 ROMmem_bget(uaecptr addr)
745: {
1.1.1.2 ! root 746: if ((addr<0x2000) && (SCR_ROM_overlay)) {return NEXTRam[0x03FFE000 +addr];}
1.1 root 747: addr &= ROMmem_mask;
748: return ROMmemory[addr];
749: }
750:
751: static void ROMmem_lput(uaecptr addr, uae_u32 b)
752: {
1.1.1.2 ! root 753: illegal_trace(write_log ("Illegal ROMmem lput at %08lx\n", (long)addr));
1.1 root 754: M68000_BusError(addr, 0);
755: }
756:
757: static void ROMmem_wput(uaecptr addr, uae_u32 b)
758: {
1.1.1.2 ! root 759: illegal_trace(write_log ("Illegal ROMmem wput at %08lx\n", (long)addr));
1.1 root 760: M68000_BusError(addr, 0);
761: }
762:
763: static void ROMmem_bput(uaecptr addr, uae_u32 b)
764: {
1.1.1.2 ! root 765: illegal_trace(write_log ("Illegal ROMmem bput at %08lx\n", (long)addr));
1.1 root 766: M68000_BusError(addr, 0);
767: }
768:
769: static int ROMmem_check(uaecptr addr, uae_u32 size)
770: {
771: addr &= ROMmem_mask;
772: return (addr + size) <= ROMmem_size;
773: }
774:
775: static uae_u8 *ROMmem_xlate(uaecptr addr)
776: {
777: addr &= ROMmem_mask;
778: return ROMmemory + addr;
779: }
780:
781: /* Hardware IO memory */
782: /* see also ioMem.c */
783:
784: uae_u8 *IOmemory;
785:
786: static int IOmem_check(uaecptr addr, uae_u32 size)
787: {
1.1.1.2 ! root 788: return 0;
1.1 root 789: }
790:
791: static uae_u8 *IOmem_xlate(uaecptr addr)
792: {
793: addr &= IOmem_mask;
794: return IOmemory + addr;
795: }
796:
797:
798:
799: /* **** Address banks **** */
800:
801: static addrbank dummy_bank =
802: {
803: dummy_lget, dummy_wget, dummy_bget,
804: dummy_lput, dummy_wput, dummy_bput,
805: dummy_xlate, dummy_check, NULL, NULL,
806: dummy_lget, dummy_wget, ABFLAG_NONE
807: // dummy_lgeti, dummy_wgeti, ABFLAG_NONE
808: };
809:
810: static addrbank BusErrMem_bank =
811: {
812: BusErrMem_lget, BusErrMem_wget, BusErrMem_bget,
813: BusErrMem_lput, BusErrMem_wput, BusErrMem_bput,
1.1.1.2 ! root 814: BusErrMem_xlate, BusErrMem_check, NULL, (char*)"BusError memory",
1.1 root 815: BusErrMem_lget, BusErrMem_wget, ABFLAG_NONE
816: };
817:
818: static addrbank NEXTmem_bank =
819: {
820: NEXTmem_lget, NEXTmem_wget, NEXTmem_bget,
821: NEXTmem_lput, NEXTmem_wput, NEXTmem_bput,
1.1.1.2 ! root 822: NEXTmem_xlate, NEXTmem_check, NULL, (char*)"NEXT memory",
1.1 root 823: NEXTmem_lget, NEXTmem_wget, ABFLAG_RAM
824:
825: };
826:
1.1.1.2 ! root 827: static addrbank NEXTempty_bank =
! 828: {
! 829: NEXTempty_lget, NEXTempty_wget, NEXTempty_bget,
! 830: NEXTempty_lput, NEXTempty_wput, NEXTempty_bput,
! 831: NEXTempty_xlate, NEXTempty_check, NULL, (char*)"Empty memory",
! 832: NEXTempty_lget, NEXTempty_wget, ABFLAG_RAM
! 833: };
! 834:
1.1 root 835: static addrbank NEXTmem_bank2 =
836: {
837: NEXTmem2_lget, NEXTmem2_wget, NEXTmem2_bget,
838: NEXTmem2_lput, NEXTmem2_wput, NEXTmem2_bput,
1.1.1.2 ! root 839: NEXTmem2_xlate, NEXTmem2_check, NULL, (char*)"NEXT memory",
1.1 root 840: NEXTmem2_lget, NEXTmem2_wget, ABFLAG_RAM
841: };
842:
843: static addrbank VoidMem_bank =
844: {
845: VoidMem_lget, VoidMem_wget, VoidMem_bget,
846: VoidMem_lput, VoidMem_wput, VoidMem_bput,
1.1.1.2 ! root 847: VoidMem_xlate, VoidMem_check, NULL, (char*)"Void memory",
1.1 root 848: VoidMem_lget, VoidMem_wget, ABFLAG_NONE
849: };
850:
851: static addrbank Video_bank =
852: {
853: NEXTvideo_lget, NEXTvideo_wget, NEXTvideo_bget,
854: NEXTvideo_lput, NEXTvideo_wput, NEXTvideo_bput,
1.1.1.2 ! root 855: NEXTvideo_xlate, NEXTvideo_check, NULL, (char*)"Video memory",
1.1 root 856: NEXTvideo_lget, NEXTvideo_wget, ABFLAG_RAM
857: };
858:
1.1.1.2 ! root 859: static addrbank ColorVideo_bank =
! 860: {
! 861: NEXTcolorvideo_lget, NEXTcolorvideo_wget, NEXTcolorvideo_bget,
! 862: NEXTcolorvideo_lput, NEXTcolorvideo_wput, NEXTcolorvideo_bput,
! 863: NEXTcolorvideo_xlate, NEXTcolorvideo_check, NULL, (char*)"Color Video memory",
! 864: NEXTcolorvideo_lget, NEXTcolorvideo_wget, ABFLAG_RAM
! 865: };
! 866:
1.1 root 867: static addrbank bmap_bank =
868: {
869: NEXTbmap_lget, NEXTbmap_wget, NEXTbmap_bget,
870: NEXTbmap_lput, NEXTbmap_wput, NEXTbmap_bput,
1.1.1.2 ! root 871: NEXTbmap_xlate, NEXTbmap_check, NULL, (char*)"bmap memory",
1.1 root 872: NEXTbmap_lget, NEXTbmap_wget, ABFLAG_RAM
873: };
874:
875: static addrbank x06_bank =
876: {
877: NEXTx06_lget, NEXTx06_wget, NEXTx06_bget,
878: NEXTx06_lput, NEXTx06_wput, NEXTx06_bput,
1.1.1.2 ! root 879: NEXTx06_xlate, NEXTx06_check, NULL, (char*)"x06 memory",
1.1 root 880: NEXTx06_lget, NEXTx06_wget, ABFLAG_RAM
881: };
882:
883: static addrbank ROMmem_bank =
884: {
885: ROMmem_lget, ROMmem_wget, ROMmem_bget,
886: ROMmem_lput, ROMmem_wput, ROMmem_bput,
1.1.1.2 ! root 887: ROMmem_xlate, ROMmem_check, NULL, (char*)"ROM memory",
1.1 root 888: ROMmem_lget, ROMmem_wget, ABFLAG_ROM
889: };
890:
891: static addrbank IOmem_bank =
892: {
893: IoMem_lget, IoMem_wget, IoMem_bget,
894: IoMem_lput, IoMem_wput, IoMem_bput,
1.1.1.2 ! root 895: IOmem_xlate, IOmem_check, NULL, (char*)"IO memory",
1.1 root 896: IoMem_lget, IoMem_wget, ABFLAG_RAM
897: };
898:
899:
900:
901: static void init_mem_banks (void)
902: {
903: int i;
904: for (i = 0; i < 65536; i++)
1.1.1.2 ! root 905: put_mem_bank (i<<16, &BusErrMem_bank);
1.1 root 906: }
907:
908:
909: /*
910: * Initialize the memory banks
911: */
1.1.1.2 ! root 912: const char* memory_init(int *nNewNEXTMemSize)
1.1 root 913: {
1.1.1.2 ! root 914: int i;
! 915: uae_u32 bankstart;
! 916: uae_u32 bankmaxsize;
! 917:
! 918: /* Set machine dependent variables */
! 919: if (ConfigureParams.System.bTurbo) {
! 920: NEXT_RAM_SIZE = 0x08000000;
! 921: NEXTmem_mask = 0x07FFFFFF;
! 922: bankshift = 25;
! 923: } else if (ConfigureParams.System.bColor) {
! 924: NEXT_RAM_SIZE = 0x02000000;
! 925: NEXTmem_mask = 0x01FFFFFF;
! 926: bankshift = 23;
! 927: } else {
! 928: NEXT_RAM_SIZE = 0x04000000;
! 929: NEXTmem_mask = 0x03FFFFFF;
! 930: bankshift = 24;
! 931: }
! 932:
! 933: write_log("Memory init: Memory size: %iMB\n", Configuration_CheckMemory(nNewNEXTMemSize));
1.1 root 934:
1.1.1.2 ! root 935: /* Convert values from MB to byte */
! 936: for (i=0; i<N_BANKS; i++) {
! 937: MemBank_Size[i] = nNewNEXTMemSize[i]<<20;
! 938: }
1.1 root 939:
940: /* fill every 65536 bank with dummy */
941: init_mem_banks();
942:
943:
1.1.1.2 ! root 944: #define MEM_HARDCODE 0
! 945: #if MEM_HARDCODE
! 946: /* Memory banks can be hardcoded here */
! 947: MemBank_Size[0] = 0x400000; // 4 MB
! 948: MemBank_Size[1] = 0x1000000; // 16 MB
! 949: MemBank_Size[2] = 0x400000; // 4 MB
! 950: MemBank_Size[3] = 0; // empty
! 951: #endif
! 952:
! 953: /* Map memory banks and fill empty area of memory bank with special banks */
! 954: for (i = 0; i<N_BANKS; i++) {
! 955: bankstart = NEXT_RAM_START+(i<<bankshift);
! 956: bankmaxsize = NEXT_RAM_SIZE/N_BANKS;
! 957: map_banks(&NEXTmem_bank, bankstart>>16, MemBank_Size[i] >> 16);
! 958: map_banks(&NEXTempty_bank, (bankstart+MemBank_Size[i])>>16, (bankmaxsize-MemBank_Size[i]) >> 16);
! 959: write_log("Mapping Bank%i at $%08x: %iMB\n", i, bankstart, MemBank_Size[i]/(1024*1024));
! 960: }
1.1 root 961:
1.1.1.2 ! root 962: // map_banks(&NEXTmem_bank, NEXT_RAM_START>>16, NEXT_RAM_SIZE >> 16);
! 963:
! 964: // map_banks(&NEXTmem_bank, 0x04000000>>16, MemBank_Size[0] >> 16);
! 965: // map_banks(&NEXTmem_bank, 0x04800000>>16, MemBank_Size[1] >> 16);
! 966: // map_banks(&NEXTmem_bank, 0x05000000>>16, MemBank_Size[2] >> 16);
! 967: // map_banks(&NEXTmem_bank, 0x05800000>>16, MemBank_Size[3] >> 16);
! 968:
! 969: // also map here... need to check address for function (weird?)
! 970: /*
! 971: map_banks(&NEXTmem_bank, 0x10000000>>16, NEXT_RAM_SIZE >> 16);
! 972: map_banks(&NEXTmem_bank, 0x14000000>>16, NEXT_RAM_SIZE >> 16);
! 973: map_banks(&NEXTmem_bank, 0x18000000>>16, NEXT_RAM_SIZE >> 16);
! 974: map_banks(&NEXTmem_bank, 0x1C000000>>16, NEXT_RAM_SIZE >> 16);
! 975: */
! 976:
1.1 root 977: // map_banks(&NEXTmem_bank2, NEXT_RAM_START2>>16, NEXT_RAM_SIZE2 >> 16);
978:
1.1.1.2 ! root 979: if (ConfigureParams.System.bColor) {
! 980: map_banks(&ColorVideo_bank, NEXT_COLORSCREEN>>16, NEXT_COLORSCREEN_SIZE >> 16);
! 981: map_banks(&ColorVideo_bank, NEXT_COLORSCREEN>>16, NEXT_COLORSCREEN_SIZE >> 16);
! 982: map_banks(&ColorVideo_bank, NEXT_COLORSCREEN>>16, NEXT_COLORSCREEN_SIZE >> 16);
! 983: map_banks(&ColorVideo_bank, NEXT_COLORSCREEN>>16, NEXT_COLORSCREEN_SIZE >> 16);
! 984: write_log("Mapping Video Memory at $%08x: %ikB\n", NEXT_COLORSCREEN, NEXT_COLORSCREEN_SIZE/1024);
! 985: } else {
! 986: map_banks(&Video_bank, NEXT_SCREEN>>16, NEXT_SCREEN_SIZE >> 16);
! 987: map_banks(&Video_bank, NEXT_SCREEN>>16, NEXT_SCREEN_SIZE >> 16);
! 988: map_banks(&Video_bank, NEXT_SCREEN>>16, NEXT_SCREEN_SIZE >> 16);
! 989: map_banks(&Video_bank, NEXT_SCREEN>>16, NEXT_SCREEN_SIZE >> 16);
! 990: write_log("Mapping Video Memory at $%08x: %ikB\n", NEXT_SCREEN, NEXT_SCREEN_SIZE/1024);
! 991: }
! 992:
1.1 root 993: map_banks(&ROMmem_bank, NEXT_EPROM_START >> 16, NEXT_EPROM_SIZE>>16);
994: map_banks(&ROMmem_bank, NEXT_EPROM2_START >> 16, NEXT_EPROM_SIZE>>16);
995:
996: map_banks(&IOmem_bank, NEXT_IO_START >> 16, NEXT_IO_SIZE>>16);
1.1.1.2 ! root 997:
! 998: if (ConfigureParams.System.nMachineType != NEXT_CUBE030)
! 999: map_banks(&IOmem_bank, NEXT_IO2_START >> 16, NEXT_IO_SIZE>>16);
! 1000:
! 1001: if (ConfigureParams.System.bTurbo)
! 1002: map_banks(&IOmem_bank, NEXT_IO3_START >> 16, NEXT_IO_SIZE>>16);
1.1 root 1003:
1004: map_banks(&bmap_bank, NEXT_BMAP_START >> 16, NEXT_BMAP_SIZE>>16);
1.1.1.2 ! root 1005:
1.1 root 1006:
1007: ROMmemory=NEXTRom;
1008: IOmemory=NEXTIo;
1009: {
1010: FILE* fin;
1011: int ret;
1.1.1.2 ! root 1012: /* Loading ROM depending on emulated system */
! 1013: if(ConfigureParams.System.nMachineType == NEXT_CUBE030)
! 1014: fin=fopen(ConfigureParams.Rom.szRom030FileName,"rb");
! 1015: else if(ConfigureParams.System.bTurbo == true)
! 1016: fin=fopen(ConfigureParams.Rom.szRomTurboFileName,"rb");
1.1 root 1017: else
1.1.1.2 ! root 1018: fin=fopen(ConfigureParams.Rom.szRom040FileName, "rb");
! 1019:
! 1020: if (fin==NULL) {
! 1021: return "Cannot open ROM file";
! 1022: }
! 1023:
1.1 root 1024: ret=fread(ROMmemory,1,0x20000,fin);
1025:
1026: write_log("Read ROM %d\n",ret);
1027: fclose(fin);
1028: }
1029:
1030: {
1031: int i;
1032: for (i=0;i<sizeof(NEXTVideo);i++) NEXTVideo[i]=0xAA;
1033: for (i=0;i<sizeof(NEXTRam);i++) NEXTRam[i]=0xAA;
1034: }
1035:
1.1.1.2 ! root 1036: return NULL;
1.1 root 1037: }
1038:
1039:
1040: /*
1041: * Uninitialize the memory banks.
1042: */
1043: void memory_uninit (void)
1044: {
1045: }
1046:
1047:
1048: void map_banks (addrbank *bank, int start, int size)
1049: {
1050: int bnr;
1051: unsigned long int hioffs = 0, endhioffs = 0x100;
1052:
1053: for (bnr = start; bnr < start + size; bnr++)
1054: put_mem_bank (bnr << 16, bank);
1055: return;
1056: }
1057:
1058: void memory_hardreset (void)
1059: {
1.1.1.2 ! root 1060: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.