Esempio n. 1
0
        private void AccelRead(ushort addr, ref byte value)
        {
            if (m_acc_enable && m_acc_on && (m_acc_mode!=AccelCMD.Off))
            {
                ;
                switch (m_acc_mode)
                {
                    case AccelCMD.On:           //LD D,D
                        {
                            if (value != 0) m_acc_buf_size = value;
                                else m_acc_buf_size = 256;
                        } break;

                    case AccelCMD.CopyBlok:     //LD L,L
                        {
                            for (int i = 0; i < m_acc_buf_size; i++)
                            {
                                byte tmp = 0;
                                switch ((addr + i) & 0xc000)
                                {
                                    case 0x0000: this.ReadMem0000((ushort)(addr + i), ref tmp); break;
                                    case 0x4000: this.ReadMem4000((ushort)(addr + i), ref tmp); break;
                                    case 0x8000: this.ReadMem8000((ushort)(addr + i), ref tmp); break;
                                    case 0xc000: this.ReadMemC000((ushort)(addr + i), ref tmp); break;
                                }
                                switch (m_acc_submode)
                                {

                                    case AccelSubCMD.None:      //CopyBlok
                                        {
                                            m_acc_buf[i] = tmp;//RDMEM_DBG((ushort)(addr + i));
                                        } break;
                                    case AccelSubCMD.XORBlok:      //XOR (HL)
                                        {
                                            m_acc_buf[i] ^= tmp;

                                        } break;
                                    case AccelSubCMD.ORBlok:       //OR (HL)
                                        {
                                            m_acc_buf[i] |= tmp;

                                        } break;
                                    case AccelSubCMD.ANDBlok:      //AND (HL)
                                        {
                                            m_acc_buf[i] &= tmp;
                                        } break;
                                }

                            }
                            m_acc_submode = AccelSubCMD.None;
                        } break;

                    case AccelCMD.GrCopyBlok:   //LD A,A
                        {
                            for (int i = 0; i < m_acc_buf_size; i++)
                            {
                                byte tmp = 0;
                                switch (addr & 0xc000)
                                {
                                    case 0x0000: this.ReadMem0000((ushort)(addr), ref tmp); break;
                                    case 0x4000: this.ReadMem4000((ushort)(addr), ref tmp); break;
                                    case 0x8000: this.ReadMem8000((ushort)(addr), ref tmp); break;
                                    case 0xc000: this.ReadMemC000((ushort)(addr), ref tmp); break;
                                }
                                switch (m_acc_submode) {
                                    case AccelSubCMD.None:m_acc_buf[i] = tmp;//RDMEM_DBG((ushort)(addr + i));
                                        break;
                                    case AccelSubCMD.XORBlok: m_acc_buf[i] ^= tmp; break;
                                    case AccelSubCMD.ORBlok: m_acc_buf[i] |= tmp; break;
                                    case AccelSubCMD.ANDBlok: m_acc_buf[i] &= tmp; break;
                                }
                                //m_acc_buf[i] = VRamPages[(m_port_y & 0xf0) >> 4][(m_port_y & 0x0f) * 1024 + (addr & 0x3FF)]; //this.RDMEM_DBG(addr);
                                m_port_y++;
                            }
                            m_acc_submode = AccelSubCMD.None;
                        } break;
                    case AccelCMD.GrFill:   //LD E,E
                        {
                            for (int i = 0; i < m_acc_buf_size; i++)
                                m_port_y++;
                        } break;

                }
            }
        }
Esempio n. 2
0
        /*
         * private void GetAccelDATA(ushort addr, ref byte value)
         * {
         *  if (_accEnable && _accOn && _accWaitData)
         *  {
         *  }
         * }
         */

        private void Accelerator(ushort addr, ref byte value)
        {
            if (!_accEnable || value < 0x40)
            {
                return;
            }
            switch (value)//this.RDMEM_DBG(addr))
            {
            //Accelerator off - ld b,b
            case 0x40:
            {
                //_accOn = false;
                //_accWaitCmd = false;
                _accMode    = AccelCMD.Off;
                _accSubMode = AccelSubCMD.None;
            }
            break;

            //Accelerator on - ld d,d
            case 0x52:
            {
                _accOn = true;
                //_accWaitCmd = true;
                _accMode    = AccelCMD.On;
                _accSubMode = AccelSubCMD.None;
            }
            break;

            case 0x49:
            {
                _accOn      = true;
                _accMode    = AccelCMD.Fill;
                _accSubMode = AccelSubCMD.None;
            }
            break;

            case 0x5B:
            {
                _accOn      = true;
                _accMode    = AccelCMD.GrFill;
                _accSubMode = AccelSubCMD.None;
            }
            break;

            case 0x64:
            {
                _accOn      = true;
                _accMode    = AccelCMD.Reserved;
                _accSubMode = AccelSubCMD.None;
            }
            break;

            case 0x6D:
            {
                _accOn      = true;
                _accMode    = AccelCMD.CopyBlok;
                _accSubMode = AccelSubCMD.None;
            }
            break;

            case 0x7F:
            {
                _accOn      = true;
                _accMode    = AccelCMD.GrCopyBlok;
                _accSubMode = AccelSubCMD.None;
            }
            break;

            case 0xAE:
            {
                _accOn      = true;
                _accSubMode = AccelSubCMD.XORBlok;
            } break;

            case 0xB6:
            {
                _accOn      = true;
                _accSubMode = AccelSubCMD.ORBlok;
            } break;

            case 0xA6:
            {
                _accOn      = true;
                _accSubMode = AccelSubCMD.ANDBlok;
            } break;
            }
        }
Esempio n. 3
0
 /*        private void GetAccelDATA(ushort addr, ref byte value)
 {
     if (m_acc_enable && m_acc_on && m_acc_wait_data)
     {
         ;
     }
 }*/
 private void Accelerator(ushort addr, ref byte value)
 {
     if (m_acc_enable)
     {
         switch (this.RDMEM_DBG(addr))
         {
                 //Accelerator off - ld b,b
             case 0x40:
                 {
     //                            m_acc_on = false;
     //                            m_acc_wait_cmd = false;
                     m_acc_mode = AccelCMD.Off;
                     m_acc_submode = AccelSubCMD.None;
                 }
                 break;
                 //Accelerator on - ld d,d
             case 0x52:
                 {
                     m_acc_on = true;
     //                            m_acc_wait_cmd = true;
                     m_acc_mode = AccelCMD.On;
                     m_acc_submode = AccelSubCMD.None;
                 }
                 break;
             case 0x49:
                 {
                     m_acc_on = true;
                     m_acc_mode = AccelCMD.Fill;
                     m_acc_submode = AccelSubCMD.None;
                 }
                 break;
             case 0x5B:
                 {
                     m_acc_on = true;
                     m_acc_mode = AccelCMD.GrFill;
                     m_acc_submode = AccelSubCMD.None;
                 }
                 break;
             case 0x64:
                 {
                     m_acc_on = true;
                     m_acc_mode = AccelCMD.Reserved;
                     m_acc_submode = AccelSubCMD.None;
                 }
                 break;
             case 0x6D:
                 {
                     m_acc_on = true;
                     m_acc_mode = AccelCMD.CopyBlok;
                     m_acc_submode = AccelSubCMD.None;
                 }
                 break;
             case 0x7F:
                 {
                     m_acc_on = true;
                     m_acc_mode = AccelCMD.GrCopyBlok;
                     m_acc_submode = AccelSubCMD.None;
                 }
                 break;
             case 0xAE:
                 {
                     m_acc_on = true;
                     m_acc_submode = AccelSubCMD.XORBlok;
                 }break;
             case 0xB6:
                 {
                     m_acc_on = true;
                     m_acc_submode = AccelSubCMD.ORBlok;
                 } break;
             case 0xA6:
                 {
                     m_acc_on = true;
                     m_acc_submode = AccelSubCMD.ANDBlok;
                 } break;
         }
     }
 }
Esempio n. 4
0
        private void AccelRead(ushort addr, ref byte value)
        {
            if (_accEnable && _accOn && (_accMode != AccelCMD.Off))
            {
                switch (_accMode)
                {
                case AccelCMD.On:               //LD D,D
                {
                    if (value != 0)
                    {
                        _accBufSize = value;
                    }
                    else
                    {
                        _accBufSize = 256;
                    }
                } break;

                case AccelCMD.CopyBlok:         //LD L,L
                {
                    for (int i = 0; i < _accBufSize; i++)
                    {
                        byte tmp = 0;
                        switch ((addr + i) & 0xc000)
                        {
                        case 0x0000: this.ReadMem0000((ushort)(addr + i), ref tmp); break;

                        case 0x4000: this.ReadMem4000((ushort)(addr + i), ref tmp); break;

                        case 0x8000: this.ReadMem8000((ushort)(addr + i), ref tmp); break;

                        case 0xc000: this.ReadMemC000((ushort)(addr + i), ref tmp); break;
                        }
                        switch (_accSubMode)
                        {
                        case AccelSubCMD.None:               //CopyBlok
                        {
                            _accBuf[i] = tmp;                //RDMEM_DBG((ushort)(addr + i));
                        } break;

                        case AccelSubCMD.XORBlok:                  //XOR (HL)
                        {
                            _accBuf[i] ^= tmp;
                        } break;

                        case AccelSubCMD.ORBlok:                   //OR (HL)
                        {
                            _accBuf[i] |= tmp;
                        } break;

                        case AccelSubCMD.ANDBlok:                  //AND (HL)
                        {
                            _accBuf[i] &= tmp;
                        } break;
                        }
                    }
                    _accSubMode = AccelSubCMD.None;
                } break;

                case AccelCMD.GrCopyBlok:       //LD A,A
                {
                    for (int i = 0; i < _accBufSize; i++)
                    {
                        byte tmp = 0;
                        switch (addr & 0xc000)
                        {
                        case 0x0000: this.ReadMem0000(addr, ref tmp); break;

                        case 0x4000: this.ReadMem4000(addr, ref tmp); break;

                        case 0x8000: this.ReadMem8000(addr, ref tmp); break;

                        case 0xc000: this.ReadMemC000(addr, ref tmp); break;
                        }
                        switch (_accSubMode)
                        {
                        case AccelSubCMD.None: _accBuf[i] = tmp;            //RDMEM_DBG((ushort)(addr + i));
                            break;

                        case AccelSubCMD.XORBlok: _accBuf[i] ^= tmp; break;

                        case AccelSubCMD.ORBlok: _accBuf[i] |= tmp; break;

                        case AccelSubCMD.ANDBlok: _accBuf[i] &= tmp; break;
                        }
                        //m_acc_buf[i] = VRamPages[(m_port_y & 0xf0) >> 4][(m_port_y & 0x0f) * 1024 + (addr & 0x3FF)]; //this.RDMEM_DBG(addr);
                        _portY++;
                    }
                    _accSubMode = AccelSubCMD.None;
                } break;

                case AccelCMD.GrFill:       //LD E,E
                {
                    for (int i = 0; i < _accBufSize; i++)
                    {
                        _portY++;
                    }
                } break;
                }
            }
        }