drivers/net/wireless/rockchip_wlan/rtl8723bu/hal/led/hal_usb_led.c

   1 /******************************************************************************\r
   2  *\r
   3  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.\r
   4  *                                        \r
   5  * This program is free software; you can redistribute it and/or modify it\r
   6  * under the terms of version 2 of the GNU General Public License as\r
   7  * published by the Free Software Foundation.\r
   8  *\r
   9  * This program is distributed in the hope that it will be useful, but WITHOUT\r
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\r
  12  * more details.\r
  13  *\r
  14  * You should have received a copy of the GNU General Public License along with\r
  15  * this program; if not, write to the Free Software Foundation, Inc.,\r
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA\r
  17  *\r
  18  *\r
  19  ******************************************************************************/\r
  20 \r
  21 #include <drv_types.h>\r
  22 #include <hal_data.h>\r
  23 \r
  24 //\r
  25 //      Description:\r
  26 //              Implementation of LED blinking behavior.\r
  27 //              It toggle off LED and schedule corresponding timer if necessary.\r
  28 //\r
  29 void\r
  30 SwLedBlink(\r
  31         PLED_USB                        pLed\r
  32         )\r
  33 {\r
  34         _adapter                        *padapter = pLed->padapter;\r
  35         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);\r
  36         u8                              bStopBlinking = _FALSE;\r
  37 \r
  38         // Change LED according to BlinkingLedState specified.\r
  39         if( pLed->BlinkingLedState == RTW_LED_ON )\r
  40         {\r
  41                 SwLedOn(padapter, pLed);\r
  42                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
  43         }\r
  44         else\r
  45         {\r
  46                 SwLedOff(padapter, pLed);\r
  47                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,( "Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
  48         }\r
  49 \r
  50         // Determine if we shall change LED state again.\r
  51         pLed->BlinkTimes--;\r
  52         switch(pLed->CurrLedState)\r
  53         {\r
  54 \r
  55         case LED_BLINK_NORMAL:\r
  56                 if(pLed->BlinkTimes == 0)\r
  57                 {\r
  58                         bStopBlinking = _TRUE;\r
  59                 }\r
  60                 break;\r
  61 \r
  62         case LED_BLINK_StartToBlink:\r
  63                 if( check_fwstate(pmlmepriv, _FW_LINKED) && check_fwstate(pmlmepriv, WIFI_STATION_STATE) )\r
  64                 {\r
  65                         bStopBlinking = _TRUE;\r
  66                 }\r
  67                 if( check_fwstate(pmlmepriv, _FW_LINKED) &&\r
  68                         (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) )\r
  69                 {\r
  70                         bStopBlinking = _TRUE;\r
  71                 }\r
  72                 else if(pLed->BlinkTimes == 0)\r
  73                 {\r
  74                         bStopBlinking = _TRUE;\r
  75                 }\r
  76                 break;\r
  77 \r
  78         case LED_BLINK_WPS:\r
  79                 if( pLed->BlinkTimes == 0 )\r
  80                 {\r
  81                         bStopBlinking = _TRUE;\r
  82                 }\r
  83                 break;\r
  84 \r
  85 \r
  86         default:\r
  87                 bStopBlinking = _TRUE;\r
  88                 break;\r
  89 \r
  90         }\r
  91 \r
  92         if(bStopBlinking)\r
  93         {\r
  94                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
  95                 {\r
  96                         SwLedOff(padapter, pLed);\r
  97                 }\r
  98                 else if( (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE) && (pLed->bLedOn == _FALSE))\r
  99                 {\r
 100                         SwLedOn(padapter, pLed);\r
 101                 }\r
 102                 else if( (check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE) &&  pLed->bLedOn == _TRUE)\r
 103                 {\r
 104                         SwLedOff(padapter, pLed);\r
 105                 }\r
 106 \r
 107                 pLed->BlinkTimes = 0;\r
 108                 pLed->bLedBlinkInProgress = _FALSE;\r
 109         }\r
 110         else\r
 111         {\r
 112                 // Assign LED state to toggle.\r
 113                 if( pLed->BlinkingLedState == RTW_LED_ON )\r
 114                         pLed->BlinkingLedState = RTW_LED_OFF;\r
 115                 else\r
 116                         pLed->BlinkingLedState = RTW_LED_ON;\r
 117 \r
 118                 // Schedule a timer to toggle LED state.\r
 119                 switch( pLed->CurrLedState )\r
 120                 {\r
 121                 case LED_BLINK_NORMAL:\r
 122                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
 123                         break;\r
 124 \r
 125                 case LED_BLINK_SLOWLY:\r
 126                 case LED_BLINK_StartToBlink:\r
 127                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
 128                         break;\r
 129 \r
 130                 case LED_BLINK_WPS:\r
 131                         {\r
 132                                 if( pLed->BlinkingLedState == RTW_LED_ON )\r
 133                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);\r
 134                                 else\r
 135                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);\r
 136                         }\r
 137                         break;\r
 138 \r
 139                 default:\r
 140                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
 141                         break;\r
 142                 }\r
 143         }\r
 144 }\r
 145 \r
 146 void\r
 147 SwLedBlink1(\r
 148         PLED_USB                        pLed\r
 149         )\r
 150 {\r
 151         _adapter                                *padapter = pLed->padapter;\r
 152         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(padapter);\r
 153         struct led_priv         *ledpriv = &(padapter->ledpriv);\r
 154         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);\r
 155         PLED_USB                        pLed1 = &(ledpriv->SwLed1);\r
 156         u8                                      bStopBlinking = _FALSE;\r
 157 \r
 158         u32 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA; //add by ylb 20121012 for customer led for alpha\r
 159         if(pHalData->CustomerID == RT_CID_819x_ALPHA_Dlink)\r
 160                 uLedBlinkNoLinkInterval= LED_BLINK_NO_LINK_INTERVAL_ALPHA_500MS;\r
 161         \r
 162         if(pHalData->CustomerID == RT_CID_819x_CAMEO)\r
 163                 pLed = &(ledpriv->SwLed1);\r
 164 \r
 165         // Change LED according to BlinkingLedState specified.\r
 166         if( pLed->BlinkingLedState == RTW_LED_ON )\r
 167         {\r
 168                 SwLedOn(padapter, pLed);\r
 169                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,( "Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
 170         }\r
 171         else\r
 172         {\r
 173                 SwLedOff(padapter, pLed);\r
 174                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
 175         }\r
 176 \r
 177 \r
 178         if(pHalData->CustomerID == RT_CID_DEFAULT)\r
 179         {\r
 180                 if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
 181                 {\r
 182                         if(!pLed1->bSWLedCtrl)\r
 183                         {\r
 184                                 SwLedOn(padapter, pLed1);\r
 185                                 pLed1->bSWLedCtrl = _TRUE;\r
 186                         }\r
 187                         else if(!pLed1->bLedOn)\r
 188                                 SwLedOn(padapter, pLed1);\r
 189                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (): turn on pLed1\n"));\r
 190                 }\r
 191                 else\r
 192                 {\r
 193                         if(!pLed1->bSWLedCtrl)\r
 194                         {\r
 195                                 SwLedOff(padapter, pLed1);\r
 196                                 pLed1->bSWLedCtrl = _TRUE;\r
 197                         }\r
 198                         else if(pLed1->bLedOn)\r
 199                                 SwLedOff(padapter, pLed1);\r
 200                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (): turn off pLed1\n"));\r
 201                 }\r
 202         }\r
 203 \r
 204         switch(pLed->CurrLedState)\r
 205         {\r
 206                 case LED_BLINK_SLOWLY:\r
 207                         if( pLed->bLedOn )\r
 208                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 209                         else\r
 210                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 211                         _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);//change by ylb 20121012 for customer led for alpha\r
 212                         break;\r
 213 \r
 214                 case LED_BLINK_NORMAL:\r
 215                         if( pLed->bLedOn )\r
 216                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 217                         else\r
 218                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 219                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
 220                         break;\r
 221 \r
 222                 case LED_BLINK_SCAN:\r
 223                         pLed->BlinkTimes--;\r
 224                         if( pLed->BlinkTimes == 0 )\r
 225                         {\r
 226                                 bStopBlinking = _TRUE;\r
 227                         }\r
 228 \r
 229                         if(bStopBlinking)\r
 230                         {\r
 231                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 232                                 {\r
 233                                         SwLedOff(padapter, pLed);\r
 234                                 }\r
 235                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
 236                                 {\r
 237                                         pLed->bLedLinkBlinkInProgress = _TRUE;\r
 238                                         pLed->CurrLedState = LED_BLINK_NORMAL;\r
 239                                         if( pLed->bLedOn )\r
 240                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 241                                         else\r
 242                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 243                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
 244                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 245 \r
 246                                 }\r
 247                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
 248                                 {\r
 249                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
 250                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
 251                                         if( pLed->bLedOn )\r
 252                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 253                                         else\r
 254                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 255                                         _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);\r
 256                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 257                                 }\r
 258                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
 259                         }\r
 260                         else\r
 261                         {\r
 262                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 263                                 {\r
 264                                         SwLedOff(padapter, pLed);\r
 265                                 }\r
 266                                 else\r
 267                                 {\r
 268                                         if( pLed->bLedOn )\r
 269                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 270                                         else\r
 271                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 272                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
 273                                 }\r
 274                         }\r
 275                         break;\r
 276 \r
 277                 case LED_BLINK_TXRX:\r
 278                         pLed->BlinkTimes--;\r
 279                         if( pLed->BlinkTimes == 0 )\r
 280                         {\r
 281                                 bStopBlinking = _TRUE;\r
 282                         }\r
 283                         if(bStopBlinking)\r
 284                         {\r
 285                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 286                                 {\r
 287                                         SwLedOff(padapter, pLed);\r
 288                                 }\r
 289                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
 290                                 {\r
 291                                         pLed->bLedLinkBlinkInProgress = _TRUE;\r
 292                                         pLed->CurrLedState = LED_BLINK_NORMAL;\r
 293                                         if( pLed->bLedOn )\r
 294                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 295                                         else\r
 296                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 297                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
 298                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 299                                 }\r
 300                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
 301                                 {\r
 302                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
 303                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
 304                                         if( pLed->bLedOn )\r
 305                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 306                                         else\r
 307                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 308                                         _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);\r
 309                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 310                                 }\r
 311                                 pLed->BlinkTimes = 0;\r
 312                                 pLed->bLedBlinkInProgress = _FALSE;\r
 313                         }\r
 314                         else\r
 315                         {\r
 316                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 317                                 {\r
 318                                         SwLedOff(padapter, pLed);\r
 319                                 }\r
 320                                 else\r
 321                                 {\r
 322                                         if( pLed->bLedOn )\r
 323                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 324                                         else\r
 325                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 326                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
 327                                 }\r
 328                         }\r
 329                         break;\r
 330 \r
 331                 case LED_BLINK_WPS:\r
 332                         if( pLed->bLedOn )\r
 333                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 334                         else\r
 335                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 336                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
 337                         break;\r
 338 \r
 339                 case LED_BLINK_WPS_STOP:        //WPS success\r
 340                         if(pLed->BlinkingLedState == RTW_LED_ON)\r
 341                         {\r
 342                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 343                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);\r
 344                                 bStopBlinking = _FALSE;\r
 345                         }\r
 346                         else\r
 347                         {\r
 348                                 bStopBlinking = _TRUE;\r
 349                         }\r
 350 \r
 351                         if(bStopBlinking)\r
 352                         {\r
 353                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 354                                 {\r
 355                                         SwLedOff(padapter, pLed);\r
 356                                 }\r
 357                                 else\r
 358                                 {\r
 359                                         pLed->bLedLinkBlinkInProgress = _TRUE;\r
 360                                         pLed->CurrLedState = LED_BLINK_NORMAL;\r
 361                                         if( pLed->bLedOn )\r
 362                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 363                                         else\r
 364                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 365                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
 366                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 367                                 }\r
 368                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
 369                         }\r
 370                         break;\r
 371 \r
 372                 default:\r
 373                         break;\r
 374         }\r
 375 \r
 376 }\r
 377 \r
 378 void\r
 379 SwLedBlink2(\r
 380         PLED_USB                        pLed\r
 381         )\r
 382 {\r
 383         _adapter                                *padapter = pLed->padapter;\r
 384         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);\r
 385         u8                                      bStopBlinking = _FALSE;\r
 386 \r
 387         // Change LED according to BlinkingLedState specified.\r
 388         if( pLed->BlinkingLedState == RTW_LED_ON)\r
 389         {\r
 390                 SwLedOn(padapter, pLed);\r
 391                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
 392         }\r
 393         else\r
 394         {\r
 395                 SwLedOff(padapter, pLed);\r
 396                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
 397         }\r
 398 \r
 399         switch(pLed->CurrLedState)\r
 400         {\r
 401                 case LED_BLINK_SCAN:\r
 402                         pLed->BlinkTimes--;\r
 403                         if( pLed->BlinkTimes == 0 )\r
 404                         {\r
 405                                 bStopBlinking = _TRUE;\r
 406                         }\r
 407 \r
 408                         if(bStopBlinking)\r
 409                         {\r
 410                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 411                                 {\r
 412                                         SwLedOff(padapter, pLed);\r
 413                                 }\r
 414                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
 415                                 {\r
 416                                         pLed->CurrLedState = RTW_LED_ON;\r
 417                                         pLed->BlinkingLedState = RTW_LED_ON;\r
 418                                         SwLedOn(padapter, pLed);\r
 419                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop scan blink CurrLedState %d\n", pLed->CurrLedState));\r
 420 \r
 421                                 }\r
 422                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
 423                                 {\r
 424                                         pLed->CurrLedState = RTW_LED_OFF;\r
 425                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
 426                                         SwLedOff(padapter, pLed);\r
 427                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop scan blink CurrLedState %d\n", pLed->CurrLedState));\r
 428                                 }\r
 429                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
 430                         }\r
 431                         else\r
 432                         {\r
 433                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 434                                 {\r
 435                                         SwLedOff(padapter, pLed);\r
 436                                 }\r
 437                                 else\r
 438                                 {\r
 439                                          if( pLed->bLedOn )\r
 440                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 441                                         else\r
 442                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 443                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
 444                                 }\r
 445                         }\r
 446                         break;\r
 447 \r
 448                 case LED_BLINK_TXRX:\r
 449                         pLed->BlinkTimes--;\r
 450                         if( pLed->BlinkTimes == 0 )\r
 451                         {\r
 452                                 bStopBlinking = _TRUE;\r
 453                         }\r
 454                         if(bStopBlinking)\r
 455                         {\r
 456                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 457                                 {\r
 458                                         SwLedOff(padapter, pLed);\r
 459                                 }\r
 460                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
 461                                 {\r
 462                                         pLed->CurrLedState = RTW_LED_ON;\r
 463                                         pLed->BlinkingLedState = RTW_LED_ON;\r
 464                                         SwLedOn(padapter, pLed);\r
 465                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop CurrLedState %d\n", pLed->CurrLedState));\r
 466 \r
 467                                 }\r
 468                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
 469                                 {\r
 470                                         pLed->CurrLedState = RTW_LED_OFF;\r
 471                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
 472                                         SwLedOff(padapter, pLed);\r
 473                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("stop CurrLedState %d\n", pLed->CurrLedState));\r
 474                                 }\r
 475                                 pLed->bLedBlinkInProgress = _FALSE;\r
 476                         }\r
 477                         else\r
 478                         {\r
 479                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 480                                 {\r
 481                                         SwLedOff(padapter, pLed);\r
 482                                 }\r
 483                                 else\r
 484                                 {\r
 485                                          if( pLed->bLedOn )\r
 486                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 487                                         else\r
 488                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 489                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
 490                                 }\r
 491                         }\r
 492                         break;\r
 493 \r
 494                 default:\r
 495                         break;\r
 496         }\r
 497 \r
 498 }\r
 499 \r
 500 void\r
 501 SwLedBlink3(\r
 502         PLED_USB                        pLed\r
 503         )\r
 504 {\r
 505         _adapter                        *padapter = pLed->padapter;\r
 506         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);\r
 507         u8                              bStopBlinking = _FALSE;\r
 508 \r
 509         // Change LED according to BlinkingLedState specified.\r
 510         if( pLed->BlinkingLedState == RTW_LED_ON )\r
 511         {\r
 512                 SwLedOn(padapter, pLed);\r
 513                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
 514         }\r
 515         else\r
 516         {\r
 517                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)\r
 518                         SwLedOff(padapter, pLed);\r
 519                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
 520         }\r
 521 \r
 522         switch(pLed->CurrLedState)\r
 523         {\r
 524                 case LED_BLINK_SCAN:\r
 525                         pLed->BlinkTimes--;\r
 526                         if( pLed->BlinkTimes == 0 )\r
 527                         {\r
 528                                 bStopBlinking = _TRUE;\r
 529                         }\r
 530 \r
 531                         if(bStopBlinking)\r
 532                         {\r
 533                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 534                                 {\r
 535                                         SwLedOff(padapter, pLed);\r
 536                                 }\r
 537                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
 538                                 {\r
 539                                         pLed->CurrLedState = RTW_LED_ON;\r
 540                                         pLed->BlinkingLedState = RTW_LED_ON;\r
 541                                         if( !pLed->bLedOn )\r
 542                                                 SwLedOn(padapter, pLed);\r
 543 \r
 544                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 545                                 }\r
 546                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
 547                                 {\r
 548                                         pLed->CurrLedState = RTW_LED_OFF;\r
 549                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
 550                                         if( pLed->bLedOn )\r
 551                                                 SwLedOff(padapter, pLed);\r
 552 \r
 553                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 554                                 }\r
 555                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
 556                         }\r
 557                         else\r
 558                         {\r
 559                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 560                                 {\r
 561                                         SwLedOff(padapter, pLed);\r
 562                                 }\r
 563                                 else\r
 564                                 {\r
 565                                         if( pLed->bLedOn )\r
 566                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 567                                         else\r
 568                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 569                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
 570                                 }\r
 571                         }\r
 572                         break;\r
 573 \r
 574                 case LED_BLINK_TXRX:\r
 575                         pLed->BlinkTimes--;\r
 576                         if( pLed->BlinkTimes == 0 )\r
 577                         {\r
 578                                 bStopBlinking = _TRUE;\r
 579                         }\r
 580                         if(bStopBlinking)\r
 581                         {\r
 582                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 583                                 {\r
 584                                         SwLedOff(padapter, pLed);\r
 585                                 }\r
 586                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
 587                                 {\r
 588                                         pLed->CurrLedState = RTW_LED_ON;\r
 589                                         pLed->BlinkingLedState = RTW_LED_ON;\r
 590 \r
 591                                         if( !pLed->bLedOn )\r
 592                                                 SwLedOn(padapter, pLed);\r
 593 \r
 594                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 595                                 }\r
 596                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
 597                                 {\r
 598                                         pLed->CurrLedState = RTW_LED_OFF;\r
 599                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
 600 \r
 601                                         if( pLed->bLedOn )\r
 602                                                 SwLedOff(padapter, pLed);\r
 603 \r
 604 \r
 605                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 606                                 }\r
 607                                 pLed->bLedBlinkInProgress = _FALSE;\r
 608                         }\r
 609                         else\r
 610                         {\r
 611                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 612                                 {\r
 613                                         SwLedOff(padapter, pLed);\r
 614                                 }\r
 615                                 else\r
 616                                 {\r
 617                                         if( pLed->bLedOn )\r
 618                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 619                                         else\r
 620                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 621                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
 622                                 }\r
 623                         }\r
 624                         break;\r
 625 \r
 626                 case LED_BLINK_WPS:\r
 627                         if( pLed->bLedOn )\r
 628                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 629                         else\r
 630                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 631                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
 632                         break;\r
 633 \r
 634                 case LED_BLINK_WPS_STOP:        //WPS success\r
 635                         if(pLed->BlinkingLedState == RTW_LED_ON)\r
 636                         {\r
 637                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 638                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);\r
 639                                 bStopBlinking = _FALSE;\r
 640                         }\r
 641                         else\r
 642                         {\r
 643                                 bStopBlinking = _TRUE;\r
 644                         }\r
 645 \r
 646                         if(bStopBlinking)\r
 647                         {\r
 648                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on )\r
 649                                 {\r
 650                                         SwLedOff(padapter, pLed);\r
 651                                 }\r
 652                                 else\r
 653                                 {\r
 654                                         pLed->CurrLedState = RTW_LED_ON;\r
 655                                         pLed->BlinkingLedState = RTW_LED_ON;\r
 656                                         SwLedOn(padapter, pLed);\r
 657                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
 658                                 }\r
 659                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
 660                         }\r
 661                         break;\r
 662 \r
 663 \r
 664                 default:\r
 665                         break;\r
 666         }\r
 667 \r
 668 }\r
 669 \r
 670 \r
 671 void\r
 672 SwLedBlink4(\r
 673         PLED_USB                        pLed\r
 674         )\r
 675 {\r
 676         _adapter                        *padapter = pLed->padapter;\r
 677         struct led_priv *ledpriv = &(padapter->ledpriv);\r
 678         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);\r
 679         PLED_USB                pLed1 = &(ledpriv->SwLed1);\r
 680         u8                              bStopBlinking = _FALSE;\r
 681 \r
 682         // Change LED according to BlinkingLedState specified.\r
 683         if( pLed->BlinkingLedState == RTW_LED_ON )\r
 684         {\r
 685                 SwLedOn(padapter, pLed);\r
 686                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
 687         }\r
 688         else\r
 689         {\r
 690                 SwLedOff(padapter, pLed);\r
 691                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
 692         }\r
 693 \r
 694         if(!pLed1->bLedWPSBlinkInProgress && pLed1->BlinkingLedState == LED_UNKNOWN)\r
 695         {\r
 696                 pLed1->BlinkingLedState = RTW_LED_OFF;\r
 697                 pLed1->CurrLedState = RTW_LED_OFF;\r
 698                 SwLedOff(padapter, pLed1);\r
 699         }\r
 700 \r
 701         switch(pLed->CurrLedState)\r
 702         {\r
 703                 case LED_BLINK_SLOWLY:\r
 704                         if( pLed->bLedOn )\r
 705                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 706                         else\r
 707                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 708                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
 709                         break;\r
 710 \r
 711                 case LED_BLINK_StartToBlink:\r
 712                         if( pLed->bLedOn )\r
 713                         {\r
 714                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 715                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
 716                         }\r
 717                         else\r
 718                         {\r
 719                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 720                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
 721                         }\r
 722                         break;\r
 723 \r
 724                 case LED_BLINK_SCAN:\r
 725                         pLed->BlinkTimes--;\r
 726                         if( pLed->BlinkTimes == 0 )\r
 727                         {\r
 728                                 bStopBlinking = _FALSE;\r
 729                         }\r
 730 \r
 731                         if(bStopBlinking)\r
 732                         {\r
 733                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 734                                 {\r
 735                                         SwLedOff(padapter, pLed);\r
 736                                 }\r
 737                                 else\r
 738                                 {\r
 739                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
 740                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
 741                                         if( pLed->bLedOn )\r
 742                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 743                                         else\r
 744                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 745                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
 746                                 }\r
 747                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
 748                         }\r
 749                         else\r
 750                         {\r
 751                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 752                                 {\r
 753                                         SwLedOff(padapter, pLed);\r
 754                                 }\r
 755                                 else\r
 756                                 {\r
 757                                          if( pLed->bLedOn )\r
 758                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 759                                         else\r
 760                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 761                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
 762                                 }\r
 763                         }\r
 764                         break;\r
 765 \r
 766                 case LED_BLINK_TXRX:\r
 767                         pLed->BlinkTimes--;\r
 768                         if( pLed->BlinkTimes == 0 )\r
 769                         {\r
 770                                 bStopBlinking = _TRUE;\r
 771                         }\r
 772                         if(bStopBlinking)\r
 773                         {\r
 774                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 775                                 {\r
 776                                         SwLedOff(padapter, pLed);\r
 777                                 }\r
 778                                 else\r
 779                                 {\r
 780                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
 781                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
 782                                         if( pLed->bLedOn )\r
 783                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 784                                         else\r
 785                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 786                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
 787                                 }\r
 788                                 pLed->bLedBlinkInProgress = _FALSE;\r
 789                         }\r
 790                         else\r
 791                         {\r
 792                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 793                                 {\r
 794                                         SwLedOff(padapter, pLed);\r
 795                                 }\r
 796                                 else\r
 797                                 {\r
 798                                         \r
 799                                         if( pLed->bLedOn )\r
 800                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 801                                         else\r
 802                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 803                                         \r
 804                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
 805                                 }\r
 806                         }\r
 807                         break;\r
 808 \r
 809                 case LED_BLINK_WPS:\r
 810                         if( pLed->bLedOn )\r
 811                         {\r
 812                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 813                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
 814                         }\r
 815                         else\r
 816                         {\r
 817                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 818                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
 819                         }\r
 820                         break;\r
 821 \r
 822                 case LED_BLINK_WPS_STOP:        //WPS authentication fail\r
 823                         if( pLed->bLedOn )\r
 824                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 825                         else\r
 826                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 827 \r
 828                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
 829                         break;\r
 830 \r
 831                 case LED_BLINK_WPS_STOP_OVERLAP:        //WPS session overlap\r
 832                         pLed->BlinkTimes--;\r
 833                         if(pLed->BlinkTimes == 0)\r
 834                         {\r
 835                                 if(pLed->bLedOn)\r
 836                                 {\r
 837                                         pLed->BlinkTimes = 1;\r
 838                                 }\r
 839                                 else\r
 840                                 {\r
 841                                         bStopBlinking = _TRUE;\r
 842                                 }\r
 843                         }\r
 844 \r
 845                         if(bStopBlinking)\r
 846                         {\r
 847                                 pLed->BlinkTimes = 10;\r
 848                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 849                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
 850                         }\r
 851                         else\r
 852                         {\r
 853                                 if( pLed->bLedOn )\r
 854                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
 855                                 else\r
 856                                         pLed->BlinkingLedState = RTW_LED_ON;\r
 857 \r
 858                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
 859                         }\r
 860                         break;\r
 861 \r
 862                 case LED_BLINK_ALWAYS_ON:\r
 863                         pLed->BlinkTimes--;\r
 864                         if( pLed->BlinkTimes == 0 )\r
 865                         {\r
 866                                 bStopBlinking = _TRUE;\r
 867                         }\r
 868                         if(bStopBlinking)\r
 869                         {\r
 870                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 871                                 {\r
 872                                         SwLedOff(padapter, pLed);\r
 873                                 }\r
 874                                 else\r
 875                                 {\r
 876                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
 877                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
 878                                         if( pLed->bLedOn )\r
 879                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 880                                         else\r
 881                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 882                                         \r
 883                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
 884                                 }\r
 885                                 pLed->bLedBlinkInProgress = _FALSE;\r
 886                         }\r
 887                         else\r
 888                         {\r
 889                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 890                                 {\r
 891                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("RFOff Status \n"));\r
 892                                         SwLedOff(padapter, pLed);\r
 893                                 }\r
 894                                 else\r
 895                                 {\r
 896                                         if( pLed->bLedOn )\r
 897                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 898                                         else\r
 899                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 900                                         \r
 901                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
 902                                 }\r
 903                         }\r
 904                         break;\r
 905 \r
 906                 default:\r
 907                         break;\r
 908         }\r
 909 \r
 910         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink4 CurrLedState %d\n", pLed->CurrLedState));\r
 911 \r
 912 \r
 913 }\r
 914 \r
 915 void\r
 916 SwLedBlink5(\r
 917         PLED_USB                        pLed\r
 918         )\r
 919 {\r
 920         _adapter                        *padapter = pLed->padapter;\r
 921         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);\r
 922         u8                              bStopBlinking = _FALSE;\r
 923 \r
 924         // Change LED according to BlinkingLedState specified.\r
 925         if( pLed->BlinkingLedState == RTW_LED_ON )\r
 926         {\r
 927                 SwLedOn(padapter, pLed);\r
 928                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
 929         }\r
 930         else\r
 931         {\r
 932                 SwLedOff(padapter, pLed);\r
 933                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
 934         }\r
 935 \r
 936         switch(pLed->CurrLedState)\r
 937         {\r
 938                 case LED_BLINK_SCAN:\r
 939                         pLed->BlinkTimes--;\r
 940                         if( pLed->BlinkTimes == 0 )\r
 941                         {\r
 942                                 bStopBlinking = _TRUE;\r
 943                         }\r
 944 \r
 945                         if(bStopBlinking)\r
 946                         {\r
 947                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 948                                 {\r
 949                                         pLed->CurrLedState = RTW_LED_OFF;\r
 950                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
 951                                         if(pLed->bLedOn)\r
 952                                                 SwLedOff(padapter, pLed);\r
 953                                 }\r
 954                                 else\r
 955                                 {               pLed->CurrLedState = RTW_LED_ON;\r
 956                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 957                                                 if(!pLed->bLedOn)\r
 958                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
 959                                 }\r
 960 \r
 961                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
 962                         }\r
 963                         else\r
 964                         {\r
 965                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 966                                 {\r
 967                                         SwLedOff(padapter, pLed);\r
 968                                 }\r
 969                                 else\r
 970                                 {\r
 971                                         if( pLed->bLedOn )\r
 972                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
 973                                         else\r
 974                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
 975                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
 976                                 }\r
 977                         }\r
 978                         break;\r
 979 \r
 980 \r
 981                 case LED_BLINK_TXRX:\r
 982                         pLed->BlinkTimes--;\r
 983                         if( pLed->BlinkTimes == 0 )\r
 984                         {\r
 985                                 bStopBlinking = _TRUE;\r
 986                         }\r
 987 \r
 988                         if(bStopBlinking)\r
 989                         {\r
 990                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
 991                                 {\r
 992                                         pLed->CurrLedState = RTW_LED_OFF;\r
 993                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
 994                                         if(pLed->bLedOn)\r
 995                                                 SwLedOff(padapter, pLed);\r
 996                                 }\r
 997                                 else\r
 998                                 {\r
 999                                         pLed->CurrLedState = RTW_LED_ON;\r
1000                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1001                                         if(!pLed->bLedOn)\r
1002                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
1003                                 }\r
1004 \r
1005                                 pLed->bLedBlinkInProgress = _FALSE;\r
1006                         }\r
1007                         else\r
1008                         {\r
1009                                 if( adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1010                                 {\r
1011                                         SwLedOff(padapter, pLed);\r
1012                                 }\r
1013                                 else\r
1014                                 {\r
1015                                          if( pLed->bLedOn )\r
1016                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1017                                         else\r
1018                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1019                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
1020                                 }\r
1021                         }\r
1022                         break;\r
1023 \r
1024                 default:\r
1025                         break;\r
1026         }\r
1027 \r
1028         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink5 CurrLedState %d\n", pLed->CurrLedState));\r
1029 \r
1030 \r
1031 }\r
1032 \r
1033 void\r
1034 SwLedBlink6(\r
1035         PLED_USB                        pLed\r
1036         )\r
1037 {\r
1038         _adapter                        *padapter = pLed->padapter;\r
1039         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);\r
1040         u8                              bStopBlinking = _FALSE;\r
1041 \r
1042         // Change LED according to BlinkingLedState specified.\r
1043         if( pLed->BlinkingLedState == RTW_LED_ON )\r
1044         {\r
1045                 SwLedOn(padapter, pLed);\r
1046                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
1047         }\r
1048         else\r
1049         {\r
1050                 SwLedOff(padapter, pLed);\r
1051                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
1052         }\r
1053 \r
1054         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink6\n"));\r
1055 }\r
1056 \r
1057 void\r
1058 SwLedBlink7(\r
1059         PLED_USB                        pLed\r
1060         )\r
1061 {\r
1062         PADAPTER Adapter = pLed->padapter;\r
1063         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);\r
1064         BOOLEAN bStopBlinking = _FALSE;\r
1065 \r
1066         // Change LED according to BlinkingLedState specified.\r
1067         if( pLed->BlinkingLedState == RTW_LED_ON )\r
1068         {\r
1069                 SwLedOn(Adapter, pLed);\r
1070                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
1071         }\r
1072         else\r
1073         {\r
1074                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)\r
1075                         SwLedOff(Adapter, pLed);\r
1076                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
1077         }\r
1078 \r
1079         switch(pLed->CurrLedState)\r
1080         {\r
1081                 case LED_BLINK_SCAN:\r
1082                         pLed->BlinkTimes--;\r
1083                         if( pLed->BlinkTimes == 0 )\r
1084                         {\r
1085                                 bStopBlinking = _TRUE;\r
1086                         }\r
1087 \r
1088                         if(bStopBlinking)\r
1089                         {\r
1090                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )\r
1091                                 {\r
1092                                         SwLedOff(Adapter, pLed);\r
1093                                 }\r
1094                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
1095                                 {\r
1096                                         pLed->CurrLedState = RTW_LED_ON;\r
1097                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1098                                         if( !pLed->bLedOn )\r
1099                                                 SwLedOn(Adapter, pLed);\r
1100 \r
1101                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
1102                                 }\r
1103                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
1104                                 {\r
1105                                         pLed->CurrLedState = RTW_LED_OFF;\r
1106                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1107                                         if( pLed->bLedOn )\r
1108                                                 SwLedOff(Adapter, pLed);\r
1109 \r
1110                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));                                  \r
1111                                 }\r
1112                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
1113                         }\r
1114                         else\r
1115                         {\r
1116                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )\r
1117                                 {\r
1118                                         SwLedOff(Adapter, pLed);\r
1119                                 }\r
1120                                 else\r
1121                                 {\r
1122                                         if( pLed->bLedOn )\r
1123                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1124                                         else\r
1125                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1126                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);\r
1127                                 }\r
1128                         }\r
1129                         break;\r
1130 \r
1131                 case LED_BLINK_WPS:\r
1132                         if( pLed->bLedOn )\r
1133                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1134                         else\r
1135                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1136                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);\r
1137                         break;\r
1138 \r
1139                 case LED_BLINK_WPS_STOP:        //WPS success\r
1140                         if(pLed->BlinkingLedState == RTW_LED_ON)\r
1141                         {\r
1142                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1143                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);\r
1144                                 bStopBlinking = _FALSE;\r
1145                         }\r
1146                         else\r
1147                         {\r
1148                                 bStopBlinking = _TRUE;\r
1149                         }\r
1150 \r
1151                         if(bStopBlinking)\r
1152                         {\r
1153                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )\r
1154                                 {\r
1155                                         SwLedOff(Adapter, pLed);\r
1156                                 }\r
1157                                 else\r
1158                                 {\r
1159                                         pLed->CurrLedState = RTW_LED_ON;\r
1160                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1161                                         SwLedOn(Adapter, pLed);\r
1162                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
1163                                 }\r
1164                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
1165                         }\r
1166                         break;\r
1167 \r
1168 \r
1169                 default:\r
1170                         break;\r
1171         }\r
1172 \r
1173         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink7\n"));\r
1174 \r
1175 }\r
1176 \r
1177 void\r
1178 SwLedBlink8(\r
1179         PLED_USB                        pLed\r
1180         )\r
1181 {\r
1182         PADAPTER Adapter = pLed->padapter;\r
1183 \r
1184         // Change LED according to BlinkingLedState specified.\r
1185         if( pLed->BlinkingLedState == RTW_LED_ON )\r
1186         {\r
1187                 SwLedOn(Adapter, pLed);\r
1188                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes blink8(%d): turn on\n", pLed->BlinkTimes));\r
1189         }\r
1190         else\r
1191         {\r
1192                 SwLedOff(Adapter, pLed);\r
1193                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes blink8(%d): turn off\n", pLed->BlinkTimes));\r
1194         }\r
1195 \r
1196         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink8\n"));\r
1197 \r
1198 }\r
1199 \r
1200 //page added for Belkin AC950. 20120813\r
1201 void\r
1202 SwLedBlink9(\r
1203         PLED_USB                        pLed\r
1204         )\r
1205 {\r
1206         PADAPTER Adapter = pLed->padapter; \r
1207         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);\r
1208         BOOLEAN bStopBlinking = _FALSE;\r
1209 \r
1210         // Change LED according to BlinkingLedState specified.\r
1211         if( pLed->BlinkingLedState == RTW_LED_ON ) \r
1212         {\r
1213                 SwLedOn(Adapter, pLed);\r
1214                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
1215         }\r
1216         else \r
1217         {\r
1218                 SwLedOff(Adapter, pLed);\r
1219                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
1220         }       \r
1221         //DBG_871X("%s, pLed->CurrLedState=%d, pLed->BlinkingLedState=%d \n", __FUNCTION__, pLed->CurrLedState, pLed->BlinkingLedState);\r
1222 \r
1223 \r
1224         switch(pLed->CurrLedState)\r
1225         {\r
1226                 case RTW_LED_ON:\r
1227                         SwLedOn(Adapter, pLed);\r
1228                         break;\r
1229                         \r
1230                 case RTW_LED_OFF:\r
1231                         SwLedOff(Adapter, pLed);\r
1232                         break;\r
1233                         \r
1234                 case LED_BLINK_SLOWLY:                  \r
1235                         if( pLed->bLedOn )\r
1236                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
1237                         else\r
1238                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1239                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
1240                         break;\r
1241 \r
1242                 case LED_BLINK_StartToBlink:\r
1243                         if( pLed->bLedOn )\r
1244                         {\r
1245                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1246                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);             \r
1247                         }\r
1248                         else\r
1249                         {\r
1250                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1251                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
1252                         }\r
1253                         break;                  \r
1254                         \r
1255                 case LED_BLINK_SCAN:\r
1256                         pLed->BlinkTimes--;\r
1257                         if( pLed->BlinkTimes == 0 )\r
1258                         {\r
1259                                 bStopBlinking = _TRUE;\r
1260                         }\r
1261                         \r
1262                         if(bStopBlinking)\r
1263                         {\r
1264                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )\r
1265                                 {\r
1266                                         SwLedOff(Adapter, pLed);\r
1267                                 }\r
1268                                 else if(check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)\r
1269                                 {\r
1270                                         pLed->bLedLinkBlinkInProgress = _TRUE;\r
1271                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
1272                                         \r
1273                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
1274                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));                                  \r
1275                                 }\r
1276                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
1277                                 {\r
1278                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
1279                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
1280                                         if( pLed->bLedOn )\r
1281                                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
1282                                         else\r
1283                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1284                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
1285                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));                                  \r
1286                                 }\r
1287                                 pLed->BlinkTimes = 0;\r
1288                                 pLed->bLedBlinkInProgress = _FALSE;     \r
1289                         }\r
1290                         else\r
1291                         {\r
1292                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1293                                 {\r
1294                                         SwLedOff(Adapter, pLed);\r
1295                                 }\r
1296                                 else\r
1297                                 {\r
1298                                          if( pLed->bLedOn )\r
1299                                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
1300                                         else\r
1301                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1302                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
1303                                 }\r
1304                         }\r
1305                         break;\r
1306 \r
1307                 case LED_BLINK_TXRX:\r
1308                         pLed->BlinkTimes--;\r
1309                         if( pLed->BlinkTimes == 0 )\r
1310                         {\r
1311                                 bStopBlinking = _TRUE;\r
1312                         }\r
1313                         if(bStopBlinking)\r
1314                         {\r
1315                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1316                                 {\r
1317                                         SwLedOff(Adapter, pLed);\r
1318                                 }\r
1319                                 else \r
1320                                 {\r
1321                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
1322                                         if( pLed->bLedOn )\r
1323                                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
1324                                         else\r
1325                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1326                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
1327                                 }\r
1328                                 pLed->bLedBlinkInProgress = _FALSE;     \r
1329                         }\r
1330                         else\r
1331                         {\r
1332                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1333                                 {\r
1334                                         SwLedOff(Adapter, pLed);\r
1335                                 }\r
1336                                 else\r
1337                                 {\r
1338                                         if( pLed->bLedOn )\r
1339                                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
1340                                         else\r
1341                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1342                                         \r
1343                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
1344                                 }\r
1345                         }\r
1346                         break;\r
1347 \r
1348                 case LED_BLINK_WPS:\r
1349                         if( pLed->bLedOn )\r
1350                         {\r
1351                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
1352                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
1353                         }\r
1354                         else\r
1355                         {\r
1356                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1357                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
1358                         }\r
1359                         break;\r
1360 \r
1361                 case LED_BLINK_WPS_STOP:        //WPS authentication fail\r
1362                         if( pLed->bLedOn )                      \r
1363                                 pLed->BlinkingLedState = RTW_LED_OFF;                   \r
1364                         else                    \r
1365                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1366                         \r
1367                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
1368                         break;\r
1369 \r
1370                 case LED_BLINK_WPS_STOP_OVERLAP:        //WPS session overlap           \r
1371                         pLed->BlinkTimes--;\r
1372                         pLed->BlinkCounter --;\r
1373                         if(pLed->BlinkCounter == 0)\r
1374                         {\r
1375                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
1376                                 pLed->CurrLedState = RTW_LED_OFF;\r
1377                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
1378                         }\r
1379                         else\r
1380                         {\r
1381                                 if(pLed->BlinkTimes == 0)\r
1382                                 {\r
1383                                         if(pLed->bLedOn)\r
1384                                         {\r
1385                                                 pLed->BlinkTimes = 1;                                                   \r
1386                                         }\r
1387                                         else\r
1388                                         {\r
1389                                                 bStopBlinking = _TRUE;\r
1390                                         }\r
1391                                 }\r
1392 \r
1393                                 if(bStopBlinking)\r
1394                                 {                               \r
1395                                         pLed->BlinkTimes = 10;                  \r
1396                                         pLed->BlinkingLedState = RTW_LED_ON;                                                    \r
1397                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);                                                         \r
1398                                 }\r
1399                                 else\r
1400                                 {\r
1401                                         if( pLed->bLedOn )                      \r
1402                                                 pLed->BlinkingLedState = RTW_LED_OFF;                   \r
1403                                         else                    \r
1404                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1405                                         \r
1406                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);                                             \r
1407                                 }\r
1408                         }\r
1409                         break;\r
1410                         \r
1411                 case LED_BLINK_ALWAYS_ON:\r
1412                         pLed->BlinkTimes--;\r
1413                         if( pLed->BlinkTimes == 0 )\r
1414                         {\r
1415                                 bStopBlinking = _TRUE;\r
1416                         }\r
1417                         if(bStopBlinking)\r
1418                         {\r
1419                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1420                                 {\r
1421                                         SwLedOff(Adapter, pLed);\r
1422                                 }\r
1423                                 else \r
1424                                 {\r
1425                                         if(IS_HARDWARE_TYPE_8812AU(Adapter))\r
1426                                         {\r
1427                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1428                                                 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;\r
1429                                         }\r
1430                                         else\r
1431                                         {\r
1432                                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
1433                                                 pLed->CurrLedState = LED_BLINK_SLOWLY;\r
1434                                                 if( pLed->bLedOn )\r
1435                                                         pLed->BlinkingLedState = RTW_LED_OFF; \r
1436                                                 else\r
1437                                                         pLed->BlinkingLedState = RTW_LED_ON; \r
1438                                         }\r
1439                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
1440                                 }\r
1441                                 pLed->bLedBlinkInProgress = _FALSE;     \r
1442                         }\r
1443                         else\r
1444                         {\r
1445                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1446                                 {\r
1447                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("RFOff Status \n"));\r
1448                                         SwLedOff(Adapter, pLed);\r
1449                                 }\r
1450                                 else\r
1451                                 {\r
1452                                         if(IS_HARDWARE_TYPE_8812AU(Adapter))\r
1453                                         {\r
1454                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1455                                         }\r
1456                                         else\r
1457                                         {\r
1458                                                 if( pLed->bLedOn )\r
1459                                                         pLed->BlinkingLedState = RTW_LED_OFF; \r
1460                                                 else\r
1461                                                         pLed->BlinkingLedState = RTW_LED_ON; \r
1462                                         }\r
1463                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
1464                                 }\r
1465                         }\r
1466                         break;\r
1467 \r
1468                 case LED_BLINK_LINK_IN_PROCESS:\r
1469                         if( pLed->bLedOn )\r
1470                         {\r
1471                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
1472                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ON_BELKIN);\r
1473                         }\r
1474                         else\r
1475                         {\r
1476                                 pLed->BlinkingLedState = RTW_LED_ON; \r
1477                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_OFF_BELKIN);\r
1478                         }\r
1479                         break;\r
1480 \r
1481                 case LED_BLINK_AUTH_ERROR:\r
1482                         pLed->BlinkTimes--;\r
1483                         if( pLed->BlinkTimes == 0 )\r
1484                         {\r
1485                                 bStopBlinking = _TRUE;\r
1486                         }\r
1487                         if(bStopBlinking == _FALSE)\r
1488                         {\r
1489                                 if( pLed->bLedOn )\r
1490                                 {\r
1491                                         pLed->BlinkingLedState = RTW_LED_OFF; \r
1492                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);\r
1493                                 }\r
1494                                 else\r
1495                                 {\r
1496                                         pLed->BlinkingLedState = RTW_LED_ON; \r
1497                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);\r
1498                                 }\r
1499                         }\r
1500                         else\r
1501                         {\r
1502                                 pLed->CurrLedState = RTW_LED_OFF;\r
1503                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1504                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);\r
1505                         }\r
1506                         break;\r
1507 \r
1508                 default:\r
1509                         break;\r
1510         }\r
1511 \r
1512         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink9 CurrLedState %d\n", pLed->CurrLedState));                                      \r
1513 }\r
1514 \r
1515 //page added for Netgear A6200V2. 20120827\r
1516 void\r
1517 SwLedBlink10(\r
1518         PLED_USB                        pLed\r
1519         )\r
1520 {\r
1521         PADAPTER Adapter = pLed->padapter;\r
1522         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);\r
1523         BOOLEAN bStopBlinking = _FALSE;\r
1524 \r
1525         // Change LED according to BlinkingLedState specified.\r
1526         if( pLed->BlinkingLedState == RTW_LED_ON )\r
1527         {\r
1528                 SwLedOn(Adapter, pLed);\r
1529                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
1530         }\r
1531         else\r
1532         {\r
1533                 SwLedOff(Adapter, pLed);\r
1534                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
1535         }\r
1536 \r
1537 \r
1538         switch(pLed->CurrLedState)\r
1539         {\r
1540                 case RTW_LED_ON:\r
1541                         SwLedOn(Adapter, pLed);\r
1542                         break;\r
1543 \r
1544                 case RTW_LED_OFF:\r
1545                         SwLedOff(Adapter, pLed);\r
1546                         break;\r
1547 \r
1548                 case LED_BLINK_SLOWLY:                  \r
1549                         if( pLed->bLedOn )\r
1550                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1551                         else\r
1552                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1553                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
1554                         break;\r
1555 \r
1556                 case LED_BLINK_StartToBlink:\r
1557                         if( pLed->bLedOn )\r
1558                         {\r
1559                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1560                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
1561                         }\r
1562                         else\r
1563                         {\r
1564                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1565                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
1566                         }\r
1567                         break;\r
1568 \r
1569                 case LED_BLINK_SCAN:\r
1570                         pLed->BlinkTimes--;\r
1571                         if( pLed->BlinkTimes == 0 )\r
1572                         {\r
1573                                 bStopBlinking = _TRUE;\r
1574                         }\r
1575 \r
1576                         if(bStopBlinking)\r
1577                         {\r
1578                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on )\r
1579                                 {\r
1580                                         SwLedOff(Adapter, pLed);\r
1581                                 }\r
1582                                 else if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
1583                                 {\r
1584                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
1585                                         pLed->CurrLedState = RTW_LED_OFF;\r
1586                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1587 \r
1588                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
1589                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
1590                                 }\r
1591                                 pLed->BlinkTimes = 0;\r
1592                                 pLed->bLedBlinkInProgress = _FALSE;\r
1593                         }\r
1594                         else\r
1595                         {\r
1596                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1597                                 {\r
1598                                         SwLedOff(Adapter, pLed);\r
1599                                 }\r
1600                                 else\r
1601                                 {\r
1602                                         if( pLed->bLedOn )\r
1603                                         {\r
1604                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1605                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);\r
1606                                         }\r
1607                                         else\r
1608                                         {\r
1609                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1610                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_SLOWLY_INTERVAL_NETGEAR+LED_BLINK_LINK_INTERVAL_NETGEAR);\r
1611                                         }\r
1612                                 }\r
1613                         }\r
1614                         break;\r
1615 \r
1616                 case LED_BLINK_WPS:\r
1617                         if( pLed->bLedOn )\r
1618                         {\r
1619                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1620                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);\r
1621                         }\r
1622                         else\r
1623                         {\r
1624                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1625                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL+LED_BLINK_LINK_INTERVAL_NETGEAR);\r
1626                         }\r
1627                         break;\r
1628 \r
1629                 case LED_BLINK_WPS_STOP:        //WPS authentication fail\r
1630                         if( pLed->bLedOn )\r
1631                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1632                         else    \r
1633                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1634 \r
1635                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
1636                         break;\r
1637 \r
1638                 case LED_BLINK_WPS_STOP_OVERLAP:        //WPS session overlap\r
1639                         pLed->BlinkTimes--;\r
1640                         pLed->BlinkCounter --;\r
1641                         if(pLed->BlinkCounter == 0)\r
1642                         {\r
1643                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1644                                 pLed->CurrLedState = RTW_LED_OFF;\r
1645                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
1646                         }\r
1647                         else\r
1648                         {\r
1649                                 if(pLed->BlinkTimes == 0)\r
1650                                 {\r
1651                                         if(pLed->bLedOn)\r
1652                                         {\r
1653                                                 pLed->BlinkTimes = 1;\r
1654                                         }\r
1655                                         else\r
1656                                         {\r
1657                                                 bStopBlinking = _TRUE;\r
1658                                         }\r
1659                                 }\r
1660 \r
1661                                 if(bStopBlinking)\r
1662                                 {\r
1663                                         pLed->BlinkTimes = 10;\r
1664                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1665                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
1666                                 }\r
1667                                 else\r
1668                                 {\r
1669                                         if( pLed->bLedOn )\r
1670                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1671                                         else    \r
1672                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1673 \r
1674                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
1675                                 }\r
1676                         }\r
1677                         break;\r
1678 \r
1679                 case LED_BLINK_ALWAYS_ON:\r
1680                         pLed->BlinkTimes--;\r
1681                         if( pLed->BlinkTimes == 0 )\r
1682                         {\r
1683                                 bStopBlinking = _TRUE;\r
1684                         }\r
1685                         if(bStopBlinking)\r
1686                         {\r
1687                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1688                                 {\r
1689                                         SwLedOff(Adapter, pLed);\r
1690                                 }\r
1691                                 else\r
1692                                 {\r
1693                                         if(IS_HARDWARE_TYPE_8812AU(Adapter))\r
1694                                         {\r
1695                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1696                                                 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;\r
1697                                         }\r
1698                                         else\r
1699                                         {\r
1700                                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
1701                                                 pLed->CurrLedState = LED_BLINK_SLOWLY;\r
1702                                                 if( pLed->bLedOn )\r
1703                                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1704                                                 else\r
1705                                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1706                                         }\r
1707                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
1708                                 }\r
1709                                 pLed->bLedBlinkInProgress = _FALSE;\r
1710                         }\r
1711                         else\r
1712                         {\r
1713                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1714                                 {\r
1715                                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("RFOff Status \n"));\r
1716                                         SwLedOff(Adapter, pLed);\r
1717                                 }\r
1718                                 else\r
1719                                 {\r
1720                                         if(IS_HARDWARE_TYPE_8812AU(Adapter))\r
1721                                         {\r
1722                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1723                                         }\r
1724                                         else\r
1725                                         {\r
1726                                                 if( pLed->bLedOn )\r
1727                                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1728                                                 else\r
1729                                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1730                                         }\r
1731                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
1732                                 }\r
1733                         }\r
1734                         break;\r
1735 \r
1736                 case LED_BLINK_LINK_IN_PROCESS:\r
1737                         if( pLed->bLedOn )\r
1738                         {\r
1739                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1740                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ON_BELKIN);\r
1741                         }\r
1742                         else\r
1743                         {\r
1744                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1745                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_OFF_BELKIN);\r
1746                         }\r
1747                         break;\r
1748 \r
1749                 case LED_BLINK_AUTH_ERROR:\r
1750                         pLed->BlinkTimes--;\r
1751                         if( pLed->BlinkTimes == 0 )\r
1752                         {\r
1753                                 bStopBlinking = _TRUE;\r
1754                         }\r
1755                         if(bStopBlinking == _FALSE)\r
1756                         {\r
1757                                 if( pLed->bLedOn )\r
1758                                 {\r
1759                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1760                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);\r
1761                                 }\r
1762                                 else\r
1763                                 {\r
1764                                         pLed->BlinkingLedState = RTW_LED_ON; \r
1765                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);\r
1766                                 }\r
1767                         }\r
1768                         else\r
1769                         {\r
1770                                 pLed->CurrLedState = RTW_LED_OFF;\r
1771                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1772                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_ERROR_INTERVAL_BELKIN);\r
1773                         }\r
1774                         break;\r
1775 \r
1776                 default:\r
1777                         break;\r
1778         }\r
1779 \r
1780         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink10 CurrLedState %d\n", pLed->CurrLedState));\r
1781 \r
1782 }\r
1783 \r
1784 void\r
1785 SwLedBlink11(\r
1786         PLED_USB                        pLed\r
1787         )\r
1788 {\r
1789         PADAPTER Adapter = pLed->padapter;\r
1790         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);\r
1791         BOOLEAN bStopBlinking = _FALSE;\r
1792 \r
1793         // Change LED according to BlinkingLedState specified.\r
1794         if( pLed->BlinkingLedState == RTW_LED_ON )\r
1795         {\r
1796                 SwLedOn(Adapter, pLed);\r
1797                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
1798         }\r
1799         else\r
1800         {\r
1801                 SwLedOff(Adapter, pLed);\r
1802                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
1803         }\r
1804 \r
1805         switch(pLed->CurrLedState)\r
1806         {\r
1807                 case LED_BLINK_TXRX:\r
1808                         if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1809                         {\r
1810                                 SwLedOff(Adapter, pLed);\r
1811                         }\r
1812                         else\r
1813                         {\r
1814                                  if( pLed->bLedOn )\r
1815                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1816                                 else\r
1817                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1818                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
1819                         }\r
1820 \r
1821                         break;\r
1822 \r
1823                 case LED_BLINK_WPS:\r
1824                         if(pLed->BlinkTimes == 5)\r
1825                         {\r
1826                                 SwLedOn(Adapter, pLed);\r
1827                                 _set_timer(&(pLed->BlinkTimer), LED_CM11_LINK_ON_INTERVEL);\r
1828                         }\r
1829                         else\r
1830                         {\r
1831                                 if( pLed->bLedOn )\r
1832                                 {\r
1833                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1834                                         _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);\r
1835                                 }\r
1836                                 else\r
1837                                 {\r
1838                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1839                                         _set_timer(&(pLed->BlinkTimer), LED_CM11_BLINK_INTERVAL);\r
1840                                 }\r
1841                         }\r
1842                         pLed->BlinkTimes--;\r
1843                         if( pLed->BlinkTimes == 0 )\r
1844                         {\r
1845                                 bStopBlinking = _TRUE;\r
1846                         }\r
1847                         if(bStopBlinking == _TRUE)\r
1848                                 pLed->BlinkTimes = 5;\r
1849                         break;\r
1850 \r
1851                 case LED_BLINK_WPS_STOP:        //WPS authentication fail\r
1852                         if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
1853                         {\r
1854                                 if( pLed->bLedOn )\r
1855                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1856                                 else\r
1857                                         pLed->BlinkingLedState = RTW_LED_ON;\r
1858                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
1859                         }\r
1860                         else\r
1861                         {\r
1862                                 pLed->CurrLedState = RTW_LED_ON;\r
1863                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1864                                 SwLedOn(Adapter, pLed);\r
1865                                 _set_timer(&(pLed->BlinkTimer), 0);\r
1866                         }\r
1867                         break;\r
1868 \r
1869                 default:\r
1870                         break;\r
1871         }\r
1872 \r
1873         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink5 CurrLedState %d\n", pLed->CurrLedState));\r
1874 }\r
1875 \r
1876 void\r
1877 SwLedBlink12(\r
1878         PLED_USB                        pLed\r
1879         )\r
1880 {\r
1881         PADAPTER Adapter = pLed->padapter;\r
1882         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);\r
1883         BOOLEAN bStopBlinking = _FALSE;\r
1884 \r
1885         // Change LED according to BlinkingLedState specified.\r
1886         if( pLed->BlinkingLedState == RTW_LED_ON )\r
1887         {\r
1888                 SwLedOn(Adapter, pLed);\r
1889                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%ld): turn on\n", pLed->BlinkTimes));\r
1890         }\r
1891         else\r
1892         {\r
1893                 SwLedOff(Adapter, pLed);\r
1894                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%ld): turn off\n", pLed->BlinkTimes));\r
1895         }\r
1896 \r
1897         switch(pLed->CurrLedState)\r
1898         {\r
1899                 case LED_BLINK_SLOWLY:\r
1900                         if( pLed->bLedOn )\r
1901                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1902                         else\r
1903                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1904                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
1905                         break;\r
1906 \r
1907                 case LED_BLINK_TXRX:\r
1908                         pLed->BlinkTimes--;\r
1909                         if( pLed->BlinkTimes == 0 )\r
1910                         {\r
1911                                 bStopBlinking = _TRUE;\r
1912                         }\r
1913 \r
1914                         if(bStopBlinking)\r
1915                         {\r
1916                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1917                                 {\r
1918                                         pLed->CurrLedState = RTW_LED_OFF;\r
1919                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
1920                                         if(pLed->bLedOn)\r
1921                                                 SwLedOff(Adapter, pLed);\r
1922                                 }\r
1923                                 else\r
1924                                 {\r
1925                                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
1926                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
1927                                         if( pLed->bLedOn )\r
1928                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1929                                         else\r
1930                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1931                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
1932                                 }\r
1933 \r
1934                                 pLed->bLedBlinkInProgress = _FALSE;\r
1935                         }\r
1936                         else\r
1937                         {\r
1938                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
1939                                 {\r
1940                                         SwLedOff(Adapter, pLed);\r
1941                                 }\r
1942                                 else\r
1943                                 {\r
1944                                          if( pLed->bLedOn )\r
1945                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
1946                                         else\r
1947                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
1948                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
1949                                 }\r
1950                         }\r
1951                         break;\r
1952 \r
1953                 default:\r
1954                         break;\r
1955         }\r
1956 \r
1957         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SwLedBlink8 CurrLedState %d\n", pLed->CurrLedState));\r
1958 \r
1959 \r
1960 }\r
1961 \r
1962 VOID\r
1963 SwLedBlink13(\r
1964         IN PLED_USB                     pLed\r
1965         )\r
1966 {\r
1967         PADAPTER Adapter = pLed->padapter;\r
1968         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);\r
1969         BOOLEAN bStopBlinking = _FALSE;\r
1970         static u8       LinkBlinkCnt=0;\r
1971 \r
1972         // Change LED according to BlinkingLedState specified.\r
1973         if( pLed->BlinkingLedState == RTW_LED_ON ) \r
1974         {\r
1975                 SwLedOn(Adapter, pLed);\r
1976                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
1977         }\r
1978         else \r
1979         {\r
1980                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)\r
1981                         SwLedOff(Adapter, pLed);\r
1982                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
1983         }       \r
1984         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("!!! SwLedBlink13 CurrLedState %d, bLedWPSBlinkInProgress %d, bLedBlinkInProgress %d\n", pLed->CurrLedState,pLed->bLedWPSBlinkInProgress,pLed->bLedBlinkInProgress));\r
1985         switch(pLed->CurrLedState)\r
1986         {                       \r
1987                 case LED_BLINK_LINK_IN_PROCESS:\r
1988                         if(!pLed->bLedWPSBlinkInProgress)\r
1989                                 LinkBlinkCnt++;\r
1990                         \r
1991                         if(LinkBlinkCnt>15)\r
1992                         {\r
1993                                 LinkBlinkCnt=0;\r
1994                                 pLed->bLedBlinkInProgress = _FALSE;\r
1995                                 break;\r
1996                         }\r
1997                         if( pLed->bLedOn )\r
1998                         {\r
1999                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
2000                                 _set_timer(&(pLed->BlinkTimer), 500);\r
2001                         }\r
2002                         else\r
2003                         {\r
2004                                 pLed->BlinkingLedState = RTW_LED_ON; \r
2005                                 _set_timer(&(pLed->BlinkTimer), 500);\r
2006                         }\r
2007 \r
2008                         break;\r
2009 \r
2010                 case LED_BLINK_WPS:\r
2011                         if( pLed->bLedOn )\r
2012                         {\r
2013                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
2014                                 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);\r
2015                         }\r
2016                         else\r
2017                         {\r
2018                                 pLed->BlinkingLedState = RTW_LED_ON; \r
2019                                 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);\r
2020                         }\r
2021                         \r
2022                         break;\r
2023 \r
2024                 case LED_BLINK_WPS_STOP:        //WPS success\r
2025                         SwLedOff(Adapter, pLed);        \r
2026                         pLed->bLedWPSBlinkInProgress = _FALSE;  \r
2027                         break;\r
2028                                         \r
2029                 default:\r
2030                         LinkBlinkCnt=0;\r
2031                         break;\r
2032         }\r
2033 \r
2034         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink13\n"));\r
2035 \r
2036 }\r
2037 \r
2038 VOID\r
2039 SwLedBlink14(\r
2040         IN PLED_USB                     pLed\r
2041         )\r
2042 {\r
2043         PADAPTER Adapter = pLed->padapter;\r
2044         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);\r
2045         BOOLEAN bStopBlinking = _FALSE;\r
2046         static u8       LinkBlinkCnt=0;\r
2047 \r
2048         // Change LED according to BlinkingLedState specified.\r
2049         if( pLed->BlinkingLedState == RTW_LED_ON )\r
2050         {\r
2051                 SwLedOn(Adapter, pLed);\r
2052                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
2053         }\r
2054         else \r
2055         {\r
2056                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)\r
2057                         SwLedOff(Adapter, pLed);\r
2058                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
2059         }       \r
2060         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("!!! SwLedBlink14 CurrLedState %d, bLedWPSBlinkInProgress %d, bLedBlinkInProgress %d\n", pLed->CurrLedState,pLed->bLedWPSBlinkInProgress,pLed->bLedBlinkInProgress));\r
2061         switch(pLed->CurrLedState)\r
2062         {                       \r
2063                 case LED_BLINK_TXRX:\r
2064                         pLed->BlinkTimes--;\r
2065                         if( pLed->BlinkTimes == 0 )\r
2066                         {\r
2067                                 bStopBlinking = _TRUE;\r
2068                         }\r
2069                         if(bStopBlinking)\r
2070                         {\r
2071                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
2072                                 {\r
2073                                         SwLedOff(Adapter, pLed);\r
2074                                 }\r
2075                                 else \r
2076                                 {\r
2077                                         SwLedOn(Adapter, pLed);\r
2078                                 }\r
2079                                 pLed->bLedBlinkInProgress = _FALSE;     \r
2080                         }\r
2081                         else\r
2082                         {\r
2083                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
2084                                 {\r
2085                                         SwLedOff(Adapter, pLed);\r
2086                                 }\r
2087                                 else\r
2088                                 {\r
2089                                         if( pLed->bLedOn )\r
2090                                         {\r
2091                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
2092                                                 if (IS_HARDWARE_TYPE_8812AU(Adapter))\r
2093                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
2094                                                 else\r
2095                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
2096                                         }\r
2097                                         else\r
2098                                         {\r
2099                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
2100                                                 if (IS_HARDWARE_TYPE_8812AU(Adapter))\r
2101                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
2102                                                 else\r
2103                                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
2104                                         }\r
2105                                 }\r
2106                         }\r
2107 \r
2108                         break;\r
2109                                         \r
2110                 default:\r
2111                         LinkBlinkCnt=0;\r
2112                         break;\r
2113         }\r
2114 \r
2115         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink14\n"));\r
2116 }\r
2117 \r
2118 VOID\r
2119 SwLedBlink15(\r
2120         IN PLED_USB                     pLed\r
2121         )\r
2122 {\r
2123         PADAPTER Adapter = pLed->padapter;\r
2124         struct mlme_priv        *pmlmepriv = &(Adapter->mlmepriv);\r
2125         BOOLEAN bStopBlinking = _FALSE;\r
2126         static u8       LinkBlinkCnt=0;\r
2127         // Change LED according to BlinkingLedState specified.\r
2128         \r
2129         if( pLed->BlinkingLedState == RTW_LED_ON ) \r
2130         {\r
2131                 SwLedOn(Adapter, pLed);\r
2132                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn on\n", pLed->BlinkTimes));\r
2133         }\r
2134         else \r
2135         {\r
2136                 if(pLed->CurrLedState != LED_BLINK_WPS_STOP)\r
2137                         SwLedOff(Adapter, pLed);\r
2138                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Blinktimes (%d): turn off\n", pLed->BlinkTimes));\r
2139         }       \r
2140         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("!!! SwLedBlink15 CurrLedState %d, bLedWPSBlinkInProgress %d, bLedBlinkInProgress %d\n", pLed->CurrLedState,pLed->bLedWPSBlinkInProgress,pLed->bLedBlinkInProgress));\r
2141         switch(pLed->CurrLedState)\r
2142         {\r
2143                 case LED_BLINK_WPS:\r
2144                         if( pLed->bLedOn )\r
2145                         {\r
2146                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
2147                                 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_DLINK);\r
2148                         }\r
2149                         else\r
2150                         {\r
2151                                 pLed->BlinkingLedState = RTW_LED_ON; \r
2152                                 _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_DLINK);\r
2153                         }\r
2154                         break;\r
2155         \r
2156                 case LED_BLINK_WPS_STOP:        //WPS success\r
2157                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("blink15, LED_BLINK_WPS_STOP  BlinkingLedState %d\n",pLed->BlinkingLedState));\r
2158                         \r
2159                         if(pLed->BlinkingLedState == RTW_LED_OFF)\r
2160                         {\r
2161                                 pLed->bLedWPSBlinkInProgress = _FALSE;  \r
2162                                 return;\r
2163                         }\r
2164                         \r
2165                         pLed->CurrLedState = LED_BLINK_WPS_STOP;\r
2166                         pLed->BlinkingLedState = RTW_LED_OFF;   \r
2167 \r
2168                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_LINKED_ON_INTERVAL_DLINK);                        \r
2169                         break;\r
2170 \r
2171                 case LED_BLINK_NO_LINK:\r
2172                         {\r
2173                                 static BOOLEAN          bLedOn=_TRUE;\r
2174                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("blink15, LED_NO_LINK_BLINK  bLedOn %d\n",bLedOn));\r
2175                                 if(bLedOn)\r
2176                                 {\r
2177                                         bLedOn=_FALSE;\r
2178                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2179                                 }\r
2180                                 else\r
2181                                 {\r
2182                                         bLedOn=_TRUE;\r
2183                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2184                                 }\r
2185                                 pLed->bLedBlinkInProgress = _TRUE;\r
2186                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL);\r
2187                         }\r
2188                         break;\r
2189 \r
2190                 case LED_BLINK_LINK_IDEL:\r
2191                         {\r
2192                                 static BOOLEAN          bLedOn=_TRUE;\r
2193                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("blink15, LED_BLINK_LINK_IDEL  bLedOn %d\n",bLedOn));\r
2194                                 if(bLedOn)\r
2195                                 {\r
2196                                         bLedOn=_FALSE;\r
2197                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2198                                 }\r
2199                                 else\r
2200                                 {\r
2201                                         bLedOn=_TRUE;\r
2202                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2203                                         \r
2204                                 }\r
2205                                 pLed->bLedBlinkInProgress = _TRUE;\r
2206                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_IDEL_INTERVAL);\r
2207                         }       \r
2208                         break;\r
2209 \r
2210                 case LED_BLINK_SCAN:\r
2211                         {\r
2212                                 static u8       BlinkTime=0;\r
2213                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("blink15, LED_SCAN_BLINK  bLedOn %d\n",BlinkTime));\r
2214                                 if(BlinkTime %2==0)\r
2215                                 {\r
2216                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2217                                 }\r
2218                                 else\r
2219                                 {\r
2220                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2221                                 }\r
2222                                 BlinkTime ++;\r
2223 \r
2224                                 if(BlinkTime<24)\r
2225                                 {\r
2226                                         pLed->bLedBlinkInProgress = _TRUE;\r
2227                                         \r
2228                                         if(pLed->BlinkingLedState == RTW_LED_ON)\r
2229                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_OFF_INTERVAL);\r
2230                                         else\r
2231                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_ON_INTERVAL);\r
2232                                 }\r
2233                                 else\r
2234                                 {\r
2235                                         //if(pLed->OLDLedState ==LED_NO_LINK_BLINK)\r
2236                                         if(check_fwstate(pmlmepriv, _FW_LINKED)== _FALSE)\r
2237                                         {\r
2238                                                 pLed->CurrLedState = LED_BLINK_NO_LINK;\r
2239                                                 pLed->BlinkingLedState = RTW_LED_ON;    \r
2240 \r
2241                                                 _set_timer(&(pLed->BlinkTimer), 100);\r
2242                                         }\r
2243                                         BlinkTime =0;\r
2244                                 }\r
2245                         }\r
2246                         break;\r
2247 \r
2248                 case LED_BLINK_TXRX:\r
2249                         pLed->BlinkTimes--;\r
2250                         if( pLed->BlinkTimes == 0 )\r
2251                         {\r
2252                                 bStopBlinking = _TRUE;\r
2253                         }\r
2254                         if(bStopBlinking)\r
2255                         {\r
2256                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
2257                                 {\r
2258                                         SwLedOff(Adapter, pLed);\r
2259                                 }\r
2260                                 else\r
2261                                 {\r
2262                                         SwLedOn(Adapter, pLed);\r
2263                                 }\r
2264                                 pLed->bLedBlinkInProgress = _FALSE;\r
2265                         }\r
2266                         else\r
2267                         {\r
2268                                 if( adapter_to_pwrctl(Adapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(Adapter)->rfoff_reason > RF_CHANGE_BY_PS)\r
2269                                 {\r
2270                                         SwLedOff(Adapter, pLed);\r
2271                                 }\r
2272                                 else\r
2273                                 {\r
2274                                         if( pLed->bLedOn )\r
2275                                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
2276                                         else\r
2277                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
2278                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
2279                                 }\r
2280                         }\r
2281                         break;\r
2282 \r
2283                 default:\r
2284                         LinkBlinkCnt=0;\r
2285                         break;\r
2286         }\r
2287 \r
2288         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("<==== blink15\n"));\r
2289 }\r
2290 \r
2291 //\r
2292 //      Description:\r
2293 //              Handler function of LED Blinking.\r
2294 //              We dispatch acture LED blink action according to LedStrategy.\r
2295 //\r
2296 void BlinkHandler(PLED_USB pLed)\r
2297 {\r
2298         _adapter                *padapter = pLed->padapter;\r
2299         struct led_priv *ledpriv = &(padapter->ledpriv);\r
2300 \r
2301         //DBG_871X("%s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);\r
2302 \r
2303         if( (padapter->bSurpriseRemoved == _TRUE) || (padapter->hw_init_completed == _FALSE))   \r
2304         {\r
2305                 //DBG_871X("%s bSurpriseRemoved:%d, bDriverStopped:%d\n", __FUNCTION__, padapter->bSurpriseRemoved, padapter->bDriverStopped);\r
2306                 return;\r
2307         }\r
2308 \r
2309         switch(ledpriv->LedStrategy)\r
2310         {\r
2311                 case SW_LED_MODE0:\r
2312                         SwLedBlink(pLed);\r
2313                         break;\r
2314                 \r
2315                 case SW_LED_MODE1:\r
2316                         SwLedBlink1(pLed);\r
2317                         break;\r
2318                 \r
2319                 case SW_LED_MODE2:\r
2320                         SwLedBlink2(pLed);\r
2321                         break;\r
2322                         \r
2323                 case SW_LED_MODE3:\r
2324                         SwLedBlink3(pLed);\r
2325                         break;\r
2326 \r
2327                 case SW_LED_MODE4:\r
2328                         SwLedBlink4(pLed);\r
2329                         break;                  \r
2330 \r
2331                 case SW_LED_MODE5:\r
2332                         SwLedBlink5(pLed);\r
2333                         break;\r
2334 \r
2335                 case SW_LED_MODE6:\r
2336                         SwLedBlink6(pLed);\r
2337                         break;\r
2338 \r
2339                 case SW_LED_MODE7:\r
2340                         SwLedBlink7(pLed);\r
2341                         break;\r
2342 \r
2343                 case SW_LED_MODE8:\r
2344                         SwLedBlink8(pLed);\r
2345                         break;\r
2346 \r
2347                 case SW_LED_MODE9:\r
2348                         SwLedBlink9(pLed);\r
2349                         break;\r
2350 \r
2351                 case SW_LED_MODE10:\r
2352                         SwLedBlink10(pLed);\r
2353                         break;\r
2354 \r
2355                 case SW_LED_MODE11:\r
2356                         SwLedBlink11(pLed);\r
2357                         break;\r
2358 \r
2359                 case SW_LED_MODE12:\r
2360                         SwLedBlink12(pLed);\r
2361                         break;\r
2362 \r
2363                 case SW_LED_MODE13:\r
2364                         SwLedBlink13(pLed);\r
2365                         break;\r
2366 \r
2367                 case SW_LED_MODE14:\r
2368                         SwLedBlink14(pLed);\r
2369                         break;\r
2370 \r
2371                 case SW_LED_MODE15:\r
2372                         SwLedBlink15(pLed);\r
2373                         break;\r
2374 \r
2375                 default:\r
2376                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("BlinkWorkItemCallback 0x%x \n", ledpriv->LedStrategy));\r
2377                         //SwLedBlink(pLed);\r
2378                         break;\r
2379         }\r
2380 }\r
2381 \r
2382 //\r
2383 //      Description:\r
2384 //              Callback function of LED BlinkTimer, \r
2385 //              it just schedules to corresponding BlinkWorkItem/led_blink_hdl\r
2386 //\r
2387 void BlinkTimerCallback(void *data)\r
2388 {\r
2389         PLED_USB         pLed = (PLED_USB)data;\r
2390         _adapter                *padapter = pLed->padapter;\r
2391 \r
2392         //DBG_871X("%s\n", __FUNCTION__);\r
2393 \r
2394         if( (padapter->bSurpriseRemoved == _TRUE) || (padapter->hw_init_completed == _FALSE))   \r
2395         {\r
2396                 //DBG_871X("%s bSurpriseRemoved:%d, bDriverStopped:%d\n", __FUNCTION__, padapter->bSurpriseRemoved, padapter->bDriverStopped);\r
2397                 return;\r
2398         }\r
2399 \r
2400         #ifdef CONFIG_LED_HANDLED_BY_CMD_THREAD\r
2401         rtw_led_blink_cmd(padapter, (PVOID)pLed);\r
2402         #else\r
2403         if(ATOMIC_READ(&pLed->bCancelWorkItem) == _FALSE)\r
2404                 _set_workitem(&(pLed->BlinkWorkItem));\r
2405         #endif\r
2406 }\r
2407 \r
2408 //\r
2409 //      Description:\r
2410 //              Callback function of LED BlinkWorkItem.\r
2411 //              We dispatch acture LED blink action according to LedStrategy.\r
2412 //\r
2413 void BlinkWorkItemCallback(_workitem *work)\r
2414 {\r
2415         PLED_USB         pLed = container_of(work, LED_USB, BlinkWorkItem);\r
2416         BlinkHandler(pLed);\r
2417 }\r
2418 \r
2419 static void\r
2420 SwLedControlMode0(\r
2421         _adapter                *padapter,\r
2422         LED_CTL_MODE            LedAction\r
2423 )\r
2424 {\r
2425         struct led_priv *ledpriv = &(padapter->ledpriv);\r
2426         PLED_USB        pLed = &(ledpriv->SwLed1);\r
2427 \r
2428         // Decide led state\r
2429         switch(LedAction)\r
2430         {\r
2431         case LED_CTL_TX:\r
2432         case LED_CTL_RX:\r
2433                 if( pLed->bLedBlinkInProgress == _FALSE )\r
2434                 {\r
2435                         pLed->bLedBlinkInProgress = _TRUE;\r
2436 \r
2437                         pLed->CurrLedState = LED_BLINK_NORMAL;\r
2438                         pLed->BlinkTimes = 2;\r
2439 \r
2440                         if( pLed->bLedOn )\r
2441                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
2442                         else\r
2443                                 pLed->BlinkingLedState = RTW_LED_ON;\r
2444                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
2445                 }\r
2446                 break;\r
2447 \r
2448         case LED_CTL_START_TO_LINK:\r
2449                 if( pLed->bLedBlinkInProgress == _FALSE )\r
2450                 {\r
2451                         pLed->bLedBlinkInProgress = _TRUE;\r
2452 \r
2453                         pLed->CurrLedState = LED_BLINK_StartToBlink;\r
2454                         pLed->BlinkTimes = 24;\r
2455 \r
2456                         if( pLed->bLedOn )\r
2457                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
2458                         else\r
2459                                 pLed->BlinkingLedState = RTW_LED_ON;\r
2460                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
2461                 }\r
2462                 else\r
2463                 {\r
2464                         pLed->CurrLedState = LED_BLINK_StartToBlink;\r
2465                 }\r
2466                 break;\r
2467 \r
2468         case LED_CTL_LINK:\r
2469                 pLed->CurrLedState = RTW_LED_ON;\r
2470                 if( pLed->bLedBlinkInProgress == _FALSE )\r
2471                 {\r
2472                         pLed->BlinkingLedState = RTW_LED_ON;\r
2473                         _set_timer(&(pLed->BlinkTimer), 0);\r
2474                 }\r
2475                 break;\r
2476 \r
2477         case LED_CTL_NO_LINK:\r
2478                 pLed->CurrLedState = RTW_LED_OFF;\r
2479                 if( pLed->bLedBlinkInProgress == _FALSE )\r
2480                 {\r
2481                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2482                         _set_timer(&(pLed->BlinkTimer), 0);\r
2483                 }\r
2484                 break;\r
2485 \r
2486         case LED_CTL_POWER_OFF:\r
2487                 pLed->CurrLedState = RTW_LED_OFF;\r
2488                 if(pLed->bLedBlinkInProgress)\r
2489                 {\r
2490                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2491                         pLed->bLedBlinkInProgress = _FALSE;\r
2492                 }\r
2493                 SwLedOff(padapter, pLed);\r
2494                 break;\r
2495 \r
2496         case LED_CTL_START_WPS:\r
2497                 if( pLed->bLedBlinkInProgress == _FALSE || pLed->CurrLedState == RTW_LED_ON)\r
2498                 {\r
2499                         pLed->bLedBlinkInProgress = _TRUE;\r
2500 \r
2501                         pLed->CurrLedState = LED_BLINK_WPS;\r
2502                         pLed->BlinkTimes = 20;\r
2503 \r
2504                         if( pLed->bLedOn )\r
2505                         {\r
2506                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
2507                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);\r
2508                         }\r
2509                         else\r
2510                         {\r
2511                                 pLed->BlinkingLedState = RTW_LED_ON;\r
2512                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LONG_INTERVAL);\r
2513                         }\r
2514                 }\r
2515                 break;\r
2516 \r
2517         case LED_CTL_STOP_WPS:\r
2518                 if(pLed->bLedBlinkInProgress)\r
2519                 {\r
2520                         pLed->CurrLedState = RTW_LED_OFF;\r
2521                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2522                         pLed->bLedBlinkInProgress = _FALSE;\r
2523                 }\r
2524                 break;\r
2525 \r
2526 \r
2527         default:\r
2528                 break;\r
2529         }\r
2530 \r
2531         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));\r
2532 \r
2533 }\r
2534 \r
2535  //ALPHA, added by chiyoko, 20090106\r
2536 static void\r
2537 SwLedControlMode1(\r
2538         _adapter                *padapter,\r
2539         LED_CTL_MODE            LedAction\r
2540 )\r
2541 {\r
2542         struct led_priv         *ledpriv = &(padapter->ledpriv);\r
2543         PLED_USB                        pLed = &(ledpriv->SwLed0);\r
2544         struct mlme_priv                *pmlmepriv = &(padapter->mlmepriv);\r
2545         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(padapter);\r
2546 \r
2547         u32 uLedBlinkNoLinkInterval = LED_BLINK_NO_LINK_INTERVAL_ALPHA; //add by ylb 20121012 for customer led for alpha\r
2548         if(pHalData->CustomerID == RT_CID_819x_ALPHA_Dlink)\r
2549                 uLedBlinkNoLinkInterval= LED_BLINK_NO_LINK_INTERVAL_ALPHA_500MS;        \r
2550         \r
2551         if(pHalData->CustomerID == RT_CID_819x_CAMEO)\r
2552                 pLed = &(ledpriv->SwLed1);\r
2553 \r
2554         switch(LedAction)\r
2555         {\r
2556                 case LED_CTL_POWER_ON:\r
2557                 case LED_CTL_START_TO_LINK:\r
2558                 case LED_CTL_NO_LINK:\r
2559                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )\r
2560                         {\r
2561                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
2562                                 {\r
2563                                         return;\r
2564                                 }\r
2565                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )\r
2566                                 {\r
2567                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2568                                         pLed->bLedLinkBlinkInProgress = _FALSE;\r
2569                                 }\r
2570                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
2571                                 {\r
2572                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2573                                         pLed->bLedBlinkInProgress = _FALSE;\r
2574                                 }\r
2575 \r
2576                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
2577                                 pLed->CurrLedState = LED_BLINK_SLOWLY;\r
2578                                 if( pLed->bLedOn )\r
2579                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2580                                 else\r
2581                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2582                                 _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);//change by ylb 20121012 for customer led for alpha\r
2583                         }\r
2584                         break;\r
2585 \r
2586                 case LED_CTL_LINK:\r
2587                         if( pLed->bLedLinkBlinkInProgress == _FALSE )\r
2588                         {\r
2589                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
2590                                 {\r
2591                                         return;\r
2592                                 }\r
2593                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
2594                                 {\r
2595                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2596                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
2597                                 }\r
2598                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
2599                                 {\r
2600                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2601                                         pLed->bLedBlinkInProgress = _FALSE;\r
2602                                 }\r
2603                                 pLed->bLedLinkBlinkInProgress = _TRUE;\r
2604                                 pLed->CurrLedState = LED_BLINK_NORMAL;\r
2605                                 if( pLed->bLedOn )\r
2606                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2607                                 else\r
2608                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2609                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
2610                         }\r
2611                         break;\r
2612 \r
2613                 case LED_CTL_SITE_SURVEY:\r
2614                          if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))\r
2615                                 ;\r
2616                          else if(pLed->bLedScanBlinkInProgress ==_FALSE)\r
2617                          {\r
2618                                 if(IS_LED_WPS_BLINKING(pLed))\r
2619                                         return;\r
2620 \r
2621                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
2622                                 {\r
2623                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2624                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
2625                                 }\r
2626                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )\r
2627                                 {\r
2628                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2629                                          pLed->bLedLinkBlinkInProgress = _FALSE;\r
2630                                 }\r
2631                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
2632                                 {\r
2633                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2634                                         pLed->bLedBlinkInProgress = _FALSE;\r
2635                                 }\r
2636                                 pLed->bLedScanBlinkInProgress = _TRUE;\r
2637                                 pLed->CurrLedState = LED_BLINK_SCAN;\r
2638                                 pLed->BlinkTimes = 24;\r
2639                                 if( pLed->bLedOn )\r
2640                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2641                                 else\r
2642                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2643 \r
2644                                 if (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on && adapter_to_pwrctl(padapter)->rfoff_reason == RF_CHANGE_BY_IPS)\r
2645                                         _set_timer(&(pLed->BlinkTimer), LED_INITIAL_INTERVAL);\r
2646                                 else                                    \r
2647                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
2648 \r
2649                          }\r
2650                         break;\r
2651 \r
2652                 case LED_CTL_TX:\r
2653                 case LED_CTL_RX:\r
2654                         if(pLed->bLedBlinkInProgress ==_FALSE)\r
2655                         {\r
2656                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
2657                                 {\r
2658                                         return;\r
2659                                 }\r
2660                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
2661                                 {\r
2662                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2663                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
2664                                 }\r
2665                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )\r
2666                                 {\r
2667                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2668                                         pLed->bLedLinkBlinkInProgress = _FALSE;\r
2669                                 }\r
2670                                 pLed->bLedBlinkInProgress = _TRUE;\r
2671                                 pLed->CurrLedState = LED_BLINK_TXRX;\r
2672                                 pLed->BlinkTimes = 2;\r
2673                                 if( pLed->bLedOn )\r
2674                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2675                                 else\r
2676                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2677                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
2678                         }\r
2679                         break;\r
2680 \r
2681                 case LED_CTL_START_WPS: //wait until xinpin finish\r
2682                 case LED_CTL_START_WPS_BOTTON:\r
2683                          if(pLed->bLedWPSBlinkInProgress ==_FALSE)\r
2684                          {\r
2685                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
2686                                 {\r
2687                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2688                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
2689                                 }\r
2690                                 if( pLed->bLedLinkBlinkInProgress == _TRUE )\r
2691                                 {\r
2692                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2693                                          pLed->bLedLinkBlinkInProgress = _FALSE;\r
2694                                 }\r
2695                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
2696                                 {\r
2697                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2698                                         pLed->bLedBlinkInProgress = _FALSE;\r
2699                                 }\r
2700                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)\r
2701                                 {\r
2702                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2703                                         pLed->bLedScanBlinkInProgress = _FALSE;\r
2704                                 }\r
2705                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
2706                                 pLed->CurrLedState = LED_BLINK_WPS;\r
2707                                 if( pLed->bLedOn )\r
2708                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2709                                 else\r
2710                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2711                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
2712                          }\r
2713                         break;\r
2714 \r
2715 \r
2716                 case LED_CTL_STOP_WPS:\r
2717                         if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
2718                         {\r
2719                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2720                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
2721                         }\r
2722                         if( pLed->bLedLinkBlinkInProgress == _TRUE )\r
2723                         {\r
2724                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2725                                  pLed->bLedLinkBlinkInProgress = _FALSE;\r
2726                         }\r
2727                         if(pLed->bLedBlinkInProgress ==_TRUE)\r
2728                         {\r
2729                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2730                                 pLed->bLedBlinkInProgress = _FALSE;\r
2731                         }\r
2732                         if(pLed->bLedScanBlinkInProgress ==_TRUE)\r
2733                         {\r
2734                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2735                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
2736                         }\r
2737                         if(pLed->bLedWPSBlinkInProgress)\r
2738                         {\r
2739                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2740                         }\r
2741                         else\r
2742                         {\r
2743                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
2744                         }\r
2745 \r
2746                         pLed->CurrLedState = LED_BLINK_WPS_STOP;\r
2747                         if(pLed->bLedOn)\r
2748                         {\r
2749                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
2750                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);\r
2751                         }\r
2752                         else\r
2753                         {\r
2754                                 pLed->BlinkingLedState = RTW_LED_ON;\r
2755                                 _set_timer(&(pLed->BlinkTimer), 0);\r
2756                         }\r
2757                         break;\r
2758 \r
2759                 case LED_CTL_STOP_WPS_FAIL:\r
2760                         if(pLed->bLedWPSBlinkInProgress)\r
2761                         {\r
2762                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2763                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
2764                         }\r
2765 \r
2766                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
2767                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
2768                         if( pLed->bLedOn )\r
2769                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
2770                         else\r
2771                                 pLed->BlinkingLedState = RTW_LED_ON;\r
2772                         _set_timer(&(pLed->BlinkTimer), uLedBlinkNoLinkInterval);//change by ylb 20121012 for customer led for alpha\r
2773                         break;\r
2774 \r
2775                 case LED_CTL_POWER_OFF:\r
2776                         pLed->CurrLedState = RTW_LED_OFF;\r
2777                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2778                         if( pLed->bLedNoLinkBlinkInProgress)\r
2779                         {\r
2780                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2781                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
2782                         }\r
2783                         if( pLed->bLedLinkBlinkInProgress)\r
2784                         {\r
2785                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2786                                 pLed->bLedLinkBlinkInProgress = _FALSE;\r
2787                         }\r
2788                         if( pLed->bLedBlinkInProgress)\r
2789                         {\r
2790                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2791                                 pLed->bLedBlinkInProgress = _FALSE;\r
2792                         }\r
2793                         if( pLed->bLedWPSBlinkInProgress )\r
2794                         {\r
2795                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2796                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
2797                         }\r
2798                         if( pLed->bLedScanBlinkInProgress)\r
2799                         {\r
2800                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2801                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
2802                         }\r
2803 \r
2804                         SwLedOff(padapter, pLed);\r
2805                         break;\r
2806 \r
2807                 default:\r
2808                         break;\r
2809 \r
2810         }\r
2811 \r
2812         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));\r
2813 }\r
2814 \r
2815  //Arcadyan/Sitecom , added by chiyoko, 20090216\r
2816 static void\r
2817 SwLedControlMode2(\r
2818         _adapter                                *padapter,\r
2819         LED_CTL_MODE            LedAction\r
2820 )\r
2821 {\r
2822         struct led_priv *ledpriv = &(padapter->ledpriv);\r
2823         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;\r
2824         PLED_USB                pLed = &(ledpriv->SwLed0);\r
2825 \r
2826         switch(LedAction)\r
2827         {\r
2828                 case LED_CTL_SITE_SURVEY:\r
2829                          if(pmlmepriv->LinkDetectInfo.bBusyTraffic)\r
2830                                 ;\r
2831                          else if(pLed->bLedScanBlinkInProgress ==_FALSE)\r
2832                          {\r
2833                                 if(IS_LED_WPS_BLINKING(pLed))\r
2834                                         return;\r
2835 \r
2836                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
2837                                 {\r
2838                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2839                                         pLed->bLedBlinkInProgress = _FALSE;\r
2840                                 }\r
2841                                 pLed->bLedScanBlinkInProgress = _TRUE;\r
2842                                 pLed->CurrLedState = LED_BLINK_SCAN;\r
2843                                 pLed->BlinkTimes = 24;\r
2844                                 if( pLed->bLedOn )\r
2845                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2846                                 else\r
2847                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2848                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
2849                          }\r
2850                         break;\r
2851 \r
2852                 case LED_CTL_TX:\r
2853                 case LED_CTL_RX:\r
2854                         if((pLed->bLedBlinkInProgress ==_FALSE) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))\r
2855                         {\r
2856                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
2857                                 {\r
2858                                         return;\r
2859                                 }\r
2860 \r
2861                                 pLed->bLedBlinkInProgress = _TRUE;\r
2862                                 pLed->CurrLedState = LED_BLINK_TXRX;\r
2863                                 pLed->BlinkTimes = 2;\r
2864                                 if( pLed->bLedOn )\r
2865                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2866                                 else\r
2867                                         pLed->BlinkingLedState = RTW_LED_ON;\r
2868                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
2869                         }\r
2870                         break;\r
2871 \r
2872                 case LED_CTL_LINK:\r
2873                         pLed->CurrLedState = RTW_LED_ON;\r
2874                         pLed->BlinkingLedState = RTW_LED_ON;\r
2875                         if( pLed->bLedBlinkInProgress)\r
2876                         {\r
2877                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2878                                 pLed->bLedBlinkInProgress = _FALSE;\r
2879                         }\r
2880                         if( pLed->bLedScanBlinkInProgress)\r
2881                         {\r
2882                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2883                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
2884                         }\r
2885 \r
2886                         _set_timer(&(pLed->BlinkTimer), 0);\r
2887                         break;\r
2888 \r
2889                 case LED_CTL_START_WPS: //wait until xinpin finish\r
2890                 case LED_CTL_START_WPS_BOTTON:\r
2891                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)\r
2892                         {\r
2893                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
2894                                 {\r
2895                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2896                                         pLed->bLedBlinkInProgress = _FALSE;\r
2897                                 }\r
2898                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)\r
2899                                 {\r
2900                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2901                                         pLed->bLedScanBlinkInProgress = _FALSE;\r
2902                                 }\r
2903                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
2904                                 pLed->CurrLedState = RTW_LED_ON;\r
2905                                 pLed->BlinkingLedState = RTW_LED_ON;\r
2906                                 _set_timer(&(pLed->BlinkTimer), 0);\r
2907                          }\r
2908                         break;\r
2909 \r
2910                 case LED_CTL_STOP_WPS:\r
2911                         pLed->bLedWPSBlinkInProgress = _FALSE;\r
2912                         if(adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on)\r
2913                         {\r
2914                                 pLed->CurrLedState = RTW_LED_OFF;\r
2915                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
2916                                 _set_timer(&(pLed->BlinkTimer), 0);\r
2917                         }\r
2918                         else\r
2919                         {\r
2920                                 pLed->CurrLedState = RTW_LED_ON;\r
2921                                 pLed->BlinkingLedState = RTW_LED_ON;\r
2922                                 _set_timer(&(pLed->BlinkTimer), 0);\r
2923                                 RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
2924                         }\r
2925                         break;\r
2926 \r
2927                 case LED_CTL_STOP_WPS_FAIL:\r
2928                         pLed->bLedWPSBlinkInProgress = _FALSE;\r
2929                         pLed->CurrLedState = RTW_LED_OFF;\r
2930                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2931                         _set_timer(&(pLed->BlinkTimer), 0);\r
2932                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
2933                         break;\r
2934 \r
2935                 case LED_CTL_START_TO_LINK:\r
2936                 case LED_CTL_NO_LINK:\r
2937                         if(!IS_LED_BLINKING(pLed))\r
2938                         {\r
2939                                 pLed->CurrLedState = RTW_LED_OFF;\r
2940                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
2941                                 _set_timer(&(pLed->BlinkTimer), 0);\r
2942                         }\r
2943                         break;\r
2944 \r
2945                 case LED_CTL_POWER_OFF:\r
2946                         pLed->CurrLedState = RTW_LED_OFF;\r
2947                         pLed->BlinkingLedState = RTW_LED_OFF;\r
2948                         if( pLed->bLedBlinkInProgress)\r
2949                         {\r
2950                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2951                                 pLed->bLedBlinkInProgress = _FALSE;\r
2952                         }\r
2953                         if( pLed->bLedScanBlinkInProgress)\r
2954                         {\r
2955                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2956                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
2957                         }\r
2958                         if( pLed->bLedWPSBlinkInProgress )\r
2959                         {\r
2960                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
2961                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
2962                         }\r
2963 \r
2964                         SwLedOff(padapter, pLed);\r
2965                         break;\r
2966 \r
2967                 default:\r
2968                         break;\r
2969 \r
2970         }\r
2971 \r
2972         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
2973 }\r
2974 \r
2975   //COREGA, added by chiyoko, 20090316\r
2976  static void\r
2977  SwLedControlMode3(\r
2978         _adapter                                *padapter,\r
2979         LED_CTL_MODE            LedAction\r
2980 )\r
2981 {\r
2982         struct led_priv *ledpriv = &(padapter->ledpriv);\r
2983         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;\r
2984         PLED_USB                pLed = &(ledpriv->SwLed0);\r
2985 \r
2986         switch(LedAction)\r
2987         {\r
2988                 case LED_CTL_SITE_SURVEY:\r
2989                         if(pmlmepriv->LinkDetectInfo.bBusyTraffic)\r
2990                                 ;\r
2991                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)\r
2992                         {\r
2993                                 if(IS_LED_WPS_BLINKING(pLed))\r
2994                                         return;\r
2995 \r
2996                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
2997                                 {\r
2998                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
2999                                         pLed->bLedBlinkInProgress = _FALSE;\r
3000                                 }\r
3001                                 pLed->bLedScanBlinkInProgress = _TRUE;\r
3002                                 pLed->CurrLedState = LED_BLINK_SCAN;\r
3003                                 pLed->BlinkTimes = 24;\r
3004                                 if( pLed->bLedOn )\r
3005                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3006                                 else\r
3007                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3008                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
3009                         }\r
3010                         break;\r
3011 \r
3012                 case LED_CTL_TX:\r
3013                 case LED_CTL_RX:\r
3014                         if((pLed->bLedBlinkInProgress ==_FALSE) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))\r
3015                         {\r
3016                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
3017                                 {\r
3018                                         return;\r
3019                                 }\r
3020 \r
3021                                 pLed->bLedBlinkInProgress = _TRUE;\r
3022                                 pLed->CurrLedState = LED_BLINK_TXRX;\r
3023                                 pLed->BlinkTimes = 2;\r
3024                                 if( pLed->bLedOn )\r
3025                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3026                                 else\r
3027                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3028                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
3029                         }\r
3030                         break;\r
3031 \r
3032                 case LED_CTL_LINK:\r
3033                         if(IS_LED_WPS_BLINKING(pLed))\r
3034                                 return;\r
3035 \r
3036                         pLed->CurrLedState = RTW_LED_ON;\r
3037                         pLed->BlinkingLedState = RTW_LED_ON;\r
3038                         if( pLed->bLedBlinkInProgress)\r
3039                         {\r
3040                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3041                                 pLed->bLedBlinkInProgress = _FALSE;\r
3042                         }\r
3043                         if( pLed->bLedScanBlinkInProgress)\r
3044                         {\r
3045                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3046                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
3047                         }\r
3048 \r
3049                         _set_timer(&(pLed->BlinkTimer), 0);\r
3050                         break;\r
3051 \r
3052                 case LED_CTL_START_WPS: //wait until xinpin finish\r
3053                 case LED_CTL_START_WPS_BOTTON:\r
3054                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)\r
3055                         {\r
3056                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
3057                                 {\r
3058                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3059                                         pLed->bLedBlinkInProgress = _FALSE;\r
3060                                 }\r
3061                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)\r
3062                                 {\r
3063                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3064                                         pLed->bLedScanBlinkInProgress = _FALSE;\r
3065                                 }\r
3066                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
3067                                 pLed->CurrLedState = LED_BLINK_WPS;\r
3068                                 if( pLed->bLedOn )\r
3069                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3070                                 else\r
3071                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3072                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
3073                         }\r
3074                         break;\r
3075 \r
3076                 case LED_CTL_STOP_WPS:\r
3077                         if(pLed->bLedWPSBlinkInProgress)\r
3078                         {\r
3079                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3080                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3081                         }\r
3082                         else\r
3083                         {\r
3084                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
3085                         }\r
3086 \r
3087                         pLed->CurrLedState = LED_BLINK_WPS_STOP;\r
3088                         if(pLed->bLedOn)\r
3089                         {\r
3090                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
3091                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA);\r
3092                         }\r
3093                         else\r
3094                         {\r
3095                                 pLed->BlinkingLedState = RTW_LED_ON;\r
3096                                 _set_timer(&(pLed->BlinkTimer), 0);\r
3097                         }\r
3098 \r
3099                         break;\r
3100 \r
3101                 case LED_CTL_STOP_WPS_FAIL:\r
3102                         if(pLed->bLedWPSBlinkInProgress)\r
3103                         {\r
3104                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3105                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3106                         }\r
3107 \r
3108                         pLed->CurrLedState = RTW_LED_OFF;\r
3109                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3110                         _set_timer(&(pLed->BlinkTimer), 0);\r
3111                         break;\r
3112 \r
3113                 case LED_CTL_START_TO_LINK:\r
3114                 case LED_CTL_NO_LINK:\r
3115                         if(!IS_LED_BLINKING(pLed))\r
3116                         {\r
3117                                 pLed->CurrLedState = RTW_LED_OFF;\r
3118                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
3119                                 _set_timer(&(pLed->BlinkTimer), 0);\r
3120                         }\r
3121                         break;\r
3122 \r
3123                 case LED_CTL_POWER_OFF:\r
3124                         pLed->CurrLedState = RTW_LED_OFF;\r
3125                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3126                         if( pLed->bLedBlinkInProgress)\r
3127                         {\r
3128                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3129                                 pLed->bLedBlinkInProgress = _FALSE;\r
3130                         }\r
3131                         if( pLed->bLedScanBlinkInProgress)\r
3132                         {\r
3133                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3134                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
3135                         }\r
3136                         if( pLed->bLedWPSBlinkInProgress )\r
3137                         {\r
3138                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3139                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3140                         }\r
3141 \r
3142                         SwLedOff(padapter, pLed);\r
3143                         break;\r
3144 \r
3145                 default:\r
3146                         break;\r
3147 \r
3148         }\r
3149 \r
3150         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("CurrLedState %d\n", pLed->CurrLedState));\r
3151 }\r
3152 \r
3153 \r
3154  //Edimax-Belkin, added by chiyoko, 20090413\r
3155 static void\r
3156 SwLedControlMode4(\r
3157         _adapter                                *padapter,\r
3158         LED_CTL_MODE            LedAction\r
3159 )\r
3160 {\r
3161         struct led_priv *ledpriv = &(padapter->ledpriv);\r
3162         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;\r
3163         PLED_USB                pLed = &(ledpriv->SwLed0);\r
3164         PLED_USB                pLed1 = &(ledpriv->SwLed1);\r
3165 \r
3166         switch(LedAction)\r
3167         {\r
3168                 case LED_CTL_START_TO_LINK:\r
3169                         if(pLed1->bLedWPSBlinkInProgress)\r
3170                         {\r
3171                                 pLed1->bLedWPSBlinkInProgress = _FALSE;\r
3172                                 _cancel_timer_ex(&(pLed1->BlinkTimer));\r
3173 \r
3174                                 pLed1->BlinkingLedState = RTW_LED_OFF;\r
3175                                 pLed1->CurrLedState = RTW_LED_OFF;\r
3176 \r
3177                                 if(pLed1->bLedOn)\r
3178                                         _set_timer(&(pLed->BlinkTimer), 0);\r
3179                         }\r
3180 \r
3181                         if( pLed->bLedStartToLinkBlinkInProgress == _FALSE )\r
3182                         {\r
3183                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
3184                                 {\r
3185                                         return;\r
3186                                 }\r
3187                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
3188                                 {\r
3189                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3190                                         pLed->bLedBlinkInProgress = _FALSE;\r
3191                                 }\r
3192                                 if(pLed->bLedNoLinkBlinkInProgress ==_TRUE)\r
3193                                 {\r
3194                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3195                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
3196                                 }\r
3197 \r
3198                                 pLed->bLedStartToLinkBlinkInProgress = _TRUE;\r
3199                                 pLed->CurrLedState = LED_BLINK_StartToBlink;\r
3200                                 if( pLed->bLedOn )\r
3201                                 {\r
3202                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3203                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
3204                                 }\r
3205                                 else\r
3206                                 {\r
3207                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3208                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
3209                                 }\r
3210                         }\r
3211                         break;\r
3212 \r
3213                 case LED_CTL_LINK:\r
3214                 case LED_CTL_NO_LINK:\r
3215                         //LED1 settings\r
3216                         if(LedAction == LED_CTL_LINK)\r
3217                         {\r
3218                                 if(pLed1->bLedWPSBlinkInProgress)\r
3219                                 {\r
3220                                         pLed1->bLedWPSBlinkInProgress = _FALSE;\r
3221                                         _cancel_timer_ex(&(pLed1->BlinkTimer));\r
3222 \r
3223                                         pLed1->BlinkingLedState = RTW_LED_OFF;\r
3224                                         pLed1->CurrLedState = RTW_LED_OFF;\r
3225 \r
3226                                         if(pLed1->bLedOn)\r
3227                                                 _set_timer(&(pLed->BlinkTimer), 0);\r
3228                                 }\r
3229                         }\r
3230 \r
3231                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )\r
3232                         {\r
3233                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
3234                                 {\r
3235                                         return;\r
3236                                 }\r
3237                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
3238                                 {\r
3239                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3240                                         pLed->bLedBlinkInProgress = _FALSE;\r
3241                                 }\r
3242 \r
3243                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
3244                                 pLed->CurrLedState = LED_BLINK_SLOWLY;\r
3245                                 if( pLed->bLedOn )\r
3246                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3247                                 else\r
3248                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3249                                 \r
3250                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
3251                         }\r
3252                         break;\r
3253 \r
3254                 case LED_CTL_SITE_SURVEY:\r
3255                         if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))\r
3256                                 ;\r
3257                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)\r
3258                         {\r
3259                                 if(IS_LED_WPS_BLINKING(pLed))\r
3260                                         return;\r
3261 \r
3262                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
3263                                 {\r
3264                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3265                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
3266                                 }\r
3267                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
3268                                 {\r
3269                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3270                                         pLed->bLedBlinkInProgress = _FALSE;\r
3271                                 }\r
3272                                 pLed->bLedScanBlinkInProgress = _TRUE;\r
3273                                 pLed->CurrLedState = LED_BLINK_SCAN;\r
3274                                 pLed->BlinkTimes = 24;\r
3275                                 if( pLed->bLedOn )\r
3276                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3277                                 else\r
3278                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3279                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
3280                         }\r
3281                         break;\r
3282 \r
3283                 case LED_CTL_TX:\r
3284                 case LED_CTL_RX:\r
3285                         if(pLed->bLedBlinkInProgress ==_FALSE)\r
3286                         {\r
3287                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
3288                                 {\r
3289                                         return;\r
3290                                 }\r
3291                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
3292                                 {\r
3293                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3294                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
3295                                 }\r
3296                                 pLed->bLedBlinkInProgress = _TRUE;\r
3297                                 pLed->CurrLedState = LED_BLINK_TXRX;\r
3298                                 pLed->BlinkTimes = 2;\r
3299                                 if( pLed->bLedOn )\r
3300                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3301                                 else\r
3302                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3303                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
3304                         }\r
3305                         break;\r
3306 \r
3307                 case LED_CTL_START_WPS: //wait until xinpin finish\r
3308                 case LED_CTL_START_WPS_BOTTON:\r
3309                         if(pLed1->bLedWPSBlinkInProgress)\r
3310                         {\r
3311                                 pLed1->bLedWPSBlinkInProgress = _FALSE;\r
3312                                 _cancel_timer_ex(&(pLed1->BlinkTimer));\r
3313 \r
3314                                 pLed1->BlinkingLedState = RTW_LED_OFF;\r
3315                                 pLed1->CurrLedState = RTW_LED_OFF;\r
3316 \r
3317                                 if(pLed1->bLedOn)\r
3318                                         _set_timer(&(pLed->BlinkTimer), 0);\r
3319                         }\r
3320 \r
3321                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)\r
3322                         {\r
3323                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
3324                                 {\r
3325                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3326                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
3327                                 }\r
3328                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
3329                                 {\r
3330                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3331                                         pLed->bLedBlinkInProgress = _FALSE;\r
3332                                 }\r
3333                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)\r
3334                                 {\r
3335                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3336                                         pLed->bLedScanBlinkInProgress = _FALSE;\r
3337                                 }\r
3338                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
3339                                 pLed->CurrLedState = LED_BLINK_WPS;\r
3340                                 if( pLed->bLedOn )\r
3341                                 {\r
3342                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3343                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);\r
3344                                 }\r
3345                                 else\r
3346                                 {\r
3347                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3348                                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
3349                                 }\r
3350                         }\r
3351                         break;\r
3352 \r
3353                 case LED_CTL_STOP_WPS:  //WPS connect success\r
3354                         if(pLed->bLedWPSBlinkInProgress)\r
3355                         {\r
3356                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3357                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3358                         }\r
3359 \r
3360                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
3361                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
3362                         if( pLed->bLedOn )\r
3363                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
3364                         else\r
3365                                 pLed->BlinkingLedState = RTW_LED_ON;\r
3366                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
3367 \r
3368                         break;\r
3369 \r
3370                 case LED_CTL_STOP_WPS_FAIL:             //WPS authentication fail\r
3371                         if(pLed->bLedWPSBlinkInProgress)\r
3372                         {\r
3373                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3374                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3375                         }\r
3376 \r
3377                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
3378                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
3379                         if( pLed->bLedOn )\r
3380                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
3381                         else\r
3382                                 pLed->BlinkingLedState = RTW_LED_ON;\r
3383                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
3384 \r
3385                         //LED1 settings\r
3386                         if(pLed1->bLedWPSBlinkInProgress)\r
3387                                 _cancel_timer_ex(&(pLed1->BlinkTimer));\r
3388                         else\r
3389                                 pLed1->bLedWPSBlinkInProgress = _TRUE;\r
3390 \r
3391                         pLed1->CurrLedState = LED_BLINK_WPS_STOP;\r
3392                         if( pLed1->bLedOn )\r
3393                                 pLed1->BlinkingLedState = RTW_LED_OFF;\r
3394                         else\r
3395                                 pLed1->BlinkingLedState = RTW_LED_ON;\r
3396                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
3397 \r
3398                         break;\r
3399 \r
3400                 case LED_CTL_STOP_WPS_FAIL_OVERLAP:     //WPS session overlap\r
3401                         if(pLed->bLedWPSBlinkInProgress)\r
3402                         {\r
3403                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3404                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3405                         }\r
3406 \r
3407                         pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
3408                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
3409                         if( pLed->bLedOn )\r
3410                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
3411                         else\r
3412                                 pLed->BlinkingLedState = RTW_LED_ON;\r
3413                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
3414 \r
3415                         //LED1 settings\r
3416                         if(pLed1->bLedWPSBlinkInProgress)\r
3417                                 _cancel_timer_ex(&(pLed1->BlinkTimer));\r
3418                         else\r
3419                                 pLed1->bLedWPSBlinkInProgress = _TRUE;\r
3420 \r
3421                         pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;\r
3422                         pLed1->BlinkTimes = 10;\r
3423                         if( pLed1->bLedOn )\r
3424                                 pLed1->BlinkingLedState = RTW_LED_OFF;\r
3425                         else\r
3426                                 pLed1->BlinkingLedState = RTW_LED_ON;\r
3427                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
3428 \r
3429                         break;\r
3430 \r
3431                 case LED_CTL_POWER_OFF:\r
3432                         pLed->CurrLedState = RTW_LED_OFF;\r
3433                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3434 \r
3435                         if( pLed->bLedNoLinkBlinkInProgress)\r
3436                         {\r
3437                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3438                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
3439                         }\r
3440                         if( pLed->bLedLinkBlinkInProgress)\r
3441                         {\r
3442                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3443                                 pLed->bLedLinkBlinkInProgress = _FALSE;\r
3444                         }\r
3445                         if( pLed->bLedBlinkInProgress)\r
3446                         {\r
3447                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3448                                 pLed->bLedBlinkInProgress = _FALSE;\r
3449                         }\r
3450                         if( pLed->bLedWPSBlinkInProgress )\r
3451                         {\r
3452                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3453                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3454                         }\r
3455                         if( pLed->bLedScanBlinkInProgress)\r
3456                         {\r
3457                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3458                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
3459                         }\r
3460                         if( pLed->bLedStartToLinkBlinkInProgress)\r
3461                         {\r
3462                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3463                                 pLed->bLedStartToLinkBlinkInProgress = _FALSE;\r
3464                         }\r
3465 \r
3466                         if( pLed1->bLedWPSBlinkInProgress )\r
3467                         {\r
3468                                 _cancel_timer_ex(&(pLed1->BlinkTimer));\r
3469                                 pLed1->bLedWPSBlinkInProgress = _FALSE;\r
3470                         }\r
3471 \r
3472                         pLed1->BlinkingLedState = LED_UNKNOWN;\r
3473                         SwLedOff(padapter, pLed);\r
3474                         SwLedOff(padapter, pLed1);\r
3475                         break;\r
3476 \r
3477                 case LED_CTL_CONNECTION_NO_TRANSFER:\r
3478                          if(pLed->bLedBlinkInProgress == _FALSE)\r
3479                          {\r
3480                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
3481                                 {\r
3482                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3483                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
3484                                 }\r
3485                                 pLed->bLedBlinkInProgress = _TRUE;\r
3486 \r
3487                                 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;\r
3488                                 pLed->BlinkingLedState = RTW_LED_ON;\r
3489                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
3490                         }\r
3491                         break;\r
3492 \r
3493                 default:\r
3494                         break;\r
3495 \r
3496         }\r
3497 \r
3498         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));\r
3499 }\r
3500 \r
3501 \r
3502 \r
3503  //Sercomm-Belkin, added by chiyoko, 20090415\r
3504 static void\r
3505 SwLedControlMode5(\r
3506         _adapter                                *padapter,\r
3507         LED_CTL_MODE            LedAction\r
3508 )\r
3509 {\r
3510         struct led_priv *ledpriv = &(padapter->ledpriv);\r
3511         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;\r
3512         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);\r
3513         PLED_USB                pLed = &(ledpriv->SwLed0);\r
3514 \r
3515         if(pHalData->CustomerID == RT_CID_819x_CAMEO)\r
3516                 pLed = &(ledpriv->SwLed1);\r
3517 \r
3518         switch(LedAction)\r
3519         {\r
3520                 case LED_CTL_POWER_ON:\r
3521                 case LED_CTL_NO_LINK:\r
3522                 case LED_CTL_LINK:      //solid blue\r
3523                         pLed->CurrLedState = RTW_LED_ON;\r
3524                         pLed->BlinkingLedState = RTW_LED_ON;\r
3525 \r
3526                         _set_timer(&(pLed->BlinkTimer), 0);\r
3527                         break;\r
3528 \r
3529                 case LED_CTL_SITE_SURVEY:\r
3530                         if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))\r
3531                                 ;\r
3532                         else if(pLed->bLedScanBlinkInProgress ==_FALSE)\r
3533                         {\r
3534                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
3535                                 {\r
3536                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3537                                         pLed->bLedBlinkInProgress = _FALSE;\r
3538                                 }\r
3539                                 pLed->bLedScanBlinkInProgress = _TRUE;\r
3540                                 pLed->CurrLedState = LED_BLINK_SCAN;\r
3541                                 pLed->BlinkTimes = 24;\r
3542                                 if( pLed->bLedOn )\r
3543                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3544                                 else\r
3545                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3546                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
3547                         }\r
3548                         break;\r
3549 \r
3550                 case LED_CTL_TX:\r
3551                 case LED_CTL_RX:\r
3552                         if(pLed->bLedBlinkInProgress ==_FALSE)\r
3553                         {\r
3554                                 if(pLed->CurrLedState == LED_BLINK_SCAN)\r
3555                                 {\r
3556                                         return;\r
3557                                 }\r
3558                                 pLed->bLedBlinkInProgress = _TRUE;\r
3559                                 pLed->CurrLedState = LED_BLINK_TXRX;\r
3560                                 pLed->BlinkTimes = 2;\r
3561                                 if( pLed->bLedOn )\r
3562                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3563                                 else\r
3564                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3565                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
3566                         }\r
3567                         break;\r
3568 \r
3569                 case LED_CTL_POWER_OFF:\r
3570                         pLed->CurrLedState = RTW_LED_OFF;\r
3571                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3572 \r
3573                         if( pLed->bLedBlinkInProgress)\r
3574                         {\r
3575                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3576                                 pLed->bLedBlinkInProgress = _FALSE;\r
3577                         }\r
3578 \r
3579                         SwLedOff(padapter, pLed);\r
3580                         break;\r
3581 \r
3582                 default:\r
3583                         break;\r
3584 \r
3585         }\r
3586 \r
3587         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led %d\n", pLed->CurrLedState));\r
3588 }\r
3589 \r
3590  //WNC-Corega, added by chiyoko, 20090902\r
3591 static void\r
3592 SwLedControlMode6(\r
3593         _adapter                                *padapter,\r
3594         LED_CTL_MODE            LedAction\r
3595 )\r
3596 {\r
3597         struct led_priv *ledpriv = &(padapter->ledpriv);\r
3598         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;\r
3599         PLED_USB        pLed0 = &(ledpriv->SwLed0);\r
3600 \r
3601         switch(LedAction)\r
3602         {\r
3603                 case LED_CTL_POWER_ON:\r
3604                 case LED_CTL_LINK:\r
3605                 case LED_CTL_NO_LINK:\r
3606                         _cancel_timer_ex(&(pLed0->BlinkTimer));\r
3607                         pLed0->CurrLedState = RTW_LED_ON;\r
3608                         pLed0->BlinkingLedState = RTW_LED_ON;\r
3609                         _set_timer(&(pLed0->BlinkTimer), 0);\r
3610                         break;\r
3611 \r
3612                 case LED_CTL_POWER_OFF:\r
3613                         SwLedOff(padapter, pLed0);\r
3614                         break;\r
3615 \r
3616                 default:\r
3617                         break;\r
3618         }\r
3619 \r
3620         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("ledcontrol 6 Led %d\n", pLed0->CurrLedState));\r
3621 }\r
3622 \r
3623 //Netgear, added by sinda, 2011/11/11\r
3624  void\r
3625  SwLedControlMode7(\r
3626          PADAPTER                        Adapter,\r
3627          LED_CTL_MODE            LedAction\r
3628  )\r
3629 {\r
3630         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
3631         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;\r
3632         PLED_USB        pLed = &(ledpriv->SwLed0);\r
3633         \r
3634         switch(LedAction)\r
3635         {               \r
3636                 case LED_CTL_SITE_SURVEY:\r
3637                         if(pmlmepriv->LinkDetectInfo.bBusyTraffic)\r
3638                                 ;\r
3639                         else if(pLed->bLedScanBlinkInProgress == _FALSE)\r
3640                         {\r
3641                                 if(IS_LED_WPS_BLINKING(pLed))\r
3642                                         return;\r
3643 \r
3644                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
3645                                 {\r
3646                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3647                                         pLed->bLedBlinkInProgress = _FALSE;\r
3648                                 }\r
3649                                 pLed->bLedScanBlinkInProgress = _TRUE;\r
3650                                 pLed->CurrLedState = LED_BLINK_SCAN;\r
3651                                 pLed->BlinkTimes = 6;\r
3652                                 if( pLed->bLedOn )\r
3653                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3654                                 else\r
3655                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3656                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);\r
3657                         }\r
3658                         break;\r
3659 \r
3660                 case LED_CTL_LINK:\r
3661                         if(IS_LED_WPS_BLINKING(pLed))\r
3662                                 return;\r
3663 \r
3664                         pLed->CurrLedState = RTW_LED_ON;\r
3665                         pLed->BlinkingLedState = RTW_LED_ON;\r
3666                         if( pLed->bLedBlinkInProgress)\r
3667                         {\r
3668                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3669                                 pLed->bLedBlinkInProgress = _FALSE;\r
3670                         }\r
3671                         if( pLed->bLedScanBlinkInProgress)\r
3672                         {\r
3673                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3674                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
3675                         }                       \r
3676 \r
3677                         _set_timer(&(pLed->BlinkTimer), 0);\r
3678                         break;\r
3679 \r
3680                 case LED_CTL_START_WPS: //wait until xinpin finish\r
3681                 case LED_CTL_START_WPS_BOTTON:\r
3682                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)\r
3683                         {\r
3684                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
3685                                 {\r
3686                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3687                                         pLed->bLedBlinkInProgress = _FALSE;\r
3688                                 }\r
3689                                 if(pLed->bLedScanBlinkInProgress == _TRUE)\r
3690                                 {\r
3691                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3692                                         pLed->bLedScanBlinkInProgress = _FALSE;\r
3693                                 }\r
3694                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
3695                                 pLed->CurrLedState = LED_BLINK_WPS;\r
3696                                 if( pLed->bLedOn )\r
3697                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3698                                 else\r
3699                                         pLed->BlinkingLedState = RTW_LED_ON;\r
3700                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);\r
3701                         }       \r
3702                         break;\r
3703 \r
3704                 case LED_CTL_STOP_WPS:\r
3705                         if(pLed->bLedWPSBlinkInProgress)\r
3706                         {\r
3707                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3708                                 pLed->bLedWPSBlinkInProgress = _FALSE;                          \r
3709                         }                                               \r
3710                         else\r
3711                         {\r
3712                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
3713                         }\r
3714 \r
3715                         pLed->CurrLedState = LED_BLINK_WPS_STOP;\r
3716                         if(pLed->bLedOn)\r
3717                         {\r
3718                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
3719                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_NETGEAR);\r
3720                         }\r
3721                         else\r
3722                         {\r
3723                                 pLed->BlinkingLedState = RTW_LED_ON;\r
3724                                 _set_timer(&(pLed->BlinkTimer), 0);\r
3725                         }                                       \r
3726 \r
3727                         break;\r
3728 \r
3729 \r
3730                 case LED_CTL_STOP_WPS_FAIL:                     \r
3731                 case LED_CTL_STOP_WPS_FAIL_OVERLAP:     //WPS session overlap                   \r
3732                         if(pLed->bLedWPSBlinkInProgress)\r
3733                         {\r
3734                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3735                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3736                         }\r
3737 \r
3738                         pLed->CurrLedState = RTW_LED_OFF;\r
3739                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3740                         _set_timer(&(pLed->BlinkTimer), 0);\r
3741                         break;\r
3742 \r
3743                 case LED_CTL_START_TO_LINK:\r
3744                 case LED_CTL_NO_LINK:\r
3745                         if(!IS_LED_BLINKING(pLed))\r
3746                         {\r
3747                                 pLed->CurrLedState = RTW_LED_OFF;\r
3748                                 pLed->BlinkingLedState = RTW_LED_OFF;           \r
3749                                 _set_timer(&(pLed->BlinkTimer), 0);\r
3750                         }\r
3751                         break;\r
3752 \r
3753                 case LED_CTL_POWER_OFF:\r
3754                 case LED_CTL_POWER_ON:\r
3755                         pLed->CurrLedState = RTW_LED_OFF;\r
3756                         pLed->BlinkingLedState = RTW_LED_OFF;\r
3757                         if( pLed->bLedBlinkInProgress)\r
3758                         {\r
3759                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3760                                 pLed->bLedBlinkInProgress = _FALSE;\r
3761                         }\r
3762                         if( pLed->bLedScanBlinkInProgress)\r
3763                         {\r
3764                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3765                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
3766                         }\r
3767                         if( pLed->bLedWPSBlinkInProgress )\r
3768                         {\r
3769                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
3770                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
3771                         }\r
3772 \r
3773                         _set_timer(&(pLed->BlinkTimer), 0);\r
3774                         break;\r
3775 \r
3776                 default:\r
3777                         break;\r
3778 \r
3779         }\r
3780 \r
3781         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("LEd control mode 7 CurrLedState %d\n", pLed->CurrLedState));\r
3782 }\r
3783 \r
3784 void\r
3785 SwLedControlMode8(\r
3786         PADAPTER                        Adapter,\r
3787         LED_CTL_MODE            LedAction\r
3788         )\r
3789 {\r
3790         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
3791         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;\r
3792         PLED_USB        pLed0 = &(ledpriv->SwLed0);\r
3793 \r
3794         switch(LedAction)\r
3795         {\r
3796                 case LED_CTL_LINK:\r
3797                         _cancel_timer_ex(&(pLed0->BlinkTimer));                 \r
3798                         pLed0->CurrLedState = RTW_LED_ON;\r
3799                         pLed0->BlinkingLedState = RTW_LED_ON;\r
3800                         _set_timer(&(pLed0->BlinkTimer), 0);\r
3801                         break;\r
3802 \r
3803                 case LED_CTL_NO_LINK:\r
3804                         _cancel_timer_ex(&(pLed0->BlinkTimer));\r
3805                         pLed0->CurrLedState = RTW_LED_OFF;\r
3806                         pLed0->BlinkingLedState = RTW_LED_OFF;                          \r
3807                         _set_timer(&(pLed0->BlinkTimer), 0);    \r
3808                         break;\r
3809 \r
3810                 case LED_CTL_POWER_OFF:\r
3811                         SwLedOff(Adapter, pLed0);\r
3812                         break;\r
3813 \r
3814                 default:\r
3815                         break;\r
3816         }\r
3817 \r
3818         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 8 %d\n", pLed0->CurrLedState));\r
3819 \r
3820 }\r
3821 \r
3822 //page added for Belkin AC950, 20120813\r
3823 void\r
3824 SwLedControlMode9(\r
3825         IN      PADAPTER                        Adapter,\r
3826         IN      LED_CTL_MODE            LedAction\r
3827 )\r
3828 {\r
3829         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
3830         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;\r
3831         PLED_USB        pLed = &(ledpriv->SwLed0);\r
3832         PLED_USB        pLed1 = &(ledpriv->SwLed1);\r
3833         PLED_USB        pLed2 = &(ledpriv->SwLed2);\r
3834         BOOLEAN  bWPSOverLap = _FALSE;\r
3835         //DBG_871X("LedAction=%d \n", LedAction);\r
3836         switch(LedAction)\r
3837         {               \r
3838                 case LED_CTL_START_TO_LINK:     \r
3839                         if(pLed2->bLedBlinkInProgress == _FALSE)\r
3840                         {\r
3841                                 pLed2->bLedBlinkInProgress = _TRUE;\r
3842                                 pLed2->BlinkingLedState = RTW_LED_ON;\r
3843                                 pLed2->CurrLedState = LED_BLINK_LINK_IN_PROCESS;\r
3844 \r
3845                                 _set_timer(&(pLed2->BlinkTimer), 0);    \r
3846                         }\r
3847                         break;          \r
3848 \r
3849                 case LED_CTL_LINK:                      \r
3850                 case LED_CTL_NO_LINK:\r
3851                         //LED1 settings\r
3852                         if(LedAction == LED_CTL_NO_LINK)\r
3853                         {\r
3854                                 //if(pMgntInfo->AuthStatus == AUTH_STATUS_FAILED)\r
3855                                 if(0)\r
3856                                 {\r
3857                                         pLed1->CurrLedState = LED_BLINK_AUTH_ERROR;\r
3858                                                 if( pLed1->bLedOn )\r
3859                                                         pLed1->BlinkingLedState = RTW_LED_OFF; \r
3860                                                 else\r
3861                                                         pLed1->BlinkingLedState = RTW_LED_ON; \r
3862                                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
3863                                 } \r
3864                                 else\r
3865                                 {\r
3866                                         pLed1->CurrLedState = RTW_LED_OFF;\r
3867                                         pLed1->BlinkingLedState = RTW_LED_OFF; \r
3868                                         if( pLed1->bLedOn )\r
3869                                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
3870                                 }\r
3871                         }\r
3872                         else\r
3873                         {\r
3874                                 pLed1->CurrLedState = RTW_LED_OFF;\r
3875                                 pLed1->BlinkingLedState = RTW_LED_OFF; \r
3876                                 if( pLed1->bLedOn )\r
3877                                         _set_timer(&(pLed1->BlinkTimer), 0); \r
3878                         }\r
3879                                                 \r
3880                         //LED2 settings\r
3881                         if(LedAction == LED_CTL_LINK)\r
3882                         {\r
3883                                 if(Adapter->securitypriv.dot11PrivacyAlgrthm != _NO_PRIVACY_)\r
3884                                 {\r
3885                                         if(pLed2->bLedBlinkInProgress ==_TRUE)\r
3886                                         {       \r
3887                                                 _cancel_timer_ex(&(pLed2->BlinkTimer));\r
3888                                                 pLed2->bLedBlinkInProgress = _FALSE;\r
3889                                         }\r
3890                                         pLed2->CurrLedState = RTW_LED_ON;\r
3891                                         pLed2->bLedNoLinkBlinkInProgress = _TRUE;\r
3892                                         if(!pLed2->bLedOn)\r
3893                                                 _set_timer(&(pLed2->BlinkTimer), 0);    \r
3894                                 }\r
3895                                 else\r
3896                                 {\r
3897                                         if(pLed2->bLedWPSBlinkInProgress != _TRUE)\r
3898                                         {\r
3899                                                 pLed2->CurrLedState = RTW_LED_OFF;\r
3900                                                 pLed2->BlinkingLedState = RTW_LED_OFF;\r
3901                                                 if(pLed2->bLedOn)\r
3902                                                         _set_timer(&(pLed2->BlinkTimer), 0);\r
3903                                         }\r
3904                                 }\r
3905                         }\r
3906                         else //NO_LINK\r
3907                         {\r
3908                                 if(pLed2->bLedWPSBlinkInProgress == _FALSE)\r
3909                                 {\r
3910                                         pLed2->CurrLedState = RTW_LED_OFF;\r
3911                                         pLed2->BlinkingLedState = RTW_LED_OFF;\r
3912                                         if(pLed2->bLedOn)\r
3913                                                 _set_timer(&(pLed2->BlinkTimer), 0);            \r
3914                                 }\r
3915                         }\r
3916 \r
3917                         //LED0 settings                 \r
3918                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )\r
3919                         {\r
3920                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
3921                                 {\r
3922                                         return;\r
3923                                 }\r
3924                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
3925                                 {       \r
3926                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3927                                         pLed->bLedBlinkInProgress = _FALSE;\r
3928                                 }\r
3929                                 \r
3930                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
3931                                 if(IS_HARDWARE_TYPE_8812AU(Adapter))\r
3932                                 {\r
3933                                         if(LedAction == LED_CTL_LINK)\r
3934                                         {\r
3935                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
3936                                                 pLed->CurrLedState = LED_BLINK_SLOWLY;\r
3937                                         }\r
3938                                         else\r
3939                                         {\r
3940                                                 pLed->CurrLedState = LED_BLINK_SLOWLY;\r
3941                                                 if( pLed->bLedOn )\r
3942                                                         pLed->BlinkingLedState = RTW_LED_OFF; \r
3943                                                 else\r
3944                                                         pLed->BlinkingLedState = RTW_LED_ON; \r
3945                                         }\r
3946                                 }\r
3947                                 else\r
3948                                 {\r
3949                                         pLed->CurrLedState = LED_BLINK_SLOWLY;\r
3950                                         if( pLed->bLedOn )\r
3951                                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
3952                                         else\r
3953                                                 pLed->BlinkingLedState = RTW_LED_ON; \r
3954                                 }\r
3955                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
3956                         }\r
3957                         \r
3958                         break;          \r
3959 \r
3960                 case LED_CTL_SITE_SURVEY:\r
3961                          if((pmlmepriv->LinkDetectInfo.bBusyTraffic) && (check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE))\r
3962                                 ;\r
3963                          else //if(pLed->bLedScanBlinkInProgress ==FALSE)\r
3964                          {\r
3965                                 if(IS_LED_WPS_BLINKING(pLed))\r
3966                                         return;\r
3967                                 \r
3968                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
3969                                 {\r
3970                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3971                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
3972                                 }\r
3973                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
3974                                 {\r
3975                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
3976                                         pLed->bLedBlinkInProgress = _FALSE;\r
3977                                 }\r
3978                                 pLed->bLedScanBlinkInProgress = _TRUE;\r
3979                                 pLed->CurrLedState = LED_BLINK_SCAN;\r
3980                                 pLed->BlinkTimes = 24;\r
3981                                 if( pLed->bLedOn )\r
3982                                         pLed->BlinkingLedState = RTW_LED_OFF; \r
3983                                 else\r
3984                                         pLed->BlinkingLedState = RTW_LED_ON; \r
3985                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
3986 \r
3987                          }\r
3988                         break;\r
3989                 \r
3990                 case LED_CTL_TX:\r
3991                 case LED_CTL_RX:\r
3992                         if(pLed->bLedBlinkInProgress == _FALSE)\r
3993                         {\r
3994                                 if(pLed->CurrLedState == LED_BLINK_SCAN || IS_LED_WPS_BLINKING(pLed))\r
3995                                 {\r
3996                                         return;\r
3997                                 }\r
3998                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
3999                                 {\r
4000                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4001                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
4002                                 }\r
4003                                 pLed->bLedBlinkInProgress = _TRUE;\r
4004                                 pLed->CurrLedState = LED_BLINK_TXRX;\r
4005                                 pLed->BlinkTimes = 2;\r
4006                                 if( pLed->bLedOn )\r
4007                                         pLed->BlinkingLedState = RTW_LED_OFF; \r
4008                                 else\r
4009                                         pLed->BlinkingLedState = RTW_LED_ON; \r
4010                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
4011                         }\r
4012                         break;\r
4013 \r
4014                 case LED_CTL_START_WPS: //wait until xinpin finish\r
4015                 case LED_CTL_START_WPS_BOTTON:\r
4016                         pLed2->bLedBlinkInProgress = _TRUE;\r
4017                         pLed2->BlinkingLedState = RTW_LED_ON;\r
4018                         pLed2->CurrLedState = LED_BLINK_LINK_IN_PROCESS;\r
4019                         pLed2->bLedWPSBlinkInProgress = _TRUE;\r
4020 \r
4021                         _set_timer(&(pLed2->BlinkTimer), 500);\r
4022                          \r
4023                         break;\r
4024                 \r
4025                 case LED_CTL_STOP_WPS:  //WPS connect success   \r
4026                         //LED2 settings\r
4027                         if(pLed2->bLedWPSBlinkInProgress == _TRUE)\r
4028                         {       \r
4029                                 _cancel_timer_ex(&(pLed2->BlinkTimer));\r
4030                                 pLed2->bLedBlinkInProgress = _FALSE;\r
4031                                 pLed2->bLedWPSBlinkInProgress = _FALSE;\r
4032                         }\r
4033                         pLed2->CurrLedState = RTW_LED_ON;\r
4034                         pLed2->bLedNoLinkBlinkInProgress = _TRUE;\r
4035                         if(!pLed2->bLedOn)\r
4036                                 _set_timer(&(pLed2->BlinkTimer), 0);    \r
4037 \r
4038                         //LED1 settings\r
4039                         _cancel_timer_ex(&(pLed1->BlinkTimer));\r
4040                         pLed1->CurrLedState = RTW_LED_OFF;\r
4041                         pLed1->BlinkingLedState = RTW_LED_OFF; \r
4042                         if( pLed1->bLedOn )\r
4043                                 _set_timer(&(pLed1->BlinkTimer), 0);    \r
4044                         \r
4045                                 \r
4046                         break;          \r
4047 \r
4048                 case LED_CTL_STOP_WPS_FAIL:             //WPS authentication fail       \r
4049                         //LED1 settings\r
4050                         //if(bWPSOverLap == _FALSE)\r
4051                         {\r
4052                                 pLed1->CurrLedState = LED_BLINK_AUTH_ERROR;\r
4053                                 pLed1->BlinkTimes = 50;\r
4054                                 if( pLed1->bLedOn )\r
4055                                         pLed1->BlinkingLedState = RTW_LED_OFF; \r
4056                                 else\r
4057                                         pLed1->BlinkingLedState = RTW_LED_ON; \r
4058                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
4059                         }\r
4060                         //else\r
4061                         //{\r
4062                         //      bWPSOverLap = _FALSE;\r
4063                         //      pLed1->CurrLedState = RTW_LED_OFF;\r
4064                         //      pLed1->BlinkingLedState = RTW_LED_OFF; \r
4065                         //      _set_timer(&(pLed1->BlinkTimer), 0);\r
4066                         //}\r
4067 \r
4068                         //LED2 settings\r
4069                         pLed2->CurrLedState = RTW_LED_OFF;\r
4070                         pLed2->BlinkingLedState = RTW_LED_OFF; \r
4071                         pLed2->bLedWPSBlinkInProgress = _FALSE;\r
4072                         if( pLed2->bLedOn )\r
4073                                 _set_timer(&(pLed2->BlinkTimer), 0);\r
4074                                                 \r
4075                         break;                          \r
4076 \r
4077                 case LED_CTL_STOP_WPS_FAIL_OVERLAP:     //WPS session overlap\r
4078                         //LED1 settings\r
4079                         bWPSOverLap = _TRUE;\r
4080                         pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;\r
4081                         pLed1->BlinkTimes = 10;\r
4082                         pLed1->BlinkCounter = 50;\r
4083                         if( pLed1->bLedOn )\r
4084                                 pLed1->BlinkingLedState = RTW_LED_OFF; \r
4085                         else\r
4086                                 pLed1->BlinkingLedState = RTW_LED_ON; \r
4087                         _set_timer(&(pLed1->BlinkTimer), 0);\r
4088 \r
4089                         //LED2 settings\r
4090                         pLed2->CurrLedState = RTW_LED_OFF;\r
4091                         pLed2->BlinkingLedState = RTW_LED_OFF;\r
4092                         pLed2->bLedWPSBlinkInProgress = _FALSE;\r
4093                         if( pLed2->bLedOn )\r
4094                                 _set_timer(&(pLed2->BlinkTimer), 0);\r
4095                         \r
4096                         break;\r
4097 \r
4098                 case LED_CTL_POWER_OFF:\r
4099                         pLed->CurrLedState = RTW_LED_OFF;\r
4100                         pLed->BlinkingLedState = RTW_LED_OFF; \r
4101                         \r
4102                         if( pLed->bLedNoLinkBlinkInProgress)\r
4103                         {\r
4104                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4105                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
4106                         }\r
4107                         if( pLed->bLedLinkBlinkInProgress)\r
4108                         {\r
4109                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4110                                 pLed->bLedLinkBlinkInProgress = _FALSE;\r
4111                         }\r
4112                         if( pLed->bLedBlinkInProgress)\r
4113                         {\r
4114                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4115                                 pLed->bLedBlinkInProgress = _FALSE;\r
4116                         }\r
4117                         if( pLed->bLedWPSBlinkInProgress )\r
4118                         {\r
4119                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4120                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
4121                         }\r
4122                         if( pLed->bLedScanBlinkInProgress)\r
4123                         {\r
4124                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4125                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
4126                         }       \r
4127                         if( pLed->bLedStartToLinkBlinkInProgress)\r
4128                         {\r
4129                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4130                                 pLed->bLedStartToLinkBlinkInProgress = _FALSE;\r
4131                         }                       \r
4132 \r
4133                         if( pLed1->bLedWPSBlinkInProgress )\r
4134                         {\r
4135                                 _cancel_timer_ex(&(pLed1->BlinkTimer));\r
4136                                 pLed1->bLedWPSBlinkInProgress = _FALSE;\r
4137                         }\r
4138 \r
4139 \r
4140                         pLed1->BlinkingLedState = LED_UNKNOWN;                          \r
4141                         SwLedOff(Adapter, pLed);\r
4142                         SwLedOff(Adapter, pLed1);                       \r
4143                         break;\r
4144 \r
4145                 case LED_CTL_CONNECTION_NO_TRANSFER:\r
4146                          if(pLed->bLedBlinkInProgress == _FALSE)\r
4147                          {\r
4148                                   if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
4149                                 {\r
4150                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4151                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
4152                                 }\r
4153                                 pLed->bLedBlinkInProgress = _TRUE;\r
4154 \r
4155                                 pLed->CurrLedState = LED_BLINK_ALWAYS_ON;\r
4156                                 pLed->BlinkingLedState = RTW_LED_ON; \r
4157                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
4158                          }\r
4159                         break;\r
4160         \r
4161                 default:\r
4162                         break;\r
4163 \r
4164         }\r
4165 \r
4166         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 9 Led %d\n", pLed->CurrLedState));\r
4167 }\r
4168 \r
4169 //page added for Netgear A6200V2, 20120827\r
4170 void\r
4171 SwLedControlMode10(\r
4172         PADAPTER                        Adapter,\r
4173         LED_CTL_MODE            LedAction\r
4174 )\r
4175 {\r
4176         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);\r
4177         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
4178         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;\r
4179         PLED_USB        pLed = &(ledpriv->SwLed0);\r
4180         PLED_USB        pLed1 = &(ledpriv->SwLed1);\r
4181 \r
4182         switch(LedAction)\r
4183         {\r
4184                 case LED_CTL_START_TO_LINK:\r
4185                         if(pLed1->bLedBlinkInProgress == _FALSE)\r
4186                         {\r
4187                                 pLed1->bLedBlinkInProgress = _TRUE;\r
4188                                 pLed1->BlinkingLedState = RTW_LED_ON;\r
4189                                 pLed1->CurrLedState = LED_BLINK_LINK_IN_PROCESS;\r
4190 \r
4191                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
4192                         }\r
4193                         break;\r
4194 \r
4195                 case LED_CTL_LINK:                      \r
4196                 case LED_CTL_NO_LINK:\r
4197                         if(LedAction == LED_CTL_LINK)\r
4198                         {\r
4199                                 if(pLed->bLedWPSBlinkInProgress == _TRUE || pLed1->bLedWPSBlinkInProgress == _TRUE)\r
4200                                         ;\r
4201                                 else\r
4202                                 {\r
4203                                         if(pHalData->CurrentBandType == BAND_ON_2_4G)\r
4204                                         //LED0 settings\r
4205                                         {\r
4206                                                 pLed->CurrLedState = RTW_LED_ON;\r
4207                                                 pLed->BlinkingLedState = RTW_LED_ON;\r
4208                                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
4209                                                 {       \r
4210                                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4211                                                         pLed->bLedBlinkInProgress = _FALSE;\r
4212                                                 }\r
4213                                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4214 \r
4215                                                 pLed1->CurrLedState = RTW_LED_OFF;\r
4216                                                 pLed1->BlinkingLedState = RTW_LED_OFF;\r
4217                                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
4218                                         }\r
4219                                         else if(pHalData->CurrentBandType == BAND_ON_5G)\r
4220                                         //LED1 settings\r
4221                                         {\r
4222                                                 pLed1->CurrLedState = RTW_LED_ON;\r
4223                                                 pLed1->BlinkingLedState = RTW_LED_ON;\r
4224                                                 if(pLed1->bLedBlinkInProgress == _TRUE)\r
4225                                                 {       \r
4226                                                         _cancel_timer_ex(&(pLed1->BlinkTimer));\r
4227                                                         pLed1->bLedBlinkInProgress = _FALSE;\r
4228                                                 }\r
4229                                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
4230 \r
4231                                                 pLed->CurrLedState = RTW_LED_OFF;\r
4232                                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
4233                                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4234                                         }\r
4235                                 }\r
4236                         }\r
4237                         else if(LedAction == LED_CTL_NO_LINK)   //TODO by page\r
4238                         {\r
4239                                 if(pLed->bLedWPSBlinkInProgress == _TRUE || pLed1->bLedWPSBlinkInProgress == _TRUE)\r
4240                                         ;\r
4241                                 else\r
4242                                 {\r
4243                                         pLed->CurrLedState = RTW_LED_OFF;\r
4244                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4245                                         if( pLed->bLedOn )\r
4246                                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4247 \r
4248                                         pLed1->CurrLedState = RTW_LED_OFF;\r
4249                                         pLed1->BlinkingLedState = RTW_LED_OFF;\r
4250                                         if( pLed1->bLedOn )\r
4251                                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
4252                                 }\r
4253                         }\r
4254 \r
4255                         break;          \r
4256 \r
4257                 case LED_CTL_SITE_SURVEY:\r
4258                          if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
4259                                 ;                                                                  //don't blink when media connect\r
4260                          else //if(pLed->bLedScanBlinkInProgress ==FALSE)\r
4261                          {\r
4262                                 if(IS_LED_WPS_BLINKING(pLed) || IS_LED_WPS_BLINKING(pLed1))\r
4263                                         return;\r
4264 \r
4265                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
4266                                 {\r
4267                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4268                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
4269                                 }\r
4270                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
4271                                 {\r
4272                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4273                                         pLed->bLedBlinkInProgress = _FALSE;\r
4274                                 }\r
4275                                 pLed->bLedScanBlinkInProgress = _TRUE;\r
4276                                 pLed->CurrLedState = LED_BLINK_SCAN;\r
4277                                 pLed->BlinkTimes = 12;\r
4278                                 pLed->BlinkingLedState = LED_BLINK_SCAN;\r
4279                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4280 \r
4281                                 if(pLed1->bLedNoLinkBlinkInProgress == _TRUE)\r
4282                                 {\r
4283                                         _cancel_timer_ex(&(pLed1->BlinkTimer));\r
4284                                         pLed1->bLedNoLinkBlinkInProgress = _FALSE;\r
4285                                 }\r
4286                                 if(pLed1->bLedBlinkInProgress == _TRUE)\r
4287                                 {\r
4288                                         _cancel_timer_ex(&(pLed1->BlinkTimer));\r
4289                                         pLed1->bLedBlinkInProgress = _FALSE;\r
4290                                 }\r
4291                                 pLed1->bLedScanBlinkInProgress = _TRUE;\r
4292                                 pLed1->CurrLedState = LED_BLINK_SCAN;\r
4293                                 pLed1->BlinkTimes = 12;\r
4294                                 pLed1->BlinkingLedState = LED_BLINK_SCAN;\r
4295                                 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_LINK_SLOWLY_INTERVAL_NETGEAR);\r
4296 \r
4297                         }\r
4298                         break;\r
4299 \r
4300                 case LED_CTL_START_WPS: //wait until xinpin finish\r
4301                 case LED_CTL_START_WPS_BOTTON:\r
4302                         //LED0 settings\r
4303                         if(pLed->bLedBlinkInProgress == _FALSE)\r
4304                         {\r
4305                                 pLed->bLedBlinkInProgress = _TRUE;\r
4306                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
4307                                 pLed->BlinkingLedState = LED_BLINK_WPS;\r
4308                                 pLed->CurrLedState = LED_BLINK_WPS;\r
4309                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4310                         }\r
4311 \r
4312                         //LED1 settings\r
4313                         if(pLed1->bLedBlinkInProgress == _FALSE)\r
4314                         {\r
4315                                 pLed1->bLedBlinkInProgress = _TRUE;\r
4316                                 pLed1->bLedWPSBlinkInProgress = _TRUE;\r
4317                                 pLed1->BlinkingLedState = LED_BLINK_WPS;\r
4318                                 pLed1->CurrLedState = LED_BLINK_WPS;\r
4319                                 _set_timer(&(pLed1->BlinkTimer), LED_BLINK_NORMAL_INTERVAL+LED_BLINK_LINK_INTERVAL_NETGEAR);\r
4320                         }\r
4321 \r
4322 \r
4323                         break;\r
4324 \r
4325                 case LED_CTL_STOP_WPS:  //WPS connect success\r
4326                         if(pHalData->CurrentBandType == BAND_ON_2_4G)\r
4327                         //LED0 settings\r
4328                         {\r
4329                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
4330                                 pLed->CurrLedState = RTW_LED_ON;\r
4331                                 pLed->BlinkingLedState = RTW_LED_ON;\r
4332                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
4333                                 {\r
4334                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4335                                         pLed->bLedBlinkInProgress = _FALSE;\r
4336                                 }\r
4337                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4338 \r
4339                                 pLed1->CurrLedState = RTW_LED_OFF;\r
4340                                 pLed1->BlinkingLedState = RTW_LED_OFF;\r
4341                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
4342                         }\r
4343                         else if(pHalData->CurrentBandType == BAND_ON_5G)\r
4344                         //LED1 settings\r
4345                         {\r
4346                                 pLed1->bLedWPSBlinkInProgress = _FALSE;\r
4347                                 pLed1->CurrLedState = RTW_LED_ON;\r
4348                                 pLed1->BlinkingLedState = RTW_LED_ON;\r
4349                                 if(pLed1->bLedBlinkInProgress == _TRUE)\r
4350                                 {\r
4351                                         _cancel_timer_ex(&(pLed1->BlinkTimer));\r
4352                                         pLed1->bLedBlinkInProgress = _FALSE;\r
4353                                 }\r
4354                                 _set_timer(&(pLed1->BlinkTimer), 0);\r
4355 \r
4356                                 pLed->CurrLedState = RTW_LED_OFF;\r
4357                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
4358                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4359                         }\r
4360 \r
4361                         break;\r
4362 \r
4363                 case LED_CTL_STOP_WPS_FAIL:             //WPS authentication fail       \r
4364                         //LED1 settings\r
4365                         pLed1->bLedWPSBlinkInProgress = _FALSE;\r
4366                         pLed1->CurrLedState = RTW_LED_OFF;\r
4367                         pLed1->BlinkingLedState = RTW_LED_OFF; \r
4368                         _set_timer(&(pLed1->BlinkTimer), 0);\r
4369 \r
4370                         //LED0 settings\r
4371                         pLed->bLedWPSBlinkInProgress = _FALSE;\r
4372                         pLed->CurrLedState = RTW_LED_OFF;\r
4373                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4374                         if( pLed->bLedOn )\r
4375                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4376 \r
4377                         break;\r
4378 \r
4379 \r
4380                 default:\r
4381                         break;\r
4382 \r
4383         }\r
4384 \r
4385         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 10 Led %d\n", pLed->CurrLedState));\r
4386 }\r
4387 \r
4388  //Edimax-ASUS, added by Page, 20121221\r
4389 void\r
4390 SwLedControlMode11(\r
4391         PADAPTER                        Adapter,\r
4392         LED_CTL_MODE            LedAction\r
4393 )\r
4394 {\r
4395         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
4396         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;\r
4397         PLED_USB        pLed = &(ledpriv->SwLed0);\r
4398 \r
4399         switch(LedAction)\r
4400         {       \r
4401                 case LED_CTL_POWER_ON:\r
4402                 case LED_CTL_START_TO_LINK:     \r
4403                 case LED_CTL_NO_LINK:\r
4404                         pLed->CurrLedState = RTW_LED_ON;\r
4405                         pLed->BlinkingLedState = RTW_LED_ON;\r
4406                         _set_timer(&(pLed->BlinkTimer), 0);\r
4407                         break;\r
4408 \r
4409                 case LED_CTL_LINK:\r
4410                         if( pLed->bLedBlinkInProgress == _TRUE )\r
4411                         {\r
4412                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4413                                 pLed->bLedBlinkInProgress = _FALSE;\r
4414                         }\r
4415                         pLed->bLedBlinkInProgress = _TRUE;\r
4416                         pLed->CurrLedState = LED_BLINK_TXRX;\r
4417                         if( pLed->bLedOn )\r
4418                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
4419                         else\r
4420                                 pLed->BlinkingLedState = RTW_LED_ON;\r
4421                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_SCAN_INTERVAL_ALPHA);\r
4422                         break;\r
4423 \r
4424                 case LED_CTL_START_WPS: //wait until xinpin finish\r
4425                 case LED_CTL_START_WPS_BOTTON:\r
4426                         if(pLed->bLedBlinkInProgress == _TRUE)\r
4427                         {\r
4428                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4429                                 pLed->bLedBlinkInProgress = _FALSE;\r
4430                         }\r
4431                         pLed->bLedWPSBlinkInProgress = _TRUE;\r
4432                         pLed->bLedBlinkInProgress = _TRUE;\r
4433                         pLed->CurrLedState = LED_BLINK_WPS;\r
4434                         if( pLed->bLedOn )\r
4435                                 pLed->BlinkingLedState = RTW_LED_OFF;\r
4436                         else\r
4437                                 pLed->BlinkingLedState = RTW_LED_ON;\r
4438                         pLed->BlinkTimes = 5;\r
4439                         _set_timer(&(pLed->BlinkTimer), 0);\r
4440 \r
4441                         break;\r
4442 \r
4443 \r
4444                 case LED_CTL_STOP_WPS:\r
4445                 case LED_CTL_STOP_WPS_FAIL:\r
4446                         if(pLed->bLedBlinkInProgress == _TRUE)\r
4447                         {\r
4448                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4449                                 pLed->bLedBlinkInProgress = _FALSE;\r
4450                         }\r
4451                         pLed->CurrLedState = LED_BLINK_WPS_STOP;\r
4452                         _set_timer(&(pLed->BlinkTimer), 0);\r
4453                         break;\r
4454 \r
4455                 case LED_CTL_POWER_OFF:\r
4456                         pLed->CurrLedState = RTW_LED_OFF;\r
4457                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4458 \r
4459                         if( pLed->bLedNoLinkBlinkInProgress)\r
4460                         {\r
4461                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4462                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
4463                         }\r
4464                         if( pLed->bLedLinkBlinkInProgress)\r
4465                         {\r
4466                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4467                                 pLed->bLedLinkBlinkInProgress = _FALSE;\r
4468                         }\r
4469                         if( pLed->bLedBlinkInProgress)\r
4470                         {\r
4471                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4472                                 pLed->bLedBlinkInProgress = _FALSE;\r
4473                         }\r
4474                         if( pLed->bLedWPSBlinkInProgress )\r
4475                         {\r
4476                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4477                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
4478                         }\r
4479                         if( pLed->bLedScanBlinkInProgress)\r
4480                         {\r
4481                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4482                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
4483                         }\r
4484 \r
4485                         SwLedOff(Adapter, pLed);\r
4486                         break;\r
4487 \r
4488                 default:\r
4489                         break;\r
4490 \r
4491         }\r
4492 \r
4493         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led mode 1 CurrLedState %d\n", pLed->CurrLedState));\r
4494 }\r
4495 \r
4496 // page added for NEC\r
4497 \r
4498 VOID\r
4499 SwLedControlMode12(\r
4500         PADAPTER                        Adapter,\r
4501         LED_CTL_MODE            LedAction\r
4502 )\r
4503 {\r
4504         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
4505         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;\r
4506         PLED_USB        pLed = &(ledpriv->SwLed0);\r
4507 \r
4508         switch(LedAction)\r
4509         {\r
4510                 case LED_CTL_POWER_ON:\r
4511                 case LED_CTL_NO_LINK:\r
4512                 case LED_CTL_LINK:\r
4513                 case LED_CTL_SITE_SURVEY:\r
4514 \r
4515                         if( pLed->bLedNoLinkBlinkInProgress == _FALSE )\r
4516                         {\r
4517                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
4518                                 {\r
4519                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4520                                         pLed->bLedBlinkInProgress = _FALSE;\r
4521                                 }\r
4522 \r
4523                                 pLed->bLedNoLinkBlinkInProgress = _TRUE;\r
4524                                 pLed->CurrLedState = LED_BLINK_SLOWLY;\r
4525                                 if( pLed->bLedOn )\r
4526                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4527                                 else\r
4528                                         pLed->BlinkingLedState = RTW_LED_ON;\r
4529                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NO_LINK_INTERVAL_ALPHA);\r
4530                         }\r
4531                         break;\r
4532 \r
4533                 case LED_CTL_TX:\r
4534                 case LED_CTL_RX:\r
4535                         if(pLed->bLedBlinkInProgress == _FALSE)\r
4536                         {\r
4537                                 if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
4538                                 {\r
4539                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4540                                         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
4541                                 }\r
4542                                 pLed->bLedBlinkInProgress = _TRUE;\r
4543                                 pLed->CurrLedState = LED_BLINK_TXRX;\r
4544                                 pLed->BlinkTimes = 2;\r
4545                                 if( pLed->bLedOn )\r
4546                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4547                                 else\r
4548                                         pLed->BlinkingLedState = RTW_LED_ON;\r
4549                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
4550                         }\r
4551                         break;\r
4552 \r
4553                 case LED_CTL_POWER_OFF:\r
4554                         pLed->CurrLedState = RTW_LED_OFF;\r
4555                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4556 \r
4557                         if( pLed->bLedBlinkInProgress)\r
4558                         {\r
4559                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4560                                 pLed->bLedBlinkInProgress = _FALSE;\r
4561                         }\r
4562 \r
4563                         if( pLed->bLedScanBlinkInProgress)\r
4564                         {\r
4565                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4566                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
4567                         }\r
4568 \r
4569                         if(pLed->bLedNoLinkBlinkInProgress == _TRUE)\r
4570                         {\r
4571                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4572                                 pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
4573                         }\r
4574 \r
4575                         SwLedOff(Adapter, pLed);\r
4576                         break;\r
4577 \r
4578                 default:\r
4579                         break;\r
4580 \r
4581         }\r
4582 \r
4583         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("SWLed12 %d\n", pLed->CurrLedState));\r
4584 }\r
4585 \r
4586 // Maddest add for NETGEAR R6100\r
4587 \r
4588 VOID\r
4589 SwLedControlMode13(\r
4590         IN      PADAPTER                        Adapter,\r
4591         IN      LED_CTL_MODE            LedAction\r
4592 )\r
4593 {\r
4594         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
4595         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;\r
4596         PLED_USB        pLed = &(ledpriv->SwLed0);\r
4597 \r
4598         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 13 CurrLedState %d, LedAction %d\n", pLed->CurrLedState,LedAction));\r
4599         switch(LedAction)\r
4600         {               \r
4601                 case LED_CTL_LINK:\r
4602                         if(pLed->bLedWPSBlinkInProgress)\r
4603                         {\r
4604                                 return; \r
4605                         }\r
4606 \r
4607                         \r
4608                         pLed->CurrLedState = RTW_LED_ON;\r
4609                         pLed->BlinkingLedState = RTW_LED_ON;\r
4610                         if( pLed->bLedBlinkInProgress)\r
4611                         {\r
4612                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4613                                 pLed->bLedBlinkInProgress = _FALSE;\r
4614                         }\r
4615                         if( pLed->bLedScanBlinkInProgress)\r
4616                         {\r
4617                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4618                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
4619                         }                       \r
4620 \r
4621                         _set_timer(&(pLed->BlinkTimer), 0);\r
4622                         break;                  \r
4623 \r
4624                 case LED_CTL_START_WPS: //wait until xinpin finish\r
4625                 case LED_CTL_START_WPS_BOTTON:  \r
4626                         if(pLed->bLedWPSBlinkInProgress == _FALSE)\r
4627                         {\r
4628                                 if(pLed->bLedBlinkInProgress == _TRUE)\r
4629                                 {\r
4630                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4631                                         pLed->bLedBlinkInProgress = _FALSE;\r
4632                                 }\r
4633                                 if(pLed->bLedScanBlinkInProgress == _TRUE)\r
4634                                 {\r
4635                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4636                                         pLed->bLedScanBlinkInProgress = _FALSE;\r
4637                                 }                               \r
4638                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
4639                                 pLed->CurrLedState = LED_BLINK_WPS;\r
4640                                 if( pLed->bLedOn )\r
4641                                 {\r
4642                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4643                                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);\r
4644                                 }\r
4645                                 else\r
4646                                 {\r
4647                                         pLed->BlinkingLedState = RTW_LED_ON; \r
4648                                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);\r
4649                                 }\r
4650                         }       \r
4651                         break;\r
4652                         \r
4653                 case LED_CTL_STOP_WPS:  \r
4654                         if(pLed->bLedWPSBlinkInProgress)\r
4655                         {\r
4656                                 _cancel_timer_ex(&(pLed->BlinkTimer));                                                  \r
4657                                 pLed->bLedWPSBlinkInProgress = _FALSE;                          \r
4658                         }                                               \r
4659                         else\r
4660                         {\r
4661                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
4662                         }\r
4663                         \r
4664                         pLed->bLedWPSBlinkInProgress = _FALSE;          \r
4665                         pLed->CurrLedState = LED_BLINK_WPS_STOP;\r
4666                         if(pLed->bLedOn)\r
4667                         {\r
4668                                 pLed->BlinkingLedState = RTW_LED_OFF;                   \r
4669                                         \r
4670                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4671                         }                                       \r
4672 \r
4673                         break;          \r
4674 \r
4675                         \r
4676                 case LED_CTL_STOP_WPS_FAIL:             \r
4677                 case LED_CTL_STOP_WPS_FAIL_OVERLAP: //WPS session overlap\r
4678                         if(pLed->bLedWPSBlinkInProgress)\r
4679                         {\r
4680                                 _cancel_timer_ex(&(pLed->BlinkTimer));                                                  \r
4681                                 pLed->bLedWPSBlinkInProgress = _FALSE;                          \r
4682                         }                       \r
4683 \r
4684                         pLed->CurrLedState = RTW_LED_OFF;\r
4685                         pLed->BlinkingLedState = RTW_LED_OFF;                           \r
4686                         _set_timer(&(pLed->BlinkTimer), 0);     \r
4687                         break;                          \r
4688 \r
4689                 case LED_CTL_START_TO_LINK:     \r
4690                         if((pLed->bLedBlinkInProgress == _FALSE) && (pLed->bLedWPSBlinkInProgress == _FALSE)) \r
4691                         {\r
4692                                 pLed->bLedBlinkInProgress = _TRUE;\r
4693                                 pLed->BlinkingLedState = RTW_LED_ON;\r
4694                                 pLed->CurrLedState = LED_BLINK_LINK_IN_PROCESS;\r
4695 \r
4696                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4697                         }\r
4698                         break;  \r
4699 \r
4700                 case LED_CTL_NO_LINK:\r
4701 \r
4702                         if(pLed->bLedWPSBlinkInProgress)\r
4703                         {\r
4704                                 return; \r
4705                         }\r
4706                         if( pLed->bLedBlinkInProgress)\r
4707                         {\r
4708                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4709                                 pLed->bLedBlinkInProgress = _FALSE;\r
4710                         }\r
4711                         if( pLed->bLedScanBlinkInProgress)\r
4712                         {\r
4713                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4714                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
4715                         }                       \r
4716                         //if(!IS_LED_BLINKING(pLed))\r
4717                         {\r
4718                                 pLed->CurrLedState = RTW_LED_OFF;\r
4719                                 pLed->BlinkingLedState = RTW_LED_OFF;                           \r
4720                                 _set_timer(&(pLed->BlinkTimer), 0);                             \r
4721                         }\r
4722                         break;\r
4723                         \r
4724                 case LED_CTL_POWER_OFF:\r
4725                 case LED_CTL_POWER_ON:\r
4726                         pLed->CurrLedState = RTW_LED_OFF;\r
4727                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4728                         if( pLed->bLedBlinkInProgress)\r
4729                         {\r
4730                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4731                                 pLed->bLedBlinkInProgress = _FALSE;\r
4732                         }\r
4733                         if( pLed->bLedScanBlinkInProgress)\r
4734                         {\r
4735                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4736                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
4737                         }                       \r
4738                         if( pLed->bLedWPSBlinkInProgress )\r
4739                         {\r
4740                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4741                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
4742                         }\r
4743 \r
4744                         if (LedAction == LED_CTL_POWER_ON)\r
4745                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4746                         else\r
4747                                 SwLedOff(Adapter, pLed);\r
4748                         break;\r
4749                         \r
4750                 default:\r
4751                         break;\r
4752 \r
4753         }\r
4754 \r
4755         \r
4756 }\r
4757 \r
4758 // Maddest add for DNI Buffalo\r
4759 \r
4760 VOID\r
4761 SwLedControlMode14(\r
4762         IN      PADAPTER                        Adapter,\r
4763         IN      LED_CTL_MODE            LedAction\r
4764 )\r
4765 {\r
4766         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
4767         PLED_USB        pLed = &(ledpriv->SwLed0);\r
4768 \r
4769         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 14 CurrLedState %d, LedAction %d\n", pLed->CurrLedState,LedAction));\r
4770         switch(LedAction)\r
4771         {                               \r
4772                 case LED_CTL_POWER_OFF:\r
4773                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 14 LED_CTL_POWER_OFF\n"));\r
4774                         pLed->CurrLedState = RTW_LED_OFF;\r
4775                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4776                         if( pLed->bLedBlinkInProgress)\r
4777                         {\r
4778                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4779                                 pLed->bLedBlinkInProgress = _FALSE;\r
4780                         }                       \r
4781                         SwLedOff(Adapter, pLed);        \r
4782                         break;\r
4783 \r
4784                 case LED_CTL_POWER_ON:\r
4785                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 14 LED_CTL_POWER_ON\n"));\r
4786                         SwLedOn(Adapter, pLed);\r
4787                         break;\r
4788 \r
4789                 case LED_CTL_LINK:\r
4790                 case LED_CTL_NO_LINK:\r
4791                         if (IS_HARDWARE_TYPE_8812AU(Adapter))\r
4792                                 SwLedOn(Adapter, pLed);\r
4793                         break;\r
4794 \r
4795                 case LED_CTL_TX:\r
4796                 case LED_CTL_RX:\r
4797                         if(pLed->bLedBlinkInProgress ==_FALSE)\r
4798                         {\r
4799                                 pLed->bLedBlinkInProgress = _TRUE;\r
4800                                 pLed->CurrLedState = LED_BLINK_TXRX;\r
4801                                 pLed->BlinkTimes = 2;\r
4802                                 if( pLed->bLedOn )\r
4803                                 {\r
4804                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4805                                         if (IS_HARDWARE_TYPE_8812AU(Adapter))\r
4806                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_LINK_INTERVAL_ALPHA);\r
4807                                         else\r
4808                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
4809                                 }\r
4810                                 else\r
4811                                 {\r
4812                                         pLed->BlinkingLedState = RTW_LED_ON;\r
4813                                         if (IS_HARDWARE_TYPE_8812AU(Adapter))\r
4814                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);\r
4815                                         else\r
4816                                                 _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
4817                                 }\r
4818                         }\r
4819                         break;\r
4820 \r
4821                 default:\r
4822                         break;\r
4823         }\r
4824 }\r
4825 \r
4826 // Maddest add for Dlink\r
4827 \r
4828 VOID\r
4829 SwLedControlMode15(\r
4830         IN      PADAPTER                        Adapter,\r
4831         IN      LED_CTL_MODE            LedAction\r
4832 )\r
4833 {\r
4834         struct led_priv *ledpriv = &(Adapter->ledpriv);\r
4835         struct mlme_priv        *pmlmepriv = &Adapter->mlmepriv;\r
4836         PLED_USB        pLed = &(ledpriv->SwLed0);\r
4837 \r
4838         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 CurrLedState %d, LedAction %d\n", pLed->CurrLedState,LedAction));\r
4839         switch(LedAction)\r
4840         {               \r
4841                 case LED_CTL_START_WPS: //wait until xinpin finish\r
4842                 case LED_CTL_START_WPS_BOTTON:  \r
4843                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_START_WPS\n"));\r
4844                         if(pLed->bLedWPSBlinkInProgress ==_FALSE)\r
4845                         {\r
4846                                 if(pLed->bLedBlinkInProgress ==_TRUE)\r
4847                                 {\r
4848                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4849                                         pLed->bLedBlinkInProgress = _FALSE;\r
4850                                 }\r
4851                                 if(pLed->bLedScanBlinkInProgress ==_TRUE)\r
4852                                 {\r
4853                                         _cancel_timer_ex(&(pLed->BlinkTimer));\r
4854                                         pLed->bLedScanBlinkInProgress = _FALSE;\r
4855                                 }                               \r
4856                                 pLed->bLedWPSBlinkInProgress = _TRUE;\r
4857                                 pLed->CurrLedState = LED_BLINK_WPS;\r
4858                                 if( pLed->bLedOn )\r
4859                                 {\r
4860                                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4861                                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_OFF_INTERVAL_NETGEAR);\r
4862                                 }\r
4863                                 else\r
4864                                 {\r
4865                                         pLed->BlinkingLedState = RTW_LED_ON; \r
4866                                         _set_timer(&(pLed->BlinkTimer), LED_WPS_BLINK_ON_INTERVAL_NETGEAR);\r
4867                                 }\r
4868                         }       \r
4869                         break;\r
4870                         \r
4871                 case LED_CTL_STOP_WPS:  \r
4872                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_STOP_WPS\n"));\r
4873                         if(pLed->bLedWPSBlinkInProgress)\r
4874                         {\r
4875                                 _cancel_timer_ex(&(pLed->BlinkTimer));                                                                          \r
4876                         }                                               \r
4877                         \r
4878                         pLed->CurrLedState = LED_BLINK_WPS_STOP;\r
4879                         //if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
4880                         {\r
4881                                 pLed->BlinkingLedState = RTW_LED_ON;                    \r
4882                                         \r
4883                                 _set_timer(&(pLed->BlinkTimer), 0);\r
4884                         }                                       \r
4885 \r
4886                         break;\r
4887 \r
4888                 case LED_CTL_STOP_WPS_FAIL:             \r
4889                 case LED_CTL_STOP_WPS_FAIL_OVERLAP: //WPS session overlap\r
4890                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_STOP_WPS_FAIL\n"));\r
4891                         if(pLed->bLedWPSBlinkInProgress)\r
4892                         {\r
4893                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4894                                 pLed->bLedWPSBlinkInProgress = _FALSE;\r
4895                         }                       \r
4896 \r
4897                         pLed->CurrLedState = RTW_LED_OFF;\r
4898                         pLed->BlinkingLedState = RTW_LED_OFF;\r
4899                         _set_timer(&(pLed->BlinkTimer), 0);\r
4900                         break;\r
4901 \r
4902                 case LED_CTL_NO_LINK:\r
4903                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_NO_LINK\n"));\r
4904                         if(pLed->bLedWPSBlinkInProgress)\r
4905                         {\r
4906                                 return; \r
4907                         }\r
4908 \r
4909                         /*if(Adapter->securitypriv.dot11PrivacyAlgrthm > _NO_PRIVACY_)\r
4910                         {\r
4911                                 if(SecIsTxKeyInstalled(Adapter, pMgntInfo->Bssid))\r
4912                                 {\r
4913                                 }\r
4914                                 else\r
4915                                 {\r
4916                                         if(pMgntInfo->LEDAssocState ==LED_ASSOC_SECURITY_BEGIN)\r
4917                                                 return; \r
4918                                 }\r
4919                         }*/\r
4920 \r
4921                         if( pLed->bLedBlinkInProgress)\r
4922                         {\r
4923                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4924                                 pLed->bLedBlinkInProgress = _FALSE;\r
4925                         }\r
4926                         if( pLed->bLedScanBlinkInProgress)\r
4927                         {\r
4928                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4929                                 pLed->bLedScanBlinkInProgress = _FALSE;\r
4930                         }                       \r
4931                         //if(!IS_LED_BLINKING(pLed))\r
4932                         {\r
4933                                 pLed->CurrLedState = LED_BLINK_NO_LINK;\r
4934                                 pLed->BlinkingLedState = RTW_LED_ON;\r
4935                                 _set_timer(&(pLed->BlinkTimer), 30);\r
4936                         }\r
4937                         break;\r
4938 \r
4939                 case LED_CTL_LINK: \r
4940                         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("Led control mode 15 LED_CTL_LINK\n"));\r
4941 \r
4942                         if(pLed->bLedWPSBlinkInProgress)\r
4943                         {\r
4944                                 return; \r
4945                         }\r
4946 \r
4947                         if( pLed->bLedBlinkInProgress)\r
4948                         {\r
4949                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4950                                 pLed->bLedBlinkInProgress = _FALSE;\r
4951                         }\r
4952 \r
4953                         pLed->CurrLedState = LED_BLINK_LINK_IDEL;\r
4954                         pLed->BlinkingLedState = RTW_LED_ON;\r
4955 \r
4956                         _set_timer(&(pLed->BlinkTimer), 30);\r
4957                         break;  \r
4958 \r
4959                 case LED_CTL_SITE_SURVEY        :\r
4960                         if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)\r
4961                                 return;\r
4962 \r
4963                         if(pLed->bLedWPSBlinkInProgress ==_TRUE)\r
4964                                 return;\r
4965                         \r
4966                         if( pLed->bLedBlinkInProgress)\r
4967                         {\r
4968                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4969                                 pLed->bLedBlinkInProgress = _FALSE;\r
4970                         }\r
4971                         pLed->CurrLedState = LED_BLINK_SCAN;\r
4972                         pLed->BlinkingLedState = RTW_LED_ON;                            \r
4973                         _set_timer(&(pLed->BlinkTimer), 0);     \r
4974                         break;\r
4975 \r
4976                 case LED_CTL_TX:\r
4977                 case LED_CTL_RX:\r
4978                         if(pLed->bLedWPSBlinkInProgress)\r
4979                         {\r
4980                                 return; \r
4981                         }\r
4982 \r
4983                         if( pLed->bLedBlinkInProgress)\r
4984                         {\r
4985                                 _cancel_timer_ex(&(pLed->BlinkTimer));\r
4986                                 pLed->bLedBlinkInProgress = _FALSE;\r
4987                         }                       \r
4988 \r
4989                         pLed->bLedBlinkInProgress = _TRUE;\r
4990                         pLed->CurrLedState = LED_BLINK_TXRX;\r
4991                         pLed->BlinkTimes = 2;\r
4992                         if( pLed->bLedOn )\r
4993                                 pLed->BlinkingLedState = RTW_LED_OFF; \r
4994                         else\r
4995                                 pLed->BlinkingLedState = RTW_LED_ON; \r
4996                         _set_timer(&(pLed->BlinkTimer), LED_BLINK_FASTER_INTERVAL_ALPHA);\r
4997                         break;                  \r
4998 \r
4999                 default:\r
5000                         break;\r
5001         }\r
5002 }\r
5003 \r
5004 void\r
5005 LedControlUSB(\r
5006         _adapter                                *padapter,\r
5007         LED_CTL_MODE            LedAction\r
5008         )\r
5009 {\r
5010         struct led_priv *ledpriv = &(padapter->ledpriv);\r
5011 \r
5012 #if(MP_DRIVER == 1)\r
5013         if (padapter->registrypriv.mp_mode == 1)\r
5014                 return;\r
5015 #endif\r
5016 \r
5017        if( (padapter->bSurpriseRemoved == _TRUE) ||(padapter->hw_init_completed == _FALSE) )\r
5018        {\r
5019              return;\r
5020        }\r
5021 \r
5022         if( ledpriv->bRegUseLed == _FALSE)\r
5023                 return;\r
5024 \r
5025         //if(priv->bInHctTest)\r
5026         //      return;\r
5027 \r
5028 #ifdef CONFIG_CONCURRENT_MODE\r
5029         // Only do led action for PRIMARY_ADAPTER\r
5030         if (padapter->adapter_type != PRIMARY_ADAPTER)\r
5031                 return;\r
5032 #endif\r
5033 \r
5034         if( (adapter_to_pwrctl(padapter)->rf_pwrstate != rf_on &&\r
5035                 adapter_to_pwrctl(padapter)->rfoff_reason > RF_CHANGE_BY_PS) &&\r
5036                 (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||\r
5037                  LedAction == LED_CTL_SITE_SURVEY ||\r
5038                  LedAction == LED_CTL_LINK ||\r
5039                  LedAction == LED_CTL_NO_LINK ||\r
5040                  LedAction == LED_CTL_POWER_ON) )\r
5041         {\r
5042                 return;\r
5043         }\r
5044 \r
5045         switch(ledpriv->LedStrategy)\r
5046         {\r
5047                 case SW_LED_MODE0:\r
5048                         SwLedControlMode0(padapter, LedAction);\r
5049                         break;\r
5050 \r
5051                 case SW_LED_MODE1:\r
5052                         SwLedControlMode1(padapter, LedAction);\r
5053                         break;\r
5054 \r
5055                 case SW_LED_MODE2:\r
5056                         SwLedControlMode2(padapter, LedAction);\r
5057                         break;\r
5058 \r
5059                 case SW_LED_MODE3:\r
5060                         SwLedControlMode3(padapter, LedAction);\r
5061                         break;\r
5062 \r
5063                 case SW_LED_MODE4:\r
5064                         SwLedControlMode4(padapter, LedAction);\r
5065                         break;\r
5066 \r
5067                 case SW_LED_MODE5:\r
5068                         SwLedControlMode5(padapter, LedAction);\r
5069                         break;\r
5070 \r
5071                 case SW_LED_MODE6:\r
5072                         SwLedControlMode6(padapter, LedAction);\r
5073                         break;\r
5074 \r
5075                 case SW_LED_MODE7:\r
5076                         SwLedControlMode7(padapter, LedAction);\r
5077                         break;\r
5078 \r
5079                 case SW_LED_MODE8:\r
5080                         SwLedControlMode8(padapter, LedAction);\r
5081                         break;\r
5082 \r
5083                 case SW_LED_MODE9:\r
5084                         SwLedControlMode9(padapter, LedAction);\r
5085                         break;\r
5086 \r
5087                 case SW_LED_MODE10:\r
5088                         SwLedControlMode10(padapter, LedAction);\r
5089                         break;\r
5090 \r
5091                 case SW_LED_MODE11:\r
5092                         SwLedControlMode11(padapter, LedAction);\r
5093                         break;\r
5094 \r
5095                 case SW_LED_MODE12:\r
5096                         SwLedControlMode12(padapter, LedAction);\r
5097                         break;\r
5098 \r
5099                 case SW_LED_MODE13:\r
5100                         SwLedControlMode13(padapter, LedAction);\r
5101                         break;\r
5102 \r
5103                 case SW_LED_MODE14:\r
5104                         SwLedControlMode14(padapter, LedAction);\r
5105                         break;\r
5106 \r
5107                 case SW_LED_MODE15:\r
5108                         SwLedControlMode15(padapter, LedAction);\r
5109                         break;\r
5110 \r
5111                 default:\r
5112                         break;\r
5113         }\r
5114 \r
5115         RT_TRACE(_module_rtl8712_led_c_,_drv_info_,("LedStrategy:%d, LedAction %d\n", ledpriv->LedStrategy,LedAction));\r
5116 }\r
5117 \r
5118 //\r
5119 //      Description:\r
5120 //              Reset status of LED_871x object.\r
5121 //\r
5122 void ResetLedStatus(PLED_USB pLed) {\r
5123 \r
5124         pLed->CurrLedState = RTW_LED_OFF; // Current LED state.\r
5125         pLed->bLedOn = _FALSE; // true if LED is ON, false if LED is OFF.\r
5126 \r
5127         pLed->bLedBlinkInProgress = _FALSE; // true if it is blinking, false o.w..\r
5128         pLed->bLedWPSBlinkInProgress = _FALSE;\r
5129         \r
5130         pLed->BlinkTimes = 0; // Number of times to toggle led state for blinking.\r
5131         pLed->BlinkCounter = 0;\r
5132         pLed->BlinkingLedState = LED_UNKNOWN; // Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are.\r
5133 \r
5134         pLed->bLedNoLinkBlinkInProgress = _FALSE;\r
5135         pLed->bLedLinkBlinkInProgress = _FALSE;\r
5136         pLed->bLedStartToLinkBlinkInProgress = _FALSE;\r
5137         pLed->bLedScanBlinkInProgress = _FALSE;\r
5138 }\r
5139 \r
5140  //\r
5141 //      Description:\r
5142 //              Initialize an LED_871x object.\r
5143 //\r
5144 void\r
5145 InitLed(\r
5146         _adapter                        *padapter,\r
5147         PLED_USB                pLed,\r
5148         LED_PIN                 LedPin\r
5149         )\r
5150 {\r
5151         pLed->padapter = padapter;\r
5152         pLed->LedPin = LedPin;\r
5153 \r
5154         ResetLedStatus(pLed);\r
5155         ATOMIC_SET(&pLed->bCancelWorkItem, _FALSE);\r
5156         _init_timer(&(pLed->BlinkTimer), padapter->pnetdev, BlinkTimerCallback, pLed);\r
5157         _init_workitem(&(pLed->BlinkWorkItem), BlinkWorkItemCallback, pLed);\r
5158 }\r
5159 \r
5160 \r
5161 //\r
5162 //      Description:\r
5163 //              DeInitialize an LED_871x object.\r
5164 //\r
5165 void\r
5166 DeInitLed(\r
5167         PLED_USB                pLed\r
5168         )\r
5169 {\r
5170         ATOMIC_SET(&pLed->bCancelWorkItem, _TRUE);\r
5171         _cancel_workitem_sync(&(pLed->BlinkWorkItem));\r
5172         _cancel_timer_ex(&(pLed->BlinkTimer));\r
5173         ResetLedStatus(pLed);\r
5174 }\r
5175 \r
5176 \r