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