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