source/src/vm/t3444a.h

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2015.09.03-
   6
   7         [ T3444A / T3444M ]
   8 */
   9
  10 #ifndef _T3444A_H_
  11 #define _T3444A_H_
  12
  13 //#include "vm.h"
  14 //#include "../emu.h"
  15 #include "device.h"
  16
  17 #define SIG_T3444A_DRIVE        0
  18 #define SIG_T3444A_TND          1
  19 #define SIG_T3444A_MOTOR        2
  20
  21 // for reading signal
  22 #define SIG_T3444A_DRDY         4
  23 #define SIG_T3444A_CRDY         5
  24 #define SIG_T3444A_RQM          6
  25
  26 //#ifdef HAS_T3444M
  27 //#define SECTORS_IN_TRACK      16
  28 //#else
  29 //#define SECTORS_IN_TRACK      26
  30 //#endif
  31
  32 class DISK;
  33 class NOISE;
  34
  35 class T3444A : public DEVICE
  36 {
  37 private:
  38         // output signals
  39         outputs_t outputs_rqm;
  40
  41         // drive noise
  42         NOISE* d_noise_seek;
  43         NOISE* d_noise_head_down;
  44         NOISE* d_noise_head_up;
  45
  46         // drive info
  47         struct {
  48                 int track;
  49                 int index;
  50                 bool access;
  51                 bool head_load;
  52                 // timing
  53                 int cur_position;
  54                 int next_trans_position;
  55                 int bytes_before_2nd_rqm;
  56                 int next_sync_position;
  57                 uint32_t prev_clock;
  58         } fdc[4];
  59         DISK* disk[4];
  60
  61         // register
  62         uint8_t status;
  63         uint8_t cmdreg;
  64         uint8_t trkreg;
  65         uint8_t secreg;
  66         uint8_t datareg;
  67         uint8_t drvreg;
  68         uint8_t sidereg;
  69         bool timerflag;
  70         uint8_t sector_id[26 * 4]; // SECTORS_IN_TRACK
  71
  72         // event
  73         int register_id[5];
  74
  75         void cancel_my_event(int event);
  76         void register_my_event(int event, double usec);
  77         void register_seek_event();
  78         void register_rqm_event(int bytes);
  79         void register_lost_event(int bytes);
  80
  81         // status
  82         bool now_search;
  83         int seektrk;
  84         bool rqm;
  85         bool tnd;
  86         bool motor_on;
  87
  88         // timing
  89         uint32_t prev_rqm_clock;
  90
  91
  92         int _max_drive;
  93         int _sectors_in_track;
  94         bool _has_t3444m;
  95         bool _fdc_debug_log;
  96
  97         int __FASTCALL get_cur_position();
  98         double __FASTCALL get_usec_to_start_trans();
  99         double __FASTCALL get_usec_to_next_trans_pos();
 100         double __FASTCALL get_usec_to_detect_index_hole(int count);
 101
 102         // image handler
 103         uint8_t search_sector();
 104
 105         // command
 106         void process_cmd();
 107         void cmd_seek_zero();
 108         void cmd_seek();
 109         void cmd_read_write();
 110         void cmd_write_id();
 111         void cmd_sence();
 112         void update_head_flag(int drv, bool head_load);
 113
 114         // rqm
 115         void set_rqm(bool val);
 116
 117 public:
 118         T3444A(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 119         {
 120                 initialize_output_signals(&outputs_rqm);
 121                 d_noise_seek = NULL;
 122                 d_noise_head_down = NULL;
 123                 d_noise_head_up = NULL;
 124                 tnd = true;
 125                 motor_on = false;
 126                 _max_drive = 4;
 127                 _sectors_in_track = 26;
 128                 _has_t3444m = _fdc_debug_log = false;
 129                 set_device_name(_T("T3444A FDC"));
 130         }
 131         ~T3444A() {}
 132
 133         // common functions
 134         void initialize();
 135         void release();
 136         void reset();
 137         void __FASTCALL write_io8(uint32_t addr, uint32_t data);
 138         uint32_t __FASTCALL read_io8(uint32_t addr);
 139         void __FASTCALL write_dma_io8(uint32_t addr, uint32_t data);
 140         uint32_t __FASTCALL read_dma_io8(uint32_t addr);
 141         void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
 142         uint32_t __FASTCALL read_signal(int ch);
 143         void event_callback(int event_id, int err);
 144         void update_config();
 145         bool process_state(FILEIO* state_fio, bool loading);
 146
 147         // unique functions
 148         void set_context_rqm(DEVICE* device, int id, uint32_t mask)
 149         {
 150                 register_output_signal(&outputs_rqm, device, id, mask);
 151         }
 152         void set_context_noise_seek(NOISE* device)
 153         {
 154                 d_noise_seek = device;
 155         }
 156         NOISE* get_context_noise_seek()
 157         {
 158                 return d_noise_seek;
 159         }
 160         void set_context_noise_head_down(NOISE* device)
 161         {
 162                 d_noise_head_down = device;
 163         }
 164         NOISE* get_context_noise_head_down()
 165         {
 166                 return d_noise_head_down;
 167         }
 168         void set_context_noise_head_up(NOISE* device)
 169         {
 170                 d_noise_head_up = device;
 171         }
 172         NOISE* get_context_noise_head_up()
 173         {
 174                 return d_noise_head_up;
 175         }
 176         DISK* get_disk_handler(int drv)
 177         {
 178                 return disk[drv];
 179         }
 180         void open_disk(int drv, const _TCHAR* file_path, int bank);
 181         void close_disk(int drv);
 182         bool is_disk_inserted(int drv);
 183         void is_disk_protected(int drv, bool value);
 184         bool is_disk_protected(int drv);
 185         void set_drive_type(int drv, uint8_t type);
 186         uint8_t get_drive_type(int drv);
 187         void set_drive_rpm(int drv, int rpm);
 188         void set_drive_mfm(int drv, bool mfm);
 189 };
 190
 191 #endif