source/src/vm/fp200/io.h

   1 /*
   2         CASIO FP-200 Emulator 'eFP-200'
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2013.03.21-
   6
   7         [ io ]
   8 */
   9
  10 #ifndef _IO_H_
  11 #define _IO_H_
  12
  13 #include "../vm.h"
  14 #include "../../emu.h"
  15 #include "../device.h"
  16
  17 #define SIG_IO_SOD      0
  18 #define SIG_IO_CMT      1
  19
  20 class FILEIO;
  21
  22 class IO : public DEVICE
  23 {
  24 private:
  25         DEVICE *d_cpu, *d_drec, *d_rtc;
  26
  27         bool mode_basic;
  28         bool sod;
  29
  30         // display
  31         uint8_t screen[64][160];
  32         uint8_t font[8*256];
  33
  34         struct {
  35                 uint8_t ram[0x400];
  36                 int offset, cursor;
  37         } lcd[2];
  38
  39         int lcd_status, lcd_addr;
  40         bool lcd_text;
  41
  42         // cmt
  43         bool cmt_selected;
  44         uint8_t cmt_mode;
  45         bool cmt_play_ready, cmt_play_signal, cmt_rec_ready;
  46         FILEIO* cmt_fio;
  47         bool cmt_rec, cmt_is_wav;
  48         _TCHAR cmt_rec_file_path[_MAX_PATH];
  49         int cmt_bufcnt;
  50         uint8_t cmt_buffer[0x10000];
  51         void cmt_write_buffer(uint8_t value, int samples);
  52
  53         // from FP-1100
  54         uint8_t cmt_clock;
  55         struct {
  56                 bool in_d, in_ck, in_s, in_r;
  57                 bool out_q, out_nq;
  58                 bool tmp_ck;
  59                 void update()
  60                 {
  61                         if(!in_s && in_r) {
  62                                 out_q = true;
  63                                 out_nq = false;
  64                         } else if(in_s && !in_r) {
  65                                 out_q = false;
  66                                 out_nq = true;
  67                         } else if(!in_s && !in_r) {
  68                                 out_q = out_nq = true; // undetermined
  69                         } else if(!tmp_ck && in_ck) {
  70                                 out_q = in_d;
  71                                 out_nq = !in_d;
  72                         }
  73                         tmp_ck = in_ck;
  74                 }
  75         } b16_1, b16_2, g21_1, g21_2;
  76         struct {
  77                 bool in_d0, in_d1, in_d2, in_d3, in_d4, in_d5, in_d6, in_d7;
  78                 bool in_a, in_b, in_c, in_s;
  79                 bool out_y, out_ny;
  80                 void update()
  81                 {
  82                         if(in_s) {
  83                                 out_y = false;
  84                         } else if(!in_a && !in_b && !in_c) {
  85                                 out_y = in_d0;
  86                         } else if( in_a && !in_b && !in_c) {
  87                                 out_y = in_d1;
  88                         } else if(!in_a &&  in_b && !in_c) {
  89                                 out_y = in_d2;
  90                         } else if( in_a &&  in_b && !in_c) {
  91                                 out_y = in_d3;
  92                         } else if(!in_a && !in_b &&  in_c) {
  93                                 out_y = in_d4;
  94                         } else if( in_a && !in_b &&  in_c) {
  95                                 out_y = in_d5;
  96                         } else if(!in_a &&  in_b &&  in_c) {
  97                                 out_y = in_d6;
  98                         } else if( in_a &&  in_b &&  in_c) {
  99                                 out_y = in_d7;
 100                         }
 101                         out_ny = !out_y;
 102                 }
 103         } c15;
 104         struct {
 105                 bool in_a, in_b, in_rc1, in_rc2;
 106                 bool out_qa, out_qb, out_qc;
 107                 bool tmp_a, tmp_b;
 108                 uint8_t counter_a, counter_b;
 109                 void update()
 110                 {
 111                         if(in_rc1 && in_rc2) {
 112                                 counter_a = counter_b = 0;
 113                         } else {
 114                                 if(tmp_a && !in_a) {
 115                                         counter_a++;
 116                                 }
 117                                 if(tmp_b && !in_b) {
 118                                         counter_b++;
 119                                 }
 120                         }
 121                         tmp_a = in_a;
 122                         tmp_b = in_b;
 123                         out_qa = ((counter_a & 1) != 0);
 124                         out_qb = ((counter_b & 1) != 0);
 125                         out_qc = ((counter_b & 2) != 0);
 126                 }
 127         } c16;
 128         struct {
 129                 bool in_ck, in_clr;
 130                 bool out_q5, out_q6;
 131                 bool tmp_ck;
 132                 uint8_t counter;
 133                 void update()
 134                 {
 135                         if(in_clr) {
 136                                 counter = 0;
 137                         } else if(tmp_ck && !in_ck) {
 138                                 counter++;
 139                         }
 140                         tmp_ck = in_ck;
 141                         out_q5 = ((counter & 0x10) != 0);
 142                         out_q6 = ((counter & 0x20) != 0);
 143                 }
 144         } f21;
 145         void update_cmt();
 146
 147         // keyboard
 148         const uint8_t* key_stat;
 149         uint8_t key_column;
 150         void update_sid();
 151
 152 public:
 153         IO(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 154         {
 155                 set_device_name(_T("I/O Bus"));
 156         }
 157         ~IO() {}
 158
 159         // common functions
 160         void initialize();
 161         void release();
 162         void reset();
 163         void write_io8(uint32_t addr, uint32_t data);
 164         uint32_t read_io8(uint32_t addr);
 165         void write_io8w(uint32_t addr, uint32_t data, int* wait);
 166         uint32_t read_io8w(uint32_t addr, int* wait);
 167         void write_signal(int id, uint32_t data, uint32_t mask);
 168         void event_callback(int event_id, int err);
 169         void decl_state();
 170         void save_state(FILEIO* state_fio);
 171         bool load_state(FILEIO* state_fio);
 172
 173         // unique functions
 174         void set_context_cpu(DEVICE* device)
 175         {
 176                 d_cpu = device;
 177         }
 178         void set_context_drec(DEVICE* device)
 179         {
 180                 d_drec = device;
 181         }
 182         void set_context_rtc(DEVICE* device)
 183         {
 184                 d_rtc = device;
 185         }
 186         void key_down(int code);
 187         void key_up();
 188         void rec_tape(const _TCHAR* file_path);
 189         void close_tape();
 190         bool is_tape_inserted()
 191         {
 192                 return cmt_rec;
 193         }
 194         bool is_tape_playing()
 195         {
 196                 return false;
 197         }
 198         bool is_tape_recording()
 199         {
 200                 return cmt_rec;
 201         }
 202         int get_tape_position()
 203         {
 204                 return 0;
 205         }
 206         void draw_screen();
 207 };
 208
 209 #endif