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