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