source/src/vm/i8237.h

   1 /*
   2         Skelton for retropc emulator
   3
   4         Origin : MESS
   5         Author : Takeda.Toshiya
   6         Date   : 2006.12.06 -
   7
   8         [ i8237 ]
   9 */
  10
  11 #ifndef _I8237_H_
  12 #define _I8237_H_
  13
  14 //#include "vm.h"
  15 //#include "../emu.h"
  16 #include "device.h"
  17
  18 #define SIG_I8237_CH0   0
  19 #define SIG_I8237_CH1   1
  20 #define SIG_I8237_CH2   2
  21 #define SIG_I8237_CH3   3
  22 #define SIG_I8237_BANK0 4
  23 #define SIG_I8237_BANK1 5
  24 #define SIG_I8237_BANK2 6
  25 #define SIG_I8237_BANK3 7
  26 #define SIG_I8237_MASK0 8
  27 #define SIG_I8237_MASK1 9
  28 #define SIG_I8237_MASK2 10
  29 #define SIG_I8237_MASK3 11
  30
  31 class DEBUGGER;
  32 class I8237_BASE : public DEVICE
  33 {
  34 protected:
  35         DEVICE* d_mem;
  36         DEBUGGER *d_debugger;
  37
  38         struct {
  39                 DEVICE* dev;
  40                 uint16_t areg;
  41                 uint16_t creg;
  42                 uint16_t bareg;
  43                 uint16_t bcreg;
  44                 uint8_t mode;
  45                 // external bank
  46                 uint16_t bankreg;
  47                 uint16_t incmask;
  48                 // output tc signals
  49                 outputs_t outputs_tc;
  50         } dma[4];
  51         outputs_t outputs_wrote_mem;
  52
  53         bool low_high;
  54         uint8_t cmd;
  55         uint8_t req;
  56         uint8_t mask;
  57         uint8_t tc;
  58         uint32_t tmp;
  59         bool mode_word;
  60         uint32_t addr_mask;
  61
  62         void __FASTCALL write_mem(uint32_t addr, uint32_t data);
  63         uint32_t __FASTCALL read_mem(uint32_t addr);
  64         void __FASTCALL write_io(int ch, uint32_t data);
  65         uint32_t __FASTCALL read_io(int ch);
  66
  67 public:
  68         I8237_BASE(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
  69         {
  70                 for(int i = 0; i < 4; i++) {
  71                         //dma[i].dev = vm->dummy;
  72                         dma[i].dev = NULL;
  73                         dma[i].bankreg = dma[i].incmask = 0;
  74                         initialize_output_signals(&dma[i].outputs_tc);
  75                 }
  76                 initialize_output_signals(&outputs_wrote_mem);
  77                 mode_word = false;
  78                 addr_mask = 0xffffffff;
  79                 d_debugger = NULL;
  80                 set_device_name(_T("i8237 DMAC"));
  81         }
  82         ~I8237_BASE() {}
  83
  84         // common functions
  85         void initialize();
  86         void reset();
  87         virtual void __FASTCALL write_io8(uint32_t addr, uint32_t data);
  88         uint32_t __FASTCALL read_io8(uint32_t addr);
  89         virtual void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
  90         virtual void __FASTCALL do_dma();
  91         // for debug
  92         virtual bool is_debugger_available()
  93         {
  94                 return false;
  95         }
  96         void *get_debugger()
  97         {
  98                 return d_debugger;
  99         }
 100         bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
 101         void __FASTCALL write_via_debugger_data8(uint32_t addr, uint32_t data);
 102         uint32_t __FASTCALL read_via_debugger_data8(uint32_t addr);
 103         void __FASTCALL write_via_debugger_data16(uint32_t addr, uint32_t data);
 104         uint32_t __FASTCALL read_via_debugger_data16(uint32_t addr);
 105
 106         // unique functions
 107         void set_context_memory(DEVICE* device)
 108         {
 109                 d_mem = device;
 110         }
 111         void set_context_ch0(DEVICE* device)
 112         {
 113                 dma[0].dev = device;
 114         }
 115         void set_context_ch1(DEVICE* device)
 116         {
 117                 dma[1].dev = device;
 118         }
 119         void set_context_ch2(DEVICE* device)
 120         {
 121                 dma[2].dev = device;
 122         }
 123         void set_context_ch3(DEVICE* device)
 124         {
 125                 dma[3].dev = device;
 126         }
 127         void set_context_tc0(DEVICE* device, int id, uint32_t mask)
 128         {
 129                 register_output_signal(&dma[0].outputs_tc, device, id, mask);
 130         }
 131         void set_context_tc1(DEVICE* device, int id, uint32_t mask)
 132         {
 133                 register_output_signal(&dma[1].outputs_tc, device, id, mask);
 134         }
 135         void set_context_tc2(DEVICE* device, int id, uint32_t mask)
 136         {
 137                 register_output_signal(&dma[2].outputs_tc, device, id, mask);
 138         }
 139         void set_context_tc3(DEVICE* device, int id, uint32_t mask)
 140         {
 141                 register_output_signal(&dma[3].outputs_tc, device, id, mask);
 142         }
 143         void set_context_wrote_mem(DEVICE* device, int id)
 144         {
 145                 register_output_signal(&outputs_wrote_mem, device, id, 1);
 146         }
 147         void set_mode_word(bool val)
 148         {
 149                 mode_word = val;
 150         }
 151         void set_address_mask(uint32_t val)
 152         {
 153                 addr_mask = val;
 154         }
 155 };
 156
 157 class I8237 : public I8237_BASE {
 158 private:
 159 #ifdef SINGLE_MODE_DMA
 160         DEVICE* d_dma;
 161 #endif
 162 public:
 163         I8237(VM_TEMPLATE* parent_vm, EMU* parent_emu);
 164         ~I8237();
 165
 166         void initialize();
 167         virtual void __FASTCALL write_io8(uint32_t addr, uint32_t data);
 168         void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
 169         uint32_t __FASTCALL read_signal(int id);
 170         void __FASTCALL do_dma();
 171         bool process_state(FILEIO* state_fio, bool loading);
 172
 173 #ifdef USE_DEBUGGER
 174         bool is_debugger_available()
 175         {
 176                 return true;
 177         }
 178 #endif
 179 #ifdef SINGLE_MODE_DMA
 180         void set_context_child_dma(DEVICE* device)
 181         {
 182                 d_dma = device;
 183         }
 184 #endif
 185 #ifdef USE_DEBUGGER
 186         void set_context_debugger(DEBUGGER* device)
 187         {
 188                 d_debugger = device;
 189         }
 190 #endif
 191 };
 192
 193 #endif
 194