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
  29 class UPD765A : public DEVICE
  30 {
  31 private:
  32         // output signals
  33         outputs_t outputs_irq;
  34         outputs_t outputs_drq;
  35         outputs_t outputs_hdu;
  36         outputs_t outputs_index;
  37
  38         // fdc
  39         struct {
  40                 uint8 track;
  41                 uint8 result;
  42                 bool access;
  43                 // timing
  44                 int cur_position;
  45                 int next_trans_position;
  46                 uint32 prev_clock;
  47         } fdc[4];
  48         DISK* disk[4];
  49
  50         uint8 hdu, hdue, id[4], eot, gpl, dtl;
  51
  52         int phase, prevphase;
  53         uint8 status, seekstat, command;
  54         uint32 result;
  55         int step_rate_time;
  56         bool no_dma_mode, motor_on;
  57 #ifdef UPD765A_DMA_MODE
  58         bool dma_data_lost;
  59 #endif
  60         bool irq_masked, drq_masked;
  61
  62         uint8* bufptr;
  63         uint8 buffer[0x8000];
  64         int count;
  65         int event_phase;
  66         int phase_id, drq_id, lost_id, result7_id, seek_id[4];
  67         bool force_ready;
  68         bool reset_signal;
  69         bool prev_index;
  70
  71         // timing
  72         uint32 prev_drq_clock;
  73
  74         int get_cur_position(int drv);
  75         double get_usec_to_exec_phase();
  76
  77         // update status
  78         void set_irq(bool val);
  79         void set_drq(bool val);
  80         void set_hdu(uint8 val);
  81
  82         // phase shift
  83         void shift_to_idle();
  84         void shift_to_cmd(int length);
  85         void shift_to_exec();
  86         void shift_to_read(int length);
  87         void shift_to_write(int length);
  88         void shift_to_scan(int length);
  89         void shift_to_result(int length);
  90         void shift_to_result7();
  91         void shift_to_result7_event();
  92
  93         // command
  94         void process_cmd(int cmd);
  95         void cmd_sence_devstat();
  96         void cmd_sence_intstat();
  97         uint8 get_devstat(int drv);
  98         void cmd_seek();
  99         void cmd_recalib();
 100         void seek(int drv, int trk);
 101         void seek_event(int drv);
 102         void cmd_read_data();
 103         void cmd_write_data();
 104         void cmd_scan();
 105         void cmd_read_diagnostic();
 106         void read_data(bool deleted, bool scan);
 107         void write_data(bool deleted);
 108         void read_diagnostic();
 109         uint32 read_sector();
 110         uint32 write_sector(bool deleted);
 111         uint32 find_id();
 112         uint32 check_cond(bool write);
 113         void get_sector_params();
 114         bool id_incr();
 115         void cmd_read_id();
 116         void cmd_write_id();
 117         uint32 read_id();
 118         uint32 write_id();
 119         void cmd_specify();
 120         void cmd_invalid();
 121 #if defined(_USE_AGAR) || defined(_USE_SDL) || defined(_USE_QT)
 122         uint8 __min(uint8 x, uint8 y) {
 123            if(x > y) return y;
 124            return x;
 125         }
 126         uint8 __max(uint8 x, uint8 y) {
 127            if(x < y) return y;
 128            return x;
 129         }
 130 #endif
 131
 132 public:
 133         UPD765A(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 134         {
 135                 init_output_signals(&outputs_irq);
 136                 init_output_signals(&outputs_drq);
 137                 init_output_signals(&outputs_hdu);
 138                 init_output_signals(&outputs_index);
 139                 raise_irq_when_media_changed = false;
 140         }
 141         ~UPD765A() {}
 142
 143         // common functions
 144         void initialize();
 145         void release();
 146         void reset();
 147         void write_io8(uint32 addr, uint32 data);
 148         uint32 read_io8(uint32 addr);
 149         void write_dma_io8(uint32 addr, uint32 data);
 150         uint32 read_dma_io8(uint32 addr);
 151         void write_signal(int id, uint32 data, uint32 mask);
 152         uint32 read_signal(int ch);
 153         void event_callback(int event_id, int err);
 154         void save_state(FILEIO* state_fio);
 155         bool load_state(FILEIO* state_fio);
 156
 157         // unique function
 158         void set_context_irq(DEVICE* device, int id, uint32 mask)
 159         {
 160                 register_output_signal(&outputs_irq, device, id, mask);
 161         }
 162         void set_context_drq(DEVICE* device, int id, uint32 mask)
 163         {
 164                 register_output_signal(&outputs_drq, device, id, mask);
 165         }
 166         void set_context_hdu(DEVICE* device, int id, uint32 mask)
 167         {
 168                 register_output_signal(&outputs_hdu, device, id, mask);
 169         }
 170         void set_context_index(DEVICE* device, int id, uint32 mask)
 171         {
 172                 register_output_signal(&outputs_index, device, id, mask);
 173         }
 174         DISK* get_disk_handler(int drv)
 175         {
 176                 return disk[drv];
 177         }
 178         void open_disk(int drv, _TCHAR path[], int bank);
 179         void close_disk(int drv);
 180         bool disk_inserted(int drv);
 181         bool disk_inserted();   // current hdu
 182         bool disk_ejected(int drv);
 183         bool disk_ejected();    // current hdu
 184         uint8 media_type(int drv);
 185         void set_drive_type(int drv, uint8 type);
 186         uint8 get_drive_type(int drv);
 187         void set_drive_rpm(int drv, int rpm);
 188         void set_drive_mfm(int drv, bool mfm);
 189         bool raise_irq_when_media_changed;
 190         void write_protect_fd(int drive, bool flag) {
 191           if((drive >= 4) || (drive < 0)) return;
 192           disk[drive]->write_protected = flag;
 193         }
 194         bool is_write_protect_fd(int drive) {
 195           if((drive >= 4) || (drive < 0)) return true; // Protected
 196           return disk[drive]->write_protected;
 197         }
 198 };
 199
 200 #endif
 201