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