Return to cpummu030.h CVS log

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

Annotation of previous/src/cpu/cpummu030.h, revision 1.1

1.1     ! root        1: #ifndef CPUMMU030_H
        !             2: #define CPUMMU030_H
        !             3: 
        !             4: #include "mmu_common.h"
        !             5: 
        !             6: void mmu_op30_pmove (uaecptr pc, uae_u32 opcode, uae_u16 next, uaecptr extra);
        !             7: void mmu_op30_ptest (uaecptr pc, uae_u32 opcode, uae_u16 next, uaecptr extra);
        !             8: void mmu_op30_pload (uaecptr pc, uae_u32 opcode, uae_u16 next, uaecptr extra);
        !             9: void mmu_op30_pflush (uaecptr pc, uae_u32 opcode, uae_u16 next, uaecptr extra);
        !            10: 
        !            11: uae_u32 mmu_op30_helper_get_fc(uae_u16 next);
        !            12: 
        !            13: void mmu030_ptest_atc_search(uaecptr logical_addr, uae_u32 fc, bool write);
        !            14: uae_u32 mmu030_ptest_table_search(uaecptr extra, uae_u32 fc, bool write, int level);
        !            15: uae_u32 mmu030_table_search(uaecptr addr, uae_u32 fc, bool write, int level);
        !            16: 
        !            17: 
        !            18: typedef struct {
        !            19:     uae_u32 addr_base;
        !            20:     uae_u32 addr_mask;
        !            21:     uae_u32 fc_base;
        !            22:     uae_u32 fc_mask;
        !            23: } TT_info;
        !            24: 
        !            25: TT_info mmu030_decode_tt(uae_u32 TT);
        !            26: void mmu030_decode_tc(uae_u32 TC);
        !            27: void mmu030_decode_rp(uae_u64 RP);
        !            28: 
        !            29: int mmu030_logical_is_in_atc(uaecptr addr, uae_u32 fc, bool write);
        !            30: void mmu030_atc_handle_history_bit(int entry_num);
        !            31: 
        !            32: void mmu030_put_long_atc(uaecptr addr, uae_u32 val, int l);
        !            33: void mmu030_put_word_atc(uaecptr addr, uae_u16 val, int l);
        !            34: void mmu030_put_byte_atc(uaecptr addr, uae_u8 val, int l);
        !            35: uae_u32 mmu030_get_long_atc(uaecptr addr, int l);
        !            36: uae_u16 mmu030_get_word_atc(uaecptr addr, int l);
        !            37: uae_u8 mmu030_get_byte_atc(uaecptr addr, int l);
        !            38: 
        !            39: void mmu030_flush_atc_fc(uae_u32 fc_base, uae_u32 fc_mask);
        !            40: void mmu030_flush_atc_page(uaecptr logical_addr);
        !            41: void mmu030_flush_atc_page_fc(uaecptr logical_addr, uae_u32 fc_base, uae_u32 fc_mask);
        !            42: void mmu030_flush_atc_all(void);
        !            43: void mmu030_reset(int hardreset);
        !            44: 
        !            45: int mmu030_match_ttr(uaecptr addr, uae_u32 fc, bool write);
        !            46: int mmu030_do_match_ttr(uae_u32 tt, TT_info masks, uaecptr addr, uae_u32 fc, bool write);
        !            47: 
        !            48: void mmu030_put_long(uaecptr addr, uae_u32 val, uae_u32 fc, int size);
        !            49: void mmu030_put_word(uaecptr addr, uae_u16 val, uae_u32 fc, int size);
        !            50: void mmu030_put_byte(uaecptr addr, uae_u8  val, uae_u32 fc, int size);
        !            51: uae_u32 mmu030_get_long(uaecptr addr, uae_u32 fc, int size);
        !            52: uae_u16 mmu030_get_word(uaecptr addr, uae_u32 fc, int size);
        !            53: uae_u8  mmu030_get_byte(uaecptr addr, uae_u32 fc, int size);
        !            54: 
        !            55: void mmu030_page_fault(uaecptr addr, bool read);
        !            56: 
        !            57: extern uae_u16 REGPARAM3 mmu030_get_word_unaligned(uaecptr addr, uae_u32 fc) REGPARAM;
        !            58: extern uae_u32 REGPARAM3 mmu030_get_long_unaligned(uaecptr addr, uae_u32 fc) REGPARAM;
        !            59: extern void REGPARAM3 mmu030_put_word_unaligned(uaecptr addr, uae_u16 val, uae_u32 fc) REGPARAM;
        !            60: extern void REGPARAM3 mmu030_put_long_unaligned(uaecptr addr, uae_u32 val, uae_u32 fc) REGPARAM;
        !            61: 
        !            62: static ALWAYS_INLINE uae_u32 uae_mmu030_get_ilong(uaecptr addr)
        !            63: {
        !            64:     uae_u32 fc = (regs.s ? 4 : 0) | 2;
        !            65: 
        !            66:        if (unlikely(is_unaligned(addr, 4)))
        !            67:                return mmu030_get_long_unaligned(addr, fc);
        !            68:        return mmu030_get_long(addr, fc, sz_long);
        !            69: }
        !            70: static ALWAYS_INLINE uae_u16 uae_mmu030_get_iword(uaecptr addr)
        !            71: {
        !            72:     uae_u32 fc = (regs.s ? 4 : 0) | 2;
        !            73: 
        !            74:        if (unlikely(is_unaligned(addr, 2)))
        !            75:                return mmu030_get_word_unaligned(addr, fc);
        !            76:        return mmu030_get_word(addr, fc, sz_word);
        !            77: }
        !            78: static ALWAYS_INLINE uae_u16 uae_mmu030_get_ibyte(uaecptr addr)
        !            79: {
        !            80:     uae_u32 fc = (regs.s ? 4 : 0) | 2;
        !            81: 
        !            82:        return mmu030_get_byte(addr, fc, sz_byte);
        !            83: }
        !            84: static ALWAYS_INLINE uae_u32 uae_mmu030_get_long(uaecptr addr)
        !            85: {
        !            86:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
        !            87: 
        !            88:        if (unlikely(is_unaligned(addr, 4)))
        !            89:                return mmu030_get_long_unaligned(addr, fc);
        !            90:        return mmu030_get_long(addr, fc, sz_long);
        !            91: }
        !            92: static ALWAYS_INLINE uae_u16 uae_mmu030_get_word(uaecptr addr)
        !            93: {
        !            94:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
        !            95: 
        !            96:        if (unlikely(is_unaligned(addr, 2)))
        !            97:                return mmu030_get_word_unaligned(addr, fc);
        !            98:        return mmu030_get_word(addr, fc, sz_word);
        !            99: }
        !           100: static ALWAYS_INLINE uae_u8 uae_mmu030_get_byte(uaecptr addr)
        !           101: {
        !           102:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
        !           103: 
        !           104:        return mmu030_get_byte(addr, fc, sz_byte);
        !           105: }
        !           106: static ALWAYS_INLINE void uae_mmu030_put_long(uaecptr addr, uae_u32 val)
        !           107: {
        !           108:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
        !           109:     
        !           110:        if (unlikely(is_unaligned(addr, 4)))
        !           111:                mmu030_put_long_unaligned(addr, val, fc);
        !           112:        else
        !           113:                mmu030_put_long(addr, val, fc, sz_long);
        !           114: }
        !           115: static ALWAYS_INLINE void uae_mmu030_put_word(uaecptr addr, uae_u16 val)
        !           116: {
        !           117:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
        !           118: 
        !           119:        if (unlikely(is_unaligned(addr, 2)))
        !           120:                mmu030_put_word_unaligned(addr, val, fc);
        !           121:        else
        !           122:                mmu030_put_word(addr, val, fc, sz_word);
        !           123: }
        !           124: static ALWAYS_INLINE void uae_mmu030_put_byte(uaecptr addr, uae_u8 val)
        !           125: {
        !           126:     uae_u32 fc = (regs.s ? 4 : 0) | 1;
        !           127: 
        !           128:        mmu030_put_byte(addr, val, fc, sz_byte);
        !           129: }
        !           130: 
        !           131: static ALWAYS_INLINE uae_u32 sfc030_get_long(uaecptr addr)
        !           132: {
        !           133:     uae_u32 fc = regs.sfc&7;
        !           134:        printf("sfc030_get_long: FC = %i\n",fc);
        !           135:     if (unlikely(is_unaligned(addr, 4)))
        !           136:                return mmu030_get_long_unaligned(addr, fc);
        !           137:        return mmu030_get_long(addr, fc, sz_long);
        !           138: }
        !           139: 
        !           140: static ALWAYS_INLINE uae_u16 sfc030_get_word(uaecptr addr)
        !           141: {
        !           142:     uae_u32 fc = regs.sfc&7;
        !           143:        printf("sfc030_get_word: FC = %i\n",fc);
        !           144:     if (unlikely(is_unaligned(addr, 2)))
        !           145:                return mmu030_get_word_unaligned(addr, fc);
        !           146:        return mmu030_get_word(addr, fc, sz_word);
        !           147: }
        !           148: 
        !           149: static ALWAYS_INLINE uae_u8 sfc030_get_byte(uaecptr addr)
        !           150: {
        !           151:     uae_u32 fc = regs.sfc&7;
        !           152:        printf("sfc030_get_byte: FC = %i\n",fc);
        !           153:        return mmu030_get_byte(addr, fc, sz_byte);
        !           154: }
        !           155: 
        !           156: static ALWAYS_INLINE void dfc030_put_long(uaecptr addr, uae_u32 val)
        !           157: {
        !           158:     uae_u32 fc = regs.dfc&7;
        !           159:        printf("dfc030_put_long: FC = %i\n",fc);
        !           160:     if (unlikely(is_unaligned(addr, 4)))
        !           161:                mmu030_put_long_unaligned(addr, val, fc);
        !           162:        else
        !           163:                mmu030_put_long(addr, val, fc, sz_long);
        !           164: }
        !           165: 
        !           166: static ALWAYS_INLINE void dfc030_put_word(uaecptr addr, uae_u16 val)
        !           167: {
        !           168:     uae_u32 fc = regs.dfc&7;
        !           169:        printf("dfc030_put_word: FC = %i\n",fc);
        !           170:     if (unlikely(is_unaligned(addr, 2)))
        !           171:                mmu030_put_word_unaligned(addr, val, fc);
        !           172:        else
        !           173:                mmu030_put_word(addr, val, fc, sz_word);
        !           174: }
        !           175: 
        !           176: static ALWAYS_INLINE void dfc030_put_byte(uaecptr addr, uae_u8 val)
        !           177: {
        !           178:     uae_u32 fc = regs.dfc&7;
        !           179:        printf("dfc030_put_byte: FC = %i\n",fc);
        !           180:     mmu030_put_byte(addr, val, fc, sz_byte);
        !           181: }
        !           182: 
        !           183: STATIC_INLINE void put_byte_mmu030 (uaecptr addr, uae_u32 v)
        !           184: {
        !           185:     uae_mmu030_put_byte (addr, v);
        !           186: }
        !           187: STATIC_INLINE void put_word_mmu030 (uaecptr addr, uae_u32 v)
        !           188: {
        !           189:     uae_mmu030_put_word (addr, v);
        !           190: }
        !           191: STATIC_INLINE void put_long_mmu030 (uaecptr addr, uae_u32 v)
        !           192: {
        !           193:     uae_mmu030_put_long (addr, v);
        !           194: }
        !           195: STATIC_INLINE uae_u32 get_byte_mmu030 (uaecptr addr)
        !           196: {
        !           197:     return uae_mmu030_get_byte (addr);
        !           198: }
        !           199: STATIC_INLINE uae_u32 get_word_mmu030 (uaecptr addr)
        !           200: {
        !           201:     return uae_mmu030_get_word (addr);
        !           202: }
        !           203: STATIC_INLINE uae_u32 get_long_mmu030 (uaecptr addr)
        !           204: {
        !           205:     return uae_mmu030_get_long (addr);
        !           206: }
        !           207: STATIC_INLINE uae_u32 get_ibyte_mmu030 (int o)
        !           208: {
        !           209:     uae_u32 pc = m68k_getpc () + o;
        !           210:     return uae_mmu030_get_iword (pc);
        !           211: }
        !           212: STATIC_INLINE uae_u32 get_iword_mmu030 (int o)
        !           213: {
        !           214:     uae_u32 pc = m68k_getpc () + o;
        !           215:     return uae_mmu030_get_iword (pc);
        !           216: }
        !           217: STATIC_INLINE uae_u32 get_ilong_mmu030 (int o)
        !           218: {
        !           219:     uae_u32 pc = m68k_getpc () + o;
        !           220:     return uae_mmu030_get_ilong (pc);
        !           221: }
        !           222: STATIC_INLINE uae_u32 next_iword_mmu030 (void)
        !           223: {
        !           224:     uae_u32 pc = m68k_getpc ();
        !           225:     m68k_incpci (2);
        !           226:     return uae_mmu030_get_iword (pc);
        !           227: }
        !           228: STATIC_INLINE uae_u32 next_ilong_mmu030 (void)
        !           229: {
        !           230:     uae_u32 pc = m68k_getpc ();
        !           231:     m68k_incpci (4);
        !           232:     return uae_mmu030_get_ilong (pc);
        !           233: }
        !           234: 
        !           235: extern void m68k_do_rts_mmu030 (void);
        !           236: extern void m68k_do_rte_mmu030 (uaecptr a7);
        !           237: extern void flush_mmu030 (uaecptr, int);
        !           238: extern void m68k_do_bsr_mmu030 (uaecptr oldpc, uae_s32 offset);
        !           239: 
        !           240: #endif

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