source/src/vm/z80sio.h

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2006.12.31 -
   6
   7         [ Z80SIO ]
   8 */
   9
  10 #ifndef _Z80SIO_H_
  11 #define _Z80SIO_H_
  12
  13 //#include "vm.h"
  14 //#include "../emu.h"
  15 #include "device.h"
  16
  17 #define SIG_Z80SIO_RECV_CH0     0
  18 #define SIG_Z80SIO_RECV_CH1     1
  19 #define SIG_Z80SIO_BREAK_CH0    2
  20 #define SIG_Z80SIO_BREAK_CH1    3
  21 #define SIG_Z80SIO_DCD_CH0      4
  22 #define SIG_Z80SIO_DCD_CH1      5
  23 #define SIG_Z80SIO_CTS_CH0      6
  24 #define SIG_Z80SIO_CTS_CH1      7
  25 #define SIG_Z80SIO_SYNC_CH0     8
  26 #define SIG_Z80SIO_SYNC_CH1     9
  27 #define SIG_Z80SIO_TX_CLK_CH0   10
  28 #define SIG_Z80SIO_TX_CLK_CH1   11
  29 #define SIG_Z80SIO_RX_CLK_CH0   12
  30 #define SIG_Z80SIO_RX_CLK_CH1   13
  31 // hack: clear recv buffer
  32 #define SIG_Z80SIO_CLEAR_CH0    14
  33 #define SIG_Z80SIO_CLEAR_CH1    15
  34
  35 class FIFO;
  36
  37 class Z80SIO : public DEVICE
  38 {
  39 private:
  40         struct {
  41                 int pointer;
  42                 uint8_t wr[8];
  43                 uint8_t vector;
  44                 uint8_t affect;
  45                 bool nextrecv_intr;
  46                 bool first_data;
  47                 bool over_flow;
  48                 bool under_run;
  49                 bool abort;
  50                 bool sync;
  51                 uint8_t sync_bit;
  52 //#ifdef HAS_UPD7201
  53                 uint16_t tx_count;
  54                 uint8_t tx_count_hi;
  55 //#endif
  56                 double tx_clock, tx_interval;
  57                 double rx_clock, rx_interval;
  58                 int tx_data_bits;
  59                 int tx_bits_x2, tx_bits_x2_remain;
  60                 int rx_bits_x2, rx_bits_x2_remain;
  61                 bool prev_tx_clock_signal;
  62                 bool prev_rx_clock_signal;
  63                 // buffer
  64                 FIFO* send;
  65                 FIFO* recv;
  66                 FIFO* rtmp;
  67                 int shift_reg;
  68                 int send_id;
  69                 int recv_id;
  70                 // interrupt
  71                 bool err_intr;
  72                 int recv_intr;
  73                 bool stat_intr;
  74                 bool send_intr;
  75                 bool req_intr;
  76                 bool in_service;
  77                 // input signals
  78                 bool dcd;
  79                 bool cts;
  80                 // output signals
  81                 outputs_t outputs_rts;
  82                 outputs_t outputs_dtr;
  83                 outputs_t outputs_send;
  84                 outputs_t outputs_sync;
  85                 outputs_t outputs_break;
  86                 outputs_t outputs_txdone;
  87                 outputs_t outputs_rxdone;
  88         } port[2];
  89
  90         void update_tx_timing(int ch);
  91         void update_rx_timing(int ch);
  92
  93         // daisy chain
  94         DEVICE *d_cpu, *d_child;
  95         bool iei, oei;
  96         uint32_t intr_bit;
  97
  98         bool __HAS_UPD7201;
  99         bool __SIO_DEBUG;
 100         void update_intr();
 101
 102 public:
 103         Z80SIO(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 104         {
 105                 memset(port, 0, sizeof(port));
 106                 for(int i = 0; i < 2; i++) {
 107                         port[i].tx_data_bits = 5;
 108                         update_tx_timing(i);
 109                         update_rx_timing(i);
 110                         initialize_output_signals(&port[i].outputs_rts);
 111                         initialize_output_signals(&port[i].outputs_dtr);
 112                         initialize_output_signals(&port[i].outputs_send);
 113                         initialize_output_signals(&port[i].outputs_sync);
 114                         initialize_output_signals(&port[i].outputs_break);
 115                         initialize_output_signals(&port[i].outputs_txdone);
 116                         initialize_output_signals(&port[i].outputs_rxdone);
 117                 }
 118                 d_cpu = d_child = NULL;
 119                 __HAS_UPD7201 = false;
 120                 __SIO_DEBUG = false;
 121                 set_device_name(_T("Z80 SIO"));
 122         }
 123         ~Z80SIO() {}
 124
 125         // common functions
 126         void initialize();
 127         void reset();
 128         void release();
 129         void write_io8(uint32_t addr, uint32_t data);
 130         uint32_t read_io8(uint32_t addr);
 131         void write_signal(int id, uint32_t data, uint32_t mask);
 132         void event_callback(int event_id, int err);
 133         bool process_state(FILEIO* state_fio, bool loading);
 134         // interrupt common functions
 135         void set_context_intr(DEVICE* device, uint32_t bit)
 136         {
 137                 d_cpu = device;
 138                 intr_bit = bit;
 139         }
 140         void set_context_child(DEVICE* device)
 141         {
 142                 d_child = device;
 143         }
 144         void set_intr_iei(bool val);
 145         uint32_t get_intr_ack();
 146         void notify_intr_reti();
 147
 148         // unique functions
 149         void set_context_rts(int ch, DEVICE* device, int id, uint32_t mask)
 150         {
 151                 register_output_signal(&port[ch].outputs_rts, device, id, mask);
 152         }
 153         void set_context_dtr(int ch, DEVICE* device, int id, uint32_t mask)
 154         {
 155                 register_output_signal(&port[ch].outputs_dtr, device, id, mask);
 156         }
 157         void set_context_send(int ch, DEVICE* device, int id)
 158         {
 159                 register_output_signal(&port[ch].outputs_send, device, id, 0xff);
 160         }
 161         void set_context_sync(int ch, DEVICE* device, int id, uint32_t mask)
 162         {
 163                 register_output_signal(&port[ch].outputs_sync, device, id, mask);
 164         }
 165         void set_context_break(int ch, DEVICE* device, int id, uint32_t mask)
 166         {
 167                 register_output_signal(&port[ch].outputs_break, device, id, mask);
 168         }
 169         void set_context_rxdone(int ch, DEVICE* device, int id, uint32_t mask)
 170         {
 171                 register_output_signal(&port[ch].outputs_rxdone, device, id, mask);
 172         }
 173         void set_context_txdone(int ch, DEVICE* device, int id, uint32_t mask)
 174         {
 175                 register_output_signal(&port[ch].outputs_txdone, device, id, mask);
 176         }
 177         void set_tx_clock(int ch, double clock)
 178         {
 179                 if(port[ch].tx_clock != clock) {
 180                         port[ch].tx_clock = clock;
 181                         update_tx_timing(ch);
 182                 }
 183         }
 184         void set_rx_clock(int ch, double clock)
 185         {
 186                 if(port[ch].rx_clock != clock) {
 187                         port[ch].rx_clock = clock;
 188                         update_rx_timing(ch);
 189                 }
 190         }
 191 };
 192
 193 #endif
 194