drivers/net/wireless/rockchip_wlan/rtl8822be/hal/led/hal_pci_led.c

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