drivers/staging/rtl8712/rtl8712_led.c

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