Esempio n. 1
0
 public RzxHandler(Z80CPU cpu, BusManager busMgr)
 {
     m_cpu = cpu;
       m_busMgr = busMgr;
       IsPlayback = false;
       IsRecording = false;
 }
Esempio n. 2
0
        public void BusInit(IBusManager bmgr)
        {
            bmgr.SubscribeRDIO(0x99, 0x98, readPortFE);
            bmgr.SubscribeRDIO(0x99, 0x18, readPort7E);

            bmgr.SubscribeNMIACK(NMIACK);

            m_cpu = bmgr.CPU;
        }
Esempio n. 3
0
        public override void BusInit(IBusManager bmgr)
        {
            base.BusInit(bmgr);
            m_cpu = bmgr.CPU;

            bmgr.SubscribeWRIO(0x801A, 0x7FFD & 0x801A, busWritePort7FFD);
            bmgr.SubscribeWRIO(0x0099, 0x0000 & 0x0099, busWritePort0000);
            bmgr.SubscribeRESET(busReset);
            bmgr.SubscribeNMIACK(busNmi);
        }
Esempio n. 4
0
 public override void BusInit(IBusManager bmgr)
 {
     base.BusInit(bmgr);
     this.m_cpu = bmgr.CPU;
     this.m_betaDisk = bmgr.FindDevice(typeof(IBetaDiskDevice)) as IBetaDiskDevice;
     bmgr.SubscribeWRIO(0x801a, 0x18, new BusWriteIoProc(this.busWritePort7FFD));
     bmgr.SubscribeWRIO(0x91, 0, new BusWriteIoProc(this.busWritePort0000));
     bmgr.SubscribeWRIO(0xA00D, 0x800D, new BusWriteIoProc(this.busWritePort80FD)); // 80FD
     bmgr.SubscribeRDIO(0xA00D, 0x800D, new BusReadIoProc(this.busReadPort80FD)); // 80FD
     bmgr.SubscribeRESET(new BusSignalProc(this.busReset));
 }
Esempio n. 5
0
        public override void BusInit(IBusManager bmgr)
        {
            base.BusInit(bmgr);
            m_cpu = bmgr.CPU;
            m_ulaProfi = bmgr.FindDevice<UlaProfi3XX>();

            bmgr.SubscribeWRIO(0x8002, 0x0000, writePort7FFD);
            bmgr.SubscribeWRIO(0xFFFF, 0xDFFD, writePortDFFD);
            bmgr.SubscribeRDMEM_M1(0xC000, 0x4000, readRamM1);
            bmgr.SubscribeRDMEM_M1(0xC000, 0x8000, readRamM1);
            bmgr.SubscribeRDMEM_M1(0xC000, 0xC000, readRamM1);

            bmgr.SubscribeRESET(busReset);
        }
Esempio n. 6
0
        public void BusInit(IBusManager bmgr)
        {
            m_betaDisk = (WD1793)bmgr.FindDevice(typeof(WD1793));
            m_cpu = bmgr.CPU;

            bmgr.SubscribeWRIO(0x9f, 0x80, new BusWriteIoProc(this.busWritePortCMD));
            bmgr.SubscribeWRIO(0x9f, 0x81, new BusWriteIoProc(this.busWritePortTRK));
            bmgr.SubscribeWRIO(0x9f, 0x82, new BusWriteIoProc(this.busWritePortSEC));
            bmgr.SubscribeWRIO(0x9f, 0x83, new BusWriteIoProc(this.busWritePortDAT));
            bmgr.SubscribeWRIO(0x9f, 0x85, new BusWriteIoProc(this.busWritePortSYS));
            bmgr.SubscribeRDIO(0x9f, 0x80, new BusReadIoProc(this.busReadPortCMD));
            bmgr.SubscribeRDIO(0x9f, 0x81, new BusReadIoProc(this.busReadPortTRK));
            bmgr.SubscribeRDIO(0x9f, 0x82, new BusReadIoProc(this.busReadPortSEC));
            bmgr.SubscribeRDIO(0x9f, 0x83, new BusReadIoProc(this.busReadPortDAT));
            bmgr.SubscribeRDIO(0x9f, 0x85, new BusReadIoProc(this.busReadPortSYS));
        }
Esempio n. 7
0
        public override void BusInit(IBusManager bmgr)
        {
            base.BusInit(bmgr);

            m_cpu = bmgr.CPU;
            m_ulaAtm = base.m_ula as UlaAtm450;

            bmgr.SubscribeRDIO(0x0001, 0x0000, busReadPortFE);      // bit Z emulation
            bmgr.SubscribeWRIO(0x0001, 0x0000, busWritePortFE);
            bmgr.SubscribeRDIO(0x0004, 0x00FB & 0x0004, busReadPortFB);   // CPSYS [(addr & 0x7F)==0x7B]

            bmgr.SubscribeWRIO(0x8202, 0x7FFD & 0x8202, busWritePort7FFD);
            bmgr.SubscribeWRIO(0x8202, 0xFDFD & 0x8202, busWritePortFDFD);

            bmgr.SubscribeWRIO(0x8202, 0x7DFD & 0x8202, busWritePort7DFD); // atm_writepal(val);

            bmgr.SubscribeRESET(busReset);
        }
Esempio n. 8
0
 public SpectrumConcrete()
 {
     _loader = new LoadManager(this);
     _cpu = new Z80CPU();
     _bus = new BusManager();
 }
Esempio n. 9
0
        public override void BusInit(IBusManager bmgr)
        {
            m_cpu = bmgr.CPU;
            m_sandbox = bmgr.IsSandbox;
            m_memory = bmgr.FindDevice<IMemoryDevice>();

            bmgr.SubscribeRDMEM_M1(0xFF00, 0x3D00, BusReadMem3D00_M1);
            bmgr.SubscribeRDMEM_M1(0xC000, 0x4000, BusReadMemRam);
            bmgr.SubscribeRDMEM_M1(0xC000, 0x8000, BusReadMemRam);
            bmgr.SubscribeRDMEM_M1(0xC000, 0xC000, BusReadMemRam);
            bmgr.SubscribeBeginFrame(BusBeginFrame);
            bmgr.SubscribeEndFrame(BusEndFrame);

            BusSubscribeWD93IO(bmgr);

            bmgr.SubscribeRESET(BusReset);
            bmgr.SubscribeNMIACK(BusNmi);

            foreach (var fs in FDD[0].SerializeManager.GetSerializers())
            {
                bmgr.AddSerializer(fs);
            }
            bmgr.RegisterIcon(m_iconRd);
            bmgr.RegisterIcon(m_iconWr);
        }
Esempio n. 10
0
 public DasmUtils(Z80CPU cpu, OnRDBUS reader)
 {
     Object = cpu;
     memReader = reader;
 }
Esempio n. 11
0
        public override void BusInit(IBusManager bmgr)
        {
            m_cpu = bmgr.CPU;
            m_sandbox = bmgr.IsSandbox;
            m_memory = bmgr.FindDevice<IMemoryDevice>();

            bmgr.SubscribeRDMEM_M1(0xFF00, 0x3D00, BusReadMem3D00_M1);
            bmgr.SubscribeRDMEM_M1(0xC000, 0x4000, BusReadMemRam);
            bmgr.SubscribeRDMEM_M1(0xC000, 0x8000, BusReadMemRam);
            bmgr.SubscribeRDMEM_M1(0xC000, 0xC000, BusReadMemRam);

            BusSubscribeWD93IO(bmgr);

            bmgr.SubscribeRESET(BusReset);
            bmgr.SubscribeNMIACK(BusNmi);

            foreach (FormatSerializer fs in FDD[0].SerializeManager.GetSerializers())
                bmgr.AddSerializer(fs);
        }
Esempio n. 12
0
        public override void BusInit(IBusManager bmgr)
        {
            m_cpu = bmgr.CPU;
            var ula = bmgr.FindDevice<IUlaDevice>();
            var memory = bmgr.FindDevice<IMemoryDevice>();
            initTiming(m_sampleRate, ula.FrameTactCount);

            if (memory is ZXMAK2.Hardware.Spectrum.MemorySpectrum128 ||
                memory is ZXMAK2.Hardware.Spectrum.MemoryPlus3)
            {
                bmgr.SubscribeWRIO(0xC002, 0xC000, writePortAddr);   // #FFFD (reg#)
                bmgr.SubscribeRDIO(0xC002, 0xC000, readPortData);    // #FFFD (rd data/reg#)
                bmgr.SubscribeWRIO(0xC002, 0x8000, writePortData);   // #BFFD (data)
            }
            else
            {
                bmgr.SubscribeWRIO(0xC0FF, 0xC0FD, writePortAddr);   // #FFFD (reg#)
                bmgr.SubscribeRDIO(0xC0FF, 0xC0FD, readPortData);    // #FFFD (rd data/reg#)
                bmgr.SubscribeWRIO(0xC0FF, 0x80FD, writePortData);   // #BFFD (data)
            }

            bmgr.SubscribeRESET(busReset);

            bmgr.SubscribeBeginFrame(BeginFrame);
            bmgr.SubscribeEndFrame(EndFrame);
        }
Esempio n. 13
0
 public void BusInit(IBusManager bmgr)
 {
     this.m_cpu = bmgr.CPU;
     IUlaDevice device = (IUlaDevice)bmgr.FindDevice(typeof(IUlaDevice));
     this.FrameTactCount = device.FrameTactCount;
     bmgr.SubscribeWRIO(0x99, 0x98, new BusWriteIoProc(this.writePortFE));
     bmgr.SubscribeBeginFrame(new BusFrameEventHandler(this.BeginFrame));
     bmgr.SubscribeEndFrame(new BusFrameEventHandler(this.EndFrame));
 }
Esempio n. 14
0
        public override void BusInit(IBusManager bmgr)
        {
            base.BusInit(bmgr);

            m_cpu = bmgr.CPU;
            m_ulaAtm = base.m_ula as UlaAtm450;

            bmgr.SubscribeRDIO(0x0001, 0x0000, busReadPortFE);					// bit Z emulation
            bmgr.SubscribeWRIO(0x009F, 0x00FF & 0x009F, busWritePortXXFF_PAL);	// atm_writepal(val);
            bmgr.SubscribeRDIO(0x8202, 0x7FFD & 0x8202, busReadPort7FFD);					// bit Z emulation

            bmgr.SubscribeWRIO(0x00FF, 0xFF77 & 0x00FF, busWritePortFF77_SYS);
            bmgr.SubscribeWRIO(0x00FF, 0x3FF7 & 0x00FF, busWritePortXFF7_WND);	//ATM3 mask=0x3FFF
            bmgr.SubscribeWRIO(0x8202, 0x7FFD & 0x8202, busWritePort7FFD_128);

            bmgr.SubscribeRESET(busReset);
        }
Esempio n. 15
0
 public override void BusInit(IBusManager bmgr)
 {
     base.BusInit(bmgr);
     this.m_cpu = bmgr.CPU;
     this.m_betaDisk = bmgr.FindDevice(typeof(IBetaDiskDevice)) as IBetaDiskDevice;
     bmgr.SubscribeWRIO(0x801a, 0x18, new BusWriteIoProc(this.busWritePort7FFD));
     bmgr.SubscribeWRIO(0xA01A, 0x8018, new BusWriteIoProc(this.busWritePort80FD));
     bmgr.SubscribeWRIO(0x91, 0, new BusWriteIoProc(this.busWritePort0000));
     bmgr.SubscribeRESET(new BusSignalProc(this.busReset));
     bmgr.SubscribeNMIACK(new BusSignalProc(this.busNmi));
     if (this.m_betaDisk != null)
     {
         bmgr.SubscribeWRIO(0x9f, 0x80, new BusWriteIoProc(this.busWritePortCMD));
         bmgr.SubscribeWRIO(0x9f, 0x81, new BusWriteIoProc(this.busWritePortTRK));
         bmgr.SubscribeWRIO(0x9f, 130, new BusWriteIoProc(this.busWritePortSEC));
         bmgr.SubscribeWRIO(0x9f, 0x83, new BusWriteIoProc(this.busWritePortDAT));
         bmgr.SubscribeWRIO(0x9f, 0x85, new BusWriteIoProc(this.busWritePortSYS));
         bmgr.SubscribeRDIO(0x9f, 0x80, new BusReadIoProc(this.busReadPortCMD));
         bmgr.SubscribeRDIO(0x9f, 0x81, new BusReadIoProc(this.busReadPortTRK));
         bmgr.SubscribeRDIO(0x9f, 130, new BusReadIoProc(this.busReadPortSEC));
         bmgr.SubscribeRDIO(0x9f, 0x83, new BusReadIoProc(this.busReadPortDAT));
         bmgr.SubscribeRDIO(0x9f, 0x85, new BusReadIoProc(this.busReadPortSYS));
     }
 }
Esempio n. 16
0
        public override void BusInit(IBusManager bmgr)
        {
            base.BusInit(bmgr);
            m_cpu = bmgr.CPU;
            m_memory = bmgr.FindDevice<IMemoryDevice>();

            bmgr.SubscribeRDIO(0x0001, 0x0000, readPortFE);

            bmgr.SubscribePreCycle(busPreCycle);

            bmgr.AddSerializer(new TapSerializer(this));
            bmgr.AddSerializer(new TzxSerializer(this));
            bmgr.AddSerializer(new CswSerializer(this));
            bmgr.AddSerializer(new WavSerializer(this));
            bmgr.RegisterIcon(m_iconTape);
        }
Esempio n. 17
0
        public override void BusInit(IBusManager bmgr)
        {
            base.BusInit(bmgr);
            this.m_cpu = bmgr.CPU;

            this.m_ulaSprinter = bmgr.FindDevice<SprinterULA>();
            if (this.m_ulaSprinter != null)
            {
                this.m_ulaSprinter.VRAM = m_vramPages;
            }
            else
            {
                throw new ApplicationException("SprinterULA not found");
            }
            this.m_SprinterBDI = bmgr.FindDevice<SprinterBDI>();
            if (this.m_SprinterBDI == null)
            {
                throw new ApplicationException("SprinterBDI not found");
            }
            bmgr.SubscribeWRIO(0x0000, 0x0000, new BusWriteIoProc(this.WRDCP));  //write to DCP Port
            bmgr.SubscribeRDIO(0x0000, 0x0000, new BusReadIoProc(this.RDDCP));    //read from DCP port
            bmgr.SubscribeWRIO(0x00ff, 0x0082, new BusWriteIoProc(this.writePort82h));  //write PAGE0
            bmgr.SubscribeRDIO(0x00ff, 0x0082, new BusReadIoProc(this.readPort82h));    //read PAGE0
            bmgr.SubscribeWRIO(0x00ff, 0x00A2, new BusWriteIoProc(this.writePortA2h));  //write PAGE1
            bmgr.SubscribeRDIO(0x00ff, 0x00A2, new BusReadIoProc(this.readPortA2h));    //read PAGE1
            bmgr.SubscribeWRIO(0x00ff, 0x00C2, new BusWriteIoProc(this.writePortC2h));  //write PAGE2
            bmgr.SubscribeRDIO(0x00ff, 0x00C2, new BusReadIoProc(this.readPortC2h));    //read PAGE2
            bmgr.SubscribeWRIO(0x00ff, 0x00E2, new BusWriteIoProc(this.writePortE2h));  //write PAGE3
            bmgr.SubscribeRDIO(0x00ff, 0x00E2, new BusReadIoProc(this.readPortE2h));    //read PAGE3
            bmgr.SubscribeWRIO(0xd027, 0x5025, new BusWriteIoProc(this.writePort7FFDh));    //write 7FFDh
            bmgr.SubscribeWRIO(0xd027, 0x1025, new BusWriteIoProc(this.writePort1FFDh));  //write 1FFDh
            bmgr.SubscribeRDIO(0x00ff, 0x00fb, new BusReadIoProc(this.readPortFBh));  //read FBh  Open Cash
            bmgr.SubscribeRDIO(0x00ff, 0x007b, new BusReadIoProc(this.readPort7Bh));  //read 7Bh  Close Cash
            bmgr.SubscribeWRIO(0x00BD, 0x003c, new BusWriteIoProc(this.writePort7Ch));  //write 7Ch
            bmgr.SubscribeWRIO(0x00FF, 0x0089, new BusWriteIoProc(this.writePort89h));  //write PORTY
            bmgr.SubscribeWRIO(0x00FF, 0x00C9, new BusWriteIoProc(this.writePortC9h));  //write C9h
            bmgr.SubscribeWRIO(0x00FF, 0x00E9, new BusWriteIoProc(this.writePortE9h));  //write E9h
            bmgr.SubscribeRDIO(0x00ff, 0x0089, new BusReadIoProc(this.readPort89h));  //read PORTY
            bmgr.SubscribeRDIO(0x00ff, 0x00E9, new BusReadIoProc(this.readPortE9h));  //read E9h
            bmgr.SubscribeRDIO(0x00ff, 0x00C9, new BusReadIoProc(this.readPortC9h));  //read C9h
            bmgr.SubscribeWRMEM(0xC000, 0x0000, new BusWriteProc(this.WriteMem0000));  //write
            bmgr.SubscribeWRMEM(0xC000,0x4000, new BusWriteProc(this.WriteMem4000));  //write
            bmgr.SubscribeWRMEM(0xC000, 0x8000, new BusWriteProc(this.WriteMem8000));  //write
            bmgr.SubscribeWRMEM(0xC000, 0xC000, new BusWriteProc(this.WriteMemC000));  //write
            bmgr.SubscribeRDMEM(0xC000, 0x0000, new BusReadProc(this.ReadMem0000));  //read
            bmgr.SubscribeRDMEM(0xC000, 0x8000, new BusReadProc(this.ReadMem8000));  //read
            bmgr.SubscribeRDMEM(0xC000, 0xC000, new BusReadProc(this.ReadMemC000));  //read
            bmgr.SubscribeRDMEM(0xC000, 0x4000, new BusReadProc(this.ReadMem4000));  //read
            bmgr.SubscribeRDIO(0xFFFF, 0, new BusReadIoProc(this.readPort00h));  //read 0
            bmgr.SubscribeRDMEM_M1(0x0000, 0x0000, new BusReadProc(this.Accelerator));
            bmgr.SubscribeRDMEM(0x0000, 0x0000, new BusReadProc(this.AccelRead));
            bmgr.SubscribeWRMEM(0x0000, 0x0000, new BusWriteProc(this.AccelWrite));

            #if Debug
            bmgr.SubscribeRDMEM_M1(0x0000, 0x0000, new BusReadProc(this.readRamM1));  //read operator from memory
            #endif
            bmgr.SubscribeRESET(new BusSignalProc(this.busReset));
        }
        public override void BusInit(IBusManager bmgr)
        {
            m_sndQueue.Clear();
            m_cpu = bmgr.CPU;
            var ula = bmgr.FindDevice<IUlaDevice>();
            FrameTactCount = ula.FrameTactCount;

            bmgr.SubscribeBeginFrame(BeginFrame);
            bmgr.SubscribeEndFrame(EndFrame);
        }
Esempio n. 19
0
        public override void BusInit(IBusManager bmgr)
        {
            m_page0000 = -1;
            m_page4000 = 5;
            m_page8000 = 2;
            m_pageC000 = 0;
            m_videoPage = 5;

            CPU = bmgr.CPU;
            Memory = bmgr.FindDevice<IMemoryDevice>();

            bmgr.SubscribeWRMEM(0xC000, 0x0000, WriteMem0000);
            bmgr.SubscribeWRMEM(0xC000, 0x4000, WriteMem4000);
            bmgr.SubscribeWRMEM(0xC000, 0x8000, WriteMem8000);
            bmgr.SubscribeWRMEM(0xC000, 0xC000, WriteMemC000);

            bmgr.SubscribeWRIO(0x0001, 0x0000, WritePortFE);

            bmgr.SubscribeBeginFrame(BeginFrame);
            bmgr.SubscribeEndFrame(EndFrame);

            bmgr.AddSerializer(new ScrSerializer(this));
            bmgr.AddSerializer(new BmpSerializer(this));
            bmgr.AddSerializer(new JpgSerializer(this));
            bmgr.AddSerializer(new PngSerializer(this));
        }
Esempio n. 20
0
 public override void BusInit(IBusManager bmgr)
 {
     base.BusInit(bmgr);
     this.m_cpu = bmgr.CPU;
     //bmgr.SubscribeWRIO(0x00FF, 0x0089, new BusWriteIoProc(this.writePort89h));  //write 89h
     bmgr.SubscribeRESET(new BusSignalProc(this.busReset));
 }