kernel/drivers/staging/rtl8712/rtl8712_led.c

   1 /******************************************************************************
   2  * rtl8712_led.c
   3  *
   4  * Copyright(c) 2007 - 2010  Realtek Corporation. All rights reserved.
   5  * Linux device driver for RTL8192SU
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of version 2 of the GNU General Public License as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  19  *
  20  * Modifications for inclusion into the Linux staging tree are
  21  * Copyright(c) 2010 Larry Finger. All rights reserved.
  22  *
  23  * Contact information:
  24  * WLAN FAE <wlanfae@realtek.com>
  25  * Larry Finger <Larry.Finger@lwfinger.net>
  26  *
  27  ******************************************************************************/
  28
  29 #include "drv_types.h"
  30
  31 /*===========================================================================
  32  *      Constant.
  33  *===========================================================================
  34
  35  *
  36  * Default LED behavior.
  37  */
  38 #define LED_BLINK_NORMAL_INTERVAL       100
  39 #define LED_BLINK_SLOWLY_INTERVAL       200
  40 #define LED_BLINK_LONG_INTERVAL 400
  41
  42 #define LED_BLINK_NO_LINK_INTERVAL_ALPHA        1000
  43 #define LED_BLINK_LINK_INTERVAL_ALPHA           500
  44 #define LED_BLINK_SCAN_INTERVAL_ALPHA           180
  45 #define LED_BLINK_FASTER_INTERVAL_ALPHA         50
  46 #define LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA     5000
  47
  48 /*===========================================================================
  49  * LED object.
  50  *===========================================================================
  51  */
  52 enum _LED_STATE_871x {
  53         LED_UNKNOWN = 0,
  54         LED_ON = 1,
  55         LED_OFF = 2,
  56         LED_BLINK_NORMAL = 3,
  57         LED_BLINK_SLOWLY = 4,
  58         LED_POWER_ON_BLINK = 5,
  59         LED_SCAN_BLINK = 6, /* LED is blinking during scanning period,
  60                              * the # of times to blink is depend on time
  61                              * for scanning. */
  62         LED_NO_LINK_BLINK = 7, /* LED is blinking during no link state. */
  63         LED_BLINK_StartToBlink = 8,/* Customized for Sercomm Printer
  64                                     * Server case */
  65         LED_BLINK_WPS = 9,      /* LED is blinkg during WPS communication */
  66         LED_TXRX_BLINK = 10,
  67         LED_BLINK_WPS_STOP = 11,        /*for ALPHA */
  68         LED_BLINK_WPS_STOP_OVERLAP = 12,        /*for BELKIN */
  69 };
  70
  71 /*===========================================================================
  72  *      Prototype of protected function.
  73  *===========================================================================
  74  */
  75 static void BlinkTimerCallback(unsigned long data);
  76
  77 static void BlinkWorkItemCallback(struct work_struct *work);
  78 /*===========================================================================
  79  * LED_819xUsb routines.
  80  *===========================================================================
  81  *
  82  *
  83  *
  84  *      Description:
  85  *              Initialize an LED_871x object.
  86  */
  87 static void InitLed871x(struct _adapter *padapter, struct LED_871x *pLed,
  88                  enum LED_PIN_871x      LedPin)
  89 {
  90         struct  net_device *nic;
  91
  92         nic = padapter->pnetdev;
  93         pLed->padapter = padapter;
  94         pLed->LedPin = LedPin;
  95         pLed->CurrLedState = LED_OFF;
  96         pLed->bLedOn = false;
  97         pLed->bLedBlinkInProgress = false;
  98         pLed->BlinkTimes = 0;
  99         pLed->BlinkingLedState = LED_UNKNOWN;
 100         setup_timer(&pLed->BlinkTimer, BlinkTimerCallback,
 101                     (unsigned long)pLed);
 102         INIT_WORK(&pLed->BlinkWorkItem, BlinkWorkItemCallback);
 103 }
 104
 105 /*
 106  *      Description:
 107  *              DeInitialize an LED_871x object.
 108  */
 109 static void DeInitLed871x(struct LED_871x *pLed)
 110 {
 111         del_timer_sync(&pLed->BlinkTimer);
 112         /* We should reset bLedBlinkInProgress if we cancel
 113          * the LedControlTimer, */
 114         pLed->bLedBlinkInProgress = false;
 115 }
 116
 117 /*
 118  *      Description:
 119  *              Turn on LED according to LedPin specified.
 120  */
 121 static void SwLedOn(struct _adapter *padapter, struct LED_871x *pLed)
 122 {
 123         u8      LedCfg;
 124
 125         if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
 126                 return;
 127         LedCfg = r8712_read8(padapter, LEDCFG);
 128         switch (pLed->LedPin) {
 129         case LED_PIN_GPIO0:
 130                 break;
 131         case LED_PIN_LED0:
 132                 /* SW control led0 on.*/
 133                 r8712_write8(padapter, LEDCFG, LedCfg & 0xf0);
 134                 break;
 135         case LED_PIN_LED1:
 136                 /* SW control led1 on.*/
 137                 r8712_write8(padapter, LEDCFG, LedCfg & 0x0f);
 138                 break;
 139         default:
 140                 break;
 141         }
 142         pLed->bLedOn = true;
 143 }
 144
 145 /*
 146  *      Description:
 147  *              Turn off LED according to LedPin specified.
 148  */
 149 static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed)
 150 {
 151         u8      LedCfg;
 152
 153         if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
 154                 return;
 155         LedCfg = r8712_read8(padapter, LEDCFG);
 156         switch (pLed->LedPin) {
 157         case LED_PIN_GPIO0:
 158                 break;
 159         case LED_PIN_LED0:
 160                 LedCfg &= 0xf0; /* Set to software control.*/
 161                 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(3)));
 162                 break;
 163         case LED_PIN_LED1:
 164                 LedCfg &= 0x0f; /* Set to software control.*/
 165                 r8712_write8(padapter, LEDCFG, (LedCfg | BIT(7)));
 166                 break;
 167         default:
 168                 break;
 169         }
 170         pLed->bLedOn = false;
 171 }
 172
 173 /*===========================================================================
 174  * Interface to manipulate LED objects.
 175  *===========================================================================
 176  *
 177  *      Description:
 178  *              Initialize all LED_871x objects.
 179  */
 180 void r8712_InitSwLeds(struct _adapter *padapter)
 181 {
 182         struct led_priv *pledpriv = &(padapter->ledpriv);
 183
 184         pledpriv->LedControlHandler = LedControl871x;
 185         InitLed871x(padapter, &(pledpriv->SwLed0), LED_PIN_LED0);
 186         InitLed871x(padapter, &(pledpriv->SwLed1), LED_PIN_LED1);
 187 }
 188
 189 /*      Description:
 190  *              DeInitialize all LED_819xUsb objects.
 191  */
 192 void r8712_DeInitSwLeds(struct _adapter *padapter)
 193 {
 194         struct led_priv *ledpriv = &(padapter->ledpriv);
 195
 196         DeInitLed871x(&(ledpriv->SwLed0));
 197         DeInitLed871x(&(ledpriv->SwLed1));
 198 }
 199
 200 /*      Description:
 201  *              Implementation of LED blinking behavior.
 202  *              It toggle off LED and schedule corresponding timer if necessary.
 203  */
 204 static void SwLedBlink(struct LED_871x *pLed)
 205 {
 206         struct _adapter *padapter = pLed->padapter;
 207         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 208         u8 bStopBlinking = false;
 209
 210         /* Change LED according to BlinkingLedState specified. */
 211         if (pLed->BlinkingLedState == LED_ON)
 212                 SwLedOn(padapter, pLed);
 213         else
 214                 SwLedOff(padapter, pLed);
 215         /* Determine if we shall change LED state again. */
 216         pLed->BlinkTimes--;
 217         switch (pLed->CurrLedState) {
 218         case LED_BLINK_NORMAL:
 219                 if (pLed->BlinkTimes == 0)
 220                         bStopBlinking = true;
 221                 break;
 222         case LED_BLINK_StartToBlink:
 223                 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
 224                     (pmlmepriv->fw_state & WIFI_STATION_STATE))
 225                         bStopBlinking = true;
 226                 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
 227                     ((pmlmepriv->fw_state & WIFI_ADHOC_STATE) ||
 228                     (pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE)))
 229                         bStopBlinking = true;
 230                 else if (pLed->BlinkTimes == 0)
 231                         bStopBlinking = true;
 232                 break;
 233         case LED_BLINK_WPS:
 234                 if (pLed->BlinkTimes == 0)
 235                         bStopBlinking = true;
 236                 break;
 237         default:
 238                 bStopBlinking = true;
 239                 break;
 240         }
 241         if (bStopBlinking) {
 242                 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
 243                     !pLed->bLedOn)
 244                         SwLedOn(padapter, pLed);
 245                 else if (check_fwstate(pmlmepriv, _FW_LINKED) &&  pLed->bLedOn)
 246                         SwLedOff(padapter, pLed);
 247                 pLed->BlinkTimes = 0;
 248                 pLed->bLedBlinkInProgress = false;
 249         } else {
 250                 /* Assign LED state to toggle. */
 251                 if (pLed->BlinkingLedState == LED_ON)
 252                         pLed->BlinkingLedState = LED_OFF;
 253                 else
 254                         pLed->BlinkingLedState = LED_ON;
 255
 256                 /* Schedule a timer to toggle LED state. */
 257                 switch (pLed->CurrLedState) {
 258                 case LED_BLINK_NORMAL:
 259                         mod_timer(&pLed->BlinkTimer, jiffies +
 260                                   msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 261                         break;
 262                 case LED_BLINK_SLOWLY:
 263                 case LED_BLINK_StartToBlink:
 264                         mod_timer(&pLed->BlinkTimer, jiffies +
 265                                   msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
 266                         break;
 267                 case LED_BLINK_WPS:
 268                         mod_timer(&pLed->BlinkTimer, jiffies +
 269                                   msecs_to_jiffies(LED_BLINK_LONG_INTERVAL));
 270                         break;
 271                 default:
 272                         mod_timer(&pLed->BlinkTimer, jiffies +
 273                                   msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
 274                         break;
 275                 }
 276         }
 277 }
 278
 279 static void SwLedBlink1(struct LED_871x *pLed)
 280 {
 281         struct _adapter *padapter = pLed->padapter;
 282         struct led_priv *ledpriv = &(padapter->ledpriv);
 283         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 284         struct eeprom_priv *peeprompriv = &(padapter->eeprompriv);
 285         struct LED_871x *pLed1 = &(ledpriv->SwLed1);
 286         u8 bStopBlinking = false;
 287
 288         if (peeprompriv->CustomerID == RT_CID_819x_CAMEO)
 289                 pLed = &(ledpriv->SwLed1);
 290         /* Change LED according to BlinkingLedState specified. */
 291         if (pLed->BlinkingLedState == LED_ON)
 292                 SwLedOn(padapter, pLed);
 293         else
 294                 SwLedOff(padapter, pLed);
 295         if (peeprompriv->CustomerID == RT_CID_DEFAULT) {
 296                 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 297                         if (!pLed1->bSWLedCtrl) {
 298                                 SwLedOn(padapter, pLed1);
 299                                 pLed1->bSWLedCtrl = true;
 300                         } else if (!pLed1->bLedOn) {
 301                                 SwLedOn(padapter, pLed1);
 302                         }
 303                 } else {
 304                         if (!pLed1->bSWLedCtrl) {
 305                                 SwLedOff(padapter, pLed1);
 306                                 pLed1->bSWLedCtrl = true;
 307                         } else if (pLed1->bLedOn) {
 308                                 SwLedOff(padapter, pLed1);
 309                         }
 310                 }
 311         }
 312         switch (pLed->CurrLedState) {
 313         case LED_BLINK_SLOWLY:
 314                 if (pLed->bLedOn)
 315                         pLed->BlinkingLedState = LED_OFF;
 316                 else
 317                         pLed->BlinkingLedState = LED_ON;
 318                 mod_timer(&pLed->BlinkTimer, jiffies +
 319                           msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 320                 break;
 321         case LED_BLINK_NORMAL:
 322                 if (pLed->bLedOn)
 323                         pLed->BlinkingLedState = LED_OFF;
 324                 else
 325                         pLed->BlinkingLedState = LED_ON;
 326                 mod_timer(&pLed->BlinkTimer, jiffies +
 327                           msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 328                 break;
 329         case LED_SCAN_BLINK:
 330                 pLed->BlinkTimes--;
 331                 if (pLed->BlinkTimes == 0)
 332                         bStopBlinking = true;
 333                 if (bStopBlinking) {
 334                         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 335                                 pLed->bLedLinkBlinkInProgress = true;
 336                                 pLed->CurrLedState = LED_BLINK_NORMAL;
 337                                 if (pLed->bLedOn)
 338                                         pLed->BlinkingLedState = LED_OFF;
 339                                 else
 340                                         pLed->BlinkingLedState = LED_ON;
 341                                 mod_timer(&pLed->BlinkTimer, jiffies +
 342                                           msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 343                         } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 344                                 pLed->bLedNoLinkBlinkInProgress = true;
 345                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
 346                                 if (pLed->bLedOn)
 347                                         pLed->BlinkingLedState = LED_OFF;
 348                                 else
 349                                         pLed->BlinkingLedState = LED_ON;
 350                                 mod_timer(&pLed->BlinkTimer, jiffies +
 351                                           msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 352                         }
 353                         pLed->bLedScanBlinkInProgress = false;
 354                 } else {
 355                          if (pLed->bLedOn)
 356                                 pLed->BlinkingLedState = LED_OFF;
 357                         else
 358                                 pLed->BlinkingLedState = LED_ON;
 359                         mod_timer(&pLed->BlinkTimer, jiffies +
 360                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 361                 }
 362                 break;
 363         case LED_TXRX_BLINK:
 364                 pLed->BlinkTimes--;
 365                 if (pLed->BlinkTimes == 0)
 366                         bStopBlinking = true;
 367                 if (bStopBlinking) {
 368                         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 369                                 pLed->bLedLinkBlinkInProgress = true;
 370                                 pLed->CurrLedState = LED_BLINK_NORMAL;
 371                                 if (pLed->bLedOn)
 372                                         pLed->BlinkingLedState = LED_OFF;
 373                                 else
 374                                         pLed->BlinkingLedState = LED_ON;
 375                                 mod_timer(&pLed->BlinkTimer, jiffies +
 376                                           msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 377                         } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 378                                 pLed->bLedNoLinkBlinkInProgress = true;
 379                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
 380                                 if (pLed->bLedOn)
 381                                         pLed->BlinkingLedState = LED_OFF;
 382                                 else
 383                                         pLed->BlinkingLedState = LED_ON;
 384                                 mod_timer(&pLed->BlinkTimer, jiffies +
 385                                           msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 386                         }
 387                         pLed->BlinkTimes = 0;
 388                         pLed->bLedBlinkInProgress = false;
 389                 } else {
 390                          if (pLed->bLedOn)
 391                                 pLed->BlinkingLedState = LED_OFF;
 392                         else
 393                                 pLed->BlinkingLedState = LED_ON;
 394                         mod_timer(&pLed->BlinkTimer, jiffies +
 395                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 396                 }
 397                 break;
 398         case LED_BLINK_WPS:
 399                 if (pLed->bLedOn)
 400                         pLed->BlinkingLedState = LED_OFF;
 401                 else
 402                         pLed->BlinkingLedState = LED_ON;
 403                 mod_timer(&pLed->BlinkTimer, jiffies +
 404                           msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 405                 break;
 406         case LED_BLINK_WPS_STOP:        /* WPS success */
 407                 if (pLed->BlinkingLedState == LED_ON) {
 408                         pLed->BlinkingLedState = LED_OFF;
 409                         mod_timer(&pLed->BlinkTimer, jiffies +
 410                                   msecs_to_jiffies(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA));
 411                         bStopBlinking = false;
 412                 } else {
 413                         bStopBlinking = true;
 414                 }
 415                 if (bStopBlinking) {
 416                         pLed->bLedLinkBlinkInProgress = true;
 417                         pLed->CurrLedState = LED_BLINK_NORMAL;
 418                         if (pLed->bLedOn)
 419                                 pLed->BlinkingLedState = LED_OFF;
 420                         else
 421                                 pLed->BlinkingLedState = LED_ON;
 422                         mod_timer(&pLed->BlinkTimer, jiffies +
 423                                   msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 424                 }
 425                 pLed->bLedWPSBlinkInProgress = false;
 426                 break;
 427         default:
 428                 break;
 429         }
 430 }
 431
 432 static void SwLedBlink2(struct LED_871x *pLed)
 433 {
 434         struct _adapter *padapter = pLed->padapter;
 435         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 436         u8 bStopBlinking = false;
 437
 438         /* Change LED according to BlinkingLedState specified. */
 439         if (pLed->BlinkingLedState == LED_ON)
 440                 SwLedOn(padapter, pLed);
 441         else
 442                 SwLedOff(padapter, pLed);
 443         switch (pLed->CurrLedState) {
 444         case LED_SCAN_BLINK:
 445                 pLed->BlinkTimes--;
 446                 if (pLed->BlinkTimes == 0)
 447                         bStopBlinking = true;
 448                 if (bStopBlinking) {
 449                         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 450                                 pLed->CurrLedState = LED_ON;
 451                                 pLed->BlinkingLedState = LED_ON;
 452                                 SwLedOn(padapter, pLed);
 453                         } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 454                                 pLed->CurrLedState = LED_OFF;
 455                                 pLed->BlinkingLedState = LED_OFF;
 456                                 SwLedOff(padapter, pLed);
 457                         }
 458                         pLed->bLedScanBlinkInProgress = false;
 459                 } else {
 460                          if (pLed->bLedOn)
 461                                 pLed->BlinkingLedState = LED_OFF;
 462                         else
 463                                 pLed->BlinkingLedState = LED_ON;
 464                         mod_timer(&pLed->BlinkTimer, jiffies +
 465                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 466                 }
 467                 break;
 468         case LED_TXRX_BLINK:
 469                 pLed->BlinkTimes--;
 470                 if (pLed->BlinkTimes == 0)
 471                         bStopBlinking = true;
 472                 if (bStopBlinking) {
 473                         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 474                                 pLed->CurrLedState = LED_ON;
 475                                 pLed->BlinkingLedState = LED_ON;
 476                                 SwLedOn(padapter, pLed);
 477                         } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 478                                 pLed->CurrLedState = LED_OFF;
 479                                 pLed->BlinkingLedState = LED_OFF;
 480                                 SwLedOff(padapter, pLed);
 481                         }
 482                         pLed->bLedBlinkInProgress = false;
 483                 } else {
 484                         if (pLed->bLedOn)
 485                                 pLed->BlinkingLedState = LED_OFF;
 486                         else
 487                                 pLed->BlinkingLedState = LED_ON;
 488                         mod_timer(&pLed->BlinkTimer, jiffies +
 489                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 490                 }
 491                 break;
 492         default:
 493                 break;
 494         }
 495 }
 496
 497 static void SwLedBlink3(struct LED_871x *pLed)
 498 {
 499         struct _adapter *padapter = pLed->padapter;
 500         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 501         u8 bStopBlinking = false;
 502
 503         /* Change LED according to BlinkingLedState specified. */
 504         if (pLed->BlinkingLedState == LED_ON)
 505                 SwLedOn(padapter, pLed);
 506         else
 507                 if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
 508                         SwLedOff(padapter, pLed);
 509         switch (pLed->CurrLedState) {
 510         case LED_SCAN_BLINK:
 511                 pLed->BlinkTimes--;
 512                 if (pLed->BlinkTimes == 0)
 513                         bStopBlinking = true;
 514                 if (bStopBlinking) {
 515                         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 516                                 pLed->CurrLedState = LED_ON;
 517                                 pLed->BlinkingLedState = LED_ON;
 518                                 if (!pLed->bLedOn)
 519                                         SwLedOn(padapter, pLed);
 520                         } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 521                                 pLed->CurrLedState = LED_OFF;
 522                                 pLed->BlinkingLedState = LED_OFF;
 523                                 if (pLed->bLedOn)
 524                                         SwLedOff(padapter, pLed);
 525                         }
 526                         pLed->bLedScanBlinkInProgress = false;
 527                 } else {
 528                         if (pLed->bLedOn)
 529                                 pLed->BlinkingLedState = LED_OFF;
 530                         else
 531                                 pLed->BlinkingLedState = LED_ON;
 532                         mod_timer(&pLed->BlinkTimer, jiffies +
 533                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 534                 }
 535                 break;
 536         case LED_TXRX_BLINK:
 537                 pLed->BlinkTimes--;
 538                 if (pLed->BlinkTimes == 0)
 539                         bStopBlinking = true;
 540                 if (bStopBlinking) {
 541                         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 542                                 pLed->CurrLedState = LED_ON;
 543                                 pLed->BlinkingLedState = LED_ON;
 544                                 if (!pLed->bLedOn)
 545                                         SwLedOn(padapter, pLed);
 546                         } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 547                                 pLed->CurrLedState = LED_OFF;
 548                                 pLed->BlinkingLedState = LED_OFF;
 549                                 if (pLed->bLedOn)
 550                                         SwLedOff(padapter, pLed);
 551                         }
 552                         pLed->bLedBlinkInProgress = false;
 553                 } else {
 554                         if (pLed->bLedOn)
 555                                 pLed->BlinkingLedState = LED_OFF;
 556                         else
 557                                 pLed->BlinkingLedState = LED_ON;
 558                         mod_timer(&pLed->BlinkTimer, jiffies +
 559                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 560                 }
 561                 break;
 562         case LED_BLINK_WPS:
 563                 if (pLed->bLedOn)
 564                         pLed->BlinkingLedState = LED_OFF;
 565                 else
 566                         pLed->BlinkingLedState = LED_ON;
 567                 mod_timer(&pLed->BlinkTimer, jiffies +
 568                           msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 569                 break;
 570         case LED_BLINK_WPS_STOP:        /*WPS success*/
 571                 if (pLed->BlinkingLedState == LED_ON) {
 572                         pLed->BlinkingLedState = LED_OFF;
 573                         mod_timer(&pLed->BlinkTimer, jiffies +
 574                                   msecs_to_jiffies(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA));
 575                         bStopBlinking = false;
 576                 } else {
 577                         bStopBlinking = true;
 578                 }
 579                 if (bStopBlinking) {
 580                         pLed->CurrLedState = LED_ON;
 581                         pLed->BlinkingLedState = LED_ON;
 582                         SwLedOn(padapter, pLed);
 583                         pLed->bLedWPSBlinkInProgress = false;
 584                 }
 585                 break;
 586         default:
 587                 break;
 588         }
 589 }
 590
 591 static void SwLedBlink4(struct LED_871x *pLed)
 592 {
 593         struct _adapter *padapter = pLed->padapter;
 594         struct led_priv *ledpriv = &(padapter->ledpriv);
 595         struct LED_871x *pLed1 = &(ledpriv->SwLed1);
 596         u8 bStopBlinking = false;
 597
 598         /* Change LED according to BlinkingLedState specified. */
 599         if (pLed->BlinkingLedState == LED_ON)
 600                 SwLedOn(padapter, pLed);
 601         else
 602                 SwLedOff(padapter, pLed);
 603         if (!pLed1->bLedWPSBlinkInProgress &&
 604             pLed1->BlinkingLedState == LED_UNKNOWN) {
 605                 pLed1->BlinkingLedState = LED_OFF;
 606                 pLed1->CurrLedState = LED_OFF;
 607                 SwLedOff(padapter, pLed1);
 608         }
 609         switch (pLed->CurrLedState) {
 610         case LED_BLINK_SLOWLY:
 611                 if (pLed->bLedOn)
 612                         pLed->BlinkingLedState = LED_OFF;
 613                 else
 614                         pLed->BlinkingLedState = LED_ON;
 615                 mod_timer(&pLed->BlinkTimer, jiffies +
 616                           msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 617                 break;
 618         case LED_BLINK_StartToBlink:
 619                 if (pLed->bLedOn) {
 620                         pLed->BlinkingLedState = LED_OFF;
 621                         mod_timer(&pLed->BlinkTimer, jiffies +
 622                                   msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
 623                 } else {
 624                         pLed->BlinkingLedState = LED_ON;
 625                         mod_timer(&pLed->BlinkTimer, jiffies +
 626                                   msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 627                 }
 628                 break;
 629         case LED_SCAN_BLINK:
 630                 pLed->BlinkTimes--;
 631                 if (pLed->BlinkTimes == 0)
 632                         bStopBlinking = true;
 633                 if (bStopBlinking) {
 634                         pLed->bLedNoLinkBlinkInProgress = true;
 635                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 636                         if (pLed->bLedOn)
 637                                 pLed->BlinkingLedState = LED_OFF;
 638                         else
 639                                 pLed->BlinkingLedState = LED_ON;
 640                         mod_timer(&pLed->BlinkTimer, jiffies +
 641                                   msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 642                         pLed->bLedScanBlinkInProgress = false;
 643                 } else {
 644                         if (pLed->bLedOn)
 645                                 pLed->BlinkingLedState = LED_OFF;
 646                         else
 647                                 pLed->BlinkingLedState = LED_ON;
 648                         mod_timer(&pLed->BlinkTimer, jiffies +
 649                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 650                 }
 651                 break;
 652         case LED_TXRX_BLINK:
 653                 pLed->BlinkTimes--;
 654                 if (pLed->BlinkTimes == 0)
 655                         bStopBlinking = true;
 656                 if (bStopBlinking) {
 657                         pLed->bLedNoLinkBlinkInProgress = true;
 658                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 659                         if (pLed->bLedOn)
 660                                 pLed->BlinkingLedState = LED_OFF;
 661                         else
 662                                 pLed->BlinkingLedState = LED_ON;
 663                         mod_timer(&pLed->BlinkTimer, jiffies +
 664                                   msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 665                         pLed->bLedBlinkInProgress = false;
 666                 } else {
 667                          if (pLed->bLedOn)
 668                                 pLed->BlinkingLedState = LED_OFF;
 669                         else
 670                                 pLed->BlinkingLedState = LED_ON;
 671                         mod_timer(&pLed->BlinkTimer, jiffies +
 672                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 673                 }
 674                 break;
 675         case LED_BLINK_WPS:
 676                 if (pLed->bLedOn) {
 677                         pLed->BlinkingLedState = LED_OFF;
 678                         mod_timer(&pLed->BlinkTimer, jiffies +
 679                                   msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
 680                 } else {
 681                         pLed->BlinkingLedState = LED_ON;
 682                         mod_timer(&pLed->BlinkTimer, jiffies +
 683                                   msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 684                 }
 685                 break;
 686         case LED_BLINK_WPS_STOP:        /*WPS authentication fail*/
 687                 if (pLed->bLedOn)
 688                         pLed->BlinkingLedState = LED_OFF;
 689                 else
 690                         pLed->BlinkingLedState = LED_ON;
 691                 mod_timer(&pLed->BlinkTimer, jiffies +
 692                           msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 693                 break;
 694         case LED_BLINK_WPS_STOP_OVERLAP:        /*WPS session overlap */
 695                 pLed->BlinkTimes--;
 696                 if (pLed->BlinkTimes == 0) {
 697                         if (pLed->bLedOn)
 698                                 pLed->BlinkTimes = 1;
 699                         else
 700                                 bStopBlinking = true;
 701                 }
 702                 if (bStopBlinking) {
 703                         pLed->BlinkTimes = 10;
 704                         pLed->BlinkingLedState = LED_ON;
 705                         mod_timer(&pLed->BlinkTimer, jiffies +
 706                                   msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 707                 } else {
 708                         if (pLed->bLedOn)
 709                                 pLed->BlinkingLedState = LED_OFF;
 710                         else
 711                                 pLed->BlinkingLedState = LED_ON;
 712                         mod_timer(&pLed->BlinkTimer, jiffies +
 713                                   msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 714                 }
 715                 break;
 716         default:
 717                 break;
 718         }
 719 }
 720
 721 static void SwLedBlink5(struct LED_871x *pLed)
 722 {
 723         struct _adapter *padapter = pLed->padapter;
 724         u8 bStopBlinking = false;
 725
 726         /* Change LED according to BlinkingLedState specified. */
 727         if (pLed->BlinkingLedState == LED_ON)
 728                 SwLedOn(padapter, pLed);
 729         else
 730                 SwLedOff(padapter, pLed);
 731         switch (pLed->CurrLedState) {
 732         case LED_SCAN_BLINK:
 733                 pLed->BlinkTimes--;
 734                 if (pLed->BlinkTimes == 0)
 735                         bStopBlinking = true;
 736                 if (bStopBlinking) {
 737                         pLed->CurrLedState = LED_ON;
 738                         pLed->BlinkingLedState = LED_ON;
 739                         if (!pLed->bLedOn)
 740                                 mod_timer(&pLed->BlinkTimer, jiffies +
 741                                           msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 742                         pLed->bLedScanBlinkInProgress = false;
 743                 } else {
 744                         if (pLed->bLedOn)
 745                                 pLed->BlinkingLedState = LED_OFF;
 746                         else
 747                                 pLed->BlinkingLedState = LED_ON;
 748                         mod_timer(&pLed->BlinkTimer, jiffies +
 749                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 750                 }
 751                 break;
 752         case LED_TXRX_BLINK:
 753                 pLed->BlinkTimes--;
 754                 if (pLed->BlinkTimes == 0)
 755                         bStopBlinking = true;
 756                 if (bStopBlinking) {
 757                         pLed->CurrLedState = LED_ON;
 758                         pLed->BlinkingLedState = LED_ON;
 759                         if (!pLed->bLedOn)
 760                                 mod_timer(&pLed->BlinkTimer, jiffies +
 761                                           msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 762                         pLed->bLedBlinkInProgress = false;
 763                 } else {
 764                          if (pLed->bLedOn)
 765                                 pLed->BlinkingLedState = LED_OFF;
 766                         else
 767                                 pLed->BlinkingLedState = LED_ON;
 768                         mod_timer(&pLed->BlinkTimer, jiffies +
 769                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 770                 }
 771                 break;
 772         default:
 773                 break;
 774         }
 775 }
 776
 777 static void SwLedBlink6(struct LED_871x *pLed)
 778 {
 779         struct _adapter *padapter = pLed->padapter;
 780         u8 bStopBlinking = false;
 781
 782         /* Change LED according to BlinkingLedState specified. */
 783         if (pLed->BlinkingLedState == LED_ON)
 784                 SwLedOn(padapter, pLed);
 785         else
 786                 SwLedOff(padapter, pLed);
 787         switch (pLed->CurrLedState) {
 788         case LED_TXRX_BLINK:
 789                 pLed->BlinkTimes--;
 790                 if (pLed->BlinkTimes == 0)
 791                         bStopBlinking = true;
 792                 if (bStopBlinking) {
 793                         pLed->CurrLedState = LED_ON;
 794                         pLed->BlinkingLedState = LED_ON;
 795                         if (!pLed->bLedOn)
 796                                 SwLedOn(padapter, pLed);
 797                         pLed->bLedBlinkInProgress = false;
 798                 } else {
 799                         if (pLed->bLedOn)
 800                                 pLed->BlinkingLedState = LED_OFF;
 801                         else
 802                                 pLed->BlinkingLedState = LED_ON;
 803                         mod_timer(&pLed->BlinkTimer, jiffies +
 804                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 805                 }
 806                 break;
 807         case LED_BLINK_WPS:
 808                 if (pLed->bLedOn)
 809                         pLed->BlinkingLedState = LED_OFF;
 810                 else
 811                         pLed->BlinkingLedState = LED_ON;
 812                 mod_timer(&pLed->BlinkTimer, jiffies +
 813                           msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 814                 break;
 815
 816         default:
 817                 break;
 818         }
 819 }
 820
 821 /*      Description:
 822  *              Callback function of LED BlinkTimer,
 823  *              it just schedules to corresponding BlinkWorkItem.
 824  */
 825 static void BlinkTimerCallback(unsigned long data)
 826 {
 827         struct LED_871x  *pLed = (struct LED_871x *)data;
 828
 829         /* This fixed the crash problem on Fedora 12 when trying to do the
 830          * insmod;ifconfig up;rmmod commands. */
 831         if (pLed->padapter->bSurpriseRemoved || pLed->padapter->bDriverStopped)
 832                 return;
 833         schedule_work(&pLed->BlinkWorkItem);
 834 }
 835
 836 /*      Description:
 837  *              Callback function of LED BlinkWorkItem.
 838  *              We dispatch actual LED blink action according to LedStrategy.
 839  */
 840 static void BlinkWorkItemCallback(struct work_struct *work)
 841 {
 842         struct LED_871x *pLed = container_of(work, struct LED_871x,
 843                                 BlinkWorkItem);
 844         struct led_priv *ledpriv = &(pLed->padapter->ledpriv);
 845
 846         switch (ledpriv->LedStrategy) {
 847         case SW_LED_MODE0:
 848                 SwLedBlink(pLed);
 849                 break;
 850         case SW_LED_MODE1:
 851                 SwLedBlink1(pLed);
 852                 break;
 853         case SW_LED_MODE2:
 854                 SwLedBlink2(pLed);
 855                 break;
 856         case SW_LED_MODE3:
 857                 SwLedBlink3(pLed);
 858                 break;
 859         case SW_LED_MODE4:
 860                 SwLedBlink4(pLed);
 861                 break;
 862         case SW_LED_MODE5:
 863                 SwLedBlink5(pLed);
 864                 break;
 865         case SW_LED_MODE6:
 866                 SwLedBlink6(pLed);
 867                 break;
 868         default:
 869                 SwLedBlink(pLed);
 870                 break;
 871         }
 872 }
 873
 874 /*============================================================================
 875  * Default LED behavior.
 876  *============================================================================
 877  *
 878  *      Description:
 879  *              Implement each led action for SW_LED_MODE0.
 880  *              This is default strategy.
 881  */
 882
 883 static void SwLedControlMode1(struct _adapter *padapter,
 884                               enum LED_CTL_MODE LedAction)
 885 {
 886         struct led_priv *ledpriv = &(padapter->ledpriv);
 887         struct LED_871x *pLed = &(ledpriv->SwLed0);
 888         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 889         struct sitesurvey_ctrl *psitesurveyctrl = &(pmlmepriv->sitesurveyctrl);
 890
 891         if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
 892                 pLed = &(ledpriv->SwLed1);
 893         switch (LedAction) {
 894         case LED_CTL_START_TO_LINK:
 895         case LED_CTL_NO_LINK:
 896                 if (!pLed->bLedNoLinkBlinkInProgress) {
 897                         if (pLed->CurrLedState == LED_SCAN_BLINK ||
 898                           IS_LED_WPS_BLINKING(pLed))
 899                                 return;
 900                         if (pLed->bLedLinkBlinkInProgress) {
 901                                 del_timer(&pLed->BlinkTimer);
 902                                 pLed->bLedLinkBlinkInProgress = false;
 903                         }
 904                         if (pLed->bLedBlinkInProgress) {
 905                                 del_timer(&pLed->BlinkTimer);
 906                                 pLed->bLedBlinkInProgress = false;
 907                         }
 908                         pLed->bLedNoLinkBlinkInProgress = true;
 909                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 910                         if (pLed->bLedOn)
 911                                 pLed->BlinkingLedState = LED_OFF;
 912                         else
 913                                 pLed->BlinkingLedState = LED_ON;
 914                         mod_timer(&pLed->BlinkTimer, jiffies +
 915                                   msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 916                 }
 917                 break;
 918         case LED_CTL_LINK:
 919                 if (!pLed->bLedLinkBlinkInProgress) {
 920                         if (pLed->CurrLedState == LED_SCAN_BLINK ||
 921                             IS_LED_WPS_BLINKING(pLed))
 922                                 return;
 923                         if (pLed->bLedNoLinkBlinkInProgress) {
 924                                 del_timer(&pLed->BlinkTimer);
 925                                 pLed->bLedNoLinkBlinkInProgress = false;
 926                         }
 927                         if (pLed->bLedBlinkInProgress) {
 928                                 del_timer(&pLed->BlinkTimer);
 929                                 pLed->bLedBlinkInProgress = false;
 930                         }
 931                         pLed->bLedLinkBlinkInProgress = true;
 932                         pLed->CurrLedState = LED_BLINK_NORMAL;
 933                         if (pLed->bLedOn)
 934                                 pLed->BlinkingLedState = LED_OFF;
 935                         else
 936                                 pLed->BlinkingLedState = LED_ON;
 937                         mod_timer(&pLed->BlinkTimer, jiffies +
 938                                   msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 939                 }
 940                 break;
 941         case LED_CTL_SITE_SURVEY:
 942                 if (psitesurveyctrl->traffic_busy &&
 943                     check_fwstate(pmlmepriv, _FW_LINKED))
 944                         ; /* dummy branch */
 945                  else if (!pLed->bLedScanBlinkInProgress) {
 946                         if (IS_LED_WPS_BLINKING(pLed))
 947                                 return;
 948                         if (pLed->bLedNoLinkBlinkInProgress) {
 949                                 del_timer(&pLed->BlinkTimer);
 950                                 pLed->bLedNoLinkBlinkInProgress = false;
 951                         }
 952                         if (pLed->bLedLinkBlinkInProgress) {
 953                                 del_timer(&pLed->BlinkTimer);
 954                                  pLed->bLedLinkBlinkInProgress = false;
 955                         }
 956                         if (pLed->bLedBlinkInProgress) {
 957                                 del_timer(&pLed->BlinkTimer);
 958                                 pLed->bLedBlinkInProgress = false;
 959                         }
 960                         pLed->bLedScanBlinkInProgress = true;
 961                         pLed->CurrLedState = LED_SCAN_BLINK;
 962                         pLed->BlinkTimes = 24;
 963                         if (pLed->bLedOn)
 964                                 pLed->BlinkingLedState = LED_OFF;
 965                         else
 966                                 pLed->BlinkingLedState = LED_ON;
 967                         mod_timer(&pLed->BlinkTimer, jiffies +
 968                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 969                  }
 970                 break;
 971         case LED_CTL_TX:
 972         case LED_CTL_RX:
 973                 if (!pLed->bLedBlinkInProgress) {
 974                         if (pLed->CurrLedState == LED_SCAN_BLINK ||
 975                             IS_LED_WPS_BLINKING(pLed))
 976                                 return;
 977                         if (pLed->bLedNoLinkBlinkInProgress) {
 978                                 del_timer(&pLed->BlinkTimer);
 979                                 pLed->bLedNoLinkBlinkInProgress = false;
 980                         }
 981                         if (pLed->bLedLinkBlinkInProgress) {
 982                                 del_timer(&pLed->BlinkTimer);
 983                                 pLed->bLedLinkBlinkInProgress = false;
 984                         }
 985                         pLed->bLedBlinkInProgress = true;
 986                         pLed->CurrLedState = LED_TXRX_BLINK;
 987                         pLed->BlinkTimes = 2;
 988                         if (pLed->bLedOn)
 989                                 pLed->BlinkingLedState = LED_OFF;
 990                         else
 991                                 pLed->BlinkingLedState = LED_ON;
 992                         mod_timer(&pLed->BlinkTimer, jiffies +
 993                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 994                 }
 995                 break;
 996
 997         case LED_CTL_START_WPS: /*wait until xinpin finish */
 998         case LED_CTL_START_WPS_BOTTON:
 999                  if (!pLed->bLedWPSBlinkInProgress) {
1000                         if (pLed->bLedNoLinkBlinkInProgress) {
1001                                 del_timer(&pLed->BlinkTimer);
1002                                 pLed->bLedNoLinkBlinkInProgress = false;
1003                         }
1004                         if (pLed->bLedLinkBlinkInProgress) {
1005                                 del_timer(&pLed->BlinkTimer);
1006                                  pLed->bLedLinkBlinkInProgress = false;
1007                         }
1008                         if (pLed->bLedBlinkInProgress) {
1009                                 del_timer(&pLed->BlinkTimer);
1010                                 pLed->bLedBlinkInProgress = false;
1011                         }
1012                         if (pLed->bLedScanBlinkInProgress) {
1013                                 del_timer(&pLed->BlinkTimer);
1014                                 pLed->bLedScanBlinkInProgress = false;
1015                         }
1016                         pLed->bLedWPSBlinkInProgress = true;
1017                         pLed->CurrLedState = LED_BLINK_WPS;
1018                         if (pLed->bLedOn)
1019                                 pLed->BlinkingLedState = LED_OFF;
1020                         else
1021                                 pLed->BlinkingLedState = LED_ON;
1022                         mod_timer(&pLed->BlinkTimer, jiffies +
1023                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1024                 }
1025                 break;
1026         case LED_CTL_STOP_WPS:
1027                 if (pLed->bLedNoLinkBlinkInProgress) {
1028                         del_timer(&pLed->BlinkTimer);
1029                         pLed->bLedNoLinkBlinkInProgress = false;
1030                 }
1031                 if (pLed->bLedLinkBlinkInProgress) {
1032                         del_timer(&pLed->BlinkTimer);
1033                          pLed->bLedLinkBlinkInProgress = false;
1034                 }
1035                 if (pLed->bLedBlinkInProgress) {
1036                         del_timer(&pLed->BlinkTimer);
1037                         pLed->bLedBlinkInProgress = false;
1038                 }
1039                 if (pLed->bLedScanBlinkInProgress) {
1040                         del_timer(&pLed->BlinkTimer);
1041                         pLed->bLedScanBlinkInProgress = false;
1042                 }
1043                 if (pLed->bLedWPSBlinkInProgress)
1044                         del_timer(&pLed->BlinkTimer);
1045                 else
1046                         pLed->bLedWPSBlinkInProgress = true;
1047                 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1048                 if (pLed->bLedOn) {
1049                         pLed->BlinkingLedState = LED_OFF;
1050                         mod_timer(&pLed->BlinkTimer, jiffies +
1051                                   msecs_to_jiffies(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA));
1052                 } else {
1053                         pLed->BlinkingLedState = LED_ON;
1054                         mod_timer(&pLed->BlinkTimer,
1055                                   jiffies + msecs_to_jiffies(0));
1056                 }
1057                 break;
1058         case LED_CTL_STOP_WPS_FAIL:
1059                 if (pLed->bLedWPSBlinkInProgress) {
1060                         del_timer(&pLed->BlinkTimer);
1061                         pLed->bLedWPSBlinkInProgress = false;
1062                 }
1063                 pLed->bLedNoLinkBlinkInProgress = true;
1064                 pLed->CurrLedState = LED_BLINK_SLOWLY;
1065                 if (pLed->bLedOn)
1066                         pLed->BlinkingLedState = LED_OFF;
1067                 else
1068                         pLed->BlinkingLedState = LED_ON;
1069                 mod_timer(&pLed->BlinkTimer, jiffies +
1070                           msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1071                 break;
1072         case LED_CTL_POWER_OFF:
1073                 pLed->CurrLedState = LED_OFF;
1074                 pLed->BlinkingLedState = LED_OFF;
1075                 if (pLed->bLedNoLinkBlinkInProgress) {
1076                         del_timer(&pLed->BlinkTimer);
1077                         pLed->bLedNoLinkBlinkInProgress = false;
1078                 }
1079                 if (pLed->bLedLinkBlinkInProgress) {
1080                         del_timer(&pLed->BlinkTimer);
1081                         pLed->bLedLinkBlinkInProgress = false;
1082                 }
1083                 if (pLed->bLedBlinkInProgress) {
1084                         del_timer(&pLed->BlinkTimer);
1085                         pLed->bLedBlinkInProgress = false;
1086                 }
1087                 if (pLed->bLedWPSBlinkInProgress) {
1088                         del_timer(&pLed->BlinkTimer);
1089                         pLed->bLedWPSBlinkInProgress = false;
1090                 }
1091                 if (pLed->bLedScanBlinkInProgress) {
1092                         del_timer(&pLed->BlinkTimer);
1093                         pLed->bLedScanBlinkInProgress = false;
1094                 }
1095                 mod_timer(&pLed->BlinkTimer,
1096                           jiffies + msecs_to_jiffies(0));
1097                 break;
1098         default:
1099                 break;
1100         }
1101 }
1102
1103 static void SwLedControlMode2(struct _adapter *padapter,
1104                               enum LED_CTL_MODE LedAction)
1105 {
1106         struct led_priv  *ledpriv = &(padapter->ledpriv);
1107         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1108         struct LED_871x *pLed = &(ledpriv->SwLed0);
1109
1110         switch (LedAction) {
1111         case LED_CTL_SITE_SURVEY:
1112                  if (pmlmepriv->sitesurveyctrl.traffic_busy)
1113                         ; /* dummy branch */
1114                  else if (!pLed->bLedScanBlinkInProgress) {
1115                         if (IS_LED_WPS_BLINKING(pLed))
1116                                 return;
1117
1118                         if (pLed->bLedBlinkInProgress) {
1119                                 del_timer(&pLed->BlinkTimer);
1120                                 pLed->bLedBlinkInProgress = false;
1121                         }
1122                         pLed->bLedScanBlinkInProgress = true;
1123                         pLed->CurrLedState = LED_SCAN_BLINK;
1124                         pLed->BlinkTimes = 24;
1125                         if (pLed->bLedOn)
1126                                 pLed->BlinkingLedState = LED_OFF;
1127                         else
1128                                 pLed->BlinkingLedState = LED_ON;
1129                         mod_timer(&pLed->BlinkTimer, jiffies +
1130                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1131                  }
1132                 break;
1133
1134         case LED_CTL_TX:
1135         case LED_CTL_RX:
1136                 if (!pLed->bLedBlinkInProgress &&
1137                     check_fwstate(pmlmepriv, _FW_LINKED)) {
1138                         if (pLed->CurrLedState == LED_SCAN_BLINK ||
1139                            IS_LED_WPS_BLINKING(pLed))
1140                                 return;
1141                         pLed->bLedBlinkInProgress = true;
1142                         pLed->CurrLedState = LED_TXRX_BLINK;
1143                         pLed->BlinkTimes = 2;
1144                         if (pLed->bLedOn)
1145                                 pLed->BlinkingLedState = LED_OFF;
1146                         else
1147                                 pLed->BlinkingLedState = LED_ON;
1148                         mod_timer(&pLed->BlinkTimer, jiffies +
1149                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1150                 }
1151                 break;
1152
1153         case LED_CTL_LINK:
1154                 pLed->CurrLedState = LED_ON;
1155                 pLed->BlinkingLedState = LED_ON;
1156                 if (pLed->bLedBlinkInProgress) {
1157                         del_timer(&pLed->BlinkTimer);
1158                         pLed->bLedBlinkInProgress = false;
1159                 }
1160                 if (pLed->bLedScanBlinkInProgress) {
1161                         del_timer(&pLed->BlinkTimer);
1162                         pLed->bLedScanBlinkInProgress = false;
1163                 }
1164
1165                 mod_timer(&pLed->BlinkTimer,
1166                           jiffies + msecs_to_jiffies(0));
1167                 break;
1168
1169         case LED_CTL_START_WPS: /*wait until xinpin finish*/
1170         case LED_CTL_START_WPS_BOTTON:
1171                 if (!pLed->bLedWPSBlinkInProgress) {
1172                         if (pLed->bLedBlinkInProgress) {
1173                                 del_timer(&pLed->BlinkTimer);
1174                                 pLed->bLedBlinkInProgress = false;
1175                         }
1176                         if (pLed->bLedScanBlinkInProgress) {
1177                                 del_timer(&pLed->BlinkTimer);
1178                                 pLed->bLedScanBlinkInProgress = false;
1179                         }
1180                         pLed->bLedWPSBlinkInProgress = true;
1181                         pLed->CurrLedState = LED_ON;
1182                         pLed->BlinkingLedState = LED_ON;
1183                         mod_timer(&pLed->BlinkTimer,
1184                                   jiffies + msecs_to_jiffies(0));
1185                  }
1186                 break;
1187
1188         case LED_CTL_STOP_WPS:
1189                 pLed->bLedWPSBlinkInProgress = false;
1190                 pLed->CurrLedState = LED_ON;
1191                 pLed->BlinkingLedState = LED_ON;
1192                 mod_timer(&pLed->BlinkTimer,
1193                           jiffies + msecs_to_jiffies(0));
1194                 break;
1195
1196         case LED_CTL_STOP_WPS_FAIL:
1197                 pLed->bLedWPSBlinkInProgress = false;
1198                 pLed->CurrLedState = LED_OFF;
1199                 pLed->BlinkingLedState = LED_OFF;
1200                 mod_timer(&pLed->BlinkTimer,
1201                           jiffies + msecs_to_jiffies(0));
1202                 break;
1203
1204         case LED_CTL_START_TO_LINK:
1205         case LED_CTL_NO_LINK:
1206                 if (!IS_LED_BLINKING(pLed)) {
1207                         pLed->CurrLedState = LED_OFF;
1208                         pLed->BlinkingLedState = LED_OFF;
1209                         mod_timer(&pLed->BlinkTimer,
1210                                   jiffies + msecs_to_jiffies(0));
1211                 }
1212                 break;
1213         case LED_CTL_POWER_OFF:
1214                 pLed->CurrLedState = LED_OFF;
1215                 pLed->BlinkingLedState = LED_OFF;
1216                 if (pLed->bLedBlinkInProgress) {
1217                         del_timer(&pLed->BlinkTimer);
1218                         pLed->bLedBlinkInProgress = false;
1219                 }
1220                 if (pLed->bLedScanBlinkInProgress) {
1221                         del_timer(&pLed->BlinkTimer);
1222                         pLed->bLedScanBlinkInProgress = false;
1223                 }
1224                 if (pLed->bLedWPSBlinkInProgress) {
1225                         del_timer(&pLed->BlinkTimer);
1226                         pLed->bLedWPSBlinkInProgress = false;
1227                 }
1228                 mod_timer(&pLed->BlinkTimer,
1229                           jiffies + msecs_to_jiffies(0));
1230                 break;
1231         default:
1232                 break;
1233         }
1234 }
1235
1236 static void SwLedControlMode3(struct _adapter *padapter,
1237                               enum LED_CTL_MODE LedAction)
1238 {
1239         struct led_priv *ledpriv = &(padapter->ledpriv);
1240         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1241         struct LED_871x *pLed = &(ledpriv->SwLed0);
1242
1243         switch (LedAction) {
1244         case LED_CTL_SITE_SURVEY:
1245                 if (pmlmepriv->sitesurveyctrl.traffic_busy)
1246                         ; /* dummy branch */
1247                 else if (!pLed->bLedScanBlinkInProgress) {
1248                         if (IS_LED_WPS_BLINKING(pLed))
1249                                 return;
1250                         if (pLed->bLedBlinkInProgress) {
1251                                 del_timer(&pLed->BlinkTimer);
1252                                 pLed->bLedBlinkInProgress = false;
1253                         }
1254                         pLed->bLedScanBlinkInProgress = true;
1255                         pLed->CurrLedState = LED_SCAN_BLINK;
1256                         pLed->BlinkTimes = 24;
1257                         if (pLed->bLedOn)
1258                                 pLed->BlinkingLedState = LED_OFF;
1259                         else
1260                                 pLed->BlinkingLedState = LED_ON;
1261                         mod_timer(&pLed->BlinkTimer, jiffies +
1262                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1263                 }
1264                 break;
1265         case LED_CTL_TX:
1266         case LED_CTL_RX:
1267                 if (!pLed->bLedBlinkInProgress &&
1268                     check_fwstate(pmlmepriv, _FW_LINKED)) {
1269                         if (pLed->CurrLedState == LED_SCAN_BLINK ||
1270                             IS_LED_WPS_BLINKING(pLed))
1271                                 return;
1272                         pLed->bLedBlinkInProgress = true;
1273                         pLed->CurrLedState = LED_TXRX_BLINK;
1274                         pLed->BlinkTimes = 2;
1275                         if (pLed->bLedOn)
1276                                 pLed->BlinkingLedState = LED_OFF;
1277                         else
1278                                 pLed->BlinkingLedState = LED_ON;
1279                         mod_timer(&pLed->BlinkTimer, jiffies +
1280                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1281                 }
1282                 break;
1283         case LED_CTL_LINK:
1284                 if (IS_LED_WPS_BLINKING(pLed))
1285                         return;
1286                 pLed->CurrLedState = LED_ON;
1287                 pLed->BlinkingLedState = LED_ON;
1288                 if (pLed->bLedBlinkInProgress) {
1289                         del_timer(&pLed->BlinkTimer);
1290                         pLed->bLedBlinkInProgress = false;
1291                 }
1292                 if (pLed->bLedScanBlinkInProgress) {
1293                         del_timer(&pLed->BlinkTimer);
1294                         pLed->bLedScanBlinkInProgress = false;
1295                 }
1296                 mod_timer(&pLed->BlinkTimer,
1297                           jiffies + msecs_to_jiffies(0));
1298                 break;
1299         case LED_CTL_START_WPS: /* wait until xinpin finish */
1300         case LED_CTL_START_WPS_BOTTON:
1301                 if (!pLed->bLedWPSBlinkInProgress) {
1302                         if (pLed->bLedBlinkInProgress) {
1303                                 del_timer(&pLed->BlinkTimer);
1304                                 pLed->bLedBlinkInProgress = false;
1305                         }
1306                         if (pLed->bLedScanBlinkInProgress) {
1307                                 del_timer(&pLed->BlinkTimer);
1308                                 pLed->bLedScanBlinkInProgress = false;
1309                         }
1310                         pLed->bLedWPSBlinkInProgress = true;
1311                         pLed->CurrLedState = LED_BLINK_WPS;
1312                         if (pLed->bLedOn)
1313                                 pLed->BlinkingLedState = LED_OFF;
1314                         else
1315                                 pLed->BlinkingLedState = LED_ON;
1316                         mod_timer(&pLed->BlinkTimer, jiffies +
1317                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1318                 }
1319                 break;
1320         case LED_CTL_STOP_WPS:
1321                 if (pLed->bLedWPSBlinkInProgress) {
1322                         del_timer(&pLed->BlinkTimer);
1323                         pLed->bLedWPSBlinkInProgress = false;
1324                 } else {
1325                         pLed->bLedWPSBlinkInProgress = true;
1326                 }
1327                 pLed->CurrLedState = LED_BLINK_WPS_STOP;
1328                 if (pLed->bLedOn) {
1329                         pLed->BlinkingLedState = LED_OFF;
1330                         mod_timer(&pLed->BlinkTimer, jiffies +
1331                                   msecs_to_jiffies(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA));
1332                 } else {
1333                         pLed->BlinkingLedState = LED_ON;
1334                         mod_timer(&pLed->BlinkTimer,
1335                                   jiffies + msecs_to_jiffies(0));
1336                 }
1337                 break;
1338         case LED_CTL_STOP_WPS_FAIL:
1339                 if (pLed->bLedWPSBlinkInProgress) {
1340                         del_timer(&pLed->BlinkTimer);
1341                         pLed->bLedWPSBlinkInProgress = false;
1342                 }
1343                 pLed->CurrLedState = LED_OFF;
1344                 pLed->BlinkingLedState = LED_OFF;
1345                 mod_timer(&pLed->BlinkTimer,
1346                           jiffies + msecs_to_jiffies(0));
1347                 break;
1348         case LED_CTL_START_TO_LINK:
1349         case LED_CTL_NO_LINK:
1350                 if (!IS_LED_BLINKING(pLed)) {
1351                         pLed->CurrLedState = LED_OFF;
1352                         pLed->BlinkingLedState = LED_OFF;
1353                         mod_timer(&pLed->BlinkTimer,
1354                                   jiffies + msecs_to_jiffies(0));
1355                 }
1356                 break;
1357         case LED_CTL_POWER_OFF:
1358                 pLed->CurrLedState = LED_OFF;
1359                 pLed->BlinkingLedState = LED_OFF;
1360                 if (pLed->bLedBlinkInProgress) {
1361                         del_timer(&pLed->BlinkTimer);
1362                         pLed->bLedBlinkInProgress = false;
1363                 }
1364                 if (pLed->bLedScanBlinkInProgress) {
1365                         del_timer(&pLed->BlinkTimer);
1366                         pLed->bLedScanBlinkInProgress = false;
1367                 }
1368                 if (pLed->bLedWPSBlinkInProgress) {
1369                         del_timer(&pLed->BlinkTimer);
1370                         pLed->bLedWPSBlinkInProgress = false;
1371                 }
1372                 mod_timer(&pLed->BlinkTimer,
1373                           jiffies + msecs_to_jiffies(0));
1374                 break;
1375         default:
1376                 break;
1377         }
1378 }
1379
1380 static void SwLedControlMode4(struct _adapter *padapter,
1381                               enum LED_CTL_MODE LedAction)
1382 {
1383         struct led_priv *ledpriv = &(padapter->ledpriv);
1384         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1385         struct LED_871x *pLed = &(ledpriv->SwLed0);
1386         struct LED_871x *pLed1 = &(ledpriv->SwLed1);
1387
1388         switch (LedAction) {
1389         case LED_CTL_START_TO_LINK:
1390                 if (pLed1->bLedWPSBlinkInProgress) {
1391                         pLed1->bLedWPSBlinkInProgress = false;
1392                         del_timer(&pLed1->BlinkTimer);
1393                         pLed1->BlinkingLedState = LED_OFF;
1394                         pLed1->CurrLedState = LED_OFF;
1395                         if (pLed1->bLedOn)
1396                                 mod_timer(&pLed->BlinkTimer,
1397                                           jiffies + msecs_to_jiffies(0));
1398                 }
1399                 if (!pLed->bLedStartToLinkBlinkInProgress) {
1400                         if (pLed->CurrLedState == LED_SCAN_BLINK ||
1401                             IS_LED_WPS_BLINKING(pLed))
1402                                 return;
1403                         if (pLed->bLedBlinkInProgress) {
1404                                 del_timer(&pLed->BlinkTimer);
1405                                 pLed->bLedBlinkInProgress = false;
1406                         }
1407                         if (pLed->bLedNoLinkBlinkInProgress) {
1408                                 del_timer(&pLed->BlinkTimer);
1409                                 pLed->bLedNoLinkBlinkInProgress = false;
1410                         }
1411                         pLed->bLedStartToLinkBlinkInProgress = true;
1412                         pLed->CurrLedState = LED_BLINK_StartToBlink;
1413                         if (pLed->bLedOn) {
1414                                 pLed->BlinkingLedState = LED_OFF;
1415                                 mod_timer(&pLed->BlinkTimer, jiffies +
1416                                           msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1417                         } else {
1418                                 pLed->BlinkingLedState = LED_ON;
1419                                 mod_timer(&pLed->BlinkTimer, jiffies +
1420                                           msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1421                         }
1422                 }
1423                 break;
1424         case LED_CTL_LINK:
1425         case LED_CTL_NO_LINK:
1426                 /*LED1 settings*/
1427                 if (LedAction == LED_CTL_LINK) {
1428                         if (pLed1->bLedWPSBlinkInProgress) {
1429                                 pLed1->bLedWPSBlinkInProgress = false;
1430                                 del_timer(&pLed1->BlinkTimer);
1431                                 pLed1->BlinkingLedState = LED_OFF;
1432                                 pLed1->CurrLedState = LED_OFF;
1433                                 if (pLed1->bLedOn)
1434                                         mod_timer(&pLed->BlinkTimer,
1435                                                   jiffies + msecs_to_jiffies(0));
1436                         }
1437                 }
1438                 if (!pLed->bLedNoLinkBlinkInProgress) {
1439                         if (pLed->CurrLedState == LED_SCAN_BLINK ||
1440                             IS_LED_WPS_BLINKING(pLed))
1441                                 return;
1442                         if (pLed->bLedBlinkInProgress) {
1443                                 del_timer(&pLed->BlinkTimer);
1444                                 pLed->bLedBlinkInProgress = false;
1445                         }
1446                         pLed->bLedNoLinkBlinkInProgress = true;
1447                         pLed->CurrLedState = LED_BLINK_SLOWLY;
1448                         if (pLed->bLedOn)
1449                                 pLed->BlinkingLedState = LED_OFF;
1450                         else
1451                                 pLed->BlinkingLedState = LED_ON;
1452                         mod_timer(&pLed->BlinkTimer, jiffies +
1453                                   msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1454                 }
1455                 break;
1456         case LED_CTL_SITE_SURVEY:
1457                 if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1458                     check_fwstate(pmlmepriv, _FW_LINKED))
1459                         ;
1460                 else if (!pLed->bLedScanBlinkInProgress) {
1461                         if (IS_LED_WPS_BLINKING(pLed))
1462                                 return;
1463                         if (pLed->bLedNoLinkBlinkInProgress) {
1464                                 del_timer(&pLed->BlinkTimer);
1465                                 pLed->bLedNoLinkBlinkInProgress = false;
1466                         }
1467                         if (pLed->bLedBlinkInProgress) {
1468                                 del_timer(&pLed->BlinkTimer);
1469                                 pLed->bLedBlinkInProgress = false;
1470                         }
1471                         pLed->bLedScanBlinkInProgress = true;
1472                         pLed->CurrLedState = LED_SCAN_BLINK;
1473                         pLed->BlinkTimes = 24;
1474                         if (pLed->bLedOn)
1475                                 pLed->BlinkingLedState = LED_OFF;
1476                         else
1477                                 pLed->BlinkingLedState = LED_ON;
1478                         mod_timer(&pLed->BlinkTimer, jiffies +
1479                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1480                 }
1481                 break;
1482         case LED_CTL_TX:
1483         case LED_CTL_RX:
1484                 if (!pLed->bLedBlinkInProgress) {
1485                         if (pLed->CurrLedState == LED_SCAN_BLINK ||
1486                             IS_LED_WPS_BLINKING(pLed))
1487                                 return;
1488                         if (pLed->bLedNoLinkBlinkInProgress) {
1489                                 del_timer(&pLed->BlinkTimer);
1490                                 pLed->bLedNoLinkBlinkInProgress = false;
1491                         }
1492                         pLed->bLedBlinkInProgress = true;
1493                         pLed->CurrLedState = LED_TXRX_BLINK;
1494                         pLed->BlinkTimes = 2;
1495                         if (pLed->bLedOn)
1496                                 pLed->BlinkingLedState = LED_OFF;
1497                         else
1498                                 pLed->BlinkingLedState = LED_ON;
1499                         mod_timer(&pLed->BlinkTimer, jiffies +
1500                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1501                 }
1502                 break;
1503         case LED_CTL_START_WPS: /*wait until xinpin finish*/
1504         case LED_CTL_START_WPS_BOTTON:
1505                 if (pLed1->bLedWPSBlinkInProgress) {
1506                         pLed1->bLedWPSBlinkInProgress = false;
1507                         del_timer(&pLed1->BlinkTimer);
1508                         pLed1->BlinkingLedState = LED_OFF;
1509                         pLed1->CurrLedState = LED_OFF;
1510                         if (pLed1->bLedOn)
1511                                 mod_timer(&pLed->BlinkTimer,
1512                                           jiffies + msecs_to_jiffies(0));
1513                 }
1514                 if (!pLed->bLedWPSBlinkInProgress) {
1515                         if (pLed->bLedNoLinkBlinkInProgress) {
1516                                 del_timer(&pLed->BlinkTimer);
1517                                 pLed->bLedNoLinkBlinkInProgress = false;
1518                         }
1519                         if (pLed->bLedBlinkInProgress) {
1520                                 del_timer(&pLed->BlinkTimer);
1521                                 pLed->bLedBlinkInProgress = false;
1522                         }
1523                         if (pLed->bLedScanBlinkInProgress) {
1524                                 del_timer(&pLed->BlinkTimer);
1525                                 pLed->bLedScanBlinkInProgress = false;
1526                         }
1527                         pLed->bLedWPSBlinkInProgress = true;
1528                         pLed->CurrLedState = LED_BLINK_WPS;
1529                         if (pLed->bLedOn) {
1530                                 pLed->BlinkingLedState = LED_OFF;
1531                                 mod_timer(&pLed->BlinkTimer, jiffies +
1532                                           msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1533                         } else {
1534                                 pLed->BlinkingLedState = LED_ON;
1535                                 mod_timer(&pLed->BlinkTimer, jiffies +
1536                                           msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1537                         }
1538                 }
1539                 break;
1540         case LED_CTL_STOP_WPS:  /*WPS connect success*/
1541                 if (pLed->bLedWPSBlinkInProgress) {
1542                         del_timer(&pLed->BlinkTimer);
1543                         pLed->bLedWPSBlinkInProgress = false;
1544                 }
1545                 pLed->bLedNoLinkBlinkInProgress = true;
1546                 pLed->CurrLedState = LED_BLINK_SLOWLY;
1547                 if (pLed->bLedOn)
1548                         pLed->BlinkingLedState = LED_OFF;
1549                 else
1550                         pLed->BlinkingLedState = LED_ON;
1551                 mod_timer(&pLed->BlinkTimer, jiffies +
1552                           msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1553                 break;
1554         case LED_CTL_STOP_WPS_FAIL:     /*WPS authentication fail*/
1555                 if (pLed->bLedWPSBlinkInProgress) {
1556                         del_timer(&pLed->BlinkTimer);
1557                         pLed->bLedWPSBlinkInProgress = false;
1558                 }
1559                 pLed->bLedNoLinkBlinkInProgress = true;
1560                 pLed->CurrLedState = LED_BLINK_SLOWLY;
1561                 if (pLed->bLedOn)
1562                         pLed->BlinkingLedState = LED_OFF;
1563                 else
1564                         pLed->BlinkingLedState = LED_ON;
1565                 mod_timer(&pLed->BlinkTimer, jiffies +
1566                           msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1567                 /*LED1 settings*/
1568                 if (pLed1->bLedWPSBlinkInProgress)
1569                         del_timer(&pLed1->BlinkTimer);
1570                 else
1571                         pLed1->bLedWPSBlinkInProgress = true;
1572                 pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1573                 if (pLed1->bLedOn)
1574                         pLed1->BlinkingLedState = LED_OFF;
1575                 else
1576                         pLed1->BlinkingLedState = LED_ON;
1577                 mod_timer(&pLed->BlinkTimer, jiffies +
1578                           msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1579                 break;
1580         case LED_CTL_STOP_WPS_FAIL_OVERLAP:     /*WPS session overlap*/
1581                 if (pLed->bLedWPSBlinkInProgress) {
1582                         del_timer(&pLed->BlinkTimer);
1583                         pLed->bLedWPSBlinkInProgress = false;
1584                 }
1585                 pLed->bLedNoLinkBlinkInProgress = true;
1586                 pLed->CurrLedState = LED_BLINK_SLOWLY;
1587                 if (pLed->bLedOn)
1588                         pLed->BlinkingLedState = LED_OFF;
1589                 else
1590                         pLed->BlinkingLedState = LED_ON;
1591                 mod_timer(&pLed->BlinkTimer, jiffies +
1592                           msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1593                 /*LED1 settings*/
1594                 if (pLed1->bLedWPSBlinkInProgress)
1595                         del_timer(&pLed1->BlinkTimer);
1596                 else
1597                         pLed1->bLedWPSBlinkInProgress = true;
1598                 pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1599                 pLed1->BlinkTimes = 10;
1600                 if (pLed1->bLedOn)
1601                         pLed1->BlinkingLedState = LED_OFF;
1602                 else
1603                         pLed1->BlinkingLedState = LED_ON;
1604                 mod_timer(&pLed->BlinkTimer, jiffies +
1605                           msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1606                 break;
1607         case LED_CTL_POWER_OFF:
1608                 pLed->CurrLedState = LED_OFF;
1609                 pLed->BlinkingLedState = LED_OFF;
1610                 if (pLed->bLedNoLinkBlinkInProgress) {
1611                         del_timer(&pLed->BlinkTimer);
1612                         pLed->bLedNoLinkBlinkInProgress = false;
1613                 }
1614                 if (pLed->bLedLinkBlinkInProgress) {
1615                         del_timer(&pLed->BlinkTimer);
1616                         pLed->bLedLinkBlinkInProgress = false;
1617                 }
1618                 if (pLed->bLedBlinkInProgress) {
1619                         del_timer(&pLed->BlinkTimer);
1620                         pLed->bLedBlinkInProgress = false;
1621                 }
1622                 if (pLed->bLedWPSBlinkInProgress) {
1623                         del_timer(&pLed->BlinkTimer);
1624                         pLed->bLedWPSBlinkInProgress = false;
1625                 }
1626                 if (pLed->bLedScanBlinkInProgress) {
1627                         del_timer(&pLed->BlinkTimer);
1628                         pLed->bLedScanBlinkInProgress = false;
1629                 }
1630                 if (pLed->bLedStartToLinkBlinkInProgress) {
1631                         del_timer(&pLed->BlinkTimer);
1632                         pLed->bLedStartToLinkBlinkInProgress = false;
1633                 }
1634                 if (pLed1->bLedWPSBlinkInProgress) {
1635                         del_timer(&pLed1->BlinkTimer);
1636                         pLed1->bLedWPSBlinkInProgress = false;
1637                 }
1638                 pLed1->BlinkingLedState = LED_UNKNOWN;
1639                 SwLedOff(padapter, pLed);
1640                 SwLedOff(padapter, pLed1);
1641                 break;
1642         default:
1643                 break;
1644         }
1645 }
1646
1647 static void SwLedControlMode5(struct _adapter *padapter,
1648                               enum LED_CTL_MODE LedAction)
1649 {
1650         struct led_priv *ledpriv = &(padapter->ledpriv);
1651         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1652         struct LED_871x *pLed = &(ledpriv->SwLed0);
1653
1654         if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
1655                 pLed = &(ledpriv->SwLed1);
1656
1657         switch (LedAction) {
1658         case LED_CTL_POWER_ON:
1659         case LED_CTL_NO_LINK:
1660         case LED_CTL_LINK:      /* solid blue */
1661                 if (pLed->CurrLedState == LED_SCAN_BLINK)
1662                         return;
1663                 pLed->CurrLedState = LED_ON;
1664                 pLed->BlinkingLedState = LED_ON;
1665                 pLed->bLedBlinkInProgress = false;
1666                 mod_timer(&pLed->BlinkTimer,
1667                           jiffies + msecs_to_jiffies(0));
1668                 break;
1669         case LED_CTL_SITE_SURVEY:
1670                 if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1671                     check_fwstate(pmlmepriv, _FW_LINKED))
1672                         ; /* dummy branch */
1673                 else if (!pLed->bLedScanBlinkInProgress) {
1674                         if (pLed->bLedBlinkInProgress) {
1675                                 del_timer(&pLed->BlinkTimer);
1676                                 pLed->bLedBlinkInProgress = false;
1677                         }
1678                         pLed->bLedScanBlinkInProgress = true;
1679                         pLed->CurrLedState = LED_SCAN_BLINK;
1680                         pLed->BlinkTimes = 24;
1681                         if (pLed->bLedOn)
1682                                 pLed->BlinkingLedState = LED_OFF;
1683                         else
1684                                 pLed->BlinkingLedState = LED_ON;
1685                         mod_timer(&pLed->BlinkTimer, jiffies +
1686                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1687                 }
1688                 break;
1689         case LED_CTL_TX:
1690         case LED_CTL_RX:
1691                 if (!pLed->bLedBlinkInProgress) {
1692                         if (pLed->CurrLedState == LED_SCAN_BLINK)
1693                                 return;
1694                         pLed->bLedBlinkInProgress = true;
1695                         pLed->CurrLedState = LED_TXRX_BLINK;
1696                         pLed->BlinkTimes = 2;
1697                         if (pLed->bLedOn)
1698                                 pLed->BlinkingLedState = LED_OFF;
1699                         else
1700                                 pLed->BlinkingLedState = LED_ON;
1701                         mod_timer(&pLed->BlinkTimer, jiffies +
1702                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1703                 }
1704                 break;
1705         case LED_CTL_POWER_OFF:
1706                 pLed->CurrLedState = LED_OFF;
1707                 pLed->BlinkingLedState = LED_OFF;
1708                 if (pLed->bLedBlinkInProgress) {
1709                         del_timer(&pLed->BlinkTimer);
1710                         pLed->bLedBlinkInProgress = false;
1711                 }
1712                 SwLedOff(padapter, pLed);
1713                 break;
1714         default:
1715                 break;
1716         }
1717 }
1718
1719
1720 static void SwLedControlMode6(struct _adapter *padapter,
1721                               enum LED_CTL_MODE LedAction)
1722 {
1723         struct led_priv *ledpriv = &(padapter->ledpriv);
1724         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1725         struct LED_871x *pLed = &(ledpriv->SwLed0);
1726
1727         switch (LedAction) {
1728         case LED_CTL_POWER_ON:
1729         case LED_CTL_NO_LINK:
1730         case LED_CTL_LINK:      /*solid blue*/
1731         case LED_CTL_SITE_SURVEY:
1732                 if (IS_LED_WPS_BLINKING(pLed))
1733                                 return;
1734                 pLed->CurrLedState = LED_ON;
1735                 pLed->BlinkingLedState = LED_ON;
1736                 pLed->bLedBlinkInProgress = false;
1737                 mod_timer(&(pLed->BlinkTimer), jiffies + msecs_to_jiffies(0));
1738                 break;
1739         case LED_CTL_TX:
1740         case LED_CTL_RX:
1741                 if (!pLed->bLedBlinkInProgress &&
1742                     check_fwstate(pmlmepriv, _FW_LINKED)) {
1743                         if (IS_LED_WPS_BLINKING(pLed))
1744                                 return;
1745                         pLed->bLedBlinkInProgress = true;
1746                         pLed->CurrLedState = LED_TXRX_BLINK;
1747                         pLed->BlinkTimes = 2;
1748                         if (pLed->bLedOn)
1749                                 pLed->BlinkingLedState = LED_OFF;
1750                         else
1751                                 pLed->BlinkingLedState = LED_ON;
1752                         mod_timer(&pLed->BlinkTimer, jiffies +
1753                                   msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1754                 }
1755                 break;
1756         case LED_CTL_START_WPS: /*wait until xinpin finish*/
1757         case LED_CTL_START_WPS_BOTTON:
1758                 if (!pLed->bLedWPSBlinkInProgress) {
1759                         if (pLed->bLedBlinkInProgress) {
1760                                 del_timer(&pLed->BlinkTimer);
1761                                 pLed->bLedBlinkInProgress = false;
1762                         }
1763                         pLed->bLedWPSBlinkInProgress = true;
1764                         pLed->CurrLedState = LED_BLINK_WPS;
1765                         if (pLed->bLedOn)
1766                                 pLed->BlinkingLedState = LED_OFF;
1767                         else
1768                                 pLed->BlinkingLedState = LED_ON;
1769                         mod_timer(&pLed->BlinkTimer, jiffies +
1770                                   msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1771                 }
1772                 break;
1773         case LED_CTL_STOP_WPS_FAIL:
1774         case LED_CTL_STOP_WPS:
1775                 if (pLed->bLedWPSBlinkInProgress) {
1776                         del_timer(&pLed->BlinkTimer);
1777                         pLed->bLedWPSBlinkInProgress = false;
1778                 }
1779                 pLed->CurrLedState = LED_ON;
1780                 pLed->BlinkingLedState = LED_ON;
1781                 mod_timer(&pLed->BlinkTimer,
1782                           jiffies + msecs_to_jiffies(0));
1783                 break;
1784         case LED_CTL_POWER_OFF:
1785                 pLed->CurrLedState = LED_OFF;
1786                 pLed->BlinkingLedState = LED_OFF;
1787                 if (pLed->bLedBlinkInProgress) {
1788                         del_timer(&pLed->BlinkTimer);
1789                         pLed->bLedBlinkInProgress = false;
1790                 }
1791                 if (pLed->bLedWPSBlinkInProgress) {
1792                         del_timer(&pLed->BlinkTimer);
1793                         pLed->bLedWPSBlinkInProgress = false;
1794                 }
1795                 SwLedOff(padapter, pLed);
1796                 break;
1797         default:
1798                 break;
1799         }
1800 }
1801
1802 /*      Description:
1803  *              Dispatch LED action according to pHalData->LedStrategy.
1804  */
1805 void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction)
1806 {
1807         struct led_priv *ledpriv = &(padapter->ledpriv);
1808
1809         if (!ledpriv->bRegUseLed)
1810                 return;
1811         switch (ledpriv->LedStrategy) {
1812         case SW_LED_MODE0:
1813                 break;
1814         case SW_LED_MODE1:
1815                 SwLedControlMode1(padapter, LedAction);
1816                 break;
1817         case SW_LED_MODE2:
1818                 SwLedControlMode2(padapter, LedAction);
1819                 break;
1820         case SW_LED_MODE3:
1821                 SwLedControlMode3(padapter, LedAction);
1822                 break;
1823         case SW_LED_MODE4:
1824                 SwLedControlMode4(padapter, LedAction);
1825                 break;
1826         case SW_LED_MODE5:
1827                 SwLedControlMode5(padapter, LedAction);
1828                 break;
1829         case SW_LED_MODE6:
1830                 SwLedControlMode6(padapter, LedAction);
1831                 break;
1832         default:
1833                 break;
1834         }
1835 }