Return to memory.h CVS log

Up to [UNIX Amiga Emulator] / uae / include

Annotation of uae/include/memory.h, revision 1.1

1.1     ! root        1:  /* 
        !             2:   * UAE - The Un*x Amiga Emulator
        !             3:   * 
        !             4:   * memory management
        !             5:   * 
        !             6:   * (c) 1995 Bernd Schmidt
        !             7:   */
        !             8: 
        !             9: #ifdef DUALCPU
        !            10: extern bool allowmem;
        !            11: extern bool incpu;
        !            12: extern bool customacc;
        !            13: extern ULONG mempattern;
        !            14: extern int memlogptr;
        !            15: #endif
        !            16: 
        !            17: #define chipmem_size 0x200000
        !            18: #define fastmem_size 0
        !            19: #define bogomem_size 0x80000 /* C00000 crap mem */
        !            20: #define kickmem_size 0x80000
        !            21: 
        !            22: #define chipmem_start 0
        !            23: #define fastmem_start 0x200000
        !            24: #define bogomem_start 0xC00000 
        !            25: #define kickmem_start 0xF80000
        !            26: 
        !            27: typedef ULONG (*lget_func)(CPTR) REGPARAM;
        !            28: typedef UWORD (*wget_func)(CPTR) REGPARAM;
        !            29: typedef UBYTE (*bget_func)(CPTR) REGPARAM;
        !            30: typedef void (*lput_func)(CPTR,ULONG) REGPARAM;
        !            31: typedef void (*wput_func)(CPTR,UWORD) REGPARAM;
        !            32: typedef void (*bput_func)(CPTR,UBYTE) REGPARAM;
        !            33: typedef UWORD *(*xlate_func)(CPTR) REGPARAM;
        !            34: typedef bool (*check_func)(CPTR, ULONG) REGPARAM;
        !            35: 
        !            36: typedef struct {
        !            37:     lget_func lget;
        !            38:     wget_func wget;
        !            39:     bget_func bget;
        !            40:     lput_func lput;
        !            41:     wput_func wput;
        !            42:     bput_func bput;
        !            43:     xlate_func xlateaddr;
        !            44:     check_func check;
        !            45: } addrbank;
        !            46: 
        !            47: extern addrbank chipmem_bank;
        !            48: extern addrbank kickmem_bank;
        !            49: extern addrbank custom_bank;
        !            50: extern addrbank clock_bank;
        !            51: extern addrbank cia_bank;
        !            52: extern addrbank rtarea_bank;
        !            53: 
        !            54: extern void rtarea_init (void);
        !            55: 
        !            56: /* Default memory access functions */
        !            57: 
        !            58: extern bool default_check(CPTR addr, ULONG size) REGPARAM;
        !            59: extern UWORD *default_xlate(CPTR addr) REGPARAM;
        !            60: 
        !            61: extern lget_func do_lget[256];
        !            62: extern wget_func do_wget[256];
        !            63: extern bget_func do_bget[256];
        !            64: extern lput_func do_lput[256];
        !            65: extern wput_func do_wput[256];
        !            66: extern bput_func do_bput[256];
        !            67: extern xlate_func do_xlateaddr[256];
        !            68: extern check_func do_check[256];
        !            69: 
        !            70: static __inline__ int bankindex(CPTR a)
        !            71: {
        !            72: #ifdef HAVE_BROKEN_SOFTWARE
        !            73:     return (a>>16) & 0xFF;
        !            74: #else
        !            75:     return a>>16;
        !            76: #endif
        !            77: }
        !            78: 
        !            79: static __inline__ ULONG longget(CPTR addr)
        !            80: {
        !            81:     return do_lget[bankindex(addr)](addr);
        !            82: }
        !            83: static __inline__ UWORD wordget(CPTR addr)
        !            84: {
        !            85:     return do_wget[bankindex(addr)](addr);
        !            86: }
        !            87: static __inline__ UBYTE byteget(CPTR addr) 
        !            88: {
        !            89:     return do_bget[bankindex(addr)](addr);
        !            90: }
        !            91: static __inline__ void longput(CPTR addr, ULONG l)
        !            92: {
        !            93:     do_lput[bankindex(addr)](addr, l);
        !            94: }
        !            95: static __inline__ void wordput(CPTR addr, UWORD w)
        !            96: {
        !            97:     do_wput[bankindex(addr)](addr, w);
        !            98: }
        !            99: static __inline__ void byteput(CPTR addr, UBYTE b)
        !           100: {
        !           101:     do_bput[bankindex(addr)](addr, b);
        !           102: }
        !           103: 
        !           104: static __inline__ bool check_addr(CPTR a)
        !           105: {
        !           106: #ifdef NO_EXCEPTION_3
        !           107:     return true;
        !           108: #else
        !           109:     return (a & 1) == 0;
        !           110: #endif
        !           111: }
        !           112: extern bool buserr;
        !           113:     
        !           114: extern void memory_init(void);    
        !           115: extern void map_banks(addrbank bank, int first, int count);
        !           116:     
        !           117: #ifdef DUALCPU    
        !           118: extern ULONG get_long(CPTR addr);
        !           119: extern UWORD get_word(CPTR addr);
        !           120: extern UBYTE get_byte(CPTR addr);
        !           121: extern void put_long(CPTR a,ULONG l);
        !           122: extern void put_word(CPTR a,UWORD w);
        !           123: extern void put_byte(CPTR a,UBYTE b);
        !           124: #else
        !           125: static __inline__ ULONG get_long(CPTR addr) 
        !           126: {
        !           127:     if (check_addr(addr))
        !           128:        return longget(addr);
        !           129:     buserr = true;
        !           130:     return 0;
        !           131: }
        !           132: static __inline__ UWORD get_word(CPTR addr) 
        !           133: {
        !           134:     if (check_addr(addr))
        !           135:        return wordget(addr);
        !           136:     buserr = true;
        !           137:     return 0;
        !           138: }
        !           139: static __inline__ UBYTE get_byte(CPTR addr) 
        !           140: {
        !           141:     return byteget(addr); 
        !           142: }
        !           143: static __inline__ void put_long(CPTR addr, ULONG l) 
        !           144: {
        !           145:     if (!check_addr(addr))
        !           146:        buserr = true;
        !           147:     longput(addr, l);
        !           148: }
        !           149: static __inline__ void put_word(CPTR addr, UWORD w) 
        !           150: {
        !           151:     if (!check_addr(addr))
        !           152:        buserr = true;
        !           153:     wordput(addr, w);
        !           154: }
        !           155: static __inline__ void put_byte(CPTR addr, UBYTE b) 
        !           156: {
        !           157:     byteput(addr, b);
        !           158: }
        !           159: #endif
        !           160: 
        !           161: static __inline__ UWORD *get_real_address(CPTR addr)
        !           162: {
        !           163:     if (!check_addr(addr))
        !           164:        buserr = true;
        !           165:     return do_xlateaddr[bankindex(addr)](addr);
        !           166: }
        !           167: 
        !           168: static __inline__ bool valid_address(CPTR addr, ULONG size)
        !           169: {
        !           170:     if (!check_addr(addr))
        !           171:        buserr = true;
        !           172:     return do_check[bankindex(addr)](addr, size);
        !           173: }

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