Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /******************************************************************************
0003  * rtl8712_led.c
0004  *
0005  * Copyright(c) 2007 - 2010  Realtek Corporation. All rights reserved.
0006  * Linux device driver for RTL8192SU
0007  *
0008  * Modifications for inclusion into the Linux staging tree are
0009  * Copyright(c) 2010 Larry Finger. All rights reserved.
0010  *
0011  * Contact information:
0012  * WLAN FAE <wlanfae@realtek.com>
0013  * Larry Finger <Larry.Finger@lwfinger.net>
0014  *
0015  ******************************************************************************/
0016 
0017 #include "drv_types.h"
0018 
0019 /*===========================================================================
0020  *  Constant.
0021  *===========================================================================
0022 
0023  *
0024  * Default LED behavior.
0025  */
0026 #define LED_BLINK_NORMAL_INTERVAL   100
0027 #define LED_BLINK_SLOWLY_INTERVAL   200
0028 #define LED_BLINK_LONG_INTERVAL 400
0029 
0030 #define LED_BLINK_NO_LINK_INTERVAL_ALPHA    1000
0031 #define LED_BLINK_LINK_INTERVAL_ALPHA       500
0032 #define LED_BLINK_SCAN_INTERVAL_ALPHA       180
0033 #define LED_BLINK_FASTER_INTERVAL_ALPHA     50
0034 #define LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA    5000
0035 
0036 /*===========================================================================
0037  * LED object.
0038  *===========================================================================
0039  */
0040 enum _LED_STATE_871x {
0041     LED_UNKNOWN = 0,
0042     LED_STATE_ON = 1,
0043     LED_STATE_OFF = 2,
0044     LED_BLINK_NORMAL = 3,
0045     LED_BLINK_SLOWLY = 4,
0046     LED_POWER_ON_BLINK = 5,
0047     LED_SCAN_BLINK = 6, /* LED is blinking during scanning period,
0048                  * the # of times to blink is depend on time
0049                  * for scanning.
0050                  */
0051     LED_NO_LINK_BLINK = 7, /* LED is blinking during no link state. */
0052     LED_BLINK_StartToBlink = 8,/* Customized for Sercomm Printer
0053                     * Server case
0054                     */
0055     LED_BLINK_WPS = 9,  /* LED is blinkg during WPS communication */
0056     LED_TXRX_BLINK = 10,
0057     LED_BLINK_WPS_STOP = 11,    /*for ALPHA */
0058     LED_BLINK_WPS_STOP_OVERLAP = 12,    /*for BELKIN */
0059 };
0060 
0061 /*===========================================================================
0062  *  Prototype of protected function.
0063  *===========================================================================
0064  */
0065 static void BlinkTimerCallback(struct timer_list *t);
0066 
0067 static void BlinkWorkItemCallback(struct work_struct *work);
0068 /*===========================================================================
0069  * LED_819xUsb routines.
0070  *===========================================================================
0071  *
0072  *
0073  *
0074  *  Description:
0075  *      Initialize an LED_871x object.
0076  */
0077 static void InitLed871x(struct _adapter *padapter, struct LED_871x *pLed,
0078             enum LED_PIN_871x   LedPin)
0079 {
0080     pLed->padapter = padapter;
0081     pLed->LedPin = LedPin;
0082     pLed->CurrLedState = LED_STATE_OFF;
0083     pLed->bLedOn = false;
0084     pLed->bLedBlinkInProgress = false;
0085     pLed->BlinkTimes = 0;
0086     pLed->BlinkingLedState = LED_UNKNOWN;
0087     timer_setup(&pLed->BlinkTimer, BlinkTimerCallback, 0);
0088     INIT_WORK(&pLed->BlinkWorkItem, BlinkWorkItemCallback);
0089 }
0090 
0091 /*
0092  *  Description:
0093  *      DeInitialize an LED_871x object.
0094  */
0095 static void DeInitLed871x(struct LED_871x *pLed)
0096 {
0097     del_timer_sync(&pLed->BlinkTimer);
0098     /* We should reset bLedBlinkInProgress if we cancel
0099      * the LedControlTimer,
0100      */
0101     pLed->bLedBlinkInProgress = false;
0102 }
0103 
0104 /*
0105  *  Description:
0106  *      Turn on LED according to LedPin specified.
0107  */
0108 static void SwLedOn(struct _adapter *padapter, struct LED_871x *pLed)
0109 {
0110     u8  LedCfg;
0111 
0112     if (padapter->surprise_removed || padapter->driver_stopped)
0113         return;
0114     LedCfg = r8712_read8(padapter, LEDCFG);
0115     switch (pLed->LedPin) {
0116     case LED_PIN_GPIO0:
0117         break;
0118     case LED_PIN_LED0:
0119         /* SW control led0 on.*/
0120         r8712_write8(padapter, LEDCFG, LedCfg & 0xf0);
0121         break;
0122     case LED_PIN_LED1:
0123         /* SW control led1 on.*/
0124         r8712_write8(padapter, LEDCFG, LedCfg & 0x0f);
0125         break;
0126     default:
0127         break;
0128     }
0129     pLed->bLedOn = true;
0130 }
0131 
0132 /*
0133  *  Description:
0134  *      Turn off LED according to LedPin specified.
0135  */
0136 static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed)
0137 {
0138     u8  LedCfg;
0139 
0140     if (padapter->surprise_removed || padapter->driver_stopped)
0141         return;
0142     LedCfg = r8712_read8(padapter, LEDCFG);
0143     switch (pLed->LedPin) {
0144     case LED_PIN_GPIO0:
0145         break;
0146     case LED_PIN_LED0:
0147         LedCfg &= 0xf0; /* Set to software control.*/
0148         r8712_write8(padapter, LEDCFG, (LedCfg | BIT(3)));
0149         break;
0150     case LED_PIN_LED1:
0151         LedCfg &= 0x0f; /* Set to software control.*/
0152         r8712_write8(padapter, LEDCFG, (LedCfg | BIT(7)));
0153         break;
0154     default:
0155         break;
0156     }
0157     pLed->bLedOn = false;
0158 }
0159 
0160 /*===========================================================================
0161  * Interface to manipulate LED objects.
0162  *===========================================================================
0163  *
0164  *  Description:
0165  *      Initialize all LED_871x objects.
0166  */
0167 void r8712_InitSwLeds(struct _adapter *padapter)
0168 {
0169     struct led_priv *pledpriv = &padapter->ledpriv;
0170 
0171     pledpriv->LedControlHandler = LedControl871x;
0172     InitLed871x(padapter, &pledpriv->SwLed0, LED_PIN_LED0);
0173     InitLed871x(padapter, &pledpriv->SwLed1, LED_PIN_LED1);
0174 }
0175 
0176 /*  Description:
0177  *      DeInitialize all LED_819xUsb objects.
0178  */
0179 void r8712_DeInitSwLeds(struct _adapter *padapter)
0180 {
0181     struct led_priv *ledpriv = &padapter->ledpriv;
0182 
0183     DeInitLed871x(&ledpriv->SwLed0);
0184     DeInitLed871x(&ledpriv->SwLed1);
0185 }
0186 
0187 /*  Description:
0188  *      Implementation of LED blinking behavior.
0189  *      It toggle off LED and schedule corresponding timer if necessary.
0190  */
0191 static void SwLedBlink(struct LED_871x *pLed)
0192 {
0193     struct _adapter *padapter = pLed->padapter;
0194     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
0195     u8 bStopBlinking = false;
0196 
0197     /* Change LED according to BlinkingLedState specified. */
0198     if (pLed->BlinkingLedState == LED_STATE_ON)
0199         SwLedOn(padapter, pLed);
0200     else
0201         SwLedOff(padapter, pLed);
0202     /* Determine if we shall change LED state again. */
0203     pLed->BlinkTimes--;
0204     switch (pLed->CurrLedState) {
0205     case LED_BLINK_NORMAL:
0206         if (pLed->BlinkTimes == 0)
0207             bStopBlinking = true;
0208         break;
0209     case LED_BLINK_StartToBlink:
0210         if (check_fwstate(pmlmepriv, _FW_LINKED) &&
0211             (pmlmepriv->fw_state & WIFI_STATION_STATE))
0212             bStopBlinking = true;
0213         if (check_fwstate(pmlmepriv, _FW_LINKED) &&
0214             ((pmlmepriv->fw_state & WIFI_ADHOC_STATE) ||
0215             (pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE)))
0216             bStopBlinking = true;
0217         else if (pLed->BlinkTimes == 0)
0218             bStopBlinking = true;
0219         break;
0220     case LED_BLINK_WPS:
0221         if (pLed->BlinkTimes == 0)
0222             bStopBlinking = true;
0223         break;
0224     default:
0225         bStopBlinking = true;
0226         break;
0227     }
0228     if (bStopBlinking) {
0229         if (check_fwstate(pmlmepriv, _FW_LINKED) &&
0230             !pLed->bLedOn)
0231             SwLedOn(padapter, pLed);
0232         else if (check_fwstate(pmlmepriv, _FW_LINKED) &&  pLed->bLedOn)
0233             SwLedOff(padapter, pLed);
0234         pLed->BlinkTimes = 0;
0235         pLed->bLedBlinkInProgress = false;
0236     } else {
0237         /* Assign LED state to toggle. */
0238         if (pLed->BlinkingLedState == LED_STATE_ON)
0239             pLed->BlinkingLedState = LED_STATE_OFF;
0240         else
0241             pLed->BlinkingLedState = LED_STATE_ON;
0242 
0243         /* Schedule a timer to toggle LED state. */
0244         switch (pLed->CurrLedState) {
0245         case LED_BLINK_NORMAL:
0246             mod_timer(&pLed->BlinkTimer, jiffies +
0247                   msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
0248             break;
0249         case LED_BLINK_SLOWLY:
0250         case LED_BLINK_StartToBlink:
0251             mod_timer(&pLed->BlinkTimer, jiffies +
0252                   msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
0253             break;
0254         case LED_BLINK_WPS:
0255             mod_timer(&pLed->BlinkTimer, jiffies +
0256                   msecs_to_jiffies(LED_BLINK_LONG_INTERVAL));
0257             break;
0258         default:
0259             mod_timer(&pLed->BlinkTimer, jiffies +
0260                   msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
0261             break;
0262         }
0263     }
0264 }
0265 
0266 static void SwLedBlink1(struct LED_871x *pLed)
0267 {
0268     struct _adapter *padapter = pLed->padapter;
0269     struct led_priv *ledpriv = &padapter->ledpriv;
0270     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
0271     struct eeprom_priv *peeprompriv = &padapter->eeprompriv;
0272     struct LED_871x *pLed1 = &ledpriv->SwLed1;
0273     u8 bStopBlinking = false;
0274 
0275     if (peeprompriv->CustomerID == RT_CID_819x_CAMEO)
0276         pLed = &ledpriv->SwLed1;
0277     /* Change LED according to BlinkingLedState specified. */
0278     if (pLed->BlinkingLedState == LED_STATE_ON)
0279         SwLedOn(padapter, pLed);
0280     else
0281         SwLedOff(padapter, pLed);
0282     if (peeprompriv->CustomerID == RT_CID_DEFAULT) {
0283         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
0284             if (!pLed1->bSWLedCtrl) {
0285                 SwLedOn(padapter, pLed1);
0286                 pLed1->bSWLedCtrl = true;
0287             } else if (!pLed1->bLedOn) {
0288                 SwLedOn(padapter, pLed1);
0289             }
0290         } else {
0291             if (!pLed1->bSWLedCtrl) {
0292                 SwLedOff(padapter, pLed1);
0293                 pLed1->bSWLedCtrl = true;
0294             } else if (pLed1->bLedOn) {
0295                 SwLedOff(padapter, pLed1);
0296             }
0297         }
0298     }
0299     switch (pLed->CurrLedState) {
0300     case LED_BLINK_SLOWLY:
0301         if (pLed->bLedOn)
0302             pLed->BlinkingLedState = LED_STATE_OFF;
0303         else
0304             pLed->BlinkingLedState = LED_STATE_ON;
0305         mod_timer(&pLed->BlinkTimer, jiffies +
0306               msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
0307         break;
0308     case LED_BLINK_NORMAL:
0309         if (pLed->bLedOn)
0310             pLed->BlinkingLedState = LED_STATE_OFF;
0311         else
0312             pLed->BlinkingLedState = LED_STATE_ON;
0313         mod_timer(&pLed->BlinkTimer, jiffies +
0314               msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
0315         break;
0316     case LED_SCAN_BLINK:
0317         pLed->BlinkTimes--;
0318         if (pLed->BlinkTimes == 0)
0319             bStopBlinking = true;
0320         if (bStopBlinking) {
0321             if (check_fwstate(pmlmepriv, _FW_LINKED)) {
0322                 pLed->bLedLinkBlinkInProgress = true;
0323                 pLed->CurrLedState = LED_BLINK_NORMAL;
0324                 if (pLed->bLedOn)
0325                     pLed->BlinkingLedState = LED_STATE_OFF;
0326                 else
0327                     pLed->BlinkingLedState = LED_STATE_ON;
0328                 mod_timer(&pLed->BlinkTimer, jiffies +
0329                       msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
0330             } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
0331                 pLed->bLedNoLinkBlinkInProgress = true;
0332                 pLed->CurrLedState = LED_BLINK_SLOWLY;
0333                 if (pLed->bLedOn)
0334                     pLed->BlinkingLedState = LED_STATE_OFF;
0335                 else
0336                     pLed->BlinkingLedState = LED_STATE_ON;
0337                 mod_timer(&pLed->BlinkTimer, jiffies +
0338                       msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
0339             }
0340             pLed->bLedScanBlinkInProgress = false;
0341         } else {
0342             if (pLed->bLedOn)
0343                 pLed->BlinkingLedState = LED_STATE_OFF;
0344             else
0345                 pLed->BlinkingLedState = LED_STATE_ON;
0346             mod_timer(&pLed->BlinkTimer, jiffies +
0347                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0348         }
0349         break;
0350     case LED_TXRX_BLINK:
0351         pLed->BlinkTimes--;
0352         if (pLed->BlinkTimes == 0)
0353             bStopBlinking = true;
0354         if (bStopBlinking) {
0355             if (check_fwstate(pmlmepriv, _FW_LINKED)) {
0356                 pLed->bLedLinkBlinkInProgress = true;
0357                 pLed->CurrLedState = LED_BLINK_NORMAL;
0358                 if (pLed->bLedOn)
0359                     pLed->BlinkingLedState = LED_STATE_OFF;
0360                 else
0361                     pLed->BlinkingLedState = LED_STATE_ON;
0362                 mod_timer(&pLed->BlinkTimer, jiffies +
0363                       msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
0364             } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
0365                 pLed->bLedNoLinkBlinkInProgress = true;
0366                 pLed->CurrLedState = LED_BLINK_SLOWLY;
0367                 if (pLed->bLedOn)
0368                     pLed->BlinkingLedState = LED_STATE_OFF;
0369                 else
0370                     pLed->BlinkingLedState = LED_STATE_ON;
0371                 mod_timer(&pLed->BlinkTimer, jiffies +
0372                       msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
0373             }
0374             pLed->BlinkTimes = 0;
0375             pLed->bLedBlinkInProgress = false;
0376         } else {
0377             if (pLed->bLedOn)
0378                 pLed->BlinkingLedState = LED_STATE_OFF;
0379             else
0380                 pLed->BlinkingLedState = LED_STATE_ON;
0381             mod_timer(&pLed->BlinkTimer, jiffies +
0382                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0383         }
0384         break;
0385     case LED_BLINK_WPS:
0386         if (pLed->bLedOn)
0387             pLed->BlinkingLedState = LED_STATE_OFF;
0388         else
0389             pLed->BlinkingLedState = LED_STATE_ON;
0390         mod_timer(&pLed->BlinkTimer, jiffies +
0391               msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0392         break;
0393     case LED_BLINK_WPS_STOP:    /* WPS success */
0394         if (pLed->BlinkingLedState == LED_STATE_ON) {
0395             pLed->BlinkingLedState = LED_STATE_OFF;
0396             mod_timer(&pLed->BlinkTimer, jiffies +
0397                   msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
0398             bStopBlinking = false;
0399         } else {
0400             bStopBlinking = true;
0401         }
0402         if (bStopBlinking) {
0403             pLed->bLedLinkBlinkInProgress = true;
0404             pLed->CurrLedState = LED_BLINK_NORMAL;
0405             if (pLed->bLedOn)
0406                 pLed->BlinkingLedState = LED_STATE_OFF;
0407             else
0408                 pLed->BlinkingLedState = LED_STATE_ON;
0409             mod_timer(&pLed->BlinkTimer, jiffies +
0410                   msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
0411         }
0412         pLed->bLedWPSBlinkInProgress = false;
0413         break;
0414     default:
0415         break;
0416     }
0417 }
0418 
0419 static void SwLedBlink2(struct LED_871x *pLed)
0420 {
0421     struct _adapter *padapter = pLed->padapter;
0422     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
0423     u8 bStopBlinking = false;
0424 
0425     /* Change LED according to BlinkingLedState specified. */
0426     if (pLed->BlinkingLedState == LED_STATE_ON)
0427         SwLedOn(padapter, pLed);
0428     else
0429         SwLedOff(padapter, pLed);
0430     switch (pLed->CurrLedState) {
0431     case LED_SCAN_BLINK:
0432         pLed->BlinkTimes--;
0433         if (pLed->BlinkTimes == 0)
0434             bStopBlinking = true;
0435         if (bStopBlinking) {
0436             if (check_fwstate(pmlmepriv, _FW_LINKED)) {
0437                 pLed->CurrLedState = LED_STATE_ON;
0438                 pLed->BlinkingLedState = LED_STATE_ON;
0439                 SwLedOn(padapter, pLed);
0440             } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
0441                 pLed->CurrLedState = LED_STATE_OFF;
0442                 pLed->BlinkingLedState = LED_STATE_OFF;
0443                 SwLedOff(padapter, pLed);
0444             }
0445             pLed->bLedScanBlinkInProgress = false;
0446         } else {
0447             if (pLed->bLedOn)
0448                 pLed->BlinkingLedState = LED_STATE_OFF;
0449             else
0450                 pLed->BlinkingLedState = LED_STATE_ON;
0451             mod_timer(&pLed->BlinkTimer, jiffies +
0452                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0453         }
0454         break;
0455     case LED_TXRX_BLINK:
0456         pLed->BlinkTimes--;
0457         if (pLed->BlinkTimes == 0)
0458             bStopBlinking = true;
0459         if (bStopBlinking) {
0460             if (check_fwstate(pmlmepriv, _FW_LINKED)) {
0461                 pLed->CurrLedState = LED_STATE_ON;
0462                 pLed->BlinkingLedState = LED_STATE_ON;
0463                 SwLedOn(padapter, pLed);
0464             } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
0465                 pLed->CurrLedState = LED_STATE_OFF;
0466                 pLed->BlinkingLedState = LED_STATE_OFF;
0467                 SwLedOff(padapter, pLed);
0468             }
0469             pLed->bLedBlinkInProgress = false;
0470         } else {
0471             if (pLed->bLedOn)
0472                 pLed->BlinkingLedState = LED_STATE_OFF;
0473             else
0474                 pLed->BlinkingLedState = LED_STATE_ON;
0475             mod_timer(&pLed->BlinkTimer, jiffies +
0476                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0477         }
0478         break;
0479     default:
0480         break;
0481     }
0482 }
0483 
0484 static void SwLedBlink3(struct LED_871x *pLed)
0485 {
0486     struct _adapter *padapter = pLed->padapter;
0487     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
0488     u8 bStopBlinking = false;
0489 
0490     /* Change LED according to BlinkingLedState specified. */
0491     if (pLed->BlinkingLedState == LED_STATE_ON)
0492         SwLedOn(padapter, pLed);
0493     else
0494         if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
0495             SwLedOff(padapter, pLed);
0496     switch (pLed->CurrLedState) {
0497     case LED_SCAN_BLINK:
0498         pLed->BlinkTimes--;
0499         if (pLed->BlinkTimes == 0)
0500             bStopBlinking = true;
0501         if (bStopBlinking) {
0502             if (check_fwstate(pmlmepriv, _FW_LINKED)) {
0503                 pLed->CurrLedState = LED_STATE_ON;
0504                 pLed->BlinkingLedState = LED_STATE_ON;
0505                 if (!pLed->bLedOn)
0506                     SwLedOn(padapter, pLed);
0507             } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
0508                 pLed->CurrLedState = LED_STATE_OFF;
0509                 pLed->BlinkingLedState = LED_STATE_OFF;
0510                 if (pLed->bLedOn)
0511                     SwLedOff(padapter, pLed);
0512             }
0513             pLed->bLedScanBlinkInProgress = false;
0514         } else {
0515             if (pLed->bLedOn)
0516                 pLed->BlinkingLedState = LED_STATE_OFF;
0517             else
0518                 pLed->BlinkingLedState = LED_STATE_ON;
0519             mod_timer(&pLed->BlinkTimer, jiffies +
0520                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0521         }
0522         break;
0523     case LED_TXRX_BLINK:
0524         pLed->BlinkTimes--;
0525         if (pLed->BlinkTimes == 0)
0526             bStopBlinking = true;
0527         if (bStopBlinking) {
0528             if (check_fwstate(pmlmepriv, _FW_LINKED)) {
0529                 pLed->CurrLedState = LED_STATE_ON;
0530                 pLed->BlinkingLedState = LED_STATE_ON;
0531                 if (!pLed->bLedOn)
0532                     SwLedOn(padapter, pLed);
0533             } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
0534                 pLed->CurrLedState = LED_STATE_OFF;
0535                 pLed->BlinkingLedState = LED_STATE_OFF;
0536                 if (pLed->bLedOn)
0537                     SwLedOff(padapter, pLed);
0538             }
0539             pLed->bLedBlinkInProgress = false;
0540         } else {
0541             if (pLed->bLedOn)
0542                 pLed->BlinkingLedState = LED_STATE_OFF;
0543             else
0544                 pLed->BlinkingLedState = LED_STATE_ON;
0545             mod_timer(&pLed->BlinkTimer, jiffies +
0546                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0547         }
0548         break;
0549     case LED_BLINK_WPS:
0550         if (pLed->bLedOn)
0551             pLed->BlinkingLedState = LED_STATE_OFF;
0552         else
0553             pLed->BlinkingLedState = LED_STATE_ON;
0554         mod_timer(&pLed->BlinkTimer, jiffies +
0555               msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0556         break;
0557     case LED_BLINK_WPS_STOP:    /*WPS success*/
0558         if (pLed->BlinkingLedState == LED_STATE_ON) {
0559             pLed->BlinkingLedState = LED_STATE_OFF;
0560             mod_timer(&pLed->BlinkTimer, jiffies +
0561                   msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
0562             bStopBlinking = false;
0563         } else {
0564             bStopBlinking = true;
0565         }
0566         if (bStopBlinking) {
0567             pLed->CurrLedState = LED_STATE_ON;
0568             pLed->BlinkingLedState = LED_STATE_ON;
0569             SwLedOn(padapter, pLed);
0570             pLed->bLedWPSBlinkInProgress = false;
0571         }
0572         break;
0573     default:
0574         break;
0575     }
0576 }
0577 
0578 static void SwLedBlink4(struct LED_871x *pLed)
0579 {
0580     struct _adapter *padapter = pLed->padapter;
0581     struct led_priv *ledpriv = &padapter->ledpriv;
0582     struct LED_871x *pLed1 = &ledpriv->SwLed1;
0583     u8 bStopBlinking = false;
0584 
0585     /* Change LED according to BlinkingLedState specified. */
0586     if (pLed->BlinkingLedState == LED_STATE_ON)
0587         SwLedOn(padapter, pLed);
0588     else
0589         SwLedOff(padapter, pLed);
0590     if (!pLed1->bLedWPSBlinkInProgress &&
0591         pLed1->BlinkingLedState == LED_UNKNOWN) {
0592         pLed1->BlinkingLedState = LED_STATE_OFF;
0593         pLed1->CurrLedState = LED_STATE_OFF;
0594         SwLedOff(padapter, pLed1);
0595     }
0596     switch (pLed->CurrLedState) {
0597     case LED_BLINK_SLOWLY:
0598         if (pLed->bLedOn)
0599             pLed->BlinkingLedState = LED_STATE_OFF;
0600         else
0601             pLed->BlinkingLedState = LED_STATE_ON;
0602         mod_timer(&pLed->BlinkTimer, jiffies +
0603               msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
0604         break;
0605     case LED_BLINK_StartToBlink:
0606         if (pLed->bLedOn) {
0607             pLed->BlinkingLedState = LED_STATE_OFF;
0608             mod_timer(&pLed->BlinkTimer, jiffies +
0609                   msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
0610         } else {
0611             pLed->BlinkingLedState = LED_STATE_ON;
0612             mod_timer(&pLed->BlinkTimer, jiffies +
0613                   msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
0614         }
0615         break;
0616     case LED_SCAN_BLINK:
0617         pLed->BlinkTimes--;
0618         if (pLed->BlinkTimes == 0)
0619             bStopBlinking = true;
0620         if (bStopBlinking) {
0621             pLed->bLedNoLinkBlinkInProgress = true;
0622             pLed->CurrLedState = LED_BLINK_SLOWLY;
0623             if (pLed->bLedOn)
0624                 pLed->BlinkingLedState = LED_STATE_OFF;
0625             else
0626                 pLed->BlinkingLedState = LED_STATE_ON;
0627             mod_timer(&pLed->BlinkTimer, jiffies +
0628                   msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
0629             pLed->bLedScanBlinkInProgress = false;
0630         } else {
0631             if (pLed->bLedOn)
0632                 pLed->BlinkingLedState = LED_STATE_OFF;
0633             else
0634                 pLed->BlinkingLedState = LED_STATE_ON;
0635             mod_timer(&pLed->BlinkTimer, jiffies +
0636                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0637         }
0638         break;
0639     case LED_TXRX_BLINK:
0640         pLed->BlinkTimes--;
0641         if (pLed->BlinkTimes == 0)
0642             bStopBlinking = true;
0643         if (bStopBlinking) {
0644             pLed->bLedNoLinkBlinkInProgress = true;
0645             pLed->CurrLedState = LED_BLINK_SLOWLY;
0646             if (pLed->bLedOn)
0647                 pLed->BlinkingLedState = LED_STATE_OFF;
0648             else
0649                 pLed->BlinkingLedState = LED_STATE_ON;
0650             mod_timer(&pLed->BlinkTimer, jiffies +
0651                   msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
0652             pLed->bLedBlinkInProgress = false;
0653         } else {
0654             if (pLed->bLedOn)
0655                 pLed->BlinkingLedState = LED_STATE_OFF;
0656             else
0657                 pLed->BlinkingLedState = LED_STATE_ON;
0658             mod_timer(&pLed->BlinkTimer, jiffies +
0659                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0660         }
0661         break;
0662     case LED_BLINK_WPS:
0663         if (pLed->bLedOn) {
0664             pLed->BlinkingLedState = LED_STATE_OFF;
0665             mod_timer(&pLed->BlinkTimer, jiffies +
0666                   msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
0667         } else {
0668             pLed->BlinkingLedState = LED_STATE_ON;
0669             mod_timer(&pLed->BlinkTimer, jiffies +
0670                   msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
0671         }
0672         break;
0673     case LED_BLINK_WPS_STOP:    /*WPS authentication fail*/
0674         if (pLed->bLedOn)
0675             pLed->BlinkingLedState = LED_STATE_OFF;
0676         else
0677             pLed->BlinkingLedState = LED_STATE_ON;
0678         mod_timer(&pLed->BlinkTimer, jiffies +
0679               msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
0680         break;
0681     case LED_BLINK_WPS_STOP_OVERLAP:    /*WPS session overlap */
0682         pLed->BlinkTimes--;
0683         if (pLed->BlinkTimes == 0) {
0684             if (pLed->bLedOn)
0685                 pLed->BlinkTimes = 1;
0686             else
0687                 bStopBlinking = true;
0688         }
0689         if (bStopBlinking) {
0690             pLed->BlinkTimes = 10;
0691             pLed->BlinkingLedState = LED_STATE_ON;
0692             mod_timer(&pLed->BlinkTimer, jiffies +
0693                   msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
0694         } else {
0695             if (pLed->bLedOn)
0696                 pLed->BlinkingLedState = LED_STATE_OFF;
0697             else
0698                 pLed->BlinkingLedState = LED_STATE_ON;
0699             mod_timer(&pLed->BlinkTimer, jiffies +
0700                   msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
0701         }
0702         break;
0703     default:
0704         break;
0705     }
0706 }
0707 
0708 static void SwLedBlink5(struct LED_871x *pLed)
0709 {
0710     struct _adapter *padapter = pLed->padapter;
0711     u8 bStopBlinking = false;
0712 
0713     /* Change LED according to BlinkingLedState specified. */
0714     if (pLed->BlinkingLedState == LED_STATE_ON)
0715         SwLedOn(padapter, pLed);
0716     else
0717         SwLedOff(padapter, pLed);
0718     switch (pLed->CurrLedState) {
0719     case LED_SCAN_BLINK:
0720         pLed->BlinkTimes--;
0721         if (pLed->BlinkTimes == 0)
0722             bStopBlinking = true;
0723         if (bStopBlinking) {
0724             pLed->CurrLedState = LED_STATE_ON;
0725             pLed->BlinkingLedState = LED_STATE_ON;
0726             if (!pLed->bLedOn)
0727                 mod_timer(&pLed->BlinkTimer, jiffies +
0728                       msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0729             pLed->bLedScanBlinkInProgress = false;
0730         } else {
0731             if (pLed->bLedOn)
0732                 pLed->BlinkingLedState = LED_STATE_OFF;
0733             else
0734                 pLed->BlinkingLedState = LED_STATE_ON;
0735             mod_timer(&pLed->BlinkTimer, jiffies +
0736                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0737         }
0738         break;
0739     case LED_TXRX_BLINK:
0740         pLed->BlinkTimes--;
0741         if (pLed->BlinkTimes == 0)
0742             bStopBlinking = true;
0743         if (bStopBlinking) {
0744             pLed->CurrLedState = LED_STATE_ON;
0745             pLed->BlinkingLedState = LED_STATE_ON;
0746             if (!pLed->bLedOn)
0747                 mod_timer(&pLed->BlinkTimer, jiffies +
0748                       msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0749             pLed->bLedBlinkInProgress = false;
0750         } else {
0751             if (pLed->bLedOn)
0752                 pLed->BlinkingLedState = LED_STATE_OFF;
0753             else
0754                 pLed->BlinkingLedState = LED_STATE_ON;
0755             mod_timer(&pLed->BlinkTimer, jiffies +
0756                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0757         }
0758         break;
0759     default:
0760         break;
0761     }
0762 }
0763 
0764 static void SwLedBlink6(struct LED_871x *pLed)
0765 {
0766     struct _adapter *padapter = pLed->padapter;
0767     u8 bStopBlinking = false;
0768 
0769     /* Change LED according to BlinkingLedState specified. */
0770     if (pLed->BlinkingLedState == LED_STATE_ON)
0771         SwLedOn(padapter, pLed);
0772     else
0773         SwLedOff(padapter, pLed);
0774     switch (pLed->CurrLedState) {
0775     case LED_TXRX_BLINK:
0776         pLed->BlinkTimes--;
0777         if (pLed->BlinkTimes == 0)
0778             bStopBlinking = true;
0779         if (bStopBlinking) {
0780             pLed->CurrLedState = LED_STATE_ON;
0781             pLed->BlinkingLedState = LED_STATE_ON;
0782             if (!pLed->bLedOn)
0783                 SwLedOn(padapter, pLed);
0784             pLed->bLedBlinkInProgress = false;
0785         } else {
0786             if (pLed->bLedOn)
0787                 pLed->BlinkingLedState = LED_STATE_OFF;
0788             else
0789                 pLed->BlinkingLedState = LED_STATE_ON;
0790             mod_timer(&pLed->BlinkTimer, jiffies +
0791                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0792         }
0793         break;
0794     case LED_BLINK_WPS:
0795         if (pLed->bLedOn)
0796             pLed->BlinkingLedState = LED_STATE_OFF;
0797         else
0798             pLed->BlinkingLedState = LED_STATE_ON;
0799         mod_timer(&pLed->BlinkTimer, jiffies +
0800               msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0801         break;
0802 
0803     default:
0804         break;
0805     }
0806 }
0807 
0808 /*  Description:
0809  *      Callback function of LED BlinkTimer,
0810  *      it just schedules to corresponding BlinkWorkItem.
0811  */
0812 static void BlinkTimerCallback(struct timer_list *t)
0813 {
0814     struct LED_871x  *pLed = from_timer(pLed, t, BlinkTimer);
0815 
0816     /* This fixed the crash problem on Fedora 12 when trying to do the
0817      * insmod;ifconfig up;rmmod commands.
0818      */
0819     if (pLed->padapter->surprise_removed || pLed->padapter->driver_stopped)
0820         return;
0821     schedule_work(&pLed->BlinkWorkItem);
0822 }
0823 
0824 /*  Description:
0825  *      Callback function of LED BlinkWorkItem.
0826  *      We dispatch actual LED blink action according to LedStrategy.
0827  */
0828 static void BlinkWorkItemCallback(struct work_struct *work)
0829 {
0830     struct LED_871x *pLed = container_of(work, struct LED_871x,
0831                 BlinkWorkItem);
0832     struct led_priv *ledpriv = &pLed->padapter->ledpriv;
0833 
0834     switch (ledpriv->LedStrategy) {
0835     case SW_LED_MODE0:
0836         SwLedBlink(pLed);
0837         break;
0838     case SW_LED_MODE1:
0839         SwLedBlink1(pLed);
0840         break;
0841     case SW_LED_MODE2:
0842         SwLedBlink2(pLed);
0843         break;
0844     case SW_LED_MODE3:
0845         SwLedBlink3(pLed);
0846         break;
0847     case SW_LED_MODE4:
0848         SwLedBlink4(pLed);
0849         break;
0850     case SW_LED_MODE5:
0851         SwLedBlink5(pLed);
0852         break;
0853     case SW_LED_MODE6:
0854         SwLedBlink6(pLed);
0855         break;
0856     default:
0857         SwLedBlink(pLed);
0858         break;
0859     }
0860 }
0861 
0862 /*============================================================================
0863  * Default LED behavior.
0864  *============================================================================
0865  *
0866  *  Description:
0867  *      Implement each led action for SW_LED_MODE0.
0868  *      This is default strategy.
0869  */
0870 
0871 static void SwLedControlMode1(struct _adapter *padapter,
0872                   enum LED_CTL_MODE LedAction)
0873 {
0874     struct led_priv *ledpriv = &padapter->ledpriv;
0875     struct LED_871x *pLed = &ledpriv->SwLed0;
0876     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
0877     struct sitesurvey_ctrl *psitesurveyctrl = &pmlmepriv->sitesurveyctrl;
0878 
0879     if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
0880         pLed = &ledpriv->SwLed1;
0881     switch (LedAction) {
0882     case LED_CTL_START_TO_LINK:
0883     case LED_CTL_NO_LINK:
0884         if (!pLed->bLedNoLinkBlinkInProgress) {
0885             if (pLed->CurrLedState == LED_SCAN_BLINK ||
0886                 IS_LED_WPS_BLINKING(pLed))
0887                 return;
0888             if (pLed->bLedLinkBlinkInProgress) {
0889                 del_timer(&pLed->BlinkTimer);
0890                 pLed->bLedLinkBlinkInProgress = false;
0891             }
0892             if (pLed->bLedBlinkInProgress) {
0893                 del_timer(&pLed->BlinkTimer);
0894                 pLed->bLedBlinkInProgress = false;
0895             }
0896             pLed->bLedNoLinkBlinkInProgress = true;
0897             pLed->CurrLedState = LED_BLINK_SLOWLY;
0898             if (pLed->bLedOn)
0899                 pLed->BlinkingLedState = LED_STATE_OFF;
0900             else
0901                 pLed->BlinkingLedState = LED_STATE_ON;
0902             mod_timer(&pLed->BlinkTimer, jiffies +
0903                   msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
0904         }
0905         break;
0906     case LED_CTL_LINK:
0907         if (!pLed->bLedLinkBlinkInProgress) {
0908             if (pLed->CurrLedState == LED_SCAN_BLINK ||
0909                 IS_LED_WPS_BLINKING(pLed))
0910                 return;
0911             if (pLed->bLedNoLinkBlinkInProgress) {
0912                 del_timer(&pLed->BlinkTimer);
0913                 pLed->bLedNoLinkBlinkInProgress = false;
0914             }
0915             if (pLed->bLedBlinkInProgress) {
0916                 del_timer(&pLed->BlinkTimer);
0917                 pLed->bLedBlinkInProgress = false;
0918             }
0919             pLed->bLedLinkBlinkInProgress = true;
0920             pLed->CurrLedState = LED_BLINK_NORMAL;
0921             if (pLed->bLedOn)
0922                 pLed->BlinkingLedState = LED_STATE_OFF;
0923             else
0924                 pLed->BlinkingLedState = LED_STATE_ON;
0925             mod_timer(&pLed->BlinkTimer, jiffies +
0926                   msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
0927         }
0928         break;
0929     case LED_CTL_SITE_SURVEY:
0930         if (psitesurveyctrl->traffic_busy &&
0931             check_fwstate(pmlmepriv, _FW_LINKED))
0932             ; /* dummy branch */
0933         else if (!pLed->bLedScanBlinkInProgress) {
0934             if (IS_LED_WPS_BLINKING(pLed))
0935                 return;
0936             if (pLed->bLedNoLinkBlinkInProgress) {
0937                 del_timer(&pLed->BlinkTimer);
0938                 pLed->bLedNoLinkBlinkInProgress = false;
0939             }
0940             if (pLed->bLedLinkBlinkInProgress) {
0941                 del_timer(&pLed->BlinkTimer);
0942                 pLed->bLedLinkBlinkInProgress = false;
0943             }
0944             if (pLed->bLedBlinkInProgress) {
0945                 del_timer(&pLed->BlinkTimer);
0946                 pLed->bLedBlinkInProgress = false;
0947             }
0948             pLed->bLedScanBlinkInProgress = true;
0949             pLed->CurrLedState = LED_SCAN_BLINK;
0950             pLed->BlinkTimes = 24;
0951             if (pLed->bLedOn)
0952                 pLed->BlinkingLedState = LED_STATE_OFF;
0953             else
0954                 pLed->BlinkingLedState = LED_STATE_ON;
0955             mod_timer(&pLed->BlinkTimer, jiffies +
0956                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
0957         }
0958         break;
0959     case LED_CTL_TX:
0960     case LED_CTL_RX:
0961         if (!pLed->bLedBlinkInProgress) {
0962             if (pLed->CurrLedState == LED_SCAN_BLINK ||
0963                 IS_LED_WPS_BLINKING(pLed))
0964                 return;
0965             if (pLed->bLedNoLinkBlinkInProgress) {
0966                 del_timer(&pLed->BlinkTimer);
0967                 pLed->bLedNoLinkBlinkInProgress = false;
0968             }
0969             if (pLed->bLedLinkBlinkInProgress) {
0970                 del_timer(&pLed->BlinkTimer);
0971                 pLed->bLedLinkBlinkInProgress = false;
0972             }
0973             pLed->bLedBlinkInProgress = true;
0974             pLed->CurrLedState = LED_TXRX_BLINK;
0975             pLed->BlinkTimes = 2;
0976             if (pLed->bLedOn)
0977                 pLed->BlinkingLedState = LED_STATE_OFF;
0978             else
0979                 pLed->BlinkingLedState = LED_STATE_ON;
0980             mod_timer(&pLed->BlinkTimer, jiffies +
0981                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
0982         }
0983         break;
0984 
0985     case LED_CTL_START_WPS: /*wait until xinpin finish */
0986     case LED_CTL_START_WPS_BOTTON:
0987         if (!pLed->bLedWPSBlinkInProgress) {
0988             if (pLed->bLedNoLinkBlinkInProgress) {
0989                 del_timer(&pLed->BlinkTimer);
0990                 pLed->bLedNoLinkBlinkInProgress = false;
0991             }
0992             if (pLed->bLedLinkBlinkInProgress) {
0993                 del_timer(&pLed->BlinkTimer);
0994                 pLed->bLedLinkBlinkInProgress = false;
0995             }
0996             if (pLed->bLedBlinkInProgress) {
0997                 del_timer(&pLed->BlinkTimer);
0998                 pLed->bLedBlinkInProgress = false;
0999             }
1000             if (pLed->bLedScanBlinkInProgress) {
1001                 del_timer(&pLed->BlinkTimer);
1002                 pLed->bLedScanBlinkInProgress = false;
1003             }
1004             pLed->bLedWPSBlinkInProgress = true;
1005             pLed->CurrLedState = LED_BLINK_WPS;
1006             if (pLed->bLedOn)
1007                 pLed->BlinkingLedState = LED_STATE_OFF;
1008             else
1009                 pLed->BlinkingLedState = LED_STATE_ON;
1010             mod_timer(&pLed->BlinkTimer, jiffies +
1011                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1012         }
1013         break;
1014     case LED_CTL_STOP_WPS:
1015         if (pLed->bLedNoLinkBlinkInProgress) {
1016             del_timer(&pLed->BlinkTimer);
1017             pLed->bLedNoLinkBlinkInProgress = false;
1018         }
1019         if (pLed->bLedLinkBlinkInProgress) {
1020             del_timer(&pLed->BlinkTimer);
1021             pLed->bLedLinkBlinkInProgress = false;
1022         }
1023         if (pLed->bLedBlinkInProgress) {
1024             del_timer(&pLed->BlinkTimer);
1025             pLed->bLedBlinkInProgress = false;
1026         }
1027         if (pLed->bLedScanBlinkInProgress) {
1028             del_timer(&pLed->BlinkTimer);
1029             pLed->bLedScanBlinkInProgress = false;
1030         }
1031         if (pLed->bLedWPSBlinkInProgress)
1032             del_timer(&pLed->BlinkTimer);
1033         else
1034             pLed->bLedWPSBlinkInProgress = true;
1035         pLed->CurrLedState = LED_BLINK_WPS_STOP;
1036         if (pLed->bLedOn) {
1037             pLed->BlinkingLedState = LED_STATE_OFF;
1038             mod_timer(&pLed->BlinkTimer, jiffies +
1039                   msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1040         } else {
1041             pLed->BlinkingLedState = LED_STATE_ON;
1042             mod_timer(&pLed->BlinkTimer,
1043                   jiffies + msecs_to_jiffies(0));
1044         }
1045         break;
1046     case LED_CTL_STOP_WPS_FAIL:
1047         if (pLed->bLedWPSBlinkInProgress) {
1048             del_timer(&pLed->BlinkTimer);
1049             pLed->bLedWPSBlinkInProgress = false;
1050         }
1051         pLed->bLedNoLinkBlinkInProgress = true;
1052         pLed->CurrLedState = LED_BLINK_SLOWLY;
1053         if (pLed->bLedOn)
1054             pLed->BlinkingLedState = LED_STATE_OFF;
1055         else
1056             pLed->BlinkingLedState = LED_STATE_ON;
1057         mod_timer(&pLed->BlinkTimer, jiffies +
1058               msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1059         break;
1060     case LED_CTL_POWER_OFF:
1061         pLed->CurrLedState = LED_STATE_OFF;
1062         pLed->BlinkingLedState = LED_STATE_OFF;
1063         if (pLed->bLedNoLinkBlinkInProgress) {
1064             del_timer(&pLed->BlinkTimer);
1065             pLed->bLedNoLinkBlinkInProgress = false;
1066         }
1067         if (pLed->bLedLinkBlinkInProgress) {
1068             del_timer(&pLed->BlinkTimer);
1069             pLed->bLedLinkBlinkInProgress = false;
1070         }
1071         if (pLed->bLedBlinkInProgress) {
1072             del_timer(&pLed->BlinkTimer);
1073             pLed->bLedBlinkInProgress = false;
1074         }
1075         if (pLed->bLedWPSBlinkInProgress) {
1076             del_timer(&pLed->BlinkTimer);
1077             pLed->bLedWPSBlinkInProgress = false;
1078         }
1079         if (pLed->bLedScanBlinkInProgress) {
1080             del_timer(&pLed->BlinkTimer);
1081             pLed->bLedScanBlinkInProgress = false;
1082         }
1083         mod_timer(&pLed->BlinkTimer,
1084               jiffies + msecs_to_jiffies(0));
1085         break;
1086     default:
1087         break;
1088     }
1089 }
1090 
1091 static void SwLedControlMode2(struct _adapter *padapter,
1092                   enum LED_CTL_MODE LedAction)
1093 {
1094     struct led_priv  *ledpriv = &padapter->ledpriv;
1095     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1096     struct LED_871x *pLed = &ledpriv->SwLed0;
1097 
1098     switch (LedAction) {
1099     case LED_CTL_SITE_SURVEY:
1100         if (pmlmepriv->sitesurveyctrl.traffic_busy)
1101             ; /* dummy branch */
1102         else if (!pLed->bLedScanBlinkInProgress) {
1103             if (IS_LED_WPS_BLINKING(pLed))
1104                 return;
1105 
1106             if (pLed->bLedBlinkInProgress) {
1107                 del_timer(&pLed->BlinkTimer);
1108                 pLed->bLedBlinkInProgress = false;
1109             }
1110             pLed->bLedScanBlinkInProgress = true;
1111             pLed->CurrLedState = LED_SCAN_BLINK;
1112             pLed->BlinkTimes = 24;
1113             if (pLed->bLedOn)
1114                 pLed->BlinkingLedState = LED_STATE_OFF;
1115             else
1116                 pLed->BlinkingLedState = LED_STATE_ON;
1117             mod_timer(&pLed->BlinkTimer, jiffies +
1118                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1119         }
1120         break;
1121 
1122     case LED_CTL_TX:
1123     case LED_CTL_RX:
1124         if (!pLed->bLedBlinkInProgress &&
1125             check_fwstate(pmlmepriv, _FW_LINKED)) {
1126             if (pLed->CurrLedState == LED_SCAN_BLINK ||
1127                 IS_LED_WPS_BLINKING(pLed))
1128                 return;
1129             pLed->bLedBlinkInProgress = true;
1130             pLed->CurrLedState = LED_TXRX_BLINK;
1131             pLed->BlinkTimes = 2;
1132             if (pLed->bLedOn)
1133                 pLed->BlinkingLedState = LED_STATE_OFF;
1134             else
1135                 pLed->BlinkingLedState = LED_STATE_ON;
1136             mod_timer(&pLed->BlinkTimer, jiffies +
1137                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1138         }
1139         break;
1140 
1141     case LED_CTL_LINK:
1142         pLed->CurrLedState = LED_STATE_ON;
1143         pLed->BlinkingLedState = LED_STATE_ON;
1144         if (pLed->bLedBlinkInProgress) {
1145             del_timer(&pLed->BlinkTimer);
1146             pLed->bLedBlinkInProgress = false;
1147         }
1148         if (pLed->bLedScanBlinkInProgress) {
1149             del_timer(&pLed->BlinkTimer);
1150             pLed->bLedScanBlinkInProgress = false;
1151         }
1152 
1153         mod_timer(&pLed->BlinkTimer,
1154               jiffies + msecs_to_jiffies(0));
1155         break;
1156 
1157     case LED_CTL_START_WPS: /*wait until xinpin finish*/
1158     case LED_CTL_START_WPS_BOTTON:
1159         if (!pLed->bLedWPSBlinkInProgress) {
1160             if (pLed->bLedBlinkInProgress) {
1161                 del_timer(&pLed->BlinkTimer);
1162                 pLed->bLedBlinkInProgress = false;
1163             }
1164             if (pLed->bLedScanBlinkInProgress) {
1165                 del_timer(&pLed->BlinkTimer);
1166                 pLed->bLedScanBlinkInProgress = false;
1167             }
1168             pLed->bLedWPSBlinkInProgress = true;
1169             pLed->CurrLedState = LED_STATE_ON;
1170             pLed->BlinkingLedState = LED_STATE_ON;
1171             mod_timer(&pLed->BlinkTimer,
1172                   jiffies + msecs_to_jiffies(0));
1173         }
1174         break;
1175 
1176     case LED_CTL_STOP_WPS:
1177         pLed->bLedWPSBlinkInProgress = false;
1178         pLed->CurrLedState = LED_STATE_ON;
1179         pLed->BlinkingLedState = LED_STATE_ON;
1180         mod_timer(&pLed->BlinkTimer,
1181               jiffies + msecs_to_jiffies(0));
1182         break;
1183 
1184     case LED_CTL_STOP_WPS_FAIL:
1185         pLed->bLedWPSBlinkInProgress = false;
1186         pLed->CurrLedState = LED_STATE_OFF;
1187         pLed->BlinkingLedState = LED_STATE_OFF;
1188         mod_timer(&pLed->BlinkTimer,
1189               jiffies + msecs_to_jiffies(0));
1190         break;
1191 
1192     case LED_CTL_START_TO_LINK:
1193     case LED_CTL_NO_LINK:
1194         if (!IS_LED_BLINKING(pLed)) {
1195             pLed->CurrLedState = LED_STATE_OFF;
1196             pLed->BlinkingLedState = LED_STATE_OFF;
1197             mod_timer(&pLed->BlinkTimer,
1198                   jiffies + msecs_to_jiffies(0));
1199         }
1200         break;
1201     case LED_CTL_POWER_OFF:
1202         pLed->CurrLedState = LED_STATE_OFF;
1203         pLed->BlinkingLedState = LED_STATE_OFF;
1204         if (pLed->bLedBlinkInProgress) {
1205             del_timer(&pLed->BlinkTimer);
1206             pLed->bLedBlinkInProgress = false;
1207         }
1208         if (pLed->bLedScanBlinkInProgress) {
1209             del_timer(&pLed->BlinkTimer);
1210             pLed->bLedScanBlinkInProgress = false;
1211         }
1212         if (pLed->bLedWPSBlinkInProgress) {
1213             del_timer(&pLed->BlinkTimer);
1214             pLed->bLedWPSBlinkInProgress = false;
1215         }
1216         mod_timer(&pLed->BlinkTimer,
1217               jiffies + msecs_to_jiffies(0));
1218         break;
1219     default:
1220         break;
1221     }
1222 }
1223 
1224 static void SwLedControlMode3(struct _adapter *padapter,
1225                   enum LED_CTL_MODE LedAction)
1226 {
1227     struct led_priv *ledpriv = &padapter->ledpriv;
1228     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1229     struct LED_871x *pLed = &ledpriv->SwLed0;
1230 
1231     switch (LedAction) {
1232     case LED_CTL_SITE_SURVEY:
1233         if (pmlmepriv->sitesurveyctrl.traffic_busy)
1234             ; /* dummy branch */
1235         else if (!pLed->bLedScanBlinkInProgress) {
1236             if (IS_LED_WPS_BLINKING(pLed))
1237                 return;
1238             if (pLed->bLedBlinkInProgress) {
1239                 del_timer(&pLed->BlinkTimer);
1240                 pLed->bLedBlinkInProgress = false;
1241             }
1242             pLed->bLedScanBlinkInProgress = true;
1243             pLed->CurrLedState = LED_SCAN_BLINK;
1244             pLed->BlinkTimes = 24;
1245             if (pLed->bLedOn)
1246                 pLed->BlinkingLedState = LED_STATE_OFF;
1247             else
1248                 pLed->BlinkingLedState = LED_STATE_ON;
1249             mod_timer(&pLed->BlinkTimer, jiffies +
1250                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1251         }
1252         break;
1253     case LED_CTL_TX:
1254     case LED_CTL_RX:
1255         if (!pLed->bLedBlinkInProgress &&
1256             check_fwstate(pmlmepriv, _FW_LINKED)) {
1257             if (pLed->CurrLedState == LED_SCAN_BLINK ||
1258                 IS_LED_WPS_BLINKING(pLed))
1259                 return;
1260             pLed->bLedBlinkInProgress = true;
1261             pLed->CurrLedState = LED_TXRX_BLINK;
1262             pLed->BlinkTimes = 2;
1263             if (pLed->bLedOn)
1264                 pLed->BlinkingLedState = LED_STATE_OFF;
1265             else
1266                 pLed->BlinkingLedState = LED_STATE_ON;
1267             mod_timer(&pLed->BlinkTimer, jiffies +
1268                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1269         }
1270         break;
1271     case LED_CTL_LINK:
1272         if (IS_LED_WPS_BLINKING(pLed))
1273             return;
1274         pLed->CurrLedState = LED_STATE_ON;
1275         pLed->BlinkingLedState = LED_STATE_ON;
1276         if (pLed->bLedBlinkInProgress) {
1277             del_timer(&pLed->BlinkTimer);
1278             pLed->bLedBlinkInProgress = false;
1279         }
1280         if (pLed->bLedScanBlinkInProgress) {
1281             del_timer(&pLed->BlinkTimer);
1282             pLed->bLedScanBlinkInProgress = false;
1283         }
1284         mod_timer(&pLed->BlinkTimer,
1285               jiffies + msecs_to_jiffies(0));
1286         break;
1287     case LED_CTL_START_WPS: /* wait until xinpin finish */
1288     case LED_CTL_START_WPS_BOTTON:
1289         if (!pLed->bLedWPSBlinkInProgress) {
1290             if (pLed->bLedBlinkInProgress) {
1291                 del_timer(&pLed->BlinkTimer);
1292                 pLed->bLedBlinkInProgress = false;
1293             }
1294             if (pLed->bLedScanBlinkInProgress) {
1295                 del_timer(&pLed->BlinkTimer);
1296                 pLed->bLedScanBlinkInProgress = false;
1297             }
1298             pLed->bLedWPSBlinkInProgress = true;
1299             pLed->CurrLedState = LED_BLINK_WPS;
1300             if (pLed->bLedOn)
1301                 pLed->BlinkingLedState = LED_STATE_OFF;
1302             else
1303                 pLed->BlinkingLedState = LED_STATE_ON;
1304             mod_timer(&pLed->BlinkTimer, jiffies +
1305                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1306         }
1307         break;
1308     case LED_CTL_STOP_WPS:
1309         if (pLed->bLedWPSBlinkInProgress) {
1310             del_timer(&pLed->BlinkTimer);
1311             pLed->bLedWPSBlinkInProgress = false;
1312         } else {
1313             pLed->bLedWPSBlinkInProgress = true;
1314         }
1315         pLed->CurrLedState = LED_BLINK_WPS_STOP;
1316         if (pLed->bLedOn) {
1317             pLed->BlinkingLedState = LED_STATE_OFF;
1318             mod_timer(&pLed->BlinkTimer, jiffies +
1319                   msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1320         } else {
1321             pLed->BlinkingLedState = LED_STATE_ON;
1322             mod_timer(&pLed->BlinkTimer,
1323                   jiffies + msecs_to_jiffies(0));
1324         }
1325         break;
1326     case LED_CTL_STOP_WPS_FAIL:
1327         if (pLed->bLedWPSBlinkInProgress) {
1328             del_timer(&pLed->BlinkTimer);
1329             pLed->bLedWPSBlinkInProgress = false;
1330         }
1331         pLed->CurrLedState = LED_STATE_OFF;
1332         pLed->BlinkingLedState = LED_STATE_OFF;
1333         mod_timer(&pLed->BlinkTimer,
1334               jiffies + msecs_to_jiffies(0));
1335         break;
1336     case LED_CTL_START_TO_LINK:
1337     case LED_CTL_NO_LINK:
1338         if (!IS_LED_BLINKING(pLed)) {
1339             pLed->CurrLedState = LED_STATE_OFF;
1340             pLed->BlinkingLedState = LED_STATE_OFF;
1341             mod_timer(&pLed->BlinkTimer,
1342                   jiffies + msecs_to_jiffies(0));
1343         }
1344         break;
1345     case LED_CTL_POWER_OFF:
1346         pLed->CurrLedState = LED_STATE_OFF;
1347         pLed->BlinkingLedState = LED_STATE_OFF;
1348         if (pLed->bLedBlinkInProgress) {
1349             del_timer(&pLed->BlinkTimer);
1350             pLed->bLedBlinkInProgress = false;
1351         }
1352         if (pLed->bLedScanBlinkInProgress) {
1353             del_timer(&pLed->BlinkTimer);
1354             pLed->bLedScanBlinkInProgress = false;
1355         }
1356         if (pLed->bLedWPSBlinkInProgress) {
1357             del_timer(&pLed->BlinkTimer);
1358             pLed->bLedWPSBlinkInProgress = false;
1359         }
1360         mod_timer(&pLed->BlinkTimer,
1361               jiffies + msecs_to_jiffies(0));
1362         break;
1363     default:
1364         break;
1365     }
1366 }
1367 
1368 static void SwLedControlMode4(struct _adapter *padapter,
1369                   enum LED_CTL_MODE LedAction)
1370 {
1371     struct led_priv *ledpriv = &padapter->ledpriv;
1372     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1373     struct LED_871x *pLed = &ledpriv->SwLed0;
1374     struct LED_871x *pLed1 = &ledpriv->SwLed1;
1375 
1376     switch (LedAction) {
1377     case LED_CTL_START_TO_LINK:
1378         if (pLed1->bLedWPSBlinkInProgress) {
1379             pLed1->bLedWPSBlinkInProgress = false;
1380             del_timer(&pLed1->BlinkTimer);
1381             pLed1->BlinkingLedState = LED_STATE_OFF;
1382             pLed1->CurrLedState = LED_STATE_OFF;
1383             if (pLed1->bLedOn)
1384                 mod_timer(&pLed->BlinkTimer,
1385                       jiffies + msecs_to_jiffies(0));
1386         }
1387         if (!pLed->bLedStartToLinkBlinkInProgress) {
1388             if (pLed->CurrLedState == LED_SCAN_BLINK ||
1389                 IS_LED_WPS_BLINKING(pLed))
1390                 return;
1391             if (pLed->bLedBlinkInProgress) {
1392                 del_timer(&pLed->BlinkTimer);
1393                 pLed->bLedBlinkInProgress = false;
1394             }
1395             if (pLed->bLedNoLinkBlinkInProgress) {
1396                 del_timer(&pLed->BlinkTimer);
1397                 pLed->bLedNoLinkBlinkInProgress = false;
1398             }
1399             pLed->bLedStartToLinkBlinkInProgress = true;
1400             pLed->CurrLedState = LED_BLINK_StartToBlink;
1401             if (pLed->bLedOn) {
1402                 pLed->BlinkingLedState = LED_STATE_OFF;
1403                 mod_timer(&pLed->BlinkTimer, jiffies +
1404                       msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1405             } else {
1406                 pLed->BlinkingLedState = LED_STATE_ON;
1407                 mod_timer(&pLed->BlinkTimer, jiffies +
1408                       msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1409             }
1410         }
1411         break;
1412     case LED_CTL_LINK:
1413     case LED_CTL_NO_LINK:
1414         /*LED1 settings*/
1415         if (LedAction == LED_CTL_LINK) {
1416             if (pLed1->bLedWPSBlinkInProgress) {
1417                 pLed1->bLedWPSBlinkInProgress = false;
1418                 del_timer(&pLed1->BlinkTimer);
1419                 pLed1->BlinkingLedState = LED_STATE_OFF;
1420                 pLed1->CurrLedState = LED_STATE_OFF;
1421                 if (pLed1->bLedOn)
1422                     mod_timer(&pLed->BlinkTimer,
1423                           jiffies + msecs_to_jiffies(0));
1424             }
1425         }
1426         if (!pLed->bLedNoLinkBlinkInProgress) {
1427             if (pLed->CurrLedState == LED_SCAN_BLINK ||
1428                 IS_LED_WPS_BLINKING(pLed))
1429                 return;
1430             if (pLed->bLedBlinkInProgress) {
1431                 del_timer(&pLed->BlinkTimer);
1432                 pLed->bLedBlinkInProgress = false;
1433             }
1434             pLed->bLedNoLinkBlinkInProgress = true;
1435             pLed->CurrLedState = LED_BLINK_SLOWLY;
1436             if (pLed->bLedOn)
1437                 pLed->BlinkingLedState = LED_STATE_OFF;
1438             else
1439                 pLed->BlinkingLedState = LED_STATE_ON;
1440             mod_timer(&pLed->BlinkTimer, jiffies +
1441                   msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1442         }
1443         break;
1444     case LED_CTL_SITE_SURVEY:
1445         if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1446             check_fwstate(pmlmepriv, _FW_LINKED))
1447             ;
1448         else if (!pLed->bLedScanBlinkInProgress) {
1449             if (IS_LED_WPS_BLINKING(pLed))
1450                 return;
1451             if (pLed->bLedNoLinkBlinkInProgress) {
1452                 del_timer(&pLed->BlinkTimer);
1453                 pLed->bLedNoLinkBlinkInProgress = false;
1454             }
1455             if (pLed->bLedBlinkInProgress) {
1456                 del_timer(&pLed->BlinkTimer);
1457                 pLed->bLedBlinkInProgress = false;
1458             }
1459             pLed->bLedScanBlinkInProgress = true;
1460             pLed->CurrLedState = LED_SCAN_BLINK;
1461             pLed->BlinkTimes = 24;
1462             if (pLed->bLedOn)
1463                 pLed->BlinkingLedState = LED_STATE_OFF;
1464             else
1465                 pLed->BlinkingLedState = LED_STATE_ON;
1466             mod_timer(&pLed->BlinkTimer, jiffies +
1467                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1468         }
1469         break;
1470     case LED_CTL_TX:
1471     case LED_CTL_RX:
1472         if (!pLed->bLedBlinkInProgress) {
1473             if (pLed->CurrLedState == LED_SCAN_BLINK ||
1474                 IS_LED_WPS_BLINKING(pLed))
1475                 return;
1476             if (pLed->bLedNoLinkBlinkInProgress) {
1477                 del_timer(&pLed->BlinkTimer);
1478                 pLed->bLedNoLinkBlinkInProgress = false;
1479             }
1480             pLed->bLedBlinkInProgress = true;
1481             pLed->CurrLedState = LED_TXRX_BLINK;
1482             pLed->BlinkTimes = 2;
1483             if (pLed->bLedOn)
1484                 pLed->BlinkingLedState = LED_STATE_OFF;
1485             else
1486                 pLed->BlinkingLedState = LED_STATE_ON;
1487             mod_timer(&pLed->BlinkTimer, jiffies +
1488                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1489         }
1490         break;
1491     case LED_CTL_START_WPS: /*wait until xinpin finish*/
1492     case LED_CTL_START_WPS_BOTTON:
1493         if (pLed1->bLedWPSBlinkInProgress) {
1494             pLed1->bLedWPSBlinkInProgress = false;
1495             del_timer(&pLed1->BlinkTimer);
1496             pLed1->BlinkingLedState = LED_STATE_OFF;
1497             pLed1->CurrLedState = LED_STATE_OFF;
1498             if (pLed1->bLedOn)
1499                 mod_timer(&pLed->BlinkTimer,
1500                       jiffies + msecs_to_jiffies(0));
1501         }
1502         if (!pLed->bLedWPSBlinkInProgress) {
1503             if (pLed->bLedNoLinkBlinkInProgress) {
1504                 del_timer(&pLed->BlinkTimer);
1505                 pLed->bLedNoLinkBlinkInProgress = false;
1506             }
1507             if (pLed->bLedBlinkInProgress) {
1508                 del_timer(&pLed->BlinkTimer);
1509                 pLed->bLedBlinkInProgress = false;
1510             }
1511             if (pLed->bLedScanBlinkInProgress) {
1512                 del_timer(&pLed->BlinkTimer);
1513                 pLed->bLedScanBlinkInProgress = false;
1514             }
1515             pLed->bLedWPSBlinkInProgress = true;
1516             pLed->CurrLedState = LED_BLINK_WPS;
1517             if (pLed->bLedOn) {
1518                 pLed->BlinkingLedState = LED_STATE_OFF;
1519                 mod_timer(&pLed->BlinkTimer, jiffies +
1520                       msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1521             } else {
1522                 pLed->BlinkingLedState = LED_STATE_ON;
1523                 mod_timer(&pLed->BlinkTimer, jiffies +
1524                       msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1525             }
1526         }
1527         break;
1528     case LED_CTL_STOP_WPS:  /*WPS connect success*/
1529         if (pLed->bLedWPSBlinkInProgress) {
1530             del_timer(&pLed->BlinkTimer);
1531             pLed->bLedWPSBlinkInProgress = false;
1532         }
1533         pLed->bLedNoLinkBlinkInProgress = true;
1534         pLed->CurrLedState = LED_BLINK_SLOWLY;
1535         if (pLed->bLedOn)
1536             pLed->BlinkingLedState = LED_STATE_OFF;
1537         else
1538             pLed->BlinkingLedState = LED_STATE_ON;
1539         mod_timer(&pLed->BlinkTimer, jiffies +
1540               msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1541         break;
1542     case LED_CTL_STOP_WPS_FAIL: /*WPS authentication fail*/
1543         if (pLed->bLedWPSBlinkInProgress) {
1544             del_timer(&pLed->BlinkTimer);
1545             pLed->bLedWPSBlinkInProgress = false;
1546         }
1547         pLed->bLedNoLinkBlinkInProgress = true;
1548         pLed->CurrLedState = LED_BLINK_SLOWLY;
1549         if (pLed->bLedOn)
1550             pLed->BlinkingLedState = LED_STATE_OFF;
1551         else
1552             pLed->BlinkingLedState = LED_STATE_ON;
1553         mod_timer(&pLed->BlinkTimer, jiffies +
1554               msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1555         /*LED1 settings*/
1556         if (pLed1->bLedWPSBlinkInProgress)
1557             del_timer(&pLed1->BlinkTimer);
1558         else
1559             pLed1->bLedWPSBlinkInProgress = true;
1560         pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1561         if (pLed1->bLedOn)
1562             pLed1->BlinkingLedState = LED_STATE_OFF;
1563         else
1564             pLed1->BlinkingLedState = LED_STATE_ON;
1565         mod_timer(&pLed->BlinkTimer, jiffies +
1566               msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1567         break;
1568     case LED_CTL_STOP_WPS_FAIL_OVERLAP: /*WPS session overlap*/
1569         if (pLed->bLedWPSBlinkInProgress) {
1570             del_timer(&pLed->BlinkTimer);
1571             pLed->bLedWPSBlinkInProgress = false;
1572         }
1573         pLed->bLedNoLinkBlinkInProgress = true;
1574         pLed->CurrLedState = LED_BLINK_SLOWLY;
1575         if (pLed->bLedOn)
1576             pLed->BlinkingLedState = LED_STATE_OFF;
1577         else
1578             pLed->BlinkingLedState = LED_STATE_ON;
1579         mod_timer(&pLed->BlinkTimer, jiffies +
1580               msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1581         /*LED1 settings*/
1582         if (pLed1->bLedWPSBlinkInProgress)
1583             del_timer(&pLed1->BlinkTimer);
1584         else
1585             pLed1->bLedWPSBlinkInProgress = true;
1586         pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1587         pLed1->BlinkTimes = 10;
1588         if (pLed1->bLedOn)
1589             pLed1->BlinkingLedState = LED_STATE_OFF;
1590         else
1591             pLed1->BlinkingLedState = LED_STATE_ON;
1592         mod_timer(&pLed->BlinkTimer, jiffies +
1593               msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1594         break;
1595     case LED_CTL_POWER_OFF:
1596         pLed->CurrLedState = LED_STATE_OFF;
1597         pLed->BlinkingLedState = LED_STATE_OFF;
1598         if (pLed->bLedNoLinkBlinkInProgress) {
1599             del_timer(&pLed->BlinkTimer);
1600             pLed->bLedNoLinkBlinkInProgress = false;
1601         }
1602         if (pLed->bLedLinkBlinkInProgress) {
1603             del_timer(&pLed->BlinkTimer);
1604             pLed->bLedLinkBlinkInProgress = false;
1605         }
1606         if (pLed->bLedBlinkInProgress) {
1607             del_timer(&pLed->BlinkTimer);
1608             pLed->bLedBlinkInProgress = false;
1609         }
1610         if (pLed->bLedWPSBlinkInProgress) {
1611             del_timer(&pLed->BlinkTimer);
1612             pLed->bLedWPSBlinkInProgress = false;
1613         }
1614         if (pLed->bLedScanBlinkInProgress) {
1615             del_timer(&pLed->BlinkTimer);
1616             pLed->bLedScanBlinkInProgress = false;
1617         }
1618         if (pLed->bLedStartToLinkBlinkInProgress) {
1619             del_timer(&pLed->BlinkTimer);
1620             pLed->bLedStartToLinkBlinkInProgress = false;
1621         }
1622         if (pLed1->bLedWPSBlinkInProgress) {
1623             del_timer(&pLed1->BlinkTimer);
1624             pLed1->bLedWPSBlinkInProgress = false;
1625         }
1626         pLed1->BlinkingLedState = LED_UNKNOWN;
1627         SwLedOff(padapter, pLed);
1628         SwLedOff(padapter, pLed1);
1629         break;
1630     default:
1631         break;
1632     }
1633 }
1634 
1635 static void SwLedControlMode5(struct _adapter *padapter,
1636                   enum LED_CTL_MODE LedAction)
1637 {
1638     struct led_priv *ledpriv = &padapter->ledpriv;
1639     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1640     struct LED_871x *pLed = &ledpriv->SwLed0;
1641 
1642     if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
1643         pLed = &ledpriv->SwLed1;
1644 
1645     switch (LedAction) {
1646     case LED_CTL_POWER_ON:
1647     case LED_CTL_NO_LINK:
1648     case LED_CTL_LINK:  /* solid blue */
1649         if (pLed->CurrLedState == LED_SCAN_BLINK)
1650             return;
1651         pLed->CurrLedState = LED_STATE_ON;
1652         pLed->BlinkingLedState = LED_STATE_ON;
1653         pLed->bLedBlinkInProgress = false;
1654         mod_timer(&pLed->BlinkTimer,
1655               jiffies + msecs_to_jiffies(0));
1656         break;
1657     case LED_CTL_SITE_SURVEY:
1658         if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1659             check_fwstate(pmlmepriv, _FW_LINKED))
1660             ; /* dummy branch */
1661         else if (!pLed->bLedScanBlinkInProgress) {
1662             if (pLed->bLedBlinkInProgress) {
1663                 del_timer(&pLed->BlinkTimer);
1664                 pLed->bLedBlinkInProgress = false;
1665             }
1666             pLed->bLedScanBlinkInProgress = true;
1667             pLed->CurrLedState = LED_SCAN_BLINK;
1668             pLed->BlinkTimes = 24;
1669             if (pLed->bLedOn)
1670                 pLed->BlinkingLedState = LED_STATE_OFF;
1671             else
1672                 pLed->BlinkingLedState = LED_STATE_ON;
1673             mod_timer(&pLed->BlinkTimer, jiffies +
1674                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1675         }
1676         break;
1677     case LED_CTL_TX:
1678     case LED_CTL_RX:
1679         if (!pLed->bLedBlinkInProgress) {
1680             if (pLed->CurrLedState == LED_SCAN_BLINK)
1681                 return;
1682             pLed->bLedBlinkInProgress = true;
1683             pLed->CurrLedState = LED_TXRX_BLINK;
1684             pLed->BlinkTimes = 2;
1685             if (pLed->bLedOn)
1686                 pLed->BlinkingLedState = LED_STATE_OFF;
1687             else
1688                 pLed->BlinkingLedState = LED_STATE_ON;
1689             mod_timer(&pLed->BlinkTimer, jiffies +
1690                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1691         }
1692         break;
1693     case LED_CTL_POWER_OFF:
1694         pLed->CurrLedState = LED_STATE_OFF;
1695         pLed->BlinkingLedState = LED_STATE_OFF;
1696         if (pLed->bLedBlinkInProgress) {
1697             del_timer(&pLed->BlinkTimer);
1698             pLed->bLedBlinkInProgress = false;
1699         }
1700         SwLedOff(padapter, pLed);
1701         break;
1702     default:
1703         break;
1704     }
1705 }
1706 
1707 static void SwLedControlMode6(struct _adapter *padapter,
1708                   enum LED_CTL_MODE LedAction)
1709 {
1710     struct led_priv *ledpriv = &padapter->ledpriv;
1711     struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1712     struct LED_871x *pLed = &ledpriv->SwLed0;
1713 
1714     switch (LedAction) {
1715     case LED_CTL_POWER_ON:
1716     case LED_CTL_NO_LINK:
1717     case LED_CTL_LINK:  /*solid blue*/
1718     case LED_CTL_SITE_SURVEY:
1719         if (IS_LED_WPS_BLINKING(pLed))
1720             return;
1721         pLed->CurrLedState = LED_STATE_ON;
1722         pLed->BlinkingLedState = LED_STATE_ON;
1723         pLed->bLedBlinkInProgress = false;
1724         mod_timer(&pLed->BlinkTimer, jiffies + msecs_to_jiffies(0));
1725         break;
1726     case LED_CTL_TX:
1727     case LED_CTL_RX:
1728         if (!pLed->bLedBlinkInProgress &&
1729             check_fwstate(pmlmepriv, _FW_LINKED)) {
1730             if (IS_LED_WPS_BLINKING(pLed))
1731                 return;
1732             pLed->bLedBlinkInProgress = true;
1733             pLed->CurrLedState = LED_TXRX_BLINK;
1734             pLed->BlinkTimes = 2;
1735             if (pLed->bLedOn)
1736                 pLed->BlinkingLedState = LED_STATE_OFF;
1737             else
1738                 pLed->BlinkingLedState = LED_STATE_ON;
1739             mod_timer(&pLed->BlinkTimer, jiffies +
1740                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1741         }
1742         break;
1743     case LED_CTL_START_WPS: /*wait until xinpin finish*/
1744     case LED_CTL_START_WPS_BOTTON:
1745         if (!pLed->bLedWPSBlinkInProgress) {
1746             if (pLed->bLedBlinkInProgress) {
1747                 del_timer(&pLed->BlinkTimer);
1748                 pLed->bLedBlinkInProgress = false;
1749             }
1750             pLed->bLedWPSBlinkInProgress = true;
1751             pLed->CurrLedState = LED_BLINK_WPS;
1752             if (pLed->bLedOn)
1753                 pLed->BlinkingLedState = LED_STATE_OFF;
1754             else
1755                 pLed->BlinkingLedState = LED_STATE_ON;
1756             mod_timer(&pLed->BlinkTimer, jiffies +
1757                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1758         }
1759         break;
1760     case LED_CTL_STOP_WPS_FAIL:
1761     case LED_CTL_STOP_WPS:
1762         if (pLed->bLedWPSBlinkInProgress) {
1763             del_timer(&pLed->BlinkTimer);
1764             pLed->bLedWPSBlinkInProgress = false;
1765         }
1766         pLed->CurrLedState = LED_STATE_ON;
1767         pLed->BlinkingLedState = LED_STATE_ON;
1768         mod_timer(&pLed->BlinkTimer,
1769               jiffies + msecs_to_jiffies(0));
1770         break;
1771     case LED_CTL_POWER_OFF:
1772         pLed->CurrLedState = LED_STATE_OFF;
1773         pLed->BlinkingLedState = LED_STATE_OFF;
1774         if (pLed->bLedBlinkInProgress) {
1775             del_timer(&pLed->BlinkTimer);
1776             pLed->bLedBlinkInProgress = false;
1777         }
1778         if (pLed->bLedWPSBlinkInProgress) {
1779             del_timer(&pLed->BlinkTimer);
1780             pLed->bLedWPSBlinkInProgress = false;
1781         }
1782         SwLedOff(padapter, pLed);
1783         break;
1784     default:
1785         break;
1786     }
1787 }
1788 
1789 /*  Description:
1790  *      Dispatch LED action according to pHalData->LedStrategy.
1791  */
1792 void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction)
1793 {
1794     struct led_priv *ledpriv = &padapter->ledpriv;
1795 
1796     if (!ledpriv->bRegUseLed)
1797         return;
1798     switch (ledpriv->LedStrategy) {
1799     case SW_LED_MODE0:
1800         break;
1801     case SW_LED_MODE1:
1802         SwLedControlMode1(padapter, LedAction);
1803         break;
1804     case SW_LED_MODE2:
1805         SwLedControlMode2(padapter, LedAction);
1806         break;
1807     case SW_LED_MODE3:
1808         SwLedControlMode3(padapter, LedAction);
1809         break;
1810     case SW_LED_MODE4:
1811         SwLedControlMode4(padapter, LedAction);
1812         break;
1813     case SW_LED_MODE5:
1814         SwLedControlMode5(padapter, LedAction);
1815         break;
1816     case SW_LED_MODE6:
1817         SwLedControlMode6(padapter, LedAction);
1818         break;
1819     default:
1820         break;
1821     }
1822 }
1823 
1824 void r8712_flush_led_works(struct _adapter *padapter)
1825 {
1826     struct led_priv *pledpriv = &padapter->ledpriv;
1827 
1828     flush_work(&pledpriv->SwLed0.BlinkWorkItem);
1829     flush_work(&pledpriv->SwLed1.BlinkWorkItem);
1830 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!