![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpummu030.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src / cpu|
Return to cpummu030.h CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / cpu |
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.