source/src/vm/z80dma.h

   1 /*
   2         Skelton for retropc emulator
   3
   4         Origin : MAME Z80DMA / Xmillenium
   5         Author : Takeda.Toshiya
   6         Date   : 2011.04.96-
   7
   8         [ Z80DMA ]
   9 */
  10
  11 #ifndef _Z80DMA_H_
  12 #define _Z80DMA_H_
  13
  14 //#include "vm.h"
  15 //#include "../emu.h"
  16 #include "device.h"
  17
  18 #define SIG_Z80DMA_READY        0
  19
  20 class DEBUGGER;
  21
  22 class Z80DMA : public DEVICE
  23 {
  24 private:
  25         DEVICE *d_mem, *d_io;
  26         DEBUGGER *d_debugger;
  27
  28         typedef union {
  29                 uint16_t m[7][8];
  30                 uint16_t t[6*8+1+1];
  31         } regs_t;
  32         regs_t regs;
  33         uint8_t status;
  34
  35         uint16_t wr_tmp[4];
  36         int wr_num, wr_ptr;
  37         uint16_t rr_tmp[7];
  38         int rr_num, rr_ptr;
  39
  40         bool enabled;
  41         uint32_t ready;
  42         bool force_ready;
  43
  44         uint16_t addr_a;
  45         uint16_t addr_b;
  46         int upcount;
  47         int blocklen;
  48         bool dma_stop;
  49         bool bus_master;
  50
  51         void write_memory(uint32_t addr, uint32_t data, int* wait);
  52         uint32_t read_memory(uint32_t addr, int* wait);
  53         void write_ioport(uint32_t addr, uint32_t data, int* wait);
  54         uint32_t read_ioport(uint32_t addr, int* wait);
  55
  56         // interrupt
  57         bool req_intr;
  58         bool in_service;
  59         uint8_t vector;
  60
  61         bool _SINGLE_MODE_DMA;
  62         bool _DMA_DEBUG;
  63
  64         bool now_ready();
  65         void request_bus();
  66         void release_bus();
  67         void update_read_buffer();
  68         void request_intr(int level);
  69
  70         // daisy chain
  71         DEVICE *d_cpu, *d_child;
  72         bool iei, oei;
  73         uint32_t intr_bit;
  74         void update_intr();
  75
  76 public:
  77         Z80DMA(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
  78         {
  79                 for(int i = 0; i < 6 * 8 + 1 + 1; i++) {
  80                         regs.t[i] = 0;
  81                 }
  82                 _SINGLE_MODE_DMA = _DMA_DEBUG = false;
  83                 d_cpu = d_child = NULL;
  84                 d_debugger = NULL;
  85                 set_device_name(_T("Z80 DMA"));
  86         }
  87         ~Z80DMA() {}
  88
  89         // common functions
  90         void reset();
  91         void initialize();
  92         void write_io8(uint32_t addr, uint32_t data);
  93         uint32_t read_io8(uint32_t addr);
  94         void write_signal(int id, uint32_t data, uint32_t mask);
  95         void do_dma();
  96         // for debug
  97         void write_via_debugger_data8w(uint32_t addr, uint32_t data, int* wait);
  98         uint32_t read_via_debugger_data8w(uint32_t addr, int* wait);
  99         void write_via_debugger_io8w(uint32_t addr, uint32_t data, int* wait);
 100         uint32_t read_via_debugger_io8w(uint32_t addr, int* wait);
 101         bool is_debugger_available()
 102         {
 103                 return true;
 104         }
 105         void *get_debugger()
 106         {
 107                 return d_debugger;
 108         }
 109         bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
 110         bool process_state(FILEIO* state_fio, bool loading);
 111         // interrupt common functions
 112         void set_context_intr(DEVICE* device, uint32_t bit)
 113         {
 114                 d_cpu = device;
 115                 intr_bit = bit;
 116         }
 117         void set_context_child(DEVICE* device)
 118         {
 119                 d_child = device;
 120         }
 121         DEVICE *get_context_child()
 122         {
 123                 return d_child;
 124         }
 125         void set_intr_iei(bool val);
 126         uint32_t get_intr_ack();
 127         void notify_intr_reti();
 128
 129         // unique function
 130         void set_context_memory(DEVICE* device)
 131         {
 132                 d_mem = device;
 133         }
 134         void set_context_io(DEVICE* device)
 135         {
 136                 d_io = device;
 137         }
 138         void set_context_debugger(DEBUGGER* device)
 139         {
 140                 d_debugger = device;
 141         }
 142 };
 143
 144 #endif
 145