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 decl_state_registers();
  76         void save_state_registers(FILEIO* state_fio);
  77         void load_state_registers(FILEIO* state_fio);
  78
  79         // unique function
  80         void set_context_mem(DEVICE* device)
  81         {
  82                 d_mem = device;
  83         }
  84         void set_context_io(DEVICE* device)
  85         {
  86                 d_io = device;
  87         }
  88         uint8_t irq_status_r(uint16_t offset);
  89         void irq_status_w(uint16_t offset, uint8_t data);
  90         uint8_t timer_r(uint16_t offset);
  91         void timer_w(uint16_t offset, uint8_t data);
  92 };
  93
  94 class HUC6280 : public HUC6280_BASE
  95 {
  96 private:
  97 protected:
  98         int run_one_opecode() override;
  99 public:
 100         HUC6280(VM* parent_vm, EMU* parent_emu) : HUC6280_BASE(parent_vm, parent_emu) {
 101                 set_device_name(_T("HuC6280 CPU"));
 102         }
 103         ~HUC6280() {}
 104
 105         // common functions
 106         void initialize();
 107         void release();
 108         void reset();
 109         int run(int clock);
 110
 111         void decl_state();
 112         void save_state(FILEIO* state_fio);
 113         bool load_state(FILEIO* state_fio);
 114
 115 #ifdef USE_DEBUGGER
 116         void set_context_debugger(DEBUGGER* device)
 117         {
 118                 d_debugger = device;
 119         }
 120 #endif
 121 };
 122
 123 #endif
 124