drivers/net/wireless/rockchip_wlan/rtl8188eu/hal/led/hal_usb_led.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 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 <hal_data.h>
  23
  24 //
  25 //      Description:
  26 //              Implementation of LED blinking behavior.
  27 //              It toggle off LED and schedule corresponding timer if necessary.
  28 //
  29 void
  30 SwLedBlink(
  31         PLED_USB                        pLed
  32         )
  33 {
  34         _adapter                        *padapter = pLed->padapter;
  35         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
  36         u8                              bStopBlinking = _FALSE;
  37
  38         // Change LED according to BlinkingLedState specified.
  39         if( pLed->BlinkingLedState == RTW_LED_ON )
  40         {
  41                 SwLedOn(padapter, pLed);
  42                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
  43         }
  44         else
  45         {
  46                 SwLedOff(padapter, pLed);
  47                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,( "Blinktimes (%d): turn off\n", pLed->BlinkTimes));
  48         }
  49
  50         // Determine if we shall change LED state again.
  51         pLed->BlinkTimes--;
  52         switch(pLed->CurrLedState)
  53         {
  54
  55         case LED_BLINK_NORMAL:
  56                 if(pLed->BlinkTimes == 0)
  57                 {
  58                         bStopBlinking = _TRUE;
  59                 }
  60                 break;
  61
  62         case LED_BLINK_StartToBlink:
  63                 if( check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE) )
  64                 {
  65                         bStopBlinking = _TRUE;
  66                 }
  67                 if( check_fwstate(pmlmepriv, _FW_LINKED) &&
  68                         (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) )
  69                 {
  70                         bStopBlinking = _TRUE;
  71                 }
  72                 else if(pLed->BlinkTimes == 0)
  73                 {
  74                         bStopBlinking = _TRUE;
  75                 }
  76                 break;
  77
  78         case LED_BLINK_WPS:
  79                 if( pLed->BlinkTimes == 0 )
  80                 {
  81                         bStopBlinking = _TRUE;
  82                 }
  83                 break;
  84
  85
  86         default:
  87                 bStopBlinking = _TRUE;
  88                 break;
  89
  90         }
  91
  92         if(bStopBlinking)
  93         {
  94                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
  95                 {
  96                         SwLedOff(padapter, pLed);
  97                 }
  98                 else if( (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE) && (pLed->bLedOn == _FALSE))
  99                 {
 100                         SwLedOn(padapter, pLed);
 101                 }
 102                 else if( (check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE) &&  pLed->bLedOn == _TRUE)
 103                 {
 104                         SwLedOff(padapter, pLed);
 105                 }
 106
 107                 pLed->BlinkTimes = 0;
 108                 pLed->bLedBlinkInProgress = _FALSE;
 109         }
 110         else
 111         {
 112                 // Assign LED state to toggle.
 113                 if( pLed->BlinkingLedState == RTW_LED_ON )
 114                         pLed->BlinkingLedState = RTW_LED_OFF;
 115                 else
 116                         pLed->BlinkingLedState = RTW_LED_ON;
 117
 118                 // Schedule a timer to toggle LED state.
 119                 switch( pLed->CurrLedState )
 120                 {
 121                 case LED_BLINK_NORMAL:
 122                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
 123                         break;
 124
 125                 case LED_BLINK_SLOWLY:
 126                 case LED_BLINK_StartToBlink:
 127                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
 128                         break;
 129
 130                 case LED_BLINK_WPS:
 131                         {
 132                                 if( pLed->BlinkingLedState == RTW_LED_ON )
 133                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
 134                                 else
 135                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
 136                         }
 137                         break;
 138
 139                 default:
 140                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
 141                         break;
 142                 }
 143         }
 144 }
 145
 146 void
 147 SwLedBlink1(
 148         PLED_USB                        pLed
 149         )
 150 {
 151         _adapter                                *padapter = pLed->padapter;
 152         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(padapter);
 153         struct led_priv         *ledpriv = &(padapter->ledpriv);
 154         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);
 155         PLED_USB                        pLed1 = &(ledpriv->SwLed1);
 156         u8                                      bStopBlinking = _FALSE;
 157
 158         u32 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA; //add by ylb 20121012 for customer led for alpha
 159         if(pHalData->CustomerID == RT_CID_819x_ALPHA_Dlink)
 160                 uLedBlinkNoLinkInterval= LED_BLINK_NO_LINK_INTERVAL_ALPHA_500MS;
 161
 162         if(pHalData->CustomerID == RT_CID_819x_CAMEO)
 163                 pLed = &(ledpriv->SwLed1);
 164
 165         // Change LED according to BlinkingLedState specified.
 166         if( pLed->BlinkingLedState == RTW_LED_ON )
 167         {
 168                 SwLedOn(padapter, pLed);
 169                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,( "Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 170         }
 171         else
 172         {
 173                 SwLedOff(padapter, pLed);
 174                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 175         }
 176
 177
 178         if(pHalData->CustomerID == RT_CID_DEFAULT)
 179         {
 180                 if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 181                 {
 182                         if(!pLed1->bSWLedCtrl)
 183                         {
 184                                 SwLedOn(padapter, pLed1);
 185                                 pLed1->bSWLedCtrl = _TRUE;
 186                         }
 187                         else if(!pLed1->bLedOn)
 188                                 SwLedOn(padapter, pLed1);
 189                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (): turn on pLed1\n"));
 190                 }
 191                 else
 192                 {
 193                         if(!pLed1->bSWLedCtrl)
 194                         {
 195                                 SwLedOff(padapter, pLed1);
 196                                 pLed1->bSWLedCtrl = _TRUE;
 197                         }
 198                         else if(pLed1->bLedOn)
 199                                 SwLedOff(padapter, pLed1);
 200                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (): turn off pLed1\n"));
 201                 }
 202         }
 203
 204         switch(pLed->CurrLedState)
 205         {
 206                 case LED_BLINK_SLOWLY:
 207                         if( pLed->bLedOn )
 208                                 pLed->BlinkingLedState = RTW_LED_OFF;
 209                         else
 210                                 pLed->BlinkingLedState = RTW_LED_ON;
 211                         _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);//change by ylb 20121012 for customer led for alpha
 212                         break;
 213
 214                 case LED_BLINK_NORMAL:
 215                         if( pLed->bLedOn )
 216                                 pLed->BlinkingLedState = RTW_LED_OFF;
 217                         else
 218                                 pLed->BlinkingLedState = RTW_LED_ON;
 219                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 220                         break;
 221
 222                 case LED_BLINK_SCAN:
 223                         pLed->BlinkTimes--;
 224                         if( pLed->BlinkTimes == 0 )
 225                         {
 226                                 bStopBlinking = _TRUE;
 227                         }
 228
 229                         if(bStopBlinking)
 230                         {
 231                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 232                                 {
 233                                         SwLedOff(padapter, pLed);
 234                                 }
 235                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 236                                 {
 237                                         pLed->bLedLinkBlinkInProgress = _TRUE;
 238                                         pLed->CurrLedState = LED_BLINK_NORMAL;
 239                                         if( pLed->bLedOn )
 240                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 241                                         else
 242                                                 pLed->BlinkingLedState = RTW_LED_ON;
 243                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 244                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 245
 246                                 }
 247                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 248                                 {
 249                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
 250                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 251                                         if( pLed->bLedOn )
 252                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 253                                         else
 254                                                 pLed->BlinkingLedState = RTW_LED_ON;
 255                                         _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);
 256                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 257                                 }
 258                                 pLed->bLedScanBlinkInProgress = _FALSE;
 259                         }
 260                         else
 261                         {
 262                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 263                                 {
 264                                         SwLedOff(padapter, pLed);
 265                                 }
 266                                 else
 267                                 {
 268                                         if( pLed->bLedOn )
 269                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 270                                         else
 271                                                 pLed->BlinkingLedState = RTW_LED_ON;
 272                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 273                                 }
 274                         }
 275                         break;
 276
 277                 case LED_BLINK_TXRX:
 278                         pLed->BlinkTimes--;
 279                         if( pLed->BlinkTimes == 0 )
 280                         {
 281                                 bStopBlinking = _TRUE;
 282                         }
 283                         if(bStopBlinking)
 284                         {
 285                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 286                                 {
 287                                         SwLedOff(padapter, pLed);
 288                                 }
 289                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 290                                 {
 291                                         pLed->bLedLinkBlinkInProgress = _TRUE;
 292                                         pLed->CurrLedState = LED_BLINK_NORMAL;
 293                                         if( pLed->bLedOn )
 294                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 295                                         else
 296                                                 pLed->BlinkingLedState = RTW_LED_ON;
 297                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 298                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 299                                 }
 300                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 301                                 {
 302                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
 303                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 304                                         if( pLed->bLedOn )
 305                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 306                                         else
 307                                                 pLed->BlinkingLedState = RTW_LED_ON;
 308                                         _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);
 309                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 310                                 }
 311                                 pLed->BlinkTimes = 0;
 312                                 pLed->bLedBlinkInProgress = _FALSE;
 313                         }
 314                         else
 315                         {
 316                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 317                                 {
 318                                         SwLedOff(padapter, pLed);
 319                                 }
 320                                 else
 321                                 {
 322                                         if( pLed->bLedOn )
 323                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 324                                         else
 325                                                 pLed->BlinkingLedState = RTW_LED_ON;
 326                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 327                                 }
 328                         }
 329                         break;
 330
 331                 case LED_BLINK_WPS:
 332                         if( pLed->bLedOn )
 333                                 pLed->BlinkingLedState = RTW_LED_OFF;
 334                         else
 335                                 pLed->BlinkingLedState = RTW_LED_ON;
 336                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 337                         break;
 338
 339                 case LED_BLINK_WPS_STOP:        //WPS success
 340                         if(pLed->BlinkingLedState == RTW_LED_ON)
 341                         {
 342                                 pLed->BlinkingLedState = RTW_LED_OFF;
 343                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
 344                                 bStopBlinking = _FALSE;
 345                         }
 346                         else
 347                         {
 348                                 bStopBlinking = _TRUE;
 349                         }
 350
 351                         if(bStopBlinking)
 352                         {
 353                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 354                                 {
 355                                         SwLedOff(padapter, pLed);
 356                                 }
 357                                 else
 358                                 {
 359                                         pLed->bLedLinkBlinkInProgress = _TRUE;
 360                                         pLed->CurrLedState = LED_BLINK_NORMAL;
 361                                         if( pLed->bLedOn )
 362                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 363                                         else
 364                                                 pLed->BlinkingLedState = RTW_LED_ON;
 365                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 366                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 367                                 }
 368                                 pLed->bLedWPSBlinkInProgress = _FALSE;
 369                         }
 370                         break;
 371
 372                 default:
 373                         break;
 374         }
 375
 376 }
 377
 378 void
 379 SwLedBlink2(
 380         PLED_USB                        pLed
 381         )
 382 {
 383         _adapter                                *padapter = pLed->padapter;
 384         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);
 385         u8                                      bStopBlinking = _FALSE;
 386
 387         // Change LED according to BlinkingLedState specified.
 388         if( pLed->BlinkingLedState == RTW_LED_ON)
 389         {
 390                 SwLedOn(padapter, pLed);
 391                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 392         }
 393         else
 394         {
 395                 SwLedOff(padapter, pLed);
 396                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 397         }
 398
 399         switch(pLed->CurrLedState)
 400         {
 401                 case LED_BLINK_SCAN:
 402                         pLed->BlinkTimes--;
 403                         if( pLed->BlinkTimes == 0 )
 404                         {
 405                                 bStopBlinking = _TRUE;
 406                         }
 407
 408                         if(bStopBlinking)
 409                         {
 410                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 411                                 {
 412                                         SwLedOff(padapter, pLed);
 413                                 }
 414                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 415                                 {
 416                                         pLed->CurrLedState = RTW_LED_ON;
 417                                         pLed->BlinkingLedState = RTW_LED_ON;
 418                                         SwLedOn(padapter, pLed);
 419                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop scan blink CurrLedState %d\n", pLed->CurrLedState));
 420
 421                                 }
 422                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 423                                 {
 424                                         pLed->CurrLedState = RTW_LED_OFF;
 425                                         pLed->BlinkingLedState = RTW_LED_OFF;
 426                                         SwLedOff(padapter, pLed);
 427                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop scan blink CurrLedState %d\n", pLed->CurrLedState));
 428                                 }
 429                                 pLed->bLedScanBlinkInProgress = _FALSE;
 430                         }
 431                         else
 432                         {
 433                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 434                                 {
 435                                         SwLedOff(padapter, pLed);
 436                                 }
 437                                 else
 438                                 {
 439                                          if( pLed->bLedOn )
 440                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 441                                         else
 442                                                 pLed->BlinkingLedState = RTW_LED_ON;
 443                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 444                                 }
 445                         }
 446                         break;
 447
 448                 case LED_BLINK_TXRX:
 449                         pLed->BlinkTimes--;
 450                         if( pLed->BlinkTimes == 0 )
 451                         {
 452                                 bStopBlinking = _TRUE;
 453                         }
 454                         if(bStopBlinking)
 455                         {
 456                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 457                                 {
 458                                         SwLedOff(padapter, pLed);
 459                                 }
 460                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 461                                 {
 462                                         pLed->CurrLedState = RTW_LED_ON;
 463                                         pLed->BlinkingLedState = RTW_LED_ON;
 464                                         SwLedOn(padapter, pLed);
 465                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop CurrLedState %d\n", pLed->CurrLedState));
 466
 467                                 }
 468                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 469                                 {
 470                                         pLed->CurrLedState = RTW_LED_OFF;
 471                                         pLed->BlinkingLedState = RTW_LED_OFF;
 472                                         SwLedOff(padapter, pLed);
 473                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop CurrLedState %d\n", pLed->CurrLedState));
 474                                 }
 475                                 pLed->bLedBlinkInProgress = _FALSE;
 476                         }
 477                         else
 478                         {
 479                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 480                                 {
 481                                         SwLedOff(padapter, pLed);
 482                                 }
 483                                 else
 484                                 {
 485                                          if( pLed->bLedOn )
 486                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 487                                         else
 488                                                 pLed->BlinkingLedState = RTW_LED_ON;
 489                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 490                                 }
 491                         }
 492                         break;
 493
 494                 default:
 495                         break;
 496         }
 497
 498 }
 499
 500 void
 501 SwLedBlink3(
 502         PLED_USB                        pLed
 503         )
 504 {
 505         _adapter                        *padapter = pLed->padapter;
 506         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 507         u8                              bStopBlinking = _FALSE;
 508
 509         // Change LED according to BlinkingLedState specified.
 510         if( pLed->BlinkingLedState == RTW_LED_ON )
 511         {
 512                 SwLedOn(padapter, pLed);
 513                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 514         }
 515         else
 516         {
 517                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)
 518                         SwLedOff(padapter, pLed);
 519                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 520         }
 521
 522         switch(pLed->CurrLedState)
 523         {
 524                 case LED_BLINK_SCAN:
 525                         pLed->BlinkTimes--;
 526                         if( pLed->BlinkTimes == 0 )
 527                         {
 528                                 bStopBlinking = _TRUE;
 529                         }
 530
 531                         if(bStopBlinking)
 532                         {
 533                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 534                                 {
 535                                         SwLedOff(padapter, pLed);
 536                                 }
 537                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 538                                 {
 539                                         pLed->CurrLedState = RTW_LED_ON;
 540                                         pLed->BlinkingLedState = RTW_LED_ON;
 541                                         if( !pLed->bLedOn )
 542                                                 SwLedOn(padapter, pLed);
 543
 544                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 545                                 }
 546                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 547                                 {
 548                                         pLed->CurrLedState = RTW_LED_OFF;
 549                                         pLed->BlinkingLedState = RTW_LED_OFF;
 550                                         if( pLed->bLedOn )
 551                                                 SwLedOff(padapter, pLed);
 552
 553                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 554                                 }
 555                                 pLed->bLedScanBlinkInProgress = _FALSE;
 556                         }
 557                         else
 558                         {
 559                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 560                                 {
 561                                         SwLedOff(padapter, pLed);
 562                                 }
 563                                 else
 564                                 {
 565                                         if( pLed->bLedOn )
 566                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 567                                         else
 568                                                 pLed->BlinkingLedState = RTW_LED_ON;
 569                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 570                                 }
 571                         }
 572                         break;
 573
 574                 case LED_BLINK_TXRX:
 575                         pLed->BlinkTimes--;
 576                         if( pLed->BlinkTimes == 0 )
 577                         {
 578                                 bStopBlinking = _TRUE;
 579                         }
 580                         if(bStopBlinking)
 581                         {
 582                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 583                                 {
 584                                         SwLedOff(padapter, pLed);
 585                                 }
 586                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
 587                                 {
 588                                         pLed->CurrLedState = RTW_LED_ON;
 589                                         pLed->BlinkingLedState = RTW_LED_ON;
 590
 591                                         if( !pLed->bLedOn )
 592                                                 SwLedOn(padapter, pLed);
 593
 594                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 595                                 }
 596                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
 597                                 {
 598                                         pLed->CurrLedState = RTW_LED_OFF;
 599                                         pLed->BlinkingLedState = RTW_LED_OFF;
 600
 601                                         if( pLed->bLedOn )
 602                                                 SwLedOff(padapter, pLed);
 603
 604
 605                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 606                                 }
 607                                 pLed->bLedBlinkInProgress = _FALSE;
 608                         }
 609                         else
 610                         {
 611                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 612                                 {
 613                                         SwLedOff(padapter, pLed);
 614                                 }
 615                                 else
 616                                 {
 617                                         if( pLed->bLedOn )
 618                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 619                                         else
 620                                                 pLed->BlinkingLedState = RTW_LED_ON;
 621                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 622                                 }
 623                         }
 624                         break;
 625
 626                 case LED_BLINK_WPS:
 627                         if( pLed->bLedOn )
 628                                 pLed->BlinkingLedState = RTW_LED_OFF;
 629                         else
 630                                 pLed->BlinkingLedState = RTW_LED_ON;
 631                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 632                         break;
 633
 634                 case LED_BLINK_WPS_STOP:        //WPS success
 635                         if(pLed->BlinkingLedState == RTW_LED_ON)
 636                         {
 637                                 pLed->BlinkingLedState = RTW_LED_OFF;
 638                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
 639                                 bStopBlinking = _FALSE;
 640                         }
 641                         else
 642                         {
 643                                 bStopBlinking = _TRUE;
 644                         }
 645
 646                         if(bStopBlinking)
 647                         {
 648                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )
 649                                 {
 650                                         SwLedOff(padapter, pLed);
 651                                 }
 652                                 else
 653                                 {
 654                                         pLed->CurrLedState = RTW_LED_ON;
 655                                         pLed->BlinkingLedState = RTW_LED_ON;
 656                                         SwLedOn(padapter, pLed);
 657                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
 658                                 }
 659                                 pLed->bLedWPSBlinkInProgress = _FALSE;
 660                         }
 661                         break;
 662
 663
 664                 default:
 665                         break;
 666         }
 667
 668 }
 669
 670
 671 void
 672 SwLedBlink4(
 673         PLED_USB                        pLed
 674         )
 675 {
 676         _adapter                        *padapter = pLed->padapter;
 677         struct led_priv *ledpriv = &(padapter->ledpriv);
 678         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 679         PLED_USB                pLed1 = &(ledpriv->SwLed1);
 680         u8                              bStopBlinking = _FALSE;
 681
 682         // Change LED according to BlinkingLedState specified.
 683         if( pLed->BlinkingLedState == RTW_LED_ON )
 684         {
 685                 SwLedOn(padapter, pLed);
 686                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 687         }
 688         else
 689         {
 690                 SwLedOff(padapter, pLed);
 691                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 692         }
 693
 694         if(!pLed1->bLedWPSBlinkInProgress && pLed1->BlinkingLedState == LED_UNKNOWN)
 695         {
 696                 pLed1->BlinkingLedState = RTW_LED_OFF;
 697                 pLed1->CurrLedState = RTW_LED_OFF;
 698                 SwLedOff(padapter, pLed1);
 699         }
 700
 701         switch(pLed->CurrLedState)
 702         {
 703                 case LED_BLINK_SLOWLY:
 704                         if( pLed->bLedOn )
 705                                 pLed->BlinkingLedState = RTW_LED_OFF;
 706                         else
 707                                 pLed->BlinkingLedState = RTW_LED_ON;
 708                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
 709                         break;
 710
 711                 case LED_BLINK_StartToBlink:
 712                         if( pLed->bLedOn )
 713                         {
 714                                 pLed->BlinkingLedState = RTW_LED_OFF;
 715                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
 716                         }
 717                         else
 718                         {
 719                                 pLed->BlinkingLedState = RTW_LED_ON;
 720                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
 721                         }
 722                         break;
 723
 724                 case LED_BLINK_SCAN:
 725                         pLed->BlinkTimes--;
 726                         if( pLed->BlinkTimes == 0 )
 727                         {
 728                                 bStopBlinking = _FALSE;
 729                         }
 730
 731                         if(bStopBlinking)
 732                         {
 733                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 734                                 {
 735                                         SwLedOff(padapter, pLed);
 736                                 }
 737                                 else
 738                                 {
 739                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
 740                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 741                                         if( pLed->bLedOn )
 742                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 743                                         else
 744                                                 pLed->BlinkingLedState = RTW_LED_ON;
 745                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
 746                                 }
 747                                 pLed->bLedScanBlinkInProgress = _FALSE;
 748                         }
 749                         else
 750                         {
 751                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 752                                 {
 753                                         SwLedOff(padapter, pLed);
 754                                 }
 755                                 else
 756                                 {
 757                                          if( pLed->bLedOn )
 758                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 759                                         else
 760                                                 pLed->BlinkingLedState = RTW_LED_ON;
 761                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
 762                                 }
 763                         }
 764                         break;
 765
 766                 case LED_BLINK_TXRX:
 767                         pLed->BlinkTimes--;
 768                         if( pLed->BlinkTimes == 0 )
 769                         {
 770                                 bStopBlinking = _TRUE;
 771                         }
 772                         if(bStopBlinking)
 773                         {
 774                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 775                                 {
 776                                         SwLedOff(padapter, pLed);
 777                                 }
 778                                 else
 779                                 {
 780                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
 781                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 782                                         if( pLed->bLedOn )
 783                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 784                                         else
 785                                                 pLed->BlinkingLedState = RTW_LED_ON;
 786                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
 787                                 }
 788                                 pLed->bLedBlinkInProgress = _FALSE;
 789                         }
 790                         else
 791                         {
 792                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 793                                 {
 794                                         SwLedOff(padapter, pLed);
 795                                 }
 796                                 else
 797                                 {
 798
 799                                         if( pLed->bLedOn )
 800                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 801                                         else
 802                                                 pLed->BlinkingLedState = RTW_LED_ON;
 803
 804                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 805                                 }
 806                         }
 807                         break;
 808
 809                 case LED_BLINK_WPS:
 810                         if( pLed->bLedOn )
 811                         {
 812                                 pLed->BlinkingLedState = RTW_LED_OFF;
 813                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
 814                         }
 815                         else
 816                         {
 817                                 pLed->BlinkingLedState = RTW_LED_ON;
 818                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
 819                         }
 820                         break;
 821
 822                 case LED_BLINK_WPS_STOP:        //WPS authentication fail
 823                         if( pLed->bLedOn )
 824                                 pLed->BlinkingLedState = RTW_LED_OFF;
 825                         else
 826                                 pLed->BlinkingLedState = RTW_LED_ON;
 827
 828                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
 829                         break;
 830
 831                 case LED_BLINK_WPS_STOP_OVERLAP:        //WPS session overlap
 832                         pLed->BlinkTimes--;
 833                         if(pLed->BlinkTimes == 0)
 834                         {
 835                                 if(pLed->bLedOn)
 836                                 {
 837                                         pLed->BlinkTimes = 1;
 838                                 }
 839                                 else
 840                                 {
 841                                         bStopBlinking = _TRUE;
 842                                 }
 843                         }
 844
 845                         if(bStopBlinking)
 846                         {
 847                                 pLed->BlinkTimes = 10;
 848                                 pLed->BlinkingLedState = RTW_LED_ON;
 849                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
 850                         }
 851                         else
 852                         {
 853                                 if( pLed->bLedOn )
 854                                         pLed->BlinkingLedState = RTW_LED_OFF;
 855                                 else
 856                                         pLed->BlinkingLedState = RTW_LED_ON;
 857
 858                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
 859                         }
 860                         break;
 861
 862                 case LED_BLINK_ALWAYS_ON:
 863                         pLed->BlinkTimes--;
 864                         if( pLed->BlinkTimes == 0 )
 865                         {
 866                                 bStopBlinking = _TRUE;
 867                         }
 868                         if(bStopBlinking)
 869                         {
 870                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 871                                 {
 872                                         SwLedOff(padapter, pLed);
 873                                 }
 874                                 else
 875                                 {
 876                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
 877                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
 878                                         if( pLed->bLedOn )
 879                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 880                                         else
 881                                                 pLed->BlinkingLedState = RTW_LED_ON;
 882
 883                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
 884                                 }
 885                                 pLed->bLedBlinkInProgress = _FALSE;
 886                         }
 887                         else
 888                         {
 889                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 890                                 {
 891                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("RFOff Status \n"));
 892                                         SwLedOff(padapter, pLed);
 893                                 }
 894                                 else
 895                                 {
 896                                         if( pLed->bLedOn )
 897                                                 pLed->BlinkingLedState = RTW_LED_OFF;
 898                                         else
 899                                                 pLed->BlinkingLedState = RTW_LED_ON;
 900
 901                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 902                                 }
 903                         }
 904                         break;
 905
 906                 default:
 907                         break;
 908         }
 909
 910         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink4 CurrLedState %d\n", pLed->CurrLedState));
 911
 912
 913 }
 914
 915 void
 916 SwLedBlink5(
 917         PLED_USB                        pLed
 918         )
 919 {
 920         _adapter                        *padapter = pLed->padapter;
 921         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 922         u8                              bStopBlinking = _FALSE;
 923
 924         // Change LED according to BlinkingLedState specified.
 925         if( pLed->BlinkingLedState == RTW_LED_ON )
 926         {
 927                 SwLedOn(padapter, pLed);
 928                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
 929         }
 930         else
 931         {
 932                 SwLedOff(padapter, pLed);
 933                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
 934         }
 935
 936         switch(pLed->CurrLedState)
 937         {
 938                 case LED_BLINK_SCAN:
 939                         pLed->BlinkTimes--;
 940                         if( pLed->BlinkTimes == 0 )
 941                         {
 942                                 bStopBlinking = _TRUE;
 943                         }
 944
 945                         if(bStopBlinking)
 946                         {
 947                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 948                                 {
 949                                         pLed->CurrLedState = RTW_LED_OFF;
 950                                         pLed->BlinkingLedState = RTW_LED_OFF;
 951                                         if(pLed->bLedOn)
 952                                                 SwLedOff(padapter, pLed);
 953                                 }
 954                                 else
 955                                 {               pLed->CurrLedState = RTW_LED_ON;
 956                                                 pLed->BlinkingLedState = RTW_LED_ON;
 957                                                 if(!pLed->bLedOn)
 958                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
 959                                 }
 960
 961                                 pLed->bLedScanBlinkInProgress = _FALSE;
 962                         }
 963                         else
 964                         {
 965                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 966                                 {
 967                                         SwLedOff(padapter, pLed);
 968                                 }
 969                                 else
 970                                 {
 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_SCAN_INTERVAL_ALPHA);
 976                                 }
 977                         }
 978                         break;
 979
 980
 981                 case LED_BLINK_TXRX:
 982                         pLed->BlinkTimes--;
 983                         if( pLed->BlinkTimes == 0 )
 984                         {
 985                                 bStopBlinking = _TRUE;
 986                         }
 987
 988                         if(bStopBlinking)
 989                         {
 990                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
 991                                 {
 992                                         pLed->CurrLedState = RTW_LED_OFF;
 993                                         pLed->BlinkingLedState = RTW_LED_OFF;
 994                                         if(pLed->bLedOn)
 995                                                 SwLedOff(padapter, pLed);
 996                                 }
 997                                 else
 998                                 {
 999                                         pLed->CurrLedState = RTW_LED_ON;
1000                                         pLed->BlinkingLedState = RTW_LED_ON;
1001                                         if(!pLed->bLedOn)
1002                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1003                                 }
1004
1005                                 pLed->bLedBlinkInProgress = _FALSE;
1006                         }
1007                         else
1008                         {
1009                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)
1010                                 {
1011                                         SwLedOff(padapter, pLed);
1012                                 }
1013                                 else
1014                                 {
1015                                          if( pLed->bLedOn )
1016                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1017                                         else
1018                                                 pLed->BlinkingLedState = RTW_LED_ON;
1019                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1020                                 }
1021                         }
1022                         break;
1023
1024                 default:
1025                         break;
1026         }
1027
1028         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink5 CurrLedState %d\n", pLed->CurrLedState));
1029
1030
1031 }
1032
1033 void
1034 SwLedBlink6(
1035         PLED_USB                        pLed
1036         )
1037 {
1038         _adapter                        *padapter = pLed->padapter;
1039         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
1040         u8                              bStopBlinking = _FALSE;
1041
1042         // Change LED according to BlinkingLedState specified.
1043         if( pLed->BlinkingLedState == RTW_LED_ON )
1044         {
1045                 SwLedOn(padapter, pLed);
1046                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
1047         }
1048         else
1049         {
1050                 SwLedOff(padapter, pLed);
1051                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
1052         }
1053
1054         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink6\n"));
1055 }
1056
1057 void
1058 SwLedBlink7(
1059         PLED_USB                        pLed
1060         )
1061 {
1062         PADAPTER Adapter = pLed->padapter;
1063         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);
1064         BOOLEAN bStopBlinking = _FALSE;
1065
1066         // Change LED according to BlinkingLedState specified.
1067         if( pLed->BlinkingLedState == RTW_LED_ON )
1068         {
1069                 SwLedOn(Adapter, pLed);
1070                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
1071         }
1072         else
1073         {
1074                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)
1075                         SwLedOff(Adapter, pLed);
1076                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
1077         }
1078
1079         switch(pLed->CurrLedState)
1080         {
1081                 case LED_BLINK_SCAN:
1082                         pLed->BlinkTimes--;
1083                         if( pLed->BlinkTimes == 0 )
1084                         {
1085                                 bStopBlinking = _TRUE;
1086                         }
1087
1088                         if(bStopBlinking)
1089                         {
1090                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )
1091                                 {
1092                                         SwLedOff(Adapter, pLed);
1093                                 }
1094                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
1095                                 {
1096                                         pLed->CurrLedState = RTW_LED_ON;
1097                                         pLed->BlinkingLedState = RTW_LED_ON;
1098                                         if( !pLed->bLedOn )
1099                                                 SwLedOn(Adapter, pLed);
1100
1101                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1102                                 }
1103                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
1104                                 {
1105                                         pLed->CurrLedState = RTW_LED_OFF;
1106                                         pLed->BlinkingLedState = RTW_LED_OFF;
1107                                         if( pLed->bLedOn )
1108                                                 SwLedOff(Adapter, pLed);
1109
1110                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1111                                 }
1112                                 pLed->bLedScanBlinkInProgress = _FALSE;
1113                         }
1114                         else
1115                         {
1116                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )
1117                                 {
1118                                         SwLedOff(Adapter, pLed);
1119                                 }
1120                                 else
1121                                 {
1122                                         if( pLed->bLedOn )
1123                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1124                                         else
1125                                                 pLed->BlinkingLedState = RTW_LED_ON;
1126                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1127                                 }
1128                         }
1129                         break;
1130
1131                 case LED_BLINK_WPS:
1132                         if( pLed->bLedOn )
1133                                 pLed->BlinkingLedState = RTW_LED_OFF;
1134                         else
1135                                 pLed->BlinkingLedState = RTW_LED_ON;
1136                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1137                         break;
1138
1139                 case LED_BLINK_WPS_STOP:        //WPS success
1140                         if(pLed->BlinkingLedState == RTW_LED_ON)
1141                         {
1142                                 pLed->BlinkingLedState = RTW_LED_OFF;
1143                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1144                                 bStopBlinking = _FALSE;
1145                         }
1146                         else
1147                         {
1148                                 bStopBlinking = _TRUE;
1149                         }
1150
1151                         if(bStopBlinking)
1152                         {
1153                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )
1154                                 {
1155                                         SwLedOff(Adapter, pLed);
1156                                 }
1157                                 else
1158                                 {
1159                                         pLed->CurrLedState = RTW_LED_ON;
1160                                         pLed->BlinkingLedState = RTW_LED_ON;
1161                                         SwLedOn(Adapter, pLed);
1162                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1163                                 }
1164                                 pLed->bLedWPSBlinkInProgress = _FALSE;
1165                         }
1166                         break;
1167
1168
1169                 default:
1170                         break;
1171         }
1172
1173         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink7\n"));
1174
1175 }
1176
1177 void
1178 SwLedBlink8(
1179         PLED_USB                        pLed
1180         )
1181 {
1182         PADAPTER Adapter = pLed->padapter;
1183
1184         // Change LED according to BlinkingLedState specified.
1185         if( pLed->BlinkingLedState == RTW_LED_ON )
1186         {
1187                 SwLedOn(Adapter, pLed);
1188                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes blink8(%d): turn on\n", pLed->BlinkTimes));
1189         }
1190         else
1191         {
1192                 SwLedOff(Adapter, pLed);
1193                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes blink8(%d): turn off\n", pLed->BlinkTimes));
1194         }
1195
1196         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink8\n"));
1197
1198 }
1199
1200 //page added for Belkin AC950. 20120813
1201 void
1202 SwLedBlink9(
1203         PLED_USB                        pLed
1204         )
1205 {
1206         PADAPTER Adapter = pLed->padapter;
1207         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);
1208         BOOLEAN bStopBlinking = _FALSE;
1209
1210         // Change LED according to BlinkingLedState specified.
1211         if( pLed->BlinkingLedState == RTW_LED_ON )
1212         {
1213                 SwLedOn(Adapter, pLed);
1214                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
1215         }
1216         else
1217         {
1218                 SwLedOff(Adapter, pLed);
1219                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
1220         }
1221         //DBG_871X("%s, pLed->CurrLedState=%d, pLed->BlinkingLedState=%d \n", __FUNCTION__, pLed->CurrLedState, pLed->BlinkingLedState);
1222
1223
1224         switch(pLed->CurrLedState)
1225         {
1226                 case RTW_LED_ON:
1227                         SwLedOn(Adapter, pLed);
1228                         break;
1229
1230                 case RTW_LED_OFF:
1231                         SwLedOff(Adapter, pLed);
1232                         break;
1233
1234                 case LED_BLINK_SLOWLY:
1235                         if( pLed->bLedOn )
1236                                 pLed->BlinkingLedState = RTW_LED_OFF;
1237                         else
1238                                 pLed->BlinkingLedState = RTW_LED_ON;
1239                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1240                         break;
1241
1242                 case LED_BLINK_StartToBlink:
1243                         if( pLed->bLedOn )
1244                         {
1245                                 pLed->BlinkingLedState = RTW_LED_OFF;
1246                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1247                         }
1248                         else
1249                         {
1250                                 pLed->BlinkingLedState = RTW_LED_ON;
1251                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1252                         }
1253                         break;
1254
1255                 case LED_BLINK_SCAN:
1256                         pLed->BlinkTimes--;
1257                         if( pLed->BlinkTimes == 0 )
1258                         {
1259                                 bStopBlinking = _TRUE;
1260                         }
1261
1262                         if(bStopBlinking)
1263                         {
1264                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )
1265                                 {
1266                                         SwLedOff(Adapter, pLed);
1267                                 }
1268                                 else if(check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
1269                                 {
1270                                         pLed->bLedLinkBlinkInProgress = _TRUE;
1271                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
1272
1273                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1274                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1275                                 }
1276                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
1277                                 {
1278                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
1279                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
1280                                         if( pLed->bLedOn )
1281                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1282                                         else
1283                                                 pLed->BlinkingLedState = RTW_LED_ON;
1284                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1285                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1286                                 }
1287                                 pLed->BlinkTimes = 0;
1288                                 pLed->bLedBlinkInProgress = _FALSE;
1289                         }
1290                         else
1291                         {
1292                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1293                                 {
1294                                         SwLedOff(Adapter, pLed);
1295                                 }
1296                                 else
1297                                 {
1298                                          if( pLed->bLedOn )
1299                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1300                                         else
1301                                                 pLed->BlinkingLedState = RTW_LED_ON;
1302                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1303                                 }
1304                         }
1305                         break;
1306
1307                 case LED_BLINK_TXRX:
1308                         pLed->BlinkTimes--;
1309                         if( pLed->BlinkTimes == 0 )
1310                         {
1311                                 bStopBlinking = _TRUE;
1312                         }
1313                         if(bStopBlinking)
1314                         {
1315                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1316                                 {
1317                                         SwLedOff(Adapter, pLed);
1318                                 }
1319                                 else
1320                                 {
1321                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
1322                                         if( pLed->bLedOn )
1323                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1324                                         else
1325                                                 pLed->BlinkingLedState = RTW_LED_ON;
1326                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1327                                 }
1328                                 pLed->bLedBlinkInProgress = _FALSE;
1329                         }
1330                         else
1331                         {
1332                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1333                                 {
1334                                         SwLedOff(Adapter, pLed);
1335                                 }
1336                                 else
1337                                 {
1338                                         if( pLed->bLedOn )
1339                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1340                                         else
1341                                                 pLed->BlinkingLedState = RTW_LED_ON;
1342
1343                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1344                                 }
1345                         }
1346                         break;
1347
1348                 case LED_BLINK_WPS:
1349                         if( pLed->bLedOn )
1350                         {
1351                                 pLed->BlinkingLedState = RTW_LED_OFF;
1352                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1353                         }
1354                         else
1355                         {
1356                                 pLed->BlinkingLedState = RTW_LED_ON;
1357                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1358                         }
1359                         break;
1360
1361                 case LED_BLINK_WPS_STOP:        //WPS authentication fail
1362                         if( pLed->bLedOn )
1363                                 pLed->BlinkingLedState = RTW_LED_OFF;
1364                         else
1365                                 pLed->BlinkingLedState = RTW_LED_ON;
1366
1367                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1368                         break;
1369
1370                 case LED_BLINK_WPS_STOP_OVERLAP:        //WPS session overlap
1371                         pLed->BlinkTimes--;
1372                         pLed->BlinkCounter --;
1373                         if(pLed->BlinkCounter == 0)
1374                         {
1375                                 pLed->BlinkingLedState = RTW_LED_OFF;
1376                                 pLed->CurrLedState = RTW_LED_OFF;
1377                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1378                         }
1379                         else
1380                         {
1381                                 if(pLed->BlinkTimes == 0)
1382                                 {
1383                                         if(pLed->bLedOn)
1384                                         {
1385                                                 pLed->BlinkTimes = 1;
1386                                         }
1387                                         else
1388                                         {
1389                                                 bStopBlinking = _TRUE;
1390                                         }
1391                                 }
1392
1393                                 if(bStopBlinking)
1394                                 {
1395                                         pLed->BlinkTimes = 10;
1396                                         pLed->BlinkingLedState = RTW_LED_ON;
1397                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1398                                 }
1399                                 else
1400                                 {
1401                                         if( pLed->bLedOn )
1402                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1403                                         else
1404                                                 pLed->BlinkingLedState = RTW_LED_ON;
1405
1406                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1407                                 }
1408                         }
1409                         break;
1410
1411                 case LED_BLINK_ALWAYS_ON:
1412                         pLed->BlinkTimes--;
1413                         if( pLed->BlinkTimes == 0 )
1414                         {
1415                                 bStopBlinking = _TRUE;
1416                         }
1417                         if(bStopBlinking)
1418                         {
1419                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1420                                 {
1421                                         SwLedOff(Adapter, pLed);
1422                                 }
1423                                 else
1424                                 {
1425                                         if(IS_HARDWARE_TYPE_8812AU(Adapter))
1426                                         {
1427                                                 pLed->BlinkingLedState = RTW_LED_ON;
1428                                                 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
1429                                         }
1430                                         else
1431                                         {
1432                                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1433                                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
1434                                                 if( pLed->bLedOn )
1435                                                         pLed->BlinkingLedState = RTW_LED_OFF;
1436                                                 else
1437                                                         pLed->BlinkingLedState = RTW_LED_ON;
1438                                         }
1439                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1440                                 }
1441                                 pLed->bLedBlinkInProgress = _FALSE;
1442                         }
1443                         else
1444                         {
1445                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1446                                 {
1447                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("RFOff Status \n"));
1448                                         SwLedOff(Adapter, pLed);
1449                                 }
1450                                 else
1451                                 {
1452                                         if(IS_HARDWARE_TYPE_8812AU(Adapter))
1453                                         {
1454                                                 pLed->BlinkingLedState = RTW_LED_ON;
1455                                         }
1456                                         else
1457                                         {
1458                                                 if( pLed->bLedOn )
1459                                                         pLed->BlinkingLedState = RTW_LED_OFF;
1460                                                 else
1461                                                         pLed->BlinkingLedState = RTW_LED_ON;
1462                                         }
1463                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1464                                 }
1465                         }
1466                         break;
1467
1468                 case LED_BLINK_LINK_IN_PROCESS:
1469                         if( pLed->bLedOn )
1470                         {
1471                                 pLed->BlinkingLedState = RTW_LED_OFF;
1472                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ON_BELKIN);
1473                         }
1474                         else
1475                         {
1476                                 pLed->BlinkingLedState = RTW_LED_ON;
1477                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_OFF_BELKIN);
1478                         }
1479                         break;
1480
1481                 case LED_BLINK_AUTH_ERROR:
1482                         pLed->BlinkTimes--;
1483                         if( pLed->BlinkTimes == 0 )
1484                         {
1485                                 bStopBlinking = _TRUE;
1486                         }
1487                         if(bStopBlinking == _FALSE)
1488                         {
1489                                 if( pLed->bLedOn )
1490                                 {
1491                                         pLed->BlinkingLedState = RTW_LED_OFF;
1492                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1493                                 }
1494                                 else
1495                                 {
1496                                         pLed->BlinkingLedState = RTW_LED_ON;
1497                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1498                                 }
1499                         }
1500                         else
1501                         {
1502                                 pLed->CurrLedState = RTW_LED_OFF;
1503                                 pLed->BlinkingLedState = RTW_LED_OFF;
1504                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1505                         }
1506                         break;
1507
1508                 default:
1509                         break;
1510         }
1511
1512         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink9 CurrLedState %d\n", pLed->CurrLedState));
1513 }
1514
1515 //page added for Netgear A6200V2. 20120827
1516 void
1517 SwLedBlink10(
1518         PLED_USB                        pLed
1519         )
1520 {
1521         PADAPTER Adapter = pLed->padapter;
1522         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);
1523         BOOLEAN bStopBlinking = _FALSE;
1524
1525         // Change LED according to BlinkingLedState specified.
1526         if( pLed->BlinkingLedState == RTW_LED_ON )
1527         {
1528                 SwLedOn(Adapter, pLed);
1529                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
1530         }
1531         else
1532         {
1533                 SwLedOff(Adapter, pLed);
1534                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
1535         }
1536
1537
1538         switch(pLed->CurrLedState)
1539         {
1540                 case RTW_LED_ON:
1541                         SwLedOn(Adapter, pLed);
1542                         break;
1543
1544                 case RTW_LED_OFF:
1545                         SwLedOff(Adapter, pLed);
1546                         break;
1547
1548                 case LED_BLINK_SLOWLY:
1549                         if( pLed->bLedOn )
1550                                 pLed->BlinkingLedState = RTW_LED_OFF;
1551                         else
1552                                 pLed->BlinkingLedState = RTW_LED_ON;
1553                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1554                         break;
1555
1556                 case LED_BLINK_StartToBlink:
1557                         if( pLed->bLedOn )
1558                         {
1559                                 pLed->BlinkingLedState = RTW_LED_OFF;
1560                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
1561                         }
1562                         else
1563                         {
1564                                 pLed->BlinkingLedState = RTW_LED_ON;
1565                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1566                         }
1567                         break;
1568
1569                 case LED_BLINK_SCAN:
1570                         pLed->BlinkTimes--;
1571                         if( pLed->BlinkTimes == 0 )
1572                         {
1573                                 bStopBlinking = _TRUE;
1574                         }
1575
1576                         if(bStopBlinking)
1577                         {
1578                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )
1579                                 {
1580                                         SwLedOff(Adapter, pLed);
1581                                 }
1582                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
1583                                 {
1584                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
1585                                         pLed->CurrLedState = RTW_LED_OFF;
1586                                         pLed->BlinkingLedState = RTW_LED_OFF;
1587
1588                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1589                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
1590                                 }
1591                                 pLed->BlinkTimes = 0;
1592                                 pLed->bLedBlinkInProgress = _FALSE;
1593                         }
1594                         else
1595                         {
1596                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1597                                 {
1598                                         SwLedOff(Adapter, pLed);
1599                                 }
1600                                 else
1601                                 {
1602                                         if( pLed->bLedOn )
1603                                         {
1604                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1605                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1606                                         }
1607                                         else
1608                                         {
1609                                                 pLed->BlinkingLedState = RTW_LED_ON;
1610                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_SLOWLY_INTERVAL_NETGEAR+LED_BLINK_LINK_INTERVAL_NETGEAR);
1611                                         }
1612                                 }
1613                         }
1614                         break;
1615
1616                 case LED_BLINK_WPS:
1617                         if( pLed->bLedOn )
1618                         {
1619                                 pLed->BlinkingLedState = RTW_LED_OFF;
1620                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
1621                         }
1622                         else
1623                         {
1624                                 pLed->BlinkingLedState = RTW_LED_ON;
1625                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL+LED_BLINK_LINK_INTERVAL_NETGEAR);
1626                         }
1627                         break;
1628
1629                 case LED_BLINK_WPS_STOP:        //WPS authentication fail
1630                         if( pLed->bLedOn )
1631                                 pLed->BlinkingLedState = RTW_LED_OFF;
1632                         else
1633                                 pLed->BlinkingLedState = RTW_LED_ON;
1634
1635                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1636                         break;
1637
1638                 case LED_BLINK_WPS_STOP_OVERLAP:        //WPS session overlap
1639                         pLed->BlinkTimes--;
1640                         pLed->BlinkCounter --;
1641                         if(pLed->BlinkCounter == 0)
1642                         {
1643                                 pLed->BlinkingLedState = RTW_LED_OFF;
1644                                 pLed->CurrLedState = RTW_LED_OFF;
1645                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1646                         }
1647                         else
1648                         {
1649                                 if(pLed->BlinkTimes == 0)
1650                                 {
1651                                         if(pLed->bLedOn)
1652                                         {
1653                                                 pLed->BlinkTimes = 1;
1654                                         }
1655                                         else
1656                                         {
1657                                                 bStopBlinking = _TRUE;
1658                                         }
1659                                 }
1660
1661                                 if(bStopBlinking)
1662                                 {
1663                                         pLed->BlinkTimes = 10;
1664                                         pLed->BlinkingLedState = RTW_LED_ON;
1665                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
1666                                 }
1667                                 else
1668                                 {
1669                                         if( pLed->bLedOn )
1670                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1671                                         else
1672                                                 pLed->BlinkingLedState = RTW_LED_ON;
1673
1674                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
1675                                 }
1676                         }
1677                         break;
1678
1679                 case LED_BLINK_ALWAYS_ON:
1680                         pLed->BlinkTimes--;
1681                         if( pLed->BlinkTimes == 0 )
1682                         {
1683                                 bStopBlinking = _TRUE;
1684                         }
1685                         if(bStopBlinking)
1686                         {
1687                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1688                                 {
1689                                         SwLedOff(Adapter, pLed);
1690                                 }
1691                                 else
1692                                 {
1693                                         if(IS_HARDWARE_TYPE_8812AU(Adapter))
1694                                         {
1695                                                 pLed->BlinkingLedState = RTW_LED_ON;
1696                                                 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
1697                                         }
1698                                         else
1699                                         {
1700                                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;
1701                                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
1702                                                 if( pLed->bLedOn )
1703                                                         pLed->BlinkingLedState = RTW_LED_OFF;
1704                                                 else
1705                                                         pLed->BlinkingLedState = RTW_LED_ON;
1706                                         }
1707                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1708                                 }
1709                                 pLed->bLedBlinkInProgress = _FALSE;
1710                         }
1711                         else
1712                         {
1713                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1714                                 {
1715                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("RFOff Status \n"));
1716                                         SwLedOff(Adapter, pLed);
1717                                 }
1718                                 else
1719                                 {
1720                                         if(IS_HARDWARE_TYPE_8812AU(Adapter))
1721                                         {
1722                                                 pLed->BlinkingLedState = RTW_LED_ON;
1723                                         }
1724                                         else
1725                                         {
1726                                                 if( pLed->bLedOn )
1727                                                         pLed->BlinkingLedState = RTW_LED_OFF;
1728                                                 else
1729                                                         pLed->BlinkingLedState = RTW_LED_ON;
1730                                         }
1731                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1732                                 }
1733                         }
1734                         break;
1735
1736                 case LED_BLINK_LINK_IN_PROCESS:
1737                         if( pLed->bLedOn )
1738                         {
1739                                 pLed->BlinkingLedState = RTW_LED_OFF;
1740                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ON_BELKIN);
1741                         }
1742                         else
1743                         {
1744                                 pLed->BlinkingLedState = RTW_LED_ON;
1745                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_OFF_BELKIN);
1746                         }
1747                         break;
1748
1749                 case LED_BLINK_AUTH_ERROR:
1750                         pLed->BlinkTimes--;
1751                         if( pLed->BlinkTimes == 0 )
1752                         {
1753                                 bStopBlinking = _TRUE;
1754                         }
1755                         if(bStopBlinking == _FALSE)
1756                         {
1757                                 if( pLed->bLedOn )
1758                                 {
1759                                         pLed->BlinkingLedState = RTW_LED_OFF;
1760                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1761                                 }
1762                                 else
1763                                 {
1764                                         pLed->BlinkingLedState = RTW_LED_ON;
1765                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1766                                 }
1767                         }
1768                         else
1769                         {
1770                                 pLed->CurrLedState = RTW_LED_OFF;
1771                                 pLed->BlinkingLedState = RTW_LED_OFF;
1772                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);
1773                         }
1774                         break;
1775
1776                 default:
1777                         break;
1778         }
1779
1780         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink10 CurrLedState %d\n", pLed->CurrLedState));
1781
1782 }
1783
1784 void
1785 SwLedBlink11(
1786         PLED_USB                        pLed
1787         )
1788 {
1789         PADAPTER Adapter = pLed->padapter;
1790         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);
1791         BOOLEAN bStopBlinking = _FALSE;
1792
1793         // Change LED according to BlinkingLedState specified.
1794         if( pLed->BlinkingLedState == RTW_LED_ON )
1795         {
1796                 SwLedOn(Adapter, pLed);
1797                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
1798         }
1799         else
1800         {
1801                 SwLedOff(Adapter, pLed);
1802                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
1803         }
1804
1805         switch(pLed->CurrLedState)
1806         {
1807                 case LED_BLINK_TXRX:
1808                         if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1809                         {
1810                                 SwLedOff(Adapter, pLed);
1811                         }
1812                         else
1813                         {
1814                                  if( pLed->bLedOn )
1815                                         pLed->BlinkingLedState = RTW_LED_OFF;
1816                                 else
1817                                         pLed->BlinkingLedState = RTW_LED_ON;
1818                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1819                         }
1820
1821                         break;
1822
1823                 case LED_BLINK_WPS:
1824                         if(pLed->BlinkTimes == 5)
1825                         {
1826                                 SwLedOn(Adapter, pLed);
1827                                 _set_timer(&(pLed->BlinkTimer), LED_CM11_LINK_ON_INTERVEL);
1828                         }
1829                         else
1830                         {
1831                                 if( pLed->bLedOn )
1832                                 {
1833                                         pLed->BlinkingLedState = RTW_LED_OFF;
1834                                         _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
1835                                 }
1836                                 else
1837                                 {
1838                                         pLed->BlinkingLedState = RTW_LED_ON;
1839                                         _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);
1840                                 }
1841                         }
1842                         pLed->BlinkTimes--;
1843                         if( pLed->BlinkTimes == 0 )
1844                         {
1845                                 bStopBlinking = _TRUE;
1846                         }
1847                         if(bStopBlinking == _TRUE)
1848                                 pLed->BlinkTimes = 5;
1849                         break;
1850
1851                 case LED_BLINK_WPS_STOP:        //WPS authentication fail
1852                         if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
1853                         {
1854                                 if( pLed->bLedOn )
1855                                         pLed->BlinkingLedState = RTW_LED_OFF;
1856                                 else
1857                                         pLed->BlinkingLedState = RTW_LED_ON;
1858                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
1859                         }
1860                         else
1861                         {
1862                                 pLed->CurrLedState = RTW_LED_ON;
1863                                 pLed->BlinkingLedState = RTW_LED_ON;
1864                                 SwLedOn(Adapter, pLed);
1865                                 _set_timer(&(pLed->BlinkTimer), 0);
1866                         }
1867                         break;
1868
1869                 default:
1870                         break;
1871         }
1872
1873         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink5 CurrLedState %d\n", pLed->CurrLedState));
1874 }
1875
1876 void
1877 SwLedBlink12(
1878         PLED_USB                        pLed
1879         )
1880 {
1881         PADAPTER Adapter = pLed->padapter;
1882         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);
1883         BOOLEAN bStopBlinking = _FALSE;
1884
1885         // Change LED according to BlinkingLedState specified.
1886         if( pLed->BlinkingLedState == RTW_LED_ON )
1887         {
1888                 SwLedOn(Adapter, pLed);
1889                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%ld): turn on\n", pLed->BlinkTimes));
1890         }
1891         else
1892         {
1893                 SwLedOff(Adapter, pLed);
1894                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%ld): turn off\n", pLed->BlinkTimes));
1895         }
1896
1897         switch(pLed->CurrLedState)
1898         {
1899                 case LED_BLINK_SLOWLY:
1900                         if( pLed->bLedOn )
1901                                 pLed->BlinkingLedState = RTW_LED_OFF;
1902                         else
1903                                 pLed->BlinkingLedState = RTW_LED_ON;
1904                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1905                         break;
1906
1907                 case LED_BLINK_TXRX:
1908                         pLed->BlinkTimes--;
1909                         if( pLed->BlinkTimes == 0 )
1910                         {
1911                                 bStopBlinking = _TRUE;
1912                         }
1913
1914                         if(bStopBlinking)
1915                         {
1916                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1917                                 {
1918                                         pLed->CurrLedState = RTW_LED_OFF;
1919                                         pLed->BlinkingLedState = RTW_LED_OFF;
1920                                         if(pLed->bLedOn)
1921                                                 SwLedOff(Adapter, pLed);
1922                                 }
1923                                 else
1924                                 {
1925                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
1926                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
1927                                         if( pLed->bLedOn )
1928                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1929                                         else
1930                                                 pLed->BlinkingLedState = RTW_LED_ON;
1931                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
1932                                 }
1933
1934                                 pLed->bLedBlinkInProgress = _FALSE;
1935                         }
1936                         else
1937                         {
1938                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
1939                                 {
1940                                         SwLedOff(Adapter, pLed);
1941                                 }
1942                                 else
1943                                 {
1944                                          if( pLed->bLedOn )
1945                                                 pLed->BlinkingLedState = RTW_LED_OFF;
1946                                         else
1947                                                 pLed->BlinkingLedState = RTW_LED_ON;
1948                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
1949                                 }
1950                         }
1951                         break;
1952
1953                 default:
1954                         break;
1955         }
1956
1957         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink8 CurrLedState %d\n", pLed->CurrLedState));
1958
1959
1960 }
1961
1962 VOID
1963 SwLedBlink13(
1964         IN PLED_USB                     pLed
1965         )
1966 {
1967         PADAPTER Adapter = pLed->padapter;
1968         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);
1969         BOOLEAN bStopBlinking = _FALSE;
1970         static u8       LinkBlinkCnt=0;
1971
1972         // Change LED according to BlinkingLedState specified.
1973         if( pLed->BlinkingLedState == RTW_LED_ON )
1974         {
1975                 SwLedOn(Adapter, pLed);
1976                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
1977         }
1978         else
1979         {
1980                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)
1981                         SwLedOff(Adapter, pLed);
1982                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
1983         }
1984         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("!!! SwLedBlink13 CurrLedState %d, bLedWPSBlinkInProgress %d, bLedBlinkInProgress %d\n", pLed->CurrLedState,pLed->bLedWPSBlinkInProgress,pLed->bLedBlinkInProgress));
1985         switch(pLed->CurrLedState)
1986         {
1987                 case LED_BLINK_LINK_IN_PROCESS:
1988                         if(!pLed->bLedWPSBlinkInProgress)
1989                                 LinkBlinkCnt++;
1990
1991                         if(LinkBlinkCnt>15)
1992                         {
1993                                 LinkBlinkCnt=0;
1994                                 pLed->bLedBlinkInProgress = _FALSE;
1995                                 break;
1996                         }
1997                         if( pLed->bLedOn )
1998                         {
1999                                 pLed->BlinkingLedState = RTW_LED_OFF;
2000                                 _set_timer(&(pLed->BlinkTimer), 500);
2001                         }
2002                         else
2003                         {
2004                                 pLed->BlinkingLedState = RTW_LED_ON;
2005                                 _set_timer(&(pLed->BlinkTimer), 500);
2006                         }
2007
2008                         break;
2009
2010                 case LED_BLINK_WPS:
2011                         if( pLed->bLedOn )
2012                         {
2013                                 pLed->BlinkingLedState = RTW_LED_OFF;
2014                                 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
2015                         }
2016                         else
2017                         {
2018                                 pLed->BlinkingLedState = RTW_LED_ON;
2019                                 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
2020                         }
2021
2022                         break;
2023
2024                 case LED_BLINK_WPS_STOP:        //WPS success
2025                         SwLedOff(Adapter, pLed);
2026                         pLed->bLedWPSBlinkInProgress = _FALSE;
2027                         break;
2028
2029                 default:
2030                         LinkBlinkCnt=0;
2031                         break;
2032         }
2033
2034         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink13\n"));
2035
2036 }
2037
2038 VOID
2039 SwLedBlink14(
2040         IN PLED_USB                     pLed
2041         )
2042 {
2043         PADAPTER Adapter = pLed->padapter;
2044         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);
2045         BOOLEAN bStopBlinking = _FALSE;
2046         static u8       LinkBlinkCnt=0;
2047
2048         // Change LED according to BlinkingLedState specified.
2049         if( pLed->BlinkingLedState == RTW_LED_ON )
2050         {
2051                 SwLedOn(Adapter, pLed);
2052                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
2053         }
2054         else
2055         {
2056                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)
2057                         SwLedOff(Adapter, pLed);
2058                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
2059         }
2060         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("!!! SwLedBlink14 CurrLedState %d, bLedWPSBlinkInProgress %d, bLedBlinkInProgress %d\n", pLed->CurrLedState,pLed->bLedWPSBlinkInProgress,pLed->bLedBlinkInProgress));
2061         switch(pLed->CurrLedState)
2062         {
2063                 case LED_BLINK_TXRX:
2064                         pLed->BlinkTimes--;
2065                         if( pLed->BlinkTimes == 0 )
2066                         {
2067                                 bStopBlinking = _TRUE;
2068                         }
2069                         if(bStopBlinking)
2070                         {
2071                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
2072                                 {
2073                                         SwLedOff(Adapter, pLed);
2074                                 }
2075                                 else
2076                                 {
2077                                         SwLedOn(Adapter, pLed);
2078                                 }
2079                                 pLed->bLedBlinkInProgress = _FALSE;
2080                         }
2081                         else
2082                         {
2083                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
2084                                 {
2085                                         SwLedOff(Adapter, pLed);
2086                                 }
2087                                 else
2088                                 {
2089                                         if( pLed->bLedOn )
2090                                         {
2091                                                 pLed->BlinkingLedState = RTW_LED_OFF;
2092                                                 if (IS_HARDWARE_TYPE_8812AU(Adapter))
2093                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
2094                                                 else
2095                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2096                                         }
2097                                         else
2098                                         {
2099                                                 pLed->BlinkingLedState = RTW_LED_ON;
2100                                                 if (IS_HARDWARE_TYPE_8812AU(Adapter))
2101                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2102                                                 else
2103                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2104                                         }
2105                                 }
2106                         }
2107
2108                         break;
2109
2110                 default:
2111                         LinkBlinkCnt=0;
2112                         break;
2113         }
2114
2115         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink14\n"));
2116 }
2117
2118 VOID
2119 SwLedBlink15(
2120         IN PLED_USB                     pLed
2121         )
2122 {
2123         PADAPTER Adapter = pLed->padapter;
2124         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);
2125         BOOLEAN bStopBlinking = _FALSE;
2126         static u8       LinkBlinkCnt=0;
2127         // Change LED according to BlinkingLedState specified.
2128
2129         if( pLed->BlinkingLedState == RTW_LED_ON )
2130         {
2131                 SwLedOn(Adapter, pLed);
2132                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));
2133         }
2134         else
2135         {
2136                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)
2137                         SwLedOff(Adapter, pLed);
2138                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));
2139         }
2140         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("!!! SwLedBlink15 CurrLedState %d, bLedWPSBlinkInProgress %d, bLedBlinkInProgress %d\n", pLed->CurrLedState,pLed->bLedWPSBlinkInProgress,pLed->bLedBlinkInProgress));
2141         switch(pLed->CurrLedState)
2142         {
2143                 case LED_BLINK_WPS:
2144                         if( pLed->bLedOn )
2145                         {
2146                                 pLed->BlinkingLedState = RTW_LED_OFF;
2147                                 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_DLINK);
2148                         }
2149                         else
2150                         {
2151                                 pLed->BlinkingLedState = RTW_LED_ON;
2152                                 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_DLINK);
2153                         }
2154                         break;
2155
2156                 case LED_BLINK_WPS_STOP:        //WPS success
2157                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("blink15, LED_BLINK_WPS_STOP  BlinkingLedState %d\n",pLed->BlinkingLedState));
2158
2159                         if(pLed->BlinkingLedState == RTW_LED_OFF)
2160                         {
2161                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2162                                 return;
2163                         }
2164
2165                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
2166                         pLed->BlinkingLedState = RTW_LED_OFF;
2167
2168                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_LINKED_ON_INTERVAL_DLINK);
2169                         break;
2170
2171                 case LED_BLINK_NO_LINK:
2172                         {
2173                                 static BOOLEAN          bLedOn=_TRUE;
2174                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("blink15, LED_NO_LINK_BLINK  bLedOn %d\n",bLedOn));
2175                                 if(bLedOn)
2176                                 {
2177                                         bLedOn=_FALSE;
2178                                         pLed->BlinkingLedState = RTW_LED_OFF;
2179                                 }
2180                                 else
2181                                 {
2182                                         bLedOn=_TRUE;
2183                                         pLed->BlinkingLedState = RTW_LED_ON;
2184                                 }
2185                                 pLed->bLedBlinkInProgress = _TRUE;
2186                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL);
2187                         }
2188                         break;
2189
2190                 case LED_BLINK_LINK_IDEL:
2191                         {
2192                                 static BOOLEAN          bLedOn=_TRUE;
2193                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("blink15, LED_BLINK_LINK_IDEL  bLedOn %d\n",bLedOn));
2194                                 if(bLedOn)
2195                                 {
2196                                         bLedOn=_FALSE;
2197                                         pLed->BlinkingLedState = RTW_LED_OFF;
2198                                 }
2199                                 else
2200                                 {
2201                                         bLedOn=_TRUE;
2202                                         pLed->BlinkingLedState = RTW_LED_ON;
2203
2204                                 }
2205                                 pLed->bLedBlinkInProgress = _TRUE;
2206                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_IDEL_INTERVAL);
2207                         }
2208                         break;
2209
2210                 case LED_BLINK_SCAN:
2211                         {
2212                                 static u8       BlinkTime=0;
2213                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("blink15, LED_SCAN_BLINK  bLedOn %d\n",BlinkTime));
2214                                 if(BlinkTime %2==0)
2215                                 {
2216                                         pLed->BlinkingLedState = RTW_LED_ON;
2217                                 }
2218                                 else
2219                                 {
2220                                         pLed->BlinkingLedState = RTW_LED_OFF;
2221                                 }
2222                                 BlinkTime ++;
2223
2224                                 if(BlinkTime<24)
2225                                 {
2226                                         pLed->bLedBlinkInProgress = _TRUE;
2227
2228                                         if(pLed->BlinkingLedState == RTW_LED_ON)
2229                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_OFF_INTERVAL);
2230                                         else
2231                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_ON_INTERVAL);
2232                                 }
2233                                 else
2234                                 {
2235                                         //if(pLed->OLDLedState ==LED_NO_LINK_BLINK)
2236                                         if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)
2237                                         {
2238                                                 pLed->CurrLedState = LED_BLINK_NO_LINK;
2239                                                 pLed->BlinkingLedState = RTW_LED_ON;
2240
2241                                                 _set_timer(&(pLed->BlinkTimer), 100);
2242                                         }
2243                                         BlinkTime =0;
2244                                 }
2245                         }
2246                         break;
2247
2248                 case LED_BLINK_TXRX:
2249                         pLed->BlinkTimes--;
2250                         if( pLed->BlinkTimes == 0 )
2251                         {
2252                                 bStopBlinking = _TRUE;
2253                         }
2254                         if(bStopBlinking)
2255                         {
2256                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
2257                                 {
2258                                         SwLedOff(Adapter, pLed);
2259                                 }
2260                                 else
2261                                 {
2262                                         SwLedOn(Adapter, pLed);
2263                                 }
2264                                 pLed->bLedBlinkInProgress = _FALSE;
2265                         }
2266                         else
2267                         {
2268                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)
2269                                 {
2270                                         SwLedOff(Adapter, pLed);
2271                                 }
2272                                 else
2273                                 {
2274                                         if( pLed->bLedOn )
2275                                                 pLed->BlinkingLedState = RTW_LED_OFF;
2276                                         else
2277                                                 pLed->BlinkingLedState = RTW_LED_ON;
2278                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2279                                 }
2280                         }
2281                         break;
2282
2283                 default:
2284                         LinkBlinkCnt=0;
2285                         break;
2286         }
2287
2288         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink15\n"));
2289 }
2290
2291 //
2292 //      Description:
2293 //              Handler function of LED Blinking.
2294 //              We dispatch acture LED blink action according to LedStrategy.
2295 //
2296 void BlinkHandler(PLED_USB pLed)
2297 {
2298         _adapter                *padapter = pLed->padapter;
2299         struct led_priv *ledpriv = &(padapter->ledpriv);
2300
2301         //DBG_871X("%s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
2302
2303         if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
2304                 /*DBG_871X("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
2305                 , __func__
2306                 , rtw_is_drv_stopped(padapter)?"True":"False"
2307                 , rtw_is_surprise_removed(padapter)?"True":"False" );*/
2308                 return;
2309         }
2310
2311         switch(ledpriv->LedStrategy)
2312         {
2313                 case SW_LED_MODE0:
2314                         SwLedBlink(pLed);
2315                         break;
2316
2317                 case SW_LED_MODE1:
2318                         SwLedBlink1(pLed);
2319                         break;
2320
2321                 case SW_LED_MODE2:
2322                         SwLedBlink2(pLed);
2323                         break;
2324
2325                 case SW_LED_MODE3:
2326                         SwLedBlink3(pLed);
2327                         break;
2328
2329                 case SW_LED_MODE4:
2330                         SwLedBlink4(pLed);
2331                         break;
2332
2333                 case SW_LED_MODE5:
2334                         SwLedBlink5(pLed);
2335                         break;
2336
2337                 case SW_LED_MODE6:
2338                         SwLedBlink6(pLed);
2339                         break;
2340
2341                 case SW_LED_MODE7:
2342                         SwLedBlink7(pLed);
2343                         break;
2344
2345                 case SW_LED_MODE8:
2346                         SwLedBlink8(pLed);
2347                         break;
2348
2349                 case SW_LED_MODE9:
2350                         SwLedBlink9(pLed);
2351                         break;
2352
2353                 case SW_LED_MODE10:
2354                         SwLedBlink10(pLed);
2355                         break;
2356
2357                 case SW_LED_MODE11:
2358                         SwLedBlink11(pLed);
2359                         break;
2360
2361                 case SW_LED_MODE12:
2362                         SwLedBlink12(pLed);
2363                         break;
2364
2365                 case SW_LED_MODE13:
2366                         SwLedBlink13(pLed);
2367                         break;
2368
2369                 case SW_LED_MODE14:
2370                         SwLedBlink14(pLed);
2371                         break;
2372
2373                 case SW_LED_MODE15:
2374                         SwLedBlink15(pLed);
2375                         break;
2376
2377                 default:
2378                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("BlinkWorkItemCallback 0x%x \n", ledpriv->LedStrategy));
2379                         //SwLedBlink(pLed);
2380                         break;
2381         }
2382 }
2383
2384 //
2385 //      Description:
2386 //              Callback function of LED BlinkTimer,
2387 //              it just schedules to corresponding BlinkWorkItem/led_blink_hdl
2388 //
2389 void BlinkTimerCallback(void *data)
2390 {
2391         PLED_USB         pLed = (PLED_USB)data;
2392         _adapter                *padapter = pLed->padapter;
2393
2394         //DBG_871X("%s\n", __FUNCTION__);
2395
2396         if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
2397                 /*DBG_871X("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
2398                         , __func__
2399                         , rtw_is_drv_stopped(padapter)?"True":"False"
2400                         , rtw_is_surprise_removed(padapter)?"True":"False" );*/
2401                 return;
2402         }
2403
2404         #ifdef CONFIG_LED_HANDLED_BY_CMD_THREAD
2405         rtw_led_blink_cmd(padapter, (PVOID)pLed);
2406         #else
2407         if(ATOMIC_READ(&pLed->bCancelWorkItem) == _FALSE)
2408                 _set_workitem(&(pLed->BlinkWorkItem));
2409         #endif
2410 }
2411
2412 //
2413 //      Description:
2414 //              Callback function of LED BlinkWorkItem.
2415 //              We dispatch acture LED blink action according to LedStrategy.
2416 //
2417 void BlinkWorkItemCallback(_workitem *work)
2418 {
2419         PLED_USB         pLed = container_of(work, LED_USB, BlinkWorkItem);
2420         BlinkHandler(pLed);
2421 }
2422
2423 static void
2424 SwLedControlMode0(
2425         _adapter                *padapter,
2426         LED_CTL_MODE            LedAction
2427 )
2428 {
2429         struct led_priv *ledpriv = &(padapter->ledpriv);
2430         PLED_USB        pLed = &(ledpriv->SwLed1);
2431
2432         // Decide led state
2433         switch(LedAction)
2434         {
2435         case LED_CTL_TX:
2436         case LED_CTL_RX:
2437                 if( pLed->bLedBlinkInProgress == _FALSE )
2438                 {
2439                         pLed->bLedBlinkInProgress = _TRUE;
2440
2441                         pLed->CurrLedState = LED_BLINK_NORMAL;
2442                         pLed->BlinkTimes = 2;
2443
2444                         if( pLed->bLedOn )
2445                                 pLed->BlinkingLedState = RTW_LED_OFF;
2446                         else
2447                                 pLed->BlinkingLedState = RTW_LED_ON;
2448                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
2449                 }
2450                 break;
2451
2452         case LED_CTL_START_TO_LINK:
2453                 if( pLed->bLedBlinkInProgress == _FALSE )
2454                 {
2455                         pLed->bLedBlinkInProgress = _TRUE;
2456
2457                         pLed->CurrLedState = LED_BLINK_StartToBlink;
2458                         pLed->BlinkTimes = 24;
2459
2460                         if( pLed->bLedOn )
2461                                 pLed->BlinkingLedState = RTW_LED_OFF;
2462                         else
2463                                 pLed->BlinkingLedState = RTW_LED_ON;
2464                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
2465                 }
2466                 else
2467                 {
2468                         pLed->CurrLedState = LED_BLINK_StartToBlink;
2469                 }
2470                 break;
2471
2472         case LED_CTL_LINK:
2473                 pLed->CurrLedState = RTW_LED_ON;
2474                 if( pLed->bLedBlinkInProgress == _FALSE )
2475                 {
2476                         pLed->BlinkingLedState = RTW_LED_ON;
2477                         _set_timer(&(pLed->BlinkTimer), 0);
2478                 }
2479                 break;
2480
2481         case LED_CTL_NO_LINK:
2482                 pLed->CurrLedState = RTW_LED_OFF;
2483                 if( pLed->bLedBlinkInProgress == _FALSE )
2484                 {
2485                         pLed->BlinkingLedState = RTW_LED_OFF;
2486                         _set_timer(&(pLed->BlinkTimer), 0);
2487                 }
2488                 break;
2489
2490         case LED_CTL_POWER_OFF:
2491                 pLed->CurrLedState = RTW_LED_OFF;
2492                 if(pLed->bLedBlinkInProgress)
2493                 {
2494                         _cancel_timer_ex(&(pLed->BlinkTimer));
2495                         pLed->bLedBlinkInProgress = _FALSE;
2496                 }
2497                 SwLedOff(padapter, pLed);
2498                 break;
2499
2500         case LED_CTL_START_WPS:
2501                 if( pLed->bLedBlinkInProgress == _FALSE || pLed->CurrLedState == RTW_LED_ON)
2502                 {
2503                         pLed->bLedBlinkInProgress = _TRUE;
2504
2505                         pLed->CurrLedState = LED_BLINK_WPS;
2506                         pLed->BlinkTimes = 20;
2507
2508                         if( pLed->bLedOn )
2509                         {
2510                                 pLed->BlinkingLedState = RTW_LED_OFF;
2511                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
2512                         }
2513                         else
2514                         {
2515                                 pLed->BlinkingLedState = RTW_LED_ON;
2516                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);
2517                         }
2518                 }
2519                 break;
2520
2521         case LED_CTL_STOP_WPS:
2522                 if(pLed->bLedBlinkInProgress)
2523                 {
2524                         pLed->CurrLedState = RTW_LED_OFF;
2525                         _cancel_timer_ex(&(pLed->BlinkTimer));
2526                         pLed->bLedBlinkInProgress = _FALSE;
2527                 }
2528                 break;
2529
2530
2531         default:
2532                 break;
2533         }
2534
2535         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));
2536
2537 }
2538
2539  //ALPHA, added by chiyoko, 20090106
2540 static void
2541 SwLedControlMode1(
2542         _adapter                *padapter,
2543         LED_CTL_MODE            LedAction
2544 )
2545 {
2546         struct led_priv         *ledpriv = &(padapter->ledpriv);
2547         PLED_USB                        pLed = &(ledpriv->SwLed0);
2548         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);
2549         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(padapter);
2550
2551         u32 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA; //add by ylb 20121012 for customer led for alpha
2552         if(pHalData->CustomerID == RT_CID_819x_ALPHA_Dlink)
2553                 uLedBlinkNoLinkInterval= LED_BLINK_NO_LINK_INTERVAL_ALPHA_500MS;
2554
2555         if(pHalData->CustomerID == RT_CID_819x_CAMEO)
2556                 pLed = &(ledpriv->SwLed1);
2557
2558         switch(LedAction)
2559         {
2560                 case LED_CTL_POWER_ON:
2561                 case LED_CTL_START_TO_LINK:
2562                 case LED_CTL_NO_LINK:
2563                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )
2564                         {
2565                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2566                                 {
2567                                         return;
2568                                 }
2569                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )
2570                                 {
2571                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2572                                         pLed->bLedLinkBlinkInProgress = _FALSE;
2573                                 }
2574                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2575                                 {
2576                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2577                                         pLed->bLedBlinkInProgress = _FALSE;
2578                                 }
2579
2580                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;
2581                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
2582                                 if( pLed->bLedOn )
2583                                         pLed->BlinkingLedState = RTW_LED_OFF;
2584                                 else
2585                                         pLed->BlinkingLedState = RTW_LED_ON;
2586                                 _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);//change by ylb 20121012 for customer led for alpha
2587                         }
2588                         break;
2589
2590                 case LED_CTL_LINK:
2591                         if( pLed->bLedLinkBlinkInProgress == _FALSE )
2592                         {
2593                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2594                                 {
2595                                         return;
2596                                 }
2597                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
2598                                 {
2599                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2600                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
2601                                 }
2602                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2603                                 {
2604                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2605                                         pLed->bLedBlinkInProgress = _FALSE;
2606                                 }
2607                                 pLed->bLedLinkBlinkInProgress = _TRUE;
2608                                 pLed->CurrLedState = LED_BLINK_NORMAL;
2609                                 if( pLed->bLedOn )
2610                                         pLed->BlinkingLedState = RTW_LED_OFF;
2611                                 else
2612                                         pLed->BlinkingLedState = RTW_LED_ON;
2613                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
2614                         }
2615                         break;
2616
2617                 case LED_CTL_SITE_SURVEY:
2618                          if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
2619                                 ;
2620                          else if(pLed->bLedScanBlinkInProgress ==_FALSE)
2621                          {
2622                                 if(IS_LED_WPS_BLINKING(pLed))
2623                                         return;
2624
2625                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
2626                                 {
2627                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2628                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
2629                                 }
2630                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )
2631                                 {
2632                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2633                                          pLed->bLedLinkBlinkInProgress = _FALSE;
2634                                 }
2635                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2636                                 {
2637                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2638                                         pLed->bLedBlinkInProgress = _FALSE;
2639                                 }
2640                                 pLed->bLedScanBlinkInProgress = _TRUE;
2641                                 pLed->CurrLedState = LED_BLINK_SCAN;
2642                                 pLed->BlinkTimes = 24;
2643                                 if( pLed->bLedOn )
2644                                         pLed->BlinkingLedState = RTW_LED_OFF;
2645                                 else
2646                                         pLed->BlinkingLedState = RTW_LED_ON;
2647
2648                                 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason == RF_CHANGE_BY_IPS)
2649                                         _set_timer(&(pLed->BlinkTimer), LED_INITIAL_INTERVAL);
2650                                 else
2651                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2652
2653                          }
2654                         break;
2655
2656                 case LED_CTL_TX:
2657                 case LED_CTL_RX:
2658                         if(pLed->bLedBlinkInProgress ==_FALSE)
2659                         {
2660                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2661                                 {
2662                                         return;
2663                                 }
2664                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
2665                                 {
2666                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2667                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
2668                                 }
2669                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )
2670                                 {
2671                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2672                                         pLed->bLedLinkBlinkInProgress = _FALSE;
2673                                 }
2674                                 pLed->bLedBlinkInProgress = _TRUE;
2675                                 pLed->CurrLedState = LED_BLINK_TXRX;
2676                                 pLed->BlinkTimes = 2;
2677                                 if( pLed->bLedOn )
2678                                         pLed->BlinkingLedState = RTW_LED_OFF;
2679                                 else
2680                                         pLed->BlinkingLedState = RTW_LED_ON;
2681                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2682                         }
2683                         break;
2684
2685                 case LED_CTL_START_WPS: //wait until xinpin finish
2686                 case LED_CTL_START_WPS_BOTTON:
2687                          if(pLed->bLedWPSBlinkInProgress ==_FALSE)
2688                          {
2689                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
2690                                 {
2691                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2692                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
2693                                 }
2694                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )
2695                                 {
2696                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2697                                          pLed->bLedLinkBlinkInProgress = _FALSE;
2698                                 }
2699                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2700                                 {
2701                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2702                                         pLed->bLedBlinkInProgress = _FALSE;
2703                                 }
2704                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
2705                                 {
2706                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2707                                         pLed->bLedScanBlinkInProgress = _FALSE;
2708                                 }
2709                                 pLed->bLedWPSBlinkInProgress = _TRUE;
2710                                 pLed->CurrLedState = LED_BLINK_WPS;
2711                                 if( pLed->bLedOn )
2712                                         pLed->BlinkingLedState = RTW_LED_OFF;
2713                                 else
2714                                         pLed->BlinkingLedState = RTW_LED_ON;
2715                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2716                          }
2717                         break;
2718
2719
2720                 case LED_CTL_STOP_WPS:
2721                         if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
2722                         {
2723                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2724                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2725                         }
2726                         if( pLed->bLedLinkBlinkInProgress == _TRUE )
2727                         {
2728                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2729                                  pLed->bLedLinkBlinkInProgress = _FALSE;
2730                         }
2731                         if(pLed->bLedBlinkInProgress ==_TRUE)
2732                         {
2733                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2734                                 pLed->bLedBlinkInProgress = _FALSE;
2735                         }
2736                         if(pLed->bLedScanBlinkInProgress ==_TRUE)
2737                         {
2738                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2739                                 pLed->bLedScanBlinkInProgress = _FALSE;
2740                         }
2741                         if(pLed->bLedWPSBlinkInProgress)
2742                         {
2743                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2744                         }
2745                         else
2746                         {
2747                                 pLed->bLedWPSBlinkInProgress = _TRUE;
2748                         }
2749
2750                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
2751                         if(pLed->bLedOn)
2752                         {
2753                                 pLed->BlinkingLedState = RTW_LED_OFF;
2754                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
2755                         }
2756                         else
2757                         {
2758                                 pLed->BlinkingLedState = RTW_LED_ON;
2759                                 _set_timer(&(pLed->BlinkTimer), 0);
2760                         }
2761                         break;
2762
2763                 case LED_CTL_STOP_WPS_FAIL:
2764                         if(pLed->bLedWPSBlinkInProgress)
2765                         {
2766                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2767                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2768                         }
2769
2770                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
2771                         pLed->CurrLedState = LED_BLINK_SLOWLY;
2772                         if( pLed->bLedOn )
2773                                 pLed->BlinkingLedState = RTW_LED_OFF;
2774                         else
2775                                 pLed->BlinkingLedState = RTW_LED_ON;
2776                         _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);//change by ylb 20121012 for customer led for alpha
2777                         break;
2778
2779                 case LED_CTL_POWER_OFF:
2780                         pLed->CurrLedState = RTW_LED_OFF;
2781                         pLed->BlinkingLedState = RTW_LED_OFF;
2782                         if( pLed->bLedNoLinkBlinkInProgress)
2783                         {
2784                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2785                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
2786                         }
2787                         if( pLed->bLedLinkBlinkInProgress)
2788                         {
2789                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2790                                 pLed->bLedLinkBlinkInProgress = _FALSE;
2791                         }
2792                         if( pLed->bLedBlinkInProgress)
2793                         {
2794                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2795                                 pLed->bLedBlinkInProgress = _FALSE;
2796                         }
2797                         if( pLed->bLedWPSBlinkInProgress )
2798                         {
2799                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2800                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2801                         }
2802                         if( pLed->bLedScanBlinkInProgress)
2803                         {
2804                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2805                                 pLed->bLedScanBlinkInProgress = _FALSE;
2806                         }
2807
2808                         SwLedOff(padapter, pLed);
2809                         break;
2810
2811                 default:
2812                         break;
2813
2814         }
2815
2816         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));
2817 }
2818
2819  //Arcadyan/Sitecom , added by chiyoko, 20090216
2820 static void
2821 SwLedControlMode2(
2822         _adapter                                *padapter,
2823         LED_CTL_MODE            LedAction
2824 )
2825 {
2826         struct led_priv *ledpriv = &(padapter->ledpriv);
2827         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2828         PLED_USB                pLed = &(ledpriv->SwLed0);
2829
2830         switch(LedAction)
2831         {
2832                 case LED_CTL_SITE_SURVEY:
2833                          if(pmlmepriv->LinkDetectInfo.bBusyTraffic)
2834                                 ;
2835                          else if(pLed->bLedScanBlinkInProgress ==_FALSE)
2836                          {
2837                                 if(IS_LED_WPS_BLINKING(pLed))
2838                                         return;
2839
2840                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2841                                 {
2842                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2843                                         pLed->bLedBlinkInProgress = _FALSE;
2844                                 }
2845                                 pLed->bLedScanBlinkInProgress = _TRUE;
2846                                 pLed->CurrLedState = LED_BLINK_SCAN;
2847                                 pLed->BlinkTimes = 24;
2848                                 if( pLed->bLedOn )
2849                                         pLed->BlinkingLedState = RTW_LED_OFF;
2850                                 else
2851                                         pLed->BlinkingLedState = RTW_LED_ON;
2852                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
2853                          }
2854                         break;
2855
2856                 case LED_CTL_TX:
2857                 case LED_CTL_RX:
2858                         if((pLed->bLedBlinkInProgress ==_FALSE) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
2859                         {
2860                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
2861                                 {
2862                                         return;
2863                                 }
2864
2865                                 pLed->bLedBlinkInProgress = _TRUE;
2866                                 pLed->CurrLedState = LED_BLINK_TXRX;
2867                                 pLed->BlinkTimes = 2;
2868                                 if( pLed->bLedOn )
2869                                         pLed->BlinkingLedState = RTW_LED_OFF;
2870                                 else
2871                                         pLed->BlinkingLedState = RTW_LED_ON;
2872                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
2873                         }
2874                         break;
2875
2876                 case LED_CTL_LINK:
2877                         pLed->CurrLedState = RTW_LED_ON;
2878                         pLed->BlinkingLedState = RTW_LED_ON;
2879                         if( pLed->bLedBlinkInProgress)
2880                         {
2881                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2882                                 pLed->bLedBlinkInProgress = _FALSE;
2883                         }
2884                         if( pLed->bLedScanBlinkInProgress)
2885                         {
2886                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2887                                 pLed->bLedScanBlinkInProgress = _FALSE;
2888                         }
2889
2890                         _set_timer(&(pLed->BlinkTimer), 0);
2891                         break;
2892
2893                 case LED_CTL_START_WPS: //wait until xinpin finish
2894                 case LED_CTL_START_WPS_BOTTON:
2895                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)
2896                         {
2897                                 if(pLed->bLedBlinkInProgress ==_TRUE)
2898                                 {
2899                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2900                                         pLed->bLedBlinkInProgress = _FALSE;
2901                                 }
2902                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
2903                                 {
2904                                         _cancel_timer_ex(&(pLed->BlinkTimer));
2905                                         pLed->bLedScanBlinkInProgress = _FALSE;
2906                                 }
2907                                 pLed->bLedWPSBlinkInProgress = _TRUE;
2908                                 pLed->CurrLedState = RTW_LED_ON;
2909                                 pLed->BlinkingLedState = RTW_LED_ON;
2910                                 _set_timer(&(pLed->BlinkTimer), 0);
2911                          }
2912                         break;
2913
2914                 case LED_CTL_STOP_WPS:
2915                         pLed->bLedWPSBlinkInProgress = _FALSE;
2916                         if(adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)
2917                         {
2918                                 pLed->CurrLedState = RTW_LED_OFF;
2919                                 pLed->BlinkingLedState = RTW_LED_OFF;
2920                                 _set_timer(&(pLed->BlinkTimer), 0);
2921                         }
2922                         else
2923                         {
2924                                 pLed->CurrLedState = RTW_LED_ON;
2925                                 pLed->BlinkingLedState = RTW_LED_ON;
2926                                 _set_timer(&(pLed->BlinkTimer), 0);
2927                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
2928                         }
2929                         break;
2930
2931                 case LED_CTL_STOP_WPS_FAIL:
2932                         pLed->bLedWPSBlinkInProgress = _FALSE;
2933                         pLed->CurrLedState = RTW_LED_OFF;
2934                         pLed->BlinkingLedState = RTW_LED_OFF;
2935                         _set_timer(&(pLed->BlinkTimer), 0);
2936                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
2937                         break;
2938
2939                 case LED_CTL_START_TO_LINK:
2940                 case LED_CTL_NO_LINK:
2941                         if(!IS_LED_BLINKING(pLed))
2942                         {
2943                                 pLed->CurrLedState = RTW_LED_OFF;
2944                                 pLed->BlinkingLedState = RTW_LED_OFF;
2945                                 _set_timer(&(pLed->BlinkTimer), 0);
2946                         }
2947                         break;
2948
2949                 case LED_CTL_POWER_OFF:
2950                         pLed->CurrLedState = RTW_LED_OFF;
2951                         pLed->BlinkingLedState = RTW_LED_OFF;
2952                         if( pLed->bLedBlinkInProgress)
2953                         {
2954                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2955                                 pLed->bLedBlinkInProgress = _FALSE;
2956                         }
2957                         if( pLed->bLedScanBlinkInProgress)
2958                         {
2959                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2960                                 pLed->bLedScanBlinkInProgress = _FALSE;
2961                         }
2962                         if( pLed->bLedWPSBlinkInProgress )
2963                         {
2964                                 _cancel_timer_ex(&(pLed->BlinkTimer));
2965                                 pLed->bLedWPSBlinkInProgress = _FALSE;
2966                         }
2967
2968                         SwLedOff(padapter, pLed);
2969                         break;
2970
2971                 default:
2972                         break;
2973
2974         }
2975
2976         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
2977 }
2978
2979   //COREGA, added by chiyoko, 20090316
2980  static void
2981  SwLedControlMode3(
2982         _adapter                                *padapter,
2983         LED_CTL_MODE            LedAction
2984 )
2985 {
2986         struct led_priv *ledpriv = &(padapter->ledpriv);
2987         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2988         PLED_USB                pLed = &(ledpriv->SwLed0);
2989
2990         switch(LedAction)
2991         {
2992                 case LED_CTL_SITE_SURVEY:
2993                         if(pmlmepriv->LinkDetectInfo.bBusyTraffic)
2994                                 ;
2995                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)
2996                         {
2997                                 if(IS_LED_WPS_BLINKING(pLed))
2998                                         return;
2999
3000                                 if(pLed->bLedBlinkInProgress ==_TRUE)
3001                                 {
3002                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3003                                         pLed->bLedBlinkInProgress = _FALSE;
3004                                 }
3005                                 pLed->bLedScanBlinkInProgress = _TRUE;
3006                                 pLed->CurrLedState = LED_BLINK_SCAN;
3007                                 pLed->BlinkTimes = 24;
3008                                 if( pLed->bLedOn )
3009                                         pLed->BlinkingLedState = RTW_LED_OFF;
3010                                 else
3011                                         pLed->BlinkingLedState = RTW_LED_ON;
3012                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3013                         }
3014                         break;
3015
3016                 case LED_CTL_TX:
3017                 case LED_CTL_RX:
3018                         if((pLed->bLedBlinkInProgress ==_FALSE) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
3019                         {
3020                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3021                                 {
3022                                         return;
3023                                 }
3024
3025                                 pLed->bLedBlinkInProgress = _TRUE;
3026                                 pLed->CurrLedState = LED_BLINK_TXRX;
3027                                 pLed->BlinkTimes = 2;
3028                                 if( pLed->bLedOn )
3029                                         pLed->BlinkingLedState = RTW_LED_OFF;
3030                                 else
3031                                         pLed->BlinkingLedState = RTW_LED_ON;
3032                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3033                         }
3034                         break;
3035
3036                 case LED_CTL_LINK:
3037                         if(IS_LED_WPS_BLINKING(pLed))
3038                                 return;
3039
3040                         pLed->CurrLedState = RTW_LED_ON;
3041                         pLed->BlinkingLedState = RTW_LED_ON;
3042                         if( pLed->bLedBlinkInProgress)
3043                         {
3044                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3045                                 pLed->bLedBlinkInProgress = _FALSE;
3046                         }
3047                         if( pLed->bLedScanBlinkInProgress)
3048                         {
3049                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3050                                 pLed->bLedScanBlinkInProgress = _FALSE;
3051                         }
3052
3053                         _set_timer(&(pLed->BlinkTimer), 0);
3054                         break;
3055
3056                 case LED_CTL_START_WPS: //wait until xinpin finish
3057                 case LED_CTL_START_WPS_BOTTON:
3058                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)
3059                         {
3060                                 if(pLed->bLedBlinkInProgress ==_TRUE)
3061                                 {
3062                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3063                                         pLed->bLedBlinkInProgress = _FALSE;
3064                                 }
3065                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
3066                                 {
3067                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3068                                         pLed->bLedScanBlinkInProgress = _FALSE;
3069                                 }
3070                                 pLed->bLedWPSBlinkInProgress = _TRUE;
3071                                 pLed->CurrLedState = LED_BLINK_WPS;
3072                                 if( pLed->bLedOn )
3073                                         pLed->BlinkingLedState = RTW_LED_OFF;
3074                                 else
3075                                         pLed->BlinkingLedState = RTW_LED_ON;
3076                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3077                         }
3078                         break;
3079
3080                 case LED_CTL_STOP_WPS:
3081                         if(pLed->bLedWPSBlinkInProgress)
3082                         {
3083                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3084                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3085                         }
3086                         else
3087                         {
3088                                 pLed->bLedWPSBlinkInProgress = _TRUE;
3089                         }
3090
3091                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
3092                         if(pLed->bLedOn)
3093                         {
3094                                 pLed->BlinkingLedState = RTW_LED_OFF;
3095                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);
3096                         }
3097                         else
3098                         {
3099                                 pLed->BlinkingLedState = RTW_LED_ON;
3100                                 _set_timer(&(pLed->BlinkTimer), 0);
3101                         }
3102
3103                         break;
3104
3105                 case LED_CTL_STOP_WPS_FAIL:
3106                         if(pLed->bLedWPSBlinkInProgress)
3107                         {
3108                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3109                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3110                         }
3111
3112                         pLed->CurrLedState = RTW_LED_OFF;
3113                         pLed->BlinkingLedState = RTW_LED_OFF;
3114                         _set_timer(&(pLed->BlinkTimer), 0);
3115                         break;
3116
3117                 case LED_CTL_START_TO_LINK:
3118                 case LED_CTL_NO_LINK:
3119                         if(!IS_LED_BLINKING(pLed))
3120                         {
3121                                 pLed->CurrLedState = RTW_LED_OFF;
3122                                 pLed->BlinkingLedState = RTW_LED_OFF;
3123                                 _set_timer(&(pLed->BlinkTimer), 0);
3124                         }
3125                         break;
3126
3127                 case LED_CTL_POWER_OFF:
3128                         pLed->CurrLedState = RTW_LED_OFF;
3129                         pLed->BlinkingLedState = RTW_LED_OFF;
3130                         if( pLed->bLedBlinkInProgress)
3131                         {
3132                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3133                                 pLed->bLedBlinkInProgress = _FALSE;
3134                         }
3135                         if( pLed->bLedScanBlinkInProgress)
3136                         {
3137                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3138                                 pLed->bLedScanBlinkInProgress = _FALSE;
3139                         }
3140                         if( pLed->bLedWPSBlinkInProgress )
3141                         {
3142                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3143                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3144                         }
3145
3146                         SwLedOff(padapter, pLed);
3147                         break;
3148
3149                 default:
3150                         break;
3151
3152         }
3153
3154         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));
3155 }
3156
3157
3158  //Edimax-Belkin, added by chiyoko, 20090413
3159 static void
3160 SwLedControlMode4(
3161         _adapter                                *padapter,
3162         LED_CTL_MODE            LedAction
3163 )
3164 {
3165         struct led_priv *ledpriv = &(padapter->ledpriv);
3166         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
3167         PLED_USB                pLed = &(ledpriv->SwLed0);
3168         PLED_USB                pLed1 = &(ledpriv->SwLed1);
3169
3170         switch(LedAction)
3171         {
3172                 case LED_CTL_START_TO_LINK:
3173                         if(pLed1->bLedWPSBlinkInProgress)
3174                         {
3175                                 pLed1->bLedWPSBlinkInProgress = _FALSE;
3176                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
3177
3178                                 pLed1->BlinkingLedState = RTW_LED_OFF;
3179                                 pLed1->CurrLedState = RTW_LED_OFF;
3180
3181                                 if(pLed1->bLedOn)
3182                                         _set_timer(&(pLed->BlinkTimer), 0);
3183                         }
3184
3185                         if( pLed->bLedStartToLinkBlinkInProgress == _FALSE )
3186                         {
3187                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3188                                 {
3189                                         return;
3190                                 }
3191                                 if(pLed->bLedBlinkInProgress ==_TRUE)
3192                                 {
3193                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3194                                         pLed->bLedBlinkInProgress = _FALSE;
3195                                 }
3196                                 if(pLed->bLedNoLinkBlinkInProgress ==_TRUE)
3197                                 {
3198                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3199                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
3200                                 }
3201
3202                                 pLed->bLedStartToLinkBlinkInProgress = _TRUE;
3203                                 pLed->CurrLedState = LED_BLINK_StartToBlink;
3204                                 if( pLed->bLedOn )
3205                                 {
3206                                         pLed->BlinkingLedState = RTW_LED_OFF;
3207                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
3208                                 }
3209                                 else
3210                                 {
3211                                         pLed->BlinkingLedState = RTW_LED_ON;
3212                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
3213                                 }
3214                         }
3215                         break;
3216
3217                 case LED_CTL_LINK:
3218                 case LED_CTL_NO_LINK:
3219                         //LED1 settings
3220                         if(LedAction == LED_CTL_LINK)
3221                         {
3222                                 if(pLed1->bLedWPSBlinkInProgress)
3223                                 {
3224                                         pLed1->bLedWPSBlinkInProgress = _FALSE;
3225                                         _cancel_timer_ex(&(pLed1->BlinkTimer));
3226
3227                                         pLed1->BlinkingLedState = RTW_LED_OFF;
3228                                         pLed1->CurrLedState = RTW_LED_OFF;
3229
3230                                         if(pLed1->bLedOn)
3231                                                 _set_timer(&(pLed->BlinkTimer), 0);
3232                                 }
3233                         }
3234
3235                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )
3236                         {
3237                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3238                                 {
3239                                         return;
3240                                 }
3241                                 if(pLed->bLedBlinkInProgress ==_TRUE)
3242                                 {
3243                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3244                                         pLed->bLedBlinkInProgress = _FALSE;
3245                                 }
3246
3247                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;
3248                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
3249                                 if( pLed->bLedOn )
3250                                         pLed->BlinkingLedState = RTW_LED_OFF;
3251                                 else
3252                                         pLed->BlinkingLedState = RTW_LED_ON;
3253
3254                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3255                         }
3256                         break;
3257
3258                 case LED_CTL_SITE_SURVEY:
3259                         if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
3260                                 ;
3261                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)
3262                         {
3263                                 if(IS_LED_WPS_BLINKING(pLed))
3264                                         return;
3265
3266                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
3267                                 {
3268                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3269                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
3270                                 }
3271                                 if(pLed->bLedBlinkInProgress ==_TRUE)
3272                                 {
3273                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3274                                         pLed->bLedBlinkInProgress = _FALSE;
3275                                 }
3276                                 pLed->bLedScanBlinkInProgress = _TRUE;
3277                                 pLed->CurrLedState = LED_BLINK_SCAN;
3278                                 pLed->BlinkTimes = 24;
3279                                 if( pLed->bLedOn )
3280                                         pLed->BlinkingLedState = RTW_LED_OFF;
3281                                 else
3282                                         pLed->BlinkingLedState = RTW_LED_ON;
3283                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3284                         }
3285                         break;
3286
3287                 case LED_CTL_TX:
3288                 case LED_CTL_RX:
3289                         if(pLed->bLedBlinkInProgress ==_FALSE)
3290                         {
3291                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3292                                 {
3293                                         return;
3294                                 }
3295                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
3296                                 {
3297                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3298                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
3299                                 }
3300                                 pLed->bLedBlinkInProgress = _TRUE;
3301                                 pLed->CurrLedState = LED_BLINK_TXRX;
3302                                 pLed->BlinkTimes = 2;
3303                                 if( pLed->bLedOn )
3304                                         pLed->BlinkingLedState = RTW_LED_OFF;
3305                                 else
3306                                         pLed->BlinkingLedState = RTW_LED_ON;
3307                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3308                         }
3309                         break;
3310
3311                 case LED_CTL_START_WPS: //wait until xinpin finish
3312                 case LED_CTL_START_WPS_BOTTON:
3313                         if(pLed1->bLedWPSBlinkInProgress)
3314                         {
3315                                 pLed1->bLedWPSBlinkInProgress = _FALSE;
3316                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
3317
3318                                 pLed1->BlinkingLedState = RTW_LED_OFF;
3319                                 pLed1->CurrLedState = RTW_LED_OFF;
3320
3321                                 if(pLed1->bLedOn)
3322                                         _set_timer(&(pLed->BlinkTimer), 0);
3323                         }
3324
3325                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)
3326                         {
3327                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
3328                                 {
3329                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3330                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
3331                                 }
3332                                 if(pLed->bLedBlinkInProgress ==_TRUE)
3333                                 {
3334                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3335                                         pLed->bLedBlinkInProgress = _FALSE;
3336                                 }
3337                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
3338                                 {
3339                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3340                                         pLed->bLedScanBlinkInProgress = _FALSE;
3341                                 }
3342                                 pLed->bLedWPSBlinkInProgress = _TRUE;
3343                                 pLed->CurrLedState = LED_BLINK_WPS;
3344                                 if( pLed->bLedOn )
3345                                 {
3346                                         pLed->BlinkingLedState = RTW_LED_OFF;
3347                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
3348                                 }
3349                                 else
3350                                 {
3351                                         pLed->BlinkingLedState = RTW_LED_ON;
3352                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
3353                                 }
3354                         }
3355                         break;
3356
3357                 case LED_CTL_STOP_WPS:  //WPS connect success
3358                         if(pLed->bLedWPSBlinkInProgress)
3359                         {
3360                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3361                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3362                         }
3363
3364                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
3365                         pLed->CurrLedState = LED_BLINK_SLOWLY;
3366                         if( pLed->bLedOn )
3367                                 pLed->BlinkingLedState = RTW_LED_OFF;
3368                         else
3369                                 pLed->BlinkingLedState = RTW_LED_ON;
3370                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3371
3372                         break;
3373
3374                 case LED_CTL_STOP_WPS_FAIL:             //WPS authentication fail
3375                         if(pLed->bLedWPSBlinkInProgress)
3376                         {
3377                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3378                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3379                         }
3380
3381                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
3382                         pLed->CurrLedState = LED_BLINK_SLOWLY;
3383                         if( pLed->bLedOn )
3384                                 pLed->BlinkingLedState = RTW_LED_OFF;
3385                         else
3386                                 pLed->BlinkingLedState = RTW_LED_ON;
3387                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3388
3389                         //LED1 settings
3390                         if(pLed1->bLedWPSBlinkInProgress)
3391                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
3392                         else
3393                                 pLed1->bLedWPSBlinkInProgress = _TRUE;
3394
3395                         pLed1->CurrLedState = LED_BLINK_WPS_STOP;
3396                         if( pLed1->bLedOn )
3397                                 pLed1->BlinkingLedState = RTW_LED_OFF;
3398                         else
3399                                 pLed1->BlinkingLedState = RTW_LED_ON;
3400                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
3401
3402                         break;
3403
3404                 case LED_CTL_STOP_WPS_FAIL_OVERLAP:     //WPS session overlap
3405                         if(pLed->bLedWPSBlinkInProgress)
3406                         {
3407                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3408                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3409                         }
3410
3411                         pLed->bLedNoLinkBlinkInProgress = _TRUE;
3412                         pLed->CurrLedState = LED_BLINK_SLOWLY;
3413                         if( pLed->bLedOn )
3414                                 pLed->BlinkingLedState = RTW_LED_OFF;
3415                         else
3416                                 pLed->BlinkingLedState = RTW_LED_ON;
3417                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3418
3419                         //LED1 settings
3420                         if(pLed1->bLedWPSBlinkInProgress)
3421                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
3422                         else
3423                                 pLed1->bLedWPSBlinkInProgress = _TRUE;
3424
3425                         pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
3426                         pLed1->BlinkTimes = 10;
3427                         if( pLed1->bLedOn )
3428                                 pLed1->BlinkingLedState = RTW_LED_OFF;
3429                         else
3430                                 pLed1->BlinkingLedState = RTW_LED_ON;
3431                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
3432
3433                         break;
3434
3435                 case LED_CTL_POWER_OFF:
3436                         pLed->CurrLedState = RTW_LED_OFF;
3437                         pLed->BlinkingLedState = RTW_LED_OFF;
3438
3439                         if( pLed->bLedNoLinkBlinkInProgress)
3440                         {
3441                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3442                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
3443                         }
3444                         if( pLed->bLedLinkBlinkInProgress)
3445                         {
3446                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3447                                 pLed->bLedLinkBlinkInProgress = _FALSE;
3448                         }
3449                         if( pLed->bLedBlinkInProgress)
3450                         {
3451                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3452                                 pLed->bLedBlinkInProgress = _FALSE;
3453                         }
3454                         if( pLed->bLedWPSBlinkInProgress )
3455                         {
3456                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3457                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3458                         }
3459                         if( pLed->bLedScanBlinkInProgress)
3460                         {
3461                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3462                                 pLed->bLedScanBlinkInProgress = _FALSE;
3463                         }
3464                         if( pLed->bLedStartToLinkBlinkInProgress)
3465                         {
3466                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3467                                 pLed->bLedStartToLinkBlinkInProgress = _FALSE;
3468                         }
3469
3470                         if( pLed1->bLedWPSBlinkInProgress )
3471                         {
3472                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
3473                                 pLed1->bLedWPSBlinkInProgress = _FALSE;
3474                         }
3475
3476                         pLed1->BlinkingLedState = LED_UNKNOWN;
3477                         SwLedOff(padapter, pLed);
3478                         SwLedOff(padapter, pLed1);
3479                         break;
3480
3481                 case LED_CTL_CONNECTION_NO_TRANSFER:
3482                          if(pLed->bLedBlinkInProgress == _FALSE)
3483                          {
3484                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
3485                                 {
3486                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3487                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
3488                                 }
3489                                 pLed->bLedBlinkInProgress = _TRUE;
3490
3491                                 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
3492                                 pLed->BlinkingLedState = RTW_LED_ON;
3493                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3494                         }
3495                         break;
3496
3497                 default:
3498                         break;
3499
3500         }
3501
3502         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));
3503 }
3504
3505
3506
3507  //Sercomm-Belkin, added by chiyoko, 20090415
3508 static void
3509 SwLedControlMode5(
3510         _adapter                                *padapter,
3511         LED_CTL_MODE            LedAction
3512 )
3513 {
3514         struct led_priv *ledpriv = &(padapter->ledpriv);
3515         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
3516         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
3517         PLED_USB                pLed = &(ledpriv->SwLed0);
3518
3519         if(pHalData->CustomerID == RT_CID_819x_CAMEO)
3520                 pLed = &(ledpriv->SwLed1);
3521
3522         switch(LedAction)
3523         {
3524                 case LED_CTL_POWER_ON:
3525                 case LED_CTL_NO_LINK:
3526                 case LED_CTL_LINK:      //solid blue
3527                         pLed->CurrLedState = RTW_LED_ON;
3528                         pLed->BlinkingLedState = RTW_LED_ON;
3529
3530                         _set_timer(&(pLed->BlinkTimer), 0);
3531                         break;
3532
3533                 case LED_CTL_SITE_SURVEY:
3534                         if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
3535                                 ;
3536                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)
3537                         {
3538                                 if(pLed->bLedBlinkInProgress ==_TRUE)
3539                                 {
3540                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3541                                         pLed->bLedBlinkInProgress = _FALSE;
3542                                 }
3543                                 pLed->bLedScanBlinkInProgress = _TRUE;
3544                                 pLed->CurrLedState = LED_BLINK_SCAN;
3545                                 pLed->BlinkTimes = 24;
3546                                 if( pLed->bLedOn )
3547                                         pLed->BlinkingLedState = RTW_LED_OFF;
3548                                 else
3549                                         pLed->BlinkingLedState = RTW_LED_ON;
3550                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3551                         }
3552                         break;
3553
3554                 case LED_CTL_TX:
3555                 case LED_CTL_RX:
3556                         if(pLed->bLedBlinkInProgress ==_FALSE)
3557                         {
3558                                 if(pLed->CurrLedState == LED_BLINK_SCAN)
3559                                 {
3560                                         return;
3561                                 }
3562                                 pLed->bLedBlinkInProgress = _TRUE;
3563                                 pLed->CurrLedState = LED_BLINK_TXRX;
3564                                 pLed->BlinkTimes = 2;
3565                                 if( pLed->bLedOn )
3566                                         pLed->BlinkingLedState = RTW_LED_OFF;
3567                                 else
3568                                         pLed->BlinkingLedState = RTW_LED_ON;
3569                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
3570                         }
3571                         break;
3572
3573                 case LED_CTL_POWER_OFF:
3574                         pLed->CurrLedState = RTW_LED_OFF;
3575                         pLed->BlinkingLedState = RTW_LED_OFF;
3576
3577                         if( pLed->bLedBlinkInProgress)
3578                         {
3579                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3580                                 pLed->bLedBlinkInProgress = _FALSE;
3581                         }
3582
3583                         SwLedOff(padapter, pLed);
3584                         break;
3585
3586                 default:
3587                         break;
3588
3589         }
3590
3591         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));
3592 }
3593
3594  //WNC-Corega, added by chiyoko, 20090902
3595 static void
3596 SwLedControlMode6(
3597         _adapter                                *padapter,
3598         LED_CTL_MODE            LedAction
3599 )
3600 {
3601         struct led_priv *ledpriv = &(padapter->ledpriv);
3602         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
3603         PLED_USB        pLed0 = &(ledpriv->SwLed0);
3604
3605         switch(LedAction)
3606         {
3607                 case LED_CTL_POWER_ON:
3608                 case LED_CTL_LINK:
3609                 case LED_CTL_NO_LINK:
3610                         _cancel_timer_ex(&(pLed0->BlinkTimer));
3611                         pLed0->CurrLedState = RTW_LED_ON;
3612                         pLed0->BlinkingLedState = RTW_LED_ON;
3613                         _set_timer(&(pLed0->BlinkTimer), 0);
3614                         break;
3615
3616                 case LED_CTL_POWER_OFF:
3617                         SwLedOff(padapter, pLed0);
3618                         break;
3619
3620                 default:
3621                         break;
3622         }
3623
3624         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("ledcontrol 6 Led %d\n", pLed0->CurrLedState));
3625 }
3626
3627 //Netgear, added by sinda, 2011/11/11
3628  void
3629  SwLedControlMode7(
3630          PADAPTER                        Adapter,
3631          LED_CTL_MODE            LedAction
3632  )
3633 {
3634         struct led_priv *ledpriv = &(Adapter->ledpriv);
3635         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
3636         PLED_USB        pLed = &(ledpriv->SwLed0);
3637
3638         switch(LedAction)
3639         {
3640                 case LED_CTL_SITE_SURVEY:
3641                         if(pmlmepriv->LinkDetectInfo.bBusyTraffic)
3642                                 ;
3643                         else if(pLed->bLedScanBlinkInProgress == _FALSE)
3644                         {
3645                                 if(IS_LED_WPS_BLINKING(pLed))
3646                                         return;
3647
3648                                 if(pLed->bLedBlinkInProgress == _TRUE)
3649                                 {
3650                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3651                                         pLed->bLedBlinkInProgress = _FALSE;
3652                                 }
3653                                 pLed->bLedScanBlinkInProgress = _TRUE;
3654                                 pLed->CurrLedState = LED_BLINK_SCAN;
3655                                 pLed->BlinkTimes = 6;
3656                                 if( pLed->bLedOn )
3657                                         pLed->BlinkingLedState = RTW_LED_OFF;
3658                                 else
3659                                         pLed->BlinkingLedState = RTW_LED_ON;
3660                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
3661                         }
3662                         break;
3663
3664                 case LED_CTL_LINK:
3665                         if(IS_LED_WPS_BLINKING(pLed))
3666                                 return;
3667
3668                         pLed->CurrLedState = RTW_LED_ON;
3669                         pLed->BlinkingLedState = RTW_LED_ON;
3670                         if( pLed->bLedBlinkInProgress)
3671                         {
3672                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3673                                 pLed->bLedBlinkInProgress = _FALSE;
3674                         }
3675                         if( pLed->bLedScanBlinkInProgress)
3676                         {
3677                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3678                                 pLed->bLedScanBlinkInProgress = _FALSE;
3679                         }
3680
3681                         _set_timer(&(pLed->BlinkTimer), 0);
3682                         break;
3683
3684                 case LED_CTL_START_WPS: //wait until xinpin finish
3685                 case LED_CTL_START_WPS_BOTTON:
3686                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)
3687                         {
3688                                 if(pLed->bLedBlinkInProgress == _TRUE)
3689                                 {
3690                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3691                                         pLed->bLedBlinkInProgress = _FALSE;
3692                                 }
3693                                 if(pLed->bLedScanBlinkInProgress == _TRUE)
3694                                 {
3695                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3696                                         pLed->bLedScanBlinkInProgress = _FALSE;
3697                                 }
3698                                 pLed->bLedWPSBlinkInProgress = _TRUE;
3699                                 pLed->CurrLedState = LED_BLINK_WPS;
3700                                 if( pLed->bLedOn )
3701                                         pLed->BlinkingLedState = RTW_LED_OFF;
3702                                 else
3703                                         pLed->BlinkingLedState = RTW_LED_ON;
3704                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
3705                         }
3706                         break;
3707
3708                 case LED_CTL_STOP_WPS:
3709                         if(pLed->bLedWPSBlinkInProgress)
3710                         {
3711                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3712                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3713                         }
3714                         else
3715                         {
3716                                 pLed->bLedWPSBlinkInProgress = _TRUE;
3717                         }
3718
3719                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
3720                         if(pLed->bLedOn)
3721                         {
3722                                 pLed->BlinkingLedState = RTW_LED_OFF;
3723                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);
3724                         }
3725                         else
3726                         {
3727                                 pLed->BlinkingLedState = RTW_LED_ON;
3728                                 _set_timer(&(pLed->BlinkTimer), 0);
3729                         }
3730
3731                         break;
3732
3733
3734                 case LED_CTL_STOP_WPS_FAIL:
3735                 case LED_CTL_STOP_WPS_FAIL_OVERLAP:     //WPS session overlap
3736                         if(pLed->bLedWPSBlinkInProgress)
3737                         {
3738                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3739                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3740                         }
3741
3742                         pLed->CurrLedState = RTW_LED_OFF;
3743                         pLed->BlinkingLedState = RTW_LED_OFF;
3744                         _set_timer(&(pLed->BlinkTimer), 0);
3745                         break;
3746
3747                 case LED_CTL_START_TO_LINK:
3748                 case LED_CTL_NO_LINK:
3749                         if(!IS_LED_BLINKING(pLed))
3750                         {
3751                                 pLed->CurrLedState = RTW_LED_OFF;
3752                                 pLed->BlinkingLedState = RTW_LED_OFF;
3753                                 _set_timer(&(pLed->BlinkTimer), 0);
3754                         }
3755                         break;
3756
3757                 case LED_CTL_POWER_OFF:
3758                 case LED_CTL_POWER_ON:
3759                         pLed->CurrLedState = RTW_LED_OFF;
3760                         pLed->BlinkingLedState = RTW_LED_OFF;
3761                         if( pLed->bLedBlinkInProgress)
3762                         {
3763                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3764                                 pLed->bLedBlinkInProgress = _FALSE;
3765                         }
3766                         if( pLed->bLedScanBlinkInProgress)
3767                         {
3768                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3769                                 pLed->bLedScanBlinkInProgress = _FALSE;
3770                         }
3771                         if( pLed->bLedWPSBlinkInProgress )
3772                         {
3773                                 _cancel_timer_ex(&(pLed->BlinkTimer));
3774                                 pLed->bLedWPSBlinkInProgress = _FALSE;
3775                         }
3776
3777                         _set_timer(&(pLed->BlinkTimer), 0);
3778                         break;
3779
3780                 default:
3781                         break;
3782
3783         }
3784
3785         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("LEd control mode 7 CurrLedState %d\n", pLed->CurrLedState));
3786 }
3787
3788 void
3789 SwLedControlMode8(
3790         PADAPTER                        Adapter,
3791         LED_CTL_MODE            LedAction
3792         )
3793 {
3794         struct led_priv *ledpriv = &(Adapter->ledpriv);
3795         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
3796         PLED_USB        pLed0 = &(ledpriv->SwLed0);
3797
3798         switch(LedAction)
3799         {
3800                 case LED_CTL_LINK:
3801                         _cancel_timer_ex(&(pLed0->BlinkTimer));
3802                         pLed0->CurrLedState = RTW_LED_ON;
3803                         pLed0->BlinkingLedState = RTW_LED_ON;
3804                         _set_timer(&(pLed0->BlinkTimer), 0);
3805                         break;
3806
3807                 case LED_CTL_NO_LINK:
3808                         _cancel_timer_ex(&(pLed0->BlinkTimer));
3809                         pLed0->CurrLedState = RTW_LED_OFF;
3810                         pLed0->BlinkingLedState = RTW_LED_OFF;
3811                         _set_timer(&(pLed0->BlinkTimer), 0);
3812                         break;
3813
3814                 case LED_CTL_POWER_OFF:
3815                         SwLedOff(Adapter, pLed0);
3816                         break;
3817
3818                 default:
3819                         break;
3820         }
3821
3822         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 8 %d\n", pLed0->CurrLedState));
3823
3824 }
3825
3826 //page added for Belkin AC950, 20120813
3827 void
3828 SwLedControlMode9(
3829         IN      PADAPTER                        Adapter,
3830         IN      LED_CTL_MODE            LedAction
3831 )
3832 {
3833         struct led_priv *ledpriv = &(Adapter->ledpriv);
3834         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
3835         PLED_USB        pLed = &(ledpriv->SwLed0);
3836         PLED_USB        pLed1 = &(ledpriv->SwLed1);
3837         PLED_USB        pLed2 = &(ledpriv->SwLed2);
3838         BOOLEAN  bWPSOverLap = _FALSE;
3839         //DBG_871X("LedAction=%d \n", LedAction);
3840         switch(LedAction)
3841         {
3842                 case LED_CTL_START_TO_LINK:
3843                         if(pLed2->bLedBlinkInProgress == _FALSE)
3844                         {
3845                                 pLed2->bLedBlinkInProgress = _TRUE;
3846                                 pLed2->BlinkingLedState = RTW_LED_ON;
3847                                 pLed2->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
3848
3849                                 _set_timer(&(pLed2->BlinkTimer), 0);
3850                         }
3851                         break;
3852
3853                 case LED_CTL_LINK:
3854                 case LED_CTL_NO_LINK:
3855                         //LED1 settings
3856                         if(LedAction == LED_CTL_NO_LINK)
3857                         {
3858                                 //if(pMgntInfo->AuthStatus == AUTH_STATUS_FAILED)
3859                                 if(0)
3860                                 {
3861                                         pLed1->CurrLedState = LED_BLINK_AUTH_ERROR;
3862                                                 if( pLed1->bLedOn )
3863                                                         pLed1->BlinkingLedState = RTW_LED_OFF;
3864                                                 else
3865                                                         pLed1->BlinkingLedState = RTW_LED_ON;
3866                                                 _set_timer(&(pLed1->BlinkTimer), 0);
3867                                 }
3868                                 else
3869                                 {
3870                                         pLed1->CurrLedState = RTW_LED_OFF;
3871                                         pLed1->BlinkingLedState = RTW_LED_OFF;
3872                                         if( pLed1->bLedOn )
3873                                                 _set_timer(&(pLed1->BlinkTimer), 0);
3874                                 }
3875                         }
3876                         else
3877                         {
3878                                 pLed1->CurrLedState = RTW_LED_OFF;
3879                                 pLed1->BlinkingLedState = RTW_LED_OFF;
3880                                 if( pLed1->bLedOn )
3881                                         _set_timer(&(pLed1->BlinkTimer), 0);
3882                         }
3883
3884                         //LED2 settings
3885                         if(LedAction == LED_CTL_LINK)
3886                         {
3887                                 if(Adapter->securitypriv.dot11PrivacyAlgrthm != _NO_PRIVACY_)
3888                                 {
3889                                         if(pLed2->bLedBlinkInProgress ==_TRUE)
3890                                         {
3891                                                 _cancel_timer_ex(&(pLed2->BlinkTimer));
3892                                                 pLed2->bLedBlinkInProgress = _FALSE;
3893                                         }
3894                                         pLed2->CurrLedState = RTW_LED_ON;
3895                                         pLed2->bLedNoLinkBlinkInProgress = _TRUE;
3896                                         if(!pLed2->bLedOn)
3897                                                 _set_timer(&(pLed2->BlinkTimer), 0);
3898                                 }
3899                                 else
3900                                 {
3901                                         if(pLed2->bLedWPSBlinkInProgress != _TRUE)
3902                                         {
3903                                                 pLed2->CurrLedState = RTW_LED_OFF;
3904                                                 pLed2->BlinkingLedState = RTW_LED_OFF;
3905                                                 if(pLed2->bLedOn)
3906                                                         _set_timer(&(pLed2->BlinkTimer), 0);
3907                                         }
3908                                 }
3909                         }
3910                         else //NO_LINK
3911                         {
3912                                 if(pLed2->bLedWPSBlinkInProgress == _FALSE)
3913                                 {
3914                                         pLed2->CurrLedState = RTW_LED_OFF;
3915                                         pLed2->BlinkingLedState = RTW_LED_OFF;
3916                                         if(pLed2->bLedOn)
3917                                                 _set_timer(&(pLed2->BlinkTimer), 0);
3918                                 }
3919                         }
3920
3921                         //LED0 settings
3922                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )
3923                         {
3924                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3925                                 {
3926                                         return;
3927                                 }
3928                                 if(pLed->bLedBlinkInProgress == _TRUE)
3929                                 {
3930                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3931                                         pLed->bLedBlinkInProgress = _FALSE;
3932                                 }
3933
3934                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;
3935                                 if(IS_HARDWARE_TYPE_8812AU(Adapter))
3936                                 {
3937                                         if(LedAction == LED_CTL_LINK)
3938                                         {
3939                                                 pLed->BlinkingLedState = RTW_LED_ON;
3940                                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
3941                                         }
3942                                         else
3943                                         {
3944                                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
3945                                                 if( pLed->bLedOn )
3946                                                         pLed->BlinkingLedState = RTW_LED_OFF;
3947                                                 else
3948                                                         pLed->BlinkingLedState = RTW_LED_ON;
3949                                         }
3950                                 }
3951                                 else
3952                                 {
3953                                         pLed->CurrLedState = LED_BLINK_SLOWLY;
3954                                         if( pLed->bLedOn )
3955                                                 pLed->BlinkingLedState = RTW_LED_OFF;
3956                                         else
3957                                                 pLed->BlinkingLedState = RTW_LED_ON;
3958                                 }
3959                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
3960                         }
3961
3962                         break;
3963
3964                 case LED_CTL_SITE_SURVEY:
3965                          if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))
3966                                 ;
3967                          else //if(pLed->bLedScanBlinkInProgress ==FALSE)
3968                          {
3969                                 if(IS_LED_WPS_BLINKING(pLed))
3970                                         return;
3971
3972                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
3973                                 {
3974                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3975                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
3976                                 }
3977                                 if(pLed->bLedBlinkInProgress == _TRUE)
3978                                 {
3979                                         _cancel_timer_ex(&(pLed->BlinkTimer));
3980                                         pLed->bLedBlinkInProgress = _FALSE;
3981                                 }
3982                                 pLed->bLedScanBlinkInProgress = _TRUE;
3983                                 pLed->CurrLedState = LED_BLINK_SCAN;
3984                                 pLed->BlinkTimes = 24;
3985                                 if( pLed->bLedOn )
3986                                         pLed->BlinkingLedState = RTW_LED_OFF;
3987                                 else
3988                                         pLed->BlinkingLedState = RTW_LED_ON;
3989                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
3990
3991                          }
3992                         break;
3993
3994                 case LED_CTL_TX:
3995                 case LED_CTL_RX:
3996                         if(pLed->bLedBlinkInProgress == _FALSE)
3997                         {
3998                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))
3999                                 {
4000                                         return;
4001                                 }
4002                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
4003                                 {
4004                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4005                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
4006                                 }
4007                                 pLed->bLedBlinkInProgress = _TRUE;
4008                                 pLed->CurrLedState = LED_BLINK_TXRX;
4009                                 pLed->BlinkTimes = 2;
4010                                 if( pLed->bLedOn )
4011                                         pLed->BlinkingLedState = RTW_LED_OFF;
4012                                 else
4013                                         pLed->BlinkingLedState = RTW_LED_ON;
4014                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
4015                         }
4016                         break;
4017
4018                 case LED_CTL_START_WPS: //wait until xinpin finish
4019                 case LED_CTL_START_WPS_BOTTON:
4020                         pLed2->bLedBlinkInProgress = _TRUE;
4021                         pLed2->BlinkingLedState = RTW_LED_ON;
4022                         pLed2->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
4023                         pLed2->bLedWPSBlinkInProgress = _TRUE;
4024
4025                         _set_timer(&(pLed2->BlinkTimer), 500);
4026
4027                         break;
4028
4029                 case LED_CTL_STOP_WPS:  //WPS connect success
4030                         //LED2 settings
4031                         if(pLed2->bLedWPSBlinkInProgress == _TRUE)
4032                         {
4033                                 _cancel_timer_ex(&(pLed2->BlinkTimer));
4034                                 pLed2->bLedBlinkInProgress = _FALSE;
4035                                 pLed2->bLedWPSBlinkInProgress = _FALSE;
4036                         }
4037                         pLed2->CurrLedState = RTW_LED_ON;
4038                         pLed2->bLedNoLinkBlinkInProgress = _TRUE;
4039                         if(!pLed2->bLedOn)
4040                                 _set_timer(&(pLed2->BlinkTimer), 0);
4041
4042                         //LED1 settings
4043                         _cancel_timer_ex(&(pLed1->BlinkTimer));
4044                         pLed1->CurrLedState = RTW_LED_OFF;
4045                         pLed1->BlinkingLedState = RTW_LED_OFF;
4046                         if( pLed1->bLedOn )
4047                                 _set_timer(&(pLed1->BlinkTimer), 0);
4048
4049
4050                         break;
4051
4052                 case LED_CTL_STOP_WPS_FAIL:             //WPS authentication fail
4053                         //LED1 settings
4054                         //if(bWPSOverLap == _FALSE)
4055                         {
4056                                 pLed1->CurrLedState = LED_BLINK_AUTH_ERROR;
4057                                 pLed1->BlinkTimes = 50;
4058                                 if( pLed1->bLedOn )
4059                                         pLed1->BlinkingLedState = RTW_LED_OFF;
4060                                 else
4061                                         pLed1->BlinkingLedState = RTW_LED_ON;
4062                                 _set_timer(&(pLed1->BlinkTimer), 0);
4063                         }
4064                         //else
4065                         //{
4066                         //      bWPSOverLap = _FALSE;
4067                         //      pLed1->CurrLedState = RTW_LED_OFF;
4068                         //      pLed1->BlinkingLedState = RTW_LED_OFF;
4069                         //      _set_timer(&(pLed1->BlinkTimer), 0);
4070                         //}
4071
4072                         //LED2 settings
4073                         pLed2->CurrLedState = RTW_LED_OFF;
4074                         pLed2->BlinkingLedState = RTW_LED_OFF;
4075                         pLed2->bLedWPSBlinkInProgress = _FALSE;
4076                         if( pLed2->bLedOn )
4077                                 _set_timer(&(pLed2->BlinkTimer), 0);
4078
4079                         break;
4080
4081                 case LED_CTL_STOP_WPS_FAIL_OVERLAP:     //WPS session overlap
4082                         //LED1 settings
4083                         bWPSOverLap = _TRUE;
4084                         pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
4085                         pLed1->BlinkTimes = 10;
4086                         pLed1->BlinkCounter = 50;
4087                         if( pLed1->bLedOn )
4088                                 pLed1->BlinkingLedState = RTW_LED_OFF;
4089                         else
4090                                 pLed1->BlinkingLedState = RTW_LED_ON;
4091                         _set_timer(&(pLed1->BlinkTimer), 0);
4092
4093                         //LED2 settings
4094                         pLed2->CurrLedState = RTW_LED_OFF;
4095                         pLed2->BlinkingLedState = RTW_LED_OFF;
4096                         pLed2->bLedWPSBlinkInProgress = _FALSE;
4097                         if( pLed2->bLedOn )
4098                                 _set_timer(&(pLed2->BlinkTimer), 0);
4099
4100                         break;
4101
4102                 case LED_CTL_POWER_OFF:
4103                         pLed->CurrLedState = RTW_LED_OFF;
4104                         pLed->BlinkingLedState = RTW_LED_OFF;
4105
4106                         if( pLed->bLedNoLinkBlinkInProgress)
4107                         {
4108                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4109                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
4110                         }
4111                         if( pLed->bLedLinkBlinkInProgress)
4112                         {
4113                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4114                                 pLed->bLedLinkBlinkInProgress = _FALSE;
4115                         }
4116                         if( pLed->bLedBlinkInProgress)
4117                         {
4118                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4119                                 pLed->bLedBlinkInProgress = _FALSE;
4120                         }
4121                         if( pLed->bLedWPSBlinkInProgress )
4122                         {
4123                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4124                                 pLed->bLedWPSBlinkInProgress = _FALSE;
4125                         }
4126                         if( pLed->bLedScanBlinkInProgress)
4127                         {
4128                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4129                                 pLed->bLedScanBlinkInProgress = _FALSE;
4130                         }
4131                         if( pLed->bLedStartToLinkBlinkInProgress)
4132                         {
4133                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4134                                 pLed->bLedStartToLinkBlinkInProgress = _FALSE;
4135                         }
4136
4137                         if( pLed1->bLedWPSBlinkInProgress )
4138                         {
4139                                 _cancel_timer_ex(&(pLed1->BlinkTimer));
4140                                 pLed1->bLedWPSBlinkInProgress = _FALSE;
4141                         }
4142
4143
4144                         pLed1->BlinkingLedState = LED_UNKNOWN;
4145                         SwLedOff(Adapter, pLed);
4146                         SwLedOff(Adapter, pLed1);
4147                         break;
4148
4149                 case LED_CTL_CONNECTION_NO_TRANSFER:
4150                          if(pLed->bLedBlinkInProgress == _FALSE)
4151                          {
4152                                   if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
4153                                 {
4154                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4155                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
4156                                 }
4157                                 pLed->bLedBlinkInProgress = _TRUE;
4158
4159                                 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;
4160                                 pLed->BlinkingLedState = RTW_LED_ON;
4161                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
4162                          }
4163                         break;
4164
4165                 default:
4166                         break;
4167
4168         }
4169
4170         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 9 Led %d\n", pLed->CurrLedState));
4171 }
4172
4173 //page added for Netgear A6200V2, 20120827
4174 void
4175 SwLedControlMode10(
4176         PADAPTER                        Adapter,
4177         LED_CTL_MODE            LedAction
4178 )
4179 {
4180         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
4181         struct led_priv *ledpriv = &(Adapter->ledpriv);
4182         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
4183         PLED_USB        pLed = &(ledpriv->SwLed0);
4184         PLED_USB        pLed1 = &(ledpriv->SwLed1);
4185
4186         switch(LedAction)
4187         {
4188                 case LED_CTL_START_TO_LINK:
4189                         if(pLed1->bLedBlinkInProgress == _FALSE)
4190                         {
4191                                 pLed1->bLedBlinkInProgress = _TRUE;
4192                                 pLed1->BlinkingLedState = RTW_LED_ON;
4193                                 pLed1->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
4194
4195                                 _set_timer(&(pLed1->BlinkTimer), 0);
4196                         }
4197                         break;
4198
4199                 case LED_CTL_LINK:
4200                 case LED_CTL_NO_LINK:
4201                         if(LedAction == LED_CTL_LINK)
4202                         {
4203                                 if(pLed->bLedWPSBlinkInProgress == _TRUE || pLed1->bLedWPSBlinkInProgress == _TRUE)
4204                                         ;
4205                                 else
4206                                 {
4207                                         if(pHalData->CurrentBandType == BAND_ON_2_4G)
4208                                         //LED0 settings
4209                                         {
4210                                                 pLed->CurrLedState = RTW_LED_ON;
4211                                                 pLed->BlinkingLedState = RTW_LED_ON;
4212                                                 if(pLed->bLedBlinkInProgress == _TRUE)
4213                                                 {
4214                                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4215                                                         pLed->bLedBlinkInProgress = _FALSE;
4216                                                 }
4217                                                 _set_timer(&(pLed->BlinkTimer), 0);
4218
4219                                                 pLed1->CurrLedState = RTW_LED_OFF;
4220                                                 pLed1->BlinkingLedState = RTW_LED_OFF;
4221                                                 _set_timer(&(pLed1->BlinkTimer), 0);
4222                                         }
4223                                         else if(pHalData->CurrentBandType == BAND_ON_5G)
4224                                         //LED1 settings
4225                                         {
4226                                                 pLed1->CurrLedState = RTW_LED_ON;
4227                                                 pLed1->BlinkingLedState = RTW_LED_ON;
4228                                                 if(pLed1->bLedBlinkInProgress == _TRUE)
4229                                                 {
4230                                                         _cancel_timer_ex(&(pLed1->BlinkTimer));
4231                                                         pLed1->bLedBlinkInProgress = _FALSE;
4232                                                 }
4233                                                 _set_timer(&(pLed1->BlinkTimer), 0);
4234
4235                                                 pLed->CurrLedState = RTW_LED_OFF;
4236                                                 pLed->BlinkingLedState = RTW_LED_OFF;
4237                                                 _set_timer(&(pLed->BlinkTimer), 0);
4238                                         }
4239                                 }
4240                         }
4241                         else if(LedAction == LED_CTL_NO_LINK)   //TODO by page
4242                         {
4243                                 if(pLed->bLedWPSBlinkInProgress == _TRUE || pLed1->bLedWPSBlinkInProgress == _TRUE)
4244                                         ;
4245                                 else
4246                                 {
4247                                         pLed->CurrLedState = RTW_LED_OFF;
4248                                         pLed->BlinkingLedState = RTW_LED_OFF;
4249                                         if( pLed->bLedOn )
4250                                                 _set_timer(&(pLed->BlinkTimer), 0);
4251
4252                                         pLed1->CurrLedState = RTW_LED_OFF;
4253                                         pLed1->BlinkingLedState = RTW_LED_OFF;
4254                                         if( pLed1->bLedOn )
4255                                                 _set_timer(&(pLed1->BlinkTimer), 0);
4256                                 }
4257                         }
4258
4259                         break;
4260
4261                 case LED_CTL_SITE_SURVEY:
4262                          if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
4263                                 ;                                                                  //don't blink when media connect
4264                          else //if(pLed->bLedScanBlinkInProgress ==FALSE)
4265                          {
4266                                 if(IS_LED_WPS_BLINKING(pLed) || IS_LED_WPS_BLINKING(pLed1))
4267                                         return;
4268
4269                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
4270                                 {
4271                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4272                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
4273                                 }
4274                                 if(pLed->bLedBlinkInProgress == _TRUE)
4275                                 {
4276                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4277                                         pLed->bLedBlinkInProgress = _FALSE;
4278                                 }
4279                                 pLed->bLedScanBlinkInProgress = _TRUE;
4280                                 pLed->CurrLedState = LED_BLINK_SCAN;
4281                                 pLed->BlinkTimes = 12;
4282                                 pLed->BlinkingLedState = LED_BLINK_SCAN;
4283                                 _set_timer(&(pLed->BlinkTimer), 0);
4284
4285                                 if(pLed1->bLedNoLinkBlinkInProgress == _TRUE)
4286                                 {
4287                                         _cancel_timer_ex(&(pLed1->BlinkTimer));
4288                                         pLed1->bLedNoLinkBlinkInProgress = _FALSE;
4289                                 }
4290                                 if(pLed1->bLedBlinkInProgress == _TRUE)
4291                                 {
4292                                         _cancel_timer_ex(&(pLed1->BlinkTimer));
4293                                         pLed1->bLedBlinkInProgress = _FALSE;
4294                                 }
4295                                 pLed1->bLedScanBlinkInProgress = _TRUE;
4296                                 pLed1->CurrLedState = LED_BLINK_SCAN;
4297                                 pLed1->BlinkTimes = 12;
4298                                 pLed1->BlinkingLedState = LED_BLINK_SCAN;
4299                                 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_LINK_SLOWLY_INTERVAL_NETGEAR);
4300
4301                         }
4302                         break;
4303
4304                 case LED_CTL_START_WPS: //wait until xinpin finish
4305                 case LED_CTL_START_WPS_BOTTON:
4306                         //LED0 settings
4307                         if(pLed->bLedBlinkInProgress == _FALSE)
4308                         {
4309                                 pLed->bLedBlinkInProgress = _TRUE;
4310                                 pLed->bLedWPSBlinkInProgress = _TRUE;
4311                                 pLed->BlinkingLedState = LED_BLINK_WPS;
4312                                 pLed->CurrLedState = LED_BLINK_WPS;
4313                                 _set_timer(&(pLed->BlinkTimer), 0);
4314                         }
4315
4316                         //LED1 settings
4317                         if(pLed1->bLedBlinkInProgress == _FALSE)
4318                         {
4319                                 pLed1->bLedBlinkInProgress = _TRUE;
4320                                 pLed1->bLedWPSBlinkInProgress = _TRUE;
4321                                 pLed1->BlinkingLedState = LED_BLINK_WPS;
4322                                 pLed1->CurrLedState = LED_BLINK_WPS;
4323                                 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL+LED_BLINK_LINK_INTERVAL_NETGEAR);
4324                         }
4325
4326
4327                         break;
4328
4329                 case LED_CTL_STOP_WPS:  //WPS connect success
4330                         if(pHalData->CurrentBandType == BAND_ON_2_4G)
4331                         //LED0 settings
4332                         {
4333                                 pLed->bLedWPSBlinkInProgress = _FALSE;
4334                                 pLed->CurrLedState = RTW_LED_ON;
4335                                 pLed->BlinkingLedState = RTW_LED_ON;
4336                                 if(pLed->bLedBlinkInProgress == _TRUE)
4337                                 {
4338                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4339                                         pLed->bLedBlinkInProgress = _FALSE;
4340                                 }
4341                                 _set_timer(&(pLed->BlinkTimer), 0);
4342
4343                                 pLed1->CurrLedState = RTW_LED_OFF;
4344                                 pLed1->BlinkingLedState = RTW_LED_OFF;
4345                                 _set_timer(&(pLed1->BlinkTimer), 0);
4346                         }
4347                         else if(pHalData->CurrentBandType == BAND_ON_5G)
4348                         //LED1 settings
4349                         {
4350                                 pLed1->bLedWPSBlinkInProgress = _FALSE;
4351                                 pLed1->CurrLedState = RTW_LED_ON;
4352                                 pLed1->BlinkingLedState = RTW_LED_ON;
4353                                 if(pLed1->bLedBlinkInProgress == _TRUE)
4354                                 {
4355                                         _cancel_timer_ex(&(pLed1->BlinkTimer));
4356                                         pLed1->bLedBlinkInProgress = _FALSE;
4357                                 }
4358                                 _set_timer(&(pLed1->BlinkTimer), 0);
4359
4360                                 pLed->CurrLedState = RTW_LED_OFF;
4361                                 pLed->BlinkingLedState = RTW_LED_OFF;
4362                                 _set_timer(&(pLed->BlinkTimer), 0);
4363                         }
4364
4365                         break;
4366
4367                 case LED_CTL_STOP_WPS_FAIL:             //WPS authentication fail
4368                         //LED1 settings
4369                         pLed1->bLedWPSBlinkInProgress = _FALSE;
4370                         pLed1->CurrLedState = RTW_LED_OFF;
4371                         pLed1->BlinkingLedState = RTW_LED_OFF;
4372                         _set_timer(&(pLed1->BlinkTimer), 0);
4373
4374                         //LED0 settings
4375                         pLed->bLedWPSBlinkInProgress = _FALSE;
4376                         pLed->CurrLedState = RTW_LED_OFF;
4377                         pLed->BlinkingLedState = RTW_LED_OFF;
4378                         if( pLed->bLedOn )
4379                                 _set_timer(&(pLed->BlinkTimer), 0);
4380
4381                         break;
4382
4383
4384                 default:
4385                         break;
4386
4387         }
4388
4389         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 10 Led %d\n", pLed->CurrLedState));
4390 }
4391
4392  //Edimax-ASUS, added by Page, 20121221
4393 void
4394 SwLedControlMode11(
4395         PADAPTER                        Adapter,
4396         LED_CTL_MODE            LedAction
4397 )
4398 {
4399         struct led_priv *ledpriv = &(Adapter->ledpriv);
4400         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
4401         PLED_USB        pLed = &(ledpriv->SwLed0);
4402
4403         switch(LedAction)
4404         {
4405                 case LED_CTL_POWER_ON:
4406                 case LED_CTL_START_TO_LINK:
4407                 case LED_CTL_NO_LINK:
4408                         pLed->CurrLedState = RTW_LED_ON;
4409                         pLed->BlinkingLedState = RTW_LED_ON;
4410                         _set_timer(&(pLed->BlinkTimer), 0);
4411                         break;
4412
4413                 case LED_CTL_LINK:
4414                         if( pLed->bLedBlinkInProgress == _TRUE )
4415                         {
4416                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4417                                 pLed->bLedBlinkInProgress = _FALSE;
4418                         }
4419                         pLed->bLedBlinkInProgress = _TRUE;
4420                         pLed->CurrLedState = LED_BLINK_TXRX;
4421                         if( pLed->bLedOn )
4422                                 pLed->BlinkingLedState = RTW_LED_OFF;
4423                         else
4424                                 pLed->BlinkingLedState = RTW_LED_ON;
4425                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);
4426                         break;
4427
4428                 case LED_CTL_START_WPS: //wait until xinpin finish
4429                 case LED_CTL_START_WPS_BOTTON:
4430                         if(pLed->bLedBlinkInProgress == _TRUE)
4431                         {
4432                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4433                                 pLed->bLedBlinkInProgress = _FALSE;
4434                         }
4435                         pLed->bLedWPSBlinkInProgress = _TRUE;
4436                         pLed->bLedBlinkInProgress = _TRUE;
4437                         pLed->CurrLedState = LED_BLINK_WPS;
4438                         if( pLed->bLedOn )
4439                                 pLed->BlinkingLedState = RTW_LED_OFF;
4440                         else
4441                                 pLed->BlinkingLedState = RTW_LED_ON;
4442                         pLed->BlinkTimes = 5;
4443                         _set_timer(&(pLed->BlinkTimer), 0);
4444
4445                         break;
4446
4447
4448                 case LED_CTL_STOP_WPS:
4449                 case LED_CTL_STOP_WPS_FAIL:
4450                         if(pLed->bLedBlinkInProgress == _TRUE)
4451                         {
4452                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4453                                 pLed->bLedBlinkInProgress = _FALSE;
4454                         }
4455                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
4456                         _set_timer(&(pLed->BlinkTimer), 0);
4457                         break;
4458
4459                 case LED_CTL_POWER_OFF:
4460                         pLed->CurrLedState = RTW_LED_OFF;
4461                         pLed->BlinkingLedState = RTW_LED_OFF;
4462
4463                         if( pLed->bLedNoLinkBlinkInProgress)
4464                         {
4465                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4466                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
4467                         }
4468                         if( pLed->bLedLinkBlinkInProgress)
4469                         {
4470                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4471                                 pLed->bLedLinkBlinkInProgress = _FALSE;
4472                         }
4473                         if( pLed->bLedBlinkInProgress)
4474                         {
4475                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4476                                 pLed->bLedBlinkInProgress = _FALSE;
4477                         }
4478                         if( pLed->bLedWPSBlinkInProgress )
4479                         {
4480                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4481                                 pLed->bLedWPSBlinkInProgress = _FALSE;
4482                         }
4483                         if( pLed->bLedScanBlinkInProgress)
4484                         {
4485                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4486                                 pLed->bLedScanBlinkInProgress = _FALSE;
4487                         }
4488
4489                         SwLedOff(Adapter, pLed);
4490                         break;
4491
4492                 default:
4493                         break;
4494
4495         }
4496
4497         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led mode 1 CurrLedState %d\n", pLed->CurrLedState));
4498 }
4499
4500 // page added for NEC
4501
4502 VOID
4503 SwLedControlMode12(
4504         PADAPTER                        Adapter,
4505         LED_CTL_MODE            LedAction
4506 )
4507 {
4508         struct led_priv *ledpriv = &(Adapter->ledpriv);
4509         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
4510         PLED_USB        pLed = &(ledpriv->SwLed0);
4511
4512         switch(LedAction)
4513         {
4514                 case LED_CTL_POWER_ON:
4515                 case LED_CTL_NO_LINK:
4516                 case LED_CTL_LINK:
4517                 case LED_CTL_SITE_SURVEY:
4518
4519                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )
4520                         {
4521                                 if(pLed->bLedBlinkInProgress == _TRUE)
4522                                 {
4523                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4524                                         pLed->bLedBlinkInProgress = _FALSE;
4525                                 }
4526
4527                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;
4528                                 pLed->CurrLedState = LED_BLINK_SLOWLY;
4529                                 if( pLed->bLedOn )
4530                                         pLed->BlinkingLedState = RTW_LED_OFF;
4531                                 else
4532                                         pLed->BlinkingLedState = RTW_LED_ON;
4533                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);
4534                         }
4535                         break;
4536
4537                 case LED_CTL_TX:
4538                 case LED_CTL_RX:
4539                         if(pLed->bLedBlinkInProgress == _FALSE)
4540                         {
4541                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
4542                                 {
4543                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4544                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;
4545                                 }
4546                                 pLed->bLedBlinkInProgress = _TRUE;
4547                                 pLed->CurrLedState = LED_BLINK_TXRX;
4548                                 pLed->BlinkTimes = 2;
4549                                 if( pLed->bLedOn )
4550                                         pLed->BlinkingLedState = RTW_LED_OFF;
4551                                 else
4552                                         pLed->BlinkingLedState = RTW_LED_ON;
4553                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
4554                         }
4555                         break;
4556
4557                 case LED_CTL_POWER_OFF:
4558                         pLed->CurrLedState = RTW_LED_OFF;
4559                         pLed->BlinkingLedState = RTW_LED_OFF;
4560
4561                         if( pLed->bLedBlinkInProgress)
4562                         {
4563                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4564                                 pLed->bLedBlinkInProgress = _FALSE;
4565                         }
4566
4567                         if( pLed->bLedScanBlinkInProgress)
4568                         {
4569                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4570                                 pLed->bLedScanBlinkInProgress = _FALSE;
4571                         }
4572
4573                         if(pLed->bLedNoLinkBlinkInProgress == _TRUE)
4574                         {
4575                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4576                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;
4577                         }
4578
4579                         SwLedOff(Adapter, pLed);
4580                         break;
4581
4582                 default:
4583                         break;
4584
4585         }
4586
4587         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SWLed12 %d\n", pLed->CurrLedState));
4588 }
4589
4590 // Maddest add for NETGEAR R6100
4591
4592 VOID
4593 SwLedControlMode13(
4594         IN      PADAPTER                        Adapter,
4595         IN      LED_CTL_MODE            LedAction
4596 )
4597 {
4598         struct led_priv *ledpriv = &(Adapter->ledpriv);
4599         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
4600         PLED_USB        pLed = &(ledpriv->SwLed0);
4601
4602         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 13 CurrLedState %d, LedAction %d\n", pLed->CurrLedState,LedAction));
4603         switch(LedAction)
4604         {
4605                 case LED_CTL_LINK:
4606                         if(pLed->bLedWPSBlinkInProgress)
4607                         {
4608                                 return;
4609                         }
4610
4611
4612                         pLed->CurrLedState = RTW_LED_ON;
4613                         pLed->BlinkingLedState = RTW_LED_ON;
4614                         if( pLed->bLedBlinkInProgress)
4615                         {
4616                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4617                                 pLed->bLedBlinkInProgress = _FALSE;
4618                         }
4619                         if( pLed->bLedScanBlinkInProgress)
4620                         {
4621                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4622                                 pLed->bLedScanBlinkInProgress = _FALSE;
4623                         }
4624
4625                         _set_timer(&(pLed->BlinkTimer), 0);
4626                         break;
4627
4628                 case LED_CTL_START_WPS: //wait until xinpin finish
4629                 case LED_CTL_START_WPS_BOTTON:
4630                         if(pLed->bLedWPSBlinkInProgress == _FALSE)
4631                         {
4632                                 if(pLed->bLedBlinkInProgress == _TRUE)
4633                                 {
4634                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4635                                         pLed->bLedBlinkInProgress = _FALSE;
4636                                 }
4637                                 if(pLed->bLedScanBlinkInProgress == _TRUE)
4638                                 {
4639                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4640                                         pLed->bLedScanBlinkInProgress = _FALSE;
4641                                 }
4642                                 pLed->bLedWPSBlinkInProgress = _TRUE;
4643                                 pLed->CurrLedState = LED_BLINK_WPS;
4644                                 if( pLed->bLedOn )
4645                                 {
4646                                         pLed->BlinkingLedState = RTW_LED_OFF;
4647                                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
4648                                 }
4649                                 else
4650                                 {
4651                                         pLed->BlinkingLedState = RTW_LED_ON;
4652                                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
4653                                 }
4654                         }
4655                         break;
4656
4657                 case LED_CTL_STOP_WPS:
4658                         if(pLed->bLedWPSBlinkInProgress)
4659                         {
4660                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4661                                 pLed->bLedWPSBlinkInProgress = _FALSE;
4662                         }
4663                         else
4664                         {
4665                                 pLed->bLedWPSBlinkInProgress = _TRUE;
4666                         }
4667
4668                         pLed->bLedWPSBlinkInProgress = _FALSE;
4669                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
4670                         if(pLed->bLedOn)
4671                         {
4672                                 pLed->BlinkingLedState = RTW_LED_OFF;
4673
4674                                 _set_timer(&(pLed->BlinkTimer), 0);
4675                         }
4676
4677                         break;
4678
4679
4680                 case LED_CTL_STOP_WPS_FAIL:
4681                 case LED_CTL_STOP_WPS_FAIL_OVERLAP: //WPS session overlap
4682                         if(pLed->bLedWPSBlinkInProgress)
4683                         {
4684                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4685                                 pLed->bLedWPSBlinkInProgress = _FALSE;
4686                         }
4687
4688                         pLed->CurrLedState = RTW_LED_OFF;
4689                         pLed->BlinkingLedState = RTW_LED_OFF;
4690                         _set_timer(&(pLed->BlinkTimer), 0);
4691                         break;
4692
4693                 case LED_CTL_START_TO_LINK:
4694                         if((pLed->bLedBlinkInProgress == _FALSE) && (pLed->bLedWPSBlinkInProgress == _FALSE))
4695                         {
4696                                 pLed->bLedBlinkInProgress = _TRUE;
4697                                 pLed->BlinkingLedState = RTW_LED_ON;
4698                                 pLed->CurrLedState = LED_BLINK_LINK_IN_PROCESS;
4699
4700                                 _set_timer(&(pLed->BlinkTimer), 0);
4701                         }
4702                         break;
4703
4704                 case LED_CTL_NO_LINK:
4705
4706                         if(pLed->bLedWPSBlinkInProgress)
4707                         {
4708                                 return;
4709                         }
4710                         if( pLed->bLedBlinkInProgress)
4711                         {
4712                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4713                                 pLed->bLedBlinkInProgress = _FALSE;
4714                         }
4715                         if( pLed->bLedScanBlinkInProgress)
4716                         {
4717                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4718                                 pLed->bLedScanBlinkInProgress = _FALSE;
4719                         }
4720                         //if(!IS_LED_BLINKING(pLed))
4721                         {
4722                                 pLed->CurrLedState = RTW_LED_OFF;
4723                                 pLed->BlinkingLedState = RTW_LED_OFF;
4724                                 _set_timer(&(pLed->BlinkTimer), 0);
4725                         }
4726                         break;
4727
4728                 case LED_CTL_POWER_OFF:
4729                 case LED_CTL_POWER_ON:
4730                         pLed->CurrLedState = RTW_LED_OFF;
4731                         pLed->BlinkingLedState = RTW_LED_OFF;
4732                         if( pLed->bLedBlinkInProgress)
4733                         {
4734                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4735                                 pLed->bLedBlinkInProgress = _FALSE;
4736                         }
4737                         if( pLed->bLedScanBlinkInProgress)
4738                         {
4739                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4740                                 pLed->bLedScanBlinkInProgress = _FALSE;
4741                         }
4742                         if( pLed->bLedWPSBlinkInProgress )
4743                         {
4744                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4745                                 pLed->bLedWPSBlinkInProgress = _FALSE;
4746                         }
4747
4748                         if (LedAction == LED_CTL_POWER_ON)
4749                                 _set_timer(&(pLed->BlinkTimer), 0);
4750                         else
4751                                 SwLedOff(Adapter, pLed);
4752                         break;
4753
4754                 default:
4755                         break;
4756
4757         }
4758
4759
4760 }
4761
4762 // Maddest add for DNI Buffalo
4763
4764 VOID
4765 SwLedControlMode14(
4766         IN      PADAPTER                        Adapter,
4767         IN      LED_CTL_MODE            LedAction
4768 )
4769 {
4770         struct led_priv *ledpriv = &(Adapter->ledpriv);
4771         PLED_USB        pLed = &(ledpriv->SwLed0);
4772
4773         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 14 CurrLedState %d, LedAction %d\n", pLed->CurrLedState,LedAction));
4774         switch(LedAction)
4775         {
4776                 case LED_CTL_POWER_OFF:
4777                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 14 LED_CTL_POWER_OFF\n"));
4778                         pLed->CurrLedState = RTW_LED_OFF;
4779                         pLed->BlinkingLedState = RTW_LED_OFF;
4780                         if( pLed->bLedBlinkInProgress)
4781                         {
4782                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4783                                 pLed->bLedBlinkInProgress = _FALSE;
4784                         }
4785                         SwLedOff(Adapter, pLed);
4786                         break;
4787
4788                 case LED_CTL_POWER_ON:
4789                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 14 LED_CTL_POWER_ON\n"));
4790                         SwLedOn(Adapter, pLed);
4791                         break;
4792
4793                 case LED_CTL_LINK:
4794                 case LED_CTL_NO_LINK:
4795                         if (IS_HARDWARE_TYPE_8812AU(Adapter))
4796                                 SwLedOn(Adapter, pLed);
4797                         break;
4798
4799                 case LED_CTL_TX:
4800                 case LED_CTL_RX:
4801                         if(pLed->bLedBlinkInProgress ==_FALSE)
4802                         {
4803                                 pLed->bLedBlinkInProgress = _TRUE;
4804                                 pLed->CurrLedState = LED_BLINK_TXRX;
4805                                 pLed->BlinkTimes = 2;
4806                                 if( pLed->bLedOn )
4807                                 {
4808                                         pLed->BlinkingLedState = RTW_LED_OFF;
4809                                         if (IS_HARDWARE_TYPE_8812AU(Adapter))
4810                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);
4811                                         else
4812                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
4813                                 }
4814                                 else
4815                                 {
4816                                         pLed->BlinkingLedState = RTW_LED_ON;
4817                                         if (IS_HARDWARE_TYPE_8812AU(Adapter))
4818                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
4819                                         else
4820                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
4821                                 }
4822                         }
4823                         break;
4824
4825                 default:
4826                         break;
4827         }
4828 }
4829
4830 // Maddest add for Dlink
4831
4832 VOID
4833 SwLedControlMode15(
4834         IN      PADAPTER                        Adapter,
4835         IN      LED_CTL_MODE            LedAction
4836 )
4837 {
4838         struct led_priv *ledpriv = &(Adapter->ledpriv);
4839         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;
4840         PLED_USB        pLed = &(ledpriv->SwLed0);
4841
4842         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 CurrLedState %d, LedAction %d\n", pLed->CurrLedState,LedAction));
4843         switch(LedAction)
4844         {
4845                 case LED_CTL_START_WPS: //wait until xinpin finish
4846                 case LED_CTL_START_WPS_BOTTON:
4847                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_START_WPS\n"));
4848                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)
4849                         {
4850                                 if(pLed->bLedBlinkInProgress ==_TRUE)
4851                                 {
4852                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4853                                         pLed->bLedBlinkInProgress = _FALSE;
4854                                 }
4855                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)
4856                                 {
4857                                         _cancel_timer_ex(&(pLed->BlinkTimer));
4858                                         pLed->bLedScanBlinkInProgress = _FALSE;
4859                                 }
4860                                 pLed->bLedWPSBlinkInProgress = _TRUE;
4861                                 pLed->CurrLedState = LED_BLINK_WPS;
4862                                 if( pLed->bLedOn )
4863                                 {
4864                                         pLed->BlinkingLedState = RTW_LED_OFF;
4865                                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);
4866                                 }
4867                                 else
4868                                 {
4869                                         pLed->BlinkingLedState = RTW_LED_ON;
4870                                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);
4871                                 }
4872                         }
4873                         break;
4874
4875                 case LED_CTL_STOP_WPS:
4876                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_STOP_WPS\n"));
4877                         if(pLed->bLedWPSBlinkInProgress)
4878                         {
4879                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4880                         }
4881
4882                         pLed->CurrLedState = LED_BLINK_WPS_STOP;
4883                         //if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
4884                         {
4885                                 pLed->BlinkingLedState = RTW_LED_ON;
4886
4887                                 _set_timer(&(pLed->BlinkTimer), 0);
4888                         }
4889
4890                         break;
4891
4892                 case LED_CTL_STOP_WPS_FAIL:
4893                 case LED_CTL_STOP_WPS_FAIL_OVERLAP: //WPS session overlap
4894                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_STOP_WPS_FAIL\n"));
4895                         if(pLed->bLedWPSBlinkInProgress)
4896                         {
4897                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4898                                 pLed->bLedWPSBlinkInProgress = _FALSE;
4899                         }
4900
4901                         pLed->CurrLedState = RTW_LED_OFF;
4902                         pLed->BlinkingLedState = RTW_LED_OFF;
4903                         _set_timer(&(pLed->BlinkTimer), 0);
4904                         break;
4905
4906                 case LED_CTL_NO_LINK:
4907                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_NO_LINK\n"));
4908                         if(pLed->bLedWPSBlinkInProgress)
4909                         {
4910                                 return;
4911                         }
4912
4913                         /*if(Adapter->securitypriv.dot11PrivacyAlgrthm > _NO_PRIVACY_)
4914                         {
4915                                 if(SecIsTxKeyInstalled(Adapter, pMgntInfo->Bssid))
4916                                 {
4917                                 }
4918                                 else
4919                                 {
4920                                         if(pMgntInfo->LEDAssocState ==LED_ASSOC_SECURITY_BEGIN)
4921                                                 return;
4922                                 }
4923                         }*/
4924
4925                         if( pLed->bLedBlinkInProgress)
4926                         {
4927                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4928                                 pLed->bLedBlinkInProgress = _FALSE;
4929                         }
4930                         if( pLed->bLedScanBlinkInProgress)
4931                         {
4932                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4933                                 pLed->bLedScanBlinkInProgress = _FALSE;
4934                         }
4935                         //if(!IS_LED_BLINKING(pLed))
4936                         {
4937                                 pLed->CurrLedState = LED_BLINK_NO_LINK;
4938                                 pLed->BlinkingLedState = RTW_LED_ON;
4939                                 _set_timer(&(pLed->BlinkTimer), 30);
4940                         }
4941                         break;
4942
4943                 case LED_CTL_LINK:
4944                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_LINK\n"));
4945
4946                         if(pLed->bLedWPSBlinkInProgress)
4947                         {
4948                                 return;
4949                         }
4950
4951                         if( pLed->bLedBlinkInProgress)
4952                         {
4953                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4954                                 pLed->bLedBlinkInProgress = _FALSE;
4955                         }
4956
4957                         pLed->CurrLedState = LED_BLINK_LINK_IDEL;
4958                         pLed->BlinkingLedState = RTW_LED_ON;
4959
4960                         _set_timer(&(pLed->BlinkTimer), 30);
4961                         break;
4962
4963                 case LED_CTL_SITE_SURVEY        :
4964                         if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
4965                                 return;
4966
4967                         if(pLed->bLedWPSBlinkInProgress ==_TRUE)
4968                                 return;
4969
4970                         if( pLed->bLedBlinkInProgress)
4971                         {
4972                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4973                                 pLed->bLedBlinkInProgress = _FALSE;
4974                         }
4975                         pLed->CurrLedState = LED_BLINK_SCAN;
4976                         pLed->BlinkingLedState = RTW_LED_ON;
4977                         _set_timer(&(pLed->BlinkTimer), 0);
4978                         break;
4979
4980                 case LED_CTL_TX:
4981                 case LED_CTL_RX:
4982                         if(pLed->bLedWPSBlinkInProgress)
4983                         {
4984                                 return;
4985                         }
4986
4987                         if( pLed->bLedBlinkInProgress)
4988                         {
4989                                 _cancel_timer_ex(&(pLed->BlinkTimer));
4990                                 pLed->bLedBlinkInProgress = _FALSE;
4991                         }
4992
4993                         pLed->bLedBlinkInProgress = _TRUE;
4994                         pLed->CurrLedState = LED_BLINK_TXRX;
4995                         pLed->BlinkTimes = 2;
4996                         if( pLed->bLedOn )
4997                                 pLed->BlinkingLedState = RTW_LED_OFF;
4998                         else
4999                                 pLed->BlinkingLedState = RTW_LED_ON;
5000                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);
5001                         break;
5002
5003                 default:
5004                         break;
5005         }
5006 }
5007
5008 void
5009 LedControlUSB(
5010         _adapter                                *padapter,
5011         LED_CTL_MODE            LedAction
5012         )
5013 {
5014         struct led_priv *ledpriv = &(padapter->ledpriv);
5015
5016 #if(MP_DRIVER == 1)
5017         if (padapter->registrypriv.mp_mode == 1)
5018                 return;
5019 #endif
5020
5021         if (RTW_CANNOT_RUN(padapter) || (!rtw_is_hw_init_completed(padapter))) {
5022                 /*DBG_871X("%s bDriverStopped:%s, bSurpriseRemoved:%s\n"
5023                 , __func__
5024                 , rtw_is_drv_stopped(padapter)?"True":"False"
5025                 , rtw_is_surprise_removed(padapter)?"True":"False" );*/
5026                 return;
5027         }
5028
5029         if( ledpriv->bRegUseLed == _FALSE)
5030                 return;
5031
5032         //if(priv->bInHctTest)
5033         //      return;
5034
5035 #ifdef CONFIG_CONCURRENT_MODE
5036         // Only do led action for PRIMARY_ADAPTER
5037         if (padapter->adapter_type != PRIMARY_ADAPTER)
5038                 return;
5039 #endif
5040
5041         if( (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on &&
5042                 adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) &&
5043                 (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
5044                  LedAction == LED_CTL_SITE_SURVEY ||
5045                  LedAction == LED_CTL_LINK ||
5046                  LedAction == LED_CTL_NO_LINK ||
5047                  LedAction == LED_CTL_POWER_ON) )
5048         {
5049                 return;
5050         }
5051
5052         switch(ledpriv->LedStrategy)
5053         {
5054                 case SW_LED_MODE0:
5055                         SwLedControlMode0(padapter, LedAction);
5056                         break;
5057
5058                 case SW_LED_MODE1:
5059                         SwLedControlMode1(padapter, LedAction);
5060                         break;
5061
5062                 case SW_LED_MODE2:
5063                         SwLedControlMode2(padapter, LedAction);
5064                         break;
5065
5066                 case SW_LED_MODE3:
5067                         SwLedControlMode3(padapter, LedAction);
5068                         break;
5069
5070                 case SW_LED_MODE4:
5071                         SwLedControlMode4(padapter, LedAction);
5072                         break;
5073
5074                 case SW_LED_MODE5:
5075                         SwLedControlMode5(padapter, LedAction);
5076                         break;
5077
5078                 case SW_LED_MODE6:
5079                         SwLedControlMode6(padapter, LedAction);
5080                         break;
5081
5082                 case SW_LED_MODE7:
5083                         SwLedControlMode7(padapter, LedAction);
5084                         break;
5085
5086                 case SW_LED_MODE8:
5087                         SwLedControlMode8(padapter, LedAction);
5088                         break;
5089
5090                 case SW_LED_MODE9:
5091                         SwLedControlMode9(padapter, LedAction);
5092                         break;
5093
5094                 case SW_LED_MODE10:
5095                         SwLedControlMode10(padapter, LedAction);
5096                         break;
5097
5098                 case SW_LED_MODE11:
5099                         SwLedControlMode11(padapter, LedAction);
5100                         break;
5101
5102                 case SW_LED_MODE12:
5103                         SwLedControlMode12(padapter, LedAction);
5104                         break;
5105
5106                 case SW_LED_MODE13:
5107                         SwLedControlMode13(padapter, LedAction);
5108                         break;
5109
5110                 case SW_LED_MODE14:
5111                         SwLedControlMode14(padapter, LedAction);
5112                         break;
5113
5114                 case SW_LED_MODE15:
5115                         SwLedControlMode15(padapter, LedAction);
5116                         break;
5117
5118                 default:
5119                         break;
5120         }
5121
5122         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("LedStrategy:%d, LedAction %d\n", ledpriv->LedStrategy,LedAction));
5123 }
5124
5125 //
5126 //      Description:
5127 //              Reset status of LED_871x object.
5128 //
5129 void ResetLedStatus(PLED_USB pLed) {
5130
5131         pLed->CurrLedState = RTW_LED_OFF; // Current LED state.
5132         pLed->bLedOn = _FALSE; // true if LED is ON, false if LED is OFF.
5133
5134         pLed->bLedBlinkInProgress = _FALSE; // true if it is blinking, false o.w..
5135         pLed->bLedWPSBlinkInProgress = _FALSE;
5136
5137         pLed->BlinkTimes = 0; // Number of times to toggle led state for blinking.
5138         pLed->BlinkCounter = 0;
5139         pLed->BlinkingLedState = LED_UNKNOWN; // Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are.
5140
5141         pLed->bLedNoLinkBlinkInProgress = _FALSE;
5142         pLed->bLedLinkBlinkInProgress = _FALSE;
5143         pLed->bLedStartToLinkBlinkInProgress = _FALSE;
5144         pLed->bLedScanBlinkInProgress = _FALSE;
5145 }
5146
5147  //
5148 //      Description:
5149 //              Initialize an LED_871x object.
5150 //
5151 void
5152 InitLed(
5153         _adapter                        *padapter,
5154         PLED_USB                pLed,
5155         LED_PIN                 LedPin
5156         )
5157 {
5158         pLed->padapter = padapter;
5159         pLed->LedPin = LedPin;
5160
5161         ResetLedStatus(pLed);
5162         ATOMIC_SET(&pLed->bCancelWorkItem, _FALSE);
5163         _init_timer(&(pLed->BlinkTimer), padapter->pnetdev, BlinkTimerCallback, pLed);
5164         _init_workitem(&(pLed->BlinkWorkItem), BlinkWorkItemCallback, pLed);
5165 }
5166
5167
5168 //
5169 //      Description:
5170 //              DeInitialize an LED_871x object.
5171 //
5172 void
5173 DeInitLed(
5174         PLED_USB                pLed
5175         )
5176 {
5177         ATOMIC_SET(&pLed->bCancelWorkItem, _TRUE);
5178         _cancel_workitem_sync(&(pLed->BlinkWorkItem));
5179         _cancel_timer_ex(&(pLed->BlinkTimer));
5180         ResetLedStatus(pLed);
5181 }
5182
5183