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 //#if defined(USE_SOUND_FILES)
  28 #define UPD765A_SND_TBL_MAX 256
  29 #ifndef SIG_SOUNDER_MUTE
  30 #define SIG_SOUNDER_MUTE        (65536 + 0)
  31 #endif
  32 #ifndef SIG_SOUNDER_RELOAD
  33 #define SIG_SOUNDER_RELOAD      (65536 + 32)
  34 #endif
  35 #ifndef SIG_SOUNDER_ADD
  36 #define SIG_SOUNDER_ADD         (65536 + 64)
  37 #endif
  38
  39 #define UPD765A_SND_TYPE_SEEK 0
  40 #define UPD765A_SND_TYPE_HEAD 1
  41 //#endif
  42
  43 class DISK;
  44
  45 class UPD765A : public DEVICE
  46 {
  47 private:
  48         // output signals
  49         outputs_t outputs_irq;
  50         outputs_t outputs_drq;
  51         outputs_t outputs_hdu;
  52         outputs_t outputs_index;
  53
  54         // fdc
  55         struct {
  56                 uint8_t track;
  57                 uint8_t result;
  58                 bool access;
  59                 // timing
  60                 int cur_position;
  61                 int next_trans_position;
  62                 uint32_t prev_clock;
  63         } fdc[4];
  64         DISK* disk[4];
  65 //#if defined(USE_SOUND_FILES)
  66         int seek_snd_trk[4];
  67         int seek_snd_id[4];
  68 //#endif
  69         uint8_t hdu, hdue, id[4], eot, gpl, dtl;
  70
  71         int phase, prevphase;
  72         uint8_t status, seekstat, command;
  73         uint32_t result;
  74         int step_rate_time;
  75         bool no_dma_mode, motor_on;
  76 //#ifdef UPD765A_DMA_MODE
  77         bool dma_data_lost;
  78 //#endif
  79         bool irq_masked, drq_masked;
  80
  81         uint8_t* bufptr;
  82         uint8_t buffer[0x8000];
  83         int count;
  84         int event_phase;
  85         int phase_id, drq_id, lost_id, result7_id, seek_id[4];
  86
  87         bool force_ready;
  88         bool reset_signal;
  89         bool prev_index;
  90
  91         // timing
  92         uint32_t prev_drq_clock;
  93
  94         int get_cur_position(int drv);
  95         double get_usec_to_exec_phase();
  96
  97         // update status
  98         void set_irq(bool val);
  99         void set_drq(bool val);
 100         void set_hdu(uint8_t val);
 101
 102         // phase shift
 103         void shift_to_idle();
 104         void shift_to_cmd(int length);
 105         void shift_to_exec();
 106         void shift_to_read(int length);
 107         void shift_to_write(int length);
 108         void shift_to_scan(int length);
 109         void shift_to_result(int length);
 110         void shift_to_result7();
 111         void shift_to_result7_event();
 112
 113         // command
 114         void process_cmd(int cmd);
 115         void cmd_sence_devstat();
 116         void cmd_sence_intstat();
 117         uint8_t get_devstat(int drv);
 118         void cmd_seek();
 119         void cmd_recalib();
 120         void seek(int drv, int trk);
 121         void seek_event(int drv);
 122         void cmd_read_data();
 123         void cmd_write_data();
 124         void cmd_scan();
 125         void cmd_read_diagnostic();
 126         void read_data(bool deleted, bool scan);
 127         void write_data(bool deleted);
 128         void read_diagnostic();
 129         uint32_t read_sector();
 130         uint32_t write_sector(bool deleted);
 131         uint32_t find_id();
 132         uint32_t check_cond(bool write);
 133         void get_sector_params();
 134         bool id_incr();
 135         void cmd_read_id();
 136         void cmd_write_id();
 137         uint32_t read_id();
 138         uint32_t write_id();
 139         void cmd_specify();
 140         void cmd_invalid();
 141
 142 //#if defined(USE_SOUND_FILES)
 143         _TCHAR snd_seek_name[512];
 144         _TCHAR snd_head_name[512];
 145         int snd_seek_mix_tbl[UPD765A_SND_TBL_MAX];
 146         int snd_head_mix_tbl[UPD765A_SND_TBL_MAX];
 147         int16_t *snd_seek_data; // Read only
 148         int16_t *snd_head_data; // Read only
 149         int snd_seek_samples_size;
 150         int snd_head_samples_size;
 151         bool snd_mute;
 152         int snd_level_l, snd_level_r;
 153         virtual void mix_main(int32_t *dst, int count, int16_t *src, int *table, int samples);
 154         void add_sound(int type);
 155 //#endif
 156 public:
 157         UPD765A(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 158         {
 159                 initialize_output_signals(&outputs_irq);
 160                 initialize_output_signals(&outputs_drq);
 161                 initialize_output_signals(&outputs_hdu);
 162                 initialize_output_signals(&outputs_index);
 163                 force_ready = false;
 164                 raise_irq_when_media_changed = false;
 165                 set_device_name(_T("uPD765A FDC"));
 166 //#if defined(USE_SOUND_FILES)
 167                 for(int i = 0; i < UPD765A_SND_TBL_MAX; i++) {
 168                         snd_seek_mix_tbl[i] = -1;
 169                         snd_head_mix_tbl[i] = -1;
 170                 }
 171                 snd_seek_data = snd_head_data = NULL;
 172                 snd_seek_samples_size = snd_head_samples_size = 0;
 173                 snd_mute = false;
 174                 snd_level_l = snd_level_r = decibel_to_volume(0);
 175                 memset(snd_seek_name, 0x00, sizeof(snd_seek_name));
 176                 memset(snd_head_name, 0x00, sizeof(snd_head_name));
 177 //#endif
 178         }
 179         ~UPD765A() {}
 180
 181         // common functions
 182         void initialize();
 183         void release();
 184         void reset();
 185         void write_io8(uint32_t addr, uint32_t data);
 186         uint32_t read_io8(uint32_t addr);
 187         void write_dma_io8(uint32_t addr, uint32_t data);
 188         uint32_t read_dma_io8(uint32_t addr);
 189         void write_signal(int id, uint32_t data, uint32_t mask);
 190         uint32_t read_signal(int ch);
 191         void event_callback(int event_id, int err);
 192         void save_state(FILEIO* state_fio);
 193         bool load_state(FILEIO* state_fio);
 194         // unique function
 195         void set_context_irq(DEVICE* device, int id, uint32_t mask)
 196         {
 197                 register_output_signal(&outputs_irq, device, id, mask);
 198         }
 199         void set_context_drq(DEVICE* device, int id, uint32_t mask)
 200         {
 201                 register_output_signal(&outputs_drq, device, id, mask);
 202         }
 203         void set_context_hdu(DEVICE* device, int id, uint32_t mask)
 204         {
 205                 register_output_signal(&outputs_hdu, device, id, mask);
 206         }
 207         void set_context_index(DEVICE* device, int id, uint32_t mask)
 208         {
 209                 register_output_signal(&outputs_index, device, id, mask);
 210         }
 211         DISK* get_disk_handler(int drv)
 212         {
 213                 return disk[drv];
 214         }
 215 //#if defined(USE_SOUND_FILES)
 216         // Around SOUND. 20161004 K.O
 217         bool load_sound_data(int type, const _TCHAR *pathname);
 218         void release_sound_data(int type);
 219         bool reload_sound_data(int type);
 220
 221         void mix(int32_t *buffer, int cnt);
 222         void set_volume(int ch, int decibel_l, int decibel_r);
 223 //#endif
 224         void open_disk(int drv, const _TCHAR* file_path, int bank);
 225         void close_disk(int drv);
 226         bool is_disk_inserted(int drv);
 227         bool is_disk_inserted();        // current hdu
 228         bool disk_ejected(int drv);
 229         bool disk_ejected();    // current hdu
 230         void is_disk_protected(int drv, bool value);
 231         bool is_disk_protected(int drv);
 232         uint8_t media_type(int drv);
 233         void set_drive_type(int drv, uint8_t type);
 234         uint8_t get_drive_type(int drv);
 235         void set_drive_rpm(int drv, int rpm);
 236         void set_drive_mfm(int drv, bool mfm);
 237         bool raise_irq_when_media_changed;
 238 };
 239
 240 #endif
 241