RETAILMSG(1,(TEXT("-PWR_Deinit \r\n")));

    return ERROR_SUCCESS;
}


DWORD 
HW_Open(
    PPWR_CONTEXT pPWR
    )
{
    return ERROR_SUCCESS;
}


DWORD 
HW_Close(
    PPWR_CONTEXT pPWR
    )
{
    return ERROR_SUCCESS;
}


BOOL
HW_PowerUp(
    PPWR_CONTEXT pPWR
   )
{
    RETAILMSG(1, (TEXT("PCF: HW_PowerUp \r\n")));
    pPWR->State = RESUME;
    SetInterruptEvent(SYSINTR_POWER);
    return TRUE;
}


BOOL
HW_PowerDown(
    PPWR_CONTEXT pPWR
   )
{
    pPWR->State = SUSPEND;
    return TRUE;
}


BOOL
HW_PowerCapabilities(
    PPWR_CONTEXT pPWR,
    PPOWER_CAPABILITIES ppc
    )
{
    return TRUE;
}


BOOL
HW_PowerSet(
    PPWR_CONTEXT pPWR,
    PCEDEVICE_POWER_STATE pDx   // IN, OUT
   )
{   
    CEDEVICE_POWER_STATE NewDx = *pDx;

    if ( VALID_DX(NewDx) ) 
    {
        // We only support D0, so do nothing.
        // Just return current state.
        pPWR->Dx = *pDx = D0;
        RETAILMSG(1, (TEXT("PCF: IOCTL_POWER_SET: D%u => D%u \r\n"), NewDx, pPWR->Dx));
        return TRUE;
    }

    return FALSE;
}


BOOL
HW_PowerGet(
    PPWR_CONTEXT pPWR,
    PCEDEVICE_POWER_STATE pDx
   )
{   
    // return our Current Dx value
    *pDx = pPWR->Dx;
    RETAILMSG(1, (TEXT("PCF: IOCTL_POWER_GET: D%u \r\n"), pPWR->Dx));

    return TRUE;
}


static DWORD 
PWR_IST(
    PPWR_CONTEXT pPWR
    )
{
	int CurrStatus = RUN;
    DWORD we;
	WCHAR  state[1024] = {0};
	LPWSTR pState = &state[0];
	DWORD dwBufChars = (sizeof(state) / sizeof(state[0]));
	DWORD  dwStateFlags = 0;
	DWORD dwErr;
    
    if (!pPWR)
        return ERROR_INVALID_PARAMETER;

    while (1) {
        __try {
            we = WaitForSingleObject(pPWR->ISTEvent, INFINITE);
			RETAILMSG(1,(TEXT("\r\nPWR_IST: pPWR->State = 0x%x \r\n"), pPWR->State));



			dwErr = GetSystemPowerState(pState, dwBufChars, &dwStateFlags);
			if (ERROR_SUCCESS != dwErr) {
				RETAILMSG(1, (TEXT("PMGET!GetSystemPowerState:ERROR:%d\n"), dwErr));
			} else {
				RETAILMSG(1, (TEXT("PMGET! System Power state is '%s', flags 0x%08x\n"), state, dwStateFlags));
				switch (POWER_STATE(dwStateFlags)) {
				case POWER_STATE_ON:
					RETAILMSG(1, (TEXT("PMGET!\tPOWER_STATE_ON\n")));
					break;
				case POWER_STATE_OFF:
					RETAILMSG(1, (TEXT("PMGET!\tPOWER_STATE_OFF\n")));
					break;
				case POWER_STATE_CRITICAL:
					RETAILMSG(1, (TEXT("PMGET!\tPOWER_STATE_CRITICAL\n")));
					break;
				case POWER_STATE_BOOT:
					RETAILMSG(1, (TEXT("PMGET!\tPOWER_STATE_BOOT\n")));
					break;
				case POWER_STATE_IDLE:
					RETAILMSG(1, (TEXT("PMGET!\tPOWER_STATE_IDLE\n")));
					break;
				case POWER_STATE_SUSPEND:
					RETAILMSG(1, (TEXT("PMGET!\tPOWER_STATE_SUSPEND\n")));
					break;
				case POWER_STATE_RESET:
					RETAILMSG(1, (TEXT("PMGET!\tPOWER_STATE_RESET\n")));
					break;
				case 0:
					break;
				default:
					RETAILMSG(1,(TEXT("PMGET!\tUnknown Power State Flags:0x%x\n"),dwStateFlags));
					ASSERT(0);
					break;
				}
			}

            
			switch (pPWR->State) {
                
                case RUN:
                    RETAILMSG(1, (TEXT("PWR_IST: RUN\r\n")));
					if (CurrStatus == SUSPEND)
					{
	                    RETAILMSG(1, (TEXT("CurrStatus == SUSPEND\r\n")));
						pPWR->State = RUN;
						CurrStatus = RUN;
						// clear any potential pending ADC interrupt
						InterruptDone(SYSINTR_POWER);
						SetSystemPowerState( NULL, POWER_STATE_ON, POWER_FORCE );
						continue;
					}
					else if (CurrStatus == RESUME)
					{
						RETAILMSG(1, (TEXT("CurrStatus == RESUME\r\n")));
						if ( wcscmp(state,TEXT("unattended")) == 0 )
						{
		                    RETAILMSG(1, (TEXT("Unattended Power Off Mode\r\n")));
							pPWR->State = RUN;
							CurrStatus = SUSPEND;
							continue;
						}
//						else if ( wcscmp(state,TEXT("resuming")) == 0 )
//						{
//		                    RETAILMSG(1, (TEXT("Still resuming...\r\n")));
//							Sleep(1000);
//							SetEvent(pPWR->ISTEvent);
//							continue;
//						}
						else
						{
		                    RETAILMSG(1, (TEXT("Power On\r\n")));
							pPWR->State = RUN;
							CurrStatus = RUN;
							// clear any potential pending ADC interrupt
							InterruptDone(SYSINTR_POWER);
							SetSystemPowerState( NULL, POWER_STATE_ON, POWER_FORCE );
							continue;
						}
					}
                    break;

                case INITIALIZE:
                    // Keep from reading our clear on read INTx registers
                    // during init.
                    RETAILMSG(1, (TEXT("PWR_IST: INITIALIZE\r\n")));
                    Sleep(10);
                    continue;
                    break;

                case SUSPEND:
                    RETAILMSG(1, (TEXT("PWR_IST: SUSPEND\r\n")));
//                    continue;
                    break;
                    
                case RESUME:
                case ADC_ERROR:
                    RETAILMSG(1,(TEXT("PWR_IST: %s \r\n"), pPWR->State == RESUME ? L"RESUME" : L"ADC_ERROR" ));
                    pPWR->State = RUN;
					CurrStatus = RESUME;
                    // clear any potential pending ADC interrupt
					InterruptDone(SYSINTR_POWER);
					Sleep(200);
					SetEvent(pPWR->ISTEvent);
//	                SetSystemPowerState( NULL, POWER_STATE_ON, POWER_FORCE );
                    continue;
                    break;
                    
                case UNINITIALIZED:
                    RETAILMSG(1,(TEXT("PWR_IST: ExitThread \r\n")));
                    ExitThread(ERROR_SUCCESS);
                    return ERROR_SUCCESS;

                default:
                    RETAILMSG(1,(TEXT("PWR_IST: unknown state: %u\r\n"), pPWR->State));
                    TEST_TRAP;
                    continue;
                    break;
            }

            //
            // get status
            //
//			EnterCriticalSection(&pPWR->RegCS);
//
//			if ( !pPWR->ResetRegReady ) {
//			} else {
//				// get & restore the cleared registers
//				pPWR->ResetRegReady = FALSE;
//			}

            LeaveCriticalSection(&pPWR->RegCS);
            
            // clear the interrupt before power off
            InterruptDone(SYSINTR_POWER);
			CurrStatus = SUSPEND;
            SetSystemPowerState( NULL, POWER_STATE_SUSPEND, POWER_FORCE );

        } _except(EXCEPTION_EXECUTE_HANDLER) {
            
            RETAILMSG(1,(TEXT("!!! PWR_IST EXCEPTION: 0x%X !!!\r\n"), GetExceptionCode() ));

        }
	}
}


/* ++

 Get/Set the PCF RTC.
 
 One neat PCF feature is the stand alone RTC.
 You could power the ARM core to full off and maintin the RTC & ALARM on the PCF.
 This is not a required feature for PPC2002 release, but OEMs are 
 free to add this as desired. You should sync the ARM & PCF RTC
 and update as appropriate. If you choose to implement this it would
 be good to power as much of the PCF off as possible to maintin it's RTC
 for much longer time.

-- */
BOOL 
PWR_GetRealTime(
    PPWR_CONTEXT pPWR,
    LPSYSTEMTIME lpst
    )
{
    return TRUE;
}


BOOL
PWR_SetRealTime(
    PPWR_CONTEXT pPWR,
    LPSYSTEMTIME lpst
    ) 
{
    return TRUE;
}


BOOL
HW_IOControl(
    PPWR_CONTEXT pPWR,
    DWORD dwCode,
    PBYTE pBufIn,
    DWORD dwLenIn,
    PBYTE pBufOut,
    DWORD dwLenOut,
    PDWORD pdwActualOut
   )
{
	return FALSE;
}