drivers/staging/r8188eu/core/rtw_led.c

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