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