Return to memory.c CVS log

Up to [Previous NeXT emulator] / previous / src / uae-cpu

Annotation of previous/src/uae-cpu/memory.c, revision 1.1

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.