drivers/staging/rtl8192su/r8192SU_led.c

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