drivers/staging/rtl8712/rtl8712_led.c

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