snled.cpp

LP1071 无线局域网卡WinCE驱动程序

            p->OffOnBlink				= g_NLedPddContext[p->LedNum].NLedSettingsInfo.OffOnBlink;
            p->OffTime				= g_NLedPddContext[p->LedNum].NLedSettingsInfo.OffTime;
            p->OnTime				= g_NLedPddContext[p->LedNum].NLedSettingsInfo.OnTime;
            p->TotalCycleTime 			= g_NLedPddContext[p->LedNum].NLedSettingsInfo.TotalCycleTime;
        }	
    }	
    else
    {
        fOk = FALSE;
        SetLastError(ERROR_INVALID_PARAMETER);
    }
    		
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-NLedDriverGetDeviceInfo\r\n")));
    	
    return (fOk);
}

//-----------------------------------------------------------------------------
//
// Function: NLedDriverSetDevice
//
// This routine changes the configuration of an LED.  The nInfoId parameter
// indicates what kind of configuration information is being changed.  
// Currently only the NLED_SETTINGS_INFO_ID value is supported.  The pInput
// parameter points to a buffer containing the data to be updated.  The size
// of the buffer depends on the value of nInfoId.  This routine returns TRUE
// if successful or FALSE if there's a problem -- in which case it also calls
// SetLastError().  The NLED MDD invokes this routine when an application 
// calls NLedSetDevice().
//
// Parameters:
//      InputParm 
//          [in] INT     	nInfoId
//          [in] PVOID 	pInput
//
// Returns:  
//      This routine returns TRUE if successful, or FALSE if there's a problem
//
//-----------------------------------------------------------------------------
BOOL WINAPI NLedDriverSetDevice(INT     nInfoId, PVOID   pInput)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+NLedDriverSetDevice\r\n")));
			
    HANDLE hThread = NULL;
    UINT      LedIndex;
	
    struct NLED_SETTINGS_INFO *pNledSettingsInfo = (struct NLED_SETTINGS_INFO*)pInput;

    if((nInfoId != NLED_SETTINGS_INFO_ID) || (pNledSettingsInfo->LedNum >= NLED_MAX_LED))
    {
      	DEBUGMSG(ZONE_ERROR, (TEXT("NLedDriverSetDevice: Invalid Parameters\r\n")));	
    	return FALSE;
    }

    LedIndex = pNledSettingsInfo->LedNum;
    g_NLedPddContext[LedIndex].NLedSettingsInfo.LedNum = pNledSettingsInfo->LedNum;	
    g_NLedPddContext[LedIndex].NLedSettingsInfo.OffOnBlink = pNledSettingsInfo->OffOnBlink;

    if(g_NLedPddContext[LedIndex].bLEDBlinkState)
    {
        SetEvent(g_NLedPddContext[LedIndex].hNLedBlinkThreadEvent);
        DEBUGMSG(ZONE_PDD, (TEXT("NLedDriverSetDevice: WaitForSingleObject - hNLedBlinkThreadStoppedEvent\r\n")));
        WaitForSingleObject(g_NLedPddContext[LedIndex].hNLedBlinkThreadStoppedEvent, INFINITE);
    }
    
   
    if(pNledSettingsInfo->OffOnBlink == 0)	// OffOnBlink setting - OFF
    {	
        TurnOffLED(LedIndex);  
	g_NLedPddContext[LedIndex].bLEDState = FALSE;
    }	
    else if(pNledSettingsInfo->OffOnBlink == 1)  // OffOnBlink setting - ON
    {  		
        TurnOnLED( LedIndex);
	g_NLedPddContext[LedIndex].bLEDState = TRUE;
    }
    else if(pNledSettingsInfo->OffOnBlink == 2) // OffOnBlink setting - BLINK
    {      
        g_NLedPddContext[LedIndex].NLedSettingsInfo = *(pNledSettingsInfo);
        
        // Round up OnTime and OffTime values 1 millisecond
        if(g_NLedPddContext[LedIndex].NLedSettingsInfo.OnTime < 1000)
            g_NLedPddContext[LedIndex].NLedSettingsInfo.OnTime = 1000;
        
        if(g_NLedPddContext[LedIndex].NLedSettingsInfo.OffTime < 1000)
        g_NLedPddContext[LedIndex].NLedSettingsInfo.OffTime = 1000;	
        
        hThread = CreateThread(
           				NULL,                  					// Default thread security descriptor
          					0,                     					// Default stack size
          					LEDBlinkThread,	// Start routine
          					&g_NLedPddContext[LedIndex].NLedSettingsInfo,           		// Start routine parameter
          					0,                     					// Run immediately
          					NULL            						// Thread ID
          				);
            
        if (hThread == NULL)
        {
            g_NLedPddContext[LedIndex].bLEDBlinkState = FALSE;
            return FALSE;
        }
            
        CloseHandle(hThread);
    }       
    else    
    {       
    	DEBUGMSG(ZONE_ERROR, (TEXT("NLedDriverSetDevice: Invalid OffOnBlink\r\n")));
    	return FALSE;
    }
    			
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-NLedDriverSetDevice\r\n")));
    
    return TRUE;
}

//-----------------------------------------------------------------------------
//
// Function: NLedDriverPowerDown
//
// This routine is invoked by the driver MDD when the system suspends or
// resumes.  The power_down flag indicates whether the system is powering 
// up or powering down.
//
// Parameters:
//      InputParm 
//          [in] BOOL power_down
//
// Returns:  
//      	None
//
//-----------------------------------------------------------------------------
VOID WINAPI NLedDriverPowerDown(BOOL power_down)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+NLedDriverPowerDown\r\n")));

    for(int i=0; i<NLED_MAX_LED; i++)  
    {
        if(power_down)  
        {
             if(g_NLedPddContext[i].bLEDState == TRUE) TurnOffLED(i);  //Trun Off LED when LED is on
        }
	else        
             if(g_NLedPddContext[i].bLEDState == TRUE) TurnOnLED(i);  //restore LED to on
    }
    
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-NLedDriverPowerDown\r\n")));
    	
    return;
}

//-----------------------------------------------------------------------------
//
// Function: TurnOnLED
//
// This routine is Turn On LED
//
// Parameters:
//      [in] DWORD LEDNum
//
// Returns:  
//      
//-----------------------------------------------------------------------------
void TurnOnLED(DWORD LEDNum)
{
	if(LEDNum == 0)
            OUTREG16(&g_pPBC->BCTRL1_SET, CSP_BITFMASK(PBC_BCTRL1_LED_1));   // Turn On LED1
        else if(LEDNum == 1)
            OUTREG16(&g_pPBC->BCTRL1_SET, CSP_BITFMASK(PBC_BCTRL1_LED_2));  // Turn On LED2
}

//-----------------------------------------------------------------------------
//
// Function: TurnOffLED
//
// This routine is Turn Off LED
//
// Parameters:
//      [in] DWORD LEDNum
//
// Returns:  
//
//----------------------------------------------------------------------------
void TurnOffLED(DWORD LEDNum)
{
	if(LEDNum == 0)
            OUTREG16(&g_pPBC->BCTRL1_CLEAR, CSP_BITFMASK(PBC_BCTRL1_LED_1));   // Turn Off LED1
        else if(LEDNum == 1)
            OUTREG16(&g_pPBC->BCTRL1_CLEAR, CSP_BITFMASK(PBC_BCTRL1_LED_2));   // Turn Off LED2
}


//-----------------------------------------------------------------------------
//
// Function: NLedDriverSetDeviceThread
//
// This routine is invoked by CreateThread() function in NLedDriverSetDevice when
// caller attempts to change the configuration of a notification LED to 'Blink' mode
//
// Parameters:
//      InputParm 
//          [in] LPVOID lParam
//
// Returns:  
//      This routine returns 0
//
//-----------------------------------------------------------------------------
DWORD WINAPI LEDBlinkThread(LPVOID lParam)
{	
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+NLedDriverSetDeviceThread\r\n")));

    NLED_SETTINGS_INFO *pNledSettingsInfo = (struct NLED_SETTINGS_INFO*)lParam;
    UINT LedIndex = pNledSettingsInfo->LedNum;
    DWORD OnTimeOut = (DWORD)(pNledSettingsInfo->OnTime/1000);	// to convert micro to milli-seconds 
    DWORD OffTimeOut = (DWORD)(pNledSettingsInfo->OffTime/1000);	// to convert micro to milli-seconds 

    g_NLedPddContext[LedIndex].bLEDBlinkState = TRUE;
	
    while(1)
    {		
	 TurnOnLED(LedIndex);
	 g_NLedPddContext[LedIndex].bLEDState = TRUE;
        
        if(WaitForSingleObject(g_NLedPddContext[LedIndex].hNLedBlinkThreadEvent, OnTimeOut) == WAIT_OBJECT_0)		
            break;
		
	TurnOffLED(LedIndex);
	g_NLedPddContext[LedIndex].bLEDState = FALSE;
               
        if(WaitForSingleObject(g_NLedPddContext[LedIndex].hNLedBlinkThreadEvent, OffTimeOut) == WAIT_OBJECT_0)			
            break;
        
    }
    
    SetEvent(g_NLedPddContext[LedIndex].hNLedBlinkThreadStoppedEvent);
    
    g_NLedPddContext[LedIndex].bLEDBlinkState = FALSE;
    
    DEBUGMSG(ZONE_FUNCTION, (TEXT("-NLedDriverSetDeviceThread\r\n")));
    
    return 0;
}