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 36static void BlinkTimerCallback (unsigned long data); 37 38static void BlinkWorkItemCallback (struct work_struct *work); 39 40void 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 63void DeInitLed819xUsb (PLED_819xUsb pLed) 64{ 65 del_timer_sync(&(pLed->BlinkTimer)); 66 pLed->bLedBlinkInProgress = FALSE; 67} 68 69void 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 89void 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 112void 113InitSwLeds( 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 125void 126DeInitSwLeds( 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 137void 138SwLedBlink( 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 250void 251SwLedBlink1( 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 475void 476SwLedBlink2( 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 597void 598SwLedBlink3( 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 767void 768SwLedBlink4( 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 964void 965SwLedBlink5( 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 1082void 1083BlinkTimerCallback( 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 1094void 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 1135void 1136SwLedControlMode0( 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 1248void 1249SwLedControlMode1( 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 1515void 1516SwLedControlMode2( 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 1859void 1860SwLedControlMode4( 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 2190void 2191SwLedControlMode5( 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 2280void 2281LedControl8192SUsb( 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