Return to cpummu030.h CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src / cpu

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

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

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