source/src/vm/mz2500/mz1e30.cpp

   1 /*
   2         SHARP MZ-2500 Emulator 'EmuZ-2500'
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2004.09.10 -
   6
   7         [ MZ-1E30 (SASI I/F) ]
   8 */
   9
  10 #include "mz1e30.h"
  11
  12 #define STATUS_INT      0x00    // unknown
  13 #define STATUS_IXO      0x04
  14 #define STATUS_CXD      0x08
  15 #define STATUS_MSG      0x10
  16 #define STATUS_BSY      0x20
  17 #define STATUS_REQ      0x80
  18
  19 #define STATUS_IRQ      0
  20 #define STATUS_DRQ      0
  21
  22 void MZ1E30::initialize()
  23 {
  24         // rom file
  25         FILEIO* fio = new FILEIO();
  26         if(fio->Fopen(create_local_path(_T("MZ-1E30.ROM")), FILEIO_READ_BINARY) ||
  27            fio->Fopen(create_local_path(_T("SASI.ROM")), FILEIO_READ_BINARY) ||
  28            fio->Fopen(create_local_path(_T("FILE.ROM")), FILEIO_READ_BINARY)) {
  29                 fio->Fseek(0, FILEIO_SEEK_END);
  30                 if((rom_size = fio->Ftell()) > 0x1000000) {
  31                         rom_size = 0x1000000;
  32                 }
  33                 rom_buffer = (uint8_t*)malloc(rom_size);
  34
  35                 fio->Fseek(0, FILEIO_SEEK_SET);
  36                 fio->Fread(rom_buffer, rom_size, 1);
  37                 fio->Fclose();
  38         } else {
  39                 rom_size = 0;
  40                 rom_buffer = (uint8_t*)malloc(1);
  41         }
  42         delete fio;
  43         rom_address = 0;
  44 }
  45
  46 void MZ1E30::release()
  47 {
  48         if(rom_buffer != NULL) {
  49                 free(rom_buffer);
  50         }
  51 }
  52
  53 void MZ1E30::reset()
  54 {
  55         irq_status = drq_status = false;
  56 }
  57
  58 void MZ1E30::write_io8(uint32_t addr, uint32_t data)
  59 {
  60         switch(addr & 0xff) {
  61         case 0xa4:
  62                 #ifdef _SCSI_DEBUG_LOG
  63                         this->out_debug_log(_T("[MZ1E30] out %04X %02X\n"), addr, data);
  64                 #endif
  65                 d_host->write_dma_io8(addr, data);
  66                 break;
  67         case 0xa5:
  68                 #ifdef _SCSI_DEBUG_LOG
  69                         this->out_debug_log(_T("[MZ1E30] out %04X %02X\n"), addr, data);
  70                 #endif
  71                 d_host->write_signal(SIG_SCSI_RST, data, 0x40);
  72                 d_host->write_signal(SIG_SCSI_SEL, data, 0x20);
  73                 break;
  74         case 0xa8:
  75                 // rom file
  76                 rom_address = ((addr & 0xff00) << 8) | (data << 8) | (rom_address & 0x0000ff);
  77                 break;
  78         }
  79 }
  80
  81 uint32_t MZ1E30::read_io8(uint32_t addr)
  82 {
  83         uint32_t val = 0;
  84
  85         switch(addr & 0xff) {
  86         case 0xa4:
  87                 val = d_host->read_dma_io8(addr);
  88                 #ifdef _SCSI_DEBUG_LOG
  89                         this->out_debug_log(_T("[MZ1E30] in  %04X %02X\n"), addr, value);
  90                 #endif
  91                 return val;
  92         case 0xa5:
  93                 val = (d_host->read_signal(SIG_SCSI_REQ) ? STATUS_REQ : 0) |
  94 //                    (d_host->read_signal(SIG_SCSI_ACK) ? STATUS_ACK : 0) |
  95                       (d_host->read_signal(SIG_SCSI_BSY) ? STATUS_BSY : 0) |
  96                       (d_host->read_signal(SIG_SCSI_MSG) ? STATUS_MSG : 0) |
  97                       (d_host->read_signal(SIG_SCSI_CD ) ? STATUS_CXD : 0) |
  98                       (d_host->read_signal(SIG_SCSI_IO ) ? STATUS_IXO : 0) |
  99                       (irq_status                        ? STATUS_INT : 0);
 100                 irq_status = false;
 101                 #ifdef _SCSI_DEBUG_LOG
 102                         this->out_debug_log(_T("[MZ1E30] in  %04X %02X (REQ=%d,BSY=%d,MSG=%d,CxD=%d,IxO=%d)\n"), addr, val,
 103                                 (val & STATUS_REQ) ? 1 : 0,
 104                                 (val & STATUS_BSY) ? 1 : 0,
 105                                 (val & STATUS_MSG) ? 1 : 0,
 106                                 (val & STATUS_CXD) ? 1 : 0,
 107                                 (val & STATUS_IXO) ? 1 : 0);
 108                 #endif
 109                 return val;
 110         case 0xa9:
 111                 // rom file
 112                 rom_address = (rom_address & 0xffff00) | ((addr & 0xff00) >> 8);
 113                 if(rom_address < rom_size) {
 114                         return rom_buffer[rom_address];
 115                 }
 116                 break;
 117         }
 118         return 0xff;
 119 }
 120
 121 void MZ1E30::write_dma_io8(uint32_t addr, uint32_t data)
 122 {
 123         write_io8(0xa4, data);
 124 }
 125
 126 uint32_t MZ1E30::read_dma_io8(uint32_t addr)
 127 {
 128         return read_io8(0xa4);
 129 }
 130
 131 void MZ1E30::write_signal(int id, uint32_t data, uint32_t mask)
 132 {
 133         switch(id) {
 134         case SIG_MZ1E30_IRQ:
 135                 irq_status = ((data & mask) != 0);
 136                 break;
 137         case SIG_MZ1E30_DRQ:
 138                 drq_status = ((data & mask) != 0);
 139                 break;
 140         }
 141 }
 142
 143 #define STATE_VERSION   2
 144
 145 #include "../../statesub.h"
 146
 147 void MZ1E30::decl_state()
 148 {
 149         enter_decl_state(STATE_VERSION);
 150
 151         DECL_STATE_ENTRY_UINT32(rom_address);
 152         DECL_STATE_ENTRY_BOOL(irq_status);
 153         DECL_STATE_ENTRY_BOOL(drq_status);
 154
 155         leave_decl_state();
 156 }
 157
 158 void MZ1E30::save_state(FILEIO* state_fio)
 159 {
 160         if(state_entry != NULL) {
 161                 state_entry->save_state(state_fio);
 162         }
 163 //      state_fio->FputUint32(STATE_VERSION);
 164 //      state_fio->FputInt32(this_device_id);
 165
 166 //      state_fio->FputUint32(rom_address);
 167 //      state_fio->FputBool(irq_status);
 168 //      state_fio->FputBool(drq_status);
 169 }
 170
 171 bool MZ1E30::load_state(FILEIO* state_fio)
 172 {
 173         bool mb = false;
 174         if(state_entry != NULL) {
 175                 mb = state_entry->load_state(state_fio);
 176         }
 177         if(!mb) {
 178                 return false;
 179         }
 180 //      if(state_fio->FgetUint32() != STATE_VERSION) {
 181 //              return false;
 182 //      }
 183 //      if(state_fio->FgetInt32() != this_device_id) {
 184 //              return false;
 185 //      }
 186 //      rom_address = state_fio->FgetUint32();
 187 //      irq_status = state_fio->FgetBool();
 188 //      drq_status = state_fio->FgetBool();
 189         return true;
 190 }
 191
 192 bool MZ1E30::process_state(FILEIO* state_fio, bool loading)
 193 {
 194         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 195                 return false;
 196         }
 197         if(!state_fio->StateCheckInt32(this_device_id)) {
 198                 return false;
 199         }
 200         state_fio->StateUint32(rom_address);
 201         state_fio->StateBool(irq_status);
 202         state_fio->StateBool(drq_status);
 203         return true;
 204 }