![[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.