Return to memory.c CVS log

Up to [UNIX Amiga Emulator] / uae

Annotation of uae/memory.c, revision 1.1.1.2

1.1.1.2 ! root        1:  /*
1.1       root        2:   * UAE - The Un*x Amiga Emulator
1.1.1.2 ! root        3:   *
1.1       root        4:   * Memory management
                      5:   *
                      6:   * (c) 1995 Bernd Schmidt
                      7:   */
                      8: 
1.1.1.2 ! root        9: #include "sysconfig.h"
        !            10: #include "sysdeps.h"
1.1       root       11: 
                     12: #include "config.h"
                     13: #include "options.h"
                     14: #include "memory.h"
                     15: #include "custom.h"
                     16: #include "cia.h"
                     17: #include "ersatz.h"
                     18: 
1.1.1.2 ! root       19: int ersatzkickfile = 0;
1.1       root       20: 
1.1.1.2 ! root       21: int buserr;
        !            22: addrbank membanks[65536];
1.1       root       23: 
                     24: /* Default memory access functions */
                     25: 
1.1.1.2 ! root       26: int default_check(CPTR a, ULONG b)
1.1       root       27: {
1.1.1.2 ! root       28:     return 0;
1.1       root       29: }
                     30: 
                     31: UWORD *default_xlate(CPTR a)
                     32: {
                     33:     fprintf(stderr, "Your Amiga program just did something terribly stupid\n");
                     34:     return 0;
                     35: }
                     36: 
1.1.1.2 ! root       37: /* A dummy bank that only contains zeros */
        !            38: 
        !            39: static ULONG dummy_lget(CPTR) REGPARAM;
        !            40: static UWORD dummy_wget(CPTR) REGPARAM;
        !            41: static UBYTE dummy_bget(CPTR) REGPARAM;
        !            42: static void  dummy_lput(CPTR, ULONG) REGPARAM;
        !            43: static void  dummy_wput(CPTR, UWORD) REGPARAM;
        !            44: static void  dummy_bput(CPTR, UBYTE) REGPARAM;
        !            45: static int   dummy_check(CPTR addr, ULONG size) REGPARAM;
        !            46: static UWORD *dummy_xlate(CPTR addr) REGPARAM;
        !            47: 
        !            48: ULONG dummy_lget(CPTR addr)
        !            49: {
        !            50:     return 0;
        !            51: }
        !            52: 
        !            53: UWORD dummy_wget(CPTR addr)
        !            54: {
        !            55:     return 0;
        !            56: }
        !            57: 
        !            58: UBYTE dummy_bget(CPTR addr)
        !            59: {
        !            60:     return 0;
        !            61: }
        !            62: 
        !            63: void dummy_lput(CPTR addr, ULONG l)
        !            64: {
        !            65: }
        !            66: 
        !            67: void dummy_wput(CPTR addr, UWORD w)
        !            68: {
        !            69: }
        !            70: 
        !            71: void dummy_bput(CPTR addr, UBYTE b)
        !            72: {
        !            73: }
        !            74: 
        !            75: int dummy_check(CPTR addr, ULONG size)
        !            76: {
        !            77:     return 0;
        !            78: }
        !            79: 
        !            80: UWORD *dummy_xlate(CPTR addr)
        !            81: {
        !            82:     return NULL;
        !            83: }
        !            84: 
1.1       root       85: /* Chip memory */
                     86: 
1.1.1.2 ! root       87: UWORD chipmemory[chipmem_size/2];
1.1       root       88: 
                     89: static ULONG chipmem_lget(CPTR) REGPARAM;
                     90: static UWORD chipmem_wget(CPTR) REGPARAM;
                     91: static UBYTE chipmem_bget(CPTR) REGPARAM;
                     92: static void  chipmem_lput(CPTR, ULONG) REGPARAM;
                     93: static void  chipmem_wput(CPTR, UWORD) REGPARAM;
                     94: static void  chipmem_bput(CPTR, UBYTE) REGPARAM;
1.1.1.2 ! root       95: static int   chipmem_check(CPTR addr, ULONG size) REGPARAM;
1.1       root       96: static UWORD *chipmem_xlate(CPTR addr) REGPARAM;
                     97: 
                     98: ULONG chipmem_lget(CPTR addr)
                     99: {
                    100:     addr -= chipmem_start & (chipmem_size-1);
                    101:     addr &= chipmem_size-1;
                    102:     return ((ULONG)chipmemory[addr >> 1] << 16) | chipmemory[(addr >> 1)+1];
                    103: }
                    104: 
                    105: UWORD chipmem_wget(CPTR addr)
                    106: {
                    107:     addr -= chipmem_start & (chipmem_size-1);
                    108:     addr &= chipmem_size-1;
                    109:     return chipmemory[addr >> 1];
                    110: }
                    111: 
                    112: UBYTE chipmem_bget(CPTR addr)
                    113: {
                    114:     addr -= chipmem_start & (chipmem_size-1);
                    115:     addr &= chipmem_size-1;
1.1.1.2 ! root      116:     if (addr & 1) 
        !           117:        return chipmemory[addr >> 1];
        !           118:     else
        !           119:        return chipmemory[addr >> 1] >> 8;
1.1       root      120: }
                    121: 
                    122: void chipmem_lput(CPTR addr, ULONG l)
                    123: {
                    124:     addr -= chipmem_start & (chipmem_size-1);
                    125:     addr &= chipmem_size-1;
                    126:     chipmemory[addr >> 1] = l >> 16;
                    127:     chipmemory[(addr >> 1)+1] = (UWORD)l;
                    128: }
                    129: 
                    130: void chipmem_wput(CPTR addr, UWORD w)
                    131: {
                    132:     addr -= chipmem_start & (chipmem_size-1);
                    133:     addr &= chipmem_size-1;
                    134:     chipmemory[addr >> 1] = w;
                    135: }
                    136: 
                    137: void chipmem_bput(CPTR addr, UBYTE b)
                    138: {
                    139:     addr -= chipmem_start & (chipmem_size-1);
                    140:     addr &= chipmem_size-1;
                    141:     if (!(addr & 1)) {
                    142:        chipmemory[addr>>1] = (chipmemory[addr>>1] & 0xff) | (((UWORD)b) << 8);
                    143:     } else {
                    144:        chipmemory[addr>>1] = (chipmemory[addr>>1] & 0xff00) | b;
                    145:     }
                    146: }
                    147: 
1.1.1.2 ! root      148: int chipmem_check(CPTR addr, ULONG size)
1.1       root      149: {
                    150:     addr -= chipmem_start & (chipmem_size-1);
                    151:     addr &= chipmem_size-1;
                    152:     return (addr + size) < chipmem_size;
                    153: }
                    154: 
                    155: UWORD *chipmem_xlate(CPTR addr)
                    156: {
                    157:     addr -= chipmem_start & (chipmem_size-1);
                    158:     addr &= chipmem_size-1;
                    159:     return chipmemory + (addr >> 1);
                    160: }
                    161: 
                    162: /* Slow memory */
                    163: 
1.1.1.2 ! root      164: static UWORD *bogomemory;
1.1       root      165: 
                    166: static ULONG bogomem_lget(CPTR) REGPARAM;
                    167: static UWORD bogomem_wget(CPTR) REGPARAM;
                    168: static UBYTE bogomem_bget(CPTR) REGPARAM;
                    169: static void  bogomem_lput(CPTR, ULONG) REGPARAM;
                    170: static void  bogomem_wput(CPTR, UWORD) REGPARAM;
                    171: static void  bogomem_bput(CPTR, UBYTE) REGPARAM;
1.1.1.2 ! root      172: static int  bogomem_check(CPTR addr, ULONG size) REGPARAM;
1.1       root      173: static UWORD *bogomem_xlate(CPTR addr) REGPARAM;
                    174: 
                    175: ULONG bogomem_lget(CPTR addr)
                    176: {
                    177:     addr -= bogomem_start & (bogomem_size-1);
                    178:     addr &= bogomem_size-1;
                    179:     return ((ULONG)bogomemory[addr >> 1] << 16) | bogomemory[(addr >> 1)+1];
                    180: }
                    181: 
                    182: UWORD bogomem_wget(CPTR addr)
                    183: {
                    184:     addr -= bogomem_start & (bogomem_size-1);
                    185:     addr &= bogomem_size-1;
                    186:     return bogomemory[addr >> 1];
                    187: }
                    188: 
                    189: UBYTE bogomem_bget(CPTR addr)
                    190: {
                    191:     addr -= bogomem_start & (bogomem_size-1);
                    192:     addr &= bogomem_size-1;
1.1.1.2 ! root      193:     if (addr & 1)
        !           194:        return bogomemory[addr >> 1];
        !           195:     else
        !           196:        return bogomemory[addr >> 1] >> 8;
1.1       root      197: }
                    198: 
                    199: void bogomem_lput(CPTR addr, ULONG l)
                    200: {
                    201:     addr -= bogomem_start & (bogomem_size-1);
                    202:     addr &= bogomem_size-1;
                    203:     bogomemory[addr >> 1] = l >> 16;
                    204:     bogomemory[(addr >> 1)+1] = (UWORD)l;
                    205: }
                    206: 
                    207: void bogomem_wput(CPTR addr, UWORD w)
                    208: {
                    209:     addr -= bogomem_start & (bogomem_size-1);
                    210:     addr &= bogomem_size-1;
                    211:     bogomemory[addr >> 1] = w;
                    212: }
                    213: 
                    214: void bogomem_bput(CPTR addr, UBYTE b)
                    215: {
                    216:     addr -= bogomem_start & (bogomem_size-1);
                    217:     addr &= bogomem_size-1;
                    218:     if (!(addr & 1)) {
                    219:        bogomemory[addr>>1] = (bogomemory[addr>>1] & 0xff) | (((UWORD)b) << 8);
                    220:     } else {
                    221:        bogomemory[addr>>1] = (bogomemory[addr>>1] & 0xff00) | b;
                    222:     }
                    223: }
                    224: 
1.1.1.2 ! root      225: int bogomem_check(CPTR addr, ULONG size)
1.1       root      226: {
                    227:     addr -= bogomem_start & (bogomem_size-1);
                    228:     addr &= bogomem_size-1;
                    229:     return (addr + size) < bogomem_size;
                    230: }
                    231: 
                    232: UWORD *bogomem_xlate(CPTR addr)
                    233: {
                    234:     addr -= bogomem_start & (bogomem_size-1);
                    235:     addr &= bogomem_size-1;
                    236:     return bogomemory + (addr >> 1);
                    237: }
                    238: 
                    239: /* Kick memory */
                    240: 
1.1.1.2 ! root      241: static int zkickfile = 0;
1.1       root      242: static UWORD kickmemory[kickmem_size/2];
                    243: 
                    244: static ULONG kickmem_lget(CPTR) REGPARAM;
                    245: static UWORD kickmem_wget(CPTR) REGPARAM;
                    246: static UBYTE kickmem_bget(CPTR) REGPARAM;
                    247: static void  kickmem_lput(CPTR, ULONG) REGPARAM;
                    248: static void  kickmem_wput(CPTR, UWORD) REGPARAM;
                    249: static void  kickmem_bput(CPTR, UBYTE) REGPARAM;
1.1.1.2 ! root      250: static int  kickmem_check(CPTR addr, ULONG size) REGPARAM;
1.1       root      251: static UWORD *kickmem_xlate(CPTR addr) REGPARAM;
                    252: 
                    253: ULONG kickmem_lget(CPTR addr)
                    254: {
                    255:     addr -= kickmem_start & (kickmem_size-1);
                    256:     addr &= kickmem_size-1;
                    257:     return ((ULONG)kickmemory[addr >> 1] << 16) | kickmemory[(addr >> 1)+1];
                    258: }
                    259: 
                    260: UWORD kickmem_wget(CPTR addr)
                    261: {
                    262:     addr -= kickmem_start & (kickmem_size-1);
                    263:     addr &= kickmem_size-1;
                    264:     return kickmemory[addr >> 1];
                    265: }
                    266: 
                    267: UBYTE kickmem_bget(CPTR addr)
                    268: {
                    269:     addr -= kickmem_start & (kickmem_size-1);
                    270:     addr &= kickmem_size-1;
                    271:     return kickmemory[addr >> 1] >> (addr & 1 ? 0 : 8);
                    272: }
                    273: 
                    274: void kickmem_lput(CPTR a, ULONG b)
                    275: {
                    276: }
                    277: 
                    278: void kickmem_wput(CPTR a, UWORD b)
                    279: {
                    280: }
                    281: 
                    282: void kickmem_bput(CPTR a, UBYTE b)
                    283: {
                    284: }
                    285: 
1.1.1.2 ! root      286: int kickmem_check(CPTR addr, ULONG size)
1.1       root      287: {
                    288:     addr -= kickmem_start & (kickmem_size-1);
                    289:     addr &= kickmem_size-1;
                    290:     return (addr + size) < kickmem_size;
                    291: }
                    292: 
                    293: UWORD *kickmem_xlate(CPTR addr)
                    294: {
                    295:     addr -= kickmem_start & (kickmem_size-1);
                    296:     addr &= kickmem_size-1;
                    297:     return kickmemory + (addr >> 1);
                    298: }
                    299: 
1.1.1.2 ! root      300: static int load_kickstart(void)
1.1       root      301: {
                    302:     int i;
                    303:     ULONG cksum = 0, prevck = 0;
1.1.1.2 ! root      304:     unsigned char buffer[8];
1.1       root      305:     
                    306:     FILE *f = fopen(romfile, "rb");
                    307:     
                    308:     if (f == NULL) {   
                    309:        fprintf(stderr, "No Kickstart ROM found.\n");
1.1.1.2 ! root      310:        return 0;
1.1       root      311:     }
                    312:     
1.1.1.2 ! root      313:     fread(buffer, 1, 8, f);
        !           314:     if (buffer[4] == 0 && buffer[5] == 8 && buffer[6] == 0 && buffer[7] == 0) {
        !           315:        fprintf(stderr, "You seem to have a ZKick file there... You probably lose.\n");
        !           316:        zkickfile = 1;
        !           317:     } else 
        !           318:        fseek(f, 0, SEEK_SET);
        !           319:     
        !           320:     i = fread(kickmemory, 1, kickmem_size, f);
        !           321:     if (i == kickmem_size/2) {
        !           322:        fprintf(stderr, "Warning: Kickstart is only 256K.\n");
        !           323:        memcpy (kickmemory + kickmem_size/4, kickmemory, kickmem_size/2);
        !           324:     } else if (i != kickmem_size) {
        !           325:        fprintf(stderr, "Error while reading Kickstart.\n");
        !           326:        return 0;
1.1       root      327:     }
                    328:     fclose (f);
                    329:     
1.1.1.2 ! root      330:     for (i = 0; i < kickmem_size/2; i++) {
        !           331:        UWORD *p = kickmemory + i;
        !           332:        UBYTE *bp = (UBYTE *)p;
        !           333:        *p = (*bp << 8) | *(bp+1);
        !           334:     }
        !           335: 
1.1       root      336:     for (i = 0; i < kickmem_size/4; i++) {
                    337:        ULONG data = kickmemory[i*2]*65536 + kickmemory[i*2+1];
                    338:        cksum += data;
                    339:        if (cksum < prevck)
                    340:            cksum++;
                    341:        prevck = cksum;
                    342:     }
                    343:     if (cksum != 0xFFFFFFFF) {
                    344:        fprintf(stderr, "Warning: Kickstart checksum incorrect. You probably have a corrupted ROM image.\n");
                    345:     }
1.1.1.2 ! root      346:     return 1;
1.1       root      347: }
                    348: 
                    349: /* Address banks */
                    350: 
1.1.1.2 ! root      351: addrbank dummy_bank = {
        !           352:     dummy_lget, dummy_wget, dummy_bget,
        !           353:     dummy_lput, dummy_wput, dummy_bput,
        !           354:     dummy_xlate, dummy_check
        !           355: };
        !           356: 
1.1       root      357: addrbank chipmem_bank = {
                    358:     chipmem_lget, chipmem_wget, chipmem_bget,
                    359:     chipmem_lput, chipmem_wput, chipmem_bput,
                    360:     chipmem_xlate, chipmem_check
                    361: };
                    362: 
                    363: addrbank bogomem_bank = {
                    364:     bogomem_lget, bogomem_wget, bogomem_bget,
                    365:     bogomem_lput, bogomem_wput, bogomem_bput,
                    366:     bogomem_xlate, bogomem_check
                    367: };
                    368: 
                    369: addrbank kickmem_bank = {
                    370:     kickmem_lget, kickmem_wget, kickmem_bget,
                    371:     kickmem_lput, kickmem_wput, kickmem_bput,
                    372:     kickmem_xlate, kickmem_check
                    373: };
                    374: 
                    375: void memory_init(void)
                    376: {
1.1.1.2 ! root      377:     int i;
        !           378:     buserr = 0;
        !           379: 
        !           380:     memset(chipmemory, 0, sizeof chipmemory);
1.1       root      381:     
1.1.1.2 ! root      382:     for(i = 0; i < 65536; i++)
        !           383:        membanks[i] = dummy_bank;
        !           384:     
        !           385:     /* Map the chipmem into all of the lower 16MB */
        !           386:     map_banks(chipmem_bank, 0x00, 256);
        !           387:     map_banks(custom_bank, 0xC0, 0x20);
        !           388:     map_banks(cia_bank, 0xA0, 32);
        !           389:     map_banks(clock_bank, 0xDC, 1);
1.1       root      390:     
                    391:     if (use_slow_mem && bogomem_size > 0) {
1.1.1.2 ! root      392:        bogomemory = (UWORD *)malloc (bogomem_size);
1.1       root      393:        map_banks(bogomem_bank, 0xC0, bogomem_size >> 16);
                    394:     }
                    395: 
1.1.1.2 ! root      396:     map_banks(rtarea_bank, 0xF0, 1); 
        !           397:     rtarea_init ();
1.1       root      398:     if (!load_kickstart()) {
                    399:        init_ersatz_rom(kickmemory);
1.1.1.2 ! root      400:        ersatzkickfile = 1;
1.1       root      401:     }
1.1.1.2 ! root      402:     if (zkickfile)
        !           403:        map_banks(kickmem_bank, 0x20, 8);
        !           404:     
        !           405:     map_banks(kickmem_bank, 0xF8, 8);
        !           406:     if (!zkickfile)
        !           407:        map_banks(expamem_bank, 0xE8, 1);
1.1       root      408: }
                    409: 
                    410: void map_banks(addrbank bank, int start, int size)
                    411: {
                    412:     int bnr;
1.1.1.2 ! root      413:     int hioffs = 0;
        !           414: #if CPU_LEVEL < 2
        !           415:     for (hioffs = 0; hioffs < 256; hioffs++)
        !           416: #endif
        !           417:        for (bnr = start; bnr < start+size; bnr++) 
        !           418:            membanks[bnr + hioffs * 256] = bank;
1.1       root      419: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.