source/src/vm/upd765a.h

   1 /*
   2         Skelton for retropc emulator
   3
   4         Origin : M88
   5         Author : Takeda.Toshiya
   6         Date   : 2006.09.17-
   7
   8         [ uPD765A ]
   9 */
  10
  11 #ifndef _UPD765A_H_
  12 #define _UPD765A_H_
  13
  14 //#include "vm.h"
  15 //#include "../emu.h"
  16 #include "device.h"
  17
  18 #define SIG_UPD765A_RESET       0
  19 #define SIG_UPD765A_TC          1
  20 #define SIG_UPD765A_MOTOR       2
  21 #define SIG_UPD765A_MOTOR_NEG   3
  22 #define SIG_UPD765A_DRVSEL      4
  23 #define SIG_UPD765A_IRQ_MASK    5
  24 #define SIG_UPD765A_DRQ_MASK    6
  25 #define SIG_UPD765A_FREADY      7
  26
  27 class DISK;
  28 class NOISE;
  29
  30 class UPD765A : public DEVICE
  31 {
  32 private:
  33         // output signals
  34         outputs_t outputs_irq;
  35         outputs_t outputs_drq;
  36         outputs_t outputs_hdu;
  37         outputs_t outputs_index;
  38
  39         // drive noise
  40         NOISE* d_noise_seek;
  41         NOISE* d_noise_head_down;
  42         NOISE* d_noise_head_up;
  43
  44         // fdc
  45         struct {
  46                 uint8_t track;
  47                 uint8_t cur_track;
  48                 uint8_t result;
  49                 bool access;
  50                 bool head_load;
  51                 // timing
  52                 int cur_position;
  53                 int next_trans_position;
  54                 uint32_t prev_clock;
  55         } fdc[4];
  56         DISK* disk[4];
  57
  58         uint8_t hdu, hdue, id[4], eot, gpl, dtl;
  59
  60         int phase, prevphase;
  61         uint8_t status, seekstat, command;
  62         uint32_t result;
  63         int step_rate_time;
  64         int head_unload_time;
  65         bool no_dma_mode, motor_on;
  66 //#ifdef UPD765A_DMA_MODE
  67         bool dma_data_lost;
  68 //#endif
  69         bool irq_masked, drq_masked;
  70
  71         uint8_t* bufptr;
  72         uint8_t buffer[0x8000];
  73         int tmp_bufsize;
  74
  75         int count;
  76         int event_phase;
  77         int phase_id, drq_id, lost_id, result7_id, seek_step_id[4], seek_end_id[4], head_unload_id[4];
  78         bool force_ready;
  79         bool reset_signal;
  80         bool prev_index;
  81
  82         int _max_drive;
  83         bool _fdc_debug_log;
  84         bool _upd765a_dma_mode;
  85         bool _upd765a_ext_drvsel;
  86         bool _upd765a_sence_intstat_result;
  87         bool _upd765a_dont_wait_seek;
  88         bool _upd765a_no_st0_at_for_seek;
  89         bool _upd765a_wait_result7;
  90         bool _upd765a_no_st1_en_or_for_result7;
  91
  92         // timing
  93         uint32_t prev_drq_clock;
  94
  95         int get_cur_position(int drv);
  96         double get_usec_to_exec_phase();
  97
  98         // update status
  99         void set_irq(bool val);
 100         void set_drq(bool val);
 101         void set_hdu(uint8_t val);
 102
 103         // phase shift
 104         void shift_to_idle();
 105         void shift_to_cmd(int length);
 106         void shift_to_exec();
 107         void shift_to_read(int length);
 108         void shift_to_write(int length);
 109         void shift_to_scan(int length);
 110         void shift_to_result(int length);
 111         void shift_to_result7();
 112         void shift_to_result7_event();
 113         void start_transfer();
 114         void finish_transfer();
 115
 116         // command
 117         void process_cmd(int cmd);
 118         void cmd_sence_devstat();
 119         void cmd_sence_intstat();
 120         uint8_t get_devstat(int drv);
 121         void cmd_seek();
 122         void cmd_recalib();
 123         void seek(int drv, int trk);
 124         void seek_event(int drv);
 125         void cmd_read_data();
 126         void cmd_write_data();
 127         void cmd_scan();
 128         void cmd_read_diagnostic();
 129         void read_data(bool deleted, bool scan);
 130         void write_data(bool deleted);
 131         void read_diagnostic();
 132         uint32_t read_sector();
 133         uint32_t write_sector(bool deleted);
 134         uint32_t find_id();
 135         uint32_t check_cond(bool write);
 136         void get_sector_params();
 137         bool id_incr();
 138         void cmd_read_id();
 139         void cmd_write_id();
 140         uint32_t read_id();
 141         uint32_t write_id();
 142         void cmd_specify();
 143         void cmd_invalid();
 144         void update_head_flag(int drv, bool head_load);
 145
 146         void decl_state_fdc(int ch);
 147 public:
 148         UPD765A(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 149         {
 150                 initialize_output_signals(&outputs_irq);
 151                 initialize_output_signals(&outputs_drq);
 152                 initialize_output_signals(&outputs_hdu);
 153                 initialize_output_signals(&outputs_index);
 154                 d_noise_seek = NULL;
 155                 d_noise_head_down = NULL;
 156                 d_noise_head_up = NULL;
 157                 force_ready = false;
 158                 raise_irq_when_media_changed = false;
 159
 160                 _max_drive = 4;
 161                 _fdc_debug_log = false;
 162                 _upd765a_dma_mode = _upd765a_ext_drvsel = _upd765a_sence_intstat_result = false;
 163                 _upd765a_dont_wait_seek = _upd765a_no_st0_at_for_seek = false;
 164                 _upd765a_wait_result7 = _upd765a_no_st1_en_or_for_result7 = false;
 165                 set_device_name(_T("uPD765A FDC"));
 166         }
 167         ~UPD765A() {}
 168
 169         // common functions
 170         void initialize();
 171         void release();
 172         void reset();
 173         void write_io8(uint32_t addr, uint32_t data);
 174         uint32_t read_io8(uint32_t addr);
 175         void write_dma_io8(uint32_t addr, uint32_t data);
 176         uint32_t read_dma_io8(uint32_t addr);
 177         void write_signal(int id, uint32_t data, uint32_t mask);
 178         uint32_t read_signal(int ch);
 179         void event_callback(int event_id, int err);
 180         void update_config();
 181         //#ifdef USE_DEBUGGER
 182         void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
 183 //#endif
 184         void decl_state();
 185         void save_state(FILEIO* state_fio);
 186         bool load_state(FILEIO* state_fio);
 187
 188         // unique function
 189         void set_context_irq(DEVICE* device, int id, uint32_t mask)
 190         {
 191                 register_output_signal(&outputs_irq, device, id, mask);
 192         }
 193         void set_context_drq(DEVICE* device, int id, uint32_t mask)
 194         {
 195                 register_output_signal(&outputs_drq, device, id, mask);
 196         }
 197         void set_context_hdu(DEVICE* device, int id, uint32_t mask)
 198         {
 199                 register_output_signal(&outputs_hdu, device, id, mask);
 200         }
 201         void set_context_index(DEVICE* device, int id, uint32_t mask)
 202         {
 203                 register_output_signal(&outputs_index, device, id, mask);
 204         }
 205         void set_context_noise_seek(NOISE* device)
 206         {
 207                 d_noise_seek = device;
 208         }
 209         NOISE* get_context_noise_seek()
 210         {
 211                 return d_noise_seek;
 212         }
 213         void set_context_noise_head_down(NOISE* device)
 214         {
 215                 d_noise_head_down = device;
 216         }
 217         NOISE* get_context_noise_head_down()
 218         {
 219                 return d_noise_head_down;
 220         }
 221         void set_context_noise_head_up(NOISE* device)
 222         {
 223                 d_noise_head_up = device;
 224         }
 225         NOISE* get_context_noise_head_up()
 226         {
 227                 return d_noise_head_up;
 228         }
 229         DISK* get_disk_handler(int drv)
 230         {
 231                 if(drv < 4) {
 232                         return disk[drv];
 233                 }
 234                 return NULL;
 235         }
 236         void open_disk(int drv, const _TCHAR* file_path, int bank);
 237         void close_disk(int drv);
 238         bool is_disk_inserted(int drv);
 239         bool is_disk_inserted();        // current hdu
 240         bool disk_ejected(int drv);
 241         bool disk_ejected();    // current hdu
 242         void is_disk_protected(int drv, bool value);
 243         bool is_disk_protected(int drv);
 244         uint8_t media_type(int drv);
 245         void set_drive_type(int drv, uint8_t type);
 246         uint8_t get_drive_type(int drv);
 247         void set_drive_rpm(int drv, int rpm);
 248         void set_drive_mfm(int drv, bool mfm);
 249         bool raise_irq_when_media_changed;
 250 };
 251
 252 #endif
 253