source/src/vm/huc6280.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Origin : MESS 0.147
   5         Author : Takeda.Toshiya
   6         Date   : 2012.10.23-
   7
   8         [ HuC6280 ]
   9 */
  10
  11 #include "huc6280.h"
  12 #ifdef USE_DEBUGGER
  13 #include "debugger.h"
  14 #endif
  15
  16 /* ----------------------------------------------------------------------------
  17         MAME h6280
  18 ---------------------------------------------------------------------------- */
  19
  20 #define INLINE inline
  21 #define PAIR pair
  22 #define offs_t UINT16
  23
  24 /*****************************************************************************/
  25 /* src/emu/devcpu.h */
  26
  27 // CPU interface functions
  28 #define CPU_INIT_NAME(name)                     cpu_init_##name
  29 #define CPU_INIT(name)                          void* CPU_INIT_NAME(name)()
  30 #define CPU_INIT_CALL(name)                     CPU_INIT_NAME(name)()
  31
  32 #define CPU_RESET_NAME(name)                    cpu_reset_##name
  33 #define CPU_RESET(name)                         void CPU_RESET_NAME(name)(h6280_Regs *cpustate)
  34 #define CPU_RESET_CALL(name)                    CPU_RESET_NAME(name)(cpustate)
  35
  36 #define CPU_EXECUTE_NAME(name)                  cpu_execute_##name
  37 #define CPU_EXECUTE(name)                       int CPU_EXECUTE_NAME(name)(h6280_Regs *cpustate, int ICount)
  38 #define CPU_EXECUTE_CALL(name)                  CPU_EXECUTE_NAME(name)(cpustate, icount)
  39
  40 #define CPU_DISASSEMBLE_NAME(name)              cpu_disassemble_##name
  41 #define CPU_DISASSEMBLE(name)                   int CPU_DISASSEMBLE_NAME(name)(_TCHAR *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram)
  42 #define CPU_DISASSEMBLE_CALL(name)              CPU_DISASSEMBLE_NAME(name)(buffer, pc, oprom, oprom)
  43
  44 #define READ8_HANDLER(name)                     UINT8 name(h6280_Regs *cpustate, offs_t offset)
  45 #define WRITE8_HANDLER(name)                    void name(h6280_Regs *cpustate, offs_t offset, UINT8 data)
  46
  47 /*****************************************************************************/
  48 /* src/emu/didisasm.h */
  49
  50 // Disassembler constants
  51 const UINT32 DASMFLAG_SUPPORTED     = 0x80000000;   // are disassembly flags supported?
  52 const UINT32 DASMFLAG_STEP_OUT      = 0x40000000;   // this instruction should be the end of a step out sequence
  53 const UINT32 DASMFLAG_STEP_OVER     = 0x20000000;   // this instruction should be stepped over by setting a breakpoint afterwards
  54 const UINT32 DASMFLAG_OVERINSTMASK  = 0x18000000;   // number of extra instructions to skip when stepping over
  55 const UINT32 DASMFLAG_OVERINSTSHIFT = 27;           // bits to shift after masking to get the value
  56 const UINT32 DASMFLAG_LENGTHMASK    = 0x0000ffff;   // the low 16-bits contain the actual length
  57
  58 /*****************************************************************************/
  59 /* src/emu/diexec.h */
  60
  61 // I/O line states
  62 enum line_state
  63 {
  64         CLEAR_LINE = 0,                         // clear (a fired or held) line
  65         ASSERT_LINE,                            // assert an interrupt immediately
  66         HOLD_LINE,                              // hold interrupt line until acknowledged
  67         PULSE_LINE                              // pulse interrupt line instantaneously (only for NMI, RESET)
  68 };
  69
  70 enum
  71 {
  72         INPUT_LINE_IRQ1 = 0,
  73         INPUT_LINE_IRQ2 = 1,
  74         INPUT_LINE_TIRQ = 2,
  75         INPUT_LINE_NMI
  76 };
  77
  78 #define logerror(...)
  79
  80 #include "mame/emu/cpu/h6280/h6280.c"
  81 #ifdef USE_DEBUGGER
  82 #include "mame/emu/cpu/h6280/6280dasm.c"
  83 #endif
  84
  85 // main
  86
  87 void HUC6280::initialize()
  88 {
  89         opaque = CPU_INIT_CALL(h6280);
  90
  91         h6280_Regs *cpustate = (h6280_Regs *)opaque;
  92         cpustate->program = d_mem;
  93         cpustate->io = d_io;
  94 #ifdef USE_DEBUGGER
  95         cpustate->emu = emu;
  96         cpustate->debugger = d_debugger;
  97         cpustate->program_stored = d_mem;
  98         cpustate->io_stored = d_io;
  99
 100         d_debugger->set_context_mem(d_mem);
 101         d_debugger->set_context_io(d_io);
 102 #endif
 103 }
 104
 105 void HUC6280::release()
 106 {
 107         free(opaque);
 108 }
 109
 110 void HUC6280::reset()
 111 {
 112         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 113
 114         CPU_RESET_CALL(h6280);
 115
 116         cpustate->program = d_mem;
 117         cpustate->io = d_io;
 118 #ifdef USE_DEBUGGER
 119         cpustate->emu = emu;
 120         cpustate->debugger = d_debugger;
 121         cpustate->program_stored = d_mem;
 122         cpustate->io_stored = d_io;
 123 #endif
 124 }
 125
 126 int HUC6280::run(int icount)
 127 {
 128         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 129         return CPU_EXECUTE_CALL(h6280);
 130 }
 131
 132 void HUC6280::write_signal(int id, uint32 data, uint32 mask)
 133 {
 134         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 135         set_irq_line(cpustate, id, data);
 136 }
 137
 138 uint32 HUC6280::get_pc()
 139 {
 140         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 141         return cpustate->ppc.w.l;
 142 }
 143
 144 uint32 HUC6280::get_next_pc()
 145 {
 146         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 147         return cpustate->pc.w.l;
 148 }
 149
 150 uint8 HUC6280::irq_status_r(uint16 offset)
 151 {
 152         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 153         return h6280_irq_status_r(cpustate, offset);
 154 }
 155
 156 void HUC6280::irq_status_w(uint16 offset, uint8 data)
 157 {
 158         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 159         h6280_irq_status_w(cpustate, offset, data);
 160 }
 161
 162 uint8 HUC6280::timer_r(uint16 offset)
 163 {
 164         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 165         return h6280_timer_r(cpustate, offset);
 166 }
 167
 168 void HUC6280::timer_w(uint16 offset, uint8 data)
 169 {
 170         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 171         h6280_timer_w(cpustate, offset, data);
 172 }
 173
 174 #ifdef USE_DEBUGGER
 175 void HUC6280::write_debug_data8(uint32 addr, uint32 data)
 176 {
 177         int wait;
 178         d_mem->write_data8w(addr, data, &wait);
 179 }
 180
 181 uint32 HUC6280::read_debug_data8(uint32 addr)
 182 {
 183         int wait;
 184         return d_mem->read_data8w(addr, &wait);
 185 }
 186
 187 void HUC6280::write_debug_io8(uint32 addr, uint32 data)
 188 {
 189         int wait;
 190         d_io->write_io8w(addr, data, &wait);
 191 }
 192
 193 uint32 HUC6280::read_debug_io8(uint32 addr) {
 194         int wait;
 195         return d_io->read_io8w(addr, &wait);
 196 }
 197
 198 bool HUC6280::write_debug_reg(const _TCHAR *reg, uint32 data)
 199 {
 200         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 201         if(_tcsicmp(reg, _T("PC")) == 0) {
 202                 cpustate->pc.w.l = data;
 203         } if(_tcsicmp(reg, _T("SP")) == 0) {
 204                 cpustate->sp.w.l = data;
 205         } if(_tcsicmp(reg, _T("ZP")) == 0) {
 206                 cpustate->zp.w.l = data;
 207         } if(_tcsicmp(reg, _T("EA")) == 0) {
 208                 cpustate->ea.w.l = data;
 209         } if(_tcsicmp(reg, _T("A")) == 0) {
 210                 cpustate->a = data;
 211         } if(_tcsicmp(reg, _T("X")) == 0) {
 212                 cpustate->x = data;
 213         } if(_tcsicmp(reg, _T("Y")) == 0) {
 214                 cpustate->y = data;
 215         } if(_tcsicmp(reg, _T("P")) == 0) {
 216                 cpustate->p = data;
 217         } else {
 218                 return false;
 219         }
 220         return true;
 221 }
 222
 223 void HUC6280::get_debug_regs_info(_TCHAR *buffer, size_t buffer_len)
 224 {
 225         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 226         my_stprintf_s(buffer, buffer_len,
 227         _T("PC = 0000 SP = %04X ZP = %04X EA = %04X A = %02X X = %02X Y = %02X P = %02X"),
 228         cpustate->pc.w.l, cpustate->sp.w.l, cpustate->zp.w.l, cpustate->ea.w.l, cpustate->a, cpustate->x, cpustate->y, cpustate->p);
 229 }
 230
 231 // disassembler
 232
 233 int HUC6280::debug_dasm(uint32 pc, _TCHAR *buffer, size_t buffer_len)
 234 {
 235         uint8 oprom[8];
 236         uint8 *opram = oprom;
 237
 238         for(int i = 0; i < 8; i++) {
 239                 int wait;
 240                 oprom[i] = d_mem->read_data8w(pc + i, &wait);
 241         }
 242         return CPU_DISASSEMBLE_CALL(h6280) & DASMFLAG_LENGTHMASK;
 243 }
 244 #endif
 245
 246 #define STATE_VERSION   2
 247
 248 void HUC6280::save_state(FILEIO* state_fio)
 249 {
 250         state_fio->FputUint32(STATE_VERSION);
 251         state_fio->FputInt32(this_device_id);
 252
 253         state_fio->Fwrite(opaque, sizeof(h6280_Regs), 1);
 254
 255 }
 256
 257 bool HUC6280::load_state(FILEIO* state_fio)
 258 {
 259         if(state_fio->FgetUint32() != STATE_VERSION) {
 260                 return false;
 261         }
 262         if(state_fio->FgetInt32() != this_device_id) {
 263                 return false;
 264         }
 265         state_fio->Fread(opaque, sizeof(h6280_Regs), 1);
 266
 267         // post process
 268         h6280_Regs *cpustate = (h6280_Regs *)opaque;
 269         cpustate->program = d_mem;
 270         cpustate->io = d_io;
 271 #ifdef USE_DEBUGGER
 272         cpustate->emu = emu;
 273         cpustate->debugger = d_debugger;
 274         cpustate->program_stored = d_mem;
 275         cpustate->io_stored = d_io;
 276 #endif
 277         return true;
 278 }