pccore.cpp

瑞星微公司RK27XX系列芯片的SDK开发包

// pcCore.c : 模拟 OS 任务调度
/*
 IDLE 中切换， IDLE 的优先级最高
*/

/******************************************************************/
#include "bool.h"

#ifdef _SourceCode

#include "..\..\stdafx.h"
#include <winbase.h>
#include "include.h"
#include "..\rk27dll.h"

#include "..\src\pcCore\pccore.h"


/*-----------------------------------------------------*/
#ifdef __cplusplus
extern "C"
{
#endif

#include "..\os\Lib\core\core.h"
    /*******************************************************************/

#define PCC_EP_PCLIB   0 // 仿真工程 
#define PCC_EP_BMPEDIT   1 // 位图编辑工程.

    /*******************************************************************/

//extern
    extern STACK OSTaskIdleStk[];
    extern INT32U  PCTimerOSStartFlag;
    extern int main(void);
extern void FS_PCMediumClose(void);
    /*******************************************************************/

    HWND  hWnd;
    INT32U  gPCCTimerEnabled = 1;
    INT32U  gPCLibStarted; // 1 : START, 0:SHUT DOWN.
    INT32U  gPCLibEntryPoint; // 1 : START, 0:SHUT DOWN.
    /******************************************************************/

    PCC_THREADINFO  gPCCTHREADINFO[OS_LOWEST_PRIO + 1] = {0};

    CRITICAL_SECTION gPCCCriticalSetion;
    HANDLE    gPCCShutDownSem;

    INT16U    gPCCLcdDisplayFlag = 0; // PCDISP_FLAG_REALSIZE
    /******************************************************************/


    void PCCEnterCritical(void)
    {
        if (gPCLibStarted)
            ::EnterCriticalSection(&gPCCCriticalSetion);
    }

    void PCCExitCritical(void)
    {
        if (gPCLibStarted)
            ::LeaveCriticalSection(&gPCCCriticalSetion);
    }

    void PCCDisableTimer(void)
    {
        gPCCTimerEnabled = 0;
    }

    void PCCEnableTimer(void)
    {
        gPCCTimerEnabled = 1;
    }

    void OS_TASK_SW(void)
    {
        INT8U  bakOSPrioCur = OSPrioCur;


        if (OSPrioCur == OSPrioHighRdy || gPCLibStarted == 0)
        {
            TR("OS Task Switch Error!");
            return ;
        }

        OSTCBCur = OSTCBHighRdy;
        OSPrioCur = OSPrioHighRdy;

        if (gPCCTHREADINFO[OSPrioHighRdy].ThredHandle)
        {
            if (::ResumeThread(gPCCTHREADINFO[OSPrioHighRdy].ThredHandle) == 0XFFFFFFFF)
            {
                TR("TASK SW FAILED[%d],errCode=%d",
                   OSPrioHighRdy ,
                   GetLastError());
            }
        }


        //::Sleep( 5 );
        if (gPCCTHREADINFO[bakOSPrioCur].ThredHandle)
        {
            if (::SuspendThread(gPCCTHREADINFO[bakOSPrioCur].ThredHandle) == 0XFFFFFFFF)
            {
                TR("TASK SW FAILED[%d],errCode=%d",
                   OSPrioCur ,
                   GetLastError());
            }
        }

    }


    void  OSIntCtxSw(void)
    {
        OS_TASK_SW();
    }

    void OSCtxSw(void)
    {
        OS_TASK_SW();
    }
    /******************************************************************/

    void OSStartHighRdy(void)
    {
        if (!OSRunning /* && PCC_EP_PCLIB == gPCLibEntryPoint*/)
        {
            OSRunning = TRUE;
            if (::ResumeThread(gPCCTHREADINFO[OSPrioCur].ThredHandle) == 0XFFFFFFFF)
            {
                TR("FAILED TO START TASK[%d],errCode=%d",
                   OSPrioCur,
                   GetLastError());
            }

        }

    }

    /*--------------------------------------*/
    /******************************************************************/
    INT8U  PCTaskCreate(void (*task)(void *),
                        void *pdata,
                        STACK  *ptos,
                        INT8U  prio,
                        INT16U  id,
                        STACK  *pbos,
                        INT32U  stksize,
                        void *pext,
                        INT16U  opt)
    {
        INT8U    err;
        HANDLE    TaskHandle;
        DWORD        TaskId;
        BOOL    res;

        gPCCTHREADINFO[prio].ThredHandle = NULL;
        gPCCTHREADINFO[prio].ThreadID = 0;
        err = OSTaskCreate(task , pdata , ptos , prio);
        if (err == OS_NO_ERR)
        {

            TaskHandle = ::CreateThread(NULL , stksize + 1024 * 2,
                                        (LPTHREAD_START_ROUTINE)task, pdata, CREATE_SUSPENDED, &TaskId);
            if (TaskHandle == NULL)  //ERROR
            {

                TR("CREATE TASK[%d] FAILED,errCode=%d!", prio , GetLastError());
                return OS_THREAD_CREATE;
            }
            if (prio == OS_IDLE_PRIO)
            {
                res = ::SetThreadPriority(TaskHandle , THREAD_PRIORITY_LOWEST);
            }
            else
            {
                //THREAD_PRIORITY_ABOVE_NORMAL
                res = ::SetThreadPriority(TaskHandle , THREAD_PRIORITY_HIGHEST);
            }

            if (!res)
            {
                TR("SETPRIO TASK[%d] FAILED,errCode=%d!", prio , GetLastError());
                ::TerminateThread(TaskHandle , 0xffff);
                return OS_THREAD_SETPRIO;

            }
            gPCCTHREADINFO[prio].ThredHandle = TaskHandle;
            gPCCTHREADINFO[prio].ThreadID = TaskId;
        }
        else
        {
            TR("OS Create TASK[%d] Error" , prio);
        }

        return err;
    }

    /******************************************************************/
    void  PCCoreInitTaskIdle(void)
    {
        INT8U    err;
        err = PCTaskCreate(OS_TaskIdle /*PCIdleTask*/ , NULL , &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1] , OS_IDLE_PRIO,
                           0xffff,
                           &OSTaskIdleStk[0], OS_TASK_IDLE_STK_SIZE , NULL, 0);

    }

    STACK *OSTaskStkInit(void (*task)(void *pd), void *pdata, STACK *ptos, INT16U opt)
    {
        return ptos;
    }


    void  PCCoreSystemStartup(HWND hwnd  , int ep)
    {
        hWnd = hwnd; //SendMessage( hWnd , 0 , 0 , 0 );

        // PC 仿真 入口.// ep == 1 , 资源编辑 入口.
        gPCLibEntryPoint = ep;

        if (gPCLibStarted == 0 && gPCLibEntryPoint == PCC_EP_PCLIB)
        {
            ::InitializeCriticalSection(&gPCCCriticalSetion);
            gPCCShutDownSem = ::CreateSemaphore(NULL , 0 , 1 , "RKSD_SEM");
            gPCLibStarted = 1;
            main();
            PCTimerOSStartFlag = 1;
        }

        PCCEnableTimer();

    }


//系统复位!!
    void  PCCoreSystemRestart(int Flag)
    {

#if 0
        if (Flag == 1)
        {
            RockPcRegClearAll();
        }
#endif

        if (OSTCBCur && OSTCBCur->OSTCBStat == OS_STAT_RDY && PCC_EP_PCLIB == gPCLibEntryPoint)
        {
            // RockPcRegClearAll();
            if (::ResumeThread(gPCCTHREADINFO[OSPrioHighRdy].ThredHandle) == 0XFFFFFFFF)
            {
                TR("TSW FAILED[%d],errCode=%d",
                   OSPrioHighRdy ,
                   GetLastError());
            }
        }
    }


    /*
     1. 发送系统 SHUTDOW 消息给 GUI TASK ,当各个TASK 处理完成之后，
      再进行外部关闭.
    */
    void  PCCoreSystemShutDown(void)
    {
        INT32U  ii;
		DECLARE_CUP_SR;
		
        gPCLibStarted = 0;//系统关闭标志.

		ENTER_CRITICAL();
        RockOSSendMsg(MBGUI , MS_ALGU_SysShutDownReq , NULL);
		EXIT_CRITICAL();
		
        PCCDisableTimer();

        ::WaitForSingleObject(gPCCShutDownSem , 1000);  //一秒钟时间.

        for (ii = 0 ; ii <= OS_LOWEST_PRIO ; ii++)
        {
            if (gPCCTHREADINFO[ii].ThredHandle != NULL)
            {
                ::TerminateThread(gPCCTHREADINFO[ii].ThredHandle , 0xffff);
                gPCCTHREADINFO[OSPrioCur].ThredHandle = NULL;
            }
        }
        ::DeleteCriticalSection(&gPCCCriticalSetion);
        ::CloseHandle(gPCCShutDownSem);
		FS_PCMediumClose();
        _fcloseall();
	
    }

    void  PCCoreSystemShutDownFinish(void)
    {
        LONG  initCount;
        ::ReleaseSemaphore(gPCCShutDownSem , 1 , &initCount);
    }

    INT32U  PCCoreGetStartFlag(void)
    {
        return gPCLibStarted;
    }

    void  PCCoreLcdLogicUpdate(void* rect , void* lcdBuffer)
    {
        //PCCDisableTimer();

        ::SendMessage(hWnd , /* WM_USER*/0x4000 , (WPARAM)rect , (LPARAM)lcdBuffer);

#if 0
        if (gPCCTHREADINFO[OSPrioCur].ThredHandle != NULL)
        {
            if (::SuspendThread(gPCCTHREADINFO[OSPrioCur].ThredHandle) == 0XFFFFFFFF)
            {
                TR("TASK SW FAILED[%d],errCode=%d",
                   OSPrioCur ,
                   GetLastError());
                return ;
            }
        }
#endif		

    }

    void  PCCoreSetLcdInfo(void)
    {
        //::SendMessage( hWnd , /* WM_USER*/0x4001 , (WPARAM )0 , (LPARAM )0 );
        ::PostMessage(hWnd , /* WM_USER*/0x4001 , (WPARAM)0 , (LPARAM)0);
    }


    void PCHostSetUpdateFinish(void)
    {
        if (gPCLibStarted == 0)
        {
            return ;
        }

        if (OSRunning && gScreenUpdating)
        {
			DECLARE_CUP_SR;
            
			ENTER_CRITICAL();
            RockOSSendMsg(MBDISP , MS_DIDI_LCDUpdateInd , NULL);
			EXIT_CRITICAL();
#if 0			
			if (::ResumeThread(gPCCTHREADINFO[OSPrioCur].ThredHandle) == 0XFFFFFFFF)
            {
                TR("TASK SW FAILED[%d],errCode=%d",
                   OSPrioCur ,
                   GetLastError());
                return ;
            }
#endif			
        }
        //PCCEnableTimer();
    }


    LCD_RGBDATA* PCGetLcdLogicBuffer(void)
    {
        return gGuiDspLcdLogic;
    }

    INT16U PCGetLcdWidth(void)
    {
        return gLcdW;
    }

    INT16U PCGetLcdHeight(void)
    {
        return gLcdH;
    }


    INT16U PCGetLcdDisplayFlag(void)
    {
        return gPCCLcdDisplayFlag;
    }

    INT16U PCSetLcdDisplayFlag(INT16U flag)
    {
        INT16U o = gPCCLcdDisplayFlag;
        gPCCLcdDisplayFlag = flag;
        return o;
    }

    /************************************************************************/
// 模拟系统 TIMER ，包括所有的外设TIMER ,周期为 5ms .
    void __stdcall RkPCTimerTick( //CALLBACK EXPORT
        HWND hWnd,    // handle of CWnd that called SetTimer
        UINT nMsg,    // WM_TIMER
        UINT nIDEvent,   // timer identification
        DWORD dwTime    // system time
    )
    {
        if (!gPCCTimerEnabled || PCC_EP_PCLIB != gPCLibEntryPoint)
            return ;
        PCTimerUpdate();

    }
/************************************************************************/
#include "os\fs\PCEmluator\PC_dev.c"
/************************************************************************/

/************************************************************************/
#include "..\Lib\sound\sound.cpp"
/************************************************************************/
    /*------------------------------------------*/
#ifdef __cplusplus
}
#endif
/****************************************************************************/

#endif // _SourceCode