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* 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         void save_state(FILEIO* state_fio);
 134         bool load_state(FILEIO* state_fio);
 135         // interrupt common functions
 136         void set_context_intr(DEVICE* device, uint32_t bit)
 137         {
 138                 d_cpu = device;
 139                 intr_bit = bit;
 140         }
 141         void set_context_child(DEVICE* device)
 142         {
 143                 d_child = device;
 144         }
 145         void set_intr_iei(bool val);
 146         uint32_t get_intr_ack();
 147         void notify_intr_reti();
 148
 149         // unique functions
 150         void set_context_rts(int ch, DEVICE* device, int id, uint32_t mask)
 151         {
 152                 register_output_signal(&port[ch].outputs_rts, device, id, mask);
 153         }
 154         void set_context_dtr(int ch, DEVICE* device, int id, uint32_t mask)
 155         {
 156                 register_output_signal(&port[ch].outputs_dtr, device, id, mask);
 157         }
 158         void set_context_send(int ch, DEVICE* device, int id)
 159         {
 160                 register_output_signal(&port[ch].outputs_send, device, id, 0xff);
 161         }
 162         void set_context_sync(int ch, DEVICE* device, int id, uint32_t mask)
 163         {
 164                 register_output_signal(&port[ch].outputs_sync, device, id, mask);
 165         }
 166         void set_context_break(int ch, DEVICE* device, int id, uint32_t mask)
 167         {
 168                 register_output_signal(&port[ch].outputs_break, device, id, mask);
 169         }
 170         void set_context_rxdone(int ch, DEVICE* device, int id, uint32_t mask)
 171         {
 172                 register_output_signal(&port[ch].outputs_rxdone, device, id, mask);
 173         }
 174         void set_context_txdone(int ch, DEVICE* device, int id, uint32_t mask)
 175         {
 176                 register_output_signal(&port[ch].outputs_txdone, device, id, mask);
 177         }
 178         void set_tx_clock(int ch, double clock)
 179         {
 180                 if(port[ch].tx_clock != clock) {
 181                         port[ch].tx_clock = clock;
 182                         update_tx_timing(ch);
 183                 }
 184         }
 185         void set_rx_clock(int ch, double clock)
 186         {
 187                 if(port[ch].rx_clock != clock) {
 188                         port[ch].rx_clock = clock;
 189                         update_rx_timing(ch);
 190                 }
 191         }
 192 };
 193
 194 #endif
 195