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 wr[8];
  43                 uint8 vector;
  44                 uint8 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 sync_bit;
  52 #ifdef UPD7201
  53                 uint16 tx_count;
  54 #endif
  55                 double tx_clock, tx_interval;
  56                 double rx_clock, rx_interval;
  57                 int tx_data_bits;
  58                 int tx_bits_x2, tx_bits_x2_remain;
  59                 int rx_bits_x2, rx_bits_x2_remain;
  60                 bool prev_tx_clock_signal;
  61                 bool prev_rx_clock_signal;
  62                 // buffer
  63                 FIFO* send;
  64                 FIFO* recv;
  65                 FIFO* rtmp;
  66                 int send_id;
  67                 int recv_id;
  68                 // interrupt
  69                 bool err_intr;
  70                 int recv_intr;
  71                 bool stat_intr;
  72                 bool send_intr;
  73                 bool req_intr;
  74                 bool in_service;
  75                 // input signals
  76                 bool dcd;
  77                 bool cts;
  78                 // output signals
  79                 outputs_t outputs_rts;
  80                 outputs_t outputs_dtr;
  81                 outputs_t outputs_send;
  82                 outputs_t outputs_sync;
  83                 outputs_t outputs_break;
  84                 outputs_t outputs_txdone;
  85                 outputs_t outputs_rxdone;
  86         } port[2];
  87
  88         void update_tx_timing(int ch);
  89         void update_rx_timing(int ch);
  90
  91         // daisy chain
  92         DEVICE *d_cpu, *d_child;
  93         bool iei, oei;
  94         uint32 intr_bit;
  95         void update_intr();
  96
  97 public:
  98         Z80SIO(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
  99         {
 100                 memset(port, 0, sizeof(port));
 101                 for(int i = 0; i < 2; i++) {
 102                         port[i].tx_data_bits = 5;
 103                         update_tx_timing(i);
 104                         update_rx_timing(i);
 105                         init_output_signals(&port[i].outputs_rts);
 106                         init_output_signals(&port[i].outputs_dtr);
 107                         init_output_signals(&port[i].outputs_send);
 108                         init_output_signals(&port[i].outputs_sync);
 109                         init_output_signals(&port[i].outputs_break);
 110                         init_output_signals(&port[i].outputs_txdone);
 111                         init_output_signals(&port[i].outputs_rxdone);
 112                 }
 113                 d_cpu = d_child = NULL;
 114         }
 115         ~Z80SIO() {}
 116
 117         // common functions
 118         void initialize();
 119         void reset();
 120         void release();
 121         void write_io8(uint32 addr, uint32 data);
 122         uint32 read_io8(uint32 addr);
 123         void write_signal(int id, uint32 data, uint32 mask);
 124         void event_callback(int event_id, int err);
 125         void save_state(FILEIO* state_fio);
 126         bool load_state(FILEIO* state_fio);
 127
 128         // interrupt common functions
 129         void set_context_intr(DEVICE* device, uint32 bit)
 130         {
 131                 d_cpu = device;
 132                 intr_bit = bit;
 133         }
 134         void set_context_child(DEVICE* device)
 135         {
 136                 d_child = device;
 137         }
 138         void set_intr_iei(bool val);
 139         uint32 intr_ack();
 140         void intr_reti();
 141
 142         // unique functions
 143         void set_context_rts(int ch, DEVICE* device, int id, uint32 mask)
 144         {
 145                 register_output_signal(&port[ch].outputs_rts, device, id, mask);
 146         }
 147         void set_context_dtr(int ch, DEVICE* device, int id, uint32 mask)
 148         {
 149                 register_output_signal(&port[ch].outputs_dtr, device, id, mask);
 150         }
 151         void set_context_send(int ch, DEVICE* device, int id)
 152         {
 153                 register_output_signal(&port[ch].outputs_send, device, id, 0xff);
 154         }
 155         void set_context_sync(int ch, DEVICE* device, int id, uint32 mask)
 156         {
 157                 register_output_signal(&port[ch].outputs_sync, device, id, mask);
 158         }
 159         void set_context_break(int ch, DEVICE* device, int id, uint32 mask)
 160         {
 161                 register_output_signal(&port[ch].outputs_break, device, id, mask);
 162         }
 163         void set_context_rxdone(int ch, DEVICE* device, int id, uint32 mask)
 164         {
 165                 register_output_signal(&port[ch].outputs_rxdone, device, id, mask);
 166         }
 167         void set_context_txdone(int ch, DEVICE* device, int id, uint32 mask)
 168         {
 169                 register_output_signal(&port[ch].outputs_txdone, device, id, mask);
 170         }
 171         void set_tx_clock(int ch, double clock)
 172         {
 173                 if(port[ch].tx_clock != clock) {
 174                         port[ch].tx_clock = clock;
 175                         update_tx_timing(ch);
 176                 }
 177         }
 178         void set_rx_clock(int ch, double clock)
 179         {
 180                 if(port[ch].rx_clock != clock) {
 181                         port[ch].rx_clock = clock;
 182                         update_rx_timing(ch);
 183                 }
 184         }
 185 };
 186
 187 #endif
 188