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