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