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