static void traceStartMessageInit(Arena arena, TraceStartMessage tsMessage)
{
AVERT(Arena, arena);
MessageInit(arena, TraceStartMessageMessage(tsMessage),
&TraceStartMessageClassStruct, MessageTypeGCSTART);
tsMessage->why[0] = '\0';
tsMessage->why[NELEMS(tsMessage->why)-1] = '\0'; /* .whybuf.nul */
tsMessage->sig = TraceStartMessageSig;
AVERT(TraceStartMessage, tsMessage);
}
static void traceMessageInit(Arena arena, TraceMessage tMessage)
{
AVERT(Arena, arena);
MessageInit(arena, TraceMessageMessage(tMessage),
&TraceMessageClassStruct, MessageTypeGC);
tMessage->liveSize = (Size)0;
tMessage->condemnedSize = (Size)0;
tMessage->notCondemnedSize = (Size)0;
tMessage->sig = TraceMessageSig;
AVERT(TraceMessage, tMessage);
}
BOOL
Init(VOID)
{
USERCONNECT UserCon;
/* Set PEB data */
NtCurrentPeb()->KernelCallbackTable = apfnDispatch;
NtCurrentPeb()->PostProcessInitRoutine = NULL;
NtUserProcessConnect( NtCurrentProcess(),
&UserCon,
sizeof(USERCONNECT));
g_ppi = GetWin32ClientInfo()->ppi; // Snapshot PI, used as pointer only!
g_ulSharedDelta = UserCon.siClient.ulSharedDelta;
gpsi = SharedPtrToUser(UserCon.siClient.psi);
gHandleTable = SharedPtrToUser(UserCon.siClient.aheList);
gHandleEntries = SharedPtrToUser(gHandleTable->handles);
RtlInitializeCriticalSection(&gcsUserApiHook);
gfServerProcess = FALSE; // FIXME HAX! Used in CsrClientConnectToServer(,,,,&gfServerProcess);
//CsrClientConnectToServer(L"\\Windows", 0, NULL, 0, &gfServerProcess);
//ERR("1 SI 0x%x : HT 0x%x : D 0x%x\n", UserCon.siClient.psi, UserCon.siClient.aheList, g_ulSharedDelta);
/* Allocate an index for user32 thread local data. */
User32TlsIndex = TlsAlloc();
if (User32TlsIndex != TLS_OUT_OF_INDEXES)
{
if (MessageInit())
{
if (MenuInit())
{
InitializeCriticalSection(&U32AccelCacheLock);
GdiDllInitialize(NULL, DLL_PROCESS_ATTACH, NULL);
LoadAppInitDlls();
return TRUE;
}
MessageCleanup();
}
TlsFree(User32TlsIndex);
}
return FALSE;
}
BOOL
WINAPI
ClientThreadSetupHelper(BOOL IsCallback)
{
/*
* Normally we are called by win32k so the win32 thread pointers
* should be valid as they are set in win32k::InitThreadCallback.
*/
PCLIENTINFO ClientInfo = GetWin32ClientInfo();
BOOLEAN IsFirstThread = _InterlockedExchange8((PCHAR)&gfFirstThread, FALSE);
TRACE("In ClientThreadSetup(IsCallback == %s, gfServerProcess = %s, IsFirstThread = %s)\n",
IsCallback ? "TRUE" : "FALSE", gfServerProcess ? "TRUE" : "FALSE", IsFirstThread ? "TRUE" : "FALSE");
if (IsFirstThread)
GdiProcessSetup();
/* Check for already initialized thread, and bail out if so */
if (ClientInfo->CI_flags & CI_INITTHREAD)
{
ERR("ClientThreadSetup: Thread already initialized.\n");
return FALSE;
}
/*
* CSRSS couldn't use user32::DllMain CSR server-to-server call to connect
* to win32k. So it is delayed to a manually-call to ClientThreadSetup.
* Also this needs to be done only for the first thread (since the connection
* is per-process).
*/
if (gfServerProcess && IsFirstThread)
{
NTSTATUS Status;
USERCONNECT UserCon;
RtlZeroMemory(&UserCon, sizeof(UserCon));
/* Minimal setup of the connect info structure */
UserCon.ulVersion = USER_VERSION;
/* Connect to win32k */
Status = NtUserProcessConnect(NtCurrentProcess(),
&UserCon,
sizeof(UserCon));
if (!NT_SUCCESS(Status)) return FALSE;
/* Retrieve data */
g_ppi = ClientInfo->ppi; // Snapshot PI, used as pointer only!
g_ulSharedDelta = UserCon.siClient.ulSharedDelta;
gpsi = SharedPtrToUser(UserCon.siClient.psi);
gHandleTable = SharedPtrToUser(UserCon.siClient.aheList);
gHandleEntries = SharedPtrToUser(gHandleTable->handles);
gSharedInfo = UserCon.siClient;
// ERR("1 SI 0x%x : HT 0x%x : D 0x%x\n", UserCon.siClient.psi, UserCon.siClient.aheList, g_ulSharedDelta);
}
TRACE("Checkpoint (register PFN)\n");
if (!RegisterClientPFN())
{
ERR("RegisterClientPFN failed\n");
return FALSE;
}
/* Mark this thread as initialized */
ClientInfo->CI_flags |= CI_INITTHREAD;
/* Initialization that should be done once per process */
if (IsFirstThread)
{
TRACE("Checkpoint (Allocating TLS)\n");
/* Allocate an index for user32 thread local data */
User32TlsIndex = TlsAlloc();
if (User32TlsIndex == TLS_OUT_OF_INDEXES)
return FALSE;
// HAAAAAAAAAACK!!!!!!
// ASSERT(gpsi);
if (!gpsi) ERR("AAAAAAAAAAAHHHHHHHHHHHHHH!!!!!!!! gpsi == NULL !!!!\n");
if (gpsi)
{
TRACE("Checkpoint (MessageInit)\n");
if (MessageInit())
{
TRACE("Checkpoint (MenuInit)\n");
if (MenuInit())
{
TRACE("Checkpoint initialization done OK\n");
InitializeCriticalSection(&U32AccelCacheLock);
LoadAppInitDlls();
return TRUE;
}
MessageCleanup();
}
TlsFree(User32TlsIndex);
return FALSE;
}
}
return TRUE;
}
BOOL
Init(VOID)
{
USERCONNECT UserCon;
PVOID *KernelCallbackTable;
/* Set up the kernel callbacks. */
KernelCallbackTable = NtCurrentPeb()->KernelCallbackTable;
KernelCallbackTable[USER32_CALLBACK_WINDOWPROC] =
(PVOID)User32CallWindowProcFromKernel;
KernelCallbackTable[USER32_CALLBACK_SENDASYNCPROC] =
(PVOID)User32CallSendAsyncProcForKernel;
KernelCallbackTable[USER32_CALLBACK_LOADSYSMENUTEMPLATE] =
(PVOID)User32LoadSysMenuTemplateForKernel;
KernelCallbackTable[USER32_CALLBACK_LOADDEFAULTCURSORS] =
(PVOID)User32SetupDefaultCursors;
KernelCallbackTable[USER32_CALLBACK_HOOKPROC] =
(PVOID)User32CallHookProcFromKernel;
KernelCallbackTable[USER32_CALLBACK_EVENTPROC] =
(PVOID)User32CallEventProcFromKernel;
KernelCallbackTable[USER32_CALLBACK_LOADMENU] =
(PVOID)User32CallLoadMenuFromKernel;
KernelCallbackTable[USER32_CALLBACK_CLIENTTHREADSTARTUP] =
(PVOID)User32CallClientThreadSetupFromKernel;
KernelCallbackTable[USER32_CALLBACK_CLIENTLOADLIBRARY] =
(PVOID)User32CallClientLoadLibraryFromKernel;
KernelCallbackTable[USER32_CALLBACK_GETCHARSETINFO] =
(PVOID)User32CallGetCharsetInfo;
NtUserProcessConnect( NtCurrentProcess(),
&UserCon,
sizeof(USERCONNECT));
g_ppi = GetWin32ClientInfo()->ppi; // Snapshot PI, used as pointer only!
g_ulSharedDelta = UserCon.siClient.ulSharedDelta;
gpsi = SharedPtrToUser(UserCon.siClient.psi);
gHandleTable = SharedPtrToUser(UserCon.siClient.aheList);
gHandleEntries = SharedPtrToUser(gHandleTable->handles);
RtlInitializeCriticalSection(&gcsUserApiHook);
gfServerProcess = FALSE; // FIXME HAX! Used in CsrClientConnectToServer(,,,,&gfServerProcess);
//CsrClientConnectToServer(L"\\Windows", 0, NULL, 0, &gfServerProcess);
//ERR("1 SI 0x%x : HT 0x%x : D 0x%x\n", UserCon.siClient.psi, UserCon.siClient.aheList, g_ulSharedDelta);
/* Allocate an index for user32 thread local data. */
User32TlsIndex = TlsAlloc();
if (User32TlsIndex != TLS_OUT_OF_INDEXES)
{
if (MessageInit())
{
if (MenuInit())
{
InitializeCriticalSection(&U32AccelCacheLock);
GdiDllInitialize(NULL, DLL_PROCESS_ATTACH, NULL);
LoadAppInitDlls();
return TRUE;
}
MessageCleanup();
}
TlsFree(User32TlsIndex);
}
return FALSE;
}
//系统启动，包括系统从SLEEP状态下唤醒启动或者从POWER DOWN状态下以片内主电源上电方式启动的相关处理
//一般情况下，2种启动方式在用户产品中不会同时存在
VOID SystemOn(VOID)
{
TIMER WaitTimer;
DBG1(("*******SystemOn************\n"));
#if (POWER_SAVING_MODE_OPTION == POWER_SAVING_MODE_SLEEP)
//获得从SLEEP状态唤醒的触发源标志
DBG1((">>WakeUpOp(), gWakeupTrigFlg:%bx\n", gWakeupTrigFlg));
//系统定义了IR唤醒功能，IR接收头连接于GPIOB6/GPIOE0，IR信号唤醒系统后，则判断键值
#ifdef WIS_FLG_IR
if((gWakeupTrigFlg == WIS_FLG_GPB6) || (gWakeupTrigFlg == WIS_FLG_GPE0))
{
DWORD IrKeyData;
TimeOutSet(&WaitTimer, 3500);
//如果在规定时间内未发现预定的IR键值，则继续睡眠
while(!IsTimeOut(&WaitTimer))
{
#ifdef FUNC_WATCHDOG_EN
FeedWatchDog();
#endif
IrKeyData = IrKeyDataVal();
DBG1(("IrKeyData = : %08LX\n", IrKeyData));
//如果检测到预定的IR键值，则开始运行系统
if( (IrKeyData == 0x5AA57F80) ||
(IrKeyData == 0x5FA07F80) ||
(IrKeyData == 0x5EA17F80) ||
(IrKeyData == 0x5DA27F80) ||
(IrKeyData == 0x5CA37F80) ||
(IrKeyData == 0x59A67F80) ||
(IrKeyData == 0x5BA47F80) )
{
MessageInit();
DBG1(("WAKE UP FROM SLEEP BY IR!\n"));
baGPIOCtrl[GPIO_A_IE] &= ~0x40;//A2
return;
}
else
{
DBG1(("ERROR IR KEY!\n"));
break;
}
}
DBG1(("TIMEOUT!\n"));
#ifdef IR_KEY_PORT
if(IR_KEY_PORT == IR_INPUT_GPIOB6)
{
SetWakeupSrcInSleep(WIS_GPB6_LOW);
DBG1(("*GPIO_B_IN:%bx\n", GetGpioReg(GPIO_B_IN)));
while((GetGpioReg(GPIO_B_IN) & 0x40) != 0x40)
{
DBG1(("请确保进入Sleep状态前WakeUp条件不成立！(GPIO_C_IN:%bx(GPIOC3 shoule be 0))\n", GetGpioReg(GPIO_B_IN)));
WaitMs(10);
#ifdef FUNC_WATCHDOG_EN
FeedWatchDog();
#endif
}
}
else if(IR_KEY_PORT == IR_INPUT_GPIOE0)
{
SetWakeupSrcInSleep(WIS_GPE0_LOW);
DBG(("*GPIO_E_IN:%bx\n", GetGpioReg(GPIO_E_IN)));
while((GetGpioReg(GPIO_E_IN) & 0x01) != 0x01)
{
DBG1(("请确保进入Sleep状态前WakeUp条件不成立！(GPIO_C_IN:%bx(GPIOC3 shoule be 0))\n", GetGpioReg(GPIO_B_IN)));
WaitMs(10);
#ifdef FUNC_WATCHDOG_EN
FeedWatchDog();
#endif
}
}
#endif
GoToSleepMode(SLEEP_MOD_OTP_PD);
DBG1(("<<WakeUpOp()\n"));
return;
}
#endif
#elif (POWER_SAVING_MODE_OPTION == POWER_SAVING_MODE_POWERDOWN)
#if (PWR_KEY_MODE == PWR_KEY_PUSH_BUTTON)
DBG(("\nPWR_KEY_PUSH_BUTTON\n\n"));
SetChip8SRstMode(CRM_IN_PUSH_BUTTON);
#elif(PWR_KEY_MODE == PWR_KEY_SLIDE_SWITCH)
DBG(("\nPWR_KEY_SLIDE_SWITCH\n\n"));
SetChip8SRstMode(CRM_IN_SLIDE_SWITCH);
#endif
gWakeupTrigFlg = GetWakeupFlgFromPD(); //获得从powerdown状态触发片内主电源上电系统启动的触发源标志
DBG(("gWakeupTrigFlg:%bx\n", gWakeupTrigFlg));
if(WIP_SRC_PWR_KEY & gWakeupTrigFlg)
{
DBG(("POWER KEY SYS ON\n"));
}
else if(WIP_SRC_LP_RTC & gWakeupTrigFlg)
{
DBG(("LP_RTC SYS ON\n"));
}
//如果POWER_KEY使用软开关(push button)，并且定义了POWER KEY开关机保持时间
//例如，要求按住POWER_KEY超过2秒后，系统才会点亮显示继续运行，否则系统再次关闭，用户不会感觉到系统运行过
//POWER_KEY持续按下了规定时间的判定是在power_key.c内完成的。
#if ((PWR_KEY_MODE == PWR_KEY_PUSH_BUTTON) && defined(TIME_POWER_ON_HOLD))
if(WIP_SRC_PWR_KEY & gWakeupTrigFlg) //必须是POWER_KEY唤醒系统时，才检查开机保持时间，而WTD复位等系统重新启动则不需要
{
TimeOutSet(&WaitTimer, (TIME_POWER_ON_HOLD * 2));
while(!IsTimeOut(&WaitTimer))
{
#ifdef FUNC_WATCHDOG_EN
FeedWatchDog();
#endif
KeyEventGet();
if(MessageGet(MSG_FIFO_KEY) == MSG_SYS_ON) //如果达到开机保持时间，则系统继续运行
{
MessageInit();
DBG(("POWER_KEY Hold time,MSG_SYS_ON\n"));
return;
}
}
DBG(("TIMEOUT!\n"));
//如果在规定时间内没有收到由power_key.c推送的MSG_SYS_ON消息，需要再次系统关闭。
GoToPDMode();
}
#elif(PWR_KEY_MODE == PWR_KEY_SLIDE_SWITCH)
DBG(("\nPWR_KEY_MODE == PWR_KEY_SLIDE_SWITCH\n\n"));
#endif
#endif
}
