kernel/drivers/staging/rtl8712/rtl8712_led.c

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