![[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 [Previous NeXT emulator] / previous / src / cpu|
Return to cpummu030.h CVS log | Up to [Previous NeXT emulator] / previous / src / cpu |
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.