Esempio n. 1
0
        static bool HandleHolly_err(sh4_int intpt)
        {
            uint interupt = (uint)(1 << ((int)((uint)intpt & (uint)InteruptType.InteruptIDMask)));

            *mem.ISTERR |= interupt;

            if ((*mem.IML6ERR & interupt) != 0)
            {
                if (Do_interupt(IPr_LVL6, 0x320, 0x600))
                {
                    return(true);
                }
            }
            else if ((*mem.IML4ERR & interupt) != 0)
            {
                if (Do_interupt(IPr_LVL4, 0x360, 0x600))
                {
                    return(true);
                }
            }
            else if ((*mem.IML2ERR & interupt) != 0)
            {
                if (Do_interupt(IPr_LVL2, 0x3a0, 0x600))
                {
                    return(true);
                }
            }
            return(false);
        }
Esempio n. 2
0
        static bool HandleSH4_int(sh4_int intpt)
        {
            switch (intpt)
            {
            case  sh4_int.sh4_in_TMU0:
                return(Do_interupt((uint)(((*mem.IPRA) >> 12) & 0xf), 0x400, 0x600));

            case  sh4_int.sh4_in_TMU1:
                return(Do_interupt((uint)(((*mem.IPRA) >> 8) & 0xf), 0x420, 0x600));

            case  sh4_int.sh4_in_TMU2:
                return(Do_interupt((uint)(((*mem.IPRA) >> 4) & 0xf), 0x440, 0x600));
            }

            return(false);
        }
Esempio n. 3
0
 static bool HandleSH4_exept(sh4_int expt)
 {
     return(false);
 }
Esempio n. 4
0
        //static bool inside_int = false;

        static bool check_ints()
        {
            if (sh4.pc_funct != 0)
            {
                return(false);
            }


            #region new code
            if (pending_interups.Count == 0)
            {
                return(false);
            }

            sh4_int interupt = pending_interups.Dequeue();

            InteruptType type = (InteruptType)((uint)interupt & (uint)InteruptType.InteruptTypeMask);

            bool rv = false;

            switch (type)
            {
            case InteruptType.sh4_int:
                rv = HandleSH4_int(interupt);
                break;

            case InteruptType.sh4_exp:
                rv = HandleSH4_exept(interupt);
                break;

            case InteruptType.holly_nrm:
                rv = HandleHolly_nrm(interupt);
                break;

            case InteruptType.holly_ext:
                rv = HandleHolly_ext(interupt);
                break;

            case InteruptType.holly_err:
                rv = HandleHolly_err(interupt);
                break;
            }

            if (!rv)
            {
                pending_interups.Enqueue(interupt);
            }

            return(rv);

/*
 *                      if (((interupt >> 24) & 0xFF) != 0)
 *                      {
 *                              WriteLine("WARNING : OLNY INTERNAL INTERUPS ARE SUPORTED");
 *                              return false;
 *                      }
 *
 *                      uint* IST_reg = null, IML6_reg = null, IML4_reg = null, IML2_reg = null;
 *
 *                      uint interupt_type=(interupt >> 24) & 0xFF;
 *
 *                      switch (interupt_type)
 *                      {
 *                              case 0:		//normal
 *                                      IST_reg = ISTNRM;
 *                                      IML6_reg = IML6NRM;
 *                                      IML4_reg = IML4NRM;
 *                                      IML2_reg = IML2NRM;
 *                                      break;
 *                              case 1:		//external
 *                                      IST_reg = ISTEXT;
 *                                      IML6_reg = IML6EXT;
 *                                      IML4_reg = IML4EXT;
 *                                      IML2_reg = IML2EXT;
 *                                      break;
 *                              case 2:		//error
 *                                      IST_reg = ISTERR;
 *                                      IML6_reg = IML6ERR;
 *                                      IML4_reg = IML4ERR;
 *                                      IML2_reg = IML2ERR;
 *                                      break;
 *                      }
 *
 *                      interupt =(uint)( 1 << ((int)(interupt & 0xFF)));
 * IST_reg |= interupt;
 *
 *                      if ((*IML6_reg & interupt) != 0)
 *                      {
 *                              if (intc(IPr_LVL6, interupt_type))
 *                                      return true;
 *                      }
 *                      else if ((*IML4_reg & interupt) != 0)
 *                      {
 *                              if (intc(IPr_LVL4, interupt_type))
 *                                      return true;
 *                      }
 *                      else if ((*IML2_reg & interupt) != 0)
 *                      {
 *                              if (intc(IPr_LVL2, interupt_type))
 *                                      return true;
 *                      }
 * */
            #endregion

            //return false;
        }
Esempio n. 5
0
 public static void RaiseInterupt(sh4_int interupt)
 {
     pending_interups.Enqueue(interupt);
 }
Esempio n. 6
0
 public void Enqueue(sh4_int obj)
 {
     base.Enqueue(obj);
 }