source/src/vm/huc6280.h

   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 #ifndef _HUC6280_H_
  12 #define _HUC6280_H_
  13
  14 #include "vm.h"
  15 #include "../emu.h"
  16 #include "device.h"
  17
  18 //#ifdef USE_DEBUGGER
  19 class DEBUGGER;
  20 //#endif
  21
  22 class HUC6280_BASE : public DEVICE
  23 {
  24 protected:
  25         DEVICE *d_mem, *d_io;
  26 //#ifdef USE_DEBUGGER
  27         DEBUGGER *d_debugger;
  28 //#endif
  29         void *opaque;
  30         int icount;
  31         bool busreq;
  32         int exec_call(void);
  33         int exec_call_debug(void);
  34         uint64_t total_icount;
  35         uint64_t prev_total_icount;
  36
  37         virtual int run_one_opecode();
  38
  39 public:
  40         HUC6280_BASE(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu) {
  41                 total_icount = prev_total_icount = 0;
  42                 set_device_name(_T("HuC6280 CPU"));
  43         }
  44         ~HUC6280_BASE() {}
  45
  46         // common functions
  47         virtual void initialize();
  48         virtual void release();
  49         virtual void reset();
  50         virtual int run(int clock);
  51         void write_signal(int id, uint32_t data, uint32_t mask);
  52         uint32_t get_pc();
  53         uint32_t get_next_pc();
  54 //#ifdef USE_DEBUGGER
  55         void *get_debugger()
  56         {
  57                 return d_debugger;
  58         }
  59         uint32_t get_debug_prog_addr_mask()
  60         {
  61                 return 0xffff;
  62         }
  63         uint32_t get_debug_data_addr_mask()
  64         {
  65                 return 0x1fffff;
  66         }
  67         void write_debug_data8(uint32_t addr, uint32_t data);
  68         uint32_t read_debug_data8(uint32_t addr);
  69         void write_debug_io8(uint32_t addr, uint32_t data);
  70         uint32_t read_debug_io8(uint32_t addr);
  71         bool write_debug_reg(const _TCHAR *reg, uint32_t data);
  72         void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
  73         int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len);
  74 //#endif
  75         void save_state_registers(FILEIO* state_fio);
  76         void load_state_registers(FILEIO* state_fio);
  77
  78         // unique function
  79         void set_context_mem(DEVICE* device)
  80         {
  81                 d_mem = device;
  82         }
  83         void set_context_io(DEVICE* device)
  84         {
  85                 d_io = device;
  86         }
  87         uint8_t irq_status_r(uint16_t offset);
  88         void irq_status_w(uint16_t offset, uint8_t data);
  89         uint8_t timer_r(uint16_t offset);
  90         void timer_w(uint16_t offset, uint8_t data);
  91 };
  92
  93 class HUC6280 : public HUC6280_BASE
  94 {
  95 private:
  96 protected:
  97         int run_one_opecode() override;
  98 public:
  99         HUC6280(VM* parent_vm, EMU* parent_emu) : HUC6280_BASE(parent_vm, parent_emu) {
 100                 set_device_name(_T("HuC6280 CPU"));
 101         }
 102         ~HUC6280() {}
 103
 104         // common functions
 105         void initialize();
 106         void release();
 107         void reset();
 108         int run(int clock);
 109
 110         void save_state(FILEIO* state_fio);
 111         bool load_state(FILEIO* state_fio);
 112
 113 #ifdef USE_DEBUGGER
 114         void set_context_debugger(DEBUGGER* device)
 115         {
 116                 d_debugger = device;
 117         }
 118 #endif
 119 };
 120
 121 #endif
 122