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