![[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:
34:
35: /*
36: approximative next memory map (source netbsd/next68k file cpu.h)
37:
38: EPROM 128k (>cube 040)
39: 0x00000000-0x0001FFFF
40: mirrored at
41: 0x01000000-0x0101FFFF
42:
43: RAM (16x4=64Mb max)
44: 0x04000000-0x07FFFFFF (0x047FFFFF for 8Mb)
45:
46: device
47: 0x02000000-0x0201BFFF
48: mirrored at
49: 0x02100000-0x0211BFFF
50:
51: SCREEN
52: 0x0B000000-0x0B03A7FF
53:
54: */
55: #define NEXT_EPROM_START 0x00000000
56: #define NEXT_EPROM2_START 0x01000000
57: #define ROMmem_mask 0x0001FFFF
58: #define ROMmem_size 0x00020000
59: #define NEXT_EPROM_SIZE 0x00020000
60:
61: // ram is flat?
62: #define NEXT_RAM_START 0x04000000
63: #define NEXT_RAM_SPACE 0x40000000
64: // #define NEXT_RAM_SIZE 0x007FE000
65: #define NEXT_RAM_SIZE 0x07FFE000
66:
67: uae_u32 NEXTmem_size; // unused
68: #define NEXTmem_mask 0x00FFFFFF
69: // for a mono screen
70: #define NEXT_SCREEN 0x0B000000
71: #define NEXT_SCREEN_SIZE 0x00040000
72: #define NEXTvideo_size NEXT_SCREEN_SIZE
73: #define NEXTvideo_mask 0x0003FFFF
74: uae_u8 NEXTVideo[256*1024];
75:
76:
77:
78: #define IOmem_mask 0x0001FFFF
79: #define IOmem_size 0x0001C000
80: #define NEXT_IO_START 0x02000000
81: #define NEXT_IO2_START 0x02100000
82: #define NEXT_IO_SIZE 0x00020000
83:
84: #define NEXT_BMAP_START 0x020C0000
85: #define NEXT_BMAP_SIZE 0x10000
86: #define NEXTbmap_size NEXT_BMAP_SIZE
87: #define NEXTbmap_mask 0x0000FFFF
88: uae_u8 NEXTbmap[NEXT_BMAP_SIZE];
89:
90: #define NEXT_X06_START 0x06000000
91: #define NEXT_X06_SIZE 0x10000
92: #define NEXTx06_size NEXT_X06_SIZE
93: #define NEXTx06_mask 0x0000FFFF
94: uae_u8 NEXTx06[NEXT_X06_SIZE];
95:
96:
97: #ifdef SAVE_MEMORY_BANKS
98: addrbank *mem_banks[65536];
99: #else
100: addrbank mem_banks[65536];
101: #endif
102:
103: #ifdef NO_INLINE_MEMORY_ACCESS
104: __inline__ uae_u32 longget (uaecptr addr)
105: {
106: return call_mem_get_func (get_mem_bank (addr).lget, addr);
107: }
108: __inline__ uae_u32 wordget (uaecptr addr)
109: {
110: return call_mem_get_func (get_mem_bank (addr).wget, addr);
111: }
112: __inline__ uae_u32 byteget (uaecptr addr)
113: {
114: return call_mem_get_func (get_mem_bank (addr).bget, addr);
115: }
116: __inline__ void longput (uaecptr addr, uae_u32 l)
117: {
118: call_mem_put_func (get_mem_bank (addr).lput, addr, l);
119: }
120: __inline__ void wordput (uaecptr addr, uae_u32 w)
121: {
122: call_mem_put_func (get_mem_bank (addr).wput, addr, w);
123: }
124: __inline__ void byteput (uaecptr addr, uae_u32 b)
125: {
126: call_mem_put_func (get_mem_bank (addr).bput, addr, b);
127: }
128: #endif
129:
130:
131: /* Some prototypes: */
132: extern void SDL_Quit(void);
133: static int NEXTmem_check (uaecptr addr, uae_u32 size) REGPARAM;
134: static uae_u8 *NEXTmem_xlate (uaecptr addr) REGPARAM;
135:
136: uae_u8 ce_banktype[65536];
137: uae_u8 ce_cachable[65536];
138:
139:
140: /* A dummy bank that only contains zeros */
141:
142: static uae_u32 dummy_lget(uaecptr addr)
143: {
144: if (illegal_mem)
145: write_log ("Illegal lget at %08lx\n", (long)addr);
146:
147: return 0;
148: }
149:
150: static uae_u32 dummy_wget(uaecptr addr)
151: {
152: if (illegal_mem)
153: write_log ("Illegal wget at %08lx\n", (long)addr);
154:
155: return 0;
156: }
157:
158: static uae_u32 dummy_bget(uaecptr addr)
159: {
160: if (illegal_mem)
161: write_log ("Illegal bget at %08lx\n", (long)addr);
162:
163: return 0;
164: }
165:
166: static void dummy_lput(uaecptr addr, uae_u32 l)
167: {
168: if (illegal_mem)
169: write_log ("Illegal lput at %08lx\n", (long)addr);
170: }
171:
172: static void dummy_wput(uaecptr addr, uae_u32 w)
173: {
174: if (illegal_mem)
175: write_log ("Illegal wput at %08lx\n", (long)addr);
176: }
177:
178: static void dummy_bput(uaecptr addr, uae_u32 b)
179: {
180: if (illegal_mem)
181: write_log ("Illegal bput at %08lx\n", (long)addr);
182: }
183:
184: static int dummy_check(uaecptr addr, uae_u32 size)
185: {
186: if (illegal_mem)
187: write_log ("Illegal check at %08lx\n", (long)addr);
188:
189: return 0;
190: }
191:
192: static uae_u8 *dummy_xlate(uaecptr addr)
193: {
194: write_log("Your Atari program just did something terribly stupid:"
195: " dummy_xlate($%x)\n", addr);
196: /*Reset_Warm();*/
197: // return NEXTmem_xlate(addr); /* So we don't crash. */
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:
267: /*M68000_BusError(addr);*/
268: return NEXTmem_xlate(addr); /* So we don't crash. */
269: }
270:
271:
272: /* **** NEXT RAM memory **** */
273:
274: static uae_u32 NEXTmem_lget(uaecptr addr)
275: {
276: addr &= NEXTmem_mask;
277: return do_get_mem_long(NEXTRam + addr);
278: }
279:
280: static uae_u32 NEXTmem_wget(uaecptr addr)
281: {
282: addr &= NEXTmem_mask;
283: return do_get_mem_word(NEXTRam + addr);
284: }
285:
286: static uae_u32 NEXTmem_bget(uaecptr addr)
287: {
288: addr &= NEXTmem_mask;
289: return NEXTRam[addr];
290: }
291:
292: static void NEXTmem_lput(uaecptr addr, uae_u32 l)
293: {
294: addr &= NEXTmem_mask;
295: do_put_mem_long(NEXTRam + addr, l);
296: }
297:
298: static void NEXTmem_wput(uaecptr addr, uae_u32 w)
299: {
300: addr &= NEXTmem_mask;
301: do_put_mem_word(NEXTRam + addr, w);
302: }
303:
304: static void NEXTmem_bput(uaecptr addr, uae_u32 b)
305: {
306: addr &= NEXTmem_mask;
307: NEXTRam[addr] = b;
308: }
309:
310: static int NEXTmem_check(uaecptr addr, uae_u32 size)
311: {
312: addr &= NEXTmem_mask;
313: return (addr + size) <= 0x003FFFFF;
314: }
315:
316: static uae_u8 *NEXTmem_xlate(uaecptr addr)
317: {
318: addr &= NEXTmem_mask;
319: return NEXTRam + addr;
320: }
321:
322: /* bank2 */
323:
324: static uae_u32 NEXTmem2_lget(uaecptr addr)
325: {
326: addr &= NEXTmem_mask;
327: return do_get_mem_long(NEXTRam + 0x00400000 + addr);
328: }
329:
330: static uae_u32 NEXTmem2_wget(uaecptr addr)
331: {
332: addr &= NEXTmem_mask;
333: return do_get_mem_word(NEXTRam + 0x00400000 + addr);
334: }
335:
336: static uae_u32 NEXTmem2_bget(uaecptr addr)
337: {
338: addr &= NEXTmem_mask;
339: return NEXTRam[addr+0x00400000];
340: }
341:
342: static void NEXTmem2_lput(uaecptr addr, uae_u32 l)
343: {
344: addr &= NEXTmem_mask;
345: do_put_mem_long(NEXTRam + addr + 0x00400000, l);
346: }
347:
348: static void NEXTmem2_wput(uaecptr addr, uae_u32 w)
349: {
350: addr &= NEXTmem_mask;
351: do_put_mem_word(NEXTRam + addr + 0x00400000, w);
352: }
353:
354: static void NEXTmem2_bput(uaecptr addr, uae_u32 b)
355: {
356: addr &= NEXTmem_mask;
357: NEXTRam[addr+0x00400000] = b;
358: }
359:
360: static int NEXTmem2_check(uaecptr addr, uae_u32 size)
361: {
362: addr &= NEXTmem_mask;
363: return (addr + size) <= 0x003FFFFF;
364: }
365:
366: static uae_u8 *NEXTmem2_xlate(uaecptr addr)
367: {
368: addr &= NEXTmem_mask;
369: return NEXTRam + addr + 0x00400000;
370: }
371:
372:
373: /* **** NEXT VRAM memory **** */
374:
375: static uae_u32 NEXTvideo_lget(uaecptr addr)
376: {
377: addr &= NEXTvideo_mask;
378: return do_get_mem_long(NEXTVideo + addr);
379: }
380:
381: static uae_u32 NEXTvideo_wget(uaecptr addr)
382: {
383: addr &= NEXTvideo_mask;
384: return do_get_mem_word(NEXTVideo + addr);
385: }
386:
387: static uae_u32 NEXTvideo_bget(uaecptr addr)
388: {
389: addr &= NEXTvideo_mask;
390: return NEXTVideo[addr];
391: }
392:
393: static void NEXTvideo_lput(uaecptr addr, uae_u32 l)
394: {
395: addr &= NEXTvideo_mask;
396: do_put_mem_long(NEXTVideo + addr, l);
397: }
398:
399: static void NEXTvideo_wput(uaecptr addr, uae_u32 w)
400: {
401: addr &= NEXTvideo_mask;
402: do_put_mem_word(NEXTVideo + addr, w);
403: }
404:
405: static void NEXTvideo_bput(uaecptr addr, uae_u32 b)
406: {
407: addr &= NEXTvideo_mask;
408: NEXTVideo[addr] = b;
409: }
410:
411: static int NEXTvideo_check(uaecptr addr, uae_u32 size)
412: {
413: addr &= NEXTvideo_mask;
414: return (addr + size) <= NEXTvideo_size;
415: }
416:
417: static uae_u8 *NEXTvideo_xlate(uaecptr addr)
418: {
419: addr &= NEXTvideo_mask;
420: return (uae_u8*)NEXTVideo + addr;
421: }
422:
423: /* **** NEXT BMAP memory **** */
424:
425: static uae_u32 NEXTbmap_lget(uaecptr addr)
426: {
427: write_log ("bmap lget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
428: addr &= NEXTbmap_mask;
429: return do_get_mem_long(NEXTbmap + addr);
430: }
431:
432: static uae_u32 NEXTbmap_wget(uaecptr addr)
433: {
434: write_log ("bmap wget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
435: addr &= NEXTbmap_mask;
436: return do_get_mem_word(NEXTbmap + addr);
437: }
438:
439: static uae_u32 NEXTbmap_bget(uaecptr addr)
440: {
441: write_log ("bmap bget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
442: addr &= NEXTbmap_mask;
443: return NEXTbmap[addr];
444: }
445:
446: static void NEXTbmap_lput(uaecptr addr, uae_u32 l)
447: {
448: write_log ("bmap lput at %08lx val=%x PC=%08x\n", (long)addr,l,m68k_getpc());
449: addr &= NEXTbmap_mask;
450: do_put_mem_long(NEXTbmap + addr, l);
451: }
452:
453: static void NEXTbmap_wput(uaecptr addr, uae_u32 w)
454: {
455: write_log ("bmap wput at %08lx val=%x PC=%08x\n", (long)addr,w,m68k_getpc());
456: addr &= NEXTbmap_mask;
457: do_put_mem_word(NEXTbmap + addr, w);
458: }
459:
460: static void NEXTbmap_bput(uaecptr addr, uae_u32 b)
461: {
462: write_log ("bmap bput at %08lx val=%x PC=%08x\n", (long)addr,b,m68k_getpc());
463: addr &= NEXTbmap_mask;
464: NEXTbmap[addr] = b;
465: }
466:
467: static int NEXTbmap_check(uaecptr addr, uae_u32 size)
468: {
469: addr &= NEXTbmap_mask;
470: return (addr + size) <= NEXTbmap_size;
471: }
472:
473: static uae_u8 *NEXTbmap_xlate(uaecptr addr)
474: {
475: addr &= NEXTbmap_mask;
476: return (uae_u8*)NEXTbmap + addr;
477: }
478:
479: /* **** NEXT x06 memory **** */
480:
481: static uae_u32 NEXTx06_lget(uaecptr addr)
482: {
483: write_log ("x06 lget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
484: addr &= NEXTx06_mask;
485: // return do_get_mem_long(NEXTx06 + addr);
486: return 0xFFFFFFFF;
487: }
488:
489: static uae_u32 NEXTx06_wget(uaecptr addr)
490: {
491: write_log ("x06 wget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
492: addr &= NEXTx06_mask;
493: // return do_get_mem_word(NEXTx06 + addr);
494: return 0xFFFF;
495: }
496:
497: static uae_u32 NEXTx06_bget(uaecptr addr)
498: {
499: write_log ("x06 bget at %08lx PC=%08x\n", (long)addr,m68k_getpc());
500: addr &= NEXTx06_mask;
501: // return NEXTx06[addr];
502: return 0xFF;
503: }
504:
505: static void NEXTx06_lput(uaecptr addr, uae_u32 l)
506: {
507: write_log ("x06 lput at %08lx val=%x PC=%08x\n", (long)addr,l,m68k_getpc());
508: addr &= NEXTx06_mask;
509: do_put_mem_long(NEXTx06 + addr, l);
510: }
511:
512: static void NEXTx06_wput(uaecptr addr, uae_u32 w)
513: {
514: write_log ("x06 wput at %08lx val=%x PC=%08x\n", (long)addr,w,m68k_getpc());
515: addr &= NEXTx06_mask;
516: do_put_mem_word(NEXTx06 + addr, w);
517: }
518:
519: static void NEXTx06_bput(uaecptr addr, uae_u32 b)
520: {
521: write_log ("x06 bput at %08lx val=%x PC=%08x\n", (long)addr,b,m68k_getpc());
522: addr &= NEXTx06_mask;
523: NEXTx06[addr] = b;
524: }
525:
526: static int NEXTx06_check(uaecptr addr, uae_u32 size)
527: {
528: addr &= NEXTx06_mask;
529: return (addr + size) <= NEXTx06_size;
530: }
531:
532: static uae_u8 *NEXTx06_xlate(uaecptr addr)
533: {
534: addr &= NEXTx06_mask;
535: return (uae_u8*)NEXTx06 + addr;
536: }
537:
538:
539: /*
540: * **** Void memory ****
541: * lots of free space in next's full 32bits memory map
542: * Reading always returns the same value and writing does nothing at all.
543: */
544:
545: static uae_u32 VoidMem_lget(uaecptr addr)
546: {
547: return 0;
548: }
549:
550: static uae_u32 VoidMem_wget(uaecptr addr)
551: {
552: return 0;
553: }
554:
555: static uae_u32 VoidMem_bget(uaecptr addr)
556: {
557: return 0;
558: }
559:
560: static void VoidMem_lput(uaecptr addr, uae_u32 l)
561: {
562: }
563:
564: static void VoidMem_wput(uaecptr addr, uae_u32 w)
565: {
566: }
567:
568: static void VoidMem_bput (uaecptr addr, uae_u32 b)
569: {
570: }
571:
572: static int VoidMem_check(uaecptr addr, uae_u32 size)
573: {
574: if (illegal_mem)
575: write_log ("Void memory check at %08lx\n", (long)addr);
576:
577: return 0;
578: }
579:
580: static uae_u8 *VoidMem_xlate (uaecptr addr)
581: {
582: write_log("Your Next program just did something terribly stupid:"
583: " VoidMem_xlate($%x)\n", addr);
584:
585: return NEXTmem_xlate(addr); /* So we don't crash. */
586: }
587:
588:
589: /* **** ROM memory **** */
590:
591: uae_u8 *ROMmemory;
592:
593: static uae_u32 ROMmem_lget(uaecptr addr)
594: {
595: addr &= ROMmem_mask;
596: return do_get_mem_long(ROMmemory + addr);
597: }
598:
599: static uae_u32 ROMmem_wget(uaecptr addr)
600: {
601: addr &= ROMmem_mask;
602: return do_get_mem_word(ROMmemory + addr);
603: }
604:
605: static uae_u32 ROMmem_bget(uaecptr addr)
606: {
607: addr &= ROMmem_mask;
608: return ROMmemory[addr];
609: }
610:
611: static void ROMmem_lput(uaecptr addr, uae_u32 b)
612: {
613: if (illegal_mem)
614: write_log ("Illegal ROMmem lput at %08lx\n", (long)addr);
615:
616: M68000_BusError(addr, 0);
617: }
618:
619: static void ROMmem_wput(uaecptr addr, uae_u32 b)
620: {
621: if (illegal_mem)
622: write_log ("Illegal ROMmem wput at %08lx\n", (long)addr);
623:
624: M68000_BusError(addr, 0);
625: }
626:
627: static void ROMmem_bput(uaecptr addr, uae_u32 b)
628: {
629: if (illegal_mem)
630: write_log ("Illegal ROMmem bput at %08lx\n", (long)addr);
631:
632: M68000_BusError(addr, 0);
633: }
634:
635: static int ROMmem_check(uaecptr addr, uae_u32 size)
636: {
637: addr &= ROMmem_mask;
638: return (addr + size) <= ROMmem_size;
639: }
640:
641: static uae_u8 *ROMmem_xlate(uaecptr addr)
642: {
643: addr &= ROMmem_mask;
644: return ROMmemory + addr;
645: }
646:
647: /* Hardware IO memory */
648: /* see also ioMem.c */
649:
650: uae_u8 *IOmemory;
651:
652: static int IOmem_check(uaecptr addr, uae_u32 size)
653: {
654: addr &= IOmem_mask;
655: return (addr + size) <= IOmem_size;
656: }
657:
658: static uae_u8 *IOmem_xlate(uaecptr addr)
659: {
660: addr &= IOmem_mask;
661: return IOmemory + addr;
662: }
663:
664:
665:
666: /* **** Address banks **** */
667:
668: static addrbank dummy_bank =
669: {
670: dummy_lget, dummy_wget, dummy_bget,
671: dummy_lput, dummy_wput, dummy_bput,
672: dummy_xlate, dummy_check, NULL, NULL,
673: dummy_lget, dummy_wget, ABFLAG_NONE
674: // dummy_lgeti, dummy_wgeti, ABFLAG_NONE
675: };
676:
677: static addrbank BusErrMem_bank =
678: {
679: BusErrMem_lget, BusErrMem_wget, BusErrMem_bget,
680: BusErrMem_lput, BusErrMem_wput, BusErrMem_bput,
681: BusErrMem_xlate, BusErrMem_check, NULL, "BusError memory",
682: BusErrMem_lget, BusErrMem_wget, ABFLAG_NONE
683: };
684:
685: static addrbank NEXTmem_bank =
686: {
687: NEXTmem_lget, NEXTmem_wget, NEXTmem_bget,
688: NEXTmem_lput, NEXTmem_wput, NEXTmem_bput,
689: NEXTmem_xlate, NEXTmem_check, NULL, "NEXT memory",
690: NEXTmem_lget, NEXTmem_wget, ABFLAG_RAM
691:
692: };
693:
694: static addrbank NEXTmem_bank2 =
695: {
696: NEXTmem2_lget, NEXTmem2_wget, NEXTmem2_bget,
697: NEXTmem2_lput, NEXTmem2_wput, NEXTmem2_bput,
698: NEXTmem2_xlate, NEXTmem2_check, NULL, "NEXT memory",
699: NEXTmem2_lget, NEXTmem2_wget, ABFLAG_RAM
700: };
701:
702: static addrbank VoidMem_bank =
703: {
704: VoidMem_lget, VoidMem_wget, VoidMem_bget,
705: VoidMem_lput, VoidMem_wput, VoidMem_bput,
706: VoidMem_xlate, VoidMem_check, NULL, "Void memory",
707: VoidMem_lget, VoidMem_wget, ABFLAG_NONE
708: };
709:
710: static addrbank Video_bank =
711: {
712: NEXTvideo_lget, NEXTvideo_wget, NEXTvideo_bget,
713: NEXTvideo_lput, NEXTvideo_wput, NEXTvideo_bput,
714: NEXTvideo_xlate, NEXTvideo_check, NULL, "Video memory",
715: NEXTvideo_lget, NEXTvideo_wget, ABFLAG_RAM
716: };
717:
718: static addrbank bmap_bank =
719: {
720: NEXTbmap_lget, NEXTbmap_wget, NEXTbmap_bget,
721: NEXTbmap_lput, NEXTbmap_wput, NEXTbmap_bput,
722: NEXTbmap_xlate, NEXTbmap_check, NULL, "bmap memory",
723: NEXTbmap_lget, NEXTbmap_wget, ABFLAG_RAM
724: };
725:
726: static addrbank x06_bank =
727: {
728: NEXTx06_lget, NEXTx06_wget, NEXTx06_bget,
729: NEXTx06_lput, NEXTx06_wput, NEXTx06_bput,
730: NEXTx06_xlate, NEXTx06_check, NULL, "x06 memory",
731: NEXTx06_lget, NEXTx06_wget, ABFLAG_RAM
732: };
733:
734: static addrbank ROMmem_bank =
735: {
736: ROMmem_lget, ROMmem_wget, ROMmem_bget,
737: ROMmem_lput, ROMmem_wput, ROMmem_bput,
738: ROMmem_xlate, ROMmem_check, NULL, "ROM memory",
739: ROMmem_lget, ROMmem_wget, ABFLAG_ROM
740: };
741:
742: static addrbank IOmem_bank =
743: {
744: IoMem_lget, IoMem_wget, IoMem_bget,
745: IoMem_lput, IoMem_wput, IoMem_bput,
746: IOmem_xlate, IOmem_check, NULL, "IO memory",
747: IoMem_lget, IoMem_wget, ABFLAG_RAM
748: };
749:
750:
751:
752: static void init_mem_banks (void)
753: {
754: int i;
755: for (i = 0; i < 65536; i++)
756: put_mem_bank (i<<16, &dummy_bank);
757: }
758:
759:
760: /*
761: * Initialize the memory banks
762: */
763: void memory_init(uae_u32 nNewNEXTMemSize)
764: {
765: NEXTmem_size = (nNewNEXTMemSize + 65535) & 0xFFFF0000;
766:
767: write_log("memory_init: NEXTmem_size=$%x\n",
768: nNewNEXTMemSize);
769:
770: /* fill every 65536 bank with dummy */
771: init_mem_banks();
772:
773: // map_banks(&BusErrMem_bank,NEXT_RAM_START>>16,NEXT_RAM_SPACE>>16);
774:
775: map_banks(&NEXTmem_bank, NEXT_RAM_START>>16, NEXT_RAM_SIZE >> 16);
776:
777: // map_banks(&NEXTmem_bank2, NEXT_RAM_START2>>16, NEXT_RAM_SIZE2 >> 16);
778:
779:
780: map_banks(&Video_bank, NEXT_SCREEN>>16, NEXT_SCREEN_SIZE >> 16);
781: map_banks(&Video_bank, NEXT_SCREEN>>16, NEXT_SCREEN_SIZE >> 16);
782: map_banks(&Video_bank, NEXT_SCREEN>>16, NEXT_SCREEN_SIZE >> 16);
783: map_banks(&Video_bank, NEXT_SCREEN>>16, NEXT_SCREEN_SIZE >> 16);
784:
785: map_banks(&ROMmem_bank, NEXT_EPROM_START >> 16, NEXT_EPROM_SIZE>>16);
786: map_banks(&ROMmem_bank, NEXT_EPROM2_START >> 16, NEXT_EPROM_SIZE>>16);
787:
788:
789: map_banks(&IOmem_bank, NEXT_IO_START >> 16, NEXT_IO_SIZE>>16);
790: map_banks(&IOmem_bank, NEXT_IO2_START >> 16, NEXT_IO_SIZE>>16);
791: // map_banks(&VoidMem_bank, NEXT_IO_START >> 16, NEXT_IO_SIZE>>16);
792: // map_banks(&VoidMem_bank, NEXT_IO2_START >> 16, NEXT_IO_SIZE>>16);
793:
794: map_banks(&bmap_bank, NEXT_BMAP_START >> 16, NEXT_BMAP_SIZE>>16);
795: // map_banks(&x06_bank, NEXT_X06_START >> 16, NEXT_X06_SIZE>>16);
796: // map_banks(&x06_bank, 0x07000000 >> 16, NEXT_X06_SIZE>>16);
797:
798: ROMmemory=NEXTRom;
799: IOmemory=NEXTIo;
800: {
801: FILE* fin;
802: int ret;
803: if(ConfigureParams.System.nCpuLevel == 3)
804: fin=fopen("./Rev_1.0_v41.BIN","rb");
805: else
806: fin=fopen("./Rev_2.5_v66.BIN","rb");
807: // fin=fopen("./Rev_3.3_v74.BIN","rb");
808: // fin=fopen("./Rev_1.2.BIN","rb");
809: // fin=fopen("./Rev_1.0_v41.BIN","rb");
810: ret=fread(ROMmemory,1,0x20000,fin);
811:
812: write_log("Read ROM %d\n",ret);
813: fclose(fin);
814: }
815:
816: {
817: int i;
818: for (i=0;i<sizeof(NEXTVideo);i++) NEXTVideo[i]=0xAA;
819: for (i=0;i<sizeof(NEXTRam);i++) NEXTRam[i]=0xAA;
820: }
821:
822: }
823:
824:
825: /*
826: * Uninitialize the memory banks.
827: */
828: void memory_uninit (void)
829: {
830: }
831:
832:
833: void map_banks (addrbank *bank, int start, int size)
834: {
835: int bnr;
836: unsigned long int hioffs = 0, endhioffs = 0x100;
837:
838: for (bnr = start; bnr < start + size; bnr++)
839: put_mem_bank (bnr << 16, bank);
840: return;
841: }
842:
843: void memory_hardreset (void)
844: {
845: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.