/******************************************************************************
|
*
|
* Copyright(c) 2007 - 2017 Realtek Corporation.
|
*
|
* This program is free software; you can redistribute it and/or modify it
|
* under the terms of version 2 of the GNU General Public License as
|
* published by the Free Software Foundation.
|
*
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
* more details.
|
*
|
*****************************************************************************/
|
|
#include <drv_types.h>
|
#include <hal_data.h>
|
#ifdef CONFIG_RTW_SW_LED
|
|
/*
|
* Description:
|
* Turn on LED according to LedPin specified.
|
* */
|
void
|
HwLedBlink(
|
PADAPTER Adapter,
|
PLED_PCIE pLed
|
)
|
{
|
|
|
switch (pLed->LedPin) {
|
case LED_PIN_GPIO0:
|
break;
|
|
case LED_PIN_LED0:
|
/* rtw_write8(Adapter, LED0Cfg, 0x2); */
|
break;
|
|
case LED_PIN_LED1:
|
/* rtw_write8(Adapter, LED1Cfg, 0x2); */
|
break;
|
|
default:
|
break;
|
}
|
|
pLed->bLedOn = _TRUE;
|
}
|
|
/*
|
* Description:
|
* Implement LED blinking behavior for SW_LED_MODE0.
|
* It toggle off LED and schedule corresponding timer if necessary.
|
* */
|
void
|
SwLedBlink(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
BOOLEAN bStopBlinking = _FALSE;
|
|
/* Change LED according to BlinkingLedState specified. */
|
if (pLed->BlinkingLedState == RTW_LED_ON) {
|
SwLedOn(Adapter, pLed);
|
} else {
|
SwLedOff(Adapter, pLed);
|
}
|
|
/* Determine if we shall change LED state again. */
|
pLed->BlinkTimes--;
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
case LED_BLINK_TXRX:
|
case LED_BLINK_RUNTOP:
|
if (pLed->BlinkTimes == 0)
|
bStopBlinking = _TRUE;
|
break;
|
|
case LED_BLINK_SCAN:
|
if (((check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, WIFI_ASOC_STATE)) ||
|
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))) && /* Linked. */
|
(!check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY)) && /* Not in scan stage. */
|
(pLed->BlinkTimes % 2 == 0)) /* Even */
|
bStopBlinking = _TRUE;
|
break;
|
|
case LED_BLINK_NO_LINK:
|
case LED_BLINK_StartToBlink:
|
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
|
bStopBlinking = _TRUE;
|
else if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) &&
|
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
|
bStopBlinking = _TRUE;
|
else if (pLed->BlinkTimes == 0)
|
bStopBlinking = _TRUE;
|
break;
|
|
case LED_BLINK_CAMEO:
|
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
|
bStopBlinking = _TRUE;
|
else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) &&
|
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
|
bStopBlinking = _TRUE;
|
break;
|
|
default:
|
bStopBlinking = _TRUE;
|
break;
|
}
|
|
if (bStopBlinking) {
|
if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
|
SwLedOff(Adapter, pLed);
|
else if (pLed->CurrLedState == LED_BLINK_TXRX)
|
SwLedOff(Adapter, pLed);
|
else if (pLed->CurrLedState == LED_BLINK_RUNTOP)
|
SwLedOff(Adapter, pLed);
|
else if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) && pLed->bLedOn == _FALSE)
|
SwLedOn(Adapter, pLed);
|
else if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) && pLed->bLedOn == _TRUE)
|
SwLedOff(Adapter, pLed);
|
|
pLed->BlinkTimes = 0;
|
pLed->bLedBlinkInProgress = _FALSE;
|
} else {
|
/* Assign LED state to toggle. */
|
if (pLed->BlinkingLedState == RTW_LED_ON)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
/* Schedule a timer to toggle LED state. */
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
case LED_BLINK_TXRX:
|
case LED_BLINK_StartToBlink:
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
break;
|
|
case LED_BLINK_SLOWLY:
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
|
break;
|
|
case LED_BLINK_SCAN:
|
case LED_BLINK_NO_LINK:
|
if (pLed->bLedOn)
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
else
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
|
break;
|
|
case LED_BLINK_RUNTOP:
|
_set_timer(&(pLed->BlinkTimer), LED_RunTop_BLINK_INTERVAL);
|
break;
|
|
case LED_BLINK_CAMEO:
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
|
break;
|
|
default:
|
/* RTW_INFO("SwLedCm2Blink(): unexpected state!\n"); */
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
|
break;
|
}
|
}
|
}
|
|
void
|
SwLedBlink5(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
BOOLEAN bStopBlinking = _FALSE;
|
|
/* Change LED according to BlinkingLedState specified. */
|
if (pLed->BlinkingLedState == RTW_LED_ON) {
|
SwLedOn(Adapter, pLed);
|
} else {
|
SwLedOff(Adapter, pLed);
|
}
|
|
switch (pLed->CurrLedState) {
|
case RTW_LED_OFF:
|
SwLedOff(Adapter, pLed);
|
break;
|
|
case LED_BLINK_SLOWLY:
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_NETTRONIX);
|
break;
|
|
case LED_BLINK_NORMAL:
|
pLed->BlinkTimes--;
|
if (pLed->BlinkTimes == 0)
|
bStopBlinking = _TRUE;
|
if (bStopBlinking) {
|
if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
|
SwLedOff(Adapter, pLed);
|
else {
|
pLed->bLedSlowBlinkInProgress = _TRUE;
|
pLed->CurrLedState = LED_BLINK_SLOWLY;
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_NETTRONIX);
|
}
|
pLed->BlinkTimes = 0;
|
pLed->bLedBlinkInProgress = _FALSE;
|
} else {
|
if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
|
SwLedOff(Adapter, pLed);
|
else {
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL_NETTRONIX);
|
}
|
}
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
|
|
void
|
SwLedBlink6(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
BOOLEAN bStopBlinking = _FALSE;
|
|
/* Change LED according to BlinkingLedState specified. */
|
if (pLed->BlinkingLedState == RTW_LED_ON) {
|
SwLedOn(Adapter, pLed);
|
} else {
|
SwLedOff(Adapter, pLed);
|
}
|
|
switch (pLed->CurrLedState) {
|
case RTW_LED_OFF:
|
SwLedOff(Adapter, pLed);
|
break;
|
|
case LED_BLINK_SLOWLY:
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
|
break;
|
|
case LED_BLINK_NORMAL:
|
pLed->BlinkTimes--;
|
if (pLed->BlinkTimes == 0)
|
bStopBlinking = _TRUE;
|
if (bStopBlinking) {
|
if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
|
SwLedOff(Adapter, pLed);
|
else {
|
pLed->bLedSlowBlinkInProgress = _TRUE;
|
pLed->CurrLedState = LED_BLINK_SLOWLY;
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
|
}
|
pLed->BlinkTimes = 0;
|
pLed->bLedBlinkInProgress = _FALSE;
|
} else {
|
if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on)
|
SwLedOff(Adapter, pLed);
|
else {
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL_PORNET);
|
}
|
}
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
|
void
|
SwLedBlink7(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
|
SwLedOn(Adapter, pLed);
|
}
|
|
|
|
/*
|
* Description:
|
* Implement LED blinking behavior for SW_LED_MODE8.
|
* It toggle off LED and schedule corresponding timer if necessary.
|
* */
|
void
|
SwLedBlink8(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
BOOLEAN bStopBlinking = _FALSE;
|
|
/* Change LED according to BlinkingLedState specified. */
|
if (pLed->BlinkingLedState == RTW_LED_ON) {
|
SwLedOn(Adapter, pLed);
|
} else {
|
SwLedOff(Adapter, pLed);
|
}
|
|
|
/* Determine if we shall change LED state again. */
|
if (pLed->CurrLedState != LED_BLINK_NO_LINK)
|
pLed->BlinkTimes--;
|
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
case LED_BLINK_SCAN:
|
if (pLed->BlinkTimes == 0)
|
bStopBlinking = _TRUE;
|
break;
|
|
default:
|
break;
|
}
|
|
if (bStopBlinking) {
|
if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
|
pLed->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed);
|
} else {
|
pLed->CurrLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed);
|
}
|
|
pLed->BlinkTimes = 0;
|
pLed->bLedBlinkInProgress = _FALSE;
|
} else {
|
/* Assign LED state to toggle. */
|
if (pLed->BlinkingLedState == RTW_LED_ON)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
/* Schedule a timer to toggle LED state. */
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
break;
|
|
default:
|
/* RTW_INFO("SwLedCm8Blink(): unexpected state!\n"); */
|
break;
|
}
|
}
|
}
|
|
void
|
SwLedBlink9(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
BOOLEAN bStopBlinking = _FALSE;
|
|
/* Change LED according to BlinkingLedState specified. */
|
if (pLed->BlinkingLedState == RTW_LED_ON) {
|
SwLedOn(Adapter, pLed);
|
} else {
|
SwLedOff(Adapter, pLed);
|
}
|
|
/* Determine if we shall change LED state again. */
|
if (pLed->CurrLedState != LED_BLINK_NO_LINK)
|
pLed->BlinkTimes--;
|
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
case LED_BLINK_SCAN:
|
if (pLed->BlinkTimes == 0)
|
bStopBlinking = _TRUE;
|
break;
|
|
case LED_BLINK_NO_LINK:
|
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
|
bStopBlinking = _TRUE;
|
else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) &&
|
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
|
bStopBlinking = _TRUE;
|
break;
|
|
default:
|
break;
|
}
|
|
if (bStopBlinking) {
|
if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
|
pLed->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed);
|
} else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
|
pLed->CurrLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed);
|
} else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
if (pLed->bLedOn)
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
else
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
}
|
|
pLed->BlinkTimes = 0;
|
if (pLed->CurrLedState != LED_BLINK_NO_LINK)
|
pLed->bLedBlinkInProgress = _FALSE;
|
} else {
|
/* Assign LED state to toggle. */
|
if (pLed->BlinkingLedState == RTW_LED_ON)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
/* Schedule a timer to toggle LED state. */
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_FAST_INTERVAL_BITLAND);
|
break;
|
|
case LED_BLINK_SCAN:
|
case LED_BLINK_NO_LINK:
|
if (pLed->bLedOn)
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
else
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
break;
|
|
default:
|
/* RTW_INFO("SwLedCm2Blink(): unexpected state!\n"); */
|
break;
|
}
|
}
|
|
|
}
|
|
|
void
|
SwLedBlink10(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
BOOLEAN bStopBlinking = _FALSE;
|
|
/* Change LED according to BlinkingLedState specified. */
|
if (pLed->BlinkingLedState == RTW_LED_ON) {
|
SwLedOn(Adapter, pLed);
|
} else {
|
SwLedOff(Adapter, pLed);
|
}
|
|
/* Determine if we shall change LED state again. */
|
if (pLed->CurrLedState != LED_BLINK_NO_LINK)
|
pLed->BlinkTimes--;
|
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
case LED_BLINK_SCAN:
|
if (pLed->BlinkTimes == 0)
|
bStopBlinking = _TRUE;
|
break;
|
default:
|
break;
|
}
|
|
if (bStopBlinking) {
|
pLed->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed);
|
|
pLed->BlinkTimes = 0;
|
pLed->bLedBlinkInProgress = _FALSE;
|
} else {
|
/* Assign LED state to toggle. */
|
if (pLed->BlinkingLedState == RTW_LED_ON)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
/* Schedule a timer to toggle LED state. */
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
case LED_BLINK_SCAN:
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_FAST_INTERVAL_BITLAND);
|
break;
|
|
default:
|
/* RT_ASSERT(_FALSE, ("SwLedCm2Blink(): unexpected state!\n")); */
|
break;
|
}
|
}
|
|
|
}
|
|
|
void
|
SwLedBlink11(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
BOOLEAN bStopBlinking = _FALSE;
|
|
/* Change LED according to BlinkingLedState specified. */
|
if (pLed->bLedBlinkInProgress == _TRUE) {
|
if (pLed->BlinkingLedState == RTW_LED_ON) {
|
SwLedOn(Adapter, pLed);
|
} else {
|
SwLedOff(Adapter, pLed);
|
}
|
}
|
|
/* Determine if we shall change LED state again. */
|
if (pLed->CurrLedState != LED_BLINK_NO_LINK)
|
pLed->BlinkTimes--;
|
|
switch (pLed->CurrLedState) {
|
case RTW_LED_ON:
|
bStopBlinking = _TRUE; /* LED on for 3 seconds */
|
default:
|
break;
|
}
|
|
if (bStopBlinking) {
|
pLed->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed);
|
|
pLed->BlinkTimes = 0;
|
pLed->bLedBlinkInProgress = _FALSE;
|
} else {
|
/* Assign LED state to toggle. */
|
if (pLed->BlinkingLedState == RTW_LED_ON)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
/* Schedule a timer to toggle LED state. */
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_XAVI:
|
_set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
|
break;
|
|
default:
|
/* RT_ASSERT(_FALSE, ("SwLedCm11Blink(): unexpected state!\n")); */
|
break;
|
}
|
}
|
|
|
}
|
|
|
void
|
SwLedBlink12(
|
PLED_PCIE pLed
|
)
|
{
|
PADAPTER Adapter = pLed->padapter;
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
BOOLEAN bStopBlinking = _FALSE;
|
|
/* Change LED according to BlinkingLedState specified. */
|
if (pLed->BlinkingLedState == RTW_LED_ON) {
|
SwLedOn(Adapter, pLed);
|
} else {
|
SwLedOff(Adapter, pLed);
|
}
|
|
/* Determine if we shall change LED state again. */
|
if (pLed->CurrLedState != LED_BLINK_NO_LINK && pLed->CurrLedState != LED_BLINK_Azurewave_5Mbps
|
&& pLed->CurrLedState != LED_BLINK_Azurewave_10Mbps && pLed->CurrLedState != LED_BLINK_Azurewave_20Mbps
|
&& pLed->CurrLedState != LED_BLINK_Azurewave_40Mbps && pLed->CurrLedState != LED_BLINK_Azurewave_80Mbps
|
&& pLed->CurrLedState != LED_BLINK_Azurewave_MAXMbps)
|
pLed->BlinkTimes--;
|
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_NORMAL:
|
case LED_BLINK_SCAN:
|
if (pLed->BlinkTimes == 0)
|
bStopBlinking = _TRUE;
|
break;
|
|
case LED_BLINK_NO_LINK:
|
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) && check_fwstate(pmlmepriv, WIFI_STATION_STATE))
|
bStopBlinking = _TRUE;
|
else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) &&
|
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
|
bStopBlinking = _TRUE;
|
break;
|
|
case LED_BLINK_Azurewave_5Mbps:
|
case LED_BLINK_Azurewave_10Mbps:
|
case LED_BLINK_Azurewave_20Mbps:
|
case LED_BLINK_Azurewave_40Mbps:
|
case LED_BLINK_Azurewave_80Mbps:
|
case LED_BLINK_Azurewave_MAXMbps:
|
/* if(pTurboCa->TxThroughput + pTurboCa->RxThroughput == 0) */
|
/* bStopBlinking = _TRUE; */
|
|
default:
|
break;
|
}
|
|
if (bStopBlinking) {
|
if (adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS) {
|
pLed->CurrLedState = RTW_LED_OFF;
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed);
|
} else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
|
pLed->CurrLedState = RTW_LED_ON;
|
pLed->BlinkingLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed);
|
} else if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _FALSE) {
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
}
|
}
|
|
pLed->BlinkTimes = 0;
|
if (pLed->CurrLedState != LED_BLINK_NO_LINK)
|
pLed->bLedBlinkInProgress = _FALSE;
|
} else {
|
/* Assign LED state to toggle. */
|
if (pLed->BlinkingLedState == RTW_LED_ON)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
/* Schedule a timer to toggle LED state. */
|
switch (pLed->CurrLedState) {
|
case LED_BLINK_Azurewave_5Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_5Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_10Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_10Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_20Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_20Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_40Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_40Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_80Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_80Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_MAXMbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_MAXMbps);
|
break;
|
|
case LED_BLINK_SCAN:
|
case LED_BLINK_NO_LINK:
|
if (pLed->bLedOn)
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
else
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
break;
|
|
default:
|
/* RT_ASSERT(_FALSE, ("SwLedCm12Blink(): unexpected state!\n")); */
|
break;
|
}
|
}
|
|
|
}
|
|
/*
|
* Description:
|
* Handler function of LED Blinking.
|
* We dispatch acture LED blink action according to LedStrategy.
|
* */
|
void BlinkHandler(PLED_PCIE pLed)
|
{
|
_adapter *padapter = pLed->padapter;
|
struct led_priv *ledpriv = adapter_to_led(padapter);
|
|
if (RTW_CANNOT_RUN(padapter))
|
return;
|
|
if (IS_HARDWARE_TYPE_8188E(padapter) ||
|
IS_HARDWARE_TYPE_JAGUAR(padapter) ||
|
IS_HARDWARE_TYPE_8723B(padapter) ||
|
IS_HARDWARE_TYPE_8192E(padapter))
|
return;
|
|
switch (ledpriv->LedStrategy) {
|
#if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
|
case SW_LED_MODE_UC_TRX_ONLY:
|
rtw_sw_led_blink_uc_trx_only(pLed);
|
break;
|
#endif
|
|
case SW_LED_MODE1:
|
/* SwLedBlink(pLed); */
|
break;
|
case SW_LED_MODE2:
|
/* SwLedBlink(pLed); */
|
break;
|
case SW_LED_MODE3:
|
/* SwLedBlink(pLed); */
|
break;
|
case SW_LED_MODE5:
|
/* SwLedBlink5(pLed); */
|
break;
|
case SW_LED_MODE6:
|
/* SwLedBlink6(pLed); */
|
break;
|
case SW_LED_MODE7:
|
SwLedBlink7(pLed);
|
break;
|
case SW_LED_MODE8:
|
SwLedBlink8(pLed);
|
break;
|
|
case SW_LED_MODE9:
|
SwLedBlink9(pLed);
|
break;
|
|
case SW_LED_MODE10:
|
SwLedBlink10(pLed);
|
break;
|
|
case SW_LED_MODE11:
|
SwLedBlink11(pLed);
|
break;
|
|
case SW_LED_MODE12:
|
SwLedBlink12(pLed);
|
break;
|
|
default:
|
/* SwLedBlink(pLed); */
|
break;
|
}
|
}
|
|
/*
|
* Description:
|
* Callback function of LED BlinkTimer,
|
* it just schedules to corresponding BlinkWorkItem/led_blink_hdl
|
* */
|
void BlinkTimerCallback(void *data)
|
{
|
PLED_PCIE pLed = (PLED_PCIE)data;
|
_adapter *padapter = pLed->padapter;
|
|
/* RTW_INFO("%s\n", __FUNCTION__); */
|
|
if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
|
/*RTW_INFO("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
|
, __func__
|
, rtw_is_drv_stopped(padapter)?"True":"False"
|
, rtw_is_surprise_removed(padapter)?"True":"False" );
|
*/
|
return;
|
}
|
|
#ifdef CONFIG_RTW_LED_HANDLED_BY_CMD_THREAD
|
rtw_led_blink_cmd(padapter, pLed);
|
#else
|
BlinkHandler(pLed);
|
#endif
|
}
|
|
/*
|
* Description:
|
* Implement each led action for SW_LED_MODE0. */
|
void
|
SwLedControlMode0(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed0 = &(ledpriv->SwLed0);
|
PLED_PCIE pLed1 = &(ledpriv->SwLed1);
|
|
switch (LedAction) {
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
break;
|
|
case LED_CTL_LINK:
|
pLed0->CurrLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed0);
|
|
pLed1->CurrLedState = LED_BLINK_NORMAL;
|
HwLedBlink(Adapter, pLed1);
|
break;
|
|
case LED_CTL_POWER_ON:
|
pLed0->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed0);
|
|
pLed1->CurrLedState = LED_BLINK_NORMAL;
|
HwLedBlink(Adapter, pLed1);
|
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed0->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed0);
|
|
pLed1->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed1);
|
break;
|
|
case LED_CTL_SITE_SURVEY:
|
break;
|
|
case LED_CTL_NO_LINK:
|
pLed0->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed0);
|
|
pLed1->CurrLedState = LED_BLINK_NORMAL;
|
HwLedBlink(Adapter, pLed1);
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
|
|
void
|
SwLedControlMode1(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
PLED_PCIE pLed = &(ledpriv->SwLed1);
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
if (pLed->bLedBlinkInProgress == _FALSE) {
|
pLed->bLedBlinkInProgress = _TRUE;
|
|
pLed->CurrLedState = LED_BLINK_NORMAL;
|
pLed->BlinkTimes = 2;
|
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
}
|
break;
|
|
case LED_CTL_SITE_SURVEY:
|
if (pLed->bLedBlinkInProgress == _FALSE) {
|
pLed->bLedBlinkInProgress = _TRUE;
|
|
if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) && check_fwstate(pmlmepriv, WIFI_STATION_STATE)) ||
|
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))) {
|
pLed->CurrLedState = LED_BLINK_SCAN;
|
pLed->BlinkTimes = 4;
|
} else {
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
pLed->BlinkTimes = 24;
|
}
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
|
}
|
} else {
|
if (pLed->CurrLedState != LED_BLINK_NO_LINK) {
|
if ((check_fwstate(pmlmepriv, WIFI_ASOC_STATE) && check_fwstate(pmlmepriv, WIFI_STATION_STATE)) ||
|
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
|
pLed->CurrLedState = LED_BLINK_SCAN;
|
else
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
}
|
}
|
break;
|
|
case LED_CTL_NO_LINK:
|
if (pLed->bLedBlinkInProgress == _FALSE) {
|
pLed->bLedBlinkInProgress = _TRUE;
|
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
pLed->BlinkTimes = 24;
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
|
}
|
} else
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
break;
|
|
case LED_CTL_LINK:
|
pLed->CurrLedState = RTW_LED_ON;
|
if (pLed->bLedBlinkInProgress == _FALSE)
|
SwLedOn(Adapter, pLed);
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed->CurrLedState = RTW_LED_OFF;
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed);
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
|
void
|
SwLedControlMode2(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
PLED_PCIE pLed0 = &(ledpriv->SwLed0);
|
PLED_PCIE pLed1 = &(ledpriv->SwLed1);
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_POWER_ON:
|
pLed0->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed0);
|
|
pLed1->CurrLedState = LED_BLINK_CAMEO;
|
if (pLed1->bLedBlinkInProgress == _FALSE) {
|
pLed1->bLedBlinkInProgress = _TRUE;
|
|
pLed1->BlinkTimes = 6;
|
|
if (pLed1->bLedOn)
|
pLed1->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed1->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed1->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
|
}
|
break;
|
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
if (pLed0->bLedBlinkInProgress == _FALSE) {
|
pLed0->bLedBlinkInProgress = _TRUE;
|
|
pLed0->CurrLedState = LED_BLINK_TXRX;
|
pLed0->BlinkTimes = 2;
|
|
if (pLed0->bLedOn)
|
pLed0->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed0->BlinkingLedState = RTW_LED_ON;
|
|
_set_timer(&(pLed0->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
}
|
break;
|
|
case LED_CTL_NO_LINK:
|
pLed1->CurrLedState = LED_BLINK_CAMEO;
|
if (pLed1->bLedBlinkInProgress == _FALSE) {
|
pLed1->bLedBlinkInProgress = _TRUE;
|
|
pLed1->BlinkTimes = 6;
|
|
if (pLed1->bLedOn)
|
pLed1->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed1->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed1->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
|
}
|
break;
|
|
case LED_CTL_LINK:
|
pLed1->CurrLedState = RTW_LED_ON;
|
if (pLed1->bLedBlinkInProgress == _FALSE)
|
SwLedOn(Adapter, pLed1);
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed0->CurrLedState = RTW_LED_OFF;
|
pLed1->CurrLedState = RTW_LED_OFF;
|
if (pLed0->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
if (pLed1->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed1->BlinkTimer));
|
pLed1->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed0);
|
SwLedOff(Adapter, pLed1);
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
|
|
|
void
|
SwLedControlMode3(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed0 = &(ledpriv->SwLed0);
|
PLED_PCIE pLed1 = &(ledpriv->SwLed1);
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_POWER_ON:
|
pLed0->CurrLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed0);
|
pLed1->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed1);
|
break;
|
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
if (pLed1->bLedBlinkInProgress == _FALSE) {
|
pLed1->bLedBlinkInProgress = _TRUE;
|
|
pLed1->CurrLedState = LED_BLINK_RUNTOP;
|
pLed1->BlinkTimes = 2;
|
|
if (pLed1->bLedOn)
|
pLed1->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed1->BlinkingLedState = RTW_LED_ON;
|
|
_set_timer(&(pLed1->BlinkTimer), LED_RunTop_BLINK_INTERVAL);
|
}
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed0->CurrLedState = RTW_LED_OFF;
|
pLed1->CurrLedState = RTW_LED_OFF;
|
if (pLed0->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
if (pLed1->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed1->BlinkTimer));
|
pLed1->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed0);
|
SwLedOff(Adapter, pLed1);
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
|
|
void
|
SwLedControlMode4(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed0 = &(ledpriv->SwLed0);
|
PLED_PCIE pLed1 = &(ledpriv->SwLed1);
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_POWER_ON:
|
pLed1->CurrLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed1);
|
pLed0->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed0);
|
break;
|
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
if (pLed0->bLedBlinkInProgress == _FALSE) {
|
pLed0->bLedBlinkInProgress = _TRUE;
|
|
pLed0->CurrLedState = LED_BLINK_RUNTOP;
|
pLed0->BlinkTimes = 2;
|
|
if (pLed0->bLedOn)
|
pLed0->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed0->BlinkingLedState = RTW_LED_ON;
|
|
_set_timer(&(pLed0->BlinkTimer), LED_RunTop_BLINK_INTERVAL);
|
}
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed0->CurrLedState = RTW_LED_OFF;
|
pLed1->CurrLedState = RTW_LED_OFF;
|
if (pLed0->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
if (pLed1->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed1->BlinkTimer));
|
pLed1->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed0);
|
SwLedOff(Adapter, pLed1);
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
|
/* added by vivi, for led new mode */
|
void
|
SwLedControlMode5(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed0 = &(ledpriv->SwLed0);
|
PLED_PCIE pLed1 = &(ledpriv->SwLed1);
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_POWER_ON:
|
case LED_CTL_START_TO_LINK:
|
case LED_CTL_NO_LINK:
|
pLed1->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed1);
|
|
|
if (pLed0->bLedSlowBlinkInProgress == _FALSE) {
|
pLed0->bLedSlowBlinkInProgress = _TRUE;
|
pLed0->CurrLedState = LED_BLINK_SLOWLY;
|
if (pLed0->bLedOn)
|
pLed0->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed0->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed0->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_NETTRONIX);
|
}
|
|
break;
|
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
pLed1->CurrLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed1);
|
|
if (pLed0->bLedBlinkInProgress == _FALSE) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedSlowBlinkInProgress = _FALSE;
|
pLed0->bLedBlinkInProgress = _TRUE;
|
pLed0->CurrLedState = LED_BLINK_NORMAL;
|
pLed0->BlinkTimes = 2;
|
|
if (pLed0->bLedOn)
|
pLed0->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed0->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed0->BlinkTimer), LED_BLINK_NORMAL_INTERVAL_NETTRONIX);
|
}
|
break;
|
|
case LED_CTL_LINK:
|
pLed1->CurrLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed1);
|
|
if (pLed0->bLedSlowBlinkInProgress == _FALSE) {
|
pLed0->bLedSlowBlinkInProgress = _TRUE;
|
pLed0->CurrLedState = LED_BLINK_SLOWLY;
|
if (pLed0->bLedOn)
|
pLed0->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed0->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed0->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_NETTRONIX);
|
}
|
break;
|
|
|
case LED_CTL_POWER_OFF:
|
pLed0->CurrLedState = RTW_LED_OFF;
|
pLed1->CurrLedState = RTW_LED_OFF;
|
if (pLed0->bLedSlowBlinkInProgress == _TRUE) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedSlowBlinkInProgress = _FALSE;
|
}
|
if (pLed0->bLedBlinkInProgress == _TRUE) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed0);
|
SwLedOff(Adapter, pLed1);
|
break;
|
|
default:
|
break;
|
}
|
|
|
}
|
|
/* added by vivi, for led new mode */
|
void
|
SwLedControlMode6(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed0 = &(ledpriv->SwLed0);
|
PLED_PCIE pLed1 = &(ledpriv->SwLed1);
|
|
|
switch (LedAction) {
|
case LED_CTL_POWER_ON:
|
case LED_CTL_START_TO_LINK:
|
case LED_CTL_NO_LINK:
|
case LED_CTL_LINK:
|
case LED_CTL_SITE_SURVEY:
|
pLed1->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed1);
|
|
if (pLed0->bLedSlowBlinkInProgress == _FALSE) {
|
pLed0->bLedSlowBlinkInProgress = _TRUE;
|
pLed0->CurrLedState = LED_BLINK_SLOWLY;
|
if (pLed0->bLedOn)
|
pLed0->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed0->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed0->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL_PORNET);
|
}
|
break;
|
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
pLed1->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed1);
|
if (pLed0->bLedBlinkInProgress == _FALSE) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedSlowBlinkInProgress = _FALSE;
|
pLed0->bLedBlinkInProgress = _TRUE;
|
pLed0->CurrLedState = LED_BLINK_NORMAL;
|
pLed0->BlinkTimes = 2;
|
if (pLed0->bLedOn)
|
pLed0->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed0->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed0->BlinkTimer), LED_BLINK_NORMAL_INTERVAL_PORNET);
|
}
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed1->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed1);
|
|
pLed0->CurrLedState = RTW_LED_OFF;
|
if (pLed0->bLedSlowBlinkInProgress == _TRUE) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedSlowBlinkInProgress = _FALSE;
|
}
|
if (pLed0->bLedBlinkInProgress == _TRUE) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed0);
|
break;
|
|
default:
|
break;
|
|
}
|
}
|
|
|
/* added by chiyokolin, for Lenovo */
|
void
|
SwLedControlMode7(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed0 = &(ledpriv->SwLed0);
|
|
switch (LedAction) {
|
case LED_CTL_POWER_ON:
|
case LED_CTL_LINK:
|
case LED_CTL_NO_LINK:
|
SwLedOn(Adapter, pLed0);
|
break;
|
|
case LED_CTL_POWER_OFF:
|
SwLedOff(Adapter, pLed0);
|
break;
|
|
default:
|
break;
|
}
|
}
|
|
/* added by chiyokolin, for QMI */
|
void
|
SwLedControlMode8(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed = &(ledpriv->SwLed0);
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
if (pLed->bLedBlinkInProgress == _FALSE && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
|
pLed->bLedBlinkInProgress = _TRUE;
|
|
pLed->CurrLedState = LED_BLINK_NORMAL;
|
pLed->BlinkTimes = 2;
|
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
}
|
break;
|
|
case LED_CTL_SITE_SURVEY:
|
case LED_CTL_POWER_ON:
|
case LED_CTL_NO_LINK:
|
case LED_CTL_LINK:
|
pLed->CurrLedState = RTW_LED_ON;
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOn(Adapter, pLed);
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed->CurrLedState = RTW_LED_OFF;
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed);
|
break;
|
|
default:
|
break;
|
}
|
}
|
|
/* added by chiyokolin, for MSI */
|
void
|
SwLedControlMode9(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed = &(ledpriv->SwLed0);
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
if (pLed->bLedBlinkInProgress == _FALSE && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
|
pLed->bLedBlinkInProgress = _TRUE;
|
|
pLed->CurrLedState = LED_BLINK_NORMAL;
|
pLed->BlinkTimes = 2;
|
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_BLINK_FAST_INTERVAL_BITLAND);
|
}
|
break;
|
|
case LED_CTL_SITE_SURVEY:
|
if (pLed->bLedBlinkInProgress == _FALSE) {
|
pLed->bLedBlinkInProgress = _TRUE;
|
pLed->CurrLedState = LED_BLINK_SCAN;
|
pLed->BlinkTimes = 2;
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
}
|
} else if (pLed->CurrLedState != LED_BLINK_SCAN) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->CurrLedState = LED_BLINK_SCAN;
|
pLed->BlinkTimes = 2;
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
}
|
}
|
break;
|
|
case LED_CTL_POWER_ON:
|
case LED_CTL_NO_LINK:
|
if (pLed->bLedBlinkInProgress == _FALSE) {
|
pLed->bLedBlinkInProgress = _TRUE;
|
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
pLed->BlinkTimes = 24;
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
}
|
} else if (pLed->CurrLedState != LED_BLINK_SCAN && pLed->CurrLedState != LED_BLINK_NO_LINK) {
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
pLed->BlinkTimes = 24;
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
}
|
}
|
break;
|
|
case LED_CTL_LINK:
|
pLed->CurrLedState = RTW_LED_ON;
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOn(Adapter, pLed);
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed->CurrLedState = RTW_LED_OFF;
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed);
|
break;
|
|
default:
|
break;
|
}
|
|
|
}
|
|
|
/* added by chiyokolin, for Edimax-ASUS */
|
void
|
SwLedControlMode10(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed0 = &(ledpriv->SwLed0);
|
PLED_PCIE pLed1 = &(ledpriv->SwLed1);
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
if (pLed1->bLedBlinkInProgress == _FALSE && pLed1->bLedWPSBlinkInProgress == _FALSE &&
|
(check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
|
pLed1->bLedBlinkInProgress = _TRUE;
|
|
pLed1->CurrLedState = LED_BLINK_NORMAL;
|
pLed1->BlinkTimes = 2;
|
|
if (pLed1->bLedOn)
|
pLed1->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed1->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
}
|
break;
|
|
case LED_CTL_SITE_SURVEY:
|
if (pLed1->bLedBlinkInProgress == _FALSE && pLed1->bLedWPSBlinkInProgress == _FALSE) {
|
pLed1->bLedBlinkInProgress = _TRUE;
|
pLed1->CurrLedState = LED_BLINK_SCAN;
|
pLed1->BlinkTimes = 12;
|
|
if (pLed1->bLedOn) {
|
pLed1->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
} else {
|
pLed1->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
}
|
} else if (pLed1->CurrLedState != LED_BLINK_SCAN && pLed1->bLedWPSBlinkInProgress == _FALSE) {
|
_cancel_timer_ex(&(pLed1->BlinkTimer));
|
pLed1->CurrLedState = LED_BLINK_SCAN;
|
pLed1->BlinkTimes = 24;
|
|
if (pLed1->bLedOn) {
|
pLed1->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
} else {
|
pLed1->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
|
}
|
}
|
break;
|
|
case LED_CTL_START_WPS:
|
case LED_CTL_START_WPS_BOTTON:
|
pLed1->CurrLedState = RTW_LED_ON;
|
if (pLed1->bLedBlinkInProgress == _TRUE) {
|
_cancel_timer_ex(&(pLed1->BlinkTimer));
|
pLed1->bLedBlinkInProgress = _FALSE;
|
}
|
|
if (pLed1->bLedWPSBlinkInProgress == _FALSE) {
|
pLed1->bLedWPSBlinkInProgress = _TRUE;
|
SwLedOn(Adapter, pLed1);
|
}
|
break;
|
|
case LED_CTL_STOP_WPS:
|
case LED_CTL_STOP_WPS_FAIL:
|
case LED_CTL_STOP_WPS_FAIL_OVERLAP:
|
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
|
pLed0->CurrLedState = RTW_LED_ON;
|
if (pLed0->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOn(Adapter, pLed0);
|
} else {
|
pLed0->CurrLedState = RTW_LED_OFF;
|
if (pLed0->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed0);
|
}
|
|
pLed1->CurrLedState = RTW_LED_OFF;
|
if (pLed1->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed1->BlinkTimer));
|
pLed1->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed1);
|
|
pLed1->bLedWPSBlinkInProgress = _FALSE;
|
|
break;
|
|
case LED_CTL_LINK:
|
pLed0->CurrLedState = RTW_LED_ON;
|
if (pLed0->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOn(Adapter, pLed0);
|
break;
|
|
case LED_CTL_NO_LINK:
|
if (pLed1->bLedWPSBlinkInProgress == _TRUE) {
|
SwLedOn(Adapter, pLed1);
|
break;
|
}
|
|
if (pLed1->CurrLedState == LED_BLINK_SCAN)
|
break;
|
|
pLed0->CurrLedState = RTW_LED_OFF;
|
if (pLed0->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed0);
|
|
pLed1->CurrLedState = RTW_LED_OFF;
|
if (pLed1->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed1->BlinkTimer));
|
pLed1->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed1);
|
|
break;
|
|
|
case LED_CTL_POWER_ON:
|
case LED_CTL_POWER_OFF:
|
if (pLed1->bLedWPSBlinkInProgress == _TRUE) {
|
SwLedOn(Adapter, pLed1);
|
break;
|
}
|
pLed0->CurrLedState = RTW_LED_OFF;
|
if (pLed0->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed0->BlinkTimer));
|
pLed0->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed0);
|
|
pLed1->CurrLedState = RTW_LED_OFF;
|
if (pLed1->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed1->BlinkTimer));
|
pLed1->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed1);
|
|
break;
|
|
default:
|
break;
|
|
}
|
|
|
}
|
|
|
/* added by hpfan, for Xavi */
|
void
|
SwLedControlMode11(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed = &(ledpriv->SwLed0);
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_START_WPS:
|
case LED_CTL_START_WPS_BOTTON:
|
pLed->bLedWPSBlinkInProgress = _TRUE;
|
if (pLed->bLedBlinkInProgress == _FALSE) {
|
pLed->bLedBlinkInProgress = _TRUE;
|
pLed->CurrLedState = LED_BLINK_XAVI;
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
|
}
|
}
|
break;
|
|
case LED_CTL_STOP_WPS:
|
case LED_CTL_STOP_WPS_FAIL:
|
case LED_CTL_STOP_WPS_FAIL_OVERLAP:
|
pLed->bLedWPSBlinkInProgress = _FALSE;
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
pLed->CurrLedState = RTW_LED_OFF;
|
}
|
SwLedOff(Adapter, pLed);
|
break;
|
|
case LED_CTL_LINK:
|
if (pLed->bLedWPSBlinkInProgress)
|
break;
|
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
pLed->CurrLedState = RTW_LED_ON;
|
|
if (!pLed->bLedOn)
|
SwLedOn(Adapter, pLed);
|
} else {
|
pLed->CurrLedState = RTW_LED_ON;
|
SwLedOn(Adapter, pLed);
|
}
|
|
_set_timer(&(pLed->BlinkTimer), LED_CM11_LINK_ON_INTERVEL);
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
break;
|
|
case LED_CTL_NO_LINK:
|
if (pLed->bLedWPSBlinkInProgress)
|
break;
|
|
if (pLed->bLedBlinkInProgress == _TRUE) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
pLed->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed);
|
break;
|
|
case LED_CTL_POWER_ON:
|
case LED_CTL_POWER_OFF:
|
if (pLed->bLedBlinkInProgress == _TRUE) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
|
pLed->CurrLedState = RTW_LED_OFF;
|
SwLedOff(Adapter, pLed);
|
break;
|
|
default:
|
break;
|
|
}
|
|
|
}
|
|
/* added by chiyokolin, for Azurewave */
|
void
|
SwLedControlMode12(
|
PADAPTER Adapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed = &(ledpriv->SwLed0);
|
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
|
LED_STATE LedState = LED_UNKNOWN;
|
|
|
/* Decide led state */
|
switch (LedAction) {
|
case LED_CTL_TX:
|
case LED_CTL_RX:
|
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
|
if (pLed->CurrLedState == LED_BLINK_SCAN)
|
break;
|
|
pLed->BlinkTimes = 0;
|
|
if (pLed->bLedOn)
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
else
|
pLed->BlinkingLedState = RTW_LED_ON;
|
|
/*if(pTurboCa->TotalThroughput <= 5)
|
LedState = LED_BLINK_Azurewave_5Mbps;
|
else if(pTurboCa->TotalThroughput <= 10)
|
LedState = LED_BLINK_Azurewave_10Mbps;
|
else if(pTurboCa->TotalThroughput <=20)
|
LedState = LED_BLINK_Azurewave_20Mbps;
|
else if(pTurboCa->TotalThroughput <=40)
|
LedState = LED_BLINK_Azurewave_40Mbps;
|
else if(pTurboCa->TotalThroughput <=80)
|
LedState = LED_BLINK_Azurewave_80Mbps;
|
else*/
|
LedState = LED_BLINK_Azurewave_MAXMbps;
|
|
if (pLed->bLedBlinkInProgress == _FALSE || pLed->CurrLedState != LedState) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->CurrLedState = LedState;
|
pLed->bLedBlinkInProgress = _TRUE;
|
|
switch (LedState) {
|
case LED_BLINK_Azurewave_5Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_5Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_10Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_10Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_20Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_20Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_40Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_40Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_80Mbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_80Mbps);
|
break;
|
|
case LED_BLINK_Azurewave_MAXMbps:
|
_set_timer(&(pLed->BlinkTimer), LED_CM12_BLINK_INTERVAL_MAXMbps);
|
break;
|
|
default:
|
break;
|
}
|
}
|
}
|
|
break;
|
|
case LED_CTL_SITE_SURVEY:
|
case LED_CTL_START_WPS:
|
case LED_CTL_START_WPS_BOTTON:
|
if (pLed->bLedBlinkInProgress == _FALSE)
|
pLed->bLedBlinkInProgress = _TRUE;
|
else if (pLed->CurrLedState != LED_BLINK_SCAN)
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
|
pLed->CurrLedState = LED_BLINK_SCAN;
|
pLed->BlinkTimes = 2;
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
}
|
break;
|
|
case LED_CTL_LINK:
|
pLed->CurrLedState = RTW_LED_ON;
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOn(Adapter, pLed);
|
break;
|
|
case LED_CTL_NO_LINK:
|
case LED_CTL_POWER_ON:
|
if (pLed->CurrLedState == LED_BLINK_SCAN)
|
break;
|
|
pLed->CurrLedState = LED_BLINK_NO_LINK;
|
pLed->bLedBlinkInProgress = _TRUE;
|
|
if (pLed->bLedOn) {
|
pLed->BlinkingLedState = RTW_LED_OFF;
|
_set_timer(&(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
|
} else {
|
pLed->BlinkingLedState = RTW_LED_ON;
|
_set_timer(&(pLed->BlinkTimer), LED_CM8_BLINK_OFF_INTERVAL);
|
}
|
break;
|
|
case LED_CTL_POWER_OFF:
|
pLed->CurrLedState = RTW_LED_OFF;
|
if (pLed->bLedBlinkInProgress) {
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
pLed->bLedBlinkInProgress = _FALSE;
|
}
|
SwLedOff(Adapter, pLed);
|
break;
|
|
default:
|
break;
|
|
}
|
|
|
}
|
|
void
|
LedControlPCIE(
|
_adapter *padapter,
|
LED_CTL_MODE LedAction
|
)
|
{
|
struct led_priv *ledpriv = adapter_to_led(padapter);
|
|
#if (MP_DRIVER == 1)
|
if (padapter->registrypriv.mp_mode == 1)
|
return;
|
#endif
|
|
if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter)))
|
return;
|
|
/* if(priv->bInHctTest) */
|
/* return; */
|
|
if ((adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) &&
|
(LedAction == LED_CTL_TX ||
|
LedAction == LED_CTL_RX ||
|
LedAction == LED_CTL_SITE_SURVEY ||
|
LedAction == LED_CTL_LINK ||
|
LedAction == LED_CTL_NO_LINK ||
|
LedAction == LED_CTL_START_TO_LINK ||
|
LedAction == LED_CTL_POWER_ON)) {
|
return;
|
}
|
|
switch (ledpriv->LedStrategy) {
|
#if CONFIG_RTW_SW_LED_TRX_DA_CLASSIFY
|
case SW_LED_MODE_UC_TRX_ONLY:
|
rtw_sw_led_ctl_mode_uc_trx_only(padapter, LedAction);
|
break;
|
#endif
|
|
case SW_LED_MODE0:
|
/* SwLedControlMode0(padapter, LedAction); */
|
break;
|
|
case SW_LED_MODE1:
|
/* SwLedControlMode1(padapter, LedAction); */
|
break;
|
|
case SW_LED_MODE2:
|
/* SwLedControlMode2(padapter, LedAction); */
|
break;
|
|
case SW_LED_MODE3:
|
/* SwLedControlMode3(padapter, LedAction); */
|
break;
|
|
case SW_LED_MODE4:
|
/* SwLedControlMode4(padapter, LedAction); */
|
break;
|
|
case SW_LED_MODE5:
|
/* SwLedControlMode5(padapter, LedAction); */
|
break;
|
|
case SW_LED_MODE6:
|
/* SwLedControlMode6(padapter, LedAction); */
|
break;
|
|
case SW_LED_MODE7:
|
SwLedControlMode7(padapter, LedAction);
|
break;
|
|
case SW_LED_MODE8:
|
SwLedControlMode8(padapter, LedAction);
|
break;
|
|
case SW_LED_MODE9:
|
SwLedControlMode9(padapter, LedAction);
|
break;
|
|
case SW_LED_MODE10:
|
SwLedControlMode10(padapter, LedAction);
|
break;
|
|
case SW_LED_MODE11:
|
SwLedControlMode11(padapter, LedAction);
|
break;
|
|
case SW_LED_MODE12:
|
SwLedControlMode12(padapter, LedAction);
|
break;
|
|
default:
|
break;
|
}
|
}
|
|
/*-----------------------------------------------------------------------------
|
* Function: gen_RefreshLedState()
|
*
|
* Overview: When we call the function, media status is no link. It must be in SW/HW
|
* radio off. Or IPS state. If IPS no link we will turn on LED, otherwise, we must turn off.
|
* After MAC IO reset, we must write LED control 0x2f2 again.
|
*
|
* Input: PADAPTER Adapter)
|
*
|
* Output: NONE
|
*
|
* Return: NONE
|
*
|
* Revised History:
|
* When Who Remark
|
* 03/27/2009 MHC Create for LED judge only~!!
|
*
|
*---------------------------------------------------------------------------*/
|
void
|
gen_RefreshLedState(
|
PADAPTER Adapter)
|
{
|
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
|
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(Adapter);
|
struct led_priv *pledpriv = adapter_to_led(Adapter);
|
PLED_PCIE pLed0 = &(pledpriv->SwLed0);
|
|
RTW_INFO("gen_RefreshLedState:() pwrctrlpriv->rfoff_reason=%x\n", pwrctrlpriv->rfoff_reason);
|
|
if (Adapter->bDriverIsGoingToUnload) {
|
switch (pledpriv->LedStrategy) {
|
case SW_LED_MODE9:
|
case SW_LED_MODE10:
|
rtw_led_control(Adapter, LED_CTL_POWER_OFF);
|
break;
|
|
default:
|
/* Turn off LED if RF is not ON. */
|
SwLedOff(Adapter, pLed0);
|
break;
|
}
|
} else if (pwrctrlpriv->rfoff_reason == RF_CHANGE_BY_IPS) {
|
switch (pledpriv->LedStrategy) {
|
case SW_LED_MODE7:
|
SwLedOn(Adapter, pLed0);
|
break;
|
|
case SW_LED_MODE8:
|
case SW_LED_MODE9:
|
rtw_led_control(Adapter, LED_CTL_NO_LINK);
|
break;
|
|
default:
|
SwLedOn(Adapter, pLed0);
|
break;
|
}
|
} else if (pwrctrlpriv->rfoff_reason == RF_CHANGE_BY_INIT) {
|
switch (pledpriv->LedStrategy) {
|
case SW_LED_MODE7:
|
SwLedOn(Adapter, pLed0);
|
break;
|
|
case SW_LED_MODE9:
|
rtw_led_control(Adapter, LED_CTL_NO_LINK);
|
break;
|
|
default:
|
SwLedOn(Adapter, pLed0);
|
break;
|
|
}
|
} else { /* SW/HW radio off */
|
|
switch (pledpriv->LedStrategy) {
|
case SW_LED_MODE9:
|
rtw_led_control(Adapter, LED_CTL_POWER_OFF);
|
break;
|
|
default:
|
/* Turn off LED if RF is not ON. */
|
SwLedOff(Adapter, pLed0);
|
break;
|
}
|
}
|
|
}
|
|
/*
|
* Description:
|
* Reset status of LED_871x object.
|
* */
|
void ResetLedStatus(PLED_PCIE pLed)
|
{
|
|
pLed->CurrLedState = RTW_LED_OFF; /* Current LED state. */
|
pLed->bLedOn = _FALSE; /* true if LED is ON, false if LED is OFF. */
|
|
pLed->bLedBlinkInProgress = _FALSE; /* true if it is blinking, false o.w.. */
|
pLed->bLedWPSBlinkInProgress = _FALSE;
|
pLed->bLedSlowBlinkInProgress = _FALSE;
|
|
pLed->BlinkTimes = 0; /* Number of times to toggle led state for blinking. */
|
pLed->BlinkingLedState = LED_UNKNOWN; /* Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are. */
|
}
|
|
/*
|
* Description:
|
* Initialize an LED_871x object.
|
* */
|
void
|
InitLed(
|
_adapter *padapter,
|
PLED_PCIE pLed,
|
LED_PIN LedPin
|
)
|
{
|
pLed->padapter = padapter;
|
pLed->LedPin = LedPin;
|
|
ResetLedStatus(pLed);
|
|
rtw_init_timer(&(pLed->BlinkTimer), padapter, BlinkTimerCallback, pLed);
|
}
|
|
|
/*
|
* Description:
|
* DeInitialize an LED_871x object.
|
* */
|
void
|
DeInitLed(
|
PLED_PCIE pLed
|
)
|
{
|
_cancel_timer_ex(&(pLed->BlinkTimer));
|
ResetLedStatus(pLed);
|
}
|
#endif
|
