1 /*** m6800: Portable 6800 class emulator *************************************/
2 
3 #ifndef _M6800_H
4 #define _M6800_H
5 
6 #include "osd_cpu.h"
7 #include "memory.h"
8 #include "cpuintrf.h"
9 
10 enum {
11 	M6800_PC=1, M6800_S, M6800_A, M6800_B, M6800_X, M6800_CC,
12 	M6800_WAI_STATE, M6800_NMI_STATE, M6800_IRQ_STATE };
13 
14 #define M6800_INT_NONE  0           /* No interrupt required */
15 #define M6800_INT_IRQ	1			/* Standard IRQ interrupt */
16 #define M6800_INT_NMI	2			/* NMI interrupt		  */
17 #define M6800_WAI		8			/* set when WAI is waiting for an interrupt */
18 #define M6800_SLP		0x10		/* HD63701 only */
19 
20 
21 #define M6800_IRQ_LINE	0			/* IRQ line number */
22 #define M6800_TIN_LINE	1			/* P20/Tin Input Capture line (eddge sense)     */
23 									/* Active eddge is selecrable by internal reg.  */
24 									/* raise eddge : CLEAR_LINE  -> ASSERT_LINE     */
25 									/* fall  eddge : ASSERT_LINE -> CLEAR_LINE      */
26 									/* it is usuali to use PULSE_LINE state         */
27 /* PUBLIC GLOBALS */
28 extern int m6800_ICount;
29 
30 /* PUBLIC FUNCTIONS */
31 void m6800_reset(void *param);
32 void m6800_exit(void);
33 int	m6800_execute(int cycles);
34 unsigned m6800_get_context(void *dst);
35 void m6800_set_context(void *src);
36 unsigned m6800_get_pc(void);
37 void m6800_set_pc(unsigned val);
38 unsigned m6800_get_sp(void);
39 void m6800_set_sp(unsigned val);
40 unsigned m6800_get_reg(int regnum);
41 void m6800_set_reg(int regnum, unsigned val);
42 void m6800_set_nmi_line(int state);
43 void m6800_set_irq_line(int irqline, int state);
44 void m6800_set_irq_callback(int (*callback)(int irqline));
45 void m6800_state_save(void *file);
46 void m6800_state_load(void *file);
47 const char *m6800_info(void *context, int regnum);
48 unsigned m6800_dasm(char *buffer, unsigned pc);
49 
50 /****************************************************************************
51  * For now make the 6801 using the m6800 variables and functions
52  ****************************************************************************/
53 #if (HAS_M6801)
54 #define M6801_A 					M6800_A
55 #define M6801_B 					M6800_B
56 #define M6801_PC					M6800_PC
57 #define M6801_S 					M6800_S
58 #define M6801_X 					M6800_X
59 #define M6801_CC					M6800_CC
60 #define M6801_WAI_STATE 			M6800_WAI_STATE
61 #define M6801_NMI_STATE 			M6800_NMI_STATE
62 #define M6801_IRQ_STATE 			M6800_IRQ_STATE
63 
64 #define M6801_INT_NONE              M6800_INT_NONE
65 #define M6801_INT_IRQ				M6800_INT_IRQ
66 #define M6801_INT_NMI				M6800_INT_NMI
67 #define M6801_WAI					M6800_WAI
68 #define M6801_IRQ_LINE				M6800_IRQ_LINE
69 
70 #define m6801_ICount				m6800_ICount
71 void m6801_reset(void *param);
72 void m6801_exit(void);
73 int	m6801_execute(int cycles);
74 unsigned m6801_get_context(void *dst);
75 void m6801_set_context(void *src);
76 unsigned m6801_get_pc(void);
77 void m6801_set_pc(unsigned val);
78 unsigned m6801_get_sp(void);
79 void m6801_set_sp(unsigned val);
80 unsigned m6801_get_reg(int regnum);
81 void m6801_set_reg(int regnum, unsigned val);
82 void m6801_set_nmi_line(int state);
83 void m6801_set_irq_line(int irqline, int state);
84 void m6801_set_irq_callback(int (*callback)(int irqline));
85 void m6801_state_save(void *file);
86 void m6801_state_load(void *file);
87 const char *m6801_info(void *context, int regnum);
88 unsigned m6801_dasm(char *buffer, unsigned pc);
89 #endif
90 
91 /****************************************************************************
92  * For now make the 6802 using the m6800 variables and functions
93  ****************************************************************************/
94 #if (HAS_M6802)
95 #define M6802_A 					M6800_A
96 #define M6802_B 					M6800_B
97 #define M6802_PC					M6800_PC
98 #define M6802_S 					M6800_S
99 #define M6802_X 					M6800_X
100 #define M6802_CC					M6800_CC
101 #define M6802_WAI_STATE 			M6800_WAI_STATE
102 #define M6802_NMI_STATE 			M6800_NMI_STATE
103 #define M6802_IRQ_STATE 			M6800_IRQ_STATE
104 
105 #define M6802_INT_NONE              M6800_INT_NONE
106 #define M6802_INT_IRQ				M6800_INT_IRQ
107 #define M6802_INT_NMI				M6800_INT_NMI
108 #define M6802_WAI					M6800_WAI
109 #define M6802_IRQ_LINE				M6800_IRQ_LINE
110 
111 #define m6802_ICount				m6800_ICount
112 void m6802_reset(void *param);
113 void m6802_exit(void);
114 int	m6802_execute(int cycles);
115 unsigned m6802_get_context(void *dst);
116 void m6802_set_context(void *src);
117 unsigned m6802_get_pc(void);
118 void m6802_set_pc(unsigned val);
119 unsigned m6802_get_sp(void);
120 void m6802_set_sp(unsigned val);
121 unsigned m6802_get_reg(int regnum);
122 void m6802_set_reg(int regnum, unsigned val);
123 void m6802_set_nmi_line(int state);
124 void m6802_set_irq_line(int irqline, int state);
125 void m6802_set_irq_callback(int (*callback)(int irqline));
126 void m6802_state_save(void *file);
127 void m6802_state_load(void *file);
128 const char *m6802_info(void *context, int regnum);
129 unsigned m6802_dasm(char *buffer, unsigned pc);
130 #endif
131 
132 /****************************************************************************
133  * For now make the 6803 using the m6800 variables and functions
134  ****************************************************************************/
135 #if (HAS_M6803)
136 #define M6803_A 					M6800_A
137 #define M6803_B 					M6800_B
138 #define M6803_PC					M6800_PC
139 #define M6803_S 					M6800_S
140 #define M6803_X 					M6800_X
141 #define M6803_CC					M6800_CC
142 #define M6803_WAI_STATE 			M6800_WAI_STATE
143 #define M6803_NMI_STATE 			M6800_NMI_STATE
144 #define M6803_IRQ_STATE 			M6800_IRQ_STATE
145 
146 #define M6803_INT_NONE              M6800_INT_NONE
147 #define M6803_INT_IRQ				M6800_INT_IRQ
148 #define M6803_INT_NMI				M6800_INT_NMI
149 #define M6803_WAI					M6800_WAI
150 #define M6803_IRQ_LINE				M6800_IRQ_LINE
151 #define M6803_TIN_LINE				M6800_TIN_LINE
152 
153 #define m6803_ICount				m6800_ICount
154 void m6803_reset(void *param);
155 void m6803_exit(void);
156 int	m6803_execute(int cycles);
157 unsigned m6803_get_context(void *dst);
158 void m6803_set_context(void *src);
159 unsigned m6803_get_pc(void);
160 void m6803_set_pc(unsigned val);
161 unsigned m6803_get_sp(void);
162 void m6803_set_sp(unsigned val);
163 unsigned m6803_get_reg(int regnum);
164 void m6803_set_reg(int regnum, unsigned val);
165 void m6803_set_nmi_line(int state);
166 void m6803_set_irq_line(int irqline, int state);
167 void m6803_set_irq_callback(int (*callback)(int irqline));
168 void m6803_state_save(void *file);
169 void m6803_state_load(void *file);
170 const char *m6803_info(void *context, int regnum);
171 unsigned m6803_dasm(char *buffer, unsigned pc);
172 #endif
173 
174 #if (HAS_M6803||HAS_HD63701)
175 /* By default, on a port write port bits which are not set as output in the DDR */
176 /* are set to the value returned by a read from the same port. If you need to */
177 /* know the DDR for e.g. port 1, do m6803_internal_registers_r(M6801_DDR1) */
178 
179 #define M6803_DDR1	0x00
180 #define M6803_DDR2	0x01
181 
182 #define M6803_PORT1 0x100
183 #define M6803_PORT2 0x101
184 READ_HANDLER( m6803_internal_registers_r );
185 WRITE_HANDLER( m6803_internal_registers_w );
186 #endif
187 
188 /****************************************************************************
189  * For now make the 6808 using the m6800 variables and functions
190  ****************************************************************************/
191 #if (HAS_M6808)
192 #define M6808_A 					M6800_A
193 #define M6808_B 					M6800_B
194 #define M6808_PC					M6800_PC
195 #define M6808_S 					M6800_S
196 #define M6808_X 					M6800_X
197 #define M6808_CC					M6800_CC
198 #define M6808_WAI_STATE 			M6800_WAI_STATE
199 #define M6808_NMI_STATE 			M6800_NMI_STATE
200 #define M6808_IRQ_STATE 			M6800_IRQ_STATE
201 
202 #define M6808_INT_NONE              M6800_INT_NONE
203 #define M6808_INT_IRQ               M6800_INT_IRQ
204 #define M6808_INT_NMI               M6800_INT_NMI
205 #define M6808_WAI                   M6800_WAI
206 #define M6808_IRQ_LINE              M6800_IRQ_LINE
207 
208 #define m6808_ICount                m6800_ICount
209 void m6808_reset(void *param);
210 void m6808_exit(void);
211 int	m6808_execute(int cycles);
212 unsigned m6808_get_context(void *dst);
213 void m6808_set_context(void *src);
214 unsigned m6808_get_pc(void);
215 void m6808_set_pc(unsigned val);
216 unsigned m6808_get_sp(void);
217 void m6808_set_sp(unsigned val);
218 unsigned m6808_get_reg(int regnum);
219 void m6808_set_reg(int regnum, unsigned val);
220 void m6808_set_nmi_line(int state);
221 void m6808_set_irq_line(int irqline, int state);
222 void m6808_set_irq_callback(int (*callback)(int irqline));
223 void m6808_state_save(void *file);
224 void m6808_state_load(void *file);
225 const char *m6808_info(void *context, int regnum);
226 unsigned m6808_dasm(char *buffer, unsigned pc);
227 #endif
228 
229 /****************************************************************************
230  * For now make the HD63701 using the m6800 variables and functions
231  ****************************************************************************/
232 #if (HAS_HD63701)
233 #define HD63701_A					 M6800_A
234 #define HD63701_B					 M6800_B
235 #define HD63701_PC					 M6800_PC
236 #define HD63701_S					 M6800_S
237 #define HD63701_X					 M6800_X
238 #define HD63701_CC					 M6800_CC
239 #define HD63701_WAI_STATE			 M6800_WAI_STATE
240 #define HD63701_NMI_STATE			 M6800_NMI_STATE
241 #define HD63701_IRQ_STATE			 M6800_IRQ_STATE
242 
243 #define HD63701_INT_NONE             M6800_INT_NONE
244 #define HD63701_INT_IRQ 			 M6800_INT_IRQ
245 #define HD63701_INT_NMI 			 M6800_INT_NMI
246 #define HD63701_WAI 				 M6800_WAI
247 #define HD63701_SLP 				 M6800_SLP
248 #define HD63701_IRQ_LINE			 M6800_IRQ_LINE
249 #define HD63701_TIN_LINE			 M6800_TIN_LINE
250 
251 #define hd63701_ICount				 m6800_ICount
252 void hd63701_reset(void *param);
253 void hd63701_exit(void);
254 int	hd63701_execute(int cycles);
255 unsigned hd63701_get_context(void *dst);
256 void hd63701_set_context(void *src);
257 unsigned hd63701_get_pc(void);
258 void hd63701_set_pc(unsigned val);
259 unsigned hd63701_get_sp(void);
260 void hd63701_set_sp(unsigned val);
261 unsigned hd63701_get_reg(int regnum);
262 void hd63701_set_reg(int regnum, unsigned val);
263 void hd63701_set_nmi_line(int state);
264 void hd63701_set_irq_line(int irqline, int state);
265 void hd63701_set_irq_callback(int (*callback)(int irqline));
266 void hd63701_state_save(void *file);
267 void hd63701_state_load(void *file);
268 const char *hd63701_info(void *context, int regnum);
269 unsigned hd63701_dasm(char *buffer, unsigned pc);
270 
271 void hd63701_trap_pc(void);
272 
273 #define HD63701_DDR1 M6803_DDR1
274 #define HD63701_DDR2 M6803_DDR2
275 
276 #define HD63701_PORT1 M6803_PORT1
277 #define HD63701_PORT2 M6803_PORT2
278 
279 READ_HANDLER( hd63701_internal_registers_r );
280 WRITE_HANDLER( hd63701_internal_registers_w );
281 
282 #endif
283 
284 /****************************************************************************
285  * For now make the NSC8105 using the m6800 variables and functions
286  ****************************************************************************/
287 #if (HAS_NSC8105)
288 #define NSC8105_A					 M6800_A
289 #define NSC8105_B					 M6800_B
290 #define NSC8105_PC					 M6800_PC
291 #define NSC8105_S					 M6800_S
292 #define NSC8105_X					 M6800_X
293 #define NSC8105_CC					 M6800_CC
294 #define NSC8105_WAI_STATE			 M6800_WAI_STATE
295 #define NSC8105_NMI_STATE			 M6800_NMI_STATE
296 #define NSC8105_IRQ_STATE			 M6800_IRQ_STATE
297 
298 #define NSC8105_INT_NONE             M6800_INT_NONE
299 #define NSC8105_INT_IRQ 			 M6800_INT_IRQ
300 #define NSC8105_INT_NMI 			 M6800_INT_NMI
301 #define NSC8105_WAI 				 M6800_WAI
302 #define NSC8105_IRQ_LINE			 M6800_IRQ_LINE
303 #define NSC8105_TIN_LINE			 M6800_TIN_LINE
304 
305 #define nsc8105_ICount				 m6800_ICount
306 void nsc8105_reset(void *param);
307 void nsc8105_exit(void);
308 int	nsc8105_execute(int cycles);
309 unsigned nsc8105_get_context(void *dst);
310 void nsc8105_set_context(void *src);
311 unsigned nsc8105_get_pc(void);
312 void nsc8105_set_pc(unsigned val);
313 unsigned nsc8105_get_sp(void);
314 void nsc8105_set_sp(unsigned val);
315 unsigned nsc8105_get_reg(int regnum);
316 void nsc8105_set_reg(int regnum, unsigned val);
317 void nsc8105_set_nmi_line(int state);
318 void nsc8105_set_irq_line(int irqline, int state);
319 void nsc8105_set_irq_callback(int (*callback)(int irqline));
320 void nsc8105_state_save(void *file);
321 void nsc8105_state_load(void *file);
322 const char *nsc8105_info(void *context, int regnum);
323 unsigned nsc8105_dasm(char *buffer, unsigned pc);
324 #endif
325 
326 /****************************************************************************/
327 /* Read a byte from given memory location									*/
328 /****************************************************************************/
329 /* ASG 971005 -- changed to cpu_readmem16/cpu_writemem16 */
330 #define M6800_RDMEM(Addr) ((unsigned)cpu_readmem16(Addr))
331 
332 /****************************************************************************/
333 /* Write a byte to given memory location                                    */
334 /****************************************************************************/
335 #define M6800_WRMEM(Addr,Value) (cpu_writemem16(Addr,Value))
336 
337 /****************************************************************************/
338 /* M6800_RDOP() is identical to M6800_RDMEM() except it is used for reading */
339 /* opcodes. In case of system with memory mapped I/O, this function can be  */
340 /* used to greatly speed up emulation                                       */
341 /****************************************************************************/
342 #define M6800_RDOP(Addr) ((unsigned)cpu_readop(Addr))
343 
344 /****************************************************************************/
345 /* M6800_RDOP_ARG() is identical to M6800_RDOP() but it's used for reading  */
346 /* opcode arguments. This difference can be used to support systems that    */
347 /* use different encoding mechanisms for opcodes and opcode arguments       */
348 /****************************************************************************/
349 #define M6800_RDOP_ARG(Addr) ((unsigned)cpu_readop_arg(Addr))
350 
351 #ifndef FALSE
352 #    define FALSE 0
353 #endif
354 #ifndef TRUE
355 #    define TRUE (!FALSE)
356 #endif
357 
358 #endif /* _M6800_H */
359