drivers/net/wireless/rtl8192cu/hal/rtl8192c/usb/rtl8192cu_led.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20
  21 #include "drv_types.h"
  22 #include "rtl8192c_hal.h"
  23
  24 //================================================================================
  25 //      Constant.
  26 //================================================================================
  27
  28 //
  29 // Default LED behavior.
  30 //
  31 #define LED_BLINK_NORMAL_INTERVAL       100
  32 #define LED_BLINK_SLOWLY_INTERVAL       200
  33 #define LED_BLINK_LONG_INTERVAL 400
  34
  35 #define LED_BLINK_NO_LINK_INTERVAL_ALPHA                1000
  36 #define LED_BLINK_LINK_INTERVAL_ALPHA                   500             //500
  37 #define LED_BLINK_SCAN_INTERVAL_ALPHA           180     //150
  38 #define LED_BLINK_FASTER_INTERVAL_ALPHA         50
  39 #define LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA     5000
  40
  41 //================================================================================
  42 // LED object.
  43 //================================================================================
  44
  45
  46 //================================================================================
  47 //      Prototype of protected function.
  48 //================================================================================
  49
  50
  51 static void
  52 BlinkTimerCallback(
  53         unsigned long data
  54         );
  55
  56 static void
  57 BlinkWorkItemCallback(
  58         struct work_struct *work
  59         );
  60
  61 //
  62 //      Description:
  63 //              Reset blinking status of LED_871x object.
  64 //
  65 static void
  66 ResetLedStatus(PLED_871x        pLed) {
  67         pLed->CurrLedState = RTW_LED_OFF; // Current LED state.
  68         pLed->bLedOn = _FALSE; // true if LED is ON, false if LED is OFF.
  69
  70         pLed->bLedBlinkInProgress = _FALSE; // true if it is blinking, false o.w..
  71         pLed->bLedNoLinkBlinkInProgress = _FALSE;
  72         pLed->bLedLinkBlinkInProgress = _FALSE;
  73         pLed->bLedStartToLinkBlinkInProgress = _FALSE;
  74         pLed->bLedScanBlinkInProgress = _FALSE;
  75         pLed->bLedWPSBlinkInProgress = _FALSE;
  76         pLed->BlinkTimes = 0; // Number of times to toggle led state for blinking.
  77         pLed->BlinkingLedState = LED_UNKNOWN; // Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are.
  78 }
  79
  80 //================================================================================
  81 // LED_819xUsb routines.
  82 //================================================================================
  83
  84 //
  85 //      Description:
  86 //              Initialize an LED_871x object.
  87 //
  88 static void
  89 InitLed871x(
  90         _adapter                        *padapter,
  91         PLED_871x               pLed,
  92         LED_PIN_871x    LedPin
  93         )
  94 {
  95         pLed->padapter = padapter;
  96         pLed->LedPin = LedPin;
  97
  98         ResetLedStatus(pLed);
  99
 100         _init_timer(&(pLed->BlinkTimer), padapter->pnetdev, BlinkTimerCallback, pLed);
 101         _init_workitem(&(pLed->BlinkWorkItem), BlinkWorkItemCallback, pLed);
 102 }
 103
 104
 105 //
 106 //      Description:
 107 //              DeInitialize an LED_871x object.
 108 //
 109 static void
 110 DeInitLed871x(
 111         PLED_871x                       pLed
 112         )
 113 {
 114         //call _cancel_workitem_sync(&(pLed->BlinkWorkItem))
 115     //before _cancel_timer_ex(&(pLed->BlinkTimer)) to
 116     //avoid led timer restarting when driver is removed
 117
 118         _cancel_workitem_sync(&(pLed->BlinkWorkItem));
 119
 120         _cancel_timer_ex(&(pLed->BlinkTimer));
 121
 122         // We should reset bLedBlinkInProgress if we cancel the LedControlTimer, 2005.03.10, by rcnjko.
 123         ResetLedStatus(pLed);
 124 }
 125
 126 //
 127 //      Description:
 128 //              Turn on LED according to LedPin specified.
 129 //
 130 static void
 131 SwLedOn(
 132         _adapter                        *padapter,
 133         PLED_871x               pLed
 134 )
 135 {
 136         u8      LedCfg;
 137         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 138
 139         if( (padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE))
 140         {
 141                 return;
 142         }
 143
 144         if(     (BOARD_MINICARD == pHalData->BoardType )||
 145                 (BOARD_USB_SOLO == pHalData->BoardType)||
 146                 (BOARD_USB_COMBO == pHalData->BoardType))
 147         {
 148                 LedCfg = rtw_read8(padapter, REG_LEDCFG2);
 149                 switch(pLed->LedPin)
 150                 {
 151                         case LED_PIN_GPIO0:
 152                                 break;
 153
 154                         case LED_PIN_LED0:
 155                                 rtw_write8(padapter, REG_LEDCFG2, (LedCfg&0xf0)|BIT5|BIT6); // SW control led0 on.
 156                                 break;
 157
 158                         case LED_PIN_LED1:
 159                                 rtw_write8(padapter, REG_LEDCFG2, (LedCfg&0x0f)|BIT5); // SW control led1 on.
 160                                 break;
 161
 162                         default:
 163                                 break;
 164
 165                 }
 166         }
 167         else
 168         {
 169                 switch(pLed->LedPin)
 170                 {
 171                         case LED_PIN_GPIO0:
 172                                 break;
 173
 174                         case LED_PIN_LED0:
 175 #ifdef CONFIG_SW_ANTENNA_DIVERSITY
 176                                 if(pHalData->AntDivCfg)
 177                                 {
 178                                         LedCfg = rtw_read8(padapter, REG_LEDCFG2);
 179                                         rtw_write8(padapter, REG_LEDCFG2, (LedCfg&0xe0)|BIT7|BIT6|BIT5); // SW control led0 on.
 180                                         //RT_TRACE(COMP_LED, DBG_LOUD, ("SwLedOn LED0 0x%x\n", PlatformEFIORead4Byte(Adapter, REG_LEDCFG2)));
 181                                 }
 182                                 else
 183 #endif
 184                                 {
 185                                         LedCfg = rtw_read8(padapter, REG_LEDCFG0);
 186                                         rtw_write8(padapter,REG_LEDCFG0, LedCfg&0x70); // SW control led0 on.
 187                                         //RT_TRACE(COMP_LED, DBG_LOUD, ("SwLedOn LED0 0x%lx\n", PlatformEFIORead4Byte(Adapter, REG_LEDCFG0)));
 188                                 }
 189                                 break;
 190
 191                         case LED_PIN_LED1:
 192                                 LedCfg = rtw_read8(padapter,(REG_LEDCFG1));
 193                                 rtw_write8(padapter,(REG_LEDCFG1), LedCfg&0x70); // SW control led1 on.
 194                                 //RT_TRACE(COMP_LED, DBG_LOUD, ("SwLedOn LED1 0x%lx\n", PlatformEFIORead4Byte(Adapter, REG_LEDCFG0)));
 195
 196                                 break;
 197
 198                         default:
 199                                 break;
 200                 }
 201         }
 202         pLed->bLedOn = _TRUE;
 203
 204 }
 205
 206
 207 //
 208 //      Description:
 209 //              Turn off LED according to LedPin specified.
 210 //
 211 static void
 212 SwLedOff(
 213         _adapter                        *padapter,
 214         PLED_871x               pLed
 215 )
 216 {
 217         u8      LedCfg;
 218         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 219
 220         if((padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE))
 221         {
 222                 goto exit;
 223         }
 224
 225         if(     (BOARD_MINICARD == pHalData->BoardType )||
 226                 (BOARD_USB_SOLO == pHalData->BoardType)||
 227                 (BOARD_USB_COMBO == pHalData->BoardType))
 228         {
 229                 LedCfg = rtw_read8(padapter, REG_LEDCFG2);//0x4E
 230
 231                 switch(pLed->LedPin)
 232                 {
 233
 234                         case LED_PIN_GPIO0:
 235                                 break;
 236
 237                         case LED_PIN_LED0:
 238                                 if(BOARD_USB_COMBO == pHalData->BoardType)
 239                                 {
 240                                         LedCfg &= 0x90; // Set to software control.
 241                                         rtw_write8(padapter, REG_LEDCFG2, (LedCfg|BIT3));
 242                                         LedCfg = rtw_read8(padapter, REG_MAC_PINMUX_CFG);
 243                                         LedCfg &= 0xFE;
 244                                         rtw_write8(padapter, REG_MAC_PINMUX_CFG, LedCfg);
 245                                 }
 246                                 else
 247                                 {
 248                                         LedCfg &= 0xf0; // Set to software control.
 249                                         if(pHalData->bLedOpenDrain == _TRUE) // Open-drain arrangement for controlling the LED
 250                                                 rtw_write8(padapter, REG_LEDCFG2, (LedCfg|BIT1|BIT5|BIT6));
 251                                         else
 252                                                 rtw_write8(padapter, REG_LEDCFG2, (LedCfg|BIT3|BIT5|BIT6));
 253                                 }
 254                                 break;
 255
 256                         case LED_PIN_LED1:
 257                                 LedCfg &= 0x0f; // Set to software control.
 258                                 rtw_write8(padapter, REG_LEDCFG2, (LedCfg|BIT3));
 259                                 break;
 260
 261                         default:
 262                                 break;
 263                 }
 264         }
 265         else
 266         {
 267                 switch(pLed->LedPin)
 268                 {
 269                         case LED_PIN_GPIO0:
 270                                 break;
 271
 272                         case LED_PIN_LED0:
 273 #ifdef CONFIG_SW_ANTENNA_DIVERSITY
 274                                 if(pHalData->AntDivCfg)
 275                                 {
 276                                         LedCfg = rtw_read8(padapter, REG_LEDCFG2);
 277                                         LedCfg &= 0xe0; // Set to software control.
 278                                         rtw_write8(padapter, REG_LEDCFG2, (LedCfg|BIT3|BIT7|BIT6|BIT5));
 279                                         //RT_TRACE(COMP_LED, DBG_LOUD, ("SwLedOff LED0 0x%x\n", PlatformEFIORead4Byte(Adapter, REG_LEDCFG2)));
 280                                 }
 281                                 else
 282 #endif
 283                                 {
 284                                         LedCfg = rtw_read8(padapter, REG_LEDCFG0);
 285                                         LedCfg &= 0x70; // Set to software control.
 286                                         rtw_write8(padapter, REG_LEDCFG0, (LedCfg|BIT3));
 287                                         //RT_TRACE(COMP_LED, DBG_LOUD, ("SwLedOff LED0 0x%lx\n", PlatformEFIORead4Byte(Adapter, REG_LEDCFG0)));
 288                                 }
 289                                 break;
 290
 291                         case LED_PIN_LED1:
 292                                 LedCfg = rtw_read8(padapter, (REG_LEDCFG1));
 293                                 LedCfg &= 0x70; // Set to software control.
 294                                 rtw_write8(padapter,  (REG_LEDCFG1), (LedCfg|BIT3));
 295                                 //RT_TRACE(COMP_LED, DBG_LOUD, ("SwLedOff LED1 0x%lx\n", PlatformEFIORead4Byte(Adapter, REG_LEDCFG0)));
 296                                 break;
 297
 298                         default:
 299                                 break;
 300                 }
 301         }
 302
 303 exit:
 304         pLed->bLedOn = _FALSE;
 305
 306 }
 307
 308 //================================================================================
 309 // Interface to manipulate LED objects.
 310 //================================================================================
 311
 312
 313 //
 314 //      Description:
 315 //              Implementation of LED blinking behavior.
 316 //              It toggle off LED and schedule corresponding timer if necessary.
 317 //
 318 static void
 319 SwLedBlink(
 320         PLED_871x                       pLed
 321         )
 322 {
 323         _adapter                        *padapter = pLed->padapter;
 324         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 325         u8                              bStopBlinking = _FALSE;
 326
 327         // Change LED according to BlinkingLedState specified.
 328         if( pLed->BlinkingLedState == RTW_LED_ON )
 329         {
 330                 SwLedOn(padapter, pLed);
 331                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 332         }
 333         else
 334         {
 335                 SwLedOff(padapter, pLed);
 336                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,( "Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 337         }
 338
 339         // Determine if we shall change LED state again.
 340         pLed->BlinkTimes--;
 341         switch(pLed->CurrLedState)
 342         {
 343
 344         case LED_BLINK_NORMAL:
 345                 if(pLed->BlinkTimes == 0)
 346                 {
 347                         bStopBlinking = _TRUE;
 348                 }
 349                 break;
 350
 351         case LED_BLINK_StartToBlink:
 352                 if( check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE) )
 353                 {
 354                         bStopBlinking = _TRUE;
 355                 }
 356                 if( check_fwstate(pmlmepriv, _FW_LINKED) &&
 357                         (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) )
 358                 {
 359                         bStopBlinking = _TRUE;
 360                 }
 361                 else if(pLed->BlinkTimes == 0)
 362                 {
 363                         bStopBlinking = _TRUE;
 364                 }
 365                 break;
 366
 367         case LED_BLINK_WPS:
 368                 if( pLed->BlinkTimes == 0 )
 369                 {
 370                         bStopBlinking = _TRUE;
 371                 }
 372                 break;
 373
 374
 375         default:
 376                 bStopBlinking = _TRUE;
 377                 break;
 378
 379         }
 380
 381         if(bStopBlinking)
 382         {
 383                 //if( padapter->pwrctrlpriv.cpwm >= PS_STATE_S2)
 384                 if(0)
 385                 {
 386                         SwLedOff(padapter, pLed);
 387                 }
 388                 else if( (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE) && (pLed->bLedOn == _FALSE))
 389                 {
 390                         SwLedOn(padapter, pLed);
 391                 }
 392                 else if( (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE) &&  pLed->bLedOn == _TRUE)
 393                 {
 394                         SwLedOff(padapter, pLed);
 395                 }
 396
 397                 pLed->BlinkTimes = 0;
 398                 pLed->bLedBlinkInProgress = _FALSE;
 399         }
 400         else
 401         {
 402                 // Assign LED state to toggle.
 403                 if( pLed->BlinkingLedState == RTW_LED_ON )
 404                         pLed->BlinkingLedState = RTW_LED_OFF;
 405                 else
 406                         pLed->BlinkingLedState = RTW_LED_ON;
 407
 408                 // Schedule a timer to toggle LED state.
 409                 switch( pLed->CurrLedState )
 410                 {
 411                 case LED_BLINK_NORMAL:
 412                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
 413                         break;
 414
 415                 case LED_BLINK_SLOWLY:
 416                 case LED_BLINK_StartToBlink:
 417                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
 418                         break;
 419
 420                 case LED_BLINK_WPS:
 421                         {
 422                                 if( pLed->BlinkingLedState == RTW_LED_ON )
 423                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
 424                                 else
 425                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
 426                         }
 427                         break;
 428
 429                 default:
 430                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
 431                         break;
 432                 }
 433         }
 434 }
 435
 436
 437 static void
 438 SwLedBlink1(
 439         PLED_871x                       pLed
 440         )
 441 {
 442         _adapter                                *padapter = pLed->padapter;
 443         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(padapter);
 444         struct led_priv         *ledpriv = &(padapter->ledpriv);
 445         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);
 446         PLED_871x                       pLed1 = &(ledpriv->SwLed1);
 447         u8                                      bStopBlinking = _FALSE;
 448
 449         if(pHalData->EEPROMCustomerID == RT_CID_819x_CAMEO)
 450                 pLed = &(ledpriv->SwLed1);
 451
 452         // Change LED according to BlinkingLedState specified.
 453         if( pLed->BlinkingLedState == RTW_LED_ON )
 454         {
 455                 SwLedOn(padapter, pLed);
 456                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,( "Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 457         }
 458         else
 459         {
 460                 SwLedOff(padapter, pLed);
 461                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 462         }
 463
 464
 465         if(pHalData->EEPROMCustomerID == RT_CID_DEFAULT)
 466         {
 467                 if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 468                 {
 469                         if(!pLed1->bSWLedCtrl)
 470                         {
 471                                 SwLedOn(padapter, pLed1);
 472                                 pLed1->bSWLedCtrl = _TRUE;
 473                         }
 474                         else if(!pLed1->bLedOn)
 475                                 SwLedOn(padapter, pLed1);
 476                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (): turn on pLed1\n"));
 477                 }
 478                 else
 479                 {
 480                         if(!pLed1->bSWLedCtrl)
 481                         {
 482                                 SwLedOff(padapter, pLed1);
 483                                 pLed1->bSWLedCtrl = _TRUE;
 484                         }
 485                         else if(pLed1->bLedOn)
 486                                 SwLedOff(padapter, pLed1);
 487                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (): turn off pLed1\n"));
 488                 }
 489         }
 490
 491
 492         if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 493         {
 494                 SwLedOff(padapter, pLed);
 495                 ResetLedStatus(pLed);
 496                 return;
 497         }
 498
 499
 500         switch(pLed->CurrLedState)
 501         {
 502                 case LED_BLINK_SLOWLY:
 503                         if( pLed->bLedOn )
 504                                 pLed->BlinkingLedState = RTW_LED_OFF;
 505                         else
 506                                 pLed->BlinkingLedState = RTW_LED_ON;
 507                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
 508                         break;
 509
 510                 case LED_BLINK_NORMAL:
 511                         if( pLed->bLedOn )
 512                                 pLed->BlinkingLedState = RTW_LED_OFF;
 513                         else
 514                                 pLed->BlinkingLedState = RTW_LED_ON;
 515                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 516                         break;
 517
 518                 case LED_SCAN_BLINK:
 519                         pLed->BlinkTimes--;
 520                         if( pLed->BlinkTimes == 0 )
 521                         {
 522                                 bStopBlinking = _TRUE;
 523                         }
 524
 525                         if(bStopBlinking)
 526                         {
 527                                 if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 528                                 {
 529                                         pLed->bLedLinkBlinkInProgress = _TRUE;
 530                                         pLed->CurrLedState = LED_BLINK_NORMAL;
 531                                         if( pLed->bLedOn )
 532                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 533                                         else
 534                                                 pLed->BlinkingLedState = RTW_LED_ON;
 535                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 536                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 537
 538                                 }
 539                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 540                                 {
 541                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
 542                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 543                                         if( pLed->bLedOn )
 544                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 545                                         else
 546                                                 pLed->BlinkingLedState = RTW_LED_ON;
 547                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
 548                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 549                                 }
 550                                 pLed->bLedScanBlinkInProgress = _FALSE;
 551                         }
 552                         else
 553                         {
 554                                 if( pLed->bLedOn )
 555                                         pLed->BlinkingLedState = RTW_LED_OFF;
 556                                 else
 557                                         pLed->BlinkingLedState = RTW_LED_ON;
 558                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 559                         }
 560                         break;
 561
 562                 case LED_TXRX_BLINK:
 563                         pLed->BlinkTimes--;
 564                         if( pLed->BlinkTimes == 0 )
 565                         {
 566                                 bStopBlinking = _TRUE;
 567                         }
 568                         if(bStopBlinking)
 569                         {
 570                                 if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 571                                 {
 572                                         pLed->bLedLinkBlinkInProgress = _TRUE;
 573                                         pLed->CurrLedState = LED_BLINK_NORMAL;
 574                                         if( pLed->bLedOn )
 575                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 576                                         else
 577                                                 pLed->BlinkingLedState = RTW_LED_ON;
 578                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 579                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 580                                 }
 581                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 582                                 {
 583                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
 584                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 585                                         if( pLed->bLedOn )
 586                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 587                                         else
 588                                                 pLed->BlinkingLedState = RTW_LED_ON;
 589                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
 590                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 591                                 }
 592                                 pLed->BlinkTimes = 0;
 593                                 pLed->bLedBlinkInProgress = _FALSE;
 594                         }
 595                         else
 596                         {
 597                                 if( pLed->bLedOn )
 598                                         pLed->BlinkingLedState = RTW_LED_OFF;
 599                                 else
 600                                         pLed->BlinkingLedState = RTW_LED_ON;
 601                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 602                         }
 603                         break;
 604
 605                 case LED_BLINK_WPS:
 606                         if( pLed->bLedOn )
 607                                 pLed->BlinkingLedState = RTW_LED_OFF;
 608                         else
 609                                 pLed->BlinkingLedState = RTW_LED_ON;
 610                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 611                         break;
 612
 613                 case LED_BLINK_WPS_STOP:        //WPS success
 614                         if(pLed->BlinkingLedState == RTW_LED_ON)
 615                                 bStopBlinking = _FALSE;
 616                         else
 617                                 bStopBlinking = _TRUE;
 618
 619                         if(bStopBlinking)
 620                         {
 621                                 pLed->bLedLinkBlinkInProgress = _TRUE;
 622                                 pLed->CurrLedState = LED_BLINK_NORMAL;
 623                                 if( pLed->bLedOn )
 624                                         pLed->BlinkingLedState = RTW_LED_OFF;
 625                                 else
 626                                         pLed->BlinkingLedState = RTW_LED_ON;
 627                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 628                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 629
 630                                 pLed->bLedWPSBlinkInProgress = _FALSE;
 631                         }
 632                         else
 633                         {
 634                                 pLed->BlinkingLedState = RTW_LED_OFF;
 635                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
 636                         }
 637                         break;
 638
 639                 default:
 640                         break;
 641         }
 642
 643 }
 644
 645 static void
 646 SwLedBlink2(
 647         PLED_871x                       pLed
 648         )
 649 {
 650         _adapter                                *padapter = pLed->padapter;
 651         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);
 652         u8                                      bStopBlinking = _FALSE;
 653
 654         // Change LED according to BlinkingLedState specified.
 655         if( pLed->BlinkingLedState == RTW_LED_ON)
 656         {
 657                 SwLedOn(padapter, pLed);
 658                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 659         }
 660         else
 661         {
 662                 SwLedOff(padapter, pLed);
 663                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 664         }
 665
 666         switch(pLed->CurrLedState)
 667         {
 668                 case LED_SCAN_BLINK:
 669                         pLed->BlinkTimes--;
 670                         if( pLed->BlinkTimes == 0 )
 671                         {
 672                                 bStopBlinking = _TRUE;
 673                         }
 674
 675                         if(bStopBlinking)
 676                         {
 677                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 678                                 {
 679                                         SwLedOff(padapter, pLed);
 680                                 }
 681                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 682                                 {
 683                                         pLed->CurrLedState = RTW_LED_ON;
 684                                         pLed->BlinkingLedState = RTW_LED_ON;
 685                                         SwLedOn(padapter, pLed);
 686                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop scan blink CurrLedState %d\n", pLed->CurrLedState));
 687
 688                                 }
 689                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 690                                 {
 691                                         pLed->CurrLedState = RTW_LED_OFF;
 692                                         pLed->BlinkingLedState = RTW_LED_OFF;
 693                                         SwLedOff(padapter, pLed);
 694                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop scan blink CurrLedState %d\n", pLed->CurrLedState));
 695                                 }
 696                                 pLed->bLedScanBlinkInProgress = _FALSE;
 697                         }
 698                         else
 699                         {
 700                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 701                                 {
 702                                         SwLedOff(padapter, pLed);
 703                                 }
 704                                 else
 705                                 {
 706                                          if( pLed->bLedOn )
 707                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 708                                         else
 709                                                 pLed->BlinkingLedState = RTW_LED_ON;
 710                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 711                                 }
 712                         }
 713                         break;
 714
 715                 case LED_TXRX_BLINK:
 716                         pLed->BlinkTimes--;
 717                         if( pLed->BlinkTimes == 0 )
 718                         {
 719                                 bStopBlinking = _TRUE;
 720                         }
 721                         if(bStopBlinking)
 722                         {
 723                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 724                                 {
 725                                         SwLedOff(padapter, pLed);
 726                                 }
 727                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 728                                 {
 729                                         pLed->CurrLedState = RTW_LED_ON;
 730                                         pLed->BlinkingLedState = RTW_LED_ON;
 731                                         SwLedOn(padapter, pLed);
 732                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop CurrLedState %d\n", pLed->CurrLedState));
 733
 734                                 }
 735                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 736                                 {
 737                                         pLed->CurrLedState = RTW_LED_OFF;
 738                                         pLed->BlinkingLedState = RTW_LED_OFF;
 739                                         SwLedOff(padapter, pLed);
 740                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop CurrLedState %d\n", pLed->CurrLedState));
 741                                 }
 742                                 pLed->bLedBlinkInProgress = _FALSE;
 743                         }
 744                         else
 745                         {
 746                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 747                                 {
 748                                         SwLedOff(padapter, pLed);
 749                                 }
 750                                 else
 751                                 {
 752                                          if( pLed->bLedOn )
 753                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 754                                         else
 755                                                 pLed->BlinkingLedState = RTW_LED_ON;
 756                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 757                                 }
 758                         }
 759                         break;
 760
 761                 default:
 762                         break;
 763         }
 764
 765 }
 766
 767 static void
 768 SwLedBlink3(
 769         PLED_871x                       pLed
 770         )
 771 {
 772         _adapter                        *padapter = pLed->padapter;
 773         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 774         u8                              bStopBlinking = _FALSE;
 775
 776         // Change LED according to BlinkingLedState specified.
 777         if( pLed->BlinkingLedState == RTW_LED_ON )
 778         {
 779                 SwLedOn(padapter, pLed);
 780                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 781         }
 782         else
 783         {
 784                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)
 785                         SwLedOff(padapter, pLed);
 786                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 787         }
 788
 789         switch(pLed->CurrLedState)
 790         {
 791                 case LED_SCAN_BLINK:
 792                         pLed->BlinkTimes--;
 793                         if( pLed->BlinkTimes == 0 )
 794                         {
 795                                 bStopBlinking = _TRUE;
 796                         }
 797
 798                         if(bStopBlinking)
 799                         {
 800                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 801                                 {
 802                                         SwLedOff(padapter, pLed);
 803                                 }
 804                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 805                                 {
 806                                         pLed->CurrLedState = RTW_LED_ON;
 807                                         pLed->BlinkingLedState = RTW_LED_ON;
 808                                         if( !pLed->bLedOn )
 809                                                 SwLedOn(padapter, pLed);
 810
 811                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 812                                 }
 813                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 814                                 {
 815                                         pLed->CurrLedState = RTW_LED_OFF;
 816                                         pLed->BlinkingLedState = RTW_LED_OFF;
 817                                         if( pLed->bLedOn )
 818                                                 SwLedOff(padapter, pLed);
 819
 820                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 821                                 }
 822                                 pLed->bLedScanBlinkInProgress = _FALSE;
 823                         }
 824                         else
 825                         {
 826                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 827                                 {
 828                                         SwLedOff(padapter, pLed);
 829                                 }
 830                                 else
 831                                 {
 832                                         if( pLed->bLedOn )
 833                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 834                                         else
 835                                                 pLed->BlinkingLedState = RTW_LED_ON;
 836                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 837                                 }
 838                         }
 839                         break;
 840
 841                 case LED_TXRX_BLINK:
 842                         pLed->BlinkTimes--;
 843                         if( pLed->BlinkTimes == 0 )
 844                         {
 845                                 bStopBlinking = _TRUE;
 846                         }
 847                         if(bStopBlinking)
 848                         {
 849                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 850                                 {
 851                                         SwLedOff(padapter, pLed);
 852                                 }
 853                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 854                                 {
 855                                         pLed->CurrLedState = RTW_LED_ON;
 856                                         pLed->BlinkingLedState = RTW_LED_ON;
 857
 858                                         if( !pLed->bLedOn )
 859                                                 SwLedOn(padapter, pLed);
 860
 861                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 862                                 }
 863                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 864                                 {
 865                                         pLed->CurrLedState = RTW_LED_OFF;
 866                                         pLed->BlinkingLedState = RTW_LED_OFF;
 867
 868                                         if( pLed->bLedOn )
 869                                                 SwLedOff(padapter, pLed);
 870
 871
 872                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 873                                 }
 874                                 pLed->bLedBlinkInProgress = _FALSE;
 875                         }
 876                         else
 877                         {
 878                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 879                                 {
 880                                         SwLedOff(padapter, pLed);
 881                                 }
 882                                 else
 883                                 {
 884                                         if( pLed->bLedOn )
 885                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 886                                         else
 887                                                 pLed->BlinkingLedState = RTW_LED_ON;
 888                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 889                                 }
 890                         }
 891                         break;
 892
 893                 case LED_BLINK_WPS:
 894                         if( pLed->bLedOn )
 895                                 pLed->BlinkingLedState = RTW_LED_OFF;
 896                         else
 897                                 pLed->BlinkingLedState = RTW_LED_ON;
 898                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 899                         break;
 900
 901                 case LED_BLINK_WPS_STOP:        //WPS success
 902                         if(pLed->BlinkingLedState == RTW_LED_ON)
 903                         {
 904                                 pLed->BlinkingLedState = RTW_LED_OFF;
 905                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
 906                                 bStopBlinking = _FALSE;
 907                         }
 908                         else
 909                         {
 910                                 bStopBlinking = _TRUE;
 911                         }
 912
 913                         if(bStopBlinking)
 914                         {
 915                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on )
 916                                 {
 917                                         SwLedOff(padapter, pLed);
 918                                 }
 919                                 else
 920                                 {
 921                                         pLed->CurrLedState = RTW_LED_ON;
 922                                         pLed->BlinkingLedState = RTW_LED_ON;
 923                                         SwLedOn(padapter, pLed);
 924                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 925                                 }
 926                                 pLed->bLedWPSBlinkInProgress = _FALSE;
 927                         }
 928                         break;
 929
 930
 931                 default:
 932                         break;
 933         }
 934
 935 }
 936
 937
 938 static void
 939 SwLedBlink4(
 940         PLED_871x                       pLed
 941         )
 942 {
 943         _adapter                        *padapter = pLed->padapter;
 944         struct led_priv *ledpriv = &(padapter->ledpriv);
 945         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 946         PLED_871x               pLed1 = &(ledpriv->SwLed1);
 947         u8                              bStopBlinking = _FALSE;
 948
 949         // Change LED according to BlinkingLedState specified.
 950         if( pLed->BlinkingLedState == RTW_LED_ON )
 951         {
 952                 SwLedOn(padapter, pLed);
 953                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 954         }
 955         else
 956         {
 957                 SwLedOff(padapter, pLed);
 958                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 959         }
 960
 961         if(!pLed1->bLedWPSBlinkInProgress && pLed1->BlinkingLedState == LED_UNKNOWN)
 962         {
 963                 pLed1->BlinkingLedState = RTW_LED_OFF;
 964                 pLed1->CurrLedState = RTW_LED_OFF;
 965                 SwLedOff(padapter, pLed1);
 966         }
 967
 968         switch(pLed->CurrLedState)
 969         {
 970                 case LED_BLINK_SLOWLY:
 971                         if( pLed->bLedOn )
 972                                 pLed->BlinkingLedState = RTW_LED_OFF;
 973                         else
 974                                 pLed->BlinkingLedState = RTW_LED_ON;
 975                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
 976                         break;
 977
 978                 case LED_BLINK_StartToBlink:
 979                         if( pLed->bLedOn )
 980                         {
 981                                 pLed->BlinkingLedState = RTW_LED_OFF;
 982                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
 983                         }
 984                         else
 985                         {
 986                                 pLed->BlinkingLedState = RTW_LED_ON;
 987                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
 988                         }
 989                         break;
 990
 991                 case LED_SCAN_BLINK:
 992                         pLed->BlinkTimes--;
 993                         if( pLed->BlinkTimes == 0 )
 994                         {
 995                                 bStopBlinking = _FALSE;
 996                         }
 997
 998                         if(bStopBlinking)
 999                         {
1000                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS)
1001                                 {
1002                                         SwLedOff(padapter, pLed);
1003                                 }
1004                                 else
1005                                 {
1006                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
1007                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
1008                                         if( pLed->bLedOn )
1009                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1010                                         else
1011                                                 pLed->BlinkingLedState = RTW_LED_ON;
1012                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1013                                 }
1014                                 pLed->bLedScanBlinkInProgress = _FALSE;
1015                         }
1016                         else
1017                         {
1018                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS)
1019                                 {
1020                                         SwLedOff(padapter, pLed);
1021                                 }
1022                                 else
1023                                 {
1024                                          if( pLed->bLedOn )
1025                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1026                                         else
1027                                                 pLed->BlinkingLedState = RTW_LED_ON;
1028                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1029                                 }
1030                         }
1031                         break;
1032
1033                 case LED_TXRX_BLINK:
1034                         pLed->BlinkTimes--;
1035                         if( pLed->BlinkTimes == 0 )
1036                         {
1037                                 bStopBlinking = _TRUE;
1038                         }
1039                         if(bStopBlinking)
1040                         {
1041                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS)
1042                                 {
1043                                         SwLedOff(padapter, pLed);
1044                                 }
1045                                 else
1046                                 {
1047                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
1048                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
1049                                         if( pLed->bLedOn )
1050                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1051                                         else
1052                                                 pLed->BlinkingLedState = RTW_LED_ON;
1053                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1054                                 }
1055                                 pLed->bLedBlinkInProgress = _FALSE;
1056                         }
1057                         else
1058                         {
1059                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS)
1060                                 {
1061                                         SwLedOff(padapter, pLed);
1062                                 }
1063                                 else
1064                                 {
1065                                          if( pLed->bLedOn )
1066                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1067                                         else
1068                                                 pLed->BlinkingLedState = RTW_LED_ON;
1069                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1070                                 }
1071                         }
1072                         break;
1073
1074                 case LED_BLINK_WPS:
1075                         if( pLed->bLedOn )
1076                         {
1077                                 pLed->BlinkingLedState = RTW_LED_OFF;
1078                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1079                         }
1080                         else
1081                         {
1082                                 pLed->BlinkingLedState = RTW_LED_ON;
1083                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1084                         }
1085                         break;
1086
1087                 case LED_BLINK_WPS_STOP:        //WPS authentication fail
1088                         if( pLed->bLedOn )
1089                                 pLed->BlinkingLedState = RTW_LED_OFF;
1090                         else
1091                                 pLed->BlinkingLedState = RTW_LED_ON;
1092
1093                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1094                         break;
1095
1096                 case LED_BLINK_WPS_STOP_OVERLAP:        //WPS session overlap
1097                         pLed->BlinkTimes--;
1098                         if(pLed->BlinkTimes == 0)
1099                         {
1100                                 if(pLed->bLedOn)
1101                                 {
1102                                         pLed->BlinkTimes = 1;
1103                                 }
1104                                 else
1105                                 {
1106                                         bStopBlinking = _TRUE;
1107                                 }
1108                         }
1109
1110                         if(bStopBlinking)
1111                         {
1112                                 pLed->BlinkTimes = 10;
1113                                 pLed->BlinkingLedState = RTW_LED_ON;
1114                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1115                         }
1116                         else
1117                         {
1118                                 if( pLed->bLedOn )
1119                                         pLed->BlinkingLedState = RTW_LED_OFF;
1120                                 else
1121                                         pLed->BlinkingLedState = RTW_LED_ON;
1122
1123                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1124                         }
1125                         break;
1126
1127
1128                 default:
1129                         break;
1130         }
1131
1132         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink4 CurrLedState %d\n", pLed->CurrLedState));
1133
1134
1135 }
1136
1137 static void
1138 SwLedBlink5(
1139         PLED_871x                       pLed
1140         )
1141 {
1142         _adapter                        *padapter = pLed->padapter;
1143         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
1144         u8                              bStopBlinking = _FALSE;
1145
1146         // Change LED according to BlinkingLedState specified.
1147         if( pLed->BlinkingLedState == RTW_LED_ON )
1148         {
1149                 SwLedOn(padapter, pLed);
1150                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
1151         }
1152         else
1153         {
1154                 SwLedOff(padapter, pLed);
1155                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
1156         }
1157
1158         switch(pLed->CurrLedState)
1159         {
1160                 case LED_SCAN_BLINK:
1161                         pLed->BlinkTimes--;
1162                         if( pLed->BlinkTimes == 0 )
1163                         {
1164                                 bStopBlinking = _TRUE;
1165                         }
1166
1167                         if(bStopBlinking)
1168                         {
1169                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS)
1170                                 {
1171                                         pLed->CurrLedState = RTW_LED_OFF;
1172                                         pLed->BlinkingLedState = RTW_LED_OFF;
1173                                         if(pLed->bLedOn)
1174                                                 SwLedOff(padapter, pLed);
1175                                 }
1176                                 else
1177                                 {               pLed->CurrLedState = RTW_LED_ON;
1178                                                 pLed->BlinkingLedState = RTW_LED_ON;
1179                                                 if(!pLed->bLedOn)
1180                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1181                                 }
1182
1183                                 pLed->bLedScanBlinkInProgress = _FALSE;
1184                         }
1185                         else
1186                         {
1187                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS)
1188                                 {
1189                                         SwLedOff(padapter, pLed);
1190                                 }
1191                                 else
1192                                 {
1193                                         if( pLed->bLedOn )
1194                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1195                                         else
1196                                                 pLed->BlinkingLedState = RTW_LED_ON;
1197                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1198                                 }
1199                         }
1200                         break;
1201
1202
1203                 case LED_TXRX_BLINK:
1204                         pLed->BlinkTimes--;
1205                         if( pLed->BlinkTimes == 0 )
1206                         {
1207                                 bStopBlinking = _TRUE;
1208                         }
1209
1210                         if(bStopBlinking)
1211                         {
1212                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS)
1213                                 {
1214                                         pLed->CurrLedState = RTW_LED_OFF;
1215                                         pLed->BlinkingLedState = RTW_LED_OFF;
1216                                         if(pLed->bLedOn)
1217                                                 SwLedOff(padapter, pLed);
1218                                 }
1219                                 else
1220                                 {
1221                                         pLed->CurrLedState = RTW_LED_ON;
1222                                         pLed->BlinkingLedState = RTW_LED_ON;
1223                                         if(!pLed->bLedOn)
1224                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1225                                 }
1226
1227                                 pLed->bLedBlinkInProgress = _FALSE;
1228                         }
1229                         else
1230                         {
1231                                 if( padapter->pwrctrlpriv.rf_pwrstate != rf_on && padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS)
1232                                 {
1233                                         SwLedOff(padapter, pLed);
1234                                 }
1235                                 else
1236                                 {
1237                                          if( pLed->bLedOn )
1238                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1239                                         else
1240                                                 pLed->BlinkingLedState = RTW_LED_ON;
1241                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1242                                 }
1243                         }
1244                         break;
1245
1246                 default:
1247                         break;
1248         }
1249
1250         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink5 CurrLedState %d\n", pLed->CurrLedState));
1251
1252
1253 }
1254
1255 static void
1256 SwLedBlink6(
1257         PLED_871x                       pLed
1258         )
1259 {
1260         _adapter                        *padapter = pLed->padapter;
1261         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
1262         u8                              bStopBlinking = _FALSE;
1263
1264         // Change LED according to BlinkingLedState specified.
1265         if( pLed->BlinkingLedState == RTW_LED_ON )
1266         {
1267                 SwLedOn(padapter, pLed);
1268                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
1269         }
1270         else
1271         {
1272                 SwLedOff(padapter, pLed);
1273                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
1274         }
1275
1276         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink6\n"));
1277 }
1278
1279
1280 //
1281 //      Description:
1282 //              Callback function of LED BlinkTimer,
1283 //              it just schedules to corresponding BlinkWorkItem.
1284 //
1285 static void
1286 BlinkTimerCallback(
1287         unsigned long data
1288         )
1289 {
1290         PLED_871x        pLed = (PLED_871x)data;
1291         _adapter                *padapter = pLed->padapter;
1292
1293         //DBG_871X("%s\n", __FUNCTION__);
1294
1295         if( (padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE))
1296         {
1297                 //DBG_871X("%s bSurpriseRemoved:%d, bDriverStopped:%d\n", __FUNCTION__, padapter->bSurpriseRemoved, padapter->bDriverStopped);
1298                 return;
1299         }
1300
1301 #ifdef CONFIG_LED_HANDLED_BY_CMD_THREAD
1302         rtw_led_blink_cmd(padapter, pLed);
1303 #else
1304         _set_workitem(&(pLed->BlinkWorkItem));
1305 #endif
1306 }
1307
1308 //
1309 //      Description:
1310 //              Handler function of LED Blinking.
1311 //              We dispatch acture LED blink action according to LedStrategy.
1312 //
1313 void BlinkHandler(PLED_871x      pLed)
1314 {
1315         struct led_priv *ledpriv = &(pLed->padapter->ledpriv);
1316         _adapter                *padapter = pLed->padapter;
1317
1318         //DBG_871X("%s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
1319
1320         if( (padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE))
1321         {
1322                 //DBG_871X("%s bSurpriseRemoved:%d, bDriverStopped:%d\n", __FUNCTION__, padapter->bSurpriseRemoved, padapter->bDriverStopped);
1323                 return;
1324         }
1325
1326         switch(ledpriv->LedStrategy)
1327         {
1328                 case SW_LED_MODE0:
1329                         SwLedBlink(pLed);
1330                         break;
1331
1332                 case SW_LED_MODE1:
1333                         SwLedBlink1(pLed);
1334                         break;
1335
1336                 case SW_LED_MODE2:
1337                         SwLedBlink2(pLed);
1338                         break;
1339
1340                 case SW_LED_MODE3:
1341                         SwLedBlink3(pLed);
1342                         break;
1343
1344                 case SW_LED_MODE4:
1345                         SwLedBlink4(pLed);
1346                         break;
1347
1348                 case SW_LED_MODE5:
1349                         SwLedBlink5(pLed);
1350                         break;
1351
1352                 case SW_LED_MODE6:
1353                         SwLedBlink6(pLed);
1354                         break;
1355
1356                 default:
1357                         //RT_TRACE(COMP_LED, DBG_LOUD, ("BlinkWorkItemCallback 0x%x \n", pHalData->LedStrategy));
1358                         //SwLedBlink(pLed);
1359                         break;
1360         }
1361 }
1362
1363 //
1364 //      Description:
1365 //              Callback function of LED BlinkWorkItem.
1366 //              We dispatch acture LED blink action according to LedStrategy.
1367 //
1368 static void BlinkWorkItemCallback(struct work_struct *work)
1369 {
1370         PLED_871x        pLed = container_of(work, LED_871x, BlinkWorkItem);
1371         BlinkHandler(pLed);
1372 }
1373
1374
1375
1376 //================================================================================
1377 // Default LED behavior.
1378 //================================================================================
1379
1380 //
1381 //      Description:
1382 //              Implement each led action for SW_LED_MODE0.
1383 //              This is default strategy.
1384 //
1385 static void
1386 SwLedControlMode0(
1387         _adapter                *padapter,
1388         LED_CTL_MODE            LedAction
1389 )
1390 {
1391         struct led_priv *ledpriv = &(padapter->ledpriv);
1392         PLED_871x       pLed = &(ledpriv->SwLed1);
1393
1394         // Decide led state
1395         switch(LedAction)
1396         {
1397         case LED_CTL_TX:
1398         case LED_CTL_RX:
1399                 if( pLed->bLedBlinkInProgress == _FALSE )
1400                 {
1401                         pLed->bLedBlinkInProgress = _TRUE;
1402
1403                         pLed->CurrLedState = LED_BLINK_NORMAL;
1404                         pLed->BlinkTimes = 2;
1405
1406                         if( pLed->bLedOn )
1407                                 pLed->BlinkingLedState = RTW_LED_OFF;
1408                         else
1409                                 pLed->BlinkingLedState = RTW_LED_ON;
1410                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1411                 }
1412                 break;
1413
1414         case LED_CTL_START_TO_LINK:
1415                 if( pLed->bLedBlinkInProgress == _FALSE )
1416                 {
1417                         pLed->bLedBlinkInProgress = _TRUE;
1418
1419                         pLed->CurrLedState = LED_BLINK_StartToBlink;
1420                         pLed->BlinkTimes = 24;
1421
1422                         if( pLed->bLedOn )
1423                                 pLed->BlinkingLedState = RTW_LED_OFF;
1424                         else
1425                                 pLed->BlinkingLedState = RTW_LED_ON;
1426                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1427                 }
1428                 else
1429                 {
1430                         pLed->CurrLedState = LED_BLINK_StartToBlink;
1431                 }
1432                 break;
1433
1434         case LED_CTL_LINK:
1435                 pLed->CurrLedState = RTW_LED_ON;
1436                 if( pLed->bLedBlinkInProgress == _FALSE )
1437                 {
1438                         SwLedOn(padapter, pLed);
1439                 }
1440                 break;
1441
1442         case LED_CTL_NO_LINK:
1443                 pLed->CurrLedState = RTW_LED_OFF;
1444                 if( pLed->bLedBlinkInProgress == _FALSE )
1445                 {
1446                         SwLedOff(padapter, pLed);
1447                 }
1448                 break;
1449
1450         case LED_CTL_POWER_OFF:
1451                 pLed->CurrLedState = RTW_LED_OFF;
1452                 if(pLed->bLedBlinkInProgress)
1453                 {
1454                         _cancel_timer_ex(&(pLed->BlinkTimer));
1455                         pLed->bLedBlinkInProgress = _FALSE;
1456                 }
1457                 SwLedOff(padapter, pLed);
1458                 break;
1459
1460         case LED_CTL_START_WPS:
1461                 if( pLed->bLedBlinkInProgress == _FALSE || pLed->CurrLedState == RTW_LED_ON)
1462                 {
1463                         pLed->bLedBlinkInProgress = _TRUE;
1464
1465                         pLed->CurrLedState = LED_BLINK_WPS;
1466                         pLed->BlinkTimes = 20;
1467
1468                         if( pLed->bLedOn )
1469                         {
1470                                 pLed->BlinkingLedState = RTW_LED_OFF;
1471                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
1472                         }
1473                         else
1474                         {
1475                                 pLed->BlinkingLedState = RTW_LED_ON;
1476                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
1477                         }
1478                 }
1479                 break;
1480
1481         case LED_CTL_STOP_WPS:
1482                 if(pLed->bLedBlinkInProgress)
1483                 {
1484                         pLed->CurrLedState = RTW_LED_OFF;
1485                         _cancel_timer_ex(&(pLed->BlinkTimer));
1486                         pLed->bLedBlinkInProgress = _FALSE;
1487                 }
1488                 break;
1489
1490
1491         default:
1492                 break;
1493         }
1494
1495         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));
1496
1497 }
1498
1499  //ALPHA, added by chiyoko, 20090106
1500 static void
1501 SwLedControlMode1(
1502         _adapter                *padapter,
1503         LED_CTL_MODE            LedAction
1504 )
1505 {
1506         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(padapter);
1507         struct led_priv         *ledpriv = &(padapter->ledpriv);
1508         PLED_871x                       pLed = &(ledpriv->SwLed0);
1509         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);
1510
1511         if(pHalData->EEPROMCustomerID == RT_CID_819x_CAMEO)
1512                 pLed = &(ledpriv->SwLed1);
1513
1514         switch(LedAction)
1515         {
1516                 case LED_CTL_POWER_ON:
1517                 case LED_CTL_START_TO_LINK:
1518                 case LED_CTL_NO_LINK:
1519                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )
1520                         {
1521                                 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1522                                 {
1523                                         return;
1524                                 }
1525                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )
1526                                 {
1527                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1528                                         pLed->bLedLinkBlinkInProgress = _FALSE;
1529                                 }
1530                                 if(pLed->bLedBlinkInProgress ==_TRUE)
1531                                 {
1532                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1533                                         pLed->bLedBlinkInProgress = _FALSE;
1534                                 }
1535
1536                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1537                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
1538                                 if( pLed->bLedOn )
1539                                         pLed->BlinkingLedState = RTW_LED_OFF;
1540                                 else
1541                                         pLed->BlinkingLedState = RTW_LED_ON;
1542                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1543                         }
1544                         break;
1545
1546                 case LED_CTL_LINK:
1547                         if( pLed->bLedLinkBlinkInProgress == _FALSE )
1548                         {
1549                                 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1550                                 {
1551                                         return;
1552                                 }
1553                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
1554                                 {
1555                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1556                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
1557                                 }
1558                                 if(pLed->bLedBlinkInProgress ==_TRUE)
1559                                 {
1560                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1561                                         pLed->bLedBlinkInProgress = _FALSE;
1562                                 }
1563                                 pLed->bLedLinkBlinkInProgress = _TRUE;
1564                                 pLed->CurrLedState = LED_BLINK_NORMAL;
1565                                 if( pLed->bLedOn )
1566                                         pLed->BlinkingLedState = RTW_LED_OFF;
1567                                 else
1568                                         pLed->BlinkingLedState = RTW_LED_ON;
1569                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1570                         }
1571                         break;
1572
1573                 case LED_CTL_SITE_SURVEY:
1574                          if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
1575                                 ;
1576                          else if(pLed->bLedScanBlinkInProgress ==_FALSE)
1577                          {
1578                                 if(IS_LED_WPS_BLINKING(pLed))
1579                                         return;
1580
1581                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
1582                                 {
1583                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1584                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
1585                                 }
1586                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )
1587                                 {
1588                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1589                                          pLed->bLedLinkBlinkInProgress = _FALSE;
1590                                 }
1591                                 if(pLed->bLedBlinkInProgress ==_TRUE)
1592                                 {
1593                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1594                                         pLed->bLedBlinkInProgress = _FALSE;
1595                                 }
1596                                 pLed->bLedScanBlinkInProgress = _TRUE;
1597                                 pLed->CurrLedState = LED_SCAN_BLINK;
1598                                 pLed->BlinkTimes = 24;
1599                                 if( pLed->bLedOn )
1600                                         pLed->BlinkingLedState = RTW_LED_OFF;
1601                                 else
1602                                         pLed->BlinkingLedState = RTW_LED_ON;
1603                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1604                          }
1605                         break;
1606
1607                 case LED_CTL_TX:
1608                 case LED_CTL_RX:
1609                         if(pLed->bLedBlinkInProgress ==_FALSE)
1610                         {
1611                                 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1612                                 {
1613                                         return;
1614                                 }
1615                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
1616                                 {
1617                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1618                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
1619                                 }
1620                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )
1621                                 {
1622                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1623                                         pLed->bLedLinkBlinkInProgress = _FALSE;
1624                                 }
1625                                 pLed->bLedBlinkInProgress = _TRUE;
1626                                 pLed->CurrLedState = LED_TXRX_BLINK;
1627                                 pLed->BlinkTimes = 2;
1628                                 if( pLed->bLedOn )
1629                                         pLed->BlinkingLedState = RTW_LED_OFF;
1630                                 else
1631                                         pLed->BlinkingLedState = RTW_LED_ON;
1632                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1633                         }
1634                         break;
1635
1636                 case LED_CTL_START_WPS: //wait until xinpin finish
1637                 case LED_CTL_START_WPS_BOTTON:
1638                          if(pLed->bLedWPSBlinkInProgress ==_FALSE)
1639                          {
1640                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
1641                                 {
1642                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1643                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
1644                                 }
1645                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )
1646                                 {
1647                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1648                                          pLed->bLedLinkBlinkInProgress = _FALSE;
1649                                 }
1650                                 if(pLed->bLedBlinkInProgress ==_TRUE)
1651                                 {
1652                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1653                                         pLed->bLedBlinkInProgress = _FALSE;
1654                                 }
1655                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
1656                                 {
1657                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1658                                         pLed->bLedScanBlinkInProgress = _FALSE;
1659                                 }
1660                                 pLed->bLedWPSBlinkInProgress = _TRUE;
1661                                 pLed->CurrLedState = LED_BLINK_WPS;
1662                                 if( pLed->bLedOn )
1663                                         pLed->BlinkingLedState = RTW_LED_OFF;
1664                                 else
1665                                         pLed->BlinkingLedState = RTW_LED_ON;
1666                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1667                          }
1668                         break;
1669
1670
1671                 case LED_CTL_STOP_WPS:
1672                         if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
1673                         {
1674                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1675                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1676                         }
1677                         if( pLed->bLedLinkBlinkInProgress == _TRUE )
1678                         {
1679                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1680                                  pLed->bLedLinkBlinkInProgress = _FALSE;
1681                         }
1682                         if(pLed->bLedBlinkInProgress ==_TRUE)
1683                         {
1684                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1685                                 pLed->bLedBlinkInProgress = _FALSE;
1686                         }
1687                         if(pLed->bLedScanBlinkInProgress ==_TRUE)
1688                         {
1689                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1690                                 pLed->bLedScanBlinkInProgress = _FALSE;
1691                         }
1692                         if(pLed->bLedWPSBlinkInProgress)
1693                         {
1694                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1695                         }
1696                         else
1697                         {
1698                                 pLed->bLedWPSBlinkInProgress = _TRUE;
1699                         }
1700
1701                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
1702                         if(pLed->bLedOn)
1703                         {
1704                                 pLed->BlinkingLedState = RTW_LED_OFF;
1705                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
1706                         }
1707                         else
1708                         {
1709                                 pLed->BlinkingLedState = RTW_LED_ON;
1710                                 _set_timer(&(pLed->BlinkTimer), 0);
1711                         }
1712                         break;
1713
1714                 case LED_CTL_STOP_WPS_FAIL:
1715                         if(pLed->bLedWPSBlinkInProgress)
1716                         {
1717                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1718                                 pLed->bLedWPSBlinkInProgress = _FALSE;
1719                         }
1720
1721                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
1722                         pLed->CurrLedState = LED_BLINK_SLOWLY;
1723                         if( pLed->bLedOn )
1724                                 pLed->BlinkingLedState = RTW_LED_OFF;
1725                         else
1726                                 pLed->BlinkingLedState = RTW_LED_ON;
1727                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1728                         break;
1729
1730                 case LED_CTL_POWER_OFF:
1731                         pLed->CurrLedState = RTW_LED_OFF;
1732                         pLed->BlinkingLedState = RTW_LED_OFF;
1733                         if( pLed->bLedNoLinkBlinkInProgress)
1734                         {
1735                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1736                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
1737                         }
1738                         if( pLed->bLedLinkBlinkInProgress)
1739                         {
1740                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1741                                 pLed->bLedLinkBlinkInProgress = _FALSE;
1742                         }
1743                         if( pLed->bLedBlinkInProgress)
1744                         {
1745                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1746                                 pLed->bLedBlinkInProgress = _FALSE;
1747                         }
1748                         if( pLed->bLedWPSBlinkInProgress )
1749                         {
1750                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1751                                 pLed->bLedWPSBlinkInProgress = _FALSE;
1752                         }
1753                         if( pLed->bLedScanBlinkInProgress)
1754                         {
1755                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1756                                 pLed->bLedScanBlinkInProgress = _FALSE;
1757                         }
1758
1759                         SwLedOff(padapter, pLed);
1760                         break;
1761
1762                 default:
1763                         break;
1764
1765         }
1766
1767         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));
1768 }
1769
1770  //Arcadyan/Sitecom , added by chiyoko, 20090216
1771 static void
1772 SwLedControlMode2(
1773         _adapter                                *padapter,
1774         LED_CTL_MODE            LedAction
1775 )
1776 {
1777         struct led_priv *ledpriv = &(padapter->ledpriv);
1778         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
1779         PLED_871x               pLed = &(ledpriv->SwLed0);
1780
1781         switch(LedAction)
1782         {
1783                 case LED_CTL_SITE_SURVEY:
1784                          if(pmlmepriv->LinkDetectInfo.bBusyTraffic)
1785                                 ;
1786                          else if(pLed->bLedScanBlinkInProgress ==_FALSE)
1787                          {
1788                                 if(IS_LED_WPS_BLINKING(pLed))
1789                                         return;
1790
1791                                 if(pLed->bLedBlinkInProgress ==_TRUE)
1792                                 {
1793                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1794                                         pLed->bLedBlinkInProgress = _FALSE;
1795                                 }
1796                                 pLed->bLedScanBlinkInProgress = _TRUE;
1797                                 pLed->CurrLedState = LED_SCAN_BLINK;
1798                                 pLed->BlinkTimes = 24;
1799                                 if( pLed->bLedOn )
1800                                         pLed->BlinkingLedState = RTW_LED_OFF;
1801                                 else
1802                                         pLed->BlinkingLedState = RTW_LED_ON;
1803                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1804                          }
1805                         break;
1806
1807                 case LED_CTL_TX:
1808                 case LED_CTL_RX:
1809                         if((pLed->bLedBlinkInProgress ==_FALSE) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
1810                         {
1811                                 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1812                                 {
1813                                         return;
1814                                 }
1815
1816                                 pLed->bLedBlinkInProgress = _TRUE;
1817                                 pLed->CurrLedState = LED_TXRX_BLINK;
1818                                 pLed->BlinkTimes = 2;
1819                                 if( pLed->bLedOn )
1820                                         pLed->BlinkingLedState = RTW_LED_OFF;
1821                                 else
1822                                         pLed->BlinkingLedState = RTW_LED_ON;
1823                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1824                         }
1825                         break;
1826
1827                 case LED_CTL_LINK:
1828                         pLed->CurrLedState = RTW_LED_ON;
1829                         pLed->BlinkingLedState = RTW_LED_ON;
1830                         if( pLed->bLedBlinkInProgress)
1831                         {
1832                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1833                                 pLed->bLedBlinkInProgress = _FALSE;
1834                         }
1835                         if( pLed->bLedScanBlinkInProgress)
1836                         {
1837                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1838                                 pLed->bLedScanBlinkInProgress = _FALSE;
1839                         }
1840
1841                         _set_timer(&(pLed->BlinkTimer), 0);
1842                         break;
1843
1844                 case LED_CTL_START_WPS: //wait until xinpin finish
1845                 case LED_CTL_START_WPS_BOTTON:
1846                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)
1847                         {
1848                                 if(pLed->bLedBlinkInProgress ==_TRUE)
1849                                 {
1850                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1851                                         pLed->bLedBlinkInProgress = _FALSE;
1852                                 }
1853                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
1854                                 {
1855                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1856                                         pLed->bLedScanBlinkInProgress = _FALSE;
1857                                 }
1858                                 pLed->bLedWPSBlinkInProgress = _TRUE;
1859                                 pLed->CurrLedState = RTW_LED_ON;
1860                                 pLed->BlinkingLedState = RTW_LED_ON;
1861                                 _set_timer(&(pLed->BlinkTimer), 0);
1862                          }
1863                         break;
1864
1865                 case LED_CTL_STOP_WPS:
1866                         pLed->bLedWPSBlinkInProgress = _FALSE;
1867                         if(padapter->pwrctrlpriv.rf_pwrstate != rf_on)
1868                         {
1869                                 SwLedOff(padapter, pLed);
1870                         }
1871                         else
1872                         {
1873                                 pLed->CurrLedState = RTW_LED_ON;
1874                                 pLed->BlinkingLedState = RTW_LED_ON;
1875                                 _set_timer(&(pLed->BlinkTimer), 0);
1876                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1877                         }
1878                         break;
1879
1880                 case LED_CTL_STOP_WPS_FAIL:
1881                         pLed->bLedWPSBlinkInProgress = _FALSE;
1882                         if(padapter->pwrctrlpriv.rf_pwrstate != rf_on)
1883                         {
1884                                 SwLedOff(padapter, pLed);
1885                         }
1886                         else
1887                         {
1888                                 pLed->CurrLedState = RTW_LED_OFF;
1889                                 pLed->BlinkingLedState = RTW_LED_OFF;
1890                                 _set_timer(&(pLed->BlinkTimer), 0);
1891                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1892                         }
1893                         break;
1894
1895                 case LED_CTL_START_TO_LINK:
1896                 case LED_CTL_NO_LINK:
1897                         if(!IS_LED_BLINKING(pLed))
1898                         {
1899                                 pLed->CurrLedState = RTW_LED_OFF;
1900                                 pLed->BlinkingLedState = RTW_LED_OFF;
1901                                 _set_timer(&(pLed->BlinkTimer), 0);
1902                         }
1903                         break;
1904
1905                 case LED_CTL_POWER_OFF:
1906                         pLed->CurrLedState = RTW_LED_OFF;
1907                         pLed->BlinkingLedState = RTW_LED_OFF;
1908                         if( pLed->bLedBlinkInProgress)
1909                         {
1910                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1911                                 pLed->bLedBlinkInProgress = _FALSE;
1912                         }
1913                         if( pLed->bLedScanBlinkInProgress)
1914                         {
1915                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1916                                 pLed->bLedScanBlinkInProgress = _FALSE;
1917                         }
1918                         if( pLed->bLedWPSBlinkInProgress )
1919                         {
1920                                 _cancel_timer_ex(&(pLed->BlinkTimer));
1921                                 pLed->bLedWPSBlinkInProgress = _FALSE;
1922                         }
1923
1924                         _set_timer(&(pLed->BlinkTimer), 0);
1925                         break;
1926
1927                 default:
1928                         break;
1929
1930         }
1931
1932         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1933 }
1934
1935   //COREGA, added by chiyoko, 20090316
1936  static void
1937  SwLedControlMode3(
1938         _adapter                                *padapter,
1939         LED_CTL_MODE            LedAction
1940 )
1941 {
1942         struct led_priv *ledpriv = &(padapter->ledpriv);
1943         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
1944         PLED_871x               pLed = &(ledpriv->SwLed0);
1945
1946         switch(LedAction)
1947         {
1948                 case LED_CTL_SITE_SURVEY:
1949                         if(pmlmepriv->LinkDetectInfo.bBusyTraffic)
1950                                 ;
1951                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)
1952                         {
1953                                 if(IS_LED_WPS_BLINKING(pLed))
1954                                         return;
1955
1956                                 if(pLed->bLedBlinkInProgress ==_TRUE)
1957                                 {
1958                                         _cancel_timer_ex(&(pLed->BlinkTimer));
1959                                         pLed->bLedBlinkInProgress = _FALSE;
1960                                 }
1961                                 pLed->bLedScanBlinkInProgress = _TRUE;
1962                                 pLed->CurrLedState = LED_SCAN_BLINK;
1963                                 pLed->BlinkTimes = 24;
1964                                 if( pLed->bLedOn )
1965                                         pLed->BlinkingLedState = RTW_LED_OFF;
1966                                 else
1967                                         pLed->BlinkingLedState = RTW_LED_ON;
1968                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1969                         }
1970                         break;
1971
1972                 case LED_CTL_TX:
1973                 case LED_CTL_RX:
1974                         if((pLed->bLedBlinkInProgress ==_FALSE) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
1975                         {
1976                                 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
1977                                 {
1978                                         return;
1979                                 }
1980
1981                                 pLed->bLedBlinkInProgress = _TRUE;
1982                                 pLed->CurrLedState = LED_TXRX_BLINK;
1983                                 pLed->BlinkTimes = 2;
1984                                 if( pLed->bLedOn )
1985                                         pLed->BlinkingLedState = RTW_LED_OFF;
1986                                 else
1987                                         pLed->BlinkingLedState = RTW_LED_ON;
1988                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1989                         }
1990                         break;
1991
1992                 case LED_CTL_LINK:
1993                         if(IS_LED_WPS_BLINKING(pLed))
1994                                 return;
1995
1996                         pLed->CurrLedState = RTW_LED_ON;
1997                         pLed->BlinkingLedState = RTW_LED_ON;
1998                         if( pLed->bLedBlinkInProgress)
1999                         {
2000                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2001                                 pLed->bLedBlinkInProgress = _FALSE;
2002                         }
2003                         if( pLed->bLedScanBlinkInProgress)
2004                         {
2005                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2006                                 pLed->bLedScanBlinkInProgress = _FALSE;
2007                         }
2008
2009                         _set_timer(&(pLed->BlinkTimer), 0);
2010                         break;
2011
2012                 case LED_CTL_START_WPS: //wait until xinpin finish
2013                 case LED_CTL_START_WPS_BOTTON:
2014                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)
2015                         {
2016                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2017                                 {
2018                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2019                                         pLed->bLedBlinkInProgress = _FALSE;
2020                                 }
2021                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
2022                                 {
2023                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2024                                         pLed->bLedScanBlinkInProgress = _FALSE;
2025                                 }
2026                                 pLed->bLedWPSBlinkInProgress = _TRUE;
2027                                 pLed->CurrLedState = LED_BLINK_WPS;
2028                                 if( pLed->bLedOn )
2029                                         pLed->BlinkingLedState = RTW_LED_OFF;
2030                                 else
2031                                         pLed->BlinkingLedState = RTW_LED_ON;
2032                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2033                         }
2034                         break;
2035
2036                 case LED_CTL_STOP_WPS:
2037                         if(pLed->bLedWPSBlinkInProgress)
2038                         {
2039                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2040                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2041                         }
2042                         else
2043                         {
2044                                 pLed->bLedWPSBlinkInProgress = _TRUE;
2045                         }
2046
2047                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
2048                         if(pLed->bLedOn)
2049                         {
2050                                 pLed->BlinkingLedState = RTW_LED_OFF;
2051                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
2052                         }
2053                         else
2054                         {
2055                                 pLed->BlinkingLedState = RTW_LED_ON;
2056                                 _set_timer(&(pLed->BlinkTimer), 0);
2057                         }
2058
2059                         break;
2060
2061                 case LED_CTL_STOP_WPS_FAIL:
2062                         if(pLed->bLedWPSBlinkInProgress)
2063                         {
2064                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2065                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2066                         }
2067
2068                         pLed->CurrLedState = RTW_LED_OFF;
2069                         pLed->BlinkingLedState = RTW_LED_OFF;
2070                         _set_timer(&(pLed->BlinkTimer), 0);
2071                         break;
2072
2073                 case LED_CTL_START_TO_LINK:
2074                 case LED_CTL_NO_LINK:
2075                         if(!IS_LED_BLINKING(pLed))
2076                         {
2077                                 pLed->CurrLedState = RTW_LED_OFF;
2078                                 pLed->BlinkingLedState = RTW_LED_OFF;
2079                                 _set_timer(&(pLed->BlinkTimer), 0);
2080                         }
2081                         break;
2082
2083                 case LED_CTL_POWER_OFF:
2084                         pLed->CurrLedState = RTW_LED_OFF;
2085                         pLed->BlinkingLedState = RTW_LED_OFF;
2086                         if( pLed->bLedBlinkInProgress)
2087                         {
2088                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2089                                 pLed->bLedBlinkInProgress = _FALSE;
2090                         }
2091                         if( pLed->bLedScanBlinkInProgress)
2092                         {
2093                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2094                                 pLed->bLedScanBlinkInProgress = _FALSE;
2095                         }
2096                         if( pLed->bLedWPSBlinkInProgress )
2097                         {
2098                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2099                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2100                         }
2101
2102                         _set_timer(&(pLed->BlinkTimer), 0);
2103                         break;
2104
2105                 default:
2106                         break;
2107
2108         }
2109
2110         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
2111 }
2112
2113
2114  //Edimax-Belkin, added by chiyoko, 20090413
2115 static void
2116 SwLedControlMode4(
2117         _adapter                                *padapter,
2118         LED_CTL_MODE            LedAction
2119 )
2120 {
2121         struct led_priv *ledpriv = &(padapter->ledpriv);
2122         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2123         PLED_871x               pLed = &(ledpriv->SwLed0);
2124         PLED_871x               pLed1 = &(ledpriv->SwLed1);
2125
2126         switch(LedAction)
2127         {
2128                 case LED_CTL_START_TO_LINK:
2129                         if(pLed1->bLedWPSBlinkInProgress)
2130                         {
2131                                 pLed1->bLedWPSBlinkInProgress = _FALSE;
2132                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
2133
2134                                 pLed1->BlinkingLedState = RTW_LED_OFF;
2135                                 pLed1->CurrLedState = RTW_LED_OFF;
2136
2137                                 if(pLed1->bLedOn)
2138                                         _set_timer(&(pLed->BlinkTimer), 0);
2139                         }
2140
2141                         if( pLed->bLedStartToLinkBlinkInProgress == _FALSE )
2142                         {
2143                                 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
2144                                 {
2145                                         return;
2146                                 }
2147                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2148                                 {
2149                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2150                                         pLed->bLedBlinkInProgress = _FALSE;
2151                                 }
2152                                 if(pLed->bLedNoLinkBlinkInProgress ==_TRUE)
2153                                 {
2154                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2155                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
2156                                 }
2157
2158                                 pLed->bLedStartToLinkBlinkInProgress = _TRUE;
2159                                 pLed->CurrLedState = LED_BLINK_StartToBlink;
2160                                 if( pLed->bLedOn )
2161                                 {
2162                                         pLed->BlinkingLedState = RTW_LED_OFF;
2163                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
2164                                 }
2165                                 else
2166                                 {
2167                                         pLed->BlinkingLedState = RTW_LED_ON;
2168                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2169                                 }
2170                         }
2171                         break;
2172
2173                 case LED_CTL_LINK:
2174                 case LED_CTL_NO_LINK:
2175                         //LED1 settings
2176                         if(LedAction == LED_CTL_LINK)
2177                         {
2178                                 if(pLed1->bLedWPSBlinkInProgress)
2179                                 {
2180                                         pLed1->bLedWPSBlinkInProgress = _FALSE;
2181                                         _cancel_timer_ex(&(pLed1->BlinkTimer));
2182
2183                                         pLed1->BlinkingLedState = RTW_LED_OFF;
2184                                         pLed1->CurrLedState = RTW_LED_OFF;
2185
2186                                         if(pLed1->bLedOn)
2187                                                 _set_timer(&(pLed->BlinkTimer), 0);
2188                                 }
2189                         }
2190
2191                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )
2192                         {
2193                                 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
2194                                 {
2195                                         return;
2196                                 }
2197                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2198                                 {
2199                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2200                                         pLed->bLedBlinkInProgress = _FALSE;
2201                                 }
2202
2203                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;
2204                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
2205                                 if( pLed->bLedOn )
2206                                         pLed->BlinkingLedState = RTW_LED_OFF;
2207                                 else
2208                                         pLed->BlinkingLedState = RTW_LED_ON;
2209                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2210                         }
2211                         break;
2212
2213                 case LED_CTL_SITE_SURVEY:
2214                         if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
2215                                 ;
2216                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)
2217                         {
2218                                 if(IS_LED_WPS_BLINKING(pLed))
2219                                         return;
2220
2221                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
2222                                 {
2223                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2224                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
2225                                 }
2226                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2227                                 {
2228                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2229                                         pLed->bLedBlinkInProgress = _FALSE;
2230                                 }
2231                                 pLed->bLedScanBlinkInProgress = _TRUE;
2232                                 pLed->CurrLedState = LED_SCAN_BLINK;
2233                                 pLed->BlinkTimes = 24;
2234                                 if( pLed->bLedOn )
2235                                         pLed->BlinkingLedState = RTW_LED_OFF;
2236                                 else
2237                                         pLed->BlinkingLedState = RTW_LED_ON;
2238                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2239                         }
2240                         break;
2241
2242                 case LED_CTL_TX:
2243                 case LED_CTL_RX:
2244                         if(pLed->bLedBlinkInProgress ==_FALSE)
2245                         {
2246                                 if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed))
2247                                 {
2248                                         return;
2249                                 }
2250                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
2251                                 {
2252                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2253                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
2254                                 }
2255                                 pLed->bLedBlinkInProgress = _TRUE;
2256                                 pLed->CurrLedState = LED_TXRX_BLINK;
2257                                 pLed->BlinkTimes = 2;
2258                                 if( pLed->bLedOn )
2259                                         pLed->BlinkingLedState = RTW_LED_OFF;
2260                                 else
2261                                         pLed->BlinkingLedState = RTW_LED_ON;
2262                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2263                         }
2264                         break;
2265
2266                 case LED_CTL_START_WPS: //wait until xinpin finish
2267                 case LED_CTL_START_WPS_BOTTON:
2268                         if(pLed1->bLedWPSBlinkInProgress)
2269                         {
2270                                 pLed1->bLedWPSBlinkInProgress = _FALSE;
2271                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
2272
2273                                 pLed1->BlinkingLedState = RTW_LED_OFF;
2274                                 pLed1->CurrLedState = RTW_LED_OFF;
2275
2276                                 if(pLed1->bLedOn)
2277                                         _set_timer(&(pLed->BlinkTimer), 0);
2278                         }
2279
2280                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)
2281                         {
2282                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
2283                                 {
2284                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2285                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
2286                                 }
2287                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2288                                 {
2289                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2290                                         pLed->bLedBlinkInProgress = _FALSE;
2291                                 }
2292                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
2293                                 {
2294                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2295                                         pLed->bLedScanBlinkInProgress = _FALSE;
2296                                 }
2297                                 pLed->bLedWPSBlinkInProgress = _TRUE;
2298                                 pLed->CurrLedState = LED_BLINK_WPS;
2299                                 if( pLed->bLedOn )
2300                                 {
2301                                         pLed->BlinkingLedState = RTW_LED_OFF;
2302                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
2303                                 }
2304                                 else
2305                                 {
2306                                         pLed->BlinkingLedState = RTW_LED_ON;
2307                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2308                                 }
2309                         }
2310                         break;
2311
2312                 case LED_CTL_STOP_WPS:  //WPS connect success
2313                         if(pLed->bLedWPSBlinkInProgress)
2314                         {
2315                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2316                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2317                         }
2318
2319                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
2320                         pLed->CurrLedState = LED_BLINK_SLOWLY;
2321                         if( pLed->bLedOn )
2322                                 pLed->BlinkingLedState = RTW_LED_OFF;
2323                         else
2324                                 pLed->BlinkingLedState = RTW_LED_ON;
2325                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2326
2327                         break;
2328
2329                 case LED_CTL_STOP_WPS_FAIL:             //WPS authentication fail
2330                         if(pLed->bLedWPSBlinkInProgress)
2331                         {
2332                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2333                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2334                         }
2335
2336                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
2337                         pLed->CurrLedState = LED_BLINK_SLOWLY;
2338                         if( pLed->bLedOn )
2339                                 pLed->BlinkingLedState = RTW_LED_OFF;
2340                         else
2341                                 pLed->BlinkingLedState = RTW_LED_ON;
2342                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2343
2344                         //LED1 settings
2345                         if(pLed1->bLedWPSBlinkInProgress)
2346                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
2347                         else
2348                                 pLed1->bLedWPSBlinkInProgress = _TRUE;
2349
2350                         pLed1->CurrLedState = LED_BLINK_WPS_STOP;
2351                         if( pLed1->bLedOn )
2352                                 pLed1->BlinkingLedState = RTW_LED_OFF;
2353                         else
2354                                 pLed1->BlinkingLedState = RTW_LED_ON;
2355                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2356
2357                         break;
2358
2359                 case LED_CTL_STOP_WPS_FAIL_OVERLAP:     //WPS session overlap
2360                         if(pLed->bLedWPSBlinkInProgress)
2361                         {
2362                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2363                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2364                         }
2365
2366                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
2367                         pLed->CurrLedState = LED_BLINK_SLOWLY;
2368                         if( pLed->bLedOn )
2369                                 pLed->BlinkingLedState = RTW_LED_OFF;
2370                         else
2371                                 pLed->BlinkingLedState = RTW_LED_ON;
2372                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
2373
2374                         //LED1 settings
2375                         if(pLed1->bLedWPSBlinkInProgress)
2376                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
2377                         else
2378                                 pLed1->bLedWPSBlinkInProgress = _TRUE;
2379
2380                         pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
2381                         pLed1->BlinkTimes = 10;
2382                         if( pLed1->bLedOn )
2383                                 pLed1->BlinkingLedState = RTW_LED_OFF;
2384                         else
2385                                 pLed1->BlinkingLedState = RTW_LED_ON;
2386                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2387
2388                         break;
2389
2390                 case LED_CTL_POWER_OFF:
2391                         pLed->CurrLedState = RTW_LED_OFF;
2392                         pLed->BlinkingLedState = RTW_LED_OFF;
2393
2394                         if( pLed->bLedNoLinkBlinkInProgress)
2395                         {
2396                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2397                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2398                         }
2399                         if( pLed->bLedLinkBlinkInProgress)
2400                         {
2401                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2402                                 pLed->bLedLinkBlinkInProgress = _FALSE;
2403                         }
2404                         if( pLed->bLedBlinkInProgress)
2405                         {
2406                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2407                                 pLed->bLedBlinkInProgress = _FALSE;
2408                         }
2409                         if( pLed->bLedWPSBlinkInProgress )
2410                         {
2411                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2412                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2413                         }
2414                         if( pLed->bLedScanBlinkInProgress)
2415                         {
2416                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2417                                 pLed->bLedScanBlinkInProgress = _FALSE;
2418                         }
2419                         if( pLed->bLedStartToLinkBlinkInProgress)
2420                         {
2421                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2422                                 pLed->bLedStartToLinkBlinkInProgress = _FALSE;
2423                         }
2424
2425                         if( pLed1->bLedWPSBlinkInProgress )
2426                         {
2427                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
2428                                 pLed1->bLedWPSBlinkInProgress = _FALSE;
2429                         }
2430
2431                         pLed1->BlinkingLedState = LED_UNKNOWN;
2432                         SwLedOff(padapter, pLed);
2433                         SwLedOff(padapter, pLed1);
2434                         break;
2435
2436                 default:
2437                         break;
2438
2439         }
2440
2441         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));
2442 }
2443
2444
2445
2446  //Sercomm-Belkin, added by chiyoko, 20090415
2447 static void
2448 SwLedControlMode5(
2449         _adapter                                *padapter,
2450         LED_CTL_MODE            LedAction
2451 )
2452 {
2453         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
2454         struct led_priv *ledpriv = &(padapter->ledpriv);
2455         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2456         PLED_871x               pLed = &(ledpriv->SwLed0);
2457
2458         if(pHalData->EEPROMCustomerID == RT_CID_819x_CAMEO)
2459                 pLed = &(ledpriv->SwLed1);
2460
2461         switch(LedAction)
2462         {
2463                 case LED_CTL_POWER_ON:
2464                 case LED_CTL_NO_LINK:
2465                 case LED_CTL_LINK:      //solid blue
2466                         pLed->CurrLedState = RTW_LED_ON;
2467                         pLed->BlinkingLedState = RTW_LED_ON;
2468
2469                         _set_timer(&(pLed->BlinkTimer), 0);
2470                         break;
2471
2472                 case LED_CTL_SITE_SURVEY:
2473                         if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
2474                                 ;
2475                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)
2476                         {
2477                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2478                                 {
2479                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2480                                         pLed->bLedBlinkInProgress = _FALSE;
2481                                 }
2482                                 pLed->bLedScanBlinkInProgress = _TRUE;
2483                                 pLed->CurrLedState = LED_SCAN_BLINK;
2484                                 pLed->BlinkTimes = 24;
2485                                 if( pLed->bLedOn )
2486                                         pLed->BlinkingLedState = RTW_LED_OFF;
2487                                 else
2488                                         pLed->BlinkingLedState = RTW_LED_ON;
2489                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2490                         }
2491                         break;
2492
2493                 case LED_CTL_TX:
2494                 case LED_CTL_RX:
2495                         if(pLed->bLedBlinkInProgress ==_FALSE)
2496                         {
2497                                 if(pLed->CurrLedState == LED_SCAN_BLINK)
2498                                 {
2499                                         return;
2500                                 }
2501                                 pLed->bLedBlinkInProgress = _TRUE;
2502                                 pLed->CurrLedState = LED_TXRX_BLINK;
2503                                 pLed->BlinkTimes = 2;
2504                                 if( pLed->bLedOn )
2505                                         pLed->BlinkingLedState = RTW_LED_OFF;
2506                                 else
2507                                         pLed->BlinkingLedState = RTW_LED_ON;
2508                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2509                         }
2510                         break;
2511
2512                 case LED_CTL_POWER_OFF:
2513                         pLed->CurrLedState = RTW_LED_OFF;
2514                         pLed->BlinkingLedState = RTW_LED_OFF;
2515
2516                         if( pLed->bLedBlinkInProgress)
2517                         {
2518                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2519                                 pLed->bLedBlinkInProgress = _FALSE;
2520                         }
2521
2522                         SwLedOff(padapter, pLed);
2523                         break;
2524
2525                 default:
2526                         break;
2527
2528         }
2529
2530         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));
2531 }
2532
2533  //WNC-Corega, added by chiyoko, 20090902
2534 static void
2535 SwLedControlMode6(
2536         _adapter                                *padapter,
2537         LED_CTL_MODE            LedAction
2538 )
2539 {
2540         struct led_priv *ledpriv = &(padapter->ledpriv);
2541         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2542         PLED_871x pLed0 = &(ledpriv->SwLed0);
2543
2544         switch(LedAction)
2545         {
2546                 case LED_CTL_POWER_ON:
2547                 case LED_CTL_LINK:
2548                 case LED_CTL_NO_LINK:
2549                         _cancel_timer_ex(&(pLed0->BlinkTimer));
2550                         pLed0->CurrLedState = RTW_LED_ON;
2551                         pLed0->BlinkingLedState = RTW_LED_ON;
2552                         _set_timer(&(pLed0->BlinkTimer), 0);
2553                         break;
2554
2555                 case LED_CTL_POWER_OFF:
2556                         SwLedOff(padapter, pLed0);
2557                         break;
2558
2559                 default:
2560                         break;
2561         }
2562
2563         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("ledcontrol 6 Led %d\n", pLed0->CurrLedState));
2564 }
2565
2566
2567 //
2568 //      Description:
2569 //              Dispatch LED action according to pHalData->LedStrategy.
2570 //
2571 static void
2572 LedControl871x(
2573         _adapter                                *padapter,
2574         LED_CTL_MODE            LedAction
2575         )
2576 {
2577         struct led_priv *ledpriv = &(padapter->ledpriv);
2578
2579        if( (padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE)
2580                 ||(padapter->hw_init_completed == _FALSE) )
2581        {
2582              return;
2583        }
2584
2585
2586         if( ledpriv->bRegUseLed == _FALSE)
2587                 return;
2588
2589         //if (!priv->up)
2590         //      return;
2591
2592         //if(priv->bInHctTest)
2593         //      return;
2594
2595         if( (padapter->pwrctrlpriv.rf_pwrstate != rf_on &&
2596                 padapter->pwrctrlpriv.rfoff_reason > RF_CHANGE_BY_PS) &&
2597                 (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
2598                  LedAction == LED_CTL_SITE_SURVEY ||
2599                  LedAction == LED_CTL_LINK ||
2600                  LedAction == LED_CTL_NO_LINK ||
2601                  LedAction == LED_CTL_POWER_ON) )
2602         {
2603                 return;
2604         }
2605
2606         switch(ledpriv->LedStrategy)
2607         {
2608                 case SW_LED_MODE0:
2609                         //SwLedControlMode0(padapter, LedAction);
2610                         break;
2611
2612                 case SW_LED_MODE1:
2613                         SwLedControlMode1(padapter, LedAction);
2614                         break;
2615                 case SW_LED_MODE2:
2616                         SwLedControlMode2(padapter, LedAction);
2617                         break;
2618
2619                 case SW_LED_MODE3:
2620                         SwLedControlMode3(padapter, LedAction);
2621                         break;
2622
2623                 case SW_LED_MODE4:
2624                         SwLedControlMode4(padapter, LedAction);
2625                         break;
2626
2627                 case SW_LED_MODE5:
2628                         SwLedControlMode5(padapter, LedAction);
2629                         break;
2630
2631                 case SW_LED_MODE6:
2632                         SwLedControlMode6(padapter, LedAction);
2633                         break;
2634
2635                 default:
2636                         break;
2637         }
2638
2639         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("LedStrategy:%d, LedAction %d\n", ledpriv->LedStrategy,LedAction));
2640 }
2641
2642 //
2643 //      Description:
2644 //              Initialize all LED_871x objects.
2645 //
2646 void
2647 rtl8192cu_InitSwLeds(
2648         _adapter        *padapter
2649         )
2650 {
2651         struct led_priv *pledpriv = &(padapter->ledpriv);
2652
2653         pledpriv->LedControlHandler = LedControl871x;
2654
2655         InitLed871x(padapter, &(pledpriv->SwLed0), LED_PIN_LED0);
2656
2657         InitLed871x(padapter,&(pledpriv->SwLed1), LED_PIN_LED1);
2658 }
2659
2660
2661 //
2662 //      Description:
2663 //              DeInitialize all LED_819xUsb objects.
2664 //
2665 void
2666 rtl8192cu_DeInitSwLeds(
2667         _adapter        *padapter
2668         )
2669 {
2670         struct led_priv *ledpriv = &(padapter->ledpriv);
2671
2672         DeInitLed871x( &(ledpriv->SwLed0) );
2673         DeInitLed871x( &(ledpriv->SwLed1) );
2674 }
2675