OSDN Git Service

[VM] TRY:Use namespace {VMNAME} to separate around VMs. This feature still apply...
[csp-qt/common_source_project-fm7.git] / source / src / vm / fm7 / floppy.cpp
index fbe2787..8575cae 100644 (file)
@@ -19,6 +19,8 @@
 #include "hd6844.h"
 #endif
 
+namespace FM7 {
+       
 #define FDC_CMD_TYPE1          1
 #define FDC_CMD_RD_SEC         2
 #define FDC_CMD_RD_MSEC                3
 
 void FM7_MAINIO::reset_fdc(void)
 {
-       fdc_statreg = 0x00;
-       fdc_cmdreg = 0x00;
-       fdc_trackreg = 0x00;
-       fdc_sectreg = 0x00;
-       fdc_datareg = 0x00;
-       fdc_headreg = 0xfe;
-       fdc_drvsel = 0x7c;
+       if(connect_fdc) {
+               fdc_cmdreg = 0;
+               fdc_statreg = fdc->read_io8(0);
+               fdc_trackreg = fdc->read_io8(1);
+               fdc_sectreg = fdc->read_io8(2);
+               fdc_datareg = fdc->read_io8(3);
+               fdc_headreg = 0xfe | fdc->read_signal(SIG_MB8877_SIDEREG);
+               fdc_drvsel = 0x7c | fdc->read_signal(SIG_MB8877_DRIVEREG);
+               irqreg_fdc = 0x00; //0b00000000;
+       }
+       //fdc_motor = (fdc->read_signal(SIG_MB8877_MOTOR) != 0);
        fdc_motor = false;
-       fdc_cmd_type1 = false;
+       
 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
-       defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
-       fdc_reg_fd1e = 0x80;
-       for(int i = 0; i < 4; i++) {
-               fdc_drive_table[i] = (uint8)i;
-               fdc->set_drive_type(i, DRIVE_TYPE_2D);
+       defined(_FM77AV20) || defined(_FM77AV20EX)
+       if(connect_fdc) {
+               fdc_reg_fd1e = 0x80;
+               for(int i = 0; i < 4; i++) {
+                       fdc_drive_table[i] = (uint8_t)i;
+                       fdc->set_drive_type(i, DRIVE_TYPE_2D);
+               }
        }
-#endif 
-       irqreg_fdc = 0xff; //0b11111111;
+#else
        if(connect_fdc) {
-               extdet_neg = true;
-               irqreg_fdc = 0x1f; //0b00011111;
+               for(int i = 0; i < 4; i++) {
+                       fdc->set_drive_type(i, DRIVE_TYPE_2D);
+               }
        }
+#endif 
        if(event_fdc_motor >= 0) cancel_event(this, event_fdc_motor);
        event_fdc_motor = -1;
        irqstat_fdc = false;
-       irqreq_fdc = false;
        irqmask_mfd = true;
-       set_fdc_motor(fdc_motor);
+       if(connect_fdc) {
+               set_fdc_motor(fdc_motor);
+       }
 }
+       
 
 /* FDD */
 
-void FM7_MAINIO::set_fdc_cmd(uint8 val)
+void FM7_MAINIO::set_fdc_cmd(uint8_t val)
 {
        if(!connect_fdc) return;
        //irqreg_fdc = 0x00;
        fdc_cmdreg = val;
-       fdc_cmd_type1 = ((val & 0x80) == 0);
 #if defined(HAS_DMA)
        if(((fdc_cmdreg >= 0x80) && (fdc_cmdreg < 0xd0)) || (fdc_cmdreg >= 0xe0)) {
-               uint32 words = dmac->read_signal(HD6844_WORDS_REG_0);
+               uint32_t words = dmac->read_signal(HD6844_WORDS_REG_0);
                if((words != 0) && (words < 0xffff) && (dmac->read_signal(HD6844_IS_TRANSFER_0) == 0)) {
                        dmac->write_signal(HD6844_SRC_FIXED_ADDR_CH0, 3, 0xffffffff);
                        dmac->write_signal(HD6844_TRANSFER_START, 0, 0xffffffff);
-                       //p_emu->out_debug_log(_T("FDC: Start DMA CMDREG=%02x CHRN=%02x %02x %02x * DRVSEL=%08x\n"),
+                       //this->out_debug_log(_T("FDC: Start DMA CMDREG=%02x CHRN=%02x %02x %02x * DRVSEL=%08x\n"),
                        //                                       fdc_cmdreg, fdc_trackreg, fdc_headreg & 0x01, fdc_sectreg, fdc_drvsel);
                }
        }
 #endif 
        fdc->write_io8(0, val & 0x00ff);
-#ifdef _FM7_FDC_DEBUG  
-       p_emu->out_debug_log(_T("FDC: CMD: $%02x"), fdc_cmdreg);
-#endif 
+//#ifdef _FM7_FDC_DEBUG        
+       if(config.special_debug_fdc) out_debug_log(_T("FDC: CMD: $%02x"), fdc_cmdreg);
+//#endif       
 }
 
-uint8 FM7_MAINIO::get_fdc_stat(void)
+uint8_t FM7_MAINIO::get_fdc_stat(void)
 {
-       uint32 stat_backup = fdc_statreg;
+       //uint32_t stat_backup = fdc_statreg;
        if(!connect_fdc) return 0xff;
        fdc_statreg =  fdc->read_io8(0);
 #ifdef _FM7_FDC_DEBUG  
-       if(stat_backup != fdc_statreg) p_emu->out_debug_log(_T("FDC: \nGet Stat(not busy): $%02x"), fdc_statreg);
+       if(stat_backup != fdc_statreg) this->out_debug_log(_T("FDC: \nGet Stat(not busy): $%02x"), fdc_statreg);
 #endif 
        return fdc_statreg;
 }
 
-void FM7_MAINIO::set_fdc_track(uint8 val)
+void FM7_MAINIO::set_fdc_track(uint8_t val)
 {
        if(!connect_fdc) return;
        // if mode is 2DD and type-of-image = 2D then val >>= 1;
        
        fdc_trackreg = val;
 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
-       defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
-       uint32 d;
+       defined(_FM77AV20) || defined(_FM77AV20EX)
+       uint32_t d;
        if((fdc_drvsel & 0x40) == 0) {
                d = fdc_drive_table[fdc_drvsel & 0x03] & 0x03;
        } else {
                d = fdc_drvsel & 0x03;
        }
+#if 1
        DISK *disk = fdc->get_disk_handler(d);
        if(disk->media_type != MEDIA_TYPE_2D){
-               if(disk->drive_type == DRIVE_TYPE_2D) val <<= 1;
+               if(config.special_debug_fdc)  out_debug_log(_T("NOTE: MEDIA TYPE IS 2DD"));
+               //if(disk->drive_type == DRIVE_TYPE_2D) val <<= 1;
        } else { 
-               if(disk->drive_type != DRIVE_TYPE_2D) val >>= 1;
+               if(config.special_debug_fdc)  out_debug_log(_T("NOTE: MEDIA TYPE IS 2D"));
+               //if(disk->drive_type != DRIVE_TYPE_2D) val >>= 1;
        }
+#endif
 #endif 
        fdc->write_io8(1, val);
-#ifdef _FM7_FDC_DEBUG  
-       p_emu->out_debug_log(_T("FDC : Set Track: %d"), val);
-#endif 
+//#ifdef _FM7_FDC_DEBUG        
+       if(config.special_debug_fdc)  out_debug_log(_T("FDC : Set Track: %d"), val);
+//#endif       
 }
 
-uint8 FM7_MAINIO::get_fdc_track(void)
+uint8_t FM7_MAINIO::get_fdc_track(void)
 {
        if(!connect_fdc) return 0xff;
        fdc_trackreg = fdc->read_io8(1);
        return fdc_trackreg;
 }
 
-void FM7_MAINIO::set_fdc_sector(uint8 val)
+void FM7_MAINIO::set_fdc_sector(uint8_t val)
 {
        if(!connect_fdc) return;
        fdc_sectreg = val;
        fdc->write_io8(2, val);
-#ifdef _FM7_FDC_DEBUG  
-       p_emu->out_debug_log(_T("FDC: Set Sector: $%02x"), val);
-#endif 
+//#ifdef _FM7_FDC_DEBUG        
+       if(config.special_debug_fdc)  out_debug_log(_T("FDC: Set Sector: $%02x"), val);
+//#endif       
 }
 
-uint8 FM7_MAINIO::get_fdc_sector(void)
+uint8_t FM7_MAINIO::get_fdc_sector(void)
 {
        if(!connect_fdc) return 0xff;
        fdc_sectreg = fdc->read_io8(2);
        return fdc_sectreg;
 }
   
-void FM7_MAINIO::set_fdc_data(uint8 val)
+void FM7_MAINIO::set_fdc_data(uint8_t val)
 {
        if(!connect_fdc) return;
        fdc_datareg = val;
        fdc->write_io8(3, val & 0x00ff);
 }
 
-uint8 FM7_MAINIO::get_fdc_data(void)
+uint8_t FM7_MAINIO::get_fdc_data(void)
 {
        if(!connect_fdc) return 0xff;
        fdc_datareg = fdc->read_io8(3);
@@ -163,53 +177,62 @@ uint8 FM7_MAINIO::get_fdc_data(void)
        return fdc_datareg;
 }
 
-uint8 FM7_MAINIO::get_fdc_motor(void)
+uint8_t FM7_MAINIO::get_fdc_motor(void)
 {
-       uint8 val = 0x3c; //0b01111100;
+       uint8_t val = 0x3c; //0b01111100;
+       uint8_t drv;
+       bool bv;
+       
        if(!connect_fdc) return 0xff;
-       //fdc_motor = (fdc->read_signal(SIG_MB8877_MOTOR) != 0) ? true : false;
-       if(fdc_motor) val |= 0x80;
+       fdc_motor = (fdc->read_signal(SIG_MB8877_MOTOR) != 0) ? true : false;
        //fdc_drvsel = fdc->read_signal(SIG_MB8877_READ_DRIVE_REG);
+       drv = fdc_drvsel & 0x03;
        val = val | (fdc_drvsel & 0x03);
 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
-       defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
+       defined(_FM77AV20) || defined(_FM77AV20EX)
        val = val | (fdc_drvsel & 0x40);
+       if((fdc_drvsel & 0x40) != 0) {
+               drv = fdc_drive_table[drv & 0x03];
+       }
 #endif 
-#ifdef _FM7_FDC_DEBUG  
-       p_emu->out_debug_log(_T("FDC: Get motor/Drive: $%02x"), val);
-#endif 
+       fdc_motor = fdc_motor & (fdc->get_drive_type(drv) != DRIVE_TYPE_UNK);
+       if(fdc_motor) val |= 0x80;
+//#ifdef _FM7_FDC_DEBUG        
+       if(config.special_debug_fdc)  out_debug_log(_T("FDC: Get motor/Drive: $%02x"), val);
+//#endif       
        return val;
 }
   
-void FM7_MAINIO::set_fdc_fd1c(uint8 val)
+void FM7_MAINIO::set_fdc_fd1c(uint8_t val)
 {
        if(!connect_fdc) return;
        fdc_headreg = (val & 0x01) | 0xfe;
        fdc->write_signal(SIG_MB8877_SIDEREG, val, 0x01);
-#ifdef _FM7_FDC_DEBUG  
-       p_emu->out_debug_log(_T("FDC: Set side/head: $%02x"), val);
-#endif 
+//#ifdef _FM7_FDC_DEBUG        
+       if(config.special_debug_fdc)  out_debug_log(_T("FDC: Set side/head: $%02x"), val);
+//#endif       
 }
 
-uint8 FM7_MAINIO::get_fdc_fd1c(void)
+uint8_t FM7_MAINIO::get_fdc_fd1c(void)
 {
        if(!connect_fdc) return 0xff;
        //fdc_headreg = fdc->read_signal(SIG_MB8877_SIDEREG);
        return fdc_headreg;
 }
 
-void FM7_MAINIO::set_fdc_fd1d(uint8 val)
+void FM7_MAINIO::set_fdc_fd1d(uint8_t val)
 {
        bool backup_motor = fdc_motor;
+       bool f;
        if(!connect_fdc) return;
        if((val & 0x80) != 0) {
-               fdc_motor = true;
+               f = true;
        } else {
-               fdc_motor = false;
+               f = false;
        }
 
 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
-       defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
+       defined(_FM77AV20) || defined(_FM77AV20EX)
        if((val & 0x40) == 0) {
                fdc->write_signal(SIG_MB8877_DRIVEREG, fdc_drive_table[val & 0x03], 0x03);
        } else {
@@ -221,41 +244,39 @@ void FM7_MAINIO::set_fdc_fd1d(uint8 val)
        fdc_drvsel = val;
 #endif 
 
-       if(fdc_motor != backup_motor) {
+       if(f != backup_motor) {
                if(event_fdc_motor >= 0) cancel_event(this, event_fdc_motor);
-               if(fdc_motor) {
+               if(f) {
                        register_event(this, EVENT_FD_MOTOR_ON, 1000.0 * 300.0, false, &event_fdc_motor); // Motor ON After 0.3Sec.
                } else {
                        register_event(this, EVENT_FD_MOTOR_OFF, 1000.0 * 50.0, false, &event_fdc_motor); // Motor OFF After 0.05Sec.
                }
-               //fdc->write_signal(SIG_MB8877_MOTOR, fdc_motor ? 0x01 : 0x00, 0x01);
        }
-#ifdef _FM7_FDC_DEBUG  
-       p_emu->out_debug_log(_T("FDC: Set Drive Select: $%02x"), val);
-#endif 
+//#ifdef _FM7_FDC_DEBUG        
+       if(config.special_debug_fdc)  out_debug_log(_T("FDC: Set Drive Select: $%02x"), val);
+//#endif       
 }
 
-uint8 FM7_MAINIO::get_fdc_fd1e(void)
+uint8_t FM7_MAINIO::get_fdc_fd1e(void)
 {
 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
-       defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
-       uint8 val = 0xa0;
-//     if(fdc->get_drive_type(fdc_drvsel & 0x03) == DRIVE_TYPE_2D) {
-//             val |= 0x40;
-//     }
-//     val |= (fdc_reg_fd1e & 0x1f);
+       defined(_FM77AV20) || defined(_FM77AV20EX)
+       uint8_t val = 0xa0;
        val |= (fdc_reg_fd1e & 0x5f);
+       if(config.special_debug_fdc) out_debug_log(_T("FDC: GET $FD1E value=$%02x"), val);
        return val;
 #else
+       //if(config.special_debug_fdc) out_debug_log(_T("FDC: GET $FD1E value=$%02x"), val);
        return 0xff;
 #endif
 }      
 
-void FM7_MAINIO::set_fdc_fd1e(uint8 val)
+void FM7_MAINIO::set_fdc_fd1e(uint8_t val)
 {
 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
-       defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
-       uint8 drive;
+       defined(_FM77AV20) || defined(_FM77AV20EX)
+       uint8_t drive;
+       if(!connect_fdc) return;
        
        fdc_reg_fd1e = val;
        
@@ -267,27 +288,31 @@ void FM7_MAINIO::set_fdc_fd1e(uint8 val)
        }
        if((val & 0x40) != 0) {
                for(drive = 0; drive < MAX_DRIVE; drive++) fdc->set_drive_type(drive, DRIVE_TYPE_2D);
-               //emu->out_debug_log(_T("2D\n"));
+               if(config.special_debug_fdc) out_debug_log(_T("SET DRIVE to 2D"));
        } else {
                for(drive = 0; drive < MAX_DRIVE; drive++) fdc->set_drive_type(drive, DRIVE_TYPE_2DD);
-               //emu->out_debug_log(_T("2DD\n"));
+               if(config.special_debug_fdc) out_debug_log(_T("SET DRIVE to 2DD"));
        }
+       if(config.special_debug_fdc) out_debug_log(_T("FDC: SET $FD1E value=$%02x"), val);
 #endif 
 }
+
 void FM7_MAINIO::set_irq_mfd(bool flag)
 {
-#if !defined(_FM8) // Which FM77?
        bool backup = irqstat_fdc;
-       irqreq_fdc = flag;
        if(!connect_fdc) return;
        if(flag) {
                irqreg_fdc |= 0x40; //0b01000000;
        } else {
                irqreg_fdc &= 0xbf; //0b10111111;
        }
+#if defined(_FM77_VARIANTS)
+       flag = flag & !(intmode_fdc);
+#endif
+//#if !defined(_FM8) // With FM8, $FD1F is alive and not do_irq(), Thanks to Anna_Wu.
        irqstat_fdc = flag & !irqmask_mfd;
        if(backup != irqstat_fdc) do_irq();
-#endif
+//#endif
        return;
 }
 
@@ -307,15 +332,28 @@ void FM7_MAINIO::set_drq_mfd(bool flag)
        return;
 }
 
-uint8 FM7_MAINIO::fdc_getdrqirq(void)
+uint8_t FM7_MAINIO::fdc_getdrqirq(void)
 {
-       uint8 val = irqreg_fdc | 0x3f;
-       if((fdc->read_io8(0) & 0x01) == 0) val |= 0x40; // Workaround of 太陽の神殿
-       irqreg_fdc |= 0x20; //0b00100000;
+       uint8_t val = irqreg_fdc | 0x3f;
+       if(!connect_fdc) return 0xff;
        return val;
 }
 
 void FM7_MAINIO::set_fdc_motor(bool flag)
 {
+       if(!connect_fdc) return;
+       uint8_t val;
        fdc->write_signal(SIG_MB8877_MOTOR, flag ? 0x01 : 0x00, 0x01);
+       val = fdc_drvsel & 0x03;
+#if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
+       defined(_FM77AV20) || defined(_FM77AV20EX)
+       if((fdc_drvsel & 0x40) == 0) {
+               val = fdc_drive_table[val & 0x03];
+       }
+#endif
+       fdc_motor = (fdc->read_signal(SIG_MB8877_MOTOR) != 0);
+       fdc_motor = fdc_motor & (fdc->get_drive_type(val) != DRIVE_TYPE_UNK);
+       if(config.special_debug_fdc) out_debug_log(_T("FDC: MOTOR=%d VAL=$%02x"), flag, val);
+}
+
 }