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